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
 

Transparency definitions

These define alpha as the opacity of a surface.

#define SDL_ALPHA_OPAQUE   255
 
#define SDL_ALPHA_TRANSPARENT   0
 
#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
 
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_PixelFormatEnum {
  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 =
}
 
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

#define SDL_ALPHA_OPAQUE   255

Definition at line 46 of file SDL_pixels.h.

◆ SDL_ALPHA_TRANSPARENT

#define SDL_ALPHA_TRANSPARENT   0

Definition at line 47 of file SDL_pixels.h.

◆ SDL_BITSPERPIXEL

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

Definition at line 127 of file SDL_pixels.h.

◆ SDL_BYTESPERPIXEL

#define SDL_BYTESPERPIXEL (   X)
Value:
((((X) == SDL_PIXELFORMAT_YUY2) || \
((X) == SDL_PIXELFORMAT_UYVY) || \
((X) == SDL_PIXELFORMAT_YVYU)) ? 2 : 1) : (((X) >> 0) & 0xFF))
@ SDL_PIXELFORMAT_YVYU
Definition: SDL_pixels.h:285
@ SDL_PIXELFORMAT_UYVY
Definition: SDL_pixels.h:283
@ SDL_PIXELFORMAT_YUY2
Definition: SDL_pixels.h:281
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167

Definition at line 128 of file SDL_pixels.h.

◆ 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))
GLuint GLuint GLsizei GLenum type
Definition: SDL_opengl.h:1571
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
GLfixed GLfixed GLint GLint order

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

#define SDL_ISPIXELFORMAT_ALPHA (   format)
Value:
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
@ SDL_ARRAYORDER_ARGB
Definition: SDL_pixels.h:97
@ SDL_ARRAYORDER_BGRA
Definition: SDL_pixels.h:99
@ SDL_ARRAYORDER_ABGR
Definition: SDL_pixels.h:100
@ SDL_ARRAYORDER_RGBA
Definition: SDL_pixels.h:96
#define SDL_ISPIXELFORMAT_PACKED(format)
Definition: SDL_pixels.h:140
#define SDL_PIXELORDER(X)
Definition: SDL_pixels.h:125
@ SDL_PACKEDORDER_RGBA
Definition: SDL_pixels.h:82
@ SDL_PACKEDORDER_ABGR
Definition: SDL_pixels.h:85
@ SDL_PACKEDORDER_BGRA
Definition: SDL_pixels.h:86
@ SDL_PACKEDORDER_ARGB
Definition: SDL_pixels.h:81
#define SDL_ISPIXELFORMAT_ARRAY(format)
Definition: SDL_pixels.h:146

Definition at line 154 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_ARRAY

#define SDL_ISPIXELFORMAT_ARRAY (   format)
Value:
#define SDL_PIXELTYPE(X)
Definition: SDL_pixels.h:124
@ SDL_PIXELTYPE_ARRAYU16
Definition: SDL_pixels.h:61
@ SDL_PIXELTYPE_ARRAYU8
Definition: SDL_pixels.h:60
@ SDL_PIXELTYPE_ARRAYF16
Definition: SDL_pixels.h:63
@ SDL_PIXELTYPE_ARRAYU32
Definition: SDL_pixels.h:62
@ SDL_PIXELTYPE_ARRAYF32
Definition: SDL_pixels.h:64

Definition at line 146 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_FOURCC

#define SDL_ISPIXELFORMAT_FOURCC (   format)     ((format) && (SDL_PIXELFLAG(format) != 1))

Definition at line 167 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_INDEXED

#define SDL_ISPIXELFORMAT_INDEXED (   format)
Value:

Definition at line 134 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_PACKED

#define SDL_ISPIXELFORMAT_PACKED (   format)
Value:

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.

◆ SDL_PIXELORDER

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

Definition at line 125 of file SDL_pixels.h.

◆ SDL_PIXELTYPE

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

Definition at line 124 of file SDL_pixels.h.

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.

69{
73};
@ SDL_BITMAPORDER_1234
Definition: SDL_pixels.h:72
@ SDL_BITMAPORDER_NONE
Definition: SDL_pixels.h:70
@ SDL_BITMAPORDER_4321
Definition: SDL_pixels.h:71

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

