SDL  2.0
SDL_pixels.c File Reference
#include "../SDL_internal.h"
#include "SDL_endian.h"
#include "SDL_video.h"
#include "SDL_sysvideo.h"
#include "SDL_blit.h"
#include "SDL_pixels_c.h"
#include "SDL_RLEaccel_c.h"
+ Include dependency graph for SDL_pixels.c:

Go to the source code of this file.

Macros

#define CASE(X)   case X: return #X;
 

Functions

const char * SDL_GetPixelFormatName (Uint32 format)
 Get the human readable name of a pixel format. More...
 
SDL_bool SDL_PixelFormatEnumToMasks (Uint32 format, int *bpp, Uint32 *Rmask, Uint32 *Gmask, Uint32 *Bmask, Uint32 *Amask)
 Convert one of the enumerated pixel formats to a bpp and RGBA masks. More...
 
Uint32 SDL_MasksToPixelFormatEnum (int bpp, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
 Convert a bpp and RGBA masks to an enumerated pixel format. More...
 
SDL_PixelFormatSDL_AllocFormat (Uint32 pixel_format)
 Create an SDL_PixelFormat structure from a pixel format enum. More...
 
int SDL_InitFormat (SDL_PixelFormat *format, Uint32 pixel_format)
 
void SDL_FreeFormat (SDL_PixelFormat *format)
 Free an SDL_PixelFormat structure. More...
 
SDL_PaletteSDL_AllocPalette (int ncolors)
 Create a palette structure with the specified number of color entries. More...
 
int SDL_SetPixelFormatPalette (SDL_PixelFormat *format, SDL_Palette *palette)
 Set the palette for a pixel format structure. More...
 
int SDL_SetPaletteColors (SDL_Palette *palette, const SDL_Color *colors, int firstcolor, int ncolors)
 Set a range of colors in a palette. More...
 
void SDL_FreePalette (SDL_Palette *palette)
 Free a palette created with SDL_AllocPalette(). More...
 
void SDL_DitherColors (SDL_Color *colors, int bpp)
 
int SDL_CalculatePitch (SDL_Surface *surface)
 
Uint8 SDL_FindColor (SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 
Uint32 SDL_MapRGB (const SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b)
 Maps an RGB triple to an opaque pixel value for a given pixel format. More...
 
Uint32 SDL_MapRGBA (const SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
 Maps an RGBA quadruple to a pixel value for a given pixel format. More...
 
void SDL_GetRGB (Uint32 pixel, const SDL_PixelFormat *format, Uint8 *r, Uint8 *g, Uint8 *b)
 Get the RGB components from a pixel of the specified format. More...
 
void SDL_GetRGBA (Uint32 pixel, const SDL_PixelFormat *format, Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a)
 Get the RGBA components from a pixel of the specified format. More...
 
static Uint8Map1to1 (SDL_Palette *src, SDL_Palette *dst, int *identical)
 
static Uint8Map1toN (SDL_PixelFormat *src, Uint8 Rmod, Uint8 Gmod, Uint8 Bmod, Uint8 Amod, SDL_PixelFormat *dst)
 
static Uint8MapNto1 (SDL_PixelFormat *src, SDL_PixelFormat *dst, int *identical)
 
SDL_BlitMapSDL_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_CalculateGammaRamp (float gamma, Uint16 *ramp)
 Calculate a 256 entry gamma ramp for a gamma value. More...
 

Variables

static Uint8 lookup_0 []
 
static Uint8 lookup_1 []
 
static Uint8 lookup_2 []
 
static Uint8 lookup_3 []
 
static Uint8 lookup_4 []
 
static Uint8 lookup_5 []
 
static Uint8 lookup_6 []
 
static Uint8 lookup_7 []
 
static Uint8 lookup_8 []
 
Uint8SDL_expand_byte [9]
 
static SDL_PixelFormatformats
 

Macro Definition Documentation

#define CASE (   X)    case X: return #X;

Referenced by SDL_GetPixelFormatName().

Function Documentation

static Uint8* Map1to1 ( SDL_Palette src,
SDL_Palette dst,
int *  identical 
)
static

Definition at line 878 of file SDL_pixels.c.

References SDL_Color::a, SDL_Color::b, SDL_Palette::colors, SDL_Color::g, i, map, SDL_Palette::ncolors, NULL, SDL_Color::r, SDL_FindColor(), SDL_malloc, SDL_memcmp, and SDL_OutOfMemory.

Referenced by MapNto1(), and SDL_MapSurface().

879 {
880  Uint8 *map;
881  int i;
882 
883  if (identical) {
884  if (src->ncolors <= dst->ncolors) {
885  /* If an identical palette, no need to map */
886  if (src == dst
887  ||
888  (SDL_memcmp
889  (src->colors, dst->colors,
890  src->ncolors * sizeof(SDL_Color)) == 0)) {
891  *identical = 1;
892  return (NULL);
893  }
894  }
895  *identical = 0;
896  }
897  map = (Uint8 *) SDL_malloc(src->ncolors);
898  if (map == NULL) {
899  SDL_OutOfMemory();
900  return (NULL);
901  }
902  for (i = 0; i < src->ncolors; ++i) {
903  map[i] = SDL_FindColor(dst,
904  src->colors[i].r, src->colors[i].g,
905  src->colors[i].b, src->colors[i].a);
906  }
907  return (map);
908 }
Uint8 g
Definition: SDL_pixels.h:282
Uint8 b
Definition: SDL_pixels.h:283
Uint8 r
Definition: SDL_pixels.h:281
Uint8 a
Definition: SDL_pixels.h:284
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
Uint8 SDL_FindColor(SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_pixels.c:772
#define SDL_memcmp
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
#define NULL
Definition: begin_code.h:143
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Color * colors
Definition: SDL_pixels.h:291
#define SDL_malloc
const GLubyte GLuint GLuint GLuint GLuint alpha GLboolean GLboolean GLboolean GLboolean alpha GLint GLint GLsizei GLsizei GLenum type GLenum GLint GLenum GLint GLint GLsizei GLsizei GLint border GLenum GLint GLint GLint GLint GLint GLsizei GLsizei height GLsizei GLsizei GLenum GLenum const GLvoid *pixels GLenum GLint GLint GLint GLint j2 GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLfloat *params GLenum GLint GLenum GLenum GLvoid *pixels GLenum GLint GLenum GLint *params GLenum GLenum GLint *params GLenum GLsizei const GLvoid *pointer GLenum GLenum const GLint *params GLenum GLfloat GLfloat GLint GLint const GLfloat *points GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat *points GLint GLfloat GLfloat GLint GLfloat GLfloat v2 GLenum GLenum const GLint *params GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum map
Definition: SDL_glfuncs.h:289
static Uint8* Map1toN ( SDL_PixelFormat src,
Uint8  Rmod,
Uint8  Gmod,
Uint8  Bmod,
Uint8  Amod,
SDL_PixelFormat dst 
)
static

Definition at line 912 of file SDL_pixels.c.

References SDL_Color::a, ASSEMBLE_RGBA, SDL_Color::b, SDL_PixelFormat::BytesPerPixel, SDL_Palette::colors, G, SDL_Color::g, i, map, SDL_Palette::ncolors, NULL, SDL_PixelFormat::palette, SDL_Color::r, SDL_malloc, and SDL_OutOfMemory.

Referenced by SDL_MapSurface().

914 {
915  Uint8 *map;
916  int i;
917  int bpp;
918  SDL_Palette *pal = src->palette;
919 
920  bpp = ((dst->BytesPerPixel == 3) ? 4 : dst->BytesPerPixel);
921  map = (Uint8 *) SDL_malloc(pal->ncolors * bpp);
922  if (map == NULL) {
923  SDL_OutOfMemory();
924  return (NULL);
925  }
926 
927  /* We memory copy to the pixel map so the endianness is preserved */
928  for (i = 0; i < pal->ncolors; ++i) {
929  Uint8 R = (Uint8) ((pal->colors[i].r * Rmod) / 255);
930  Uint8 G = (Uint8) ((pal->colors[i].g * Gmod) / 255);
931  Uint8 B = (Uint8) ((pal->colors[i].b * Bmod) / 255);
932  Uint8 A = (Uint8) ((pal->colors[i].a * Amod) / 255);
933  ASSEMBLE_RGBA(&map[i * bpp], dst->BytesPerPixel, dst, R, G, B, A);
934  }
935  return (map);
936 }
Uint8 g
Definition: SDL_pixels.h:282
Uint8 BytesPerPixel
Definition: SDL_pixels.h:304
#define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a)
Definition: SDL_blit.h:401
Uint8 b
Definition: SDL_pixels.h:283
Uint8 r
Definition: SDL_pixels.h:281
Uint8 a
Definition: SDL_pixels.h:284
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
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
#define NULL
Definition: begin_code.h:143
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Color * colors
Definition: SDL_pixels.h:291
#define G(x, y, z)
Definition: SDL_test_md5.c:74
#define SDL_malloc
SDL_Palette * palette
Definition: SDL_pixels.h:302
const GLubyte GLuint GLuint GLuint GLuint alpha GLboolean GLboolean GLboolean GLboolean alpha GLint GLint GLsizei GLsizei GLenum type GLenum GLint GLenum GLint GLint GLsizei GLsizei GLint border GLenum GLint GLint GLint GLint GLint GLsizei GLsizei height GLsizei GLsizei GLenum GLenum const GLvoid *pixels GLenum GLint GLint GLint GLint j2 GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLfloat *params GLenum GLint GLenum GLenum GLvoid *pixels GLenum GLint GLenum GLint *params GLenum GLenum GLint *params GLenum GLsizei const GLvoid *pointer GLenum GLenum const GLint *params GLenum GLfloat GLfloat GLint GLint const GLfloat *points GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat *points GLint GLfloat GLfloat GLint GLfloat GLfloat v2 GLenum GLenum const GLint *params GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum map
Definition: SDL_glfuncs.h:289
static Uint8* MapNto1 ( SDL_PixelFormat src,
SDL_PixelFormat dst,
int *  identical 
)
static

Definition at line 940 of file SDL_pixels.c.

References colors, SDL_Palette::colors, Map1to1(), SDL_Palette::ncolors, SDL_PixelFormat::palette, and SDL_DitherColors().

Referenced by SDL_MapSurface().

941 {
942  /* Generate a 256 color dither palette */
943  SDL_Palette dithered;
944  SDL_Color colors[256];
945  SDL_Palette *pal = dst->palette;
946 
947  dithered.ncolors = 256;
948  SDL_DitherColors(colors, 8);
949  dithered.colors = colors;
950  return (Map1to1(&dithered, pal, identical));
951 }
void SDL_DitherColors(SDL_Color *colors, int bpp)
Definition: SDL_pixels.c:720
static Uint8 * Map1to1(SDL_Palette *src, SDL_Palette *dst, int *identical)
Definition: SDL_pixels.c:878
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Palette * palette
Definition: SDL_pixels.h:302
static int colors[7]
Definition: testgesture.c:40
SDL_BlitMap* SDL_AllocBlitMap ( void  )

Definition at line 954 of file SDL_pixels.c.

References SDL_BlitInfo::a, SDL_BlitInfo::b, SDL_BlitInfo::g, SDL_BlitMap::info, map, NULL, SDL_BlitInfo::r, SDL_calloc(), and SDL_OutOfMemory.

Referenced by SDL_CreateRGBSurface().

955 {
956  SDL_BlitMap *map;
957 
958  /* Allocate the empty map */
959  map = (SDL_BlitMap *) SDL_calloc(1, sizeof(*map));
960  if (map == NULL) {
961  SDL_OutOfMemory();
962  return (NULL);
963  }
964  map->info.r = 0xFF;
965  map->info.g = 0xFF;
966  map->info.b = 0xFF;
967  map->info.a = 0xFF;
968 
969  /* It's ready to go */
970  return (map);
971 }
Uint8 r
Definition: SDL_blit.h:70
Uint8 b
Definition: SDL_blit.h:70
Uint8 g
Definition: SDL_blit.h:70
void * SDL_calloc(size_t nmemb, size_t size)
#define NULL
Definition: begin_code.h:143
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
const GLubyte GLuint GLuint GLuint GLuint alpha GLboolean GLboolean GLboolean GLboolean alpha GLint GLint GLsizei GLsizei GLenum type GLenum GLint GLenum GLint GLint GLsizei GLsizei GLint border GLenum GLint GLint GLint GLint GLint GLsizei GLsizei height GLsizei GLsizei GLenum GLenum const GLvoid *pixels GLenum GLint GLint GLint GLint j2 GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLfloat *params GLenum GLint GLenum GLenum GLvoid *pixels GLenum GLint GLenum GLint *params GLenum GLenum GLint *params GLenum GLsizei const GLvoid *pointer GLenum GLenum const GLint *params GLenum GLfloat GLfloat GLint GLint const GLfloat *points GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat *points GLint GLfloat GLfloat GLint GLfloat GLfloat v2 GLenum GLenum const GLint *params GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum map
Definition: SDL_glfuncs.h:289
SDL_BlitInfo info
Definition: SDL_blit.h:91
Uint8 a
Definition: SDL_blit.h:70
SDL_PixelFormat* SDL_AllocFormat ( Uint32  pixel_format)

Create an SDL_PixelFormat structure from a pixel format enum.

Definition at line 488 of file SDL_pixels.c.

References SDL_PixelFormat::format, formats, SDL_PixelFormat::next, NULL, SDL_PixelFormat::refcount, SDL_free(), SDL_InitFormat(), SDL_InvalidParamError, SDL_ISPIXELFORMAT_INDEXED, SDL_malloc, and SDL_OutOfMemory.

489 {
491 
492  /* Look it up in our list of previously allocated formats */
493  for (format = formats; format; format = format->next) {
494  if (pixel_format == format->format) {
495  ++format->refcount;
496  return format;
497  }
498  }
499 
500  /* Allocate an empty pixel format structure, and initialize it */
501  format = SDL_malloc(sizeof(*format));
502  if (format == NULL) {
503  SDL_OutOfMemory();
504  return NULL;
505  }
506  if (SDL_InitFormat(format, pixel_format) < 0) {
507  SDL_free(format);
508  SDL_InvalidParamError("format");
509  return NULL;
510  }
511 
513  /* Cache the RGB formats */
514  format->next = formats;
515  formats = format;
516  }
517  return format;
518 }
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:133
static SDL_PixelFormat * formats
Definition: SDL_pixels.c:485
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
void SDL_free(void *mem)
int SDL_InitFormat(SDL_PixelFormat *format, Uint32 pixel_format)
Definition: SDL_pixels.c:521
#define NULL
Definition: begin_code.h:143
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
Uint32 pixel_format
Definition: testoverlay2.c:152
#define SDL_malloc
struct SDL_PixelFormat * next
Definition: SDL_pixels.h:319
SDL_Palette* SDL_AllocPalette ( int  ncolors)

Create a palette structure with the specified number of color entries.

Returns
A new palette, or NULL if there wasn't enough memory.
Note
The palette entries are initialized to white.
See also
SDL_FreePalette()

Definition at line 617 of file SDL_pixels.c.

References SDL_Palette::colors, SDL_Palette::ncolors, NULL, SDL_Palette::refcount, SDL_free(), SDL_InvalidParamError, SDL_malloc, SDL_memset, SDL_OutOfMemory, and SDL_Palette::version.

618 {
619  SDL_Palette *palette;
620 
621  /* Input validation */
622  if (ncolors < 1) {
623  SDL_InvalidParamError("ncolors");
624  return NULL;
625  }
626 
627  palette = (SDL_Palette *) SDL_malloc(sizeof(*palette));
628  if (!palette) {
629  SDL_OutOfMemory();
630  return NULL;
631  }
632  palette->colors =
633  (SDL_Color *) SDL_malloc(ncolors * sizeof(*palette->colors));
634  if (!palette->colors) {
635  SDL_free(palette);
636  return NULL;
637  }
638  palette->ncolors = ncolors;
639  palette->version = 1;
640  palette->refcount = 1;
641 
642  SDL_memset(palette->colors, 0xFF, ncolors * sizeof(*palette->colors));
643 
644  return palette;
645 }
Uint32 version
Definition: SDL_pixels.h:292
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
void SDL_free(void *mem)
#define NULL
Definition: begin_code.h:143
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Color * colors
Definition: SDL_pixels.h:291
#define SDL_malloc
#define SDL_memset
void SDL_CalculateGammaRamp ( float  gamma,
Uint16 ramp 
)

Calculate a 256 entry gamma ramp for a gamma value.

Definition at line 1088 of file SDL_pixels.c.

References i, NULL, SDL_InvalidParamError, SDL_memset, and SDL_pow.

1089 {
1090  int i;
1091 
1092  /* Input validation */
1093  if (gamma < 0.0f ) {
1094  SDL_InvalidParamError("gamma");
1095  return;
1096  }
1097  if (ramp == NULL) {
1098  SDL_InvalidParamError("ramp");
1099  return;
1100  }
1101 
1102  /* 0.0 gamma is all black */
1103  if (gamma == 0.0f) {
1104  SDL_memset(ramp, 0, 256 * sizeof(Uint16));
1105  return;
1106  } else if (gamma == 1.0f) {
1107  /* 1.0 gamma is identity */
1108  for (i = 0; i < 256; ++i) {
1109  ramp[i] = (i << 8) | i;
1110  }
1111  return;
1112  } else {
1113  /* Calculate a real gamma ramp */
1114  int value;
1115  gamma = 1.0f / gamma;
1116  for (i = 0; i < 256; ++i) {
1117  value =
1118  (int) (SDL_pow((double) i / 256.0, gamma) * 65535.0 + 0.5);
1119  if (value > 65535) {
1120  value = 65535;
1121  }
1122  ramp[i] = (Uint16) value;
1123  }
1124  }
1125 }
GLfloat f
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
GLsizei const GLfloat * value
#define SDL_pow
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
#define NULL
Definition: begin_code.h:143
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:147
#define SDL_memset
int SDL_CalculatePitch ( SDL_Surface surface)

Definition at line 748 of file SDL_pixels.c.

References SDL_PixelFormat::BitsPerPixel, SDL_PixelFormat::BytesPerPixel, SDL_Surface::format, and SDL_Surface::w.

Referenced by SDL_CreateRGBSurface().

749 {
750  int pitch;
751 
752  /* Surface should be 4-byte aligned for speed */
753  pitch = surface->w * surface->format->BytesPerPixel;
754  switch (surface->format->BitsPerPixel) {
755  case 1:
756  pitch = (pitch + 7) / 8;
757  break;
758  case 4:
759  pitch = (pitch + 1) / 2;
760  break;
761  default:
762  break;
763  }
764  pitch = (pitch + 3) & ~3; /* 4-byte aligning */
765  return (pitch);
766 }
Uint8 BytesPerPixel
Definition: SDL_pixels.h:304
Uint8 BitsPerPixel
Definition: SDL_pixels.h:303
SDL_PixelFormat * format
Definition: SDL_surface.h:72
void SDL_DitherColors ( SDL_Color colors,
int  bpp 
)

Definition at line 720 of file SDL_pixels.c.

References SDL_Color::a, SDL_Color::b, SDL_Color::g, i, SDL_Color::r, and SDL_ALPHA_OPAQUE.

Referenced by MapNto1().

721 {
722  int i;
723  if (bpp != 8)
724  return; /* only 8bpp supported right now */
725 
726  for (i = 0; i < 256; i++) {
727  int r, g, b;
728  /* map each bit field to the full [0, 255] interval,
729  so 0 is mapped to (0, 0, 0) and 255 to (255, 255, 255) */
730  r = i & 0xe0;
731  r |= r >> 3 | r >> 6;
732  colors[i].r = r;
733  g = (i << 3) & 0xe0;
734  g |= g >> 3 | g >> 6;
735  colors[i].g = g;
736  b = i & 0x3;
737  b |= b << 2;
738  b |= b << 4;
739  colors[i].b = b;
740  colors[i].a = SDL_ALPHA_OPAQUE;
741  }
742 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
Uint8 g
Definition: SDL_pixels.h:282
Uint8 b
Definition: SDL_pixels.h:283
GLboolean GLboolean g
Uint8 r
Definition: SDL_pixels.h:281
Uint8 a
Definition: SDL_pixels.h:284
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
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:45
GLboolean GLboolean GLboolean b
Uint8 SDL_FindColor ( SDL_Palette pal,
Uint8  r,
Uint8  g,
Uint8  b,
Uint8  a 
)

Definition at line 772 of file SDL_pixels.c.

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

773 {
774  /* Do colorspace distance matching */
775  unsigned int smallest;
776  unsigned int distance;
777  int rd, gd, bd, ad;
778  int i;
779  Uint8 pixel = 0;
780 
781  smallest = ~0;
782  for (i = 0; i < pal->ncolors; ++i) {
783  rd = pal->colors[i].r - r;
784  gd = pal->colors[i].g - g;
785  bd = pal->colors[i].b - b;
786  ad = pal->colors[i].a - a;
787  distance = (rd * rd) + (gd * gd) + (bd * bd) + (ad * ad);
788  if (distance < smallest) {
789  pixel = i;
790  if (distance == 0) { /* Perfect match! */
791  break;
792  }
793  smallest = distance;
794  }
795  }
796  return (pixel);
797 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
Uint8 g
Definition: SDL_pixels.h:282
Uint8 b
Definition: SDL_pixels.h:283
GLsizei GLsizei GLfloat distance
GLboolean GLboolean g
Uint8 r
Definition: SDL_pixels.h:281
Uint8 a
Definition: SDL_pixels.h:284
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:139
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_Color * colors
Definition: SDL_pixels.h:291
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean GLboolean b
void SDL_FreeBlitMap ( SDL_BlitMap map)

Definition at line 1079 of file SDL_pixels.c.

References SDL_free(), and SDL_InvalidateMap().

Referenced by SDL_FreeSurface().

1080 {
1081  if (map) {
1082  SDL_InvalidateMap(map);
1083  SDL_free(map);
1084  }
1085 }
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
void SDL_free(void *mem)
void SDL_FreeFormat ( SDL_PixelFormat format)

Free an SDL_PixelFormat structure.

Definition at line 586 of file SDL_pixels.c.

References SDL_PixelFormat::next, SDL_PixelFormat::palette, SDL_PixelFormat::refcount, SDL_free(), SDL_FreePalette(), and SDL_InvalidParamError.

587 {
588  SDL_PixelFormat *prev;
589 
590  if (!format) {
591  SDL_InvalidParamError("format");
592  return;
593  }
594  if (--format->refcount > 0) {
595  return;
596  }
597 
598  /* Remove this format from our list */
599  if (format == formats) {
600  formats = format->next;
601  } else if (formats) {
602  for (prev = formats; prev->next; prev = prev->next) {
603  if (prev->next == format) {
604  prev->next = format->next;
605  break;
606  }
607  }
608  }
609 
610  if (format->palette) {
611  SDL_FreePalette(format->palette);
612  }
613  SDL_free(format);
614 }
static SDL_PixelFormat * formats
Definition: SDL_pixels.c:485
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
void SDL_free(void *mem)
void SDL_FreePalette(SDL_Palette *palette)
Free a palette created with SDL_AllocPalette().
Definition: SDL_pixels.c:703
SDL_Palette * palette
Definition: SDL_pixels.h:302
struct SDL_PixelFormat * next
Definition: SDL_pixels.h:319
void SDL_FreePalette ( SDL_Palette palette)

Free a palette created with SDL_AllocPalette().

See also
SDL_AllocPalette()

Definition at line 703 of file SDL_pixels.c.

References SDL_Palette::colors, SDL_Palette::refcount, SDL_free(), and SDL_InvalidParamError.

Referenced by SDL_FreeFormat(), and SDL_SetPixelFormatPalette().

704 {
705  if (!palette) {
706  SDL_InvalidParamError("palette");
707  return;
708  }
709  if (--palette->refcount > 0) {
710  return;
711  }
712  SDL_free(palette->colors);
713  SDL_free(palette);
714 }
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
void SDL_free(void *mem)
SDL_Color * colors
Definition: SDL_pixels.h:291
const char* SDL_GetPixelFormatName ( Uint32  format)

Get the human readable name of a pixel format.

Definition at line 86 of file SDL_pixels.c.

References CASE, SDL_PIXELFORMAT_ABGR1555, SDL_PIXELFORMAT_ABGR4444, SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB1555, SDL_PIXELFORMAT_ARGB2101010, SDL_PIXELFORMAT_ARGB4444, SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR24, SDL_PIXELFORMAT_BGR555, SDL_PIXELFORMAT_BGR565, SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGRA4444, SDL_PIXELFORMAT_BGRA5551, SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGRX8888, SDL_PIXELFORMAT_INDEX1LSB, SDL_PIXELFORMAT_INDEX1MSB, SDL_PIXELFORMAT_INDEX4LSB, SDL_PIXELFORMAT_INDEX4MSB, SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_IYUV, SDL_PIXELFORMAT_NV12, SDL_PIXELFORMAT_NV21, SDL_PIXELFORMAT_RGB24, SDL_PIXELFORMAT_RGB332, SDL_PIXELFORMAT_RGB444, SDL_PIXELFORMAT_RGB555, SDL_PIXELFORMAT_RGB565, SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGBA4444, SDL_PIXELFORMAT_RGBA5551, SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGBX8888, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_YV12, and SDL_PIXELFORMAT_YVYU.

87 {
88  switch (format) {
89 #define CASE(X) case X: return #X;
127 #undef CASE
128  default:
129  return "SDL_PIXELFORMAT_UNKNOWN";
130  }
131 }
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
#define CASE(X)
void SDL_GetRGB ( Uint32  pixel,
const SDL_PixelFormat format,
Uint8 r,
Uint8 g,
Uint8 b 
)

Get the RGB components from a pixel of the specified format.

See also
SDL_GetRGBA

Definition at line 828 of file SDL_pixels.c.

References SDL_Color::b, SDL_PixelFormat::Bloss, SDL_PixelFormat::Bmask, SDL_PixelFormat::Bshift, SDL_Palette::colors, SDL_Color::g, SDL_PixelFormat::Gloss, SDL_PixelFormat::Gmask, SDL_PixelFormat::Gshift, SDL_Palette::ncolors, NULL, SDL_PixelFormat::palette, SDL_Color::r, SDL_PixelFormat::Rloss, SDL_PixelFormat::Rmask, SDL_PixelFormat::Rshift, and SDL_expand_byte.

830 {
831  if (format->palette == NULL) {
832  unsigned v;
833  v = (pixel & format->Rmask) >> format->Rshift;
834  *r = SDL_expand_byte[format->Rloss][v];
835  v = (pixel & format->Gmask) >> format->Gshift;
836  *g = SDL_expand_byte[format->Gloss][v];
837  v = (pixel & format->Bmask) >> format->Bshift;
838  *b = SDL_expand_byte[format->Bloss][v];
839  } else {
840  if (pixel < (unsigned)format->palette->ncolors) {
841  *r = format->palette->colors[pixel].r;
842  *g = format->palette->colors[pixel].g;
843  *b = format->palette->colors[pixel].b;
844  } else {
845  *r = *g = *b = 0;
846  }
847  }
848 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
Uint8 g
Definition: SDL_pixels.h:282
Uint8 b
Definition: SDL_pixels.h:283
GLboolean GLboolean g
const GLdouble * v
Definition: SDL_opengl.h:2057
Uint8 r
Definition: SDL_pixels.h:281
Uint8 * SDL_expand_byte[9]
Definition: SDL_pixels.c:71
#define NULL
Definition: begin_code.h:143
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Palette * palette
Definition: SDL_pixels.h:302
GLboolean GLboolean GLboolean b
void SDL_GetRGBA ( Uint32  pixel,
const SDL_PixelFormat format,
Uint8 r,
Uint8 g,
Uint8 b,
Uint8 a 
)

Get the RGBA components from a pixel of the specified format.

See also
SDL_GetRGB

Definition at line 851 of file SDL_pixels.c.

References SDL_Color::a, SDL_PixelFormat::Aloss, SDL_PixelFormat::Amask, SDL_PixelFormat::Ashift, SDL_Color::b, SDL_PixelFormat::Bloss, SDL_PixelFormat::Bmask, SDL_PixelFormat::Bshift, SDL_Palette::colors, SDL_Color::g, SDL_PixelFormat::Gloss, SDL_PixelFormat::Gmask, SDL_PixelFormat::Gshift, SDL_Palette::ncolors, NULL, SDL_PixelFormat::palette, SDL_Color::r, SDL_PixelFormat::Rloss, SDL_PixelFormat::Rmask, SDL_PixelFormat::Rshift, and SDL_expand_byte.

853 {
854  if (format->palette == NULL) {
855  unsigned v;
856  v = (pixel & format->Rmask) >> format->Rshift;
857  *r = SDL_expand_byte[format->Rloss][v];
858  v = (pixel & format->Gmask) >> format->Gshift;
859  *g = SDL_expand_byte[format->Gloss][v];
860  v = (pixel & format->Bmask) >> format->Bshift;
861  *b = SDL_expand_byte[format->Bloss][v];
862  v = (pixel & format->Amask) >> format->Ashift;
863  *a = SDL_expand_byte[format->Aloss][v];
864  } else {
865  if (pixel < (unsigned)format->palette->ncolors) {
866  *r = format->palette->colors[pixel].r;
867  *g = format->palette->colors[pixel].g;
868  *b = format->palette->colors[pixel].b;
869  *a = format->palette->colors[pixel].a;
870  } else {
871  *r = *g = *b = *a = 0;
872  }
873  }
874 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
Uint8 g
Definition: SDL_pixels.h:282
Uint8 b
Definition: SDL_pixels.h:283
GLboolean GLboolean g
const GLdouble * v
Definition: SDL_opengl.h:2057
Uint8 r
Definition: SDL_pixels.h:281
Uint8 a
Definition: SDL_pixels.h:284
Uint8 * SDL_expand_byte[9]
Definition: SDL_pixels.c:71
#define NULL
Definition: begin_code.h:143
SDL_Color * colors
Definition: SDL_pixels.h:291
SDL_Palette * palette
Definition: SDL_pixels.h:302
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean GLboolean b
int SDL_InitFormat ( SDL_PixelFormat format,
Uint32  pixel_format 
)

Definition at line 521 of file SDL_pixels.c.

References SDL_PixelFormat::Aloss, SDL_PixelFormat::Amask, SDL_PixelFormat::Ashift, SDL_PixelFormat::BitsPerPixel, SDL_PixelFormat::Bloss, SDL_PixelFormat::Bmask, SDL_PixelFormat::Bshift, SDL_PixelFormat::BytesPerPixel, SDL_PixelFormat::format, SDL_PixelFormat::Gloss, SDL_PixelFormat::Gmask, SDL_PixelFormat::Gshift, SDL_PixelFormat::next, NULL, SDL_PixelFormat::palette, pixel_format, SDL_PixelFormat::refcount, SDL_PixelFormat::Rloss, SDL_PixelFormat::Rmask, SDL_PixelFormat::Rshift, SDL_PixelFormatEnumToMasks(), and SDL_zerop.

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

522 {
523  int bpp;
524  Uint32 Rmask, Gmask, Bmask, Amask;
525  Uint32 mask;
526 
528  &Rmask, &Gmask, &Bmask, &Amask)) {
529  return -1;
530  }
531 
532  /* Set up the format */
533  SDL_zerop(format);
534  format->format = pixel_format;
535  format->BitsPerPixel = bpp;
536  format->BytesPerPixel = (bpp + 7) / 8;
537 
538  format->Rmask = Rmask;
539  format->Rshift = 0;
540  format->Rloss = 8;
541  if (Rmask) {
542  for (mask = Rmask; !(mask & 0x01); mask >>= 1)
543  ++format->Rshift;
544  for (; (mask & 0x01); mask >>= 1)
545  --format->Rloss;
546  }
547 
548  format->Gmask = Gmask;
549  format->Gshift = 0;
550  format->Gloss = 8;
551  if (Gmask) {
552  for (mask = Gmask; !(mask & 0x01); mask >>= 1)
553  ++format->Gshift;
554  for (; (mask & 0x01); mask >>= 1)
555  --format->Gloss;
556  }
557 
558  format->Bmask = Bmask;
559  format->Bshift = 0;
560  format->Bloss = 8;
561  if (Bmask) {
562  for (mask = Bmask; !(mask & 0x01); mask >>= 1)
563  ++format->Bshift;
564  for (; (mask & 0x01); mask >>= 1)
565  --format->Bloss;
566  }
567 
568  format->Amask = Amask;
569  format->Ashift = 0;
570  format->Aloss = 8;
571  if (Amask) {
572  for (mask = Amask; !(mask & 0x01); mask >>= 1)
573  ++format->Ashift;
574  for (; (mask & 0x01); mask >>= 1)
575  --format->Aloss;
576  }
577 
578  format->palette = NULL;
579  format->refcount = 1;
580  format->next = NULL;
581 
582  return 0;
583 }
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
Uint8 BytesPerPixel
Definition: SDL_pixels.h:304
SDL_bool SDL_PixelFormatEnumToMasks(Uint32 format, int *bpp, Uint32 *Rmask, Uint32 *Gmask, Uint32 *Bmask, Uint32 *Amask)
Convert one of the enumerated pixel formats to a bpp and RGBA masks.
Definition: SDL_pixels.c:134
#define SDL_zerop(x)
Definition: SDL_stdinc.h:356
Uint8 BitsPerPixel
Definition: SDL_pixels.h:303
GLenum GLint GLuint mask
#define NULL
Definition: begin_code.h:143
Uint32 pixel_format
Definition: testoverlay2.c:152
SDL_Palette * palette
Definition: SDL_pixels.h:302
struct SDL_PixelFormat * next
Definition: SDL_pixels.h:319
void SDL_InvalidateMap ( SDL_BlitMap map)

Definition at line 974 of file SDL_pixels.c.

References SDL_BlitMap::dst, SDL_BlitMap::dst_palette_version, SDL_BlitMap::info, NULL, SDL_Surface::refcount, SDL_free(), SDL_FreeSurface, SDL_BlitMap::src_palette_version, and SDL_BlitInfo::table.

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

975 {
976  if (!map) {
977  return;
978  }
979  if (map->dst) {
980  /* Release our reference to the surface - see the note below */
981  if (--map->dst->refcount <= 0) {
982  SDL_FreeSurface(map->dst);
983  }
984  }
985  map->dst = NULL;
986  map->src_palette_version = 0;
987  map->dst_palette_version = 0;
988  SDL_free(map->info.table);
989  map->info.table = NULL;
990 }
Uint8 * table
Definition: SDL_blit.h:67
Uint32 dst_palette_version
Definition: SDL_blit.h:95
Uint32 src_palette_version
Definition: SDL_blit.h:96
#define SDL_FreeSurface
void SDL_free(void *mem)
SDL_Surface * dst
Definition: SDL_blit.h:87
#define NULL
Definition: begin_code.h:143
SDL_BlitInfo info
Definition: SDL_blit.h:91
Uint32 SDL_MapRGB ( const SDL_PixelFormat format,
Uint8  r,
Uint8  g,
Uint8  b 
)

Maps an RGB triple to an opaque pixel value for a given pixel format.

See also
SDL_MapRGBA

Definition at line 801 of file SDL_pixels.c.

References SDL_PixelFormat::Amask, SDL_PixelFormat::Bloss, SDL_PixelFormat::Bshift, SDL_PixelFormat::Gloss, SDL_PixelFormat::Gshift, NULL, SDL_PixelFormat::palette, SDL_PixelFormat::Rloss, SDL_PixelFormat::Rshift, SDL_ALPHA_OPAQUE, and SDL_FindColor().

802 {
803  if (format->palette == NULL) {
804  return (r >> format->Rloss) << format->Rshift
805  | (g >> format->Gloss) << format->Gshift
806  | (b >> format->Bloss) << format->Bshift | format->Amask;
807  } else {
808  return SDL_FindColor(format->palette, r, g, b, SDL_ALPHA_OPAQUE);
809  }
810 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
GLboolean GLboolean g
Uint8 SDL_FindColor(SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_pixels.c:772
#define NULL
Definition: begin_code.h:143
SDL_Palette * palette
Definition: SDL_pixels.h:302
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:45
GLboolean GLboolean GLboolean b
Uint32 SDL_MapRGBA ( const SDL_PixelFormat format,
Uint8  r,
Uint8  g,
Uint8  b,
Uint8  a 
)

Maps an RGBA quadruple to a pixel value for a given pixel format.

See also
SDL_MapRGB

Definition at line 814 of file SDL_pixels.c.

References SDL_PixelFormat::Aloss, SDL_PixelFormat::Amask, SDL_PixelFormat::Ashift, SDL_PixelFormat::Bloss, SDL_PixelFormat::Bshift, SDL_PixelFormat::Gloss, SDL_PixelFormat::Gshift, NULL, SDL_PixelFormat::palette, SDL_PixelFormat::Rloss, SDL_PixelFormat::Rshift, and SDL_FindColor().

816 {
817  if (format->palette == NULL) {
818  return (r >> format->Rloss) << format->Rshift
819  | (g >> format->Gloss) << format->Gshift
820  | (b >> format->Bloss) << format->Bshift
821  | ((a >> format->Aloss) << format->Ashift & format->Amask);
822  } else {
823  return SDL_FindColor(format->palette, r, g, b, a);
824  }
825 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2072
GLboolean GLboolean g
Uint8 SDL_FindColor(SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_pixels.c:772
#define NULL
Definition: begin_code.h:143
SDL_Palette * palette
Definition: SDL_pixels.h:302
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean GLboolean b
int SDL_MapSurface ( SDL_Surface src,
SDL_Surface dst 
)

Definition at line 993 of file SDL_pixels.c.

References SDL_BlitInfo::a, SDL_BlitInfo::b, SDL_PixelFormat::BitsPerPixel, SDL_BlitMap::dst, SDL_BlitMap::dst_palette_version, SDL_Surface::flags, SDL_Surface::format, SDL_PixelFormat::format, SDL_BlitInfo::g, SDL_BlitMap::identity, SDL_BlitMap::info, SDL_Surface::map, map, Map1to1(), Map1toN(), MapNto1(), NULL, SDL_PixelFormat::palette, SDL_BlitInfo::r, SDL_Surface::refcount, SDL_CalculateBlit(), SDL_InvalidateMap(), SDL_ISPIXELFORMAT_INDEXED, SDL_RLEACCEL, SDL_UnRLESurface(), SDL_BlitMap::src_palette_version, SDL_BlitInfo::table, and SDL_Palette::version.

Referenced by SDL_LowerBlit().

994 {
995  SDL_PixelFormat *srcfmt;
996  SDL_PixelFormat *dstfmt;
997  SDL_BlitMap *map;
998 
999  /* Clear out any previous mapping */
1000  map = src->map;
1001  if ((src->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
1002  SDL_UnRLESurface(src, 1);
1003  }
1004  SDL_InvalidateMap(map);
1005 
1006  /* Figure out what kind of mapping we're doing */
1007  map->identity = 0;
1008  srcfmt = src->format;
1009  dstfmt = dst->format;
1010  if (SDL_ISPIXELFORMAT_INDEXED(srcfmt->format)) {
1011  if (SDL_ISPIXELFORMAT_INDEXED(dstfmt->format)) {
1012  /* Palette --> Palette */
1013  map->info.table =
1014  Map1to1(srcfmt->palette, dstfmt->palette, &map->identity);
1015  if (!map->identity) {
1016  if (map->info.table == NULL) {
1017  return (-1);
1018  }
1019  }
1020  if (srcfmt->BitsPerPixel != dstfmt->BitsPerPixel)
1021  map->identity = 0;
1022  } else {
1023  /* Palette --> BitField */
1024  map->info.table =
1025  Map1toN(srcfmt, src->map->info.r, src->map->info.g,
1026  src->map->info.b, src->map->info.a, dstfmt);
1027  if (map->info.table == NULL) {
1028  return (-1);
1029  }
1030  }
1031  } else {
1032  if (SDL_ISPIXELFORMAT_INDEXED(dstfmt->format)) {
1033  /* BitField --> Palette */
1034  map->info.table = MapNto1(srcfmt, dstfmt, &map->identity);
1035  if (!map->identity) {
1036  if (map->info.table == NULL) {
1037  return (-1);
1038  }
1039  }
1040  map->identity = 0; /* Don't optimize to copy */
1041  } else {
1042  /* BitField --> BitField */
1043  if (srcfmt == dstfmt) {
1044  map->identity = 1;
1045  }
1046  }
1047  }
1048 
1049  map->dst = dst;
1050 
1051  if (map->dst) {
1052  /* Keep a reference to this surface so it doesn't get deleted
1053  while we're still pointing at it.
1054 
1055  A better method would be for the destination surface to keep
1056  track of surfaces that are mapped to it and automatically
1057  invalidate them when it is freed, but this will do for now.
1058  */
1059  ++map->dst->refcount;
1060  }
1061 
1062  if (dstfmt->palette) {
1063  map->dst_palette_version = dstfmt->palette->version;
1064  } else {
1065  map->dst_palette_version = 0;
1066  }
1067 
1068  if (srcfmt->palette) {
1069  map->src_palette_version = srcfmt->palette->version;
1070  } else {
1071  map->src_palette_version = 0;
1072  }
1073 
1074  /* Choose your blitters wisely */
1075  return (SDL_CalculateBlit(src));
1076 }
Uint8 * table
Definition: SDL_blit.h:67
GLenum GLenum dst
Uint8 r
Definition: SDL_blit.h:70
Uint32 version
Definition: SDL_pixels.h:292
Uint8 b
Definition: SDL_blit.h:70
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:133
Uint8 g
Definition: SDL_blit.h:70
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Uint32 dst_palette_version
Definition: SDL_blit.h:95
Uint32 flags
Definition: SDL_surface.h:71
Uint32 src_palette_version
Definition: SDL_blit.h:96
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:974
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
static Uint8 * Map1to1(SDL_Palette *src, SDL_Palette *dst, int *identical)
Definition: SDL_pixels.c:878
Uint8 BitsPerPixel
Definition: SDL_pixels.h:303
int SDL_CalculateBlit(SDL_Surface *surface)
Definition: SDL_blit.c:216
static Uint8 * MapNto1(SDL_PixelFormat *src, SDL_PixelFormat *dst, int *identical)
Definition: SDL_pixels.c:940
SDL_Surface * dst
Definition: SDL_blit.h:87
#define NULL
Definition: begin_code.h:143
SDL_PixelFormat * format
Definition: SDL_surface.h:72
static Uint8 * Map1toN(SDL_PixelFormat *src, Uint8 Rmod, Uint8 Gmod, Uint8 Bmod, Uint8 Amod, SDL_PixelFormat *dst)
Definition: SDL_pixels.c:912
SDL_Palette * palette
Definition: SDL_pixels.h:302
const GLubyte GLuint GLuint GLuint GLuint alpha GLboolean GLboolean GLboolean GLboolean alpha GLint GLint GLsizei GLsizei GLenum type GLenum GLint GLenum GLint GLint GLsizei GLsizei GLint border GLenum GLint GLint GLint GLint GLint GLsizei GLsizei height GLsizei GLsizei GLenum GLenum const GLvoid *pixels GLenum GLint GLint GLint GLint j2 GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLfloat *params GLenum GLint GLenum GLenum GLvoid *pixels GLenum GLint GLenum GLint *params GLenum GLenum GLint *params GLenum GLsizei const GLvoid *pointer GLenum GLenum const GLint *params GLenum GLfloat GLfloat GLint GLint const GLfloat *points GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat *points GLint GLfloat GLfloat GLint GLfloat GLfloat v2 GLenum GLenum const GLint *params GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum map
Definition: SDL_glfuncs.h:289
int identity
Definition: SDL_blit.h:88
SDL_BlitInfo info
Definition: SDL_blit.h:91
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
Uint8 a
Definition: SDL_blit.h:70
Uint32 SDL_MasksToPixelFormatEnum ( int  bpp,
Uint32  Rmask,
Uint32  Gmask,
Uint32  Bmask,
Uint32  Amask 
)

Convert a bpp and RGBA masks to an enumerated pixel format.

Returns
The pixel format, or SDL_PIXELFORMAT_UNKNOWN if the conversion wasn't possible.
See also
SDL_PixelFormatEnumToMasks()

Definition at line 293 of file SDL_pixels.c.

References SDL_PIXELFORMAT_ABGR1555, SDL_PIXELFORMAT_ABGR4444, SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB1555, SDL_PIXELFORMAT_ARGB2101010, SDL_PIXELFORMAT_ARGB4444, SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR24, SDL_PIXELFORMAT_BGR555, SDL_PIXELFORMAT_BGR565, SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGRA4444, SDL_PIXELFORMAT_BGRA5551, SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGRX8888, SDL_PIXELFORMAT_INDEX1MSB, SDL_PIXELFORMAT_INDEX4MSB, SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_RGB24, SDL_PIXELFORMAT_RGB332, SDL_PIXELFORMAT_RGB444, SDL_PIXELFORMAT_RGB555, SDL_PIXELFORMAT_RGB565, SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGBA4444, SDL_PIXELFORMAT_RGBA5551, SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGBX8888, and SDL_PIXELFORMAT_UNKNOWN.

295 {
296  switch (bpp) {
297  case 1:
298  /* SDL defaults to MSB ordering */
300  case 4:
301  /* SDL defaults to MSB ordering */
303  case 8:
304  if (Rmask == 0) {
305  return SDL_PIXELFORMAT_INDEX8;
306  }
307  if (Rmask == 0xE0 &&
308  Gmask == 0x1C &&
309  Bmask == 0x03 &&
310  Amask == 0x00) {
311  return SDL_PIXELFORMAT_RGB332;
312  }
313  break;
314  case 12:
315  if (Rmask == 0) {
316  return SDL_PIXELFORMAT_RGB444;
317  }
318  if (Rmask == 0x0F00 &&
319  Gmask == 0x00F0 &&
320  Bmask == 0x000F &&
321  Amask == 0x0000) {
322  return SDL_PIXELFORMAT_RGB444;
323  }
324  break;
325  case 15:
326  if (Rmask == 0) {
327  return SDL_PIXELFORMAT_RGB555;
328  }
329  /* Fall through to 16-bit checks */
330  case 16:
331  if (Rmask == 0) {
332  return SDL_PIXELFORMAT_RGB565;
333  }
334  if (Rmask == 0x7C00 &&
335  Gmask == 0x03E0 &&
336  Bmask == 0x001F &&
337  Amask == 0x0000) {
338  return SDL_PIXELFORMAT_RGB555;
339  }
340  if (Rmask == 0x001F &&
341  Gmask == 0x03E0 &&
342  Bmask == 0x7C00 &&
343  Amask == 0x0000) {
344  return SDL_PIXELFORMAT_BGR555;
345  }
346  if (Rmask == 0x0F00 &&
347  Gmask == 0x00F0 &&
348  Bmask == 0x000F &&
349  Amask == 0xF000) {
351  }
352  if (Rmask == 0xF000 &&
353  Gmask == 0x0F00 &&
354  Bmask == 0x00F0 &&
355  Amask == 0x000F) {
357  }
358  if (Rmask == 0x000F &&
359  Gmask == 0x00F0 &&
360  Bmask == 0x0F00 &&
361  Amask == 0xF000) {
363  }
364  if (Rmask == 0x00F0 &&
365  Gmask == 0x0F00 &&
366  Bmask == 0xF000 &&
367  Amask == 0x000F) {
369  }
370  if (Rmask == 0x7C00 &&
371  Gmask == 0x03E0 &&
372  Bmask == 0x001F &&
373  Amask == 0x8000) {
375  }
376  if (Rmask == 0xF800 &&
377  Gmask == 0x07C0 &&
378  Bmask == 0x003E &&
379  Amask == 0x0001) {
381  }
382  if (Rmask == 0x001F &&
383  Gmask == 0x03E0 &&
384  Bmask == 0x7C00 &&
385  Amask == 0x8000) {
387  }
388  if (Rmask == 0x003E &&
389  Gmask == 0x07C0 &&
390  Bmask == 0xF800 &&
391  Amask == 0x0001) {
393  }
394  if (Rmask == 0xF800 &&
395  Gmask == 0x07E0 &&
396  Bmask == 0x001F &&
397  Amask == 0x0000) {
398  return SDL_PIXELFORMAT_RGB565;
399  }
400  if (Rmask == 0x001F &&
401  Gmask == 0x07E0 &&
402  Bmask == 0xF800 &&
403  Amask == 0x0000) {
404  return SDL_PIXELFORMAT_BGR565;
405  }
406  break;
407  case 24:
408  switch (Rmask) {
409  case 0:
410  case 0x00FF0000:
411 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
412  return SDL_PIXELFORMAT_RGB24;
413 #else
414  return SDL_PIXELFORMAT_BGR24;
415 #endif
416  case 0x000000FF:
417 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
418  return SDL_PIXELFORMAT_BGR24;
419 #else
420  return SDL_PIXELFORMAT_RGB24;
421 #endif
422  }
423  case 32:
424  if (Rmask == 0) {
425  return SDL_PIXELFORMAT_RGB888;
426  }
427  if (Rmask == 0x00FF0000 &&
428  Gmask == 0x0000FF00 &&
429  Bmask == 0x000000FF &&
430  Amask == 0x00000000) {
431  return SDL_PIXELFORMAT_RGB888;
432  }
433  if (Rmask == 0xFF000000 &&
434  Gmask == 0x00FF0000 &&
435  Bmask == 0x0000FF00 &&
436  Amask == 0x00000000) {
438  }
439  if (Rmask == 0x000000FF &&
440  Gmask == 0x0000FF00 &&
441  Bmask == 0x00FF0000 &&
442  Amask == 0x00000000) {
443  return SDL_PIXELFORMAT_BGR888;
444  }
445  if (Rmask == 0x0000FF00 &&
446  Gmask == 0x00FF0000 &&
447  Bmask == 0xFF000000 &&
448  Amask == 0x00000000) {
450  }
451  if (Rmask == 0x00FF0000 &&
452  Gmask == 0x0000FF00 &&
453  Bmask == 0x000000FF &&
454  Amask == 0xFF000000) {
456  }
457  if (Rmask == 0xFF000000 &&
458  Gmask == 0x00FF0000 &&
459  Bmask == 0x0000FF00 &&
460  Amask == 0x000000FF) {
462  }
463  if (Rmask == 0x000000FF &&
464  Gmask == 0x0000FF00 &&
465  Bmask == 0x00FF0000 &&
466  Amask == 0xFF000000) {
468  }
469  if (Rmask == 0x0000FF00 &&
470  Gmask == 0x00FF0000 &&
471  Bmask == 0xFF000000 &&
472  Amask == 0x000000FF) {
474  }
475  if (Rmask == 0x3FF00000 &&
476  Gmask == 0x000FFC00 &&
477  Bmask == 0x000003FF &&
478  Amask == 0xC0000000) {
480  }
481  }
483 }
SDL_bool SDL_PixelFormatEnumToMasks ( Uint32  format,
int *  bpp,
Uint32 Rmask,
Uint32 Gmask,
Uint32 Bmask,
Uint32 Amask 
)

Convert one of the enumerated pixel formats to a bpp and RGBA masks.

Returns
SDL_TRUE, or SDL_FALSE if the conversion wasn't possible.
See also
SDL_MasksToPixelFormatEnum()

Definition at line 134 of file SDL_pixels.c.

References SDL_BITSPERPIXEL, SDL_BYTESPERPIXEL, SDL_FALSE, SDL_ISPIXELFORMAT_FOURCC, SDL_PACKEDLAYOUT_1010102, SDL_PACKEDLAYOUT_1555, SDL_PACKEDLAYOUT_2101010, SDL_PACKEDLAYOUT_332, SDL_PACKEDLAYOUT_4444, SDL_PACKEDLAYOUT_5551, SDL_PACKEDLAYOUT_565, SDL_PACKEDLAYOUT_8888, SDL_PACKEDORDER_ABGR, SDL_PACKEDORDER_ARGB, SDL_PACKEDORDER_BGRA, SDL_PACKEDORDER_BGRX, SDL_PACKEDORDER_RGBA, SDL_PACKEDORDER_RGBX, SDL_PACKEDORDER_XBGR, SDL_PACKEDORDER_XRGB, SDL_PIXELFORMAT_BGR24, SDL_PIXELFORMAT_RGB24, SDL_PIXELLAYOUT, SDL_PIXELORDER, SDL_PIXELTYPE, SDL_PIXELTYPE_PACKED16, SDL_PIXELTYPE_PACKED32, SDL_PIXELTYPE_PACKED8, SDL_SetError, and SDL_TRUE.

Referenced by SDL_InitFormat().

136 {
137  Uint32 masks[4];
138 
139  /* This function doesn't work with FourCC pixel formats */
141  SDL_SetError("FOURCC pixel formats are not supported");
142  return SDL_FALSE;
143  }
144 
145  /* Initialize the values here */
146  if (SDL_BYTESPERPIXEL(format) <= 2) {
147  *bpp = SDL_BITSPERPIXEL(format);
148  } else {
149  *bpp = SDL_BYTESPERPIXEL(format) * 8;
150  }
151  *Rmask = *Gmask = *Bmask = *Amask = 0;
152 
153  if (format == SDL_PIXELFORMAT_RGB24) {
154 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
155  *Rmask = 0x00FF0000;
156  *Gmask = 0x0000FF00;
157  *Bmask = 0x000000FF;
158 #else
159  *Rmask = 0x000000FF;
160  *Gmask = 0x0000FF00;
161  *Bmask = 0x00FF0000;
162 #endif
163  return SDL_TRUE;
164  }
165 
166  if (format == SDL_PIXELFORMAT_BGR24) {
167 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
168  *Rmask = 0x000000FF;
169  *Gmask = 0x0000FF00;
170  *Bmask = 0x00FF0000;
171 #else
172  *Rmask = 0x00FF0000;
173  *Gmask = 0x0000FF00;
174  *Bmask = 0x000000FF;
175 #endif
176  return SDL_TRUE;
177  }
178 
182  /* Not a format that uses masks */
183  return SDL_TRUE;
184  }
185 
186  switch (SDL_PIXELLAYOUT(format)) {
188  masks[0] = 0x00000000;
189  masks[1] = 0x000000E0;
190  masks[2] = 0x0000001C;
191  masks[3] = 0x00000003;
192  break;
194  masks[0] = 0x0000F000;
195  masks[1] = 0x00000F00;
196  masks[2] = 0x000000F0;
197  masks[3] = 0x0000000F;
198  break;
200  masks[0] = 0x00008000;
201  masks[1] = 0x00007C00;
202  masks[2] = 0x000003E0;
203  masks[3] = 0x0000001F;
204  break;
206  masks[0] = 0x0000F800;
207  masks[1] = 0x000007C0;
208  masks[2] = 0x0000003E;
209  masks[3] = 0x00000001;
210  break;
212  masks[0] = 0x00000000;
213  masks[1] = 0x0000F800;
214  masks[2] = 0x000007E0;
215  masks[3] = 0x0000001F;
216  break;
218  masks[0] = 0xFF000000;
219  masks[1] = 0x00FF0000;
220  masks[2] = 0x0000FF00;
221  masks[3] = 0x000000FF;
222  break;
224  masks[0] = 0xC0000000;
225  masks[1] = 0x3FF00000;
226  masks[2] = 0x000FFC00;
227  masks[3] = 0x000003FF;
228  break;
230  masks[0] = 0xFFC00000;
231  masks[1] = 0x003FF000;
232  masks[2] = 0x00000FFC;
233  masks[3] = 0x00000003;
234  break;
235  default:
236  SDL_SetError("Unknown pixel format");
237  return SDL_FALSE;
238  }
239 
240  switch (SDL_PIXELORDER(format)) {
242  *Rmask = masks[1];
243  *Gmask = masks[2];
244  *Bmask = masks[3];
245  break;
247  *Rmask = masks[0];
248  *Gmask = masks[1];
249  *Bmask = masks[2];
250  break;
252  *Amask = masks[0];
253  *Rmask = masks[1];
254  *Gmask = masks[2];
255  *Bmask = masks[3];
256  break;
258  *Rmask = masks[0];
259  *Gmask = masks[1];
260  *Bmask = masks[2];
261  *Amask = masks[3];
262  break;
264  *Bmask = masks[1];
265  *Gmask = masks[2];
266  *Rmask = masks[3];
267  break;
269  *Bmask = masks[0];
270  *Gmask = masks[1];
271  *Rmask = masks[2];
272  break;
274  *Bmask = masks[0];
275  *Gmask = masks[1];
276  *Rmask = masks[2];
277  *Amask = masks[3];
278  break;
280  *Amask = masks[0];
281  *Bmask = masks[1];
282  *Gmask = masks[2];
283  *Rmask = masks[3];
284  break;
285  default:
286  SDL_SetError("Unknown pixel format");
287  return SDL_FALSE;
288  }
289  return SDL_TRUE;
290 }
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
#define SDL_PIXELLAYOUT(X)
Definition: SDL_pixels.h:125
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:127
#define SDL_PIXELORDER(X)
Definition: SDL_pixels.h:124
#define SDL_PIXELTYPE(X)
Definition: SDL_pixels.h:123
#define SDL_SetError
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:166
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:126
int SDL_SetPaletteColors ( SDL_Palette palette,
const SDL_Color colors,
int  firstcolor,
int  ncolors 
)

Set a range of colors in a palette.

Parameters
paletteThe palette to modify.
colorsAn array of colors to copy into the palette.
firstcolorThe index of the first palette entry to modify.
ncolorsThe number of entries to modify.
Returns
0 on success, or -1 if not all of the colors could be set.

Definition at line 676 of file SDL_pixels.c.

References SDL_Palette::colors, SDL_Palette::ncolors, SDL_memcpy, and SDL_Palette::version.

678 {
679  int status = 0;
680 
681  /* Verify the parameters */
682  if (!palette) {
683  return -1;
684  }
685  if (ncolors > (palette->ncolors - firstcolor)) {
686  ncolors = (palette->ncolors - firstcolor);
687  status = -1;
688  }
689 
690  if (colors != (palette->colors + firstcolor)) {
691  SDL_memcpy(palette->colors + firstcolor, colors,
692  ncolors * sizeof(*colors));
693  }
694  ++palette->version;
695  if (!palette->version) {
696  palette->version = 1;
697  }
698 
699  return status;
700 }
Uint32 version
Definition: SDL_pixels.h:292
#define SDL_memcpy
SDL_Color * colors
Definition: SDL_pixels.h:291
int SDL_SetPixelFormatPalette ( SDL_PixelFormat format,
SDL_Palette palette 
)

Set the palette for a pixel format structure.

Definition at line 648 of file SDL_pixels.c.

References SDL_PixelFormat::BitsPerPixel, SDL_Palette::ncolors, SDL_PixelFormat::palette, SDL_Palette::refcount, SDL_FreePalette(), and SDL_SetError.

649 {
650  if (!format) {
651  return SDL_SetError("SDL_SetPixelFormatPalette() passed NULL format");
652  }
653 
654  if (palette && palette->ncolors != (1 << format->BitsPerPixel)) {
655  return SDL_SetError("SDL_SetPixelFormatPalette() passed a palette that doesn't match the format");
656  }
657 
658  if (format->palette == palette) {
659  return 0;
660  }
661 
662  if (format->palette) {
663  SDL_FreePalette(format->palette);
664  }
665 
666  format->palette = palette;
667 
668  if (format->palette) {
669  ++format->palette->refcount;
670  }
671 
672  return 0;
673 }
Uint8 BitsPerPixel
Definition: SDL_pixels.h:303
void SDL_FreePalette(SDL_Palette *palette)
Free a palette created with SDL_AllocPalette().
Definition: SDL_pixels.c:703
#define SDL_SetError
SDL_Palette * palette
Definition: SDL_pixels.h:302

Variable Documentation

SDL_PixelFormat* formats
static

Definition at line 485 of file SDL_pixels.c.

Referenced by main(), and SDL_AllocFormat().

Uint8 lookup_0[]
static
Initial value:
= {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
}

Definition at line 35 of file SDL_pixels.c.

Uint8 lookup_1[]
static
Initial value:
= {
0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 255
}

Definition at line 39 of file SDL_pixels.c.

Uint8 lookup_2[]
static
Initial value:
= {
0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 255
}

Definition at line 43 of file SDL_pixels.c.

Uint8 lookup_3[]
static
Initial value:
= {
0, 8, 16, 24, 32, 41, 49, 57, 65, 74, 82, 90, 98, 106, 115, 123, 131, 139, 148, 156, 164, 172, 180, 189, 197, 205, 213, 222, 230, 238, 246, 255
}

Definition at line 47 of file SDL_pixels.c.

Uint8 lookup_4[]
static
Initial value:
= {
0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255
}

Definition at line 51 of file SDL_pixels.c.

Uint8 lookup_5[]
static
Initial value:
= {
0, 36, 72, 109, 145, 182, 218, 255
}

Definition at line 55 of file SDL_pixels.c.

Uint8 lookup_6[]
static
Initial value:
= {
0, 85, 170, 255
}

Definition at line 59 of file SDL_pixels.c.

Uint8 lookup_7[]
static
Initial value:
= {
0, 255
}

Definition at line 63 of file SDL_pixels.c.

Uint8 lookup_8[]
static
Initial value:
= {
255
}

Definition at line 67 of file SDL_pixels.c.

Uint8* SDL_expand_byte[9]
Initial value:
= {
}
static Uint8 lookup_5[]
Definition: SDL_pixels.c:55
static Uint8 lookup_0[]
Definition: SDL_pixels.c:35
static Uint8 lookup_4[]
Definition: SDL_pixels.c:51
static Uint8 lookup_2[]
Definition: SDL_pixels.c:43
static Uint8 lookup_7[]
Definition: SDL_pixels.c:63
static Uint8 lookup_1[]
Definition: SDL_pixels.c:39
static Uint8 lookup_8[]
Definition: SDL_pixels.c:67
static Uint8 lookup_3[]
Definition: SDL_pixels.c:47
static Uint8 lookup_6[]
Definition: SDL_pixels.c:59

Definition at line 71 of file SDL_pixels.c.

Referenced by SDL_GetRGB(), and SDL_GetRGBA().