#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:

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 { 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 { SDL_BITMAPORDER_NONE , SDL_BITMAPORDER_4321 , SDL_BITMAPORDER_1234 }

enum	SDL_PackedOrder { 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 { SDL_ARRAYORDER_NONE , SDL_ARRAYORDER_RGB , SDL_ARRAYORDER_RGBA , SDL_ARRAYORDER_ARGB , SDL_ARRAYORDER_BGR , SDL_ARRAYORDER_BGRA , SDL_ARRAYORDER_ABGR }

enum	SDL_PackedLayout { 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_XRGB4444 , SDL_PIXELFORMAT_RGB444 = SDL_PIXELFORMAT_XRGB4444 , SDL_PIXELFORMAT_XBGR4444 , SDL_PIXELFORMAT_BGR444 = SDL_PIXELFORMAT_XBGR4444 , SDL_PIXELFORMAT_XRGB1555 , SDL_PIXELFORMAT_RGB555 = SDL_PIXELFORMAT_XRGB1555 , SDL_PIXELFORMAT_XBGR1555 , SDL_PIXELFORMAT_BGR555 = SDL_PIXELFORMAT_XBGR1555 , 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_XRGB8888 , SDL_PIXELFORMAT_RGB888 = SDL_PIXELFORMAT_XRGB8888 , SDL_PIXELFORMAT_RGBX8888 , SDL_PIXELFORMAT_XBGR8888 , SDL_PIXELFORMAT_BGR888 = SDL_PIXELFORMAT_XBGR8888 , 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_PixelFormat *	SDL_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_Palette *	SDL_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:

    (SDL_ISPIXELFORMAT_FOURCC(X) ? \
        ((((X) == SDL_PIXELFORMAT_YUY2) || \
          ((X) == SDL_PIXELFORMAT_UYVY) || \
          ((X) == SDL_PIXELFORMAT_YVYU)) ? 2 : 1) : (((X) >> 0) & 0xFF))

Definition at line 128 of file SDL_pixels.h.

◆ SDL_Colour

#define SDL_Colour SDL_Color

Definition at line 311 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))

type

GLuint GLuint GLsizei GLenum type

Definition: SDL_opengl.h:1571

bits

GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits

Definition: SDL_opengl_glext.h:6179

order

GLfixed GLfixed GLint GLint order

Definition: SDL_opengl_glext.h:4561

Definition at line 119 of file SDL_pixels.h.

◆ SDL_DEFINE_PIXELFOURCC

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

Definition at line 117 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_ALPHA

#define SDL_ISPIXELFORMAT_ALPHA ( format )

Value:

    ((SDL_ISPIXELFORMAT_PACKED(format) && \
     ((SDL_PIXELORDER(format) == SDL_PACKEDORDER_ARGB) || \
      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_RGBA) || \
      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_ABGR) || \
      (SDL_PIXELORDER(format) == SDL_PACKEDORDER_BGRA))) || \
    (SDL_ISPIXELFORMAT_ARRAY(format) && \
     ((SDL_PIXELORDER(format) == SDL_ARRAYORDER_ARGB) || \
      (SDL_PIXELORDER(format) == SDL_ARRAYORDER_RGBA) || \
      (SDL_PIXELORDER(format) == SDL_ARRAYORDER_ABGR) || \
      (SDL_PIXELORDER(format) == SDL_ARRAYORDER_BGRA))))

Definition at line 154 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_ARRAY

#define SDL_ISPIXELFORMAT_ARRAY ( format )

Value:

    (!SDL_ISPIXELFORMAT_FOURCC(format) && \
     ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYU8) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYU16) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYU32) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYF16) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYF32)))

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:

    (!SDL_ISPIXELFORMAT_FOURCC(format) && \
     ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX1) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX4) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX8)))

Definition at line 134 of file SDL_pixels.h.

◆ SDL_ISPIXELFORMAT_PACKED

#define SDL_ISPIXELFORMAT_PACKED ( format )

Value:

    (!SDL_ISPIXELFORMAT_FOURCC(format) && \
     ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_PACKED8) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_PACKED16) || \
      (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_PACKED32)))

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

◆ SDL_ArrayOrder

enum SDL_ArrayOrder

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.

 {
     SDL_ARRAYORDER_NONE,
     SDL_ARRAYORDER_RGB,
     SDL_ARRAYORDER_RGBA,
     SDL_ARRAYORDER_ARGB,
     SDL_ARRAYORDER_BGR,
     SDL_ARRAYORDER_BGRA,
     SDL_ARRAYORDER_ABGR
 } SDL_ArrayOrder;

◆ SDL_BitmapOrder