105{
115};
@ SDL_PACKEDLAYOUT_NONE
Definition: SDL_pixels.h:106
@ SDL_PACKEDLAYOUT_8888
Definition: SDL_pixels.h:112
@ SDL_PACKEDLAYOUT_1010102
Definition: SDL_pixels.h:114
@ SDL_PACKEDLAYOUT_565
Definition: SDL_pixels.h:111
@ SDL_PACKEDLAYOUT_332
Definition: SDL_pixels.h:107
@ SDL_PACKEDLAYOUT_5551
Definition: SDL_pixels.h:110
@ SDL_PACKEDLAYOUT_1555
Definition: SDL_pixels.h:109
@ SDL_PACKEDLAYOUT_4444
Definition: SDL_pixels.h:108
@ SDL_PACKEDLAYOUT_2101010
Definition: SDL_pixels.h:113

◆ SDL_PixelFormatEnum

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),
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),
263
264 /* Aliases for RGBA byte arrays of color data, for the current platform */
265#if SDL_BYTEORDER == SDL_BIG_ENDIAN
270#else
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', ' ')
#define SDL_DEFINE_PIXELFOURCC(A, B, C, D)
Definition: SDL_pixels.h:117
SDL_PixelFormatEnum
Definition: SDL_pixels.h:172
@ SDL_PIXELFORMAT_BGR565
Definition: SDL_pixels.h:227
@ SDL_PIXELFORMAT_EXTERNAL_OES
Definition: SDL_pixels.h:291
@ SDL_PIXELFORMAT_RGB332
Definition: SDL_pixels.h:188
@ SDL_PIXELFORMAT_INDEX1LSB
Definition: SDL_pixels.h:174
@ SDL_PIXELFORMAT_ABGR4444
Definition: SDL_pixels.h:206
@ SDL_PIXELFORMAT_BGRA4444
Definition: SDL_pixels.h:209
@ SDL_PIXELFORMAT_BGR24
Definition: SDL_pixels.h:233
@ SDL_PIXELFORMAT_INDEX4MSB
Definition: SDL_pixels.h:183
@ SDL_PIXELFORMAT_BGRA32
Definition: SDL_pixels.h:273
@ SDL_PIXELFORMAT_RGB555
Definition: SDL_pixels.h:194
@ SDL_PIXELFORMAT_RGB444
Definition: SDL_pixels.h:191
@ SDL_PIXELFORMAT_RGBA8888
Definition: SDL_pixels.h:251
@ SDL_PIXELFORMAT_RGBA5551
Definition: SDL_pixels.h:215
@ SDL_PIXELFORMAT_ARGB1555
Definition: SDL_pixels.h:212
@ SDL_PIXELFORMAT_INDEX8
Definition: SDL_pixels.h:186
@ SDL_PIXELFORMAT_BGR888
Definition: SDL_pixels.h:242
@ SDL_PIXELFORMAT_YV12
Definition: SDL_pixels.h:277
@ SDL_PIXELFORMAT_ABGR32
Definition: SDL_pixels.h:274
@ SDL_PIXELFORMAT_BGRX8888
Definition: SDL_pixels.h:245
@ SDL_PIXELFORMAT_RGB24
Definition: SDL_pixels.h:230
@ SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:236
@ SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:254
@ SDL_PIXELFORMAT_NV12
Definition: SDL_pixels.h:287
@ SDL_PIXELFORMAT_BGRA8888
Definition: SDL_pixels.h:257
@ SDL_PIXELFORMAT_ARGB32
Definition: SDL_pixels.h:272
@ SDL_PIXELFORMAT_ABGR1555
Definition: SDL_pixels.h:218
@ SDL_PIXELFORMAT_NV21
Definition: SDL_pixels.h:289
@ SDL_PIXELFORMAT_IYUV
Definition: SDL_pixels.h:279
@ SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:248
@ SDL_PIXELFORMAT_ARGB4444
Definition: SDL_pixels.h:200
@ SDL_PIXELFORMAT_RGBA32
Definition: SDL_pixels.h:271
@ SDL_PIXELFORMAT_INDEX1MSB
Definition: SDL_pixels.h:177
@ SDL_PIXELFORMAT_INDEX4LSB
Definition: SDL_pixels.h:180
@ SDL_PIXELFORMAT_RGBX8888
Definition: SDL_pixels.h:239
@ SDL_PIXELFORMAT_BGRA5551
Definition: SDL_pixels.h:221
@ SDL_PIXELFORMAT_RGB565
Definition: SDL_pixels.h:224
@ SDL_PIXELFORMAT_ARGB2101010
Definition: SDL_pixels.h:260
@ SDL_PIXELFORMAT_BGR555
Definition: SDL_pixels.h:197
@ SDL_PIXELFORMAT_UNKNOWN
Definition: SDL_pixels.h:173
@ SDL_PIXELFORMAT_RGBA4444
Definition: SDL_pixels.h:203
#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.

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) {
516 return NULL;
517 }
518 if (SDL_InitFormat(format, pixel_format) < 0) {
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_malloc
#define SDL_AtomicUnlock
#define SDL_free
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
static SDL_PixelFormat * formats
Definition: SDL_pixels.c:492
static SDL_SpinLock formats_lock
Definition: SDL_pixels.c:493
int SDL_InitFormat(SDL_PixelFormat *format, Uint32 pixel_format)
Definition: SDL_pixels.c:537
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
#define NULL
Definition: begin_code.h:167
EGLint EGLint * formats
Definition: eglext.h:718

References formats, formats_lock, NULL, SDL_AtomicLock, SDL_AtomicUnlock, SDL_free, SDL_InitFormat(), SDL_InvalidParamError, SDL_ISPIXELFORMAT_INDEXED, SDL_malloc, and SDL_OutOfMemory.

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

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) {
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}
#define SDL_memset
Uint32 version
Definition: SDL_pixels.h:308
SDL_Color * colors
Definition: SDL_pixels.h:307

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.

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

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}
#define SDL_pow
GLsizei const GLfloat * value
uint16_t Uint16
Definition: SDL_stdinc.h:191
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

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

