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

Go to the source code of this file.

## Data Structures

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

## Macros

#define | SDL_MUSTLOCK(S) (((S)->flags & SDL_RLEACCEL) != 0)
#define | SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
#define | SDL_SaveBMP(surface, file) SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
#define | SDL_BlitSurface SDL_UpperBlit
#define | SDL_BlitScaled SDL_UpperBlitScaled
Surface flags
These are the currently supported flags for the SDL_Surface. Used internally (read-only).
#define | SDL_SWSURFACE 0
#define | SDL_PREALLOC 0x00000001
#define | SDL_RLEACCEL 0x00000002
#define | SDL_DONTFREE 0x00000004

## Typedefs

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

## Functions

SDL_Surface * | SDL_CreateRGBSurface (Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
SDL_Surface * | SDL_CreateRGBSurfaceFrom (void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
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_Surface * | SDL_LoadBMP_RW (SDL_RWops *src, int freesrc)
int | SDL_SaveBMP_RW (SDL_Surface *surface, SDL_RWops *dst, int freedst)
int | SDL_SetSurfaceRLE (SDL_Surface *surface, int flag)
| Sets the RLE acceleration hint for a surface. More...
int | SDL_SetColorKey (SDL_Surface *surface, int flag, Uint32 key)
| Sets the color key (transparent pixel) in a blittable surface. More...
int | SDL_GetColorKey (SDL_Surface *surface, Uint32 *key)
| Gets the color key (transparent pixel) in a blittable surface. More...
int | SDL_SetSurfaceColorMod (SDL_Surface *surface, Uint8 r, Uint8 g, Uint8 b)
| Set an additional color value used in blit operations. More...
int | SDL_GetSurfaceColorMod (SDL_Surface *surface, Uint8 *r, Uint8 *g, Uint8 *b)
| Get the additional color value used in blit operations. More...
int | SDL_SetSurfaceAlphaMod (SDL_Surface *surface, Uint8 alpha)
| Set an additional alpha value used in blit operations. More...
int | SDL_GetSurfaceAlphaMod (SDL_Surface *surface, Uint8 *alpha)
| Get the additional alpha value used in blit operations. More...
int | SDL_SetSurfaceBlendMode (SDL_Surface *surface, SDL_BlendMode blendMode)
| Set the blend mode used for blit operations. More...
int | SDL_GetSurfaceBlendMode (SDL_Surface *surface, SDL_BlendMode *blendMode)
| Get the blend mode used for blit operations. More...
SDL_bool | SDL_SetClipRect (SDL_Surface *surface, const SDL_Rect *rect)
void | SDL_GetClipRect (SDL_Surface *surface, SDL_Rect *rect)
SDL_Surface * | SDL_ConvertSurface (SDL_Surface *src, const SDL_PixelFormat *fmt, Uint32 flags)
SDL_Surface * | SDL_ConvertSurfaceFormat (SDL_Surface *src, Uint32 pixel_format, Uint32 flags)
int | SDL_ConvertPixels (int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
| Copy a block of pixels of one format to another format. More...
int | SDL_FillRect (SDL_Surface *dst, const SDL_Rect *rect, Uint32 color)
int | SDL_FillRects (SDL_Surface *dst, const SDL_Rect *rects, int count, Uint32 color)
int | SDL_UpperBlit (SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
int | SDL_LowerBlit (SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
int | SDL_SoftStretch (SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, const SDL_Rect *dstrect)
| Perform a fast, low quality, stretch blit between two surfaces of the same pixel format. More...
int | SDL_UpperBlitScaled (SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
int | SDL_LowerBlitScaled (SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)

## Detailed Description

Header file for SDL_Surface definition and management functions.

Definition in file SDL_surface.h.

## Macro Definition Documentation

#define SDL_BlitScaled SDL_UpperBlitScaled

Definition at line 476 of file SDL_surface.h.

Referenced by SW_RenderCopy(), and SW_RenderCopyEx().

#define SDL_BlitSurface SDL_UpperBlit

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

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

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

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

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

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

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

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

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

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

Definition at line 447 of file SDL_surface.h.

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

#define SDL_DONTFREE 0x00000004

Surface is referenced internally

Definition at line 55 of file SDL_surface.h.

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

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

Load a surface from a file.

Convenience macro.

Definition at line 182 of file SDL_surface.h.

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

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

Evaluates to true if the surface needs to be locked before access.

Definition at line 61 of file SDL_surface.h.

Referenced by SDL_CalculateShapeBitmap(), SDL_CalculateShapeTree(), SDL_CreateTextureFromSurface(), SDL_RLEAlphaBlit(), SDL_RLEBlit(), SDL_SoftBlit(), SDL_SoftStretch(), SDLgfx_rotateSurface(), and SW_UpdateTexture().

#define SDL_PREALLOC 0x00000001

Surface uses preallocated memory

Definition at line 53 of file SDL_surface.h.

Referenced by RLEAlphaSurface(), RLEColorkeySurface(), SDL_CreateRGBSurfaceFrom(), SDL_CreateSurfaceOnStack(), SDL_FreeSurface(), and SDL_UnRLESurface().

#define SDL_RLEACCEL 0x00000002

Surface is RLE encoded

Definition at line 54 of file SDL_surface.h.

Referenced by SDL_CalculateBlit(), SDL_ConvertSurface(), SDL_FreeSurface(), SDL_LockSurface(), SDL_MapSurface(), SDL_RLESurface(), SDL_SetColorKey(), SDL_UnlockSurface(), SDL_UnRLESurface(), SDLgfx_rotateSurface(), surface_testCompleteSurfaceConversion(), and surface_testSurfaceConversion().

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

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

#define SDL_SWSURFACE 0

Just here for compatibility

Definition at line 52 of file SDL_surface.h.

Referenced by _surfaceSetUp(), SDLgfx_rotateSurface(), SDLTest_DrawCharacter(), and SW_RenderCopyEx().

## Typedef Documentation

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

The type of function used for surface blitting functions.

Definition at line 97 of file SDL_surface.h.

## Function Documentation

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

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

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

Definition at line 1022 of file SDL_surface.c.

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

{
SDL_Surface src_surface, dst_surface;
SDL_PixelFormat src_fmt, dst_fmt;
SDL_BlitMap src_blitmap, dst_blitmap;
SDL_Rect rect;
void *nonconst_src = (void *) src;
/* Check to make sure we are blitting somewhere, so we don't crash */
if (!dst) {
return SDL_InvalidParamError("dst");
}
if (!dst_pitch) {
return SDL_InvalidParamError("dst_pitch");
}
/* Fast path for same format copy */
if (src_format == dst_format) {
int bpp, i;
if (SDL_ISPIXELFORMAT_FOURCC(src_format)) {
switch (src_format) {
case SDL_PIXELFORMAT_YUY2:
case SDL_PIXELFORMAT_UYVY:
case SDL_PIXELFORMAT_YVYU:
bpp = 2;
break;
case SDL_PIXELFORMAT_YV12:
case SDL_PIXELFORMAT_IYUV:
case SDL_PIXELFORMAT_NV12:
case SDL_PIXELFORMAT_NV21:
bpp = 1;
break;
default:
return SDL_SetError("Unknown FOURCC pixel format");
}
} else {
bpp = SDL_BYTESPERPIXEL(src_format);
}
width *= bpp;
for (i = height; i--;) {
SDL_memcpy(dst, src, width);
src = (Uint8*)src + src_pitch;
dst = (Uint8*)dst + dst_pitch;
}
if (src_format == SDL_PIXELFORMAT_YV12 || src_format == SDL_PIXELFORMAT_IYUV) {
/* U and V planes are a quarter the size of the Y plane */
width /= 2;
height /= 2;
src_pitch /= 2;
dst_pitch /= 2;
for (i = height * 2; i--;) {
SDL_memcpy(dst, src, width);
src = (Uint8*)src + src_pitch;
dst = (Uint8*)dst + dst_pitch;
}
} else if (src_format == SDL_PIXELFORMAT_NV12 || src_format == SDL_PIXELFORMAT_NV21) {
/* U/V plane is half the height of the Y plane */
height /= 2;
for (i = height; i--;) {
SDL_memcpy(dst, src, width);
src = (Uint8*)src + src_pitch;
dst = (Uint8*)dst + dst_pitch;
}
}
return 0;
}
if (!SDL_CreateSurfaceOnStack(width, height, src_format, nonconst_src,
src_pitch,
&src_surface, &src_fmt, &src_blitmap)) {
return -1;
}
if (!SDL_CreateSurfaceOnStack(width, height, dst_format, dst, dst_pitch,
&dst_surface, &dst_fmt, &dst_blitmap)) {
return -1;
}
/* Set up the rect and go! */
rect.x = 0;
rect.y = 0;
rect.w = width;
rect.h = height;
return SDL_LowerBlit(&src_surface, &rect, &dst_surface, &rect);
}
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1737
width
GLint GLint GLsizei width
Definition: SDL_opengl.h:1565
rect
SDL_Rect rect
Definition: testrelative.c:27
SDL_CreateSurfaceOnStack
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:984
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_BYTESPERPIXEL
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:127
SDL_PIXELFORMAT_NV21
Definition: SDL_pixels.h:275
SDL_InvalidParamError
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
height
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1565
SDL_LowerBlit
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:500
SDL_PIXELFORMAT_YVYU
Definition: SDL_pixels.h:271
SDL_PIXELFORMAT_NV12
Definition: SDL_pixels.h:273
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:393
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_Rect::w
int w
Definition: SDL_rect.h:67
i
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:42
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_PIXELFORMAT_YV12
Definition: SDL_pixels.h:263
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_PIXELFORMAT_IYUV
Definition: SDL_pixels.h:265
SDL_PixelFormat
Definition: SDL_pixels.h:299
SDL_PIXELFORMAT_UYVY
Definition: SDL_pixels.h:269
SDL_PIXELFORMAT_YUY2
Definition: SDL_pixels.h:267
SDL_ISPIXELFORMAT_FOURCC
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:166
SDL_BlitMap
Definition: SDL_blit.h:85
src
GLenum src
Definition: SDL_opengl_glext.h:1737
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

SDL_Surface* SDL_ConvertSurface | ( | SDL_Surface * | src,
|  | const SDL_PixelFormat * | fmt,
|  | Uint32 | flags
| ) |  |

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

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

Definition at line 842 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_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_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_GetRGBA, SDL_InvalidateMap(), SDL_LowerBlit(), SDL_MapRGBA, SDL_memcmp, SDL_memcpy, SDL_RLEACCEL, SDL_SetClipRect(), SDL_SetColorKey(), SDL_SetError, SDL_SetSurfaceBlendMode(), SDL_SetSurfaceRLE(), SDL_TRUE, SDL_Rect::w, SDL_Surface::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_ConvertSurfaceFormat().

{
SDL_Surface *convert;
Uint32 copy_flags;
SDL_Color copy_color;
SDL_Rect bounds;
/* Check for empty destination palette! (results in empty image) */
if (format->palette != NULL) {
int i;
for (i = 0; i < format->palette->ncolors; ++i) {
if ((format->palette->colors[i].r != 0xFF) ||
(format->palette->colors[i].g != 0xFF) ||
(format->palette->colors[i].b != 0xFF))
break;
}
if (i == format->palette->ncolors) {
SDL_SetError("Empty destination palette");
return (NULL);
}
}
/* Create a new surface with the desired format */
convert = SDL_CreateRGBSurface(flags, surface->w, surface->h,
format->BitsPerPixel, format->Rmask,
format->Gmask, format->Bmask,
format->Amask);
if (convert == NULL) {
return (NULL);
}
/* Copy the palette if any */
if (format->palette && convert->format->palette) {
SDL_memcpy(convert->format->palette->colors,
format->palette->colors,
format->palette->ncolors * sizeof(SDL_Color));
convert->format->palette->ncolors = format->palette->ncolors;
}
/* Save the original copy flags */
copy_flags = surface->map->info.flags;
copy_color.r = surface->map->info.r;
copy_color.g = surface->map->info.g;
copy_color.b = surface->map->info.b;
copy_color.a = surface->map->info.a;
surface->map->info.r = 0xFF;
surface->map->info.g = 0xFF;
surface->map->info.b = 0xFF;
surface->map->info.a = 0xFF;
surface->map->info.flags = 0;
SDL_InvalidateMap(surface->map);
/* Copy over the image data */
bounds.x = 0;
bounds.y = 0;
bounds.w = surface->w;
bounds.h = surface->h;
SDL_LowerBlit(surface, &bounds, convert, &bounds);
/* Clean up the original surface, and update converted surface */
convert->map->info.r = copy_color.r;
convert->map->info.g = copy_color.g;
convert->map->info.b = copy_color.b;
convert->map->info.a = copy_color.a;
convert->map->info.flags =
(copy_flags &
~(SDL_COPY_COLORKEY | SDL_COPY_BLEND
| SDL_COPY_RLE_DESIRED | SDL_COPY_RLE_COLORKEY |
SDL_COPY_RLE_ALPHAKEY));
surface->map->info.r = copy_color.r;
surface->map->info.g = copy_color.g;
surface->map->info.b = copy_color.b;
surface->map->info.a = copy_color.a;
surface->map->info.flags = copy_flags;
SDL_InvalidateMap(surface->map);
if (copy_flags & SDL_COPY_COLORKEY) {
SDL_bool set_colorkey_by_color = SDL_FALSE;
if (surface->format->palette) {
if (format->palette &&
surface->format->palette->ncolors <= format->palette->ncolors &&
(SDL_memcmp(surface->format->palette->colors, format->palette->colors,
surface->format->palette->ncolors * sizeof(SDL_Color)) == 0)) {
/* The palette is identical, just set the same colorkey */
SDL_SetColorKey(convert, 1, surface->map->info.colorkey);
} else if (format->Amask) {
/* The alpha was set in the destination from the palette */
} else {
set_colorkey_by_color = SDL_TRUE;
}
} else {
set_colorkey_by_color = SDL_TRUE;
}
if (set_colorkey_by_color) {
/* Set the colorkey by color, which needs to be unique */
Uint8 keyR, keyG, keyB, keyA;
SDL_GetRGBA(surface->map->info.colorkey, surface->format, &keyR,
&keyG, &keyB, &keyA);
SDL_SetColorKey(convert, 1,
SDL_MapRGBA(convert->format, keyR, keyG, keyB, keyA));
/* This is needed when converting for 3D texture upload */
SDL_ConvertColorkeyToAlpha(convert);
}
}
SDL_SetClipRect(convert, &surface->clip_rect);
/* Enable alpha blending by default if the new surface has an
* alpha channel or alpha modulation */
if ((surface->format->Amask && format->Amask) ||
(copy_flags & (SDL_COPY_COLORKEY|SDL_COPY_MODULATE_ALPHA))) {
SDL_SetSurfaceBlendMode(convert, SDL_BLENDMODE_BLEND);
}
if ((copy_flags & SDL_COPY_RLE_DESIRED) || (flags & SDL_RLEACCEL)) {
SDL_SetSurfaceRLE(convert, SDL_RLEACCEL);
}
/* We're ready to go! */
return (convert);
}
SDL_BlitInfo::r
Uint8 r
Definition: SDL_blit.h:70
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
SDL_BlitInfo::b
Uint8 b
Definition: SDL_blit.h:70
SDL_SetClipRect
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:457
SDL_Color
Definition: SDL_pixels.h:279
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
SDL_SetSurfaceRLE
int SDL_SetSurfaceRLE(SDL_Surface *surface, int flag)
Sets the RLE acceleration hint for a surface.
Definition: SDL_surface.c:156
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_Color::g
Uint8 g
Definition: SDL_pixels.h:282
SDL_MapRGBA
#define SDL_MapRGBA
Definition: SDL_dynapi_overrides.h:293
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_BlitInfo::g
Uint8 g
Definition: SDL_blit.h:70
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_SetSurfaceBlendMode
int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode)
Set the blend mode used for blit operations.
Definition: SDL_surface.c:391
SDL_ConvertColorkeyToAlpha
static void SDL_ConvertColorkeyToAlpha(SDL_Surface *surface)
Definition: SDL_surface.c:240
SDL_Color::b
Uint8 b
Definition: SDL_pixels.h:283
SDL_COPY_RLE_COLORKEY
#define SDL_COPY_RLE_COLORKEY
Definition: SDL_blit.h:42
SDL_LowerBlit
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:500
SDL_SetColorKey
int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key)
Sets the color key (transparent pixel) in a blittable surface.
Definition: SDL_surface.c:177
SDL_BlitInfo::colorkey
Uint32 colorkey
Definition: SDL_blit.h:69
SDL_COPY_RLE_DESIRED
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:126
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:393
SDL_Color::r
Uint8 r
Definition: SDL_pixels.h:281
SDL_Color::a
Uint8 a
Definition: SDL_pixels.h:284
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_memcmp
#define SDL_memcmp
Definition: SDL_dynapi_overrides.h:395
SDL_Palette::ncolors
int ncolors
Definition: SDL_pixels.h:290
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_TRUE
Definition: SDL_stdinc.h:129
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_GetRGBA
#define SDL_GetRGBA
Definition: SDL_dynapi_overrides.h:295
SDL_Surface::clip_rect
SDL_Rect clip_rect
Definition: SDL_surface.h:85
i
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:42
NULL
#define NULL
Definition: begin_code.h:143
SDL_Palette::colors
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_CreateRGBSurface
SDL_Surface * SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
Definition: SDL_surface.c:34
SDL_COPY_MODULATE_ALPHA
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_COPY_RLE_ALPHAKEY
#define SDL_COPY_RLE_ALPHAKEY
Definition: SDL_blit.h:43
SDL_FALSE
Definition: SDL_stdinc.h:128
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:302
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDL_COPY_BLEND
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
SDL_RLEACCEL
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44
SDL_BlitInfo::a
Uint8 a
Definition: SDL_blit.h:70

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

Definition at line 966 of file SDL_surface.c.

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

{
SDL_PixelFormat *fmt;
SDL_Surface *convert = NULL;
fmt = SDL_AllocFormat(pixel_format);
if (fmt) {
convert = SDL_ConvertSurface(surface, fmt, flags);
SDL_FreeFormat(fmt);
}
return convert;
}
SDL_ConvertSurface
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:842
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_AllocFormat
#define SDL_AllocFormat
Definition: SDL_dynapi_overrides.h:286
SDL_FreeFormat
#define SDL_FreeFormat
Definition: SDL_dynapi_overrides.h:287
NULL
#define NULL
Definition: begin_code.h:143
SDL_PixelFormat
Definition: SDL_pixels.h:299
pixel_format
Uint32 pixel_format
Definition: testoverlay2.c:152
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480

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

  flags | The `flags` are obsolete and should be set to 0.
  width | The width in pixels of the surface to create.
  height | The height in pixels of the surface to create.
  depth | The depth in bits of the surface to create.
  Rmask | The red mask of the surface to create.
  Gmask | The green mask of the surface to create.
  Bmask | The blue mask of the surface to create.
  Amask | The alpha mask of the surface to create.

Definition at line 34 of file SDL_surface.c.

References 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_MasksToPixelFormatEnum, SDL_memset, SDL_OutOfMemory, SDL_PIXELFORMAT_UNKNOWN, SDL_SetClipRect(), SDL_SetError, SDL_SetSurfaceBlendMode(), SDL_SetSurfacePalette(), void, and SDL_Surface::w.

Referenced by SDL_ConvertSurface(), and SDL_CreateRGBSurfaceFrom().

{
SDL_Surface *surface;
Uint32 format;
/* The flags are no longer used, make the compiler happy */
(void)flags;
/* Get the pixel format */
format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
if (format == SDL_PIXELFORMAT_UNKNOWN) {
SDL_SetError("Unknown pixel format");
return NULL;
}
/* Allocate the surface */
surface = (SDL_Surface *) SDL_calloc(1, sizeof(*surface));
if (surface == NULL) {
SDL_OutOfMemory();
return NULL;
}
surface->format = SDL_AllocFormat(format);
if (!surface->format) {
SDL_FreeSurface(surface);
return NULL;
}
surface->w = width;
surface->h = height;
surface->pitch = SDL_CalculatePitch(surface);
SDL_SetClipRect(surface, NULL);
if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
SDL_Palette *palette =
SDL_AllocPalette((1 << surface->format->BitsPerPixel));
if (!palette) {
SDL_FreeSurface(surface);
return NULL;
}
if (palette->ncolors == 2) {
/* Create a black and white bitmap palette */
palette->colors[0].r = 0xFF;
palette->colors[0].g = 0xFF;
palette->colors[0].b = 0xFF;
palette->colors[1].r = 0x00;
palette->colors[1].g = 0x00;
palette->colors[1].b = 0x00;
}
SDL_SetSurfacePalette(surface, palette);
SDL_FreePalette(palette);
}
/* Get the pixels */
if (surface->w && surface->h) {
surface->pixels = SDL_malloc(surface->h * surface->pitch);
if (!surface->pixels) {
SDL_FreeSurface(surface);
SDL_OutOfMemory();
return NULL;
}
/* This is important for bitmaps */
SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
}
/* Allocate an empty mapping */
surface->map = SDL_AllocBlitMap();
if (!surface->map) {
SDL_FreeSurface(surface);
return NULL;
}
/* By default surface with an alpha mask are set up for blending */
if (Amask) {
SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);
}
/* The surface is ready to go */
surface->refcount = 1;
return surface;
}
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
SDL_SetClipRect
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:457
width
GLint GLint GLsizei width
Definition: SDL_opengl.h:1565
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_Color::g
Uint8 g
Definition: SDL_pixels.h:282
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_ISPIXELFORMAT_INDEXED
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:133
SDL_MasksToPixelFormatEnum
#define SDL_MasksToPixelFormatEnum
Definition: SDL_dynapi_overrides.h:285
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_SetSurfaceBlendMode
int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode)
Set the blend mode used for blit operations.
Definition: SDL_surface.c:391
SDL_Color::b
Uint8 b
Definition: SDL_pixels.h:283
SDL_AllocFormat
#define SDL_AllocFormat
Definition: SDL_dynapi_overrides.h:286
height
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1565
SDL_Surface::w
int w
Definition: SDL_surface.h:73
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_Palette
Definition: SDL_pixels.h:288
SDL_calloc
void * SDL_calloc(size_t nmemb, size_t size)
SDL_Color::r
Uint8 r
Definition: SDL_pixels.h:281
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
SDL_PixelFormat::BitsPerPixel
Uint8 BitsPerPixel
Definition: SDL_pixels.h:303
SDL_SetSurfacePalette
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:142
SDL_Palette::ncolors
int ncolors
Definition: SDL_pixels.h:290
SDL_PIXELFORMAT_UNKNOWN
Definition: SDL_pixels.h:172
SDL_AllocPalette
#define SDL_AllocPalette
Definition: SDL_dynapi_overrides.h:288
SDL_FreeSurface
void SDL_FreeSurface(SDL_Surface *surface)
Definition: SDL_surface.c:1116
NULL
#define NULL
Definition: begin_code.h:143
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Palette::colors
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
depth
GLint GLint GLsizei GLsizei GLsizei depth
Definition: SDL_opengl.h:1565
SDL_FreePalette
#define SDL_FreePalette
Definition: SDL_dynapi_overrides.h:291
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
void
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
Definition: SDL_dynapi_procs.h:93
SDL_Surface::refcount
int refcount
Definition: SDL_surface.h:91
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
SDL_AllocBlitMap
SDL_BlitMap * SDL_AllocBlitMap(void)
Definition: SDL_pixels.c:954
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_CalculatePitch
int SDL_CalculatePitch(SDL_Surface *surface)
Definition: SDL_pixels.c:748
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:380
SDL_PixelFormat::format
Uint32 format
Definition: SDL_pixels.h:301
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:392
SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44

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

{
SDL_Surface *surface;
surface =
SDL_CreateRGBSurface(0, 0, 0, depth, Rmask, Gmask, Bmask, Amask);
if (surface != NULL) {
surface->flags |= SDL_PREALLOC;
surface->pixels = pixels;
surface->w = width;
surface->h = height;
surface->pitch = pitch;
SDL_SetClipRect(surface, NULL);
}
return surface;
}
SDL_SetClipRect
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:457
width
GLint GLint GLsizei width
Definition: SDL_opengl.h:1565
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
pixels
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1565
height
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1565
SDL_Surface::w
int w
Definition: SDL_surface.h:73
SDL_Surface::flags
Uint32 flags
Definition: SDL_surface.h:71
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
NULL
#define NULL
Definition: begin_code.h:143
depth
GLint GLint GLsizei GLsizei GLsizei depth
Definition: SDL_opengl.h:1565
SDL_CreateRGBSurface
SDL_Surface * SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
Definition: SDL_surface.c:34
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
SDL_PREALLOC
#define SDL_PREALLOC
Definition: SDL_surface.h:53

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

{
SDL_Rect clipped;
Uint8 *pixels;
if (!dst) {
return SDL_SetError("Passed NULL destination surface");
}
/* This function doesn't work on surfaces < 8 bpp */
if (dst->format->BitsPerPixel < 8) {
return SDL_SetError("SDL_FillRect(): Unsupported surface format");
}
/* If 'rect' == NULL, then fill the whole surface */
if (rect) {
/* Perform clipping */
if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
return 0;
}
rect = &clipped;
} else {
rect = &dst->clip_rect;
/* Don't attempt to fill if the surface's clip_rect is empty */
if (SDL_RectEmpty(rect)) {
return 0;
}
}
/* Perform software fill */
if (!dst->pixels) {
return SDL_SetError("SDL_FillRect(): You must lock the surface");
}
pixels = (Uint8 *) dst->pixels + rect->y * dst->pitch +
rect->x * dst->format->BytesPerPixel;
switch (dst->format->BytesPerPixel) {
case 1:
{
color |= (color << 8);
color |= (color << 16);
#ifdef __SSE__
if (SDL_HasSSE()) {
SDL_FillRect1SSE(pixels, dst->pitch, color, rect->w, rect->h);
break;
}
#endif
SDL_FillRect1(pixels, dst->pitch, color, rect->w, rect->h);
break;
}
case 2:
{
color |= (color << 16);
#ifdef __SSE__
if (SDL_HasSSE()) {
SDL_FillRect2SSE(pixels, dst->pitch, color, rect->w, rect->h);
break;
}
#endif
SDL_FillRect2(pixels, dst->pitch, color, rect->w, rect->h);
break;
}
case 3:
/* 24-bit RGB is a slow path, at least for now. */
{
SDL_FillRect3(pixels, dst->pitch, color, rect->w, rect->h);
break;
}
case 4:
{
#ifdef __SSE__
if (SDL_HasSSE()) {
SDL_FillRect4SSE(pixels, dst->pitch, color, rect->w, rect->h);
break;
}
#endif
SDL_FillRect4(pixels, dst->pitch, color, rect->w, rect->h);
break;
}
}
/* We're done! */
return 0;
}
SDL_PixelFormat::BytesPerPixel
Uint8 BytesPerPixel
Definition: SDL_pixels.h:304
pixels
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1565
SDL_IntersectRect
#define SDL_IntersectRect
Definition: SDL_dynapi_overrides.h:300
SDL_RectEmpty
SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
Returns true if the rectangle has no area.
Definition: SDL_rect.h:82
SDL_FillRect3
static void SDL_FillRect3(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:197
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_PixelFormat::BitsPerPixel
Uint8 BitsPerPixel
Definition: SDL_pixels.h:303
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_Surface::clip_rect
SDL_Rect clip_rect
Definition: SDL_surface.h:85
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_FillRect2
static void SDL_FillRect2(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:173
SDL_Rect::h
int h
Definition: SDL_rect.h:67
color
GLuint color
Definition: SDL_opengl_glext.h:1148
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
SDL_FillRect4
static void SDL_FillRect4(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:225
SDL_FillRect1
static void SDL_FillRect1(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:134
SDL_HasSSE
#define SDL_HasSSE
Definition: SDL_dynapi_overrides.h:113
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

int SDL_FillRects | ( | SDL_Surface * | dst,
|  | const SDL_Rect * | rects,
|  | int | count,
|  | Uint32 | color
| ) |  |

Definition at line 327 of file SDL_fillrect.c.

References i, SDL_FillRect(), and SDL_SetError.

{
int i;
int status = 0;
if (!rects) {
return SDL_SetError("SDL_FillRects() passed NULL rects");
}
for (i = 0; i < count; ++i) {
status += SDL_FillRect(dst, &rects[i], color);
}
return status;
}
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1564
i
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:42
SDL_FillRect
int SDL_FillRect(SDL_Surface *dst, const SDL_Rect *rect, Uint32 color)
Definition: SDL_fillrect.c:237
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
color
GLuint color
Definition: SDL_opengl_glext.h:1148

void SDL_FreeSurface | ( | SDL_Surface * | surface | ) |

Definition at line 1116 of file SDL_surface.c.

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

Referenced by SDL_CreateRGBSurface().

{
if (surface == NULL) {
return;
}
if (surface->flags & SDL_DONTFREE) {
return;
}
if (--surface->refcount > 0) {
return;
}
while (surface->locked > 0) {
SDL_UnlockSurface(surface);
}
if (surface->flags & SDL_RLEACCEL) {
SDL_UnRLESurface(surface, 0);
}
if (surface->format) {
SDL_SetSurfacePalette(surface, NULL);
SDL_FreeFormat(surface->format);
surface->format = NULL;
}
if (surface->map != NULL) {
SDL_FreeBlitMap(surface->map);
surface->map = NULL;
}
if (!(surface->flags & SDL_PREALLOC)) {
SDL_free(surface->pixels);
}
SDL_free(surface);
}
SDL_UnlockSurface
void SDL_UnlockSurface(SDL_Surface *surface)
Definition: SDL_surface.c:824
SDL_DONTFREE
#define SDL_DONTFREE
Definition: SDL_surface.h:55
SDL_UnRLESurface
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Definition: SDL_RLEaccel.c:1540
SDL_Surface::flags
Uint32 flags
Definition: SDL_surface.h:71
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
SDL_SetSurfacePalette
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:142
SDL_free
void SDL_free(void *mem)
SDL_FreeFormat
#define SDL_FreeFormat
Definition: SDL_dynapi_overrides.h:287
SDL_Surface::locked
int locked
Definition: SDL_surface.h:81
NULL
#define NULL
Definition: begin_code.h:143
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_Surface::refcount
int refcount
Definition: SDL_surface.h:91
SDL_FreeBlitMap
void SDL_FreeBlitMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:1079
SDL_PREALLOC
#define SDL_PREALLOC
Definition: SDL_surface.h:53
SDL_RLEACCEL
#define SDL_RLEACCEL
Definition: SDL_surface.h:54

void SDL_GetClipRect | ( | SDL_Surface * | surface,
|  | SDL_Rect * | rect
| ) |  |

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

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

Definition at line 481 of file SDL_surface.c.

References SDL_Surface::clip_rect.

{
if (surface && rect) {
*rect = surface->clip_rect;
}
}
SDL_Surface::clip_rect
SDL_Rect clip_rect
Definition: SDL_surface.h:85

int SDL_GetColorKey | ( | SDL_Surface * | surface,
|  | Uint32 * | key
| ) |  |

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

Parameters

  surface | The surface to update
  key | A 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 222 of file SDL_surface.c.

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

{
if (!surface) {
return -1;
}
if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
return -1;
}
if (key) {
*key = surface->map->info.colorkey;
}
return 0;
}
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_BlitInfo::colorkey
Uint32 colorkey
Definition: SDL_blit.h:69
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91

int SDL_GetSurfaceAlphaMod | ( | SDL_Surface * | surface,
|  | Uint8 * | alpha
| ) |  |

Get the additional alpha value used in blit operations.

Parameters

  surface | The surface to query.
  alpha | A 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 378 of file SDL_surface.c.

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

{
if (!surface) {
return -1;
}
if (alpha) {
*alpha = surface->map->info.a;
}
return 0;
}
alpha
GLfloat GLfloat GLfloat alpha
Definition: SDL_opengl_glext.h:412
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
SDL_BlitInfo::a
Uint8 a
Definition: SDL_blit.h:70

int SDL_GetSurfaceBlendMode | ( | SDL_Surface * | surface,
|  | SDL_BlendMode * | blendMode
| ) |  |

Get the blend mode used for blit operations.

Parameters

  surface | The surface to query.
  blendMode | A 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 428 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.

{
if (!surface) {
return -1;
}
if (!blendMode) {
return 0;
}
switch (surface->map->
info.flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD)) {
case SDL_COPY_BLEND:
*blendMode = SDL_BLENDMODE_BLEND;
break;
case SDL_COPY_ADD:
*blendMode = SDL_BLENDMODE_ADD;
break;
case SDL_COPY_MOD:
*blendMode = SDL_BLENDMODE_MOD;
break;
default:
*blendMode = SDL_BLENDMODE_NONE;
break;
}
return 0;
}
SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
SDL_COPY_MOD
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
SDL_COPY_ADD
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
SDL_BLENDMODE_MOD
Definition: SDL_blendmode.h:50
blendMode
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_BLENDMODE_ADD
Definition: SDL_blendmode.h:47
SDL_COPY_BLEND
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44

int SDL_GetSurfaceColorMod | ( | SDL_Surface * | surface,
|  | Uint8 * | r,
|  | Uint8 * | g,
|  | Uint8 * | b
| ) |  |

Get the additional color value used in blit operations.

Parameters

  surface | The surface to query.
  r | A pointer filled in with the current red color value.
  g | A pointer filled in with the current green color value.
  b | A 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 336 of file SDL_surface.c.

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

{
if (!surface) {
return -1;
}
if (r) {
*r = surface->map->info.r;
}
if (g) {
*g = surface->map->info.g;
}
if (b) {
*b = surface->map->info.b;
}
return 0;
}
SDL_BlitInfo::r
Uint8 r
Definition: SDL_blit.h:70
SDL_BlitInfo::b
Uint8 b
Definition: SDL_blit.h:70
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
SDL_BlitInfo::g
Uint8 g
Definition: SDL_blit.h:70
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1109
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91

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 81 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, and SDL_Surface::w.

{
SDL_bool was_error;
Sint64 fp_offset = 0;
int bmpPitch;
int i, pad;
SDL_Surface *surface;
Uint32 Rmask = 0;
Uint32 Gmask = 0;
Uint32 Bmask = 0;
Uint32 Amask = 0;
SDL_Palette *palette;
Uint8 *bits;
Uint8 *top, *end;
SDL_bool topDown;
int ExpandBMP;
SDL_bool haveRGBMasks = SDL_FALSE;
SDL_bool haveAlphaMask = SDL_FALSE;
SDL_bool correctAlpha = SDL_FALSE;
/* The Win32 BMP file header (14 bytes) */
char magic[2];
/* Uint32 bfSize = 0; */
/* Uint16 bfReserved1 = 0; */
/* Uint16 bfReserved2 = 0; */
Uint32 bfOffBits = 0;
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
Uint32 biSize = 0;
Sint32 biWidth = 0;
Sint32 biHeight = 0;
/* Uint16 biPlanes = 0; */
Uint16 biBitCount = 0;
Uint32 biCompression = 0;
/* Uint32 biSizeImage = 0; */
/* Sint32 biXPelsPerMeter = 0; */
/* Sint32 biYPelsPerMeter = 0; */
Uint32 biClrUsed = 0;
/* Uint32 biClrImportant = 0; */
/* Make sure we are passed a valid data source */
surface = NULL;
was_error = SDL_FALSE;
if (src == NULL) {
was_error = SDL_TRUE;
goto done;
}
/* Read in the BMP file header */
fp_offset = SDL_RWtell(src);
SDL_ClearError();
if (SDL_RWread(src, magic, 1, 2) != 2) {
SDL_Error(SDL_EFREAD);
was_error = SDL_TRUE;
goto done;
}
if (SDL_strncmp(magic, "BM", 2) != 0) {
SDL_SetError("File is not a Windows BMP file");
was_error = SDL_TRUE;
goto done;
}
/* bfSize = */ SDL_ReadLE32(src);
/* bfReserved1 = */ SDL_ReadLE16(src);
/* bfReserved2 = */ SDL_ReadLE16(src);
bfOffBits = SDL_ReadLE32(src);
/* Read the Win32 BITMAPINFOHEADER */
biSize = SDL_ReadLE32(src);
if (biSize == 12) { /* really old BITMAPCOREHEADER */
biWidth = (Uint32) SDL_ReadLE16(src);
biHeight = (Uint32) SDL_ReadLE16(src);
/* biPlanes = */ SDL_ReadLE16(src);
biBitCount = SDL_ReadLE16(src);
biCompression = BI_RGB;
} else if (biSize >= 40) { /* some version of BITMAPINFOHEADER */
Uint32 headerSize;
biWidth = SDL_ReadLE32(src);
biHeight = SDL_ReadLE32(src);
/* biPlanes = */ SDL_ReadLE16(src);
biBitCount = SDL_ReadLE16(src);
biCompression = SDL_ReadLE32(src);
/* biSizeImage = */ SDL_ReadLE32(src);
/* biXPelsPerMeter = */ SDL_ReadLE32(src);
/* biYPelsPerMeter = */ SDL_ReadLE32(src);
biClrUsed = SDL_ReadLE32(src);
/* biClrImportant = */ SDL_ReadLE32(src);
/* 64 == BITMAPCOREHEADER2, an incompatible OS/2 2.x extension. Skip this stuff for now. */
if (biSize == 64) {
/* ignore these extra fields. */
if (biCompression == BI_BITFIELDS) {
/* this value is actually huffman compression in this variant. */
SDL_SetError("Compressed BMP files not supported");
was_error = SDL_TRUE;
goto done;
}
} else {
/* This is complicated. If compression is BI_BITFIELDS, then
we have 3 DWORDS that specify the RGB masks. This is either
stored here in an BITMAPV2INFOHEADER (which only differs in
that it adds these RGB masks) and biSize >= 52, or we've got
these masks stored in the exact same place, but strictly
speaking, this is the bmiColors field in BITMAPINFO immediately
following the legacy v1 info header, just past biSize. */
if (biCompression == BI_BITFIELDS) {
haveRGBMasks = SDL_TRUE;
Rmask = SDL_ReadLE32(src);
Gmask = SDL_ReadLE32(src);
Bmask = SDL_ReadLE32(src);
/* ...v3 adds an alpha mask. */
if (biSize >= 56) { /* BITMAPV3INFOHEADER; adds alpha mask */
haveAlphaMask = SDL_TRUE;
Amask = SDL_ReadLE32(src);
}
} else {
/* the mask fields are ignored for v2+ headers if not BI_BITFIELD. */
if (biSize >= 52) { /* BITMAPV2INFOHEADER; adds RGB masks */
/*Rmask = */ SDL_ReadLE32(src);
/*Gmask = */ SDL_ReadLE32(src);
/*Bmask = */ SDL_ReadLE32(src);
}
if (biSize >= 56) { /* BITMAPV3INFOHEADER; adds alpha mask */
/*Amask = */ SDL_ReadLE32(src);
}
}
/* Insert other fields here; Wikipedia and MSDN say we're up to
v5 of this header, but we ignore those for now (they add gamma,
color spaces, etc). Ignoring the weird OS/2 2.x format, we
currently parse up to v3 correctly (hopefully!). */
}
/* skip any header bytes we didn't handle... */
headerSize = (Uint32) (SDL_RWtell(src) - (fp_offset + 14));
if (biSize > headerSize) {
SDL_RWseek(src, (biSize - headerSize), RW_SEEK_CUR);
}
}
if (biHeight < 0) {
topDown = SDL_TRUE;
biHeight = -biHeight;
} else {
topDown = SDL_FALSE;
}
/* Check for read error */
if (SDL_strcmp(SDL_GetError(), "") != 0) {
was_error = SDL_TRUE;
goto done;
}
/* Expand 1 and 4 bit bitmaps to 8 bits per pixel */
switch (biBitCount) {
case 1:
case 4:
ExpandBMP = biBitCount;
biBitCount = 8;
break;
default:
ExpandBMP = 0;
break;
}
/* We don't support any BMP compression right now */
switch (biCompression) {
case BI_RGB:
/* If there are no masks, use the defaults */
SDL_assert(!haveRGBMasks);
SDL_assert(!haveAlphaMask);
/* Default values for the BMP format */
switch (biBitCount) {
case 15:
case 16:
Rmask = 0x7C00;
Gmask = 0x03E0;
Bmask = 0x001F;
break;
case 24:
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
Rmask = 0x000000FF;
Gmask = 0x0000FF00;
Bmask = 0x00FF0000;
#else
Rmask = 0x00FF0000;
Gmask = 0x0000FF00;
Bmask = 0x000000FF;
#endif
break;
case 32:
/* We don't know if this has alpha channel or not */
correctAlpha = SDL_TRUE;
Amask = 0xFF000000;
Rmask = 0x00FF0000;
Gmask = 0x0000FF00;
Bmask = 0x000000FF;
break;
default:
break;
}
break;
case BI_BITFIELDS:
break; /* we handled this in the info header. */
default:
SDL_SetError("Compressed BMP files not supported");
was_error = SDL_TRUE;
goto done;
}
/* Create a compatible surface, note that the colors are RGB ordered */
surface =
SDL_CreateRGBSurface(0, biWidth, biHeight, biBitCount, Rmask, Gmask,
Bmask, Amask);
if (surface == NULL) {
was_error = SDL_TRUE;
goto done;
}
/* Load the palette, if any */
palette = (surface->format)->palette;
if (palette) {
SDL_assert(biBitCount <= 8);
if (biClrUsed == 0) {
biClrUsed = 1 << biBitCount;
}
if ((int) biClrUsed > palette->ncolors) {
SDL_Color *colors;
int ncolors = biClrUsed;
colors =
(SDL_Color *) SDL_realloc(palette->colors,
ncolors *
sizeof(*palette->colors));
if (!colors) {
SDL_OutOfMemory();
was_error = SDL_TRUE;
goto done;
}
palette->ncolors = ncolors;
palette->colors = colors;
} else if ((int) biClrUsed < palette->ncolors) {
palette->ncolors = biClrUsed;
}
if (biSize == 12) {
for (i = 0; i < (int) biClrUsed; ++i) {
SDL_RWread(src, &palette->colors[i].b, 1, 1);
SDL_RWread(src, &palette->colors[i].g, 1, 1);
SDL_RWread(src, &palette->colors[i].r, 1, 1);
palette->colors[i].a = SDL_ALPHA_OPAQUE;
}
} else {
for (i = 0; i < (int) biClrUsed; ++i) {
SDL_RWread(src, &palette->colors[i].b, 1, 1);
SDL_RWread(src, &palette->colors[i].g, 1, 1);
SDL_RWread(src, &palette->colors[i].r, 1, 1);
SDL_RWread(src, &palette->colors[i].a, 1, 1);
/* According to Microsoft documentation, the fourth element
is reserved and must be zero, so we shouldn't treat it as
alpha.
*/
palette->colors[i].a = SDL_ALPHA_OPAQUE;
}
}
}
/* Read the surface pixels. Note that the bmp image is upside down */
if (SDL_RWseek(src, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
was_error = SDL_TRUE;
goto done;
}
top = (Uint8 *)surface->pixels;
end = (Uint8 *)surface->pixels+(surface->h*surface->pitch);
switch (ExpandBMP) {
case 1:
bmpPitch = (biWidth + 7) >> 3;
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
break;
case 4:
bmpPitch = (biWidth + 1) >> 1;
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
break;
default:
pad = ((surface->pitch % 4) ? (4 - (surface->pitch % 4)) : 0);
break;
}
if (topDown) {
bits = top;
} else {
bits = end - surface->pitch;
}
while (bits >= top && bits < end) {
switch (ExpandBMP) {
case 1:
case 4:{
Uint8 pixel = 0;
int shift = (8 - ExpandBMP);
for (i = 0; i < surface->w; ++i) {
if (i % (8 / ExpandBMP) == 0) {
if (!SDL_RWread(src, &pixel, 1, 1)) {
SDL_SetError("Error reading from BMP");
was_error = SDL_TRUE;
goto done;
}
}
*(bits + i) = (pixel >> shift);
pixel <<= ExpandBMP;
}
}
break;
default:
if (SDL_RWread(src, bits, 1, surface->pitch)
!= surface->pitch) {
SDL_Error(SDL_EFREAD);
was_error = SDL_TRUE;
goto done;
}
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
/* Byte-swap the pixels if needed. Note that the 24bpp
case has already been taken care of above. */
switch (biBitCount) {
case 15:
case 16:{
Uint16 *pix = (Uint16 *) bits;
for (i = 0; i < surface->w; i++)
pix[i] = SDL_Swap16(pix[i]);
break;
}
case 32:{
Uint32 *pix = (Uint32 *) bits;
for (i = 0; i < surface->w; i++)
pix[i] = SDL_Swap32(pix[i]);
break;
}
}
#endif
break;
}
/* Skip padding bytes, ugh */
if (pad) {
Uint8 padbyte;
for (i = 0; i < pad; ++i) {
SDL_RWread(src, &padbyte, 1, 1);
}
}
if (topDown) {
bits += surface->pitch;
} else {
bits -= surface->pitch;
}
}
if (correctAlpha) {
CorrectAlphaChannel(surface);
}
done:
if (was_error) {
if (src) {
SDL_RWseek(src, fp_offset, RW_SEEK_SET);
}
SDL_FreeSurface(surface);
surface = NULL;
}
if (freesrc && src) {
SDL_RWclose(src);
}
return (surface);
}
BI_RGB
#define BI_RGB
Definition: SDL_bmp.c:44
SDL_ClearError
#define SDL_ClearError
Definition: SDL_dynapi_overrides.h:120
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:119
SDL_Color
Definition: SDL_pixels.h:279
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_Color::g
Uint8 g
Definition: SDL_pixels.h:282
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_EFSEEK
Definition: SDL_error.h:60
end
GLuint GLuint end
Definition: SDL_opengl.h:1564
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_ReadLE32
#define SDL_ReadLE32
Definition: SDL_dynapi_overrides.h:365
SDL_RWread
#define SDL_RWread(ctx, ptr, size, n)
Definition: SDL_rwops.h:187
SDL_Color::b
Uint8 b
Definition: SDL_pixels.h:283
bits
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
Definition: SDL_opengl_glext.h:6176
SDL_realloc
#define SDL_realloc
Definition: SDL_dynapi_overrides.h:382
CorrectAlphaChannel
static void CorrectAlphaChannel(SDL_Surface *surface)
Definition: SDL_bmp.c:51
SDL_Surface::w
int w
Definition: SDL_surface.h:73
top
GLdouble GLdouble GLdouble GLdouble top
Definition: SDL_opengl_glext.h:6103
SDL_strncmp
#define SDL_strncmp
Definition: SDL_dynapi_overrides.h:424
SDL_Error
#define SDL_Error
Definition: SDL_dynapi_overrides.h:121
SDL_RWseek
#define SDL_RWseek(ctx, offset, whence)
Definition: SDL_rwops.h:185
SDL_ReadLE16
#define SDL_ReadLE16
Definition: SDL_dynapi_overrides.h:363
SDL_Swap32
SDL_FORCE_INLINE Uint32 SDL_Swap32(Uint32 x)
Definition: SDL_endian.h:141
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:126
SDL_Palette
Definition: SDL_pixels.h:288
SDL_Color::r
Uint8 r
Definition: SDL_pixels.h:281
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:450
SDL_Color::a
Uint8 a
Definition: SDL_pixels.h:284
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
done
int done
Definition: checkkeys.c:28
SDL_EFREAD
Definition: SDL_error.h:58
SDL_Palette::ncolors
int ncolors
Definition: SDL_pixels.h:290
SDL_Swap16
SDL_FORCE_INLINE Uint16 SDL_Swap16(Uint16 x)
Definition: SDL_endian.h:101
SDL_TRUE
Definition: SDL_stdinc.h:129
Sint32
int32_t Sint32
A signed 32-bit integer type.
Definition: SDL_stdinc.h:151
BI_BITFIELDS
#define BI_BITFIELDS
Definition: SDL_bmp.c:47
i
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:42
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:167
NULL
#define NULL
Definition: begin_code.h:143
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Palette::colors
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_RWclose
#define SDL_RWclose(ctx)
Definition: SDL_rwops.h:189
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_CreateRGBSurface
#define SDL_CreateRGBSurface
Definition: SDL_dynapi_overrides.h:448
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
RW_SEEK_SET
#define RW_SEEK_SET
Definition: SDL_rwops.h:174
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:147
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:423
RW_SEEK_CUR
#define RW_SEEK_CUR
Definition: SDL_rwops.h:175
Sint64
int64_t Sint64
A signed 64-bit integer type.
Definition: SDL_stdinc.h:160
colors
static int colors[7]
Definition: testgesture.c:40
SDL_ALPHA_OPAQUE
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:45
SDL_RWtell
#define SDL_RWtell(ctx)
Definition: SDL_rwops.h:186

int SDL_LockSurface | ( | SDL_Surface * | surface | ) |

Sets up a surface for directly accessing the pixels.

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

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

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

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

See also
  SDL_UnlockSurface()

Definition at line 803 of file SDL_surface.c.

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

Referenced by SDL_ConvertColorkeyToAlpha().

{
if (!surface->locked) {
/* Perform the lock */
if (surface->flags & SDL_RLEACCEL) {
SDL_UnRLESurface(surface, 1);
surface->flags |= SDL_RLEACCEL; /* save accel'd state */
}
}
/* Increment the surface lock count, for recursive locks */
++surface->locked;
/* Ready to go.. */
return (0);
}
SDL_UnRLESurface
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Definition: SDL_RLEaccel.c:1540
SDL_Surface::flags
Uint32 flags
Definition: SDL_surface.h:71
SDL_Surface::locked
int locked
Definition: SDL_surface.h:81
SDL_RLEACCEL
#define SDL_RLEACCEL
Definition: SDL_surface.h:54

int SDL_LowerBlit | ( | SDL_Surface * | src,
|  | SDL_Rect * | srcrect,
|  | SDL_Surface * | dst,
|  | SDL_Rect * | dstrect
| ) |  |

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

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

{
/* Check to make sure the blit mapping is valid */
if ((src->map->dst != dst) ||
(dst->format->palette &&
src->map->dst_palette_version != dst->format->palette->version) ||
(src->format->palette &&
src->map->src_palette_version != src->format->palette->version)) {
if (SDL_MapSurface(src, dst) < 0) {
return (-1);
}
/* just here for debugging */
/* printf */
/* ("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", */
/* src, dst->flags, src->map->info.flags, dst, dst->flags, */
/* dst->map->info.flags, src->map->blit); */
}
return (src->map->blit(src, srcrect, dst, dstrect));
}
SDL_Palette::version
Uint32 version
Definition: SDL_pixels.h:292
SDL_BlitMap::blit
SDL_blit blit
Definition: SDL_blit.h:89
SDL_BlitMap::dst_palette_version
Uint32 dst_palette_version
Definition: SDL_blit.h:95
SDL_BlitMap::src_palette_version
Uint32 src_palette_version
Definition: SDL_blit.h:96
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_MapSurface
int SDL_MapSurface(SDL_Surface *src, SDL_Surface *dst)
Definition: SDL_pixels.c:993
SDL_BlitMap::dst
SDL_Surface * dst
Definition: SDL_blit.h:87
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:302

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

{
static const Uint32 complex_copy_flags = (
SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA |
SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD |
SDL_COPY_COLORKEY
);
if (!(src->map->info.flags & SDL_COPY_NEAREST)) {
src->map->info.flags |= SDL_COPY_NEAREST;
SDL_InvalidateMap(src->map);
}
if ( !(src->map->info.flags & complex_copy_flags) &&
src->format->format == dst->format->format &&
!SDL_ISPIXELFORMAT_INDEXED(src->format->format) ) {
return SDL_SoftStretch( src, srcrect, dst, dstrect );
} else {
return SDL_LowerBlit( src, srcrect, dst, dstrect );
}
}
SDL_COPY_MODULATE_COLOR
#define SDL_COPY_MODULATE_COLOR
Definition: SDL_blit.h:34
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_SoftStretch
#define SDL_SoftStretch
Definition: SDL_dynapi_overrides.h:474
SDL_ISPIXELFORMAT_INDEXED
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:133
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_COPY_MOD
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
SDL_LowerBlit
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:500
SDL_COPY_ADD
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_COPY_NEAREST
#define SDL_COPY_NEAREST
Definition: SDL_blit.h:40
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_COPY_MODULATE_ALPHA
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
SDL_PixelFormat::format
Uint32 format
Definition: SDL_pixels.h:301
SDL_COPY_BLEND
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91

int SDL_SaveBMP_RW | ( | SDL_Surface * | surface,
|  | SDL_RWops * | dst,
|  | int | freedst
| ) |  |

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

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 454 of file SDL_bmp.c.

References SDL_PixelFormat::Amask, 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, 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_InitFormat(), SDL_LIL_ENDIAN, SDL_LockSurface, SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR24, SDL_PIXELFORMAT_BGRA8888, SDL_RWclose, SDL_RWseek, SDL_RWtell, SDL_RWwrite, SDL_SetError, SDL_strcmp, SDL_TRUE, SDL_UnlockSurface, SDL_WriteLE16, SDL_WriteLE32, and SDL_Surface::w.

{
Sint64 fp_offset;
int i, pad;
SDL_Surface *surface;
Uint8 *bits;
/* The Win32 BMP file header (14 bytes) */
char magic[2] = { 'B', 'M' };
Uint32 bfSize;
Uint16 bfReserved1;
Uint16 bfReserved2;
Uint32 bfOffBits;
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
Uint32 biSize;
Sint32 biWidth;
Sint32 biHeight;
Uint16 biPlanes;
Uint16 biBitCount;
Uint32 biCompression;
Uint32 biSizeImage;
Sint32 biXPelsPerMeter;
Sint32 biYPelsPerMeter;
Uint32 biClrUsed;
Uint32 biClrImportant;
/* Make sure we have somewhere to save */
surface = NULL;
if (dst) {
SDL_bool save32bit = SDL_FALSE;
#ifdef SAVE_32BIT_BMP
/* We can save alpha information in a 32-bit BMP */
if (saveme->map->info.flags & SDL_COPY_COLORKEY ||
saveme->format->Amask) {
save32bit = SDL_TRUE;
}
#endif /* SAVE_32BIT_BMP */
if (saveme->format->palette && !save32bit) {
if (saveme->format->BitsPerPixel == 8) {
surface = saveme;
} else {
SDL_SetError("%d bpp BMP files not supported",
saveme->format->BitsPerPixel);
}
} else if ((saveme->format->BitsPerPixel == 24) &&
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
(saveme->format->Rmask == 0x00FF0000) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x000000FF)
#else
(saveme->format->Rmask == 0x000000FF) &&
(saveme->format->Gmask == 0x0000FF00) &&
(saveme->format->Bmask == 0x00FF0000)
#endif
) {
surface = saveme;
} else {
SDL_PixelFormat format;
/* If the surface has a colorkey or alpha channel we'll save a
32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */
if (save32bit) {
SDL_InitFormat(&format,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
SDL_PIXELFORMAT_ARGB8888
#else
SDL_PIXELFORMAT_BGRA8888
#endif
);
} else {
SDL_InitFormat(&format, SDL_PIXELFORMAT_BGR24);
}
surface = SDL_ConvertSurface(saveme, &format, 0);
if (!surface) {
SDL_SetError("Couldn't convert image to %d bpp",
format.BitsPerPixel);
}
}
} else {
/* Set no error here because it may overwrite a more useful message from
SDL_RWFromFile() if SDL_SaveBMP_RW() is called from SDL_SaveBMP(). */
return -1;
}
if (surface && (SDL_LockSurface(surface) == 0)) {
const int bw = surface->w * surface->format->BytesPerPixel;
/* Set the BMP file header values */
bfSize = 0; /* We'll write this when we're done */
bfReserved1 = 0;
bfReserved2 = 0;
bfOffBits = 0; /* We'll write this when we're done */
/* Write the BMP file header values */
fp_offset = SDL_RWtell(dst);
SDL_ClearError();
SDL_RWwrite(dst, magic, 2, 1);
SDL_WriteLE32(dst, bfSize);
SDL_WriteLE16(dst, bfReserved1);
SDL_WriteLE16(dst, bfReserved2);
SDL_WriteLE32(dst, bfOffBits);
/* Set the BMP info values */
biSize = 40;
biWidth = surface->w;
biHeight = surface->h;
biPlanes = 1;
biBitCount = surface->format->BitsPerPixel;
biCompression = BI_RGB;
biSizeImage = surface->h * surface->pitch;
biXPelsPerMeter = 0;
biYPelsPerMeter = 0;
if (surface->format->palette) {
biClrUsed = surface->format->palette->ncolors;
} else {
biClrUsed = 0;
}
biClrImportant = 0;
/* Write the BMP info values */
SDL_WriteLE32(dst, biSize);
SDL_WriteLE32(dst, biWidth);
SDL_WriteLE32(dst, biHeight);
SDL_WriteLE16(dst, biPlanes);
SDL_WriteLE16(dst, biBitCount);
SDL_WriteLE32(dst, biCompression);
SDL_WriteLE32(dst, biSizeImage);
SDL_WriteLE32(dst, biXPelsPerMeter);
SDL_WriteLE32(dst, biYPelsPerMeter);
SDL_WriteLE32(dst, biClrUsed);
SDL_WriteLE32(dst, biClrImportant);
/* Write the palette (in BGR color order) */
if (surface->format->palette) {
SDL_Color *colors;
int ncolors;
colors = surface->format->palette->colors;
ncolors = surface->format->palette->ncolors;
for (i = 0; i < ncolors; ++i) {
SDL_RWwrite(dst, &colors[i].b, 1, 1);
SDL_RWwrite(dst, &colors[i].g, 1, 1);
SDL_RWwrite(dst, &colors[i].r, 1, 1);
SDL_RWwrite(dst, &colors[i].a, 1, 1);
}
}
/* Write the bitmap offset */
bfOffBits = (Uint32)(SDL_RWtell(dst) - fp_offset);
if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfOffBits);
if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
/* Write the bitmap image upside down */
bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
while (bits > (Uint8 *) surface->pixels) {
bits -= surface->pitch;
if (SDL_RWwrite(dst, bits, 1, bw) != bw) {
SDL_Error(SDL_EFWRITE);
break;
}
if (pad) {
const Uint8 padbyte = 0;
for (i = 0; i < pad; ++i) {
SDL_RWwrite(dst, &padbyte, 1, 1);
}
}
}
/* Write the BMP file size */
bfSize = (Uint32)(SDL_RWtell(dst) - fp_offset);
if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
SDL_WriteLE32(dst, bfSize);
if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
}
/* Close it up.. */
SDL_UnlockSurface(surface);
if (surface != saveme) {
SDL_FreeSurface(surface);
}
}
if (freedst && dst) {
SDL_RWclose(dst);
}
return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
}
BI_RGB
#define BI_RGB
Definition: SDL_bmp.c:44
SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:247
SDL_ClearError
#define SDL_ClearError
Definition: SDL_dynapi_overrides.h:120
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:119
SDL_Color
Definition: SDL_pixels.h:279
SDL_UnlockSurface
#define SDL_UnlockSurface
Definition: SDL_dynapi_overrides.h:453
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_PIXELFORMAT_BGR24
Definition: SDL_pixels.h:232
SDL_RWwrite
#define SDL_RWwrite(ctx, ptr, size, n)
Definition: SDL_rwops.h:188
SDL_PixelFormat::BytesPerPixel
Uint8 BytesPerPixel
Definition: SDL_pixels.h:304
SDL_ConvertSurface
#define SDL_ConvertSurface
Definition: SDL_dynapi_overrides.h:467
SDL_EFSEEK
Definition: SDL_error.h:60
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_WriteLE16
#define SDL_WriteLE16
Definition: SDL_dynapi_overrides.h:370
SDL_LIL_ENDIAN
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
bits
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
Definition: SDL_opengl_glext.h:6176
SDL_Surface::w
int w
Definition: SDL_surface.h:73
SDL_Error
#define SDL_Error
Definition: SDL_dynapi_overrides.h:121
SDL_RWseek
#define SDL_RWseek(ctx, offset, whence)
Definition: SDL_rwops.h:185
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:126
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1109
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:450
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
SDL_PixelFormat::BitsPerPixel
Uint8 BitsPerPixel
Definition: SDL_pixels.h:303
SDL_Palette::ncolors
int ncolors
Definition: SDL_pixels.h:290
SDL_TRUE
Definition: SDL_stdinc.h:129
Sint32
int32_t Sint32
A signed 32-bit integer type.
Definition: SDL_stdinc.h:151
SDL_InitFormat
int SDL_InitFormat(SDL_PixelFormat *format, Uint32 pixel_format)
Definition: SDL_pixels.c:521
i
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:42
NULL
#define NULL
Definition: begin_code.h:143
SDL_Palette::colors
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_RWclose
#define SDL_RWclose(ctx)
Definition: SDL_rwops.h:189
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_LockSurface
#define SDL_LockSurface
Definition: SDL_dynapi_overrides.h:452
SDL_PixelFormat
Definition: SDL_pixels.h:299
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
SDL_WriteLE32
#define SDL_WriteLE32
Definition: SDL_dynapi_overrides.h:372
RW_SEEK_SET
#define RW_SEEK_SET
Definition: SDL_rwops.h:174
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:147
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:302
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:423
SDL_PIXELFORMAT_BGRA8888
Definition: SDL_pixels.h:256
Sint64
int64_t Sint64
A signed 64-bit integer type.
Definition: SDL_stdinc.h:160
SDL_EFWRITE
Definition: SDL_error.h:59
colors
static int colors[7]
Definition: testgesture.c:40
a
GLboolean GLboolean GLboolean GLboolean a
Definition: SDL_opengl_glext.h:1109
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
SDL_RWtell
#define SDL_RWtell(ctx)
Definition: SDL_rwops.h:186
SDL_BYTEORDER
#define SDL_BYTEORDER
Definition: SDL_config_pandora.h:36

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 457 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_CreateRGBSurface(), and SDL_CreateRGBSurfaceFrom().

