/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

#include "SDL_sysvideo.h"

#include "SDL_blit.h"

#include "SDL_RLEaccel_c.h"

#include "SDL_pixels_c.h"

/* Public routines */

/*

* Create an empty RGB surface of the appropriate depth

*/

SDL_Surface *

SDL_CreateRGBSurface(Uint32 flags,

int width, int height, int depth,

Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)

/* Get the pixel format */

format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);

if (format == SDL_PIXELFORMAT_UNKNOWN) {

SDL_SetError("Unknown pixel format");

return NULL;

}

if (surface == NULL) {

SDL_OutOfMemory();

return NULL;

}

if (!surface->format) {

SDL_FreeSurface(surface);

return NULL;

}

surface->w = width;

surface->h = height;

surface->pitch = SDL_CalculatePitch(surface);

SDL_SetClipRect(surface, NULL);

SDL_Palette *palette =

SDL_AllocPalette((1 << surface->format->BitsPerPixel));

if (!palette) {

SDL_FreeSurface(surface);

return NULL;

}

if (Rmask || Bmask || Gmask) {

const SDL_PixelFormat *format = surface->format;

/* create palette according to masks */

int i;

int Rm = 0, Gm = 0, Bm = 0;

int Rw = 0, Gw = 0, Bw = 0;

if (Rmask) {

Rw = 8 - format->Rloss;

for (i = format->Rloss; i > 0; i -= Rw)

Rm |= 1 << i;

}

if (Gmask) {

Gw = 8 - format->Gloss;

for (i = format->Gloss; i > 0; i -= Gw)

Gm |= 1 << i;

}

if (Bmask) {

Bw = 8 - format->Bloss;

for (i = format->Bloss; i > 0; i -= Bw)

Bm |= 1 << i;

}

for (i = 0; i < palette->ncolors; ++i) {

int r, g, b;

r = (i & Rmask) >> format->Rshift;

r = (r << format->Rloss) | ((r * Rm) >> Rw);

palette->colors[i].r = r;

g = (i & Gmask) >> format->Gshift;

g = (g << format->Gloss) | ((g * Gm) >> Gw);

palette->colors[i].g = g;

b = (i & Bmask) >> format->Bshift;

b = (b << format->Bloss) | ((b * Bm) >> Bw);

palette->colors[i].b = b;

}

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

}

/* The surface is ready to go */

surface->refcount = 1;

return surface;

/*

* Create an RGB surface from an existing memory buffer

*/

SDL_Surface *

SDL_CreateRGBSurfaceFrom(void *pixels,

int width, int height, int depth, int pitch,

Uint32 Rmask, Uint32 Gmask, Uint32 Bmask,

Uint32 Amask)

{

SDL_Surface *surface;

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;

}

int

SDL_SetSurfacePalette(SDL_Surface * surface, SDL_Palette * palette)

SDL_SetError("SDL_SetSurfacePalette() passed a NULL surface");

return -1;

}

int

SDL_SetSurfaceRLE(SDL_Surface * surface, int flag)

if (!surface) {

return -1;

}

return 0;

}

{

int flags;

if (!surface) {

return -1;

}

if (flag & SDL_RLEACCEL) {

SDL_SetSurfaceRLE(surface, 1);

}

surface->map->info.flags |= SDL_COPY_COLORKEY;

surface->map->info.colorkey = key;

if (surface->map->info.flags != flags) {

SDL_InvalidateMap(surface->map);

}

/* Compatibility mode */

if (surface->map->info.flags & SDL_COPY_COLORKEY) {

surface->flags |= SDL_SRCCOLORKEY;

} else {

surface->flags &= ~SDL_SRCCOLORKEY;

}

int

SDL_GetColorKey(SDL_Surface * surface, Uint32 * key)

{

if (!surface) {

return -1;

}

if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {

return -1;

}

if (key) {

*key = surface->map->info.colorkey;

}

return 0;

}

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

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;

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

}

int

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

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;

surface->map->info.flags &= ~SDL_COPY_MODULATE_COLOR;

}

if (surface->map->info.flags != flags) {

SDL_InvalidateMap(surface->map);

return 0;

}

int

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

{

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;

}

int

SDL_SetSurfaceAlphaMod(SDL_Surface * surface, Uint8 alpha)

{

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;

surface->map->info.flags &= ~SDL_COPY_MODULATE_ALPHA;

}

if (surface->map->info.flags != flags) {

SDL_InvalidateMap(surface->map);

}

int

SDL_GetSurfaceAlphaMod(SDL_Surface * surface, Uint8 * alpha)

if (!surface) {

return -1;

}