enum SDL_BitmapOrder

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.

 {
     SDL_BITMAPORDER_NONE,
     SDL_BITMAPORDER_4321,
     SDL_BITMAPORDER_1234
 } SDL_BitmapOrder;

◆ SDL_PackedLayout

enum SDL_PackedLayout

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.

 {
     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
 } SDL_PackedLayout;

◆ SDL_PackedOrder

enum SDL_PackedOrder

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.

 {
     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
 } SDL_PackedOrder;

◆ SDL_PixelFormatEnum

enum 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_XRGB4444
SDL_PIXELFORMAT_RGB444
SDL_PIXELFORMAT_XBGR4444
SDL_PIXELFORMAT_BGR444
SDL_PIXELFORMAT_XRGB1555
SDL_PIXELFORMAT_RGB555
SDL_PIXELFORMAT_XBGR1555
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_XRGB8888
SDL_PIXELFORMAT_RGB888
SDL_PIXELFORMAT_RGBX8888
SDL_PIXELFORMAT_XBGR8888
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.

 {
     SDL_PIXELFORMAT_UNKNOWN,
     SDL_PIXELFORMAT_INDEX1LSB =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_4321, 0,
                                1, 0),
     SDL_PIXELFORMAT_INDEX1MSB =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_1234, 0,
                                1, 0),
     SDL_PIXELFORMAT_INDEX4LSB =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_4321, 0,
                                4, 0),
     SDL_PIXELFORMAT_INDEX4MSB =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_1234, 0,
                                4, 0),
     SDL_PIXELFORMAT_INDEX8 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1),
     SDL_PIXELFORMAT_RGB332 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED8, SDL_PACKEDORDER_XRGB,
                                SDL_PACKEDLAYOUT_332, 8, 1),
     SDL_PIXELFORMAT_XRGB4444 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
                                SDL_PACKEDLAYOUT_4444, 12, 2),
     SDL_PIXELFORMAT_RGB444 = SDL_PIXELFORMAT_XRGB4444,
     SDL_PIXELFORMAT_XBGR4444 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR,
                                SDL_PACKEDLAYOUT_4444, 12, 2),
     SDL_PIXELFORMAT_BGR444 = SDL_PIXELFORMAT_XBGR4444,
     SDL_PIXELFORMAT_XRGB1555 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
                                SDL_PACKEDLAYOUT_1555, 15, 2),
     SDL_PIXELFORMAT_RGB555 = SDL_PIXELFORMAT_XRGB1555,
     SDL_PIXELFORMAT_XBGR1555 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR,
                                SDL_PACKEDLAYOUT_1555, 15, 2),
     SDL_PIXELFORMAT_BGR555 = SDL_PIXELFORMAT_XBGR1555,
     SDL_PIXELFORMAT_ARGB4444 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB,
                                SDL_PACKEDLAYOUT_4444, 16, 2),
     SDL_PIXELFORMAT_RGBA4444 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA,
                                SDL_PACKEDLAYOUT_4444, 16, 2),
     SDL_PIXELFORMAT_ABGR4444 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR,
                                SDL_PACKEDLAYOUT_4444, 16, 2),
     SDL_PIXELFORMAT_BGRA4444 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA,
                                SDL_PACKEDLAYOUT_4444, 16, 2),
     SDL_PIXELFORMAT_ARGB1555 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB,
                                SDL_PACKEDLAYOUT_1555, 16, 2),
     SDL_PIXELFORMAT_RGBA5551 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA,
                                SDL_PACKEDLAYOUT_5551, 16, 2),
     SDL_PIXELFORMAT_ABGR1555 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR,
                                SDL_PACKEDLAYOUT_1555, 16, 2),
     SDL_PIXELFORMAT_BGRA5551 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA,
                                SDL_PACKEDLAYOUT_5551, 16, 2),
     SDL_PIXELFORMAT_RGB565 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB,
                                SDL_PACKEDLAYOUT_565, 16, 2),
     SDL_PIXELFORMAT_BGR565 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR,
                                SDL_PACKEDLAYOUT_565, 16, 2),
     SDL_PIXELFORMAT_RGB24 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB, 0,
                                24, 3),
     SDL_PIXELFORMAT_BGR24 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_BGR, 0,
                                24, 3),
     SDL_PIXELFORMAT_XRGB8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB,
                                SDL_PACKEDLAYOUT_8888, 24, 4),
     SDL_PIXELFORMAT_RGB888 = SDL_PIXELFORMAT_XRGB8888,
     SDL_PIXELFORMAT_RGBX8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBX,
                                SDL_PACKEDLAYOUT_8888, 24, 4),
     SDL_PIXELFORMAT_XBGR8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR,
                                SDL_PACKEDLAYOUT_8888, 24, 4),
     SDL_PIXELFORMAT_BGR888 = SDL_PIXELFORMAT_XBGR8888,
     SDL_PIXELFORMAT_BGRX8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRX,
                                SDL_PACKEDLAYOUT_8888, 24, 4),
     SDL_PIXELFORMAT_ARGB8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB,
                                SDL_PACKEDLAYOUT_8888, 32, 4),
     SDL_PIXELFORMAT_RGBA8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBA,
                                SDL_PACKEDLAYOUT_8888, 32, 4),
     SDL_PIXELFORMAT_ABGR8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR,
                                SDL_PACKEDLAYOUT_8888, 32, 4),
     SDL_PIXELFORMAT_BGRA8888 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRA,
                                SDL_PACKEDLAYOUT_8888, 32, 4),
     SDL_PIXELFORMAT_ARGB2101010 =
         SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB,
                                SDL_PACKEDLAYOUT_2101010, 32, 4),
  
     /* Aliases for RGBA byte arrays of color data, for the current platform */
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
     SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_RGBA8888,
     SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_ARGB8888,
     SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_BGRA8888,
     SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_ABGR8888,
 #else
     SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_ABGR8888,
     SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_BGRA8888,
     SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_ARGB8888,
     SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_RGBA8888,
 #endif
  
     SDL_PIXELFORMAT_YV12 =      /**< Planar mode: Y + V + U  (3 planes) */
         SDL_DEFINE_PIXELFOURCC('Y', 'V', '1', '2'),
     SDL_PIXELFORMAT_IYUV =      /**< Planar mode: Y + U + V  (3 planes) */
         SDL_DEFINE_PIXELFOURCC('I', 'Y', 'U', 'V'),
     SDL_PIXELFORMAT_YUY2 =      /**< Packed mode: Y0+U0+Y1+V0 (1 plane) */
         SDL_DEFINE_PIXELFOURCC('Y', 'U', 'Y', '2'),
     SDL_PIXELFORMAT_UYVY =      /**< Packed mode: U0+Y0+V0+Y1 (1 plane) */
         SDL_DEFINE_PIXELFOURCC('U', 'Y', 'V', 'Y'),
     SDL_PIXELFORMAT_YVYU =      /**< Packed mode: Y0+V0+Y1+U0 (1 plane) */
         SDL_DEFINE_PIXELFOURCC('Y', 'V', 'Y', 'U'),
     SDL_PIXELFORMAT_NV12 =      /**< Planar mode: Y + U/V interleaved  (2 planes) */
         SDL_DEFINE_PIXELFOURCC('N', 'V', '1', '2'),
     SDL_PIXELFORMAT_NV21 =      /**< Planar mode: Y + V/U interleaved  (2 planes) */
         SDL_DEFINE_PIXELFOURCC('N', 'V', '2', '1'),
     SDL_PIXELFORMAT_EXTERNAL_OES =      /**< Android video texture format */
         SDL_DEFINE_PIXELFOURCC('O', 'E', 'S', ' ')
 } SDL_PixelFormatEnum;