{
SDL_Rect full_rect;
/* Don't do anything if there's no surface to act on */
if (!surface) {
return SDL_FALSE;
}
/* Set up the full surface rectangle */
full_rect.x = 0;
full_rect.y = 0;
full_rect.w = surface->w;
full_rect.h = surface->h;
/* Set the clipping rectangle */
if (!rect) {
surface->clip_rect = full_rect;
return SDL_TRUE;
}
return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect);
}
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_Surface::w
int w
Definition: SDL_surface.h:73
SDL_IntersectRect
#define SDL_IntersectRect
Definition: SDL_dynapi_overrides.h:300
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_TRUE
Definition: SDL_stdinc.h:129
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_Surface::clip_rect
SDL_Rect clip_rect
Definition: SDL_surface.h:85
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

int SDL_SetColorKey | ( | SDL_Surface * | surface,
|  | int | flag,
|  | Uint32 | key
| ) |  |

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

Parameters

  surface | The surface to update
  flag | Non-zero to enable colorkey and 0 to disable colorkey
  key | The 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 177 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().

{
int flags;
if (!surface) {
return SDL_InvalidParamError("surface");
}
if (surface->format->palette && key >= ((Uint32) surface->format->palette->ncolors)) {
return SDL_InvalidParamError("key");
}
if (flag & SDL_RLEACCEL) {
SDL_SetSurfaceRLE(surface, 1);
}
flags = surface->map->info.flags;
if (flag) {
surface->map->info.flags |= SDL_COPY_COLORKEY;
surface->map->info.colorkey = key;
if (surface->format->palette) {
surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_TRANSPARENT;
++surface->format->palette->version;
if (!surface->format->palette->version) {
surface->format->palette->version = 1;
}
}
} else {
if (surface->format->palette) {
surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_OPAQUE;
++surface->format->palette->version;
if (!surface->format->palette->version) {
surface->format->palette->version = 1;
}
}
surface->map->info.flags &= ~SDL_COPY_COLORKEY;
}
if (surface->map->info.flags != flags) {
SDL_InvalidateMap(surface->map);
}
return 0;
}
SDL_Palette::version
Uint32 version
Definition: SDL_pixels.h:292
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
SDL_SetSurfaceRLE
int SDL_SetSurfaceRLE(SDL_Surface *surface, int flag)
Sets the RLE acceleration hint for a surface.
Definition: SDL_surface.c:156
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_InvalidParamError
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
SDL_BlitInfo::colorkey
Uint32 colorkey
Definition: SDL_blit.h:69
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_ALPHA_TRANSPARENT
#define SDL_ALPHA_TRANSPARENT
Definition: SDL_pixels.h:46
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_Color::a
Uint8 a
Definition: SDL_pixels.h:284
SDL_Palette::ncolors
int ncolors
Definition: SDL_pixels.h:290
SDL_Palette::colors
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:302
SDL_ALPHA_OPAQUE
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:45
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
SDL_RLEACCEL
#define SDL_RLEACCEL
Definition: SDL_surface.h:54

