SDL_surface.c File Reference

#include "../SDL_internal.h"
#include "SDL_video.h"
#include "SDL_sysvideo.h"
#include "SDL_blit.h"
#include "SDL_RLEaccel_c.h"
#include "SDL_pixels_c.h"
#include "SDL_yuv_c.h"

Include dependency graph for SDL_surface.c:

Go to the source code of this file.

Functions
	SDL_COMPILE_TIME_ASSERT (surface_size_assumptions, sizeof(int)==sizeof(Sint32) &&sizeof(size_t) >=sizeof(Sint32))
static Sint64	SDL_CalculatePitch (Uint32 format, int width)
SDL_Surface *	SDL_CreateRGBSurfaceWithFormat (Uint32 flags, int width, int height, int depth, Uint32 format)
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)
SDL_Surface *	SDL_CreateRGBSurfaceWithFormatFrom (void *pixels, int width, int height, int depth, int pitch, Uint32 format)
int	SDL_SetSurfacePalette (SDL_Surface *surface, SDL_Palette *palette)
	Set the palette used by a surface. More...
int	SDL_SetSurfaceRLE (SDL_Surface *surface, int flag)
	Sets the RLE acceleration hint for a surface. More...
SDL_bool	SDL_HasSurfaceRLE (SDL_Surface *surface)
	Returns whether the surface is RLE enabled. More...
int	SDL_SetColorKey (SDL_Surface *surface, int flag, Uint32 key)
	Sets the color key (transparent pixel) in a blittable surface. More...
SDL_bool	SDL_HasColorKey (SDL_Surface *surface)
	Returns whether the surface has a color key. More...
int	SDL_GetColorKey (SDL_Surface *surface, Uint32 *key)
	Gets the color key (transparent pixel) in a blittable surface. More...
