SDL  2.0
SDL_pixels.h File Reference
#include "SDL_stdinc.h"
#include "SDL_endian.h"
#include "begin_code.h"
#include "close_code.h"
+ Include dependency graph for SDL_pixels.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  SDL_Color
 
struct  SDL_Palette
 
struct  SDL_PixelFormat
 

Macros

#define SDL_DEFINE_PIXELFOURCC(A, B, C, D)   SDL_FOURCC(A, B, C, D)
 
#define SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes)
 
#define SDL_PIXELFLAG(X)   (((X) >> 28) & 0x0F)
 
#define SDL_PIXELTYPE(X)   (((X) >> 24) & 0x0F)
 
#define SDL_PIXELORDER(X)   (((X) >> 20) & 0x0F)
 
#define SDL_PIXELLAYOUT(X)   (((X) >> 16) & 0x0F)
 
#define SDL_BITSPERPIXEL(X)   (((X) >> 8) & 0xFF)
 
#define SDL_BYTESPERPIXEL(X)
 
#define SDL_ISPIXELFORMAT_INDEXED(format)
 
#define SDL_ISPIXELFORMAT_PACKED(format)
 
#define SDL_ISPIXELFORMAT_ARRAY(format)
 
#define SDL_ISPIXELFORMAT_ALPHA(format)
 
#define SDL_ISPIXELFORMAT_FOURCC(format)   ((format) && (SDL_PIXELFLAG(format) != 1))
 
#define SDL_Colour   SDL_Color
 
Transparency definitions

These define alpha as the opacity of a surface.

#define SDL_ALPHA_OPAQUE   255
 
#define SDL_ALPHA_TRANSPARENT   0
 

Enumerations

enum  {
  SDL_PIXELTYPE_UNKNOWN,
  SDL_PIXELTYPE_INDEX1,
  SDL_PIXELTYPE_INDEX4,
  SDL_PIXELTYPE_INDEX8,
  SDL_PIXELTYPE_PACKED8,
  SDL_PIXELTYPE_PACKED16,
  SDL_PIXELTYPE_PACKED32,
  SDL_PIXELTYPE_ARRAYU8,
  SDL_PIXELTYPE_ARRAYU16,
  SDL_PIXELTYPE_ARRAYU32,
  SDL_PIXELTYPE_ARRAYF16,
  SDL_PIXELTYPE_ARRAYF32
}
 
enum  {
  SDL_BITMAPORDER_NONE,
  SDL_BITMAPORDER_4321,
  SDL_BITMAPORDER_1234
}
 
enum  {
  SDL_PACKEDORDER_NONE,
  SDL_PACKEDORDER_XRGB,
  SDL_PACKEDORDER_RGBX,
  SDL_PACKEDORDER_ARGB,
  SDL_PACKEDORDER_RGBA,
  SDL_PACKEDORDER_XBGR,
  SDL_PACKEDORDER_BGRX,
  SDL_PACKEDORDER_ABGR,
  SDL_PACKEDORDER_BGRA
}
 
enum  {
  SDL_ARRAYORDER_NONE,
  SDL_ARRAYORDER_RGB,
  SDL_ARRAYORDER_RGBA,
  SDL_ARRAYORDER_ARGB,
  SDL_ARRAYORDER_BGR,
  SDL_ARRAYORDER_BGRA,
  SDL_ARRAYORDER_ABGR
}
 
enum  {
  SDL_PACKEDLAYOUT_NONE,
  SDL_PACKEDLAYOUT_332,
  SDL_PACKEDLAYOUT_4444,
  SDL_PACKEDLAYOUT_1555,
  SDL_PACKEDLAYOUT_5551,
  SDL_PACKEDLAYOUT_565,
  SDL_PACKEDLAYOUT_8888,
  SDL_PACKEDLAYOUT_2101010,
  SDL_PACKEDLAYOUT_1010102
}
 