int SDL_SetSurfaceAlphaMod | ( | SDL_Surface * | surface,
|  | Uint8 | alpha
| ) |  |

Set an additional alpha value used in blit operations.

Parameters

  surface | The surface to update.
  alpha | The 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 355 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().

{
int flags;
if (!surface) {
return -1;
}
surface->map->info.a = alpha;
flags = surface->map->info.flags;
if (alpha != 0xFF) {
surface->map->info.flags |= SDL_COPY_MODULATE_ALPHA;
} else {
surface->map->info.flags &= ~SDL_COPY_MODULATE_ALPHA;
}
if (surface->map->info.flags != flags) {
SDL_InvalidateMap(surface->map);
}
return 0;
}
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
alpha
GLfloat GLfloat GLfloat alpha
Definition: SDL_opengl_glext.h:412
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_COPY_MODULATE_ALPHA
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
SDL_BlitInfo::a
Uint8 a
Definition: SDL_blit.h:70

int SDL_SetSurfaceBlendMode | ( | SDL_Surface * | surface,
|  | SDL_BlendMode | blendMode
| ) |  |

Set the blend mode used for blit operations.

Parameters

  surface | The surface to update.
  blendMode | SDL_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 391 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_CreateRGBSurface().

{
int flags, status;
if (!surface) {
return -1;
}
status = 0;
flags = surface->map->info.flags;
surface->map->info.flags &=
~(SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD);
switch (blendMode) {
case SDL_BLENDMODE_NONE:
break;
case SDL_BLENDMODE_BLEND:
surface->map->info.flags |= SDL_COPY_BLEND;
break;
case SDL_BLENDMODE_ADD:
surface->map->info.flags |= SDL_COPY_ADD;
break;
case SDL_BLENDMODE_MOD:
surface->map->info.flags |= SDL_COPY_MOD;
break;
default:
status = SDL_Unsupported();
break;
}
if (surface->map->info.flags != flags) {
SDL_InvalidateMap(surface->map);
}
return status;
}
SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_COPY_MOD
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
SDL_COPY_ADD
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
SDL_BLENDMODE_MOD
Definition: SDL_blendmode.h:50
blendMode
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_BLENDMODE_ADD
Definition: SDL_blendmode.h:47
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_Unsupported
#define SDL_Unsupported()
Definition: SDL_error.h:53
SDL_COPY_BLEND
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44