static void	SDL_ConvertColorkeyToAlpha (SDL_Surface *surface, SDL_bool ignore_alpha)
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)
int	SDL_LowerBlit (SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
int	SDL_UpperBlit (SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
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)
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_DuplicateSurface (SDL_Surface *surface)
SDL_Surface *	SDL_ConvertSurface (SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
SDL_Surface *	SDL_ConvertSurfaceFormat (SDL_Surface *surface, Uint32 pixel_format, Uint32 flags)
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)
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...
void	SDL_FreeSurface (SDL_Surface *surface)

Function Documentation

SDL_CalculatePitch()

static Sint64 SDL_CalculatePitch ( Uint32  format, int  width  )

static

Definition at line 41 of file SDL_surface.c.

{
    Sint64 pitch;
 
    if (SDL_ISPIXELFORMAT_FOURCC(format) || SDL_BITSPERPIXEL(format) >= 8) {
        pitch = ((Sint64)width * SDL_BYTESPERPIXEL(format));
    } else {
        pitch = (((Sint64)width * SDL_BITSPERPIXEL(format)) + 7) / 8;
    }
    pitch = (pitch + 3) & ~3;   /* 4-byte aligning for speed */
    return pitch;
}

References SDL_BITSPERPIXEL, SDL_BYTESPERPIXEL, and SDL_ISPIXELFORMAT_FOURCC.

Referenced by SDL_CreateRGBSurfaceWithFormat().

SDL_COMPILE_TIME_ASSERT()

SDL_COMPILE_TIME_ASSERT	(	surface_size_assumptions	,
		sizeof(int)	= =sizeof(Sint32) &&sizeof(size_t) >=sizeof(Sint32)
	)

SDL_ConvertColorkeyToAlpha()

static void SDL_ConvertColorkeyToAlpha ( SDL_Surface *  surface, SDL_bool  ignore_alpha  )

static

Definition at line 330 of file SDL_surface.c.

{
    int x, y;
 
    if (!surface) {
        return;
    }
 
    if (!(surface->map->info.flags & SDL_COPY_COLORKEY) ||
        !surface->format->Amask) {
        return;
    }
 
    SDL_LockSurface(surface);
 
    switch (surface->format->BytesPerPixel) {
    case 2:
        {
            Uint16 *row, *spot;
            Uint16 ckey = (Uint16) surface->map->info.colorkey;
            Uint16 mask = (Uint16) (~surface->format->Amask);
 
            /* Ignore, or not, alpha in colorkey comparison */
            if (ignore_alpha) {
                ckey &= mask;
                row = (Uint16 *) surface->pixels;
                for (y = surface->h; y--;) {
                    spot = row;
                    for (x = surface->w; x--;) {
                        if ((*spot & mask) == ckey) {
                            *spot &= mask;
                        }
                        ++spot;
                    }
                    row += surface->pitch / 2;
                }
            } else {
                row = (Uint16 *) surface->pixels;
                for (y = surface->h; y--;) {
                    spot = row;
                    for (x = surface->w; x--;) {
                        if (*spot == ckey) {
                            *spot &= mask;
                        }
                        ++spot;
                    }
                    row += surface->pitch / 2;
                }
            }
        }
        break;
    case 3:
        /* FIXME */
        break;
    case 4:
        {
            Uint32 *row, *spot;
            Uint32 ckey = surface->map->info.colorkey;
            Uint32 mask = ~surface->format->Amask;
 
            /* Ignore, or not, alpha in colorkey comparison */
            if (ignore_alpha) {
                ckey &= mask;
                row = (Uint32 *) surface->pixels;
                for (y = surface->h; y--;) {
                    spot = row;
                    for (x = surface->w; x--;) {
                        if ((*spot & mask) == ckey) {
                            *spot &= mask;
                        }
                        ++spot;
                    }
                    row += surface->pitch / 4;
                }
            } else {
                row = (Uint32 *) surface->pixels;
                for (y = surface->h; y--;) {
                    spot = row;
                    for (x = surface->w; x--;) {
                        if (*spot == ckey) {
                            *spot &= mask;
                        }
                        ++spot;
                    }
                    row += surface->pitch / 4;
                }
            }
        }
        break;
    }
 
    SDL_UnlockSurface(surface);
 
    SDL_SetColorKey(surface, 0, 0);
    SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);
}

References SDL_BLENDMODE_BLEND, SDL_COPY_COLORKEY, SDL_LockSurface(), SDL_SetColorKey(), SDL_SetSurfaceBlendMode(), and SDL_UnlockSurface().

Referenced by SDL_ConvertSurface().

SDL_ConvertPixels()

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

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

Returns

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

Definition at line 1267 of file SDL_surface.c.

