include/SDL_surface.h
author Ryan C. Gordon <icculus@icculus.org>
Mon, 08 Sep 2014 01:36:22 -0400
changeset 9126 08f3b56969b1
parent 8149 681eb46b8ac4
child 9619 b94b6d0bff0f
permissions -rw-r--r--
Deal with various .bmp file format variants in SDL_LoadBMP_RW().

This helps when modern versions of The Gimp (and lots of other things)
produces a 32-bit bitmap with an alpha channel, or anything with "BI_BITFIELDS"
format, since that data is now embedded in the bitmap info header instead of
directly following it and we would accidentally skip over embedded versions of
it.

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