int SDL_SetSurfaceColorMod | ( | SDL_Surface * | surface,
|  | Uint8 | r,
|  | Uint8 | g,
|  | Uint8 | b
| ) |  |

Set an additional color value used in blit operations.

Parameters

  surface | The surface to update.
  r | The red color value multiplied into blit operations.
  g | The green color value multiplied into blit operations.
  b | The 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 310 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().

{
int flags;
if (!surface) {
return -1;
}
surface->map->info.r = r;
surface->map->info.g = g;
surface->map->info.b = b;
flags = surface->map->info.flags;
if (r != 0xFF || g != 0xFF || b != 0xFF) {
surface->map->info.flags |= SDL_COPY_MODULATE_COLOR;
} else {
surface->map->info.flags &= ~SDL_COPY_MODULATE_COLOR;
}
if (surface->map->info.flags != flags) {
SDL_InvalidateMap(surface->map);
}
return 0;
}
SDL_BlitInfo::r
Uint8 r
Definition: SDL_blit.h:70
SDL_COPY_MODULATE_COLOR
#define SDL_COPY_MODULATE_COLOR
Definition: SDL_blit.h:34
SDL_BlitInfo::b
Uint8 b
Definition: SDL_blit.h:70
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_BlitInfo::g
Uint8 g
Definition: SDL_blit.h:70
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1109
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91

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

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