◆ SDL_PixelType

enum SDL_PixelType

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.

 {
     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
 } SDL_PixelType;

Function Documentation

◆ SDL_AllocFormat()

SDL_PixelFormat* SDL_AllocFormat ( Uint32 pixel_format )

Create an SDL_PixelFormat structure from a pixel format enum.

Definition at line 503 of file SDL_pixels.c.

 {
     SDL_PixelFormat *format;
  
     SDL_AtomicLock(&formats_lock);
  
     /* Look it up in our list of previously allocated formats */
     for (format = formats; format; format = format->next) {
         if (pixel_format == format->format) {
             ++format->refcount;
             SDL_AtomicUnlock(&formats_lock);
             return format;
         }
     }
  
     /* Allocate an empty pixel format structure, and initialize it */
     format = SDL_malloc(sizeof(*format));
     if (format == NULL) {
         SDL_AtomicUnlock(&formats_lock);
         SDL_OutOfMemory();
         return NULL;
     }
     if (SDL_InitFormat(format, pixel_format) < 0) {
         SDL_AtomicUnlock(&formats_lock);
         SDL_free(format);
         SDL_InvalidParamError("format");
         return NULL;
     }
  
     if (!SDL_ISPIXELFORMAT_INDEXED(pixel_format)) {
         /* Cache the RGB formats */
         format->next = formats;
         formats = format;
     }
  
     SDL_AtomicUnlock(&formats_lock);
  
     return format;
 }