{
    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;
    int ret;
 
    /* 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");
    }
 
#if SDL_HAVE_YUV
    if (SDL_ISPIXELFORMAT_FOURCC(src_format) && SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
        return SDL_ConvertPixels_YUV_to_YUV(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
    } else if (SDL_ISPIXELFORMAT_FOURCC(src_format)) {
        return SDL_ConvertPixels_YUV_to_RGB(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
    } else if (SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
        return SDL_ConvertPixels_RGB_to_YUV(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
    }
#else
    if (SDL_ISPIXELFORMAT_FOURCC(src_format) || SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
        SDL_SetError("SDL not built with YUV support");
        return -1;
    }
#endif
 
    /* Fast path for same format copy */
    if (src_format == dst_format) {
        int i;
        const int bpp = SDL_BYTESPERPIXEL(src_format);
        width *= bpp;
        for (i = height; i--;) {
            SDL_memcpy(dst, src, width);
            src = (const 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;
    ret = SDL_LowerBlit(&src_surface, &rect, &dst_surface, &rect);
 
    /* Free blitmap reference, after blitting between stack'ed surfaces */
    SDL_InvalidateMap(src_surface.map);
 
    return ret;
}

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

SDL_ConvertSurface()

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

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

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

Definition at line 979 of file SDL_surface.c.

{
    SDL_Surface *convert;
    Uint32 copy_flags;
    SDL_Color copy_color;
    SDL_Rect bounds;
    int ret;
    SDL_bool palette_ck_transform = SDL_FALSE;
    int palette_ck_value = 0;
    SDL_bool palette_has_alpha = SDL_FALSE;
    Uint8 *palette_saved_alpha = NULL;
 
    if (!surface) {
        SDL_InvalidParamError("surface");
        return NULL;
    }
    if (!format) {
        SDL_InvalidParamError("format");
        return NULL;
    }
 
    /* 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 = (copy_flags & (SDL_COPY_RLE_COLORKEY | SDL_COPY_RLE_ALPHAKEY));
    SDL_InvalidateMap(surface->map);
 
    /* Copy over the image data */
    bounds.x = 0;
    bounds.y = 0;
    bounds.w = surface->w;
    bounds.h = surface->h;
 
    /* Source surface has a palette with no real alpha (0 or OPAQUE).
     * Destination format has alpha.
     * -> set alpha channel to be opaque */
    if (surface->format->palette && format->Amask) {
        SDL_bool set_opaque = SDL_FALSE;
 
        SDL_bool is_opaque, has_alpha_channel;
        SDL_DetectPalette(surface->format->palette, &is_opaque, &has_alpha_channel);
 
        if (is_opaque) {
            if (!has_alpha_channel) {
                set_opaque = SDL_TRUE;
            }
        } else {
            palette_has_alpha = SDL_TRUE;
        }
 
        /* Set opaque and backup palette alpha values */
        if (set_opaque) {
            int i;
            palette_saved_alpha = SDL_stack_alloc(Uint8, surface->format->palette->ncolors);
            for (i = 0; i < surface->format->palette->ncolors; i++) {
                palette_saved_alpha[i] = surface->format->palette->colors[i].a;
                surface->format->palette->colors[i].a = SDL_ALPHA_OPAQUE;
            }
        }
    }
 
    /* Transform colorkey to alpha. for cases where source palette has duplicate values, and colorkey is one of them */
    if (copy_flags & SDL_COPY_COLORKEY) {
        if (surface->format->palette && !format->palette) {
            palette_ck_transform = SDL_TRUE;
            palette_has_alpha = SDL_TRUE;
            palette_ck_value = surface->format->palette->colors[surface->map->info.colorkey].a;
            surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_TRANSPARENT;
        }
    }
 
    ret = SDL_LowerBlit(surface, &bounds, convert, &bounds);
 
    /* Restore colorkey alpha value */
    if (palette_ck_transform) {
        surface->format->palette->colors[surface->map->info.colorkey].a = palette_ck_value;
    }
 
    /* Restore palette alpha values */
    if (palette_saved_alpha) {
        int i;
        for (i = 0; i < surface->format->palette->ncolors; i++) {
            surface->format->palette->colors[i].a = palette_saved_alpha[i];
        }
        SDL_stack_free(palette_saved_alpha);
    }
 
    /* 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);
 
    /* SDL_LowerBlit failed, and so the conversion */
    if (ret < 0) {
        SDL_FreeSurface(convert);
        return NULL;
    }
 
    if (copy_flags & SDL_COPY_COLORKEY) {
        SDL_bool set_colorkey_by_color = SDL_FALSE;
        SDL_bool convert_colorkey = SDL_TRUE;
 
        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->palette) {
                if (format->Amask) {
                    /* No need to add the colorkey, transparency is in the alpha channel*/
                } else {
                    /* Only set the colorkey information */
                    set_colorkey_by_color = SDL_TRUE;
                    convert_colorkey = SDL_FALSE;
                }
            } else {
                set_colorkey_by_color = SDL_TRUE;
            }
        } else {
            set_colorkey_by_color = SDL_TRUE;
        }
 
        if (set_colorkey_by_color) {
            SDL_Surface *tmp;
            SDL_Surface *tmp2;
            int converted_colorkey = 0;
 
            /* Create a dummy surface to get the colorkey converted */
            tmp = SDL_CreateRGBSurface(0, 1, 1,
                                   surface->format->BitsPerPixel, surface->format->Rmask,
                                   surface->format->Gmask, surface->format->Bmask,
                                   surface->format->Amask);
 
            /* Share the palette, if any */
            if (surface->format->palette) {
                SDL_SetSurfacePalette(tmp, surface->format->palette);
            }
 
            SDL_FillRect(tmp, NULL, surface->map->info.colorkey);
 
            tmp->map->info.flags &= ~SDL_COPY_COLORKEY;
 
            /* Convertion of the colorkey */
            tmp2 = SDL_ConvertSurface(tmp, format, 0);
 
            /* Get the converted colorkey */
            SDL_memcpy(&converted_colorkey, tmp2->pixels, tmp2->format->BytesPerPixel);
 
            SDL_FreeSurface(tmp);
            SDL_FreeSurface(tmp2);
 
            /* Set the converted colorkey on the new surface */
            SDL_SetColorKey(convert, 1, converted_colorkey);
 
            /* This is needed when converting for 3D texture upload */
            if (convert_colorkey) {
                SDL_ConvertColorkeyToAlpha(convert, SDL_TRUE);
            }
        }
    }
    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) ||
        (palette_has_alpha && format->Amask) ||
        (copy_flags & 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);
}

