misc/builddeps/win32/sdl/include/SDL2/SDL_surface.h

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