enum  {
  SDL_PIXELFORMAT_UNKNOWN,
  SDL_PIXELFORMAT_INDEX1LSB,
  SDL_PIXELFORMAT_INDEX1MSB,
  SDL_PIXELFORMAT_INDEX4LSB,
  SDL_PIXELFORMAT_INDEX4MSB,
  SDL_PIXELFORMAT_INDEX8,
  SDL_PIXELFORMAT_RGB332,
  SDL_PIXELFORMAT_RGB444,
  SDL_PIXELFORMAT_RGB555,
  SDL_PIXELFORMAT_BGR555,
  SDL_PIXELFORMAT_ARGB4444,
  SDL_PIXELFORMAT_RGBA4444,
  SDL_PIXELFORMAT_ABGR4444,
  SDL_PIXELFORMAT_BGRA4444,
  SDL_PIXELFORMAT_ARGB1555,
  SDL_PIXELFORMAT_RGBA5551,
  SDL_PIXELFORMAT_ABGR1555,
  SDL_PIXELFORMAT_BGRA5551,
  SDL_PIXELFORMAT_RGB565,
  SDL_PIXELFORMAT_BGR565,
  SDL_PIXELFORMAT_RGB24,
  SDL_PIXELFORMAT_BGR24,
  SDL_PIXELFORMAT_RGB888,
  SDL_PIXELFORMAT_RGBX8888,
  SDL_PIXELFORMAT_BGR888,
  SDL_PIXELFORMAT_BGRX8888,
  SDL_PIXELFORMAT_ARGB8888,
  SDL_PIXELFORMAT_RGBA8888,
  SDL_PIXELFORMAT_ABGR8888,
  SDL_PIXELFORMAT_BGRA8888,
  SDL_PIXELFORMAT_ARGB2101010,
  SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_ABGR8888,
  SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_BGRA8888,
  SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_ARGB8888,
  SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_RGBA8888,
  SDL_PIXELFORMAT_YV12,
  SDL_PIXELFORMAT_IYUV,
  SDL_PIXELFORMAT_YUY2,
  SDL_PIXELFORMAT_UYVY,
  SDL_PIXELFORMAT_YVYU,
  SDL_PIXELFORMAT_NV12,
  SDL_PIXELFORMAT_NV21,
  SDL_PIXELFORMAT_EXTERNAL_OES =
}
 

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...
 
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...
 
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...
 
void SDL_CalculateGammaRamp (float gamma, Uint16 *ramp)
 Calculate a 256 entry gamma ramp for a gamma value. More...
 

Detailed Description

Header for the enumerated pixel format definitions.

Definition in file SDL_pixels.h.

Macro Definition Documentation

◆ SDL_ALPHA_OPAQUE

◆ SDL_ALPHA_TRANSPARENT

#define SDL_ALPHA_TRANSPARENT   0

Definition at line 47 of file SDL_pixels.h.

Referenced by SDL_SetColorKey().

◆ SDL_BITSPERPIXEL

#define SDL_BITSPERPIXEL (   X)    (((X) >> 8) & 0xFF)

◆ SDL_BYTESPERPIXEL

#define SDL_BYTESPERPIXEL (   X)
Value:
((((X) == SDL_PIXELFORMAT_YUY2) || \
((X) == SDL_PIXELFORMAT_UYVY) || \
((X) == SDL_PIXELFORMAT_YVYU)) ? 2 : 1) : (((X) >> 0) & 0xFF))
set set set set set set set set set set set set set set set set set set set set *set set set macro pixldst op &r &cond WK op &r &cond WK op &r &cond WK else op &m &cond &ia op &r &cond WK else op &m &cond &ia elseif elseif else error unsupported base if elseif elseif else error unsupported unaligned pixldst unaligned endm macro pixst base base else pixldst base endif endm macro PF base if bpp PF set rept prefetch_distance PF set OFFSET endr endif endm macro preload_leading_step2 base if bpp ifc DST PF PF else if bpp lsl PF PF lsl PF PF lsl PF PF PF else PF lsl PF lsl PF lsl PF endif SIZE macro preload_middle scratch_holds_offset if bpp if else PF PF endif endif endif endm macro preload_trailing base if bpp if bpp *pix_per_block PF PF lsl PF PF PF PF PF else PF lsl PF X
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167

Definition at line 128 of file SDL_pixels.h.

Referenced by SDL_CalculatePitch(), SDL_ConvertPixels(), SDL_CreateTexture(), SDL_CreateWindowTexture(), SDL_LockTextureNative(), SDL_PixelFormatEnumToMasks(), SDL_RenderReadPixels(), SDL_UnlockTextureNative(), SDL_UpdateTextureNative(), SDL_UpdateTextureYUV(), and SDL_UpdateTextureYUVPlanar().

◆ SDL_Colour

#define SDL_Colour   SDL_Color

Definition at line 302 of file SDL_pixels.h.