Referenced by SDL_CreateRGBSurface(), and SDL_FreeSurface().

{
if (!surface) {
return SDL_SetError("SDL_SetSurfacePalette() passed a NULL surface");
}
if (SDL_SetPixelFormatPalette(surface->format, palette) < 0) {
return -1;
}
SDL_InvalidateMap(surface->map);
return 0;
}
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_SetPixelFormatPalette
#define SDL_SetPixelFormatPalette
Definition: SDL_dynapi_overrides.h:289

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

{
int flags;
if (!surface) {
return -1;
}
flags = surface->map->info.flags;
if (flag) {
surface->map->info.flags |= SDL_COPY_RLE_DESIRED;
} else {
surface->map->info.flags &= ~SDL_COPY_RLE_DESIRED;
}
if (surface->map->info.flags != flags) {
SDL_InvalidateMap(surface->map);
}
return 0;
}
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_COPY_RLE_DESIRED
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91

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.

{
int src_locked;
int dst_locked;
int pos, inc;
int dst_maxrow;
int src_row, dst_row;
Uint8 *srcp = NULL;
Uint8 *dstp;
SDL_Rect full_src;
SDL_Rect full_dst;
#ifdef USE_ASM_STRETCH
SDL_bool use_asm = SDL_TRUE;
#ifdef __GNUC__
int u1, u2;
#endif
#endif /* USE_ASM_STRETCH */
const int bpp = dst->format->BytesPerPixel;
if (src->format->format != dst->format->format) {
return SDL_SetError("Only works with same format surfaces");
}
/* Verify the blit rectangles */
if (srcrect) {
if ((srcrect->x < 0) || (srcrect->y < 0) ||
((srcrect->x + srcrect->w) > src->w) ||
((srcrect->y + srcrect->h) > src->h)) {
return SDL_SetError("Invalid source blit rectangle");
}
} else {
full_src.x = 0;
full_src.y = 0;
full_src.w = src->w;
full_src.h = src->h;
srcrect = &full_src;
}
if (dstrect) {
if ((dstrect->x < 0) || (dstrect->y < 0) ||
((dstrect->x + dstrect->w) > dst->w) ||
((dstrect->y + dstrect->h) > dst->h)) {
return SDL_SetError("Invalid destination blit rectangle");
}
} else {
full_dst.x = 0;
full_dst.y = 0;
full_dst.w = dst->w;
full_dst.h = dst->h;
dstrect = &full_dst;
}
/* Lock the destination if it's in hardware */
dst_locked = 0;
if (SDL_MUSTLOCK(dst)) {
if (SDL_LockSurface(dst) < 0) {
return SDL_SetError("Unable to lock destination surface");
}
dst_locked = 1;
}
/* Lock the source if it's in hardware */
src_locked = 0;
if (SDL_MUSTLOCK(src)) {
if (SDL_LockSurface(src) < 0) {
if (dst_locked) {
SDL_UnlockSurface(dst);
}
return SDL_SetError("Unable to lock source surface");
}
src_locked = 1;
}
/* Set up the data... */
pos = 0x10000;
inc = (srcrect->h << 16) / dstrect->h;
src_row = srcrect->y;
dst_row = dstrect->y;
#ifdef USE_ASM_STRETCH
/* Write the opcodes for this stretch */
if ((bpp == 3) || (generate_rowbytes(srcrect->w, dstrect->w, bpp) < 0)) {
use_asm = SDL_FALSE;
}
#endif
/* Perform the stretch blit */
for (dst_maxrow = dst_row + dstrect->h; dst_row < dst_maxrow; ++dst_row) {
dstp = (Uint8 *) dst->pixels + (dst_row * dst->pitch)
+ (dstrect->x * bpp);
while (pos >= 0x10000L) {
srcp = (Uint8 *) src->pixels + (src_row * src->pitch)
+ (srcrect->x * bpp);
++src_row;
pos -= 0x10000L;
}
#ifdef USE_ASM_STRETCH
if (use_asm) {
#ifdef __GNUC__
__asm__ __volatile__("call *%4":"=&D"(u1), "=&S"(u2)
:"0"(dstp), "1"(srcp), "r"(copy_row)
:"memory");
#elif defined(_MSC_VER) || defined(__WATCOMC__)
/* *INDENT-OFF* */
{
void *code = copy_row;
__asm {
push edi
push esi
mov edi, dstp
mov esi, srcp
call dword ptr code
pop esi
pop edi
}
}
/* *INDENT-ON* */
#else
#error Need inline assembly for this compiler
#endif
} else
#endif
switch (bpp) {
case 1:
copy_row1(srcp, srcrect->w, dstp, dstrect->w);
break;
case 2:
copy_row2((Uint16 *) srcp, srcrect->w,
(Uint16 *) dstp, dstrect->w);
break;
case 3:
copy_row3(srcp, srcrect->w, dstp, dstrect->w);
break;
case 4:
copy_row4((Uint32 *) srcp, srcrect->w,
(Uint32 *) dstp, dstrect->w);
break;
}
pos += inc;
}
/* We need to unlock the surfaces if they're locked */
if (dst_locked) {
SDL_UnlockSurface(dst);
}
if (src_locked) {
SDL_UnlockSurface(src);
}
return (0);
}
SDL_UnlockSurface
#define SDL_UnlockSurface
Definition: SDL_dynapi_overrides.h:453
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_PixelFormat::BytesPerPixel
Uint8 BytesPerPixel
Definition: SDL_pixels.h:304
u1
GLfixed u1
Definition: SDL_opengl_glext.h:4558
SDL_Surface::w
int w
Definition: SDL_surface.h:73
copy_row3
static void copy_row3(Uint8 *src, int src_w, Uint8 *dst, int dst_w)
Definition: SDL_stretch.c:177
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:126
u2
GLfixed GLfixed u2
Definition: SDL_opengl_glext.h:4558
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
pop
#define pop
Definition: SDL_qsort.c:130
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_TRUE
Definition: SDL_stdinc.h:129
SDL_Rect::w
int w
Definition: SDL_rect.h:67
NULL
#define NULL
Definition: begin_code.h:143
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_LockSurface
#define SDL_LockSurface
Definition: SDL_dynapi_overrides.h:452
SDL_MUSTLOCK
#define SDL_MUSTLOCK(S)
Definition: SDL_surface.h:61
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_FALSE
Definition: SDL_stdinc.h:128
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:147
SDL_PixelFormat::format
Uint32 format
Definition: SDL_pixels.h:301
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