References formats, formats_lock, NULL, pixel_format, 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 646 of file SDL_pixels.c.

 {
     SDL_Palette *palette;
  
     /* Input validation */
     if (ncolors < 1) {
       SDL_InvalidParamError("ncolors");
       return NULL;
     }
  
     palette = (SDL_Palette *) SDL_malloc(sizeof(*palette));
     if (!palette) {
         SDL_OutOfMemory();
         return NULL;
     }
     palette->colors =
         (SDL_Color *) SDL_malloc(ncolors * sizeof(*palette->colors));
     if (!palette->colors) {
         SDL_free(palette);
         return NULL;
     }
     palette->ncolors = ncolors;
     palette->version = 1;
     palette->refcount = 1;
  
     SDL_memset(palette->colors, 0xFF, ncolors * sizeof(*palette->colors));
  
     return palette;
 }

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

 {
     int i;
  
     /* Input validation */
     if (gamma < 0.0f ) {
       SDL_InvalidParamError("gamma");
       return;
     }
     if (ramp == NULL) {
       SDL_InvalidParamError("ramp");
       return;
     }
  
     /* 0.0 gamma is all black */
     if (gamma == 0.0f) {
         SDL_memset(ramp, 0, 256 * sizeof(Uint16));
         return;
     } else if (gamma == 1.0f) {
         /* 1.0 gamma is identity */
         for (i = 0; i < 256; ++i) {
             ramp[i] = (i << 8) | i;
         }
         return;
     } else {
         /* Calculate a real gamma ramp */
         int value;
         gamma = 1.0f / gamma;
         for (i = 0; i < 256; ++i) {
             value =
                 (int) (SDL_pow((double) i / 256.0, gamma) * 65535.0 + 0.5);
             if (value > 65535) {
                 value = 65535;
             }
             ramp[i] = (Uint16) value;
         }
     }
 }

References i, int(), NULL, SDL_InvalidParamError, SDL_memset, and SDL_pow.

◆ SDL_FreeFormat()

void SDL_FreeFormat ( SDL_PixelFormat * format )

Free an SDL_PixelFormat structure.