◆ SDL_DEFINE_PIXELFORMAT

#define SDL_DEFINE_PIXELFORMAT (   type,
  order,
  layout,
  bits,
  bytes 
)
Value:
((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | \
((bits) << 8) | ((bytes) << 0))
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
GLfixed GLfixed GLint GLint order
GLuint GLuint GLsizei GLenum type
Definition: SDL_opengl.h:1571

Definition at line 119 of file SDL_pixels.h.

◆ SDL_DEFINE_PIXELFOURCC

#define SDL_DEFINE_PIXELFOURCC (   A,
  B,
  C,
 
)    SDL_FOURCC(A, B, C, D)

Definition at line 117 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_ALPHA

◆ SDL_ISPIXELFORMAT_ARRAY

#define SDL_ISPIXELFORMAT_ARRAY (   format)

◆ SDL_ISPIXELFORMAT_FOURCC

◆ SDL_ISPIXELFORMAT_INDEXED

#define SDL_ISPIXELFORMAT_INDEXED (   format)

◆ SDL_ISPIXELFORMAT_PACKED

#define SDL_ISPIXELFORMAT_PACKED (   format)
Value:
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
#define SDL_PIXELTYPE(X)
Definition: SDL_pixels.h:124
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167

Definition at line 140 of file SDL_pixels.h.

◆ SDL_PIXELFLAG

#define SDL_PIXELFLAG (   X)    (((X) >> 28) & 0x0F)

Definition at line 123 of file SDL_pixels.h.

◆ SDL_PIXELLAYOUT

#define SDL_PIXELLAYOUT (   X)    (((X) >> 16) & 0x0F)

Definition at line 126 of file SDL_pixels.h.

Referenced by cmpmodes(), SDL_PixelFormatEnumToMasks(), and SW_RenderCopyEx().

◆ SDL_PIXELORDER

#define SDL_PIXELORDER (   X)    (((X) >> 20) & 0x0F)

Definition at line 125 of file SDL_pixels.h.

Referenced by SDL_PixelFormatEnumToMasks().

◆ SDL_PIXELTYPE

#define SDL_PIXELTYPE (   X)    (((X) >> 24) & 0x0F)

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Pixel type.

Enumerator
SDL_PIXELTYPE_UNKNOWN 
SDL_PIXELTYPE_INDEX1 
SDL_PIXELTYPE_INDEX4 
SDL_PIXELTYPE_INDEX8 
SDL_PIXELTYPE_PACKED8 
SDL_PIXELTYPE_PACKED16 
SDL_PIXELTYPE_PACKED32 
SDL_PIXELTYPE_ARRAYU8 
SDL_PIXELTYPE_ARRAYU16 
SDL_PIXELTYPE_ARRAYU32 
SDL_PIXELTYPE_ARRAYF16 
SDL_PIXELTYPE_ARRAYF32 

Definition at line 51 of file SDL_pixels.h.

◆ anonymous enum

anonymous enum

Bitmap pixel order, high bit -> low bit.

Enumerator
SDL_BITMAPORDER_NONE 
SDL_BITMAPORDER_4321 
SDL_BITMAPORDER_1234 

Definition at line 68 of file SDL_pixels.h.

◆ anonymous enum

anonymous enum

Packed component order, high bit -> low bit.

Enumerator
SDL_PACKEDORDER_NONE 
SDL_PACKEDORDER_XRGB 
SDL_PACKEDORDER_RGBX 
SDL_PACKEDORDER_ARGB 
SDL_PACKEDORDER_RGBA 
SDL_PACKEDORDER_XBGR 
SDL_PACKEDORDER_BGRX 
SDL_PACKEDORDER_ABGR 
SDL_PACKEDORDER_BGRA 

Definition at line 76 of file SDL_pixels.h.

◆ anonymous enum

anonymous enum

Array component order, low byte -> high byte.

Enumerator
SDL_ARRAYORDER_NONE 
SDL_ARRAYORDER_RGB 
SDL_ARRAYORDER_RGBA 
SDL_ARRAYORDER_ARGB 
SDL_ARRAYORDER_BGR 
SDL_ARRAYORDER_BGRA 
SDL_ARRAYORDER_ABGR 

Definition at line 92 of file SDL_pixels.h.

◆ anonymous enum

anonymous enum

Packed component layout.