void SDL_UnlockSurface | ( | SDL_Surface * | surface | ) |

See also
  SDL_LockSurface()

Definition at line 824 of file SDL_surface.c.

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

Referenced by SDL_ConvertColorkeyToAlpha(), and SDL_FreeSurface().

{
/* Only perform an unlock if we are locked */
if (!surface->locked || (--surface->locked > 0)) {
return;
}
/* Update RLE encoded surface with new data */
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
surface->flags &= ~SDL_RLEACCEL; /* stop lying */
SDL_RLESurface(surface);
}
}
SDL_Surface::flags
Uint32 flags
Definition: SDL_surface.h:71
SDL_Surface::locked
int locked
Definition: SDL_surface.h:81
SDL_RLESurface
int SDL_RLESurface(SDL_Surface *surface)
Definition: SDL_RLEaccel.c:1403
SDL_RLEACCEL
#define SDL_RLEACCEL
Definition: SDL_surface.h:54

int SDL_UpperBlit | ( | SDL_Surface * | src,
|  | const SDL_Rect * | srcrect,
|  | SDL_Surface * | dst,
|  | SDL_Rect * | dstrect
| ) |  |

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

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

{
SDL_Rect fulldst;
int srcx, srcy, w, h;
/* Make sure the surfaces aren't locked */
if (!src || !dst) {
return SDL_SetError("SDL_UpperBlit: passed a NULL surface");
}
if (src->locked || dst->locked) {
return SDL_SetError("Surfaces must not be locked during blit");
}
/* If the destination rectangle is NULL, use the entire dest surface */
if (dstrect == NULL) {
fulldst.x = fulldst.y = 0;
fulldst.w = dst->w;
fulldst.h = dst->h;
dstrect = &fulldst;
}
/* clip the source rectangle to the source surface */
if (srcrect) {
int maxw, maxh;
srcx = srcrect->x;
w = srcrect->w;
if (srcx < 0) {
w += srcx;
dstrect->x -= srcx;
srcx = 0;
}
maxw = src->w - srcx;
if (maxw < w)
w = maxw;
srcy = srcrect->y;
h = srcrect->h;
if (srcy < 0) {
h += srcy;
dstrect->y -= srcy;
srcy = 0;
}
maxh = src->h - srcy;
if (maxh < h)
h = maxh;
} else {
srcx = srcy = 0;
w = src->w;
h = src->h;
}
/* clip the destination rectangle against the clip rectangle */
{
SDL_Rect *clip = &dst->clip_rect;
int dx, dy;
dx = clip->x - dstrect->x;
if (dx > 0) {
w -= dx;
dstrect->x += dx;
srcx += dx;
}
dx = dstrect->x + w - clip->x - clip->w;
if (dx > 0)
w -= dx;
dy = clip->y - dstrect->y;
if (dy > 0) {
h -= dy;
dstrect->y += dy;
srcy += dy;
}
dy = dstrect->y + h - clip->y - clip->h;
if (dy > 0)
h -= dy;
}
/* Switch back to a fast blit if we were previously stretching */
if (src->map->info.flags & SDL_COPY_NEAREST) {
src->map->info.flags &= ~SDL_COPY_NEAREST;
SDL_InvalidateMap(src->map);
}
if (w > 0 && h > 0) {
SDL_Rect sr;
sr.x = srcx;
sr.y = srcy;
sr.w = dstrect->w = w;
sr.h = dstrect->h = h;
return SDL_LowerBlit(src, &sr, dst, dstrect);
}
dstrect->w = dstrect->h = 0;
return 0;
}
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_Surface::w
int w
Definition: SDL_surface.h:73
SDL_LowerBlit
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:500
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
SDL_COPY_NEAREST
#define SDL_COPY_NEAREST
Definition: SDL_blit.h:40
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_Surface::locked
int locked
Definition: SDL_surface.h:81
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_Surface::clip_rect
SDL_Rect clip_rect
Definition: SDL_surface.h:85
NULL
#define NULL
Definition: begin_code.h:143
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_Rect::h
int h
Definition: SDL_rect.h:67
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
SDL_Rect::y
int y
Definition: SDL_rect.h:66
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