References SDL_Color::a, SDL_BlitInfo::a, SDL_Color::b, SDL_BlitInfo::b, SDL_PixelFormat::BytesPerPixel, SDL_Surface::clip_rect, SDL_BlitInfo::colorkey, SDL_Palette::colors, SDL_BlitInfo::flags, SDL_Surface::format, SDL_Color::g, SDL_BlitInfo::g, SDL_Rect::h, i, SDL_BlitMap::info, SDL_Surface::map, SDL_Palette::ncolors, NULL, SDL_PixelFormat::palette, SDL_Surface::pixels, SDL_Color::r, SDL_BlitInfo::r, SDL_ALPHA_OPAQUE, SDL_ALPHA_TRANSPARENT, SDL_BLENDMODE_BLEND, SDL_ConvertColorkeyToAlpha(), SDL_ConvertSurface(), 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_DetectPalette(), SDL_FALSE, SDL_FillRect, SDL_FreeSurface(), SDL_InvalidateMap(), SDL_InvalidParamError, SDL_LowerBlit(), SDL_memcmp, SDL_memcpy, SDL_RLEACCEL, SDL_SetClipRect(), SDL_SetColorKey(), SDL_SetError, SDL_SetSurfaceBlendMode(), SDL_SetSurfacePalette(), SDL_SetSurfaceRLE(), SDL_stack_alloc, SDL_stack_free, SDL_TRUE, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_ConvertSurface(), SDL_ConvertSurfaceFormat(), and SDL_DuplicateSurface().

SDL_ConvertSurfaceFormat()

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

Definition at line 1211 of file SDL_surface.c.

{
    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;
}

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

SDL_CreateRGBSurface()

SDL_Surface* SDL_CreateRGBSurface	(	Uint32	flags,
		int	width,
		int	height,
		int	depth,
		Uint32	Rmask,
		Uint32	Gmask,
		Uint32	Bmask,
		Uint32	Amask
	)

Allocate and free an RGB surface.

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

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

Parameters

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

{
    Uint32 format;
 
    /* Get the pixel format */
    format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
    if (format == SDL_PIXELFORMAT_UNKNOWN) {
        SDL_SetError("Unknown pixel format");
        return NULL;
    }
 
    return SDL_CreateRGBSurfaceWithFormat(flags, width, height, depth, format);
}

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

Referenced by SDL_ConvertSurface(), and SDL_CreateRGBSurfaceFrom().

SDL_CreateRGBSurfaceFrom()