if (alpha) {

*alpha = surface->map->info.a;

}

return 0;

}

{

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

surface->map->info.flags |= SDL_COPY_BLEND;

break;

surface->map->info.flags |= SDL_COPY_ADD;

break;

case SDL_BLENDMODE_MOD:

surface->map->info.flags |= SDL_COPY_MOD;

break;

default:

SDL_Unsupported();

status = -1;

break;

}

if (surface->map->info.flags != flags) {

SDL_InvalidateMap(surface->map);

/* Compatibility mode */

if (surface->map->info.flags & SDL_COPY_BLEND) {

surface->flags |= SDL_SRCALPHA;

} else {

surface->flags &= ~SDL_SRCALPHA;

}

return status;

}

{

if (!surface) {

return -1;

if (!blendMode) {

return 0;

switch (surface->map->

info.flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD)) {

break;

case SDL_COPY_ADD:

case SDL_COPY_MOD:

*blendMode = SDL_BLENDMODE_MOD;

break;

return 0;

}

SDL_bool

SDL_SetClipRect(SDL_Surface * surface, const SDL_Rect * rect)

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_IntersectRect(rect, &full_rect, &surface->clip_rect);

void

SDL_GetClipRect(SDL_Surface * surface, SDL_Rect * rect)

if (surface && rect) {

*rect = surface->clip_rect;

}

/*

* Set up a blit between two surfaces -- split into three parts:

* The upper part, SDL_UpperBlit(), performs clipping and rectangle

* verification. The lower part is a pointer to a low level

* accelerated blitting function.

*

* These parts are separated out and each used internally by this

* library in the optimimum places. They are exported so that if

* you know exactly what you are doing, you can optimize your code

* by calling the one(s) you need.

*/

int

SDL_LowerBlit(SDL_Surface * src, SDL_Rect * srcrect,

SDL_Surface * dst, SDL_Rect * dstrect)

/* Check to make sure the blit mapping is valid */

if ((src->map->dst != dst) ||

(dst->format->palette &&

src->map->palette_version != dst->format->palette->version)) {

if (SDL_MapSurface(src, dst) < 0) {

return (-1);

}

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

}

SDL_Rect fulldst;

int srcx, srcy, w, h;

/* Make sure the surfaces aren't locked */

if (!src || !dst) {

SDL_SetError("SDL_UpperBlit: passed a NULL surface");

return (-1);

}

if (src->locked || dst->locked) {

SDL_SetError("Surfaces must not be locked during blit");

return (-1);

}

/* If the destination rectangle is NULL, use the entire dest surface */

if (dstrect == NULL) {

fulldst.x = fulldst.y = 0;

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;

}

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;

}

/*

* Scale and blit a surface

*/

int

SDL_BlitScaled(SDL_Surface * src, const SDL_Rect * srcrect,

SDL_Surface * dst, const SDL_Rect * dstrect)

{

/* Save off the original dst width, height */

int dstW = dstrect->w;

int dstH = dstrect->h;

SDL_Rect final_dst = *dstrect;

SDL_Rect final_src = *srcrect;

/* Clip the dst surface to the dstrect */

SDL_SetClipRect( dst, &final_dst );

/* If the dest was clipped to a zero sized rect then exit */

if ( dst->clip_rect.w <= 0 || dst->clip_rect.h <= 0 ) {

return -1;

}

/* Did the dst width change? */

if ( dstW != dst->clip_rect.w ) {

/* scale the src width appropriately */

final_src.w = final_src.w * dst->clip_rect.w / dstW;

}

/* Did the dst height change? */

if ( dstH != dst->clip_rect.h ) {

/* scale the src width appropriately */

final_src.h = final_src.h * dst->clip_rect.h / dstH;

}

/* Clip the src surface to the srcrect */

SDL_SetClipRect( src, &final_src );

src->map->info.flags |= SDL_COPY_NEAREST;

if ( src->format->format == dst->format->format && !SDL_ISPIXELFORMAT_INDEXED(src->format->format) ) {

return SDL_SoftStretch( src, &final_src, dst, &final_dst );

} else {

return SDL_LowerBlit( src, &final_src, dst, &final_dst );

}

}

/*

* Lock a surface to directly access the pixels

*/

int

SDL_LockSurface(SDL_Surface * surface)

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

/*

* Unlock a previously locked surface

*/

void

SDL_UnlockSurface(SDL_Surface * surface)

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

}

}

/*

* Convert a surface into the specified pixel format.

*/

SDL_ConvertSurface(SDL_Surface * surface, SDL_PixelFormat * format,

Uint32 flags)

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 */

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;

}