Enumerator
SDL_PACKEDLAYOUT_NONE 
SDL_PACKEDLAYOUT_332 
SDL_PACKEDLAYOUT_4444 
SDL_PACKEDLAYOUT_1555 
SDL_PACKEDLAYOUT_5551 
SDL_PACKEDLAYOUT_565 
SDL_PACKEDLAYOUT_8888 
SDL_PACKEDLAYOUT_2101010 
SDL_PACKEDLAYOUT_1010102 

Definition at line 104 of file SDL_pixels.h.

◆ anonymous enum

anonymous enum
Enumerator
SDL_PIXELFORMAT_UNKNOWN 
SDL_PIXELFORMAT_INDEX1LSB 
SDL_PIXELFORMAT_INDEX1MSB 
SDL_PIXELFORMAT_INDEX4LSB 
SDL_PIXELFORMAT_INDEX4MSB 
SDL_PIXELFORMAT_INDEX8 
SDL_PIXELFORMAT_RGB332 
SDL_PIXELFORMAT_RGB444 
SDL_PIXELFORMAT_RGB555 
SDL_PIXELFORMAT_BGR555 
SDL_PIXELFORMAT_ARGB4444 
SDL_PIXELFORMAT_RGBA4444 
SDL_PIXELFORMAT_ABGR4444 
SDL_PIXELFORMAT_BGRA4444 
SDL_PIXELFORMAT_ARGB1555 
SDL_PIXELFORMAT_RGBA5551 
SDL_PIXELFORMAT_ABGR1555 
SDL_PIXELFORMAT_BGRA5551 
SDL_PIXELFORMAT_RGB565 
SDL_PIXELFORMAT_BGR565 
SDL_PIXELFORMAT_RGB24 
SDL_PIXELFORMAT_BGR24 
SDL_PIXELFORMAT_RGB888 
SDL_PIXELFORMAT_RGBX8888 
SDL_PIXELFORMAT_BGR888 
SDL_PIXELFORMAT_BGRX8888 
SDL_PIXELFORMAT_ARGB8888 
SDL_PIXELFORMAT_RGBA8888 
SDL_PIXELFORMAT_ABGR8888 
SDL_PIXELFORMAT_BGRA8888 
SDL_PIXELFORMAT_ARGB2101010 
SDL_PIXELFORMAT_RGBA32 
SDL_PIXELFORMAT_ARGB32 
SDL_PIXELFORMAT_BGRA32 
SDL_PIXELFORMAT_ABGR32 
SDL_PIXELFORMAT_YV12 

Planar mode: Y + V + U (3 planes)

SDL_PIXELFORMAT_IYUV 

Planar mode: Y + U + V (3 planes)

SDL_PIXELFORMAT_YUY2 

Packed mode: Y0+U0+Y1+V0 (1 plane)

SDL_PIXELFORMAT_UYVY 

Packed mode: U0+Y0+V0+Y1 (1 plane)

SDL_PIXELFORMAT_YVYU 

Packed mode: Y0+V0+Y1+U0 (1 plane)

SDL_PIXELFORMAT_NV12 

Planar mode: Y + U/V interleaved (2 planes)

SDL_PIXELFORMAT_NV21 

Planar mode: Y + V/U interleaved (2 planes)

SDL_PIXELFORMAT_EXTERNAL_OES 

Android video texture format

Definition at line 171 of file SDL_pixels.h.