SDL_Surface* SDL_CreateRGBSurfaceFrom	(	void *	pixels,
		int	width,
		int	height,
		int	depth,
		int	pitch,
		Uint32	Rmask,
		Uint32	Gmask,
		Uint32	Bmask,
		Uint32	Amask
	)

Definition at line 175 of file SDL_surface.c.

{
    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;
}

References NULL, SDL_CreateRGBSurface(), SDL_PREALLOC, and SDL_SetClipRect().

SDL_CreateRGBSurfaceWithFormat()

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

Definition at line 59 of file SDL_surface.c.

{
    Sint64 pitch;
    SDL_Surface *surface;
 
    /* The flags are no longer used, make the compiler happy */
    (void)flags;
 
    pitch = SDL_CalculatePitch(format, width);
    if (pitch < 0 || pitch > SDL_MAX_SINT32) {
        /* Overflow... */
        SDL_OutOfMemory();
        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 = (int)pitch;
    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) {
        /* Assumptions checked in surface_size_assumptions assert above */
        Sint64 size = ((Sint64)surface->h * surface->pitch);
        if (size < 0 || size > SDL_MAX_SINT32) {
            /* Overflow... */
            SDL_FreeSurface(surface);
            SDL_OutOfMemory();
            return NULL;
        }
 
        surface->pixels = SDL_SIMDAlloc((size_t)size);
        if (!surface->pixels) {
            SDL_FreeSurface(surface);
            SDL_OutOfMemory();
            return NULL;
        }
        surface->flags |= SDL_SIMD_ALIGNED;
        /* 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 (surface->format->Amask) {
        SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);
    }
 
    /* The surface is ready to go */
    surface->refcount = 1;
    return surface;
}

References SDL_Color::b, SDL_Palette::colors, SDL_Color::g, int(), SDL_Palette::ncolors, NULL, SDL_Color::r, SDL_AllocBlitMap(), SDL_AllocFormat, SDL_AllocPalette, SDL_BLENDMODE_BLEND, SDL_CalculatePitch(), SDL_calloc, SDL_FreePalette, SDL_FreeSurface(), SDL_ISPIXELFORMAT_INDEXED, SDL_MAX_SINT32, SDL_memset, SDL_OutOfMemory, SDL_SetClipRect(), SDL_SetSurfaceBlendMode(), SDL_SetSurfacePalette(), SDL_SIMD_ALIGNED, SDL_SIMDAlloc, and void.

Referenced by SDL_CreateRGBSurface(), and SDL_CreateRGBSurfaceWithFormatFrom().

SDL_CreateRGBSurfaceWithFormatFrom()

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

Definition at line 199 of file SDL_surface.c.

{
    SDL_Surface *surface;
 
    surface = SDL_CreateRGBSurfaceWithFormat(0, 0, 0, depth, format);
    if (surface != NULL) {
        surface->flags |= SDL_PREALLOC;
        surface->pixels = pixels;
        surface->w = width;
        surface->h = height;
        surface->pitch = pitch;
        SDL_SetClipRect(surface, NULL);
    }
    return surface;
}

References NULL, SDL_CreateRGBSurfaceWithFormat(), SDL_PREALLOC, and SDL_SetClipRect().

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  )

static

Definition at line 1229 of file SDL_surface.c.

{
    if (SDL_ISPIXELFORMAT_INDEXED(pixel_format)) {
        SDL_SetError("Indexed pixel formats not supported");
        return SDL_FALSE;
    }
    if (SDL_InitFormat(format, pixel_format) < 0) {
        return SDL_FALSE;
    }
 
    SDL_zerop(surface);
    surface->flags = SDL_PREALLOC;
    surface->format = format;
    surface->pixels = pixels;
    surface->w = width;
    surface->h = height;
    surface->pitch = pitch;
    /* We don't actually need to set up the clip rect for our purposes */
    /* SDL_SetClipRect(surface, NULL); */
 
    /* Allocate an empty mapping */
    SDL_zerop(blitmap);
    blitmap->info.r = 0xFF;
    blitmap->info.g = 0xFF;
    blitmap->info.b = 0xFF;
    blitmap->info.a = 0xFF;
    surface->map = blitmap;
 
    /* The surface is ready to go */
    surface->refcount = 1;
    return SDL_TRUE;
}