Definition at line 609 of file SDL_pixels.c.

 {
     SDL_PixelFormat *prev;
  
     if (!format) {
         SDL_InvalidParamError("format");
         return;
     }
  
     SDL_AtomicLock(&formats_lock);
  
     if (--format->refcount > 0) {
         SDL_AtomicUnlock(&formats_lock);
         return;
     }
  
     /* Remove this format from our list */
     if (format == formats) {
         formats = format->next;
     } else if (formats) {
         for (prev = formats; prev->next; prev = prev->next) {
             if (prev->next == format) {
                 prev->next = format->next;
                 break;
             }
         }
     }
  
     SDL_AtomicUnlock(&formats_lock);
  
     if (format->palette) {
         SDL_FreePalette(format->palette);
     }
     SDL_free(format);
 }

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

 {
     if (!palette) {
         SDL_InvalidParamError("palette");
         return;
     }
     if (--palette->refcount > 0) {
         return;
     }
     SDL_free(palette->colors);
     SDL_free(palette);
 }

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.

 {
     switch (format) {
 #define CASE(X) case X: return #X;
     CASE(SDL_PIXELFORMAT_INDEX1LSB)
     CASE(SDL_PIXELFORMAT_INDEX1MSB)
     CASE(SDL_PIXELFORMAT_INDEX4LSB)
     CASE(SDL_PIXELFORMAT_INDEX4MSB)
     CASE(SDL_PIXELFORMAT_INDEX8)
     CASE(SDL_PIXELFORMAT_RGB332)
     CASE(SDL_PIXELFORMAT_RGB444)
     CASE(SDL_PIXELFORMAT_BGR444)
     CASE(SDL_PIXELFORMAT_RGB555)
     CASE(SDL_PIXELFORMAT_BGR555)
     CASE(SDL_PIXELFORMAT_ARGB4444)
     CASE(SDL_PIXELFORMAT_RGBA4444)
     CASE(SDL_PIXELFORMAT_ABGR4444)
     CASE(SDL_PIXELFORMAT_BGRA4444)
     CASE(SDL_PIXELFORMAT_ARGB1555)
     CASE(SDL_PIXELFORMAT_RGBA5551)
     CASE(SDL_PIXELFORMAT_ABGR1555)
     CASE(SDL_PIXELFORMAT_BGRA5551)
     CASE(SDL_PIXELFORMAT_RGB565)
     CASE(SDL_PIXELFORMAT_BGR565)
     CASE(SDL_PIXELFORMAT_RGB24)
     CASE(SDL_PIXELFORMAT_BGR24)
     CASE(SDL_PIXELFORMAT_RGB888)
     CASE(SDL_PIXELFORMAT_RGBX8888)
     CASE(SDL_PIXELFORMAT_BGR888)
     CASE(SDL_PIXELFORMAT_BGRX8888)
     CASE(SDL_PIXELFORMAT_ARGB8888)
     CASE(SDL_PIXELFORMAT_RGBA8888)
     CASE(SDL_PIXELFORMAT_ABGR8888)
     CASE(SDL_PIXELFORMAT_BGRA8888)
     CASE(SDL_PIXELFORMAT_ARGB2101010)
     CASE(SDL_PIXELFORMAT_YV12)
     CASE(SDL_PIXELFORMAT_IYUV)
     CASE(SDL_PIXELFORMAT_YUY2)
     CASE(SDL_PIXELFORMAT_UYVY)
     CASE(SDL_PIXELFORMAT_YVYU)
     CASE(SDL_PIXELFORMAT_NV12)
     CASE(SDL_PIXELFORMAT_NV21)
 #undef CASE
     default:
         return "SDL_PIXELFORMAT_UNKNOWN";
     }
 }

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

 {
     if (format->palette == NULL) {
         unsigned v;
         v = (pixel & format->Rmask) >> format->Rshift;
         *r = SDL_expand_byte[format->Rloss][v];
         v = (pixel & format->Gmask) >> format->Gshift;
         *g = SDL_expand_byte[format->Gloss][v];
         v = (pixel & format->Bmask) >> format->Bshift;
         *b = SDL_expand_byte[format->Bloss][v];
     } else {
         if (pixel < (unsigned)format->palette->ncolors) {
             *r = format->palette->colors[pixel].r;
             *g = format->palette->colors[pixel].g;
             *b = format->palette->colors[pixel].b;
         } else {
             *r = *g = *b = 0;
         }
     }
 }

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

 {
     if (format->palette == NULL) {
         unsigned v;
         v = (pixel & format->Rmask) >> format->Rshift;
         *r = SDL_expand_byte[format->Rloss][v];
         v = (pixel & format->Gmask) >> format->Gshift;
         *g = SDL_expand_byte[format->Gloss][v];
         v = (pixel & format->Bmask) >> format->Bshift;
         *b = SDL_expand_byte[format->Bloss][v];
         v = (pixel & format->Amask) >> format->Ashift;
         *a = SDL_expand_byte[format->Aloss][v];
     } else {
         if (pixel < (unsigned)format->palette->ncolors) {
             *r = format->palette->colors[pixel].r;
             *g = format->palette->colors[pixel].g;
             *b = format->palette->colors[pixel].b;
             *a = format->palette->colors[pixel].a;
         } else {
             *r = *g = *b = *a = 0;
         }
     }
 }

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

 {
     if (format->palette == NULL) {
         return (r >> format->Rloss) << format->Rshift
             | (g >> format->Gloss) << format->Gshift
             | (b >> format->Bloss) << format->Bshift | format->Amask;
     } else {
         return SDL_FindColor(format->palette, r, g, b, SDL_ALPHA_OPAQUE);
     }
 }

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

 {
     if (format->palette == NULL) {
         return (r >> format->Rloss) << format->Rshift
             | (g >> format->Gloss) << format->Gshift
             | (b >> format->Bloss) << format->Bshift
             | ((a >> format->Aloss) << format->Ashift & format->Amask);
     } else {
         return SDL_FindColor(format->palette, r, g, b, a);
     }
 }

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

 {
     switch (bpp) {
     case 1:
         /* SDL defaults to MSB ordering */
         return SDL_PIXELFORMAT_INDEX1MSB;
     case 4:
         /* SDL defaults to MSB ordering */
         return SDL_PIXELFORMAT_INDEX4MSB;
     case 8:
         if (Rmask == 0) {
             return SDL_PIXELFORMAT_INDEX8;
         }
         if (Rmask == 0xE0 &&
             Gmask == 0x1C &&
             Bmask == 0x03 &&
             Amask == 0x00) {
             return SDL_PIXELFORMAT_RGB332;
         }
         break;
     case 12:
         if (Rmask == 0) {
             return SDL_PIXELFORMAT_RGB444;
         }
         if (Rmask == 0x0F00 &&
             Gmask == 0x00F0 &&
             Bmask == 0x000F &&
             Amask == 0x0000) {
             return SDL_PIXELFORMAT_RGB444;
         }
         if (Rmask == 0x000F &&
             Gmask == 0x00F0 &&
             Bmask == 0x0F00 &&
             Amask == 0x0000) {
             return SDL_PIXELFORMAT_BGR444;
         }
         break;
     case 15:
         if (Rmask == 0) {
             return SDL_PIXELFORMAT_RGB555;
         }
     /* fallthrough */
     case 16:
         if (Rmask == 0) {
             return SDL_PIXELFORMAT_RGB565;
         }
         if (Rmask == 0x7C00 &&
             Gmask == 0x03E0 &&
             Bmask == 0x001F &&
             Amask == 0x0000) {
             return SDL_PIXELFORMAT_RGB555;
         }
         if (Rmask == 0x001F &&
             Gmask == 0x03E0 &&
             Bmask == 0x7C00 &&
             Amask == 0x0000) {
             return SDL_PIXELFORMAT_BGR555;
         }
         if (Rmask == 0x0F00 &&
             Gmask == 0x00F0 &&
             Bmask == 0x000F &&
             Amask == 0xF000) {
             return SDL_PIXELFORMAT_ARGB4444;
         }
         if (Rmask == 0xF000 &&
             Gmask == 0x0F00 &&
             Bmask == 0x00F0 &&
             Amask == 0x000F) {
             return SDL_PIXELFORMAT_RGBA4444;
         }
         if (Rmask == 0x000F &&
             Gmask == 0x00F0 &&
             Bmask == 0x0F00 &&
             Amask == 0xF000) {
             return SDL_PIXELFORMAT_ABGR4444;
         }
         if (Rmask == 0x00F0 &&
             Gmask == 0x0F00 &&
             Bmask == 0xF000 &&
             Amask == 0x000F) {
             return SDL_PIXELFORMAT_BGRA4444;
         }
         if (Rmask == 0x7C00 &&
             Gmask == 0x03E0 &&
             Bmask == 0x001F &&
             Amask == 0x8000) {
             return SDL_PIXELFORMAT_ARGB1555;
         }
         if (Rmask == 0xF800 &&
             Gmask == 0x07C0 &&
             Bmask == 0x003E &&
             Amask == 0x0001) {
             return SDL_PIXELFORMAT_RGBA5551;
         }
         if (Rmask == 0x001F &&
             Gmask == 0x03E0 &&
             Bmask == 0x7C00 &&
             Amask == 0x8000) {
             return SDL_PIXELFORMAT_ABGR1555;
         }
         if (Rmask == 0x003E &&
             Gmask == 0x07C0 &&
             Bmask == 0xF800 &&
             Amask == 0x0001) {
             return SDL_PIXELFORMAT_BGRA5551;
         }
         if (Rmask == 0xF800 &&
             Gmask == 0x07E0 &&
             Bmask == 0x001F &&
             Amask == 0x0000) {
             return SDL_PIXELFORMAT_RGB565;
         }
         if (Rmask == 0x001F &&
             Gmask == 0x07E0 &&
             Bmask == 0xF800 &&
             Amask == 0x0000) {
             return SDL_PIXELFORMAT_BGR565;
         }
         if (Rmask == 0x003F &&
             Gmask == 0x07C0 &&
             Bmask == 0xF800 &&
             Amask == 0x0000) {
             /* Technically this would be BGR556, but Witek says this works in bug 3158 */
             return SDL_PIXELFORMAT_RGB565;
         }
         break;
     case 24:
         switch (Rmask) {
         case 0:
         case 0x00FF0000:
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
             return SDL_PIXELFORMAT_RGB24;
 #else
             return SDL_PIXELFORMAT_BGR24;
 #endif
         case 0x000000FF:
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
             return SDL_PIXELFORMAT_BGR24;
 #else
             return SDL_PIXELFORMAT_RGB24;
 #endif
         }
     case 32:
         if (Rmask == 0) {
             return SDL_PIXELFORMAT_RGB888;
         }
         if (Rmask == 0x00FF0000 &&
             Gmask == 0x0000FF00 &&
             Bmask == 0x000000FF &&
             Amask == 0x00000000) {
             return SDL_PIXELFORMAT_RGB888;
         }
         if (Rmask == 0xFF000000 &&
             Gmask == 0x00FF0000 &&
             Bmask == 0x0000FF00 &&
             Amask == 0x00000000) {
             return SDL_PIXELFORMAT_RGBX8888;
         }
         if (Rmask == 0x000000FF &&
             Gmask == 0x0000FF00 &&
             Bmask == 0x00FF0000 &&
             Amask == 0x00000000) {
             return SDL_PIXELFORMAT_BGR888;
         }
         if (Rmask == 0x0000FF00 &&
             Gmask == 0x00FF0000 &&
             Bmask == 0xFF000000 &&
             Amask == 0x00000000) {
             return SDL_PIXELFORMAT_BGRX8888;
         }
         if (Rmask == 0x00FF0000 &&
             Gmask == 0x0000FF00 &&
             Bmask == 0x000000FF &&
             Amask == 0xFF000000) {
             return SDL_PIXELFORMAT_ARGB8888;
         }
         if (Rmask == 0xFF000000 &&
             Gmask == 0x00FF0000 &&
             Bmask == 0x0000FF00 &&
             Amask == 0x000000FF) {
             return SDL_PIXELFORMAT_RGBA8888;
         }
         if (Rmask == 0x000000FF &&
             Gmask == 0x0000FF00 &&
             Bmask == 0x00FF0000 &&
             Amask == 0xFF000000) {
             return SDL_PIXELFORMAT_ABGR8888;
         }
         if (Rmask == 0x0000FF00 &&
             Gmask == 0x00FF0000 &&
             Bmask == 0xFF000000 &&
             Amask == 0x000000FF) {
             return SDL_PIXELFORMAT_BGRA8888;
         }
         if (Rmask == 0x3FF00000 &&
             Gmask == 0x000FFC00 &&
             Bmask == 0x000003FF &&
             Amask == 0xC0000000) {
             return SDL_PIXELFORMAT_ARGB2101010;
         }
     }
     return 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 135 of file SDL_pixels.c.

 {
     Uint32 masks[4];
  
     /* This function doesn't work with FourCC pixel formats */
     if (SDL_ISPIXELFORMAT_FOURCC(format)) {
         SDL_SetError("FOURCC pixel formats are not supported");
         return SDL_FALSE;
     }
  
     /* Initialize the values here */
     if (SDL_BYTESPERPIXEL(format) <= 2) {
         *bpp = SDL_BITSPERPIXEL(format);
     } else {
         *bpp = SDL_BYTESPERPIXEL(format) * 8;
     }
     *Rmask = *Gmask = *Bmask = *Amask = 0;
  
     if (format == SDL_PIXELFORMAT_RGB24) {
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
         *Rmask = 0x00FF0000;
         *Gmask = 0x0000FF00;
         *Bmask = 0x000000FF;
 #else
         *Rmask = 0x000000FF;
         *Gmask = 0x0000FF00;
         *Bmask = 0x00FF0000;
 #endif
         return SDL_TRUE;
     }
  
     if (format == SDL_PIXELFORMAT_BGR24) {
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
         *Rmask = 0x000000FF;
         *Gmask = 0x0000FF00;
         *Bmask = 0x00FF0000;
 #else
         *Rmask = 0x00FF0000;
         *Gmask = 0x0000FF00;
         *Bmask = 0x000000FF;
 #endif
         return SDL_TRUE;
     }
  
     if (SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED8 &&
         SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED16 &&
         SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED32) {
         /* Not a format that uses masks */
         return SDL_TRUE;
     }
  
     switch (SDL_PIXELLAYOUT(format)) {
     case SDL_PACKEDLAYOUT_332:
         masks[0] = 0x00000000;
         masks[1] = 0x000000E0;
         masks[2] = 0x0000001C;
         masks[3] = 0x00000003;
         break;
     case SDL_PACKEDLAYOUT_4444:
         masks[0] = 0x0000F000;
         masks[1] = 0x00000F00;
         masks[2] = 0x000000F0;
         masks[3] = 0x0000000F;
         break;
     case SDL_PACKEDLAYOUT_1555:
         masks[0] = 0x00008000;
         masks[1] = 0x00007C00;
         masks[2] = 0x000003E0;
         masks[3] = 0x0000001F;
         break;
     case SDL_PACKEDLAYOUT_5551:
         masks[0] = 0x0000F800;
         masks[1] = 0x000007C0;
         masks[2] = 0x0000003E;
         masks[3] = 0x00000001;
         break;
     case SDL_PACKEDLAYOUT_565:
         masks[0] = 0x00000000;
         masks[1] = 0x0000F800;
         masks[2] = 0x000007E0;
         masks[3] = 0x0000001F;
         break;
     case SDL_PACKEDLAYOUT_8888:
         masks[0] = 0xFF000000;
         masks[1] = 0x00FF0000;
         masks[2] = 0x0000FF00;
         masks[3] = 0x000000FF;
         break;
     case SDL_PACKEDLAYOUT_2101010:
         masks[0] = 0xC0000000;
         masks[1] = 0x3FF00000;
         masks[2] = 0x000FFC00;
         masks[3] = 0x000003FF;
         break;
     case SDL_PACKEDLAYOUT_1010102:
         masks[0] = 0xFFC00000;
         masks[1] = 0x003FF000;
         masks[2] = 0x00000FFC;
         masks[3] = 0x00000003;
         break;
     default:
         SDL_SetError("Unknown pixel format");
         return SDL_FALSE;
     }
  
     switch (SDL_PIXELORDER(format)) {
     case SDL_PACKEDORDER_XRGB:
         *Rmask = masks[1];
         *Gmask = masks[2];
         *Bmask = masks[3];
         break;
     case SDL_PACKEDORDER_RGBX:
         *Rmask = masks[0];
         *Gmask = masks[1];
         *Bmask = masks[2];
         break;
     case SDL_PACKEDORDER_ARGB:
         *Amask = masks[0];
         *Rmask = masks[1];
         *Gmask = masks[2];
         *Bmask = masks[3];
         break;
     case SDL_PACKEDORDER_RGBA:
         *Rmask = masks[0];
         *Gmask = masks[1];
         *Bmask = masks[2];
         *Amask = masks[3];
         break;
     case SDL_PACKEDORDER_XBGR:
         *Bmask = masks[1];
         *Gmask = masks[2];
         *Rmask = masks[3];
         break;
     case SDL_PACKEDORDER_BGRX:
         *Bmask = masks[0];
         *Gmask = masks[1];
         *Rmask = masks[2];
         break;
     case SDL_PACKEDORDER_BGRA:
         *Bmask = masks[0];
         *Gmask = masks[1];
         *Rmask = masks[2];
         *Amask = masks[3];
         break;
     case SDL_PACKEDORDER_ABGR:
         *Amask = masks[0];
         *Bmask = masks[1];
         *Gmask = masks[2];
         *Rmask = masks[3];
         break;
     default:
         SDL_SetError("Unknown pixel format");
         return SDL_FALSE;
     }
     return SDL_TRUE;
 }

References bpp, 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

palette	The palette to modify.
colors	An array of colors to copy into the palette.
firstcolor	The index of the first palette entry to modify.
ncolors	The number of entries to modify.

Returns: 0 on success, or -1 if not all of the colors could be set.

Definition at line 705 of file SDL_pixels.c.

 {
     int status = 0;
  
     /* Verify the parameters */
     if (!palette) {
         return -1;
     }
     if (ncolors > (palette->ncolors - firstcolor)) {
         ncolors = (palette->ncolors - firstcolor);
         status = -1;
     }
  
     if (colors != (palette->colors + firstcolor)) {
         SDL_memcpy(palette->colors + firstcolor, colors,
                    ncolors * sizeof(*colors));
     }
     ++palette->version;
     if (!palette->version) {
         palette->version = 1;
     }
  
     return status;
 }

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

 {
     if (!format) {
         return SDL_SetError("SDL_SetPixelFormatPalette() passed NULL format");
     }
  
     if (palette && palette->ncolors > (1 << format->BitsPerPixel)) {
         return SDL_SetError("SDL_SetPixelFormatPalette() passed a palette that doesn't match the format");
     }
  
     if (format->palette == palette) {
         return 0;
     }
  
     if (format->palette) {
         SDL_FreePalette(format->palette);
     }
  
     format->palette = palette;
  
     if (format->palette) {
         ++format->palette->refcount;
     }
  
     return 0;
 }

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

Data Structures

Transparency definitions

Detailed Description

Macro Definition Documentation

◆ SDL_ALPHA_OPAQUE

◆ SDL_ALPHA_TRANSPARENT

◆ SDL_BITSPERPIXEL

◆ SDL_BYTESPERPIXEL

◆ SDL_Colour

◆ SDL_DEFINE_PIXELFORMAT

◆ SDL_DEFINE_PIXELFOURCC

◆ SDL_ISPIXELFORMAT_ALPHA

◆ SDL_ISPIXELFORMAT_ARRAY

◆ SDL_ISPIXELFORMAT_FOURCC

◆ SDL_ISPIXELFORMAT_INDEXED

◆ SDL_ISPIXELFORMAT_PACKED

◆ SDL_PIXELFLAG

◆ SDL_PIXELLAYOUT

◆ SDL_PIXELORDER

◆ SDL_PIXELTYPE

Enumeration Type Documentation

◆ SDL_ArrayOrder

◆ SDL_BitmapOrder

◆ SDL_PackedLayout

◆ SDL_PackedOrder

◆ SDL_PixelFormatEnum

◆ SDL_PixelType

Function Documentation

◆ SDL_AllocFormat()

◆ SDL_AllocPalette()

◆ SDL_CalculateGammaRamp()

◆ SDL_FreeFormat()

◆ SDL_FreePalette()

◆ SDL_GetPixelFormatName()

◆ SDL_GetRGB()

◆ SDL_GetRGBA()

◆ SDL_MapRGB()

◆ SDL_MapRGBA()

◆ SDL_MasksToPixelFormatEnum()

◆ SDL_PixelFormatEnumToMasks()

◆ SDL_SetPaletteColors()

◆ SDL_SetPixelFormatPalette()