SDL_pixels_c.h File Reference

#include "../SDL_internal.h"
#include "SDL_blit.h"

Include dependency graph for SDL_pixels_c.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	SDL_InitFormat (SDL_PixelFormat *format, Uint32 pixel_format)
SDL_BlitMap *	SDL_AllocBlitMap (void)
void	SDL_InvalidateMap (SDL_BlitMap *map)
int	SDL_MapSurface (SDL_Surface *src, SDL_Surface *dst)
void	SDL_FreeBlitMap (SDL_BlitMap *map)
void	SDL_InvalidateAllBlitMap (SDL_Surface *surface)
void	SDL_DitherColors (SDL_Color *colors, int bpp)
Uint8	SDL_FindColor (SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
void	SDL_DetectPalette (SDL_Palette *pal, SDL_bool *is_opaque, SDL_bool *has_alpha_channel)

Function Documentation

SDL_AllocBlitMap()

SDL_BlitMap* SDL_AllocBlitMap

(

void

)

Definition at line 1007 of file SDL_pixels.c.

{
    SDL_BlitMap *map;
 
    /* Allocate the empty map */
    map = (SDL_BlitMap *) SDL_calloc(1, sizeof(*map));
    if (map == NULL) {
        SDL_OutOfMemory();
        return (NULL);
    }
    map->info.r = 0xFF;
    map->info.g = 0xFF;
    map->info.b = 0xFF;
    map->info.a = 0xFF;
 
    /* It's ready to go */
    return (map);
}

References map, NULL, SDL_calloc, and SDL_OutOfMemory.

Referenced by SDL_CreateRGBSurfaceWithFormat().

SDL_DetectPalette()

void SDL_DetectPalette	(	SDL_Palette *	pal,
		SDL_bool *	is_opaque,
		SDL_bool *	has_alpha_channel
	)

Definition at line 806 of file SDL_pixels.c.

{
    int i;
 
    {
        SDL_bool all_opaque = SDL_TRUE;
        for (i = 0; i < pal->ncolors; i++) {
            Uint8 alpha_value = pal->colors[i].a;
            if (alpha_value != SDL_ALPHA_OPAQUE) {
                all_opaque = SDL_FALSE;
                break;
            }
        }
 
        if (all_opaque) {
            /* Palette is opaque, with an alpha channel */
            *is_opaque = SDL_TRUE;
            *has_alpha_channel = SDL_TRUE;
            return;
        }
    }
 
    {
        SDL_bool all_transparent = SDL_TRUE;
        for (i = 0; i < pal->ncolors; i++) {
            Uint8 alpha_value = pal->colors[i].a;
            if (alpha_value != SDL_ALPHA_TRANSPARENT) {
                all_transparent = SDL_FALSE;
                break;
            }
        }
 
        if (all_transparent) {
            /* Palette is opaque, without an alpha channel */
            *is_opaque = SDL_TRUE;
            *has_alpha_channel = SDL_FALSE;
            return;
        }
    }
 
    /* Palette has alpha values */
    *is_opaque = SDL_FALSE;
    *has_alpha_channel = SDL_TRUE;
}

References SDL_Color::a, SDL_Palette::colors, i, SDL_Palette::ncolors, SDL_ALPHA_OPAQUE, SDL_ALPHA_TRANSPARENT, SDL_FALSE, and SDL_TRUE.

Referenced by SDL_ConvertSurface(), and SDL_CreateTextureFromSurface().

SDL_DitherColors()

void SDL_DitherColors	(	SDL_Color *	colors,
		int	bpp
	)

Definition at line 749 of file SDL_pixels.c.

{
    int i;
    if (bpp != 8)
        return;                 /* only 8bpp supported right now */
 
    for (i = 0; i < 256; i++) {
        int r, g, b;
        /* map each bit field to the full [0, 255] interval,
           so 0 is mapped to (0, 0, 0) and 255 to (255, 255, 255) */
        r = i & 0xe0;
        r |= r >> 3 | r >> 6;
        colors[i].r = r;
        g = (i << 3) & 0xe0;
        g |= g >> 3 | g >> 6;
        colors[i].g = g;
        b = i & 0x3;
        b |= b << 2;
        b |= b << 4;
        colors[i].b = b;
        colors[i].a = SDL_ALPHA_OPAQUE;
    }
}

References bpp, colors, i, and SDL_ALPHA_OPAQUE.

Referenced by MapNto1().

SDL_FindColor()

Uint8 SDL_FindColor	(	SDL_Palette *	pal,
		Uint8	r,
		Uint8	g,
		Uint8	b,
		Uint8	a
	)

Definition at line 777 of file SDL_pixels.c.

{
    /* Do colorspace distance matching */
    unsigned int smallest;
    unsigned int distance;
    int rd, gd, bd, ad;
    int i;
    Uint8 pixel = 0;
 
    smallest = ~0;
    for (i = 0; i < pal->ncolors; ++i) {
        rd = pal->colors[i].r - r;
        gd = pal->colors[i].g - g;
        bd = pal->colors[i].b - b;
        ad = pal->colors[i].a - a;
        distance = (rd * rd) + (gd * gd) + (bd * bd) + (ad * ad);
        if (distance < smallest) {
            pixel = i;
            if (distance == 0) {        /* Perfect match! */
                break;
            }
            smallest = distance;
        }
    }
    return (pixel);
}

References SDL_Color::a, SDL_Color::b, SDL_Palette::colors, SDL_Color::g, i, SDL_Palette::ncolors, and SDL_Color::r.

Referenced by Map1to1(), SDL_MapRGB(), and SDL_MapRGBA().

SDL_FreeBlitMap()

void SDL_FreeBlitMap

(

SDL_BlitMap *

map

)

Definition at line 1182 of file SDL_pixels.c.

{
    if (map) {
        SDL_InvalidateMap(map);
        SDL_free(map);
    }
}

References map, SDL_free, and SDL_InvalidateMap().

Referenced by SDL_FreeSurface().

SDL_InitFormat()

int SDL_InitFormat	(	SDL_PixelFormat *	format,
		Uint32	pixel_format
	)

Definition at line 544 of file SDL_pixels.c.

{
    int bpp;
    Uint32 Rmask, Gmask, Bmask, Amask;
    Uint32 mask;
 
    if (!SDL_PixelFormatEnumToMasks(pixel_format, &bpp,
                                    &Rmask, &Gmask, &Bmask, &Amask)) {
        return -1;
    }
 
    /* Set up the format */
    SDL_zerop(format);
    format->format = pixel_format;
    format->BitsPerPixel = bpp;
    format->BytesPerPixel = (bpp + 7) / 8;
 
    format->Rmask = Rmask;
    format->Rshift = 0;
    format->Rloss = 8;
    if (Rmask) {
        for (mask = Rmask; !(mask & 0x01); mask >>= 1)
            ++format->Rshift;
        for (; (mask & 0x01); mask >>= 1)
            --format->Rloss;
    }
 
    format->Gmask = Gmask;
    format->Gshift = 0;
    format->Gloss = 8;
    if (Gmask) {
        for (mask = Gmask; !(mask & 0x01); mask >>= 1)
            ++format->Gshift;
        for (; (mask & 0x01); mask >>= 1)
            --format->Gloss;
    }
 
    format->Bmask = Bmask;
    format->Bshift = 0;
    format->Bloss = 8;
    if (Bmask) {
        for (mask = Bmask; !(mask & 0x01); mask >>= 1)
            ++format->Bshift;
        for (; (mask & 0x01); mask >>= 1)
            --format->Bloss;
    }
 
    format->Amask = Amask;
    format->Ashift = 0;
    format->Aloss = 8;
    if (Amask) {
        for (mask = Amask; !(mask & 0x01); mask >>= 1)
            ++format->Ashift;
        for (; (mask & 0x01); mask >>= 1)
            --format->Aloss;
    }
 
    format->palette = NULL;
    format->refcount = 1;
    format->next = NULL;
 
    return 0;
}

References bpp, NULL, pixel_format, SDL_PixelFormatEnumToMasks(), and SDL_zerop.

Referenced by SDL_AllocFormat(), SDL_CreateSurfaceOnStack(), and SDL_SaveBMP_RW().

SDL_InvalidateAllBlitMap()

void SDL_InvalidateAllBlitMap

(

SDL_Surface *

surface

)

Definition at line 1034 of file SDL_pixels.c.

{
    SDL_ListNode *l = surface->list_blitmap;
 
    surface->list_blitmap = NULL;
 
    while (l) {
        SDL_ListNode *tmp = l;
        SDL_InvalidateMap((SDL_BlitMap *)l->entry);
        l = l->next;
        SDL_free(tmp);
    }
}

References l, NULL, SDL_free, and SDL_InvalidateMap().

Referenced by SDL_FreeSurface().

SDL_InvalidateMap()

void SDL_InvalidateMap

(

SDL_BlitMap *

map

)

Definition at line 1083 of file SDL_pixels.c.

{
    if (!map) {
        return;
    }
    if (map->dst) {
        /* Un-register from the destination surface */
        SDL_ListRemove((SDL_ListNode **)&(map->dst->list_blitmap), map);
    }
    map->dst = NULL;
    map->src_palette_version = 0;
    map->dst_palette_version = 0;
    SDL_free(map->info.table);
    map->info.table = NULL;
}

References map, NULL, SDL_free, and SDL_ListRemove().

Referenced by SDL_CalculateBlit(), SDL_ConvertPixels(), SDL_ConvertSurface(), SDL_FreeBlitMap(), SDL_FreeSurface(), SDL_InvalidateAllBlitMap(), SDL_LowerBlitScaled(), SDL_MapSurface(), SDL_SetColorKey(), SDL_SetSurfaceAlphaMod(), SDL_SetSurfaceBlendMode(), SDL_SetSurfaceColorMod(), SDL_SetSurfacePalette(), SDL_SetSurfaceRLE(), and SDL_UpperBlit().

SDL_MapSurface()

int SDL_MapSurface	(	SDL_Surface *	src,
		SDL_Surface *	dst
	)

Definition at line 1100 of file SDL_pixels.c.

{
    SDL_PixelFormat *srcfmt;
    SDL_PixelFormat *dstfmt;
    SDL_BlitMap *map;
 
    /* Clear out any previous mapping */
    map = src->map;
#if SDL_HAVE_RLE
    if ((src->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
        SDL_UnRLESurface(src, 1);
    }
#endif
    SDL_InvalidateMap(map);
 
    /* Figure out what kind of mapping we're doing */
    map->identity = 0;
    srcfmt = src->format;
    dstfmt = dst->format;
    if (SDL_ISPIXELFORMAT_INDEXED(srcfmt->format)) {
        if (SDL_ISPIXELFORMAT_INDEXED(dstfmt->format)) {
            /* Palette --> Palette */
            map->info.table =
                Map1to1(srcfmt->palette, dstfmt->palette, &map->identity);
            if (!map->identity) {
                if (map->info.table == NULL) {
                    return (-1);
                }
            }
            if (srcfmt->BitsPerPixel != dstfmt->BitsPerPixel)
                map->identity = 0;
        } else {
            /* Palette --> BitField */
            map->info.table =
                Map1toN(srcfmt, src->map->info.r, src->map->info.g,
                        src->map->info.b, src->map->info.a, dstfmt);
            if (map->info.table == NULL) {
                return (-1);
            }
        }
    } else {
        if (SDL_ISPIXELFORMAT_INDEXED(dstfmt->format)) {
            /* BitField --> Palette */
            map->info.table = MapNto1(srcfmt, dstfmt, &map->identity);
            if (!map->identity) {
                if (map->info.table == NULL) {
                    return (-1);
                }
            }
            map->identity = 0;  /* Don't optimize to copy */
        } else {
            /* BitField --> BitField */
            if (srcfmt == dstfmt) {
                map->identity = 1;
            }
        }
    }
 
    map->dst = dst;
 
    if (map->dst) {
        /* Register BlitMap to the destination surface, to be invalidated when needed */
        SDL_ListAdd((SDL_ListNode **)&(map->dst->list_blitmap), map);
    }
 
    if (dstfmt->palette) {
        map->dst_palette_version = dstfmt->palette->version;
    } else {
        map->dst_palette_version = 0;
    }
 
    if (srcfmt->palette) {
        map->src_palette_version = srcfmt->palette->version;
    } else {
        map->src_palette_version = 0;
    }
 
    /* Choose your blitters wisely */
    return (SDL_CalculateBlit(src));
}

References SDL_PixelFormat::BitsPerPixel, SDL_PixelFormat::format, map, Map1to1(), Map1toN(), MapNto1(), NULL, SDL_PixelFormat::palette, SDL_CalculateBlit(), SDL_InvalidateMap(), SDL_ISPIXELFORMAT_INDEXED, SDL_ListAdd(), SDL_RLEACCEL, SDL_UnRLESurface(), and SDL_Palette::version.

Referenced by SDL_LowerBlit().