References SDL_BlitInfo::a, SDL_BlitInfo::b, SDL_BlitInfo::g, SDL_BlitMap::info, pixel_format, SDL_BlitInfo::r, SDL_FALSE, SDL_InitFormat(), SDL_ISPIXELFORMAT_INDEXED, SDL_PREALLOC, SDL_SetError, SDL_TRUE, and SDL_zerop.

Referenced by SDL_ConvertPixels().

SDL_DuplicateSurface()

SDL_Surface* SDL_DuplicateSurface

(

SDL_Surface *

surface

)

Definition at line 970 of file SDL_surface.c.

{
    return SDL_ConvertSurface(surface, surface->format, surface->flags);
}

References SDL_ConvertSurface().

SDL_FreeSurface()

void SDL_FreeSurface

(

SDL_Surface *

surface

)

Definition at line 1341 of file SDL_surface.c.

{
    if (surface == NULL) {
        return;
    }
    if (surface->flags & SDL_DONTFREE) {
        return;
    }
    SDL_InvalidateMap(surface->map);
 
    SDL_InvalidateAllBlitMap(surface);
 
    if (--surface->refcount > 0) {
        return;
    }
    while (surface->locked > 0) {
        SDL_UnlockSurface(surface);
    }
#if SDL_HAVE_RLE
    if (surface->flags & SDL_RLEACCEL) {
        SDL_UnRLESurface(surface, 0);
    }
#endif
    if (surface->format) {
        SDL_SetSurfacePalette(surface, NULL);
        SDL_FreeFormat(surface->format);
        surface->format = NULL;
    }
    if (surface->flags & SDL_PREALLOC) {
        /* Don't free */
    } else if (surface->flags & SDL_SIMD_ALIGNED) {
        /* Free aligned */
        SDL_SIMDFree(surface->pixels);
    } else {
        /* Normal */
        SDL_free(surface->pixels);
    }
    if (surface->map) {
        SDL_FreeBlitMap(surface->map);
    }
    SDL_free(surface);
}

References NULL, SDL_DONTFREE, SDL_free, SDL_FreeBlitMap(), SDL_FreeFormat, SDL_InvalidateAllBlitMap(), SDL_InvalidateMap(), SDL_PREALLOC, SDL_RLEACCEL, SDL_SetSurfacePalette(), SDL_SIMD_ALIGNED, SDL_SIMDFree, SDL_UnlockSurface(), and SDL_UnRLESurface().

Referenced by SDL_ConvertSurface(), and SDL_CreateRGBSurfaceWithFormat().

SDL_GetClipRect()

void SDL_GetClipRect	(	SDL_Surface *	surface,
		SDL_Rect *	rect
	)

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

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

Definition at line 605 of file SDL_surface.c.

{
    if (surface && rect) {
        *rect = surface->clip_rect;
    }
}

References rect.

SDL_GetColorKey()

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

{
    if (!surface) {
        return SDL_InvalidParamError("surface");
    }
 
    if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
        return SDL_SetError("Surface doesn't have a colorkey");
    }
 
    if (key) {
        *key = surface->map->info.colorkey;
    }
    return 0;
}

References SDL_COPY_COLORKEY, SDL_InvalidParamError, and SDL_SetError.

SDL_GetSurfaceAlphaMod()

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

{
    if (!surface) {
        return -1;
    }
 
    if (alpha) {
        *alpha = surface->map->info.a;
    }
    return 0;
}

SDL_GetSurfaceBlendMode()

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