172 {
176  1, 0),
179  1, 0),
182  4, 0),
185  4, 0),
190  SDL_PACKEDLAYOUT_332, 8, 1),
193  SDL_PACKEDLAYOUT_4444, 12, 2),
196  SDL_PACKEDLAYOUT_1555, 15, 2),
199  SDL_PACKEDLAYOUT_1555, 15, 2),
202  SDL_PACKEDLAYOUT_4444, 16, 2),
205  SDL_PACKEDLAYOUT_4444, 16, 2),
208  SDL_PACKEDLAYOUT_4444, 16, 2),
211  SDL_PACKEDLAYOUT_4444, 16, 2),
214  SDL_PACKEDLAYOUT_1555, 16, 2),
217  SDL_PACKEDLAYOUT_5551, 16, 2),
220  SDL_PACKEDLAYOUT_1555, 16, 2),
223  SDL_PACKEDLAYOUT_5551, 16, 2),
226  SDL_PACKEDLAYOUT_565, 16, 2),
229  SDL_PACKEDLAYOUT_565, 16, 2),
232  24, 3),
235  24, 3),
238  SDL_PACKEDLAYOUT_8888, 24, 4),
241  SDL_PACKEDLAYOUT_8888, 24, 4),
244  SDL_PACKEDLAYOUT_8888, 24, 4),
247  SDL_PACKEDLAYOUT_8888, 24, 4),
250  SDL_PACKEDLAYOUT_8888, 32, 4),
253  SDL_PACKEDLAYOUT_8888, 32, 4),
256  SDL_PACKEDLAYOUT_8888, 32, 4),
259  SDL_PACKEDLAYOUT_8888, 32, 4),
262  SDL_PACKEDLAYOUT_2101010, 32, 4),
263 
264  /* Aliases for RGBA byte arrays of color data, for the current platform */
265 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
270 #else
272  SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_BGRA8888,
273  SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_ARGB8888,
274  SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_RGBA8888,
275 #endif
276 
277  SDL_PIXELFORMAT_YV12 = /**< Planar mode: Y + V + U (3 planes) */
278  SDL_DEFINE_PIXELFOURCC('Y', 'V', '1', '2'),
279  SDL_PIXELFORMAT_IYUV = /**< Planar mode: Y + U + V (3 planes) */
280  SDL_DEFINE_PIXELFOURCC('I', 'Y', 'U', 'V'),
281  SDL_PIXELFORMAT_YUY2 = /**< Packed mode: Y0+U0+Y1+V0 (1 plane) */
282  SDL_DEFINE_PIXELFOURCC('Y', 'U', 'Y', '2'),
283  SDL_PIXELFORMAT_UYVY = /**< Packed mode: U0+Y0+V0+Y1 (1 plane) */
284  SDL_DEFINE_PIXELFOURCC('U', 'Y', 'V', 'Y'),
285  SDL_PIXELFORMAT_YVYU = /**< Packed mode: Y0+V0+Y1+U0 (1 plane) */
286  SDL_DEFINE_PIXELFOURCC('Y', 'V', 'Y', 'U'),
287  SDL_PIXELFORMAT_NV12 = /**< Planar mode: Y + U/V interleaved (2 planes) */
288  SDL_DEFINE_PIXELFOURCC('N', 'V', '1', '2'),
289  SDL_PIXELFORMAT_NV21 = /**< Planar mode: Y + V/U interleaved (2 planes) */
290  SDL_DEFINE_PIXELFOURCC('N', 'V', '2', '1'),
291  SDL_PIXELFORMAT_EXTERNAL_OES = /**< Android video texture format */
292  SDL_DEFINE_PIXELFOURCC('O', 'E', 'S', ' ')
293 };
#define SDL_DEFINE_PIXELFOURCC(A, B, C, D)
Definition: SDL_pixels.h:117
#define SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes)
Definition: SDL_pixels.h:119

Function Documentation

◆ SDL_AllocFormat()

SDL_PixelFormat* SDL_AllocFormat ( Uint32  pixel_format)

Create an SDL_PixelFormat structure from a pixel format enum.

Definition at line 496 of file SDL_pixels.c.

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

497 {
499 
501 
502  /* Look it up in our list of previously allocated formats */
503  for (format = formats; format; format = format->next) {
504  if (pixel_format == format->format) {
505  ++format->refcount;
507  return format;
508  }
509  }
510 
511  /* Allocate an empty pixel format structure, and initialize it */
512  format = SDL_malloc(sizeof(*format));
513  if (format == NULL) {
515  SDL_OutOfMemory();
516  return NULL;
517  }
518  if (SDL_InitFormat(format, pixel_format) < 0) {
520  SDL_free(format);
521  SDL_InvalidParamError("format");
522  return NULL;
523  }
524 
525  if (!SDL_ISPIXELFORMAT_INDEXED(pixel_format)) {
526  /* Cache the RGB formats */
527  format->next = formats;
528  formats = format;
529  }
530 
532 
533  return format;
534 }
#define SDL_AtomicLock
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
static SDL_PixelFormat * formats
Definition: SDL_pixels.c:492
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
#define SDL_AtomicUnlock
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
static SDL_SpinLock formats_lock
Definition: SDL_pixels.c:493
#define SDL_free
int SDL_InitFormat(SDL_PixelFormat *format, Uint32 pixel_format)
Definition: SDL_pixels.c:537
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
EGLint EGLint * formats
Definition: eglext.h:718
#define SDL_malloc
struct SDL_PixelFormat * next
Definition: SDL_pixels.h:335

