include/SDL_surface.h
author Sam Lantinga <slouken@libsdl.org>
Tue, 23 Oct 2018 12:40:25 -0700
changeset 12354 7846ac86d46e
parent 12204 5486557ca8d9
permissions -rw-r--r--
Fixed reinitializing the SDL joystick subsystem on Android
     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
    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 /* @} *//* 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  */
    69 typedef 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  */
    97 typedef 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  */
   103 typedef 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  */
   129 extern 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. */
   134 extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormat
   135     (Uint32 flags, int width, int height, int depth, Uint32 format);
   136 
   137 extern 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);
   146 extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormatFrom
   147     (void *pixels, int width, int height, int depth, int pitch, Uint32 format);
   148 extern 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  */
   157 extern 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  */
   179 extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
   180 /** \sa SDL_LockSurface() */
   181 extern 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  */
   192 extern 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  */
   215 extern 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  */
   234 extern 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  */
   248 extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
   249                                             int flag, Uint32 key);
   250 
   251 /**
   252  *  \brief Returns whether the surface has a color key
   253  *
   254  *  \return SDL_TRUE if the surface has a color key, or SDL_FALSE if the surface is NULL or has no color key
   255  */
   256 extern DECLSPEC SDL_bool SDLCALL SDL_HasColorKey(SDL_Surface * surface);
   257 
   258 /**
   259  *  \brief Gets the color key (transparent pixel) in a blittable surface.
   260  *
   261  *  \param surface The surface to update
   262  *  \param key A pointer filled in with the transparent pixel in the native
   263  *             surface format
   264  *
   265  *  \return 0 on success, or -1 if the surface is not valid or colorkey is not
   266  *          enabled.
   267  */
   268 extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
   269                                             Uint32 * key);
   270 
   271 /**
   272  *  \brief Set an additional color value used in blit operations.
   273  *
   274  *  \param surface The surface to update.
   275  *  \param r The red color value multiplied into blit operations.
   276  *  \param g The green color value multiplied into blit operations.
   277  *  \param b The blue color value multiplied into blit operations.
   278  *
   279  *  \return 0 on success, or -1 if the surface is not valid.
   280  *
   281  *  \sa SDL_GetSurfaceColorMod()
   282  */
   283 extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
   284                                                    Uint8 r, Uint8 g, Uint8 b);
   285 
   286 
   287 /**
   288  *  \brief Get the additional color value used in blit operations.
   289  *
   290  *  \param surface The surface to query.
   291  *  \param r A pointer filled in with the current red color value.
   292  *  \param g A pointer filled in with the current green color value.
   293  *  \param b A pointer filled in with the current blue color value.
   294  *
   295  *  \return 0 on success, or -1 if the surface is not valid.
   296  *
   297  *  \sa SDL_SetSurfaceColorMod()
   298  */
   299 extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
   300                                                    Uint8 * r, Uint8 * g,
   301                                                    Uint8 * b);
   302 
   303 /**
   304  *  \brief Set an additional alpha value used in blit operations.
   305  *
   306  *  \param surface The surface to update.
   307  *  \param alpha The alpha value multiplied into blit operations.
   308  *
   309  *  \return 0 on success, or -1 if the surface is not valid.
   310  *
   311  *  \sa SDL_GetSurfaceAlphaMod()
   312  */
   313 extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
   314                                                    Uint8 alpha);
   315 
   316 /**
   317  *  \brief Get the additional alpha value used in blit operations.
   318  *
   319  *  \param surface The surface to query.
   320  *  \param alpha A pointer filled in with the current alpha value.
   321  *
   322  *  \return 0 on success, or -1 if the surface is not valid.
   323  *
   324  *  \sa SDL_SetSurfaceAlphaMod()
   325  */
   326 extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
   327                                                    Uint8 * alpha);
   328 
   329 /**
   330  *  \brief Set the blend mode used for blit operations.
   331  *
   332  *  \param surface The surface to update.
   333  *  \param blendMode ::SDL_BlendMode to use for blit blending.
   334  *
   335  *  \return 0 on success, or -1 if the parameters are not valid.
   336  *
   337  *  \sa SDL_GetSurfaceBlendMode()
   338  */
   339 extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
   340                                                     SDL_BlendMode blendMode);
   341 
   342 /**
   343  *  \brief Get the blend mode used for blit operations.
   344  *
   345  *  \param surface   The surface to query.
   346  *  \param blendMode A pointer filled in with the current blend mode.
   347  *
   348  *  \return 0 on success, or -1 if the surface is not valid.
   349  *
   350  *  \sa SDL_SetSurfaceBlendMode()
   351  */
   352 extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
   353                                                     SDL_BlendMode *blendMode);
   354 
   355 /**
   356  *  Sets the clipping rectangle for the destination surface in a blit.
   357  *
   358  *  If the clip rectangle is NULL, clipping will be disabled.
   359  *
   360  *  If the clip rectangle doesn't intersect the surface, the function will
   361  *  return SDL_FALSE and blits will be completely clipped.  Otherwise the
   362  *  function returns SDL_TRUE and blits to the surface will be clipped to
   363  *  the intersection of the surface area and the clipping rectangle.
   364  *
   365  *  Note that blits are automatically clipped to the edges of the source
   366  *  and destination surfaces.
   367  */
   368 extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
   369                                                  const SDL_Rect * rect);
   370 
   371 /**
   372  *  Gets the clipping rectangle for the destination surface in a blit.
   373  *
   374  *  \c rect must be a pointer to a valid rectangle which will be filled
   375  *  with the correct values.
   376  */
   377 extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface * surface,
   378                                              SDL_Rect * rect);
   379 
   380 /*
   381  * Creates a new surface identical to the existing surface
   382  */
   383 extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface * surface);
   384 
   385 /**
   386  *  Creates a new surface of the specified format, and then copies and maps
   387  *  the given surface to it so the blit of the converted surface will be as
   388  *  fast as possible.  If this function fails, it returns NULL.
   389  *
   390  *  The \c flags parameter is passed to SDL_CreateRGBSurface() and has those
   391  *  semantics.  You can also pass ::SDL_RLEACCEL in the flags parameter and
   392  *  SDL will try to RLE accelerate colorkey and alpha blits in the resulting
   393  *  surface.
   394  */
   395 extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
   396     (SDL_Surface * src, const SDL_PixelFormat * fmt, Uint32 flags);
   397 extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat
   398     (SDL_Surface * src, Uint32 pixel_format, Uint32 flags);
   399 
   400 /**
   401  * \brief Copy a block of pixels of one format to another format
   402  *
   403  *  \return 0 on success, or -1 if there was an error
   404  */
   405 extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
   406                                               Uint32 src_format,
   407                                               const void * src, int src_pitch,
   408                                               Uint32 dst_format,
   409                                               void * dst, int dst_pitch);
   410 
   411 /**
   412  *  Performs a fast fill of the given rectangle with \c color.
   413  *
   414  *  If \c rect is NULL, the whole surface will be filled with \c color.
   415  *
   416  *  The color should be a pixel of the format used by the surface, and
   417  *  can be generated by the SDL_MapRGB() function.
   418  *
   419  *  \return 0 on success, or -1 on error.
   420  */
   421 extern DECLSPEC int SDLCALL SDL_FillRect
   422     (SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
   423 extern DECLSPEC int SDLCALL SDL_FillRects
   424     (SDL_Surface * dst, const SDL_Rect * rects, int count, Uint32 color);
   425 
   426 /**
   427  *  Performs a fast blit from the source surface to the destination surface.
   428  *
   429  *  This assumes that the source and destination rectangles are
   430  *  the same size.  If either \c srcrect or \c dstrect are NULL, the entire
   431  *  surface (\c src or \c dst) is copied.  The final blit rectangles are saved
   432  *  in \c srcrect and \c dstrect after all clipping is performed.
   433  *
   434  *  \return If the blit is successful, it returns 0, otherwise it returns -1.
   435  *
   436  *  The blit function should not be called on a locked surface.
   437  *
   438  *  The blit semantics for surfaces with and without blending and colorkey
   439  *  are defined as follows:
   440  *  \verbatim
   441     RGBA->RGB:
   442       Source surface blend mode set to SDL_BLENDMODE_BLEND:
   443         alpha-blend (using the source alpha-channel and per-surface alpha)
   444         SDL_SRCCOLORKEY ignored.
   445       Source surface blend mode set to SDL_BLENDMODE_NONE:
   446         copy RGB.
   447         if SDL_SRCCOLORKEY set, only copy the pixels matching the
   448         RGB values of the source color key, ignoring alpha in the
   449         comparison.
   450 
   451     RGB->RGBA:
   452       Source surface blend mode set to SDL_BLENDMODE_BLEND:
   453         alpha-blend (using the source per-surface alpha)
   454       Source surface blend mode set to SDL_BLENDMODE_NONE:
   455         copy RGB, set destination alpha to source per-surface alpha value.
   456       both:
   457         if SDL_SRCCOLORKEY set, only copy the pixels matching the
   458         source color key.
   459 
   460     RGBA->RGBA:
   461       Source surface blend mode set to SDL_BLENDMODE_BLEND:
   462         alpha-blend (using the source alpha-channel and per-surface alpha)
   463         SDL_SRCCOLORKEY ignored.
   464       Source surface blend mode set to SDL_BLENDMODE_NONE:
   465         copy all of RGBA to the destination.
   466         if SDL_SRCCOLORKEY set, only copy the pixels matching the
   467         RGB values of the source color key, ignoring alpha in the
   468         comparison.
   469 
   470     RGB->RGB:
   471       Source surface blend mode set to SDL_BLENDMODE_BLEND:
   472         alpha-blend (using the source per-surface alpha)
   473       Source surface blend mode set to SDL_BLENDMODE_NONE:
   474         copy RGB.
   475       both:
   476         if SDL_SRCCOLORKEY set, only copy the pixels matching the
   477         source color key.
   478     \endverbatim
   479  *
   480  *  You should call SDL_BlitSurface() unless you know exactly how SDL
   481  *  blitting works internally and how to use the other blit functions.
   482  */
   483 #define SDL_BlitSurface SDL_UpperBlit
   484 
   485 /**
   486  *  This is the public blit function, SDL_BlitSurface(), and it performs
   487  *  rectangle validation and clipping before passing it to SDL_LowerBlit()
   488  */
   489 extern DECLSPEC int SDLCALL SDL_UpperBlit
   490     (SDL_Surface * src, const SDL_Rect * srcrect,
   491      SDL_Surface * dst, SDL_Rect * dstrect);
   492 
   493 /**
   494  *  This is a semi-private blit function and it performs low-level surface
   495  *  blitting only.
   496  */
   497 extern DECLSPEC int SDLCALL SDL_LowerBlit
   498     (SDL_Surface * src, SDL_Rect * srcrect,
   499      SDL_Surface * dst, SDL_Rect * dstrect);
   500 
   501 /**
   502  *  \brief Perform a fast, low quality, stretch blit between two surfaces of the
   503  *         same pixel format.
   504  *
   505  *  \note This function uses a static buffer, and is not thread-safe.
   506  */
   507 extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src,
   508                                             const SDL_Rect * srcrect,
   509                                             SDL_Surface * dst,
   510                                             const SDL_Rect * dstrect);
   511 
   512 #define SDL_BlitScaled SDL_UpperBlitScaled
   513 
   514 /**
   515  *  This is the public scaled blit function, SDL_BlitScaled(), and it performs
   516  *  rectangle validation and clipping before passing it to SDL_LowerBlitScaled()
   517  */
   518 extern DECLSPEC int SDLCALL SDL_UpperBlitScaled
   519     (SDL_Surface * src, const SDL_Rect * srcrect,
   520     SDL_Surface * dst, SDL_Rect * dstrect);
   521 
   522 /**
   523  *  This is a semi-private blit function and it performs low-level surface
   524  *  scaled blitting only.
   525  */
   526 extern DECLSPEC int SDLCALL SDL_LowerBlitScaled
   527     (SDL_Surface * src, SDL_Rect * srcrect,
   528     SDL_Surface * dst, SDL_Rect * dstrect);
   529 
   530 /**
   531  *  \brief Set the YUV conversion mode
   532  */
   533 extern DECLSPEC void SDLCALL SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_MODE mode);
   534 
   535 /**
   536  *  \brief Get the YUV conversion mode
   537  */
   538 extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionMode(void);
   539 
   540 /**
   541  *  \brief Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
   542  */
   543 extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionModeForResolution(int width, int height);
   544 
   545 /* Ends C function definitions when using C++ */
   546 #ifdef __cplusplus
   547 }
   548 #endif
   549 #include "close_code.h"
   550 
   551 #endif /* SDL_surface_h_ */
   552 
   553 /* vi: set ts=4 sw=4 expandtab: */