{
    if (!surface) {
        return -1;
    }
 
    if (!blendMode) {
        return 0;
    }
 
    switch (surface->map->
            info.flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_MUL)) {
    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;
    case SDL_COPY_MUL:
        *blendMode = SDL_BLENDMODE_MUL;
        break;
    default:
        *blendMode = SDL_BLENDMODE_NONE;
        break;
    }
    return 0;
}

References blendMode, SDL_BLENDMODE_ADD, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_MOD, SDL_BLENDMODE_MUL, SDL_BLENDMODE_NONE, SDL_COPY_ADD, SDL_COPY_BLEND, SDL_COPY_MOD, and SDL_COPY_MUL.

SDL_GetSurfaceColorMod()

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

{
    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_HasColorKey()

SDL_bool SDL_HasColorKey

(

SDL_Surface *

surface

)

Returns whether the surface has a color key.

Returns

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

Definition at line 298 of file SDL_surface.c.

{
    if (!surface) {
        return SDL_FALSE;
    }
 
    if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
        return SDL_FALSE;
    }
 
    return SDL_TRUE;
}

References SDL_COPY_COLORKEY, SDL_FALSE, and SDL_TRUE.

SDL_HasSurfaceRLE()

SDL_bool SDL_HasSurfaceRLE

(

SDL_Surface *

surface

)

Returns whether the surface is RLE enabled.

Returns

SDL_TRUE if the surface is RLE enabled, or SDL_FALSE if the surface is NULL or not RLE enabled

Definition at line 253 of file SDL_surface.c.

{
    if (!surface) {
        return SDL_FALSE;
    }
 
    if (!(surface->map->info.flags & SDL_COPY_RLE_DESIRED)) {
        return SDL_FALSE;
    }
 
    return SDL_TRUE;
}

References SDL_COPY_RLE_DESIRED, SDL_FALSE, and SDL_TRUE.

SDL_LockSurface()

int SDL_LockSurface

(

SDL_Surface *

surface

)

Sets up a surface for directly accessing the pixels.

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

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

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

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

See also

SDL_UnlockSurface()

Definition at line 927 of file SDL_surface.c.

{
    if (!surface->locked) {
#if SDL_HAVE_RLE
        /* Perform the lock */
        if (surface->flags & SDL_RLEACCEL) {
            SDL_UnRLESurface(surface, 1);
            surface->flags |= SDL_RLEACCEL;     /* save accel'd state */
        }
#endif
    }
 
    /* Increment the surface lock count, for recursive locks */
    ++surface->locked;
 
    /* Ready to go.. */
    return (0);
}

References SDL_RLEACCEL, and SDL_UnRLESurface().

Referenced by SDL_ConvertColorkeyToAlpha().

SDL_LowerBlit()

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

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

Definition at line 624 of file SDL_surface.c.