◆ SDL_AllocPalette()

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

640 {
641  SDL_Palette *palette;
642 
643  /* Input validation */
644  if (ncolors < 1) {
645  SDL_InvalidParamError("ncolors");
646  return NULL;
647  }
648 
649  palette = (SDL_Palette *) SDL_malloc(sizeof(*palette));
650  if (!palette) {
651  SDL_OutOfMemory();
652  return NULL;
653  }
654  palette->colors =
655  (SDL_Color *) SDL_malloc(ncolors * sizeof(*palette->colors));
656  if (!palette->colors) {
657  SDL_free(palette);
658  return NULL;
659  }
660  palette->ncolors = ncolors;
661  palette->version = 1;
662  palette->refcount = 1;
663 
664  SDL_memset(palette->colors, 0xFF, ncolors * sizeof(*palette->colors));
665 
666  return palette;
667 }
Uint32 version
Definition: SDL_pixels.h:308
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
#define SDL_free
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Color * colors
Definition: SDL_pixels.h:307
#define SDL_malloc
#define SDL_memset

◆ SDL_CalculateGammaRamp()

void SDL_CalculateGammaRamp ( float  gamma,
Uint16 ramp 
)

Calculate a 256 entry gamma ramp for a gamma value.

Definition at line 1086 of file SDL_pixels.c.

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

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

◆ SDL_FreeFormat()

void SDL_FreeFormat ( SDL_PixelFormat format)

Free an SDL_PixelFormat structure.

Definition at line 602 of file SDL_pixels.c.

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

603 {
604  SDL_PixelFormat *prev;
605 
606  if (!format) {
607  SDL_InvalidParamError("format");
608  return;
609  }
610 
612 
613  if (--format->refcount > 0) {
615  return;
616  }
617 
618  /* Remove this format from our list */
619  if (format == formats) {
620  formats = format->next;
621  } else if (formats) {
622  for (prev = formats; prev->next; prev = prev->next) {
623  if (prev->next == format) {
624  prev->next = format->next;
625  break;
626  }
627  }
628  }
629 
631 
632  if (format->palette) {
633  SDL_FreePalette(format->palette);
634  }
635  SDL_free(format);
636 }
#define SDL_AtomicLock
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
#define SDL_AtomicUnlock
static SDL_SpinLock formats_lock
Definition: SDL_pixels.c:493
#define SDL_free
void SDL_FreePalette(SDL_Palette *palette)
Free a palette created with SDL_AllocPalette().
Definition: SDL_pixels.c:725
EGLint EGLint * formats
Definition: eglext.h:718
SDL_Palette * palette
Definition: SDL_pixels.h:318
struct SDL_PixelFormat * next
Definition: SDL_pixels.h:335

◆ SDL_FreePalette()

void SDL_FreePalette ( SDL_Palette palette)

Free a palette created with SDL_AllocPalette().

See also
SDL_AllocPalette()

Definition at line 725 of file SDL_pixels.c.

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

Referenced by SDL_FreeFormat(), and SDL_SetPixelFormatPalette().

726 {
727  if (!palette) {
728  SDL_InvalidParamError("palette");
729  return;
730  }
731  if (--palette->refcount > 0) {
732  return;
733  }
734  SDL_free(palette->colors);
735  SDL_free(palette);
736 }
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
#define SDL_free
SDL_Color * colors
Definition: SDL_pixels.h:307

◆ SDL_GetPixelFormatName()

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:1572
#define CASE(X)

◆ SDL_GetRGB()

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

