1/*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any damages
7 arising from the use of this software.
8
9 Permission is granted to anyone to use this software for any purpose,
10 including commercial applications, and to alter it and redistribute it
11 freely, subject to the following restrictions:
12
13 1. The origin of this software must not be misrepresented; you must not
14 claim that you wrote the original software. If you use this software
15 in a product, an acknowledgment in the product documentation would be
16 appreciated but is not required.
17 2. Altered source versions must be plainly marked as such, and must not be
18 misrepresented as being the original software.
19 3. This notice may not be removed or altered from any source distribution.
20*/
21
22/**
23 * \file SDL_surface.h
24 *
25 * Header file for ::SDL_Surface definition and management functions.
26 */
27
28#ifndef SDL_surface_h_
29#define SDL_surface_h_
30
31#include "SDL_stdinc.h"
32#include "SDL_pixels.h"
33#include "SDL_rect.h"
34#include "SDL_blendmode.h"
35#include "SDL_rwops.h"
36
37#include "begin_code.h"
38/* Set up for C function definitions, even when using C++ */
39#ifdef __cplusplus
40extern "C" {
41#endif
42
43/**
44 * \name Surface flags
45 *
46 * These are the currently supported flags for the ::SDL_Surface.
47 *
48 * \internal
49 * Used internally (read-only).
50 */
51/* @{ */
52#define SDL_SWSURFACE 0 /**< Just here for compatibility */
53#define SDL_PREALLOC 0x00000001 /**< Surface uses preallocated memory */
54#define SDL_RLEACCEL 0x00000002 /**< Surface is RLE encoded */
55#define SDL_DONTFREE 0x00000004 /**< Surface is referenced internally */
56/* @} *//* Surface flags */
57
58/**
59 * Evaluates to true if the surface needs to be locked before access.
60 */
61#define SDL_MUSTLOCK(S) (((S)->flags & SDL_RLEACCEL) != 0)
62
63/**
64 * \brief A collection of pixels used in software blitting.
65 *
66 * \note This structure should be treated as read-only, except for \c pixels,
67 * which, if not NULL, contains the raw pixel data for the surface.
68 */
69typedef struct SDL_Surface
70{
71 Uint32 flags; /**< Read-only */
72 SDL_PixelFormat *format; /**< Read-only */
73 int w, h; /**< Read-only */
74 int pitch; /**< Read-only */
75 void *pixels; /**< Read-write */
76
77 /** Application data associated with the surface */
78 void *userdata; /**< Read-write */
79
80 /** information needed for surfaces requiring locks */
81 int locked; /**< Read-only */
82 void *lock_data; /**< Read-only */
83
84 /** clipping information */
85 SDL_Rect clip_rect; /**< Read-only */
86
87 /** info for fast blit mapping to other surfaces */
88 struct SDL_BlitMap *map; /**< Private */
89
90 /** Reference count -- used when freeing surface */
91 int refcount; /**< Read-mostly */
92} SDL_Surface;
93
94/**
95 * \brief The type of function used for surface blitting functions.
96 */
97typedef int (SDLCALL *SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
98 struct SDL_Surface * dst, SDL_Rect * dstrect);
99
100/**
101 * \brief The formula used for converting between YUV and RGB
102 */
103typedef enum
104{
105 SDL_YUV_CONVERSION_JPEG, /**< Full range JPEG */
106 SDL_YUV_CONVERSION_BT601, /**< BT.601 (the default) */
107 SDL_YUV_CONVERSION_BT709, /**< BT.709 */
108 SDL_YUV_CONVERSION_AUTOMATIC /**< BT.601 for SD content, BT.709 for HD content */
109} SDL_YUV_CONVERSION_MODE;
110
111/**
112 * Allocate and free an RGB surface.
113 *
114 * If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
115 * If the depth is greater than 8 bits, the pixel format is set using the
116 * flags '[RGB]mask'.
117 *
118 * If the function runs out of memory, it will return NULL.
119 *
120 * \param flags The \c flags are obsolete and should be set to 0.
121 * \param width The width in pixels of the surface to create.
122 * \param height The height in pixels of the surface to create.
123 * \param depth The depth in bits of the surface to create.
124 * \param Rmask The red mask of the surface to create.
125 * \param Gmask The green mask of the surface to create.
126 * \param Bmask The blue mask of the surface to create.
127 * \param Amask The alpha mask of the surface to create.
128 */
129extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
130 (Uint32 flags, int width, int height, int depth,
131 Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
132
133/* !!! FIXME for 2.1: why does this ask for depth? Format provides that. */
134extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormat
135 (Uint32 flags, int width, int height, int depth, Uint32 format);
136
137extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
138 int width,
139 int height,
140 int depth,
141 int pitch,
142 Uint32 Rmask,
143 Uint32 Gmask,
144 Uint32 Bmask,
145 Uint32 Amask);
146extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormatFrom
147 (void *pixels, int width, int height, int depth, int pitch, Uint32 format);
148extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
149
150/**
151 * \brief Set the palette used by a surface.
152 *
153 * \return 0, or -1 if the surface format doesn't use a palette.
154 *
155 * \note A single palette can be shared with many surfaces.
156 */
157extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface,
158 SDL_Palette * palette);
159
160/**
161 * \brief Sets up a surface for directly accessing the pixels.
162 *
163 * Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write
164 * to and read from \c surface->pixels, using the pixel format stored in
165 * \c surface->format. Once you are done accessing the surface, you should
166 * use SDL_UnlockSurface() to release it.
167 *
168 * Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates
169 * to 0, then you can read and write to the surface at any time, and the
170 * pixel format of the surface will not change.
171 *
172 * No operating system or library calls should be made between lock/unlock
173 * pairs, as critical system locks may be held during this time.
174 *
175 * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
176 *
177 * \sa SDL_UnlockSurface()
178 */
179extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
180/** \sa SDL_LockSurface() */
181extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface);
182
183/**
184 * Load a surface from a seekable SDL data stream (memory or file).
185 *
186 * If \c freesrc is non-zero, the stream will be closed after being read.
187 *
188 * The new surface should be freed with SDL_FreeSurface().
189 *
190 * \return the new surface, or NULL if there was an error.
191 */
192extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src,
193 int freesrc);
194
195/**
196 * Load a surface from a file.
197 *
198 * Convenience macro.
199 */
200#define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
201
202/**
203 * Save a surface to a seekable SDL data stream (memory or file).
204 *
205 * Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the
206 * BMP directly. Other RGB formats with 8-bit or higher get converted to a
207 * 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit
208 * surface before they are saved. YUV and paletted 1-bit and 4-bit formats are
209 * not supported.
210 *
211 * If \c freedst is non-zero, the stream will be closed after being written.
212 *
213 * \return 0 if successful or -1 if there was an error.
214 */
215extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
216 (SDL_Surface * surface, SDL_RWops * dst, int freedst);
217
218/**
219 * Save a surface to a file.
220 *
221 * Convenience macro.
222 */
223#define SDL_SaveBMP(surface, file) \
224 SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
225
226/**
227 * \brief Sets the RLE acceleration hint for a surface.
228 *
229 * \return 0 on success, or -1 if the surface is not valid
230 *
231 * \note If RLE is enabled, colorkey and alpha blending blits are much faster,
232 * but the surface must be locked before directly accessing the pixels.
233 */
234extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
235 int flag);
236
237/**
238 * \brief Sets the color key (transparent pixel) in a blittable surface.
239 *
240 * \param surface The surface to update
241 * \param flag Non-zero to enable colorkey and 0 to disable colorkey
242 * \param key The transparent pixel in the native surface format
243 *
244 * \return 0 on success, or -1 if the surface is not valid
245 *
246 * You can pass SDL_RLEACCEL to enable RLE accelerated blits.
247 */
248extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
249 int flag, Uint32 key);
250
251/**
252 * \brief Gets the color key (transparent pixel) in a blittable surface.
253 *
254 * \param surface The surface to update
255 * \param key A pointer filled in with the transparent pixel in the native
256 * surface format
257 *
258 * \return 0 on success, or -1 if the surface is not valid or colorkey is not
259 * enabled.
260 */
261extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
262 Uint32 * key);
263
264/**
265 * \brief Set an additional color value used in blit operations.
266 *
267 * \param surface The surface to update.
268 * \param r The red color value multiplied into blit operations.
269 * \param g The green color value multiplied into blit operations.
270 * \param b The blue color value multiplied into blit operations.
271 *
272 * \return 0 on success, or -1 if the surface is not valid.
273 *
274 * \sa SDL_GetSurfaceColorMod()
275 */
276extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
277 Uint8 r, Uint8 g, Uint8 b);
278
279
280/**
281 * \brief Get the additional color value used in blit operations.
282 *
283 * \param surface The surface to query.
284 * \param r A pointer filled in with the current red color value.
285 * \param g A pointer filled in with the current green color value.
286 * \param b A pointer filled in with the current blue color value.
287 *
288 * \return 0 on success, or -1 if the surface is not valid.
289 *
290 * \sa SDL_SetSurfaceColorMod()
291 */
292extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
293 Uint8 * r, Uint8 * g,
294 Uint8 * b);
295
296/**
297 * \brief Set an additional alpha value used in blit operations.
298 *
299 * \param surface The surface to update.
300 * \param alpha The alpha value multiplied into blit operations.
301 *
302 * \return 0 on success, or -1 if the surface is not valid.
303 *
304 * \sa SDL_GetSurfaceAlphaMod()
305 */
306extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
307 Uint8 alpha);
308
309/**
310 * \brief Get the additional alpha value used in blit operations.
311 *
312 * \param surface The surface to query.
313 * \param alpha A pointer filled in with the current alpha value.
314 *
315 * \return 0 on success, or -1 if the surface is not valid.
316 *
317 * \sa SDL_SetSurfaceAlphaMod()
318 */
319extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
320 Uint8 * alpha);
321
322/**
323 * \brief Set the blend mode used for blit operations.
324 *
325 * \param surface The surface to update.
326 * \param blendMode ::SDL_BlendMode to use for blit blending.
327 *
328 * \return 0 on success, or -1 if the parameters are not valid.
329 *
330 * \sa SDL_GetSurfaceBlendMode()
331 */
332extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
333 SDL_BlendMode blendMode);
334
335/**
336 * \brief Get the blend mode used for blit operations.
337 *
338 * \param surface The surface to query.
339 * \param blendMode A pointer filled in with the current blend mode.
340 *
341 * \return 0 on success, or -1 if the surface is not valid.
342 *
343 * \sa SDL_SetSurfaceBlendMode()
344 */
345extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
346 SDL_BlendMode *blendMode);
347
348/**
349 * Sets the clipping rectangle for the destination surface in a blit.
350 *
351 * If the clip rectangle is NULL, clipping will be disabled.
352 *
353 * If the clip rectangle doesn't intersect the surface, the function will
354 * return SDL_FALSE and blits will be completely clipped. Otherwise the
355 * function returns SDL_TRUE and blits to the surface will be clipped to
356 * the intersection of the surface area and the clipping rectangle.
357 *
358 * Note that blits are automatically clipped to the edges of the source
359 * and destination surfaces.
360 */
361extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
362 const SDL_Rect * rect);
363
364/**
365 * Gets the clipping rectangle for the destination surface in a blit.
366 *
367 * \c rect must be a pointer to a valid rectangle which will be filled
368 * with the correct values.
369 */
370extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface * surface,
371 SDL_Rect * rect);
372
373/*
374 * Creates a new surface identical to the existing surface
375 */
376extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface * surface);
377
378/**
379 * Creates a new surface of the specified format, and then copies and maps
380 * the given surface to it so the blit of the converted surface will be as
381 * fast as possible. If this function fails, it returns NULL.
382 *
383 * The \c flags parameter is passed to SDL_CreateRGBSurface() and has those
384 * semantics. You can also pass ::SDL_RLEACCEL in the flags parameter and
385 * SDL will try to RLE accelerate colorkey and alpha blits in the resulting
386 * surface.
387 */
388extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
389 (SDL_Surface * src, const SDL_PixelFormat * fmt, Uint32 flags);
390extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat
391 (SDL_Surface * src, Uint32 pixel_format, Uint32 flags);
392
393/**
394 * \brief Copy a block of pixels of one format to another format
395 *
396 * \return 0 on success, or -1 if there was an error
397 */
398extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
399 Uint32 src_format,
400 const void * src, int src_pitch,
401 Uint32 dst_format,
402 void * dst, int dst_pitch);
403
404/**
405 * Performs a fast fill of the given rectangle with \c color.
406 *
407 * If \c rect is NULL, the whole surface will be filled with \c color.
408 *
409 * The color should be a pixel of the format used by the surface, and
410 * can be generated by the SDL_MapRGB() function.
411 *
412 * \return 0 on success, or -1 on error.
413 */
414extern DECLSPEC int SDLCALL SDL_FillRect
415 (SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
416extern DECLSPEC int SDLCALL SDL_FillRects
417 (SDL_Surface * dst, const SDL_Rect * rects, int count, Uint32 color);
418
419/**
420 * Performs a fast blit from the source surface to the destination surface.
421 *
422 * This assumes that the source and destination rectangles are
423 * the same size. If either \c srcrect or \c dstrect are NULL, the entire
424 * surface (\c src or \c dst) is copied. The final blit rectangles are saved
425 * in \c srcrect and \c dstrect after all clipping is performed.
426 *
427 * \return If the blit is successful, it returns 0, otherwise it returns -1.
428 *
429 * The blit function should not be called on a locked surface.
430 *
431 * The blit semantics for surfaces with and without blending and colorkey
432 * are defined as follows:
433 * \verbatim
434 RGBA->RGB:
435 Source surface blend mode set to SDL_BLENDMODE_BLEND:
436 alpha-blend (using the source alpha-channel and per-surface alpha)
437 SDL_SRCCOLORKEY ignored.
438 Source surface blend mode set to SDL_BLENDMODE_NONE:
439 copy RGB.
440 if SDL_SRCCOLORKEY set, only copy the pixels matching the
441 RGB values of the source color key, ignoring alpha in the
442 comparison.
443
444 RGB->RGBA:
445 Source surface blend mode set to SDL_BLENDMODE_BLEND:
446 alpha-blend (using the source per-surface alpha)
447 Source surface blend mode set to SDL_BLENDMODE_NONE:
448 copy RGB, set destination alpha to source per-surface alpha value.
449 both:
450 if SDL_SRCCOLORKEY set, only copy the pixels matching the
451 source color key.
452
453 RGBA->RGBA:
454 Source surface blend mode set to SDL_BLENDMODE_BLEND:
455 alpha-blend (using the source alpha-channel and per-surface alpha)
456 SDL_SRCCOLORKEY ignored.
457 Source surface blend mode set to SDL_BLENDMODE_NONE:
458 copy all of RGBA to the destination.
459 if SDL_SRCCOLORKEY set, only copy the pixels matching the
460 RGB values of the source color key, ignoring alpha in the
461 comparison.
462
463 RGB->RGB:
464 Source surface blend mode set to SDL_BLENDMODE_BLEND:
465 alpha-blend (using the source per-surface alpha)
466 Source surface blend mode set to SDL_BLENDMODE_NONE:
467 copy RGB.
468 both:
469 if SDL_SRCCOLORKEY set, only copy the pixels matching the
470 source color key.
471 \endverbatim
472 *
473 * You should call SDL_BlitSurface() unless you know exactly how SDL
474 * blitting works internally and how to use the other blit functions.
475 */
476#define SDL_BlitSurface SDL_UpperBlit
477
478/**
479 * This is the public blit function, SDL_BlitSurface(), and it performs
480 * rectangle validation and clipping before passing it to SDL_LowerBlit()
481 */
482extern DECLSPEC int SDLCALL SDL_UpperBlit
483 (SDL_Surface * src, const SDL_Rect * srcrect,
484 SDL_Surface * dst, SDL_Rect * dstrect);
485
486/**
487 * This is a semi-private blit function and it performs low-level surface
488 * blitting only.
489 */
490extern DECLSPEC int SDLCALL SDL_LowerBlit
491 (SDL_Surface * src, SDL_Rect * srcrect,
492 SDL_Surface * dst, SDL_Rect * dstrect);
493
494/**
495 * \brief Perform a fast, low quality, stretch blit between two surfaces of the
496 * same pixel format.
497 *
498 * \note This function uses a static buffer, and is not thread-safe.
499 */
500extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src,
501 const SDL_Rect * srcrect,
502 SDL_Surface * dst,
503 const SDL_Rect * dstrect);
504
505#define SDL_BlitScaled SDL_UpperBlitScaled
506
507/**
508 * This is the public scaled blit function, SDL_BlitScaled(), and it performs
509 * rectangle validation and clipping before passing it to SDL_LowerBlitScaled()
510 */
511extern DECLSPEC int SDLCALL SDL_UpperBlitScaled
512 (SDL_Surface * src, const SDL_Rect * srcrect,
513 SDL_Surface * dst, SDL_Rect * dstrect);
514
515/**
516 * This is a semi-private blit function and it performs low-level surface
517 * scaled blitting only.
518 */
519extern DECLSPEC int SDLCALL SDL_LowerBlitScaled
520 (SDL_Surface * src, SDL_Rect * srcrect,
521 SDL_Surface * dst, SDL_Rect * dstrect);
522
523/**
524 * \brief Set the YUV conversion mode
525 */
526extern DECLSPEC void SDLCALL SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_MODE mode);
527
528/**
529 * \brief Get the YUV conversion mode
530 */
531extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionMode(void);
532
533/**
534 * \brief Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
535 */
536extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionModeForResolution(int width, int height);
537
538/* Ends C function definitions when using C++ */
539#ifdef __cplusplus
540}
541#endif
542#include "close_code.h"
543
544#endif /* SDL_surface_h_ */
545
546/* vi: set ts=4 sw=4 expandtab: */
547