{
    /* 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));
}

References SDL_MapSurface().

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

SDL_LowerBlitScaled()

int SDL_LowerBlitScaled	(	SDL_Surface *	src,
		SDL_Rect *	srcrect,
		SDL_Surface *	dst,
		SDL_Rect *	dstrect
	)

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

Definition at line 900 of file SDL_surface.c.

{
    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_MUL |
        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 );
    }
}

References SDL_COPY_ADD, SDL_COPY_BLEND, SDL_COPY_COLORKEY, SDL_COPY_MOD, SDL_COPY_MODULATE_ALPHA, SDL_COPY_MODULATE_COLOR, SDL_COPY_MUL, SDL_COPY_NEAREST, SDL_InvalidateMap(), SDL_ISPIXELFORMAT_INDEXED, SDL_LowerBlit(), and SDL_SoftStretch.

Referenced by SDL_UpperBlitScaled().

SDL_SetClipRect()

SDL_bool SDL_SetClipRect	(	SDL_Surface *	surface,
		const SDL_Rect *	rect
	)

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

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

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

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

Definition at line 581 of file SDL_surface.c.

{
    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);
}

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

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

SDL_SetColorKey()

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

{
    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;
    } else {
        surface->map->info.flags &= ~SDL_COPY_COLORKEY;
    }
    if (surface->map->info.flags != flags) {
        SDL_InvalidateMap(surface->map);
    }
 
    return 0;
}

References SDL_COPY_COLORKEY, SDL_InvalidateMap(), SDL_InvalidParamError, SDL_RLEACCEL, and SDL_SetSurfaceRLE().

Referenced by SDL_ConvertColorkeyToAlpha(), and SDL_ConvertSurface().

SDL_SetSurfaceAlphaMod()

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

{
    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;
}

References SDL_COPY_MODULATE_ALPHA, and SDL_InvalidateMap().

SDL_SetSurfaceBlendMode()

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

{
    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 | SDL_COPY_MUL);
    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;
    case SDL_BLENDMODE_MUL:
        surface->map->info.flags |= SDL_COPY_MUL;
        break;
    default:
        status = SDL_Unsupported();
        break;
    }
 
    if (surface->map->info.flags != flags) {
        SDL_InvalidateMap(surface->map);
    }
 
    return status;
}

References blendMode, SDL_BLENDMODE_ADD, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_MOD, SDL_BLENDMODE_MUL, SDL_BLENDMODE_NONE, SDL_COPY_ADD, SDL_COPY_BLEND, SDL_COPY_MOD, SDL_COPY_MUL, SDL_InvalidateMap(), and SDL_Unsupported.

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

SDL_SetSurfaceColorMod()

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

{
    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;
}

References SDL_COPY_MODULATE_COLOR, and SDL_InvalidateMap().

SDL_SetSurfacePalette()

int SDL_SetSurfacePalette	(	SDL_Surface *	surface,
		SDL_Palette *	palette
	)

Set the palette used by a surface.

Returns

0, or -1 if the surface format doesn't use a palette.

Note

A single palette can be shared with many surfaces.

Definition at line 218 of file SDL_surface.c.

{
    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;
}

References SDL_InvalidateMap(), SDL_SetError, and SDL_SetPixelFormatPalette.

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

SDL_SetSurfaceRLE()

int SDL_SetSurfaceRLE	(	SDL_Surface *	surface,
		int	flag
	)

Sets the RLE acceleration hint for a surface.

Returns

0 on success, or -1 if the surface is not valid

Note

If RLE is enabled, colorkey and alpha blending blits are much faster, but the surface must be locked before directly accessing the pixels.

Definition at line 232 of file SDL_surface.c.

{
    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;
}

References SDL_COPY_RLE_DESIRED, and SDL_InvalidateMap().

Referenced by SDL_ConvertSurface(), and SDL_SetColorKey().

SDL_UnlockSurface()

void SDL_UnlockSurface

(

SDL_Surface *

surface

)

See also

SDL_LockSurface()

Definition at line 950 of file SDL_surface.c.

{
    /* Only perform an unlock if we are locked */
    if (!surface->locked || (--surface->locked > 0)) {
        return;
    }
 
#if SDL_HAVE_RLE
    /* Update RLE encoded surface with new data */
    if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
        surface->flags &= ~SDL_RLEACCEL;        /* stop lying */
        SDL_RLESurface(surface);
    }
#endif
}

References SDL_RLEACCEL, and SDL_RLESurface().

Referenced by SDL_ConvertColorkeyToAlpha(), and SDL_FreeSurface().

SDL_UpperBlit()

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

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

Definition at line 647 of file SDL_surface.c.

{
    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;
}

References SDL_Rect::h, NULL, SDL_COPY_NEAREST, SDL_InvalidateMap(), SDL_LowerBlit(), SDL_SetError, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

SDL_UpperBlitScaled()

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

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

Definition at line 746 of file SDL_surface.c.

{
    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 + 1 + 0.5) - (int)SDL_floor(src_x0 + 0.5);
    final_src.h = (int)SDL_floor(src_y1 + 1 + 0.5) - (int)SDL_floor(src_y0 + 0.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);
}

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