828 {
829  if (format->palette == NULL) {
830  unsigned v;
831  v = (pixel & format->Rmask) >> format->Rshift;
832  *r = SDL_expand_byte[format->Rloss][v];
833  v = (pixel & format->Gmask) >> format->Gshift;
834  *g = SDL_expand_byte[format->Gloss][v];
835  v = (pixel & format->Bmask) >> format->Bshift;
836  *b = SDL_expand_byte[format->Bloss][v];
837  } else {
838  if (pixel < (unsigned)format->palette->ncolors) {
839  *r = format->palette->colors[pixel].r;
840  *g = format->palette->colors[pixel].g;
841  *b = format->palette->colors[pixel].b;
842  } else {
843  *r = *g = *b = 0;
844  }
845  }
846 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
Uint8 g
Definition: SDL_pixels.h:298
const GLdouble * v
Definition: SDL_opengl.h:2064
Uint8 b
Definition: SDL_pixels.h:299
Uint8 r
Definition: SDL_pixels.h:297
Uint8 * SDL_expand_byte[9]
Definition: SDL_pixels.c:71
#define NULL
Definition: begin_code.h:164
SDL_Color * colors
Definition: SDL_pixels.h:307
SDL_Palette * palette
Definition: SDL_pixels.h:318
GLboolean GLboolean g
GLboolean GLboolean GLboolean b

◆ SDL_GetRGBA()

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

851 {
852  if (format->palette == NULL) {
853  unsigned v;
854  v = (pixel & format->Rmask) >> format->Rshift;
855  *r = SDL_expand_byte[format->Rloss][v];
856  v = (pixel & format->Gmask) >> format->Gshift;
857  *g = SDL_expand_byte[format->Gloss][v];
858  v = (pixel & format->Bmask) >> format->Bshift;
859  *b = SDL_expand_byte[format->Bloss][v];
860  v = (pixel & format->Amask) >> format->Ashift;
861  *a = SDL_expand_byte[format->Aloss][v];
862  } else {
863  if (pixel < (unsigned)format->palette->ncolors) {
864  *r = format->palette->colors[pixel].r;
865  *g = format->palette->colors[pixel].g;
866  *b = format->palette->colors[pixel].b;
867  *a = format->palette->colors[pixel].a;
868  } else {
869  *r = *g = *b = *a = 0;
870  }
871  }
872 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
Uint8 g
Definition: SDL_pixels.h:298
const GLdouble * v
Definition: SDL_opengl.h:2064
Uint8 b
Definition: SDL_pixels.h:299
Uint8 r
Definition: SDL_pixels.h:297
Uint8 a
Definition: SDL_pixels.h:300
Uint8 * SDL_expand_byte[9]
Definition: SDL_pixels.c:71
#define NULL
Definition: begin_code.h:164
SDL_Color * colors
Definition: SDL_pixels.h:307
SDL_Palette * palette
Definition: SDL_pixels.h:318
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean g
GLboolean GLboolean GLboolean b

◆ SDL_MapRGB()

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

800 {
801  if (format->palette == NULL) {
802  return (r >> format->Rloss) << format->Rshift
803  | (g >> format->Gloss) << format->Gshift
804  | (b >> format->Bloss) << format->Bshift | format->Amask;
805  } else {
806  return SDL_FindColor(format->palette, r, g, b, SDL_ALPHA_OPAQUE);
807  }
808 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
Uint8 SDL_FindColor(SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_pixels.c:770
#define NULL
Definition: begin_code.h:164
SDL_Palette * palette
Definition: SDL_pixels.h:318
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:46
GLboolean GLboolean g
GLboolean GLboolean GLboolean b

◆ SDL_MapRGBA()

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

814 {
815  if (format->palette == NULL) {
816  return (r >> format->Rloss) << format->Rshift
817  | (g >> format->Gloss) << format->Gshift
818  | (b >> format->Bloss) << format->Bshift
819  | ((a >> format->Aloss) << format->Ashift & format->Amask);
820  } else {
821  return SDL_FindColor(format->palette, r, g, b, a);
822  }
823 }
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
Uint8 SDL_FindColor(SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_pixels.c:770
#define NULL
Definition: begin_code.h:164
SDL_Palette * palette
Definition: SDL_pixels.h:318
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean g
GLboolean GLboolean GLboolean b

◆ SDL_MasksToPixelFormatEnum()

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  /* fallthrough */
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  if (Rmask == 0x003F &&
407  Gmask == 0x07C0 &&
408  Bmask == 0xF800 &&
409  Amask == 0x0000) {
410  /* Technically this would be BGR556, but Witek says this works in bug 3158 */
411  return SDL_PIXELFORMAT_RGB565;
412  }
413  break;
414  case 24:
415  switch (Rmask) {
416  case 0:
417  case 0x00FF0000:
418 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
419  return SDL_PIXELFORMAT_RGB24;
420 #else
421  return SDL_PIXELFORMAT_BGR24;
422 #endif
423  case 0x000000FF:
424 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
425  return SDL_PIXELFORMAT_BGR24;
426 #else
427  return SDL_PIXELFORMAT_RGB24;
428 #endif
429  }
430  case 32:
431  if (Rmask == 0) {
432  return SDL_PIXELFORMAT_RGB888;
433  }
434  if (Rmask == 0x00FF0000 &&
435  Gmask == 0x0000FF00 &&
436  Bmask == 0x000000FF &&
437  Amask == 0x00000000) {
438  return SDL_PIXELFORMAT_RGB888;
439  }
440  if (Rmask == 0xFF000000 &&
441  Gmask == 0x00FF0000 &&
442  Bmask == 0x0000FF00 &&
443  Amask == 0x00000000) {
445  }
446  if (Rmask == 0x000000FF &&
447  Gmask == 0x0000FF00 &&
448  Bmask == 0x00FF0000 &&
449  Amask == 0x00000000) {
450  return SDL_PIXELFORMAT_BGR888;
451  }
452  if (Rmask == 0x0000FF00 &&
453  Gmask == 0x00FF0000 &&
454  Bmask == 0xFF000000 &&
455  Amask == 0x00000000) {
457  }
458  if (Rmask == 0x00FF0000 &&
459  Gmask == 0x0000FF00 &&
460  Bmask == 0x000000FF &&
461  Amask == 0xFF000000) {
463  }
464  if (Rmask == 0xFF000000 &&
465  Gmask == 0x00FF0000 &&
466  Bmask == 0x0000FF00 &&
467  Amask == 0x000000FF) {
469  }
470  if (Rmask == 0x000000FF &&
471  Gmask == 0x0000FF00 &&
472  Bmask == 0x00FF0000 &&
473  Amask == 0xFF000000) {
475  }
476  if (Rmask == 0x0000FF00 &&
477  Gmask == 0x00FF0000 &&
478  Bmask == 0xFF000000 &&
479  Amask == 0x000000FF) {
481  }
482  if (Rmask == 0x3FF00000 &&
483  Gmask == 0x000FFC00 &&
484  Bmask == 0x000003FF &&
485  Amask == 0xC0000000) {
487  }
488  }
490 }
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp

◆ SDL_PixelFormatEnumToMasks()

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) {
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 }
#define SDL_PIXELLAYOUT(X)
Definition: SDL_pixels.h:126
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
#define SDL_PIXELORDER(X)
Definition: SDL_pixels.h:125
#define SDL_PIXELTYPE(X)
Definition: SDL_pixels.h:124
#define SDL_SetError
uint32_t Uint32
Definition: SDL_stdinc.h:203
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:127

◆ SDL_SetPaletteColors()

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 698 of file SDL_pixels.c.

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

700 {
701  int status = 0;
702 
703  /* Verify the parameters */
704  if (!palette) {
705  return -1;
706  }
707  if (ncolors > (palette->ncolors - firstcolor)) {
708  ncolors = (palette->ncolors - firstcolor);
709  status = -1;
710  }
711 
712  if (colors != (palette->colors + firstcolor)) {
713  SDL_memcpy(palette->colors + firstcolor, colors,
714  ncolors * sizeof(*colors));
715  }
716  ++palette->version;
717  if (!palette->version) {
718  palette->version = 1;
719  }
720 
721  return status;
722 }
Uint32 version
Definition: SDL_pixels.h:308
#define SDL_memcpy
SDL_Color * colors
Definition: SDL_pixels.h:307

◆ SDL_SetPixelFormatPalette()

int SDL_SetPixelFormatPalette ( SDL_PixelFormat format,
SDL_Palette palette 
)

Set the palette for a pixel format structure.

Definition at line 670 of file SDL_pixels.c.

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

671 {
672  if (!format) {
673  return SDL_SetError("SDL_SetPixelFormatPalette() passed NULL format");
674  }
675 
676  if (palette && palette->ncolors > (1 << format->BitsPerPixel)) {
677  return SDL_SetError("SDL_SetPixelFormatPalette() passed a palette that doesn't match the format");
678  }
679 
680  if (format->palette == palette) {
681  return 0;
682  }
683 
684  if (format->palette) {
685  SDL_FreePalette(format->palette);
686  }
687 
688  format->palette = palette;
689 
690  if (format->palette) {
691  ++format->palette->refcount;
692  }
693 
694  return 0;
695 }
Uint8 BitsPerPixel
Definition: SDL_pixels.h:319
void SDL_FreePalette(SDL_Palette *palette)
Free a palette created with SDL_AllocPalette().
Definition: SDL_pixels.c:725
#define SDL_SetError
SDL_Palette * palette
Definition: SDL_pixels.h:318