fermium/
pixels.rs

1#![allow(missing_docs)]
2
3//! Module for pixel editing.
4
5use crate::{c_char, c_int, stdinc::*};
6
7/// More alpha => more opaque.
8pub const SDL_ALPHA_OPAQUE: u8 = 255;
9/// Transparent pixels are alpha = 0.
10pub const SDL_ALPHA_TRANSPARENT: u8 = 0;
11
12/// Pixel type.
13///
14/// Instances of this value are called `SDL_PIXELTYPE_*`
15#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
16#[repr(transparent)]
17pub struct SDL_PixelType(pub u32);
18/// An unknown pixel type.
19pub const SDL_PIXELTYPE_UNKNOWN: SDL_PixelType = SDL_PixelType(0);
20pub const SDL_PIXELTYPE_INDEX1: SDL_PixelType = SDL_PixelType(1);
21pub const SDL_PIXELTYPE_INDEX4: SDL_PixelType = SDL_PixelType(2);
22pub const SDL_PIXELTYPE_INDEX8: SDL_PixelType = SDL_PixelType(3);
23pub const SDL_PIXELTYPE_PACKED8: SDL_PixelType = SDL_PixelType(4);
24pub const SDL_PIXELTYPE_PACKED16: SDL_PixelType = SDL_PixelType(5);
25pub const SDL_PIXELTYPE_PACKED32: SDL_PixelType = SDL_PixelType(6);
26pub const SDL_PIXELTYPE_ARRAYU8: SDL_PixelType = SDL_PixelType(7);
27pub const SDL_PIXELTYPE_ARRAYU16: SDL_PixelType = SDL_PixelType(8);
28pub const SDL_PIXELTYPE_ARRAYU32: SDL_PixelType = SDL_PixelType(9);
29pub const SDL_PIXELTYPE_ARRAYF16: SDL_PixelType = SDL_PixelType(10);
30pub const SDL_PIXELTYPE_ARRAYF32: SDL_PixelType = SDL_PixelType(11);
31
32/// Bitmap pixel order, high bit -> low bit.
33///
34/// Instances of this value are called `SDL_BITMAPORDER_*`
35#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
36#[repr(transparent)]
37pub struct SDL_BitmapOrder(pub u32);
38/// No bitmap ordering.
39pub const SDL_BITMAPORDER_NONE: SDL_BitmapOrder = SDL_BitmapOrder(0);
40/// Bitmap ordering from high to low.
41pub const SDL_BITMAPORDER_4321: SDL_BitmapOrder = SDL_BitmapOrder(1);
42/// Bitmap ordering from low to high.
43pub const SDL_BITMAPORDER_1234: SDL_BitmapOrder = SDL_BitmapOrder(2);
44
45/// Packed component order, high bit -> low bit.
46///
47/// Instances of this value are called `SDL_PACKEDORDER_*`
48#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
49#[repr(transparent)]
50pub struct SDL_PackedOrder(pub u32);
51pub const SDL_PACKEDORDER_NONE: SDL_PackedOrder = SDL_PackedOrder(0);
52pub const SDL_PACKEDORDER_XRGB: SDL_PackedOrder = SDL_PackedOrder(1);
53pub const SDL_PACKEDORDER_RGBX: SDL_PackedOrder = SDL_PackedOrder(2);
54pub const SDL_PACKEDORDER_ARGB: SDL_PackedOrder = SDL_PackedOrder(3);
55pub const SDL_PACKEDORDER_RGBA: SDL_PackedOrder = SDL_PackedOrder(4);
56pub const SDL_PACKEDORDER_XBGR: SDL_PackedOrder = SDL_PackedOrder(5);
57pub const SDL_PACKEDORDER_BGRX: SDL_PackedOrder = SDL_PackedOrder(6);
58pub const SDL_PACKEDORDER_ABGR: SDL_PackedOrder = SDL_PackedOrder(7);
59pub const SDL_PACKEDORDER_BGRA: SDL_PackedOrder = SDL_PackedOrder(8);
60
61/// Array component order, low byte -> high byte.
62///
63/// Instances of this value are called `SDL_ARRAYORDER_*`
64#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
65#[repr(transparent)]
66pub struct SDL_ArrayOrder(pub u32);
67pub const SDL_ARRAYORDER_NONE: SDL_ArrayOrder = SDL_ArrayOrder(0);
68pub const SDL_ARRAYORDER_RGB: SDL_ArrayOrder = SDL_ArrayOrder(1);
69pub const SDL_ARRAYORDER_RGBA: SDL_ArrayOrder = SDL_ArrayOrder(2);
70pub const SDL_ARRAYORDER_ARGB: SDL_ArrayOrder = SDL_ArrayOrder(3);
71pub const SDL_ARRAYORDER_BGR: SDL_ArrayOrder = SDL_ArrayOrder(4);
72pub const SDL_ARRAYORDER_BGRA: SDL_ArrayOrder = SDL_ArrayOrder(5);
73pub const SDL_ARRAYORDER_ABGR: SDL_ArrayOrder = SDL_ArrayOrder(6);
74
75/// Packed component order, high bit -> low bit.
76///
77/// Instances of this value are called `SDL_PACKEDLAYOUT_*`
78#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
79#[repr(transparent)]
80pub struct SDL_PackedLayout(pub u32);
81pub const SDL_PACKEDLAYOUT_NONE: SDL_PackedLayout = SDL_PackedLayout(0);
82pub const SDL_PACKEDLAYOUT_332: SDL_PackedLayout = SDL_PackedLayout(1);
83pub const SDL_PACKEDLAYOUT_4444: SDL_PackedLayout = SDL_PackedLayout(2);
84pub const SDL_PACKEDLAYOUT_1555: SDL_PackedLayout = SDL_PackedLayout(3);
85pub const SDL_PACKEDLAYOUT_5551: SDL_PackedLayout = SDL_PackedLayout(4);
86pub const SDL_PACKEDLAYOUT_565: SDL_PackedLayout = SDL_PackedLayout(5);
87pub const SDL_PACKEDLAYOUT_8888: SDL_PackedLayout = SDL_PackedLayout(6);
88pub const SDL_PACKEDLAYOUT_2101010: SDL_PackedLayout = SDL_PackedLayout(7);
89pub const SDL_PACKEDLAYOUT_1010102: SDL_PackedLayout = SDL_PackedLayout(8);
90
91/// Converts a FourCC into a pixel format enumeration value.
92#[inline]
93#[must_use]
94pub const fn SDL_DEFINE_PIXELFOURCC(
95  a: u8, b: u8, c: u8, d: u8,
96) -> SDL_PixelFormatEnum {
97  SDL_PixelFormatEnum(SDL_FOURCC(a, b, c, d))
98}
99
100/// Converts the pixel type parameters into a pixel format enumeration value.
101#[inline]
102#[must_use]
103pub const fn SDL_DEFINE_PIXELFORMAT(
104  type_: SDL_PixelType, order: u32, layout: u32, bits: u32, bytes: u32,
105) -> SDL_PixelFormatEnum {
106  SDL_PixelFormatEnum(
107    (1 << 28)
108      | ((type_.0) << 24)
109      | ((order) << 20)
110      | ((layout) << 16)
111      | ((bits) << 8)
112      | (bytes),
113  )
114}
115
116/// Gets the pixel flag bits.
117///
118/// Generally 1, except that FourCC enumerations can have other values.
119#[inline]
120#[must_use]
121pub const fn SDL_PIXELFLAG(x: SDL_PixelFormatEnum) -> u32 {
122  ((x.0) >> 28) & 0x0F
123}
124/// Gets the pixel type bits.
125#[inline]
126#[must_use]
127pub const fn SDL_PIXELTYPE(x: SDL_PixelFormatEnum) -> u32 {
128  ((x.0) >> 24) & 0x0F
129}
130/// Gets the pixel order bits.
131#[inline]
132#[must_use]
133pub const fn SDL_PIXELORDER(x: SDL_PixelFormatEnum) -> u32 {
134  ((x.0) >> 20) & 0x0F
135}
136/// Gets the pixel layout bits.
137#[inline]
138#[must_use]
139pub const fn SDL_PIXELLAYOUT(x: SDL_PixelFormatEnum) -> u32 {
140  ((x.0) >> 16) & 0x0F
141}
142/// Gets the bits per pixel.
143#[inline]
144#[must_use]
145pub const fn SDL_BITSPERPIXEL(x: SDL_PixelFormatEnum) -> u32 {
146  ((x.0) >> 8) & 0xFF
147}
148/// Gets the bytes per pixel.
149#[inline]
150#[must_use]
151pub const fn SDL_BYTESPERPIXEL(x: SDL_PixelFormatEnum) -> u32 {
152  if SDL_ISPIXELFORMAT_FOURCC(x) {
153    if ((x.0) == SDL_PIXELFORMAT_YUY2.0)
154      || ((x.0) == SDL_PIXELFORMAT_UYVY.0)
155      || ((x.0) == SDL_PIXELFORMAT_YVYU.0)
156    {
157      2
158    } else {
159      1
160    }
161  } else {
162    x.0 & 0xFF
163  }
164}
165/// Is this pixel format an indexed format?
166#[inline]
167#[must_use]
168pub const fn SDL_ISPIXELFORMAT_INDEXED(format: SDL_PixelFormatEnum) -> bool {
169  !SDL_ISPIXELFORMAT_FOURCC(format)
170    && ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX1.0)
171      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX4.0)
172      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX8.0))
173}
174/// Is this pixel format a packed format?
175#[inline]
176#[must_use]
177pub const fn SDL_ISPIXELFORMAT_PACKED(format: SDL_PixelFormatEnum) -> bool {
178  !SDL_ISPIXELFORMAT_FOURCC(format)
179    && ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_PACKED8.0)
180      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_PACKED16.0)
181      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_PACKED32.0))
182}
183/// Is this pixel format an array format?
184#[inline]
185#[must_use]
186pub const fn SDL_ISPIXELFORMAT_ARRAY(format: SDL_PixelFormatEnum) -> bool {
187  !SDL_ISPIXELFORMAT_FOURCC(format)
188    && ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYU8.0)
189      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYU16.0)
190      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYU32.0)
191      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYF16.0)
192      || (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_ARRAYF32.0))
193}
194/// Does the pixel format have an alpha channel?
195#[inline]
196#[must_use]
197pub const fn SDL_ISPIXELFORMAT_ALPHA(format: SDL_PixelFormatEnum) -> bool {
198  (SDL_ISPIXELFORMAT_PACKED(format)
199    && ((SDL_PIXELORDER(format) == SDL_PACKEDORDER_ARGB.0)
200      || (SDL_PIXELORDER(format) == SDL_PACKEDORDER_RGBA.0)
201      || (SDL_PIXELORDER(format) == SDL_PACKEDORDER_ABGR.0)
202      || (SDL_PIXELORDER(format) == SDL_PACKEDORDER_BGRA.0)))
203    || (SDL_ISPIXELFORMAT_ARRAY(format)
204      && ((SDL_PIXELORDER(format) == SDL_ARRAYORDER_ARGB.0)
205        || (SDL_PIXELORDER(format) == SDL_ARRAYORDER_RGBA.0)
206        || (SDL_PIXELORDER(format) == SDL_ARRAYORDER_ABGR.0)
207        || (SDL_PIXELORDER(format) == SDL_ARRAYORDER_BGRA.0)))
208}
209/// Is the pixel format a FourCC format?
210#[inline]
211#[must_use]
212pub const fn SDL_ISPIXELFORMAT_FOURCC(format: SDL_PixelFormatEnum) -> bool {
213  (format.0 != 0) && (SDL_PIXELFLAG(format) != 1)
214}
215
216/// An enumerated pixel format value.
217///
218/// Instances of this value are called `SDL_PIXELFORMAT_*`
219#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
220#[repr(transparent)]
221pub struct SDL_PixelFormatEnum(pub u32);
222pub const SDL_PIXELFORMAT_UNKNOWN: SDL_PixelFormatEnum = SDL_PixelFormatEnum(0);
223pub const SDL_PIXELFORMAT_INDEX1LSB: SDL_PixelFormatEnum =
224  SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_4321.0, 0, 1, 0);
225pub const SDL_PIXELFORMAT_INDEX1MSB: SDL_PixelFormatEnum =
226  SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_1234.0, 0, 1, 0);
227pub const SDL_PIXELFORMAT_INDEX4LSB: SDL_PixelFormatEnum =
228  SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_4321.0, 0, 4, 0);
229pub const SDL_PIXELFORMAT_INDEX4MSB: SDL_PixelFormatEnum =
230  SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_1234.0, 0, 4, 0);
231pub const SDL_PIXELFORMAT_INDEX8: SDL_PixelFormatEnum =
232  SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1);
233pub const SDL_PIXELFORMAT_RGB332: SDL_PixelFormatEnum = SDL_DEFINE_PIXELFORMAT(
234  SDL_PIXELTYPE_PACKED8,
235  SDL_PACKEDORDER_XRGB.0,
236  SDL_PACKEDLAYOUT_332.0,
237  8,
238  1,
239);
240pub const SDL_PIXELFORMAT_XRGB4444: SDL_PixelFormatEnum =
241  SDL_DEFINE_PIXELFORMAT(
242    SDL_PIXELTYPE_PACKED16,
243    SDL_PACKEDORDER_XRGB.0,
244    SDL_PACKEDLAYOUT_4444.0,
245    12,
246    2,
247  );
248pub const SDL_PIXELFORMAT_RGB444: SDL_PixelFormatEnum =
249  SDL_PIXELFORMAT_XRGB4444;
250pub const SDL_PIXELFORMAT_XBGR4444: SDL_PixelFormatEnum =
251  SDL_DEFINE_PIXELFORMAT(
252    SDL_PIXELTYPE_PACKED16,
253    SDL_PACKEDORDER_XBGR.0,
254    SDL_PACKEDLAYOUT_4444.0,
255    12,
256    2,
257  );
258pub const SDL_PIXELFORMAT_BGR444: SDL_PixelFormatEnum =
259  SDL_PIXELFORMAT_XBGR4444;
260pub const SDL_PIXELFORMAT_XRGB1555: SDL_PixelFormatEnum =
261  SDL_DEFINE_PIXELFORMAT(
262    SDL_PIXELTYPE_PACKED16,
263    SDL_PACKEDORDER_XRGB.0,
264    SDL_PACKEDLAYOUT_1555.0,
265    15,
266    2,
267  );
268pub const SDL_PIXELFORMAT_RGB555: SDL_PixelFormatEnum =
269  SDL_PIXELFORMAT_XRGB1555;
270pub const SDL_PIXELFORMAT_XBGR1555: SDL_PixelFormatEnum =
271  SDL_DEFINE_PIXELFORMAT(
272    SDL_PIXELTYPE_PACKED16,
273    SDL_PACKEDORDER_XBGR.0,
274    SDL_PACKEDLAYOUT_1555.0,
275    15,
276    2,
277  );
278pub const SDL_PIXELFORMAT_BGR555: SDL_PixelFormatEnum =
279  SDL_PIXELFORMAT_XBGR1555;
280pub const SDL_PIXELFORMAT_ARGB4444: SDL_PixelFormatEnum =
281  SDL_DEFINE_PIXELFORMAT(
282    SDL_PIXELTYPE_PACKED16,
283    SDL_PACKEDORDER_ARGB.0,
284    SDL_PACKEDLAYOUT_4444.0,
285    16,
286    2,
287  );
288pub const SDL_PIXELFORMAT_RGBA4444: SDL_PixelFormatEnum =
289  SDL_DEFINE_PIXELFORMAT(
290    SDL_PIXELTYPE_PACKED16,
291    SDL_PACKEDORDER_RGBA.0,
292    SDL_PACKEDLAYOUT_4444.0,
293    16,
294    2,
295  );
296pub const SDL_PIXELFORMAT_ABGR4444: SDL_PixelFormatEnum =
297  SDL_DEFINE_PIXELFORMAT(
298    SDL_PIXELTYPE_PACKED16,
299    SDL_PACKEDORDER_ABGR.0,
300    SDL_PACKEDLAYOUT_4444.0,
301    16,
302    2,
303  );
304pub const SDL_PIXELFORMAT_BGRA4444: SDL_PixelFormatEnum =
305  SDL_DEFINE_PIXELFORMAT(
306    SDL_PIXELTYPE_PACKED16,
307    SDL_PACKEDORDER_BGRA.0,
308    SDL_PACKEDLAYOUT_4444.0,
309    16,
310    2,
311  );
312pub const SDL_PIXELFORMAT_ARGB1555: SDL_PixelFormatEnum =
313  SDL_DEFINE_PIXELFORMAT(
314    SDL_PIXELTYPE_PACKED16,
315    SDL_PACKEDORDER_ARGB.0,
316    SDL_PACKEDLAYOUT_1555.0,
317    16,
318    2,
319  );
320pub const SDL_PIXELFORMAT_RGBA5551: SDL_PixelFormatEnum =
321  SDL_DEFINE_PIXELFORMAT(
322    SDL_PIXELTYPE_PACKED16,
323    SDL_PACKEDORDER_RGBA.0,
324    SDL_PACKEDLAYOUT_5551.0,
325    16,
326    2,
327  );
328pub const SDL_PIXELFORMAT_ABGR1555: SDL_PixelFormatEnum =
329  SDL_DEFINE_PIXELFORMAT(
330    SDL_PIXELTYPE_PACKED16,
331    SDL_PACKEDORDER_ABGR.0,
332    SDL_PACKEDLAYOUT_1555.0,
333    16,
334    2,
335  );
336pub const SDL_PIXELFORMAT_BGRA5551: SDL_PixelFormatEnum =
337  SDL_DEFINE_PIXELFORMAT(
338    SDL_PIXELTYPE_PACKED16,
339    SDL_PACKEDORDER_BGRA.0,
340    SDL_PACKEDLAYOUT_5551.0,
341    16,
342    2,
343  );
344pub const SDL_PIXELFORMAT_RGB565: SDL_PixelFormatEnum = SDL_DEFINE_PIXELFORMAT(
345  SDL_PIXELTYPE_PACKED16,
346  SDL_PACKEDORDER_XRGB.0,
347  SDL_PACKEDLAYOUT_565.0,
348  16,
349  2,
350);
351pub const SDL_PIXELFORMAT_BGR565: SDL_PixelFormatEnum = SDL_DEFINE_PIXELFORMAT(
352  SDL_PIXELTYPE_PACKED16,
353  SDL_PACKEDORDER_XBGR.0,
354  SDL_PACKEDLAYOUT_565.0,
355  16,
356  2,
357);
358pub const SDL_PIXELFORMAT_RGB24: SDL_PixelFormatEnum =
359  SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB.0, 0, 24, 3);
360pub const SDL_PIXELFORMAT_BGR24: SDL_PixelFormatEnum =
361  SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_BGR.0, 0, 24, 3);
362pub const SDL_PIXELFORMAT_XRGB8888: SDL_PixelFormatEnum =
363  SDL_DEFINE_PIXELFORMAT(
364    SDL_PIXELTYPE_PACKED32,
365    SDL_PACKEDORDER_XRGB.0,
366    SDL_PACKEDLAYOUT_8888.0,
367    24,
368    4,
369  );
370pub const SDL_PIXELFORMAT_RGB888: SDL_PixelFormatEnum =
371  SDL_PIXELFORMAT_XRGB8888;
372pub const SDL_PIXELFORMAT_RGBX8888: SDL_PixelFormatEnum =
373  SDL_DEFINE_PIXELFORMAT(
374    SDL_PIXELTYPE_PACKED32,
375    SDL_PACKEDORDER_RGBX.0,
376    SDL_PACKEDLAYOUT_8888.0,
377    24,
378    4,
379  );
380pub const SDL_PIXELFORMAT_XBGR8888: SDL_PixelFormatEnum =
381  SDL_DEFINE_PIXELFORMAT(
382    SDL_PIXELTYPE_PACKED32,
383    SDL_PACKEDORDER_XBGR.0,
384    SDL_PACKEDLAYOUT_8888.0,
385    24,
386    4,
387  );
388pub const SDL_PIXELFORMAT_BGR888: SDL_PixelFormatEnum =
389  SDL_PIXELFORMAT_XBGR8888;
390pub const SDL_PIXELFORMAT_BGRX8888: SDL_PixelFormatEnum =
391  SDL_DEFINE_PIXELFORMAT(
392    SDL_PIXELTYPE_PACKED32,
393    SDL_PACKEDORDER_BGRX.0,
394    SDL_PACKEDLAYOUT_8888.0,
395    24,
396    4,
397  );
398pub const SDL_PIXELFORMAT_ARGB8888: SDL_PixelFormatEnum =
399  SDL_DEFINE_PIXELFORMAT(
400    SDL_PIXELTYPE_PACKED32,
401    SDL_PACKEDORDER_ARGB.0,
402    SDL_PACKEDLAYOUT_8888.0,
403    32,
404    4,
405  );
406pub const SDL_PIXELFORMAT_RGBA8888: SDL_PixelFormatEnum =
407  SDL_DEFINE_PIXELFORMAT(
408    SDL_PIXELTYPE_PACKED32,
409    SDL_PACKEDORDER_RGBA.0,
410    SDL_PACKEDLAYOUT_8888.0,
411    32,
412    4,
413  );
414pub const SDL_PIXELFORMAT_ABGR8888: SDL_PixelFormatEnum =
415  SDL_DEFINE_PIXELFORMAT(
416    SDL_PIXELTYPE_PACKED32,
417    SDL_PACKEDORDER_ABGR.0,
418    SDL_PACKEDLAYOUT_8888.0,
419    32,
420    4,
421  );
422pub const SDL_PIXELFORMAT_BGRA8888: SDL_PixelFormatEnum =
423  SDL_DEFINE_PIXELFORMAT(
424    SDL_PIXELTYPE_PACKED32,
425    SDL_PACKEDORDER_BGRA.0,
426    SDL_PACKEDLAYOUT_8888.0,
427    32,
428    4,
429  );
430pub const SDL_PIXELFORMAT_ARGB2101010: SDL_PixelFormatEnum =
431  SDL_DEFINE_PIXELFORMAT(
432    SDL_PIXELTYPE_PACKED32,
433    SDL_PACKEDORDER_ARGB.0,
434    SDL_PACKEDLAYOUT_2101010.0,
435    32,
436    4,
437  );
438
439pub const SDL_PIXELFORMAT_RGBA32: SDL_PixelFormatEnum =
440  if cfg!(target_endian = "big") {
441    SDL_PIXELFORMAT_RGBA8888
442  } else {
443    SDL_PIXELFORMAT_ABGR8888
444  };
445pub const SDL_PIXELFORMAT_ARGB32: SDL_PixelFormatEnum =
446  if cfg!(target_endian = "big") {
447    SDL_PIXELFORMAT_ARGB8888
448  } else {
449    SDL_PIXELFORMAT_BGRA8888
450  };
451pub const SDL_PIXELFORMAT_BGRA32: SDL_PixelFormatEnum =
452  if cfg!(target_endian = "big") {
453    SDL_PIXELFORMAT_BGRA8888
454  } else {
455    SDL_PIXELFORMAT_ARGB8888
456  };
457pub const SDL_PIXELFORMAT_ABGR32: SDL_PixelFormatEnum =
458  if cfg!(target_endian = "big") {
459    SDL_PIXELFORMAT_ABGR8888
460  } else {
461    SDL_PIXELFORMAT_RGBA8888
462  };
463
464/// Planar mode: Y + V + U  (3 planes)
465pub const SDL_PIXELFORMAT_YV12: SDL_PixelFormatEnum =
466  SDL_DEFINE_PIXELFOURCC(b'Y', b'V', b'1', b'2');
467/// Planar mode: Y + U + V  (3 planes)
468pub const SDL_PIXELFORMAT_IYUV: SDL_PixelFormatEnum =
469  SDL_DEFINE_PIXELFOURCC(b'I', b'Y', b'U', b'V');
470/// Packed mode: Y0+U0+Y1+V0 (1 plane)
471pub const SDL_PIXELFORMAT_YUY2: SDL_PixelFormatEnum =
472  SDL_DEFINE_PIXELFOURCC(b'Y', b'U', b'Y', b'2');
473/// Packed mode: U0+Y0+V0+Y1 (1 plane)
474pub const SDL_PIXELFORMAT_UYVY: SDL_PixelFormatEnum =
475  SDL_DEFINE_PIXELFOURCC(b'U', b'Y', b'V', b'Y');
476/// Packed mode: Y0+V0+Y1+U0 (1 plane)
477pub const SDL_PIXELFORMAT_YVYU: SDL_PixelFormatEnum =
478  SDL_DEFINE_PIXELFOURCC(b'Y', b'V', b'Y', b'U');
479/// Planar mode: Y + U/V interleaved  (2 planes)
480pub const SDL_PIXELFORMAT_NV12: SDL_PixelFormatEnum =
481  SDL_DEFINE_PIXELFOURCC(b'N', b'V', b'1', b'2');
482/// Planar mode: Y + V/U interleaved  (2 planes)
483pub const SDL_PIXELFORMAT_NV21: SDL_PixelFormatEnum =
484  SDL_DEFINE_PIXELFOURCC(b'N', b'V', b'2', b'1');
485/// Android video texture format
486pub const SDL_PIXELFORMAT_EXTERNAL_OES: SDL_PixelFormatEnum =
487  SDL_DEFINE_PIXELFOURCC(b'O', b'E', b'S', b' ');
488
489/// An RGBA color value (8-bits per channel).
490#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
491#[repr(C)]
492#[allow(missing_docs)]
493pub struct SDL_Color {
494  pub r: Uint8,
495  pub g: Uint8,
496  pub b: Uint8,
497  pub a: Uint8,
498}
499
500/// Info about a palette of colors.
501///
502/// Generally, you shouldn't alter these fields. In fact usually you shouldn't
503/// even allocate or free these on your own, SDL2 will do so for you at the
504/// appropriate times.
505#[derive(Debug)]
506#[repr(C)]
507pub struct SDL_Palette {
508  pub ncolors: c_int,
509  pub colors: *mut SDL_Color,
510  pub version: Uint32,
511  pub refcount: c_int,
512}
513
514/// An SDL Pixel Format.
515///
516/// Generally, you shouldn't alter these fields.
517#[derive(Debug)]
518#[repr(C)]
519pub struct SDL_PixelFormat {
520  pub format: Uint32,
521  pub palette: *mut SDL_Palette,
522  pub BitsPerPixel: Uint8,
523  pub BytesPerPixel: Uint8,
524  pub padding: [Uint8; 2],
525  pub Rmask: Uint32,
526  pub Gmask: Uint32,
527  pub Bmask: Uint32,
528  pub Amask: Uint32,
529  pub Rloss: Uint8,
530  pub Gloss: Uint8,
531  pub Bloss: Uint8,
532  pub Aloss: Uint8,
533  pub Rshift: Uint8,
534  pub Gshift: Uint8,
535  pub Bshift: Uint8,
536  pub Ashift: Uint8,
537  pub refcount: c_int,
538  pub next: *mut SDL_PixelFormat,
539}
540
541extern "C" {
542  /// Get the human readable name of a pixel format
543  pub fn SDL_GetPixelFormatName(format: Uint32) -> *const c_char;
544
545  /// Convert one of the enumerated pixel formats to a bpp and RGBA masks.
546  ///
547  /// **Return:** `SDL_TRUE`, or `SDL_FALSE` if the conversion wasn't possible.
548  pub fn SDL_PixelFormatEnumToMasks(
549    format: Uint32, bpp: *mut c_int, Rmask: *mut Uint32, Gmask: *mut Uint32,
550    Bmask: *mut Uint32, Amask: *mut Uint32,
551  ) -> SDL_bool;
552
553  /// Convert a bpp and RGBA masks to an enumerated pixel format.
554  ///
555  /// **Return:** The pixel format, or `SDL_PIXELFORMAT_UNKNOWN` if the
556  /// conversion wasn't possible.
557  pub fn SDL_MasksToPixelFormatEnum(
558    bpp: c_int, Rmask: Uint32, Gmask: Uint32, Bmask: Uint32, Amask: Uint32,
559  ) -> Uint32;
560
561  /// Create an [`SDL_PixelFormat`] structure from a pixel format enum.
562  pub fn SDL_AllocFormat(pixel_format: Uint32) -> *mut SDL_PixelFormat;
563
564  /// Free an [`SDL_PixelFormat`] structure.
565  pub fn SDL_FreeFormat(format: *mut SDL_PixelFormat);
566
567  /// Create a palette structure with the specified number of color entries.
568  ///
569  /// The palette entries are initialized to white.
570  ///
571  /// **Return:** A new palette, or NULL if there wasn't enough memory.
572  pub fn SDL_AllocPalette(ncolors: c_int) -> *mut SDL_Palette;
573
574  /// Set the palette for a pixel format structure.
575  pub fn SDL_SetPixelFormatPalette(
576    format: *mut SDL_PixelFormat, palette: *mut SDL_Palette,
577  ) -> c_int;
578
579  /// Set a range of colors in a palette.
580  ///
581  /// * `palette`: The palette to modify.
582  /// * `colors`: An array of colors to copy into the palette.
583  /// * `firstcolor`: The index of the first palette entry to modify.
584  /// * `ncolors`: The number of entries to modify.
585  ///
586  /// **Return:** 0 on success, or -1 if not all of the colors could be set.
587  pub fn SDL_SetPaletteColors(
588    palette: *mut SDL_Palette, colors: *const SDL_Color, firstcolor: c_int,
589    ncolors: c_int,
590  ) -> c_int;
591
592  /// Free a palette created with [`SDL_AllocPalette`].
593  pub fn SDL_FreePalette(palette: *mut SDL_Palette);
594
595  /// Maps an RGB triple to an opaque pixel value for a given pixel format.
596  pub fn SDL_MapRGB(
597    format: *const SDL_PixelFormat, r: Uint8, g: Uint8, b: Uint8,
598  ) -> Uint32;
599
600  /// Maps an RGBA quadruple to a pixel value for a given pixel format.
601  pub fn SDL_MapRGBA(
602    format: *const SDL_PixelFormat, r: Uint8, g: Uint8, b: Uint8, a: Uint8,
603  ) -> Uint32;
604
605  /// Get the RGB components from a pixel of the specified format.
606  pub fn SDL_GetRGB(
607    pixel: Uint32, format: *const SDL_PixelFormat, r: *mut Uint8,
608    g: *mut Uint8, b: *mut Uint8,
609  );
610
611  /// Get the RGBA components from a pixel of the specified format.
612  pub fn SDL_GetRGBA(
613    pixel: Uint32, format: *const SDL_PixelFormat, r: *mut Uint8,
614    g: *mut Uint8, b: *mut Uint8, a: *mut Uint8,
615  );
616
617  /// Calculate a 256 entry gamma ramp for a gamma value.
618  pub fn SDL_CalculateGammaRamp(gamma: f32, ramp: *mut Uint16);
619}