int SDL_UpperBlitScaled | ( | SDL_Surface * | src,
|  | const SDL_Rect * | srcrect,
|  | SDL_Surface * | dst,
|  | SDL_Rect * | dstrect
| ) |  |

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

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

{
double src_x0, src_y0, src_x1, src_y1;
double dst_x0, dst_y0, dst_x1, dst_y1;
SDL_Rect final_src, final_dst;
double scaling_w, scaling_h;
int src_w, src_h;
int dst_w, dst_h;
/* Make sure the surfaces aren't locked */
if (!src || !dst) {
return SDL_SetError("SDL_UpperBlitScaled: passed a NULL surface");
}
if (src->locked || dst->locked) {
return SDL_SetError("Surfaces must not be locked during blit");
}
if (NULL == srcrect) {
src_w = src->w;
src_h = src->h;
} else {
src_w = srcrect->w;
src_h = srcrect->h;
}
if (NULL == dstrect) {
dst_w = dst->w;
dst_h = dst->h;
} else {
dst_w = dstrect->w;
dst_h = dstrect->h;
}
if (dst_w == src_w && dst_h == src_h) {
/* No scaling, defer to regular blit */
return SDL_BlitSurface(src, srcrect, dst, dstrect);
}
scaling_w = (double)dst_w / src_w;
scaling_h = (double)dst_h / src_h;
if (NULL == dstrect) {
dst_x0 = 0;
dst_y0 = 0;
dst_x1 = dst_w - 1;
dst_y1 = dst_h - 1;
} else {
dst_x0 = dstrect->x;
dst_y0 = dstrect->y;
dst_x1 = dst_x0 + dst_w - 1;
dst_y1 = dst_y0 + dst_h - 1;
}
if (NULL == srcrect) {
src_x0 = 0;
src_y0 = 0;
src_x1 = src_w - 1;
src_y1 = src_h - 1;
} else {
src_x0 = srcrect->x;
src_y0 = srcrect->y;
src_x1 = src_x0 + src_w - 1;
src_y1 = src_y0 + src_h - 1;
/* Clip source rectangle to the source surface */
if (src_x0 < 0) {
dst_x0 -= src_x0 * scaling_w;
src_x0 = 0;
}
if (src_x1 >= src->w) {
dst_x1 -= (src_x1 - src->w + 1) * scaling_w;
src_x1 = src->w - 1;
}
if (src_y0 < 0) {
dst_y0 -= src_y0 * scaling_h;
src_y0 = 0;
}
if (src_y1 >= src->h) {
dst_y1 -= (src_y1 - src->h + 1) * scaling_h;
src_y1 = src->h - 1;
}
}
/* Clip destination rectangle to the clip rectangle */
/* Translate to clip space for easier calculations */
dst_x0 -= dst->clip_rect.x;
dst_x1 -= dst->clip_rect.x;
dst_y0 -= dst->clip_rect.y;
dst_y1 -= dst->clip_rect.y;
if (dst_x0 < 0) {
src_x0 -= dst_x0 / scaling_w;
dst_x0 = 0;
}
if (dst_x1 >= dst->clip_rect.w) {
src_x1 -= (dst_x1 - dst->clip_rect.w + 1) / scaling_w;
dst_x1 = dst->clip_rect.w - 1;
}
if (dst_y0 < 0) {
src_y0 -= dst_y0 / scaling_h;
dst_y0 = 0;
}
if (dst_y1 >= dst->clip_rect.h) {
src_y1 -= (dst_y1 - dst->clip_rect.h + 1) / scaling_h;
dst_y1 = dst->clip_rect.h - 1;
}
/* Translate back to surface coordinates */
dst_x0 += dst->clip_rect.x;
dst_x1 += dst->clip_rect.x;
dst_y0 += dst->clip_rect.y;
dst_y1 += dst->clip_rect.y;
final_src.x = (int)SDL_floor(src_x0 + 0.5);
final_src.y = (int)SDL_floor(src_y0 + 0.5);
final_src.w = (int)SDL_floor(src_x1 - src_x0 + 1.5);
final_src.h = (int)SDL_floor(src_y1 - src_y0 + 1.5);
final_dst.x = (int)SDL_floor(dst_x0 + 0.5);
final_dst.y = (int)SDL_floor(dst_y0 + 0.5);
final_dst.w = (int)SDL_floor(dst_x1 - dst_x0 + 1.5);
final_dst.h = (int)SDL_floor(dst_y1 - dst_y0 + 1.5);
if (final_dst.w < 0)
final_dst.w = 0;
if (final_dst.h < 0)
final_dst.h = 0;
if (dstrect)
*dstrect = final_dst;
if (final_dst.w == 0 || final_dst.h == 0 ||
final_src.w <= 0 || final_src.h <= 0) {
/* No-op. */
return 0;
}
return SDL_LowerBlitScaled(src, &final_src, dst, &final_dst);
}
SDL_Surface::h
int h
Definition: SDL_surface.h:73
SDL_BlitSurface
#define SDL_BlitSurface
Definition: SDL_surface.h:447
SDL_Surface::w
int w
Definition: SDL_surface.h:73
SDL_floor
#define SDL_floor
Definition: SDL_dynapi_overrides.h:437
SDL_Surface::locked
int locked
Definition: SDL_surface.h:81
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_Surface::clip_rect
SDL_Rect clip_rect
Definition: SDL_surface.h:85
NULL
#define NULL
Definition: begin_code.h:143
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:36
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_LowerBlitScaled
int SDL_LowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:776
SDL_Rect::y
int y
Definition: SDL_rect.h:66
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64