◆ SDL_FreeFormat()

void SDL_FreeFormat ( SDL_PixelFormat format)

Free an SDL_PixelFormat structure.

Definition at line 602 of file SDL_pixels.c.

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 }
636}
void SDL_FreePalette(SDL_Palette *palette)
Free a palette created with SDL_AllocPalette().
Definition: SDL_pixels.c:725
struct SDL_PixelFormat * next
Definition: SDL_pixels.h:335

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

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

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}

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

Referenced by SDL_FreeFormat(), and SDL_SetPixelFormatPalette().

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

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

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}
const GLdouble * v
Definition: SDL_opengl.h:2064
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
GLboolean GLboolean GLboolean b
GLboolean GLboolean g
Uint8 * SDL_expand_byte[9]
Definition: SDL_pixels.c:71

References NULL, and SDL_expand_byte.

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

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}
GLboolean GLboolean GLboolean GLboolean a

References NULL, and SDL_expand_byte.

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

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}
Uint8 SDL_FindColor(SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_pixels.c:770
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:46

References NULL, SDL_ALPHA_OPAQUE, and SDL_FindColor().

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

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}

References NULL, and SDL_FindColor().

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

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) {
306 }
307 if (Rmask == 0xE0 &&
308 Gmask == 0x1C &&
309 Bmask == 0x03 &&
310 Amask == 0x00) {
312 }
313 break;
314 case 12:
315 if (Rmask == 0) {
317 }
318 if (Rmask == 0x0F00 &&
319 Gmask == 0x00F0 &&
320 Bmask == 0x000F &&
321 Amask == 0x0000) {
323 }
324 break;
325 case 15:
326 if (Rmask == 0) {
328 }
329 /* fallthrough */
330 case 16:
331 if (Rmask == 0) {
333 }
334 if (Rmask == 0x7C00 &&
335 Gmask == 0x03E0 &&
336 Bmask == 0x001F &&
337 Amask == 0x0000) {
339 }
340 if (Rmask == 0x001F &&
341 Gmask == 0x03E0 &&
342 Bmask == 0x7C00 &&
343 Amask == 0x0000) {
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) {
399 }
400 if (Rmask == 0x001F &&
401 Gmask == 0x07E0 &&
402 Bmask == 0xF800 &&
403 Amask == 0x0000) {
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 */
412 }
413 break;
414 case 24:
415 switch (Rmask) {
416 case 0:
417 case 0x00FF0000:
418#if SDL_BYTEORDER == SDL_BIG_ENDIAN
420#else
422#endif
423 case 0x000000FF:
424#if SDL_BYTEORDER == SDL_BIG_ENDIAN
426#else
428#endif
429 }
430 case 32:
431 if (Rmask == 0) {
433 }
434 if (Rmask == 0x00FF0000 &&
435 Gmask == 0x0000FF00 &&
436 Bmask == 0x000000FF &&
437 Amask == 0x00000000) {
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) {
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}

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.

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

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
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
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_SetError
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:127
#define SDL_PIXELLAYOUT(X)
Definition: SDL_pixels.h:126
@ SDL_TRUE
Definition: SDL_stdinc.h:164
@ SDL_FALSE
Definition: SDL_stdinc.h:163
uint32_t Uint32
Definition: SDL_stdinc.h:203

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

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

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}
#define SDL_memcpy
static int colors[7]
Definition: testgesture.c:41

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

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

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}

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