src/video/SDL_bmp.c
author Sam Lantinga <slouken@libsdl.org>
Sat, 02 Jan 2016 10:10:34 -0800
changeset 9998 f67cf37e9cd4
parent 9619 b94b6d0bff0f
child 10404 a990b0da18cc
permissions -rw-r--r--
Updated copyright to 2016
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2016 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 #include "../SDL_internal.h"
    22 
    23 /*
    24    Code to load and save surfaces in Windows BMP format.
    25 
    26    Why support BMP format?  Well, it's a native format for Windows, and
    27    most image processing programs can read and write it.  It would be nice
    28    to be able to have at least one image format that we can natively load
    29    and save, and since PNG is so complex that it would bloat the library,
    30    BMP is a good alternative.
    31 
    32    This code currently supports Win32 DIBs in uncompressed 8 and 24 bpp.
    33 */
    34 
    35 #include "SDL_video.h"
    36 #include "SDL_assert.h"
    37 #include "SDL_endian.h"
    38 #include "SDL_pixels_c.h"
    39 
    40 #define SAVE_32BIT_BMP
    41 
    42 /* Compression encodings for BMP files */
    43 #ifndef BI_RGB
    44 #define BI_RGB      0
    45 #define BI_RLE8     1
    46 #define BI_RLE4     2
    47 #define BI_BITFIELDS    3
    48 #endif
    49 
    50 
    51 static void CorrectAlphaChannel(SDL_Surface *surface)
    52 {
    53     /* Check to see if there is any alpha channel data */
    54     SDL_bool hasAlpha = SDL_FALSE;
    55 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
    56     int alphaChannelOffset = 0;
    57 #else
    58     int alphaChannelOffset = 3;
    59 #endif
    60     Uint8 *alpha = ((Uint8*)surface->pixels) + alphaChannelOffset;
    61     Uint8 *end = alpha + surface->h * surface->pitch;
    62 
    63     while (alpha < end) {
    64         if (*alpha != 0) {
    65             hasAlpha = SDL_TRUE;
    66             break;
    67         }
    68         alpha += 4;
    69     }
    70 
    71     if (!hasAlpha) {
    72         alpha = ((Uint8*)surface->pixels) + alphaChannelOffset;
    73         while (alpha < end) {
    74             *alpha = SDL_ALPHA_OPAQUE;
    75             alpha += 4;
    76         }
    77     }
    78 }
    79 
    80 SDL_Surface *
    81 SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
    82 {
    83     SDL_bool was_error;
    84     Sint64 fp_offset = 0;
    85     int bmpPitch;
    86     int i, pad;
    87     SDL_Surface *surface;
    88     Uint32 Rmask = 0;
    89     Uint32 Gmask = 0;
    90     Uint32 Bmask = 0;
    91     Uint32 Amask = 0;
    92     SDL_Palette *palette;
    93     Uint8 *bits;
    94     Uint8 *top, *end;
    95     SDL_bool topDown;
    96     int ExpandBMP;
    97     SDL_bool haveRGBMasks = SDL_FALSE;
    98     SDL_bool haveAlphaMask = SDL_FALSE;
    99     SDL_bool correctAlpha = SDL_FALSE;
   100 
   101     /* The Win32 BMP file header (14 bytes) */
   102     char magic[2];
   103     /* Uint32 bfSize = 0; */
   104     /* Uint16 bfReserved1 = 0; */
   105     /* Uint16 bfReserved2 = 0; */
   106     Uint32 bfOffBits = 0;
   107 
   108     /* The Win32 BITMAPINFOHEADER struct (40 bytes) */
   109     Uint32 biSize = 0;
   110     Sint32 biWidth = 0;
   111     Sint32 biHeight = 0;
   112     /* Uint16 biPlanes = 0; */
   113     Uint16 biBitCount = 0;
   114     Uint32 biCompression = 0;
   115     /* Uint32 biSizeImage = 0; */
   116     /* Sint32 biXPelsPerMeter = 0; */
   117     /* Sint32 biYPelsPerMeter = 0; */
   118     Uint32 biClrUsed = 0;
   119     /* Uint32 biClrImportant = 0; */
   120 
   121     /* Make sure we are passed a valid data source */
   122     surface = NULL;
   123     was_error = SDL_FALSE;
   124     if (src == NULL) {
   125         was_error = SDL_TRUE;
   126         goto done;
   127     }
   128 
   129     /* Read in the BMP file header */
   130     fp_offset = SDL_RWtell(src);
   131     SDL_ClearError();
   132     if (SDL_RWread(src, magic, 1, 2) != 2) {
   133         SDL_Error(SDL_EFREAD);
   134         was_error = SDL_TRUE;
   135         goto done;
   136     }
   137     if (SDL_strncmp(magic, "BM", 2) != 0) {
   138         SDL_SetError("File is not a Windows BMP file");
   139         was_error = SDL_TRUE;
   140         goto done;
   141     }
   142     /* bfSize = */ SDL_ReadLE32(src);
   143     /* bfReserved1 = */ SDL_ReadLE16(src);
   144     /* bfReserved2 = */ SDL_ReadLE16(src);
   145     bfOffBits = SDL_ReadLE32(src);
   146 
   147     /* Read the Win32 BITMAPINFOHEADER */
   148     biSize = SDL_ReadLE32(src);
   149     if (biSize == 12) {   /* really old BITMAPCOREHEADER */
   150         biWidth = (Uint32) SDL_ReadLE16(src);
   151         biHeight = (Uint32) SDL_ReadLE16(src);
   152         /* biPlanes = */ SDL_ReadLE16(src);
   153         biBitCount = SDL_ReadLE16(src);
   154         biCompression = BI_RGB;
   155     } else if (biSize >= 40) {  /* some version of BITMAPINFOHEADER */
   156         Uint32 headerSize;
   157         biWidth = SDL_ReadLE32(src);
   158         biHeight = SDL_ReadLE32(src);
   159         /* biPlanes = */ SDL_ReadLE16(src);
   160         biBitCount = SDL_ReadLE16(src);
   161         biCompression = SDL_ReadLE32(src);
   162         /* biSizeImage = */ SDL_ReadLE32(src);
   163         /* biXPelsPerMeter = */ SDL_ReadLE32(src);
   164         /* biYPelsPerMeter = */ SDL_ReadLE32(src);
   165         biClrUsed = SDL_ReadLE32(src);
   166         /* biClrImportant = */ SDL_ReadLE32(src);
   167 
   168         /* 64 == BITMAPCOREHEADER2, an incompatible OS/2 2.x extension. Skip this stuff for now. */
   169         if (biSize == 64) {
   170             /* ignore these extra fields. */
   171             if (biCompression == BI_BITFIELDS) {
   172                 /* this value is actually huffman compression in this variant. */
   173                 SDL_SetError("Compressed BMP files not supported");
   174                 was_error = SDL_TRUE;
   175                 goto done;
   176             }
   177         } else {
   178             /* This is complicated. If compression is BI_BITFIELDS, then
   179                we have 3 DWORDS that specify the RGB masks. This is either
   180                stored here in an BITMAPV2INFOHEADER (which only differs in
   181                that it adds these RGB masks) and biSize >= 52, or we've got
   182                these masks stored in the exact same place, but strictly
   183                speaking, this is the bmiColors field in BITMAPINFO immediately
   184                following the legacy v1 info header, just past biSize. */
   185             if (biCompression == BI_BITFIELDS) {
   186                 haveRGBMasks = SDL_TRUE;
   187                 Rmask = SDL_ReadLE32(src);
   188                 Gmask = SDL_ReadLE32(src);
   189                 Bmask = SDL_ReadLE32(src);
   190 
   191                 /* ...v3 adds an alpha mask. */
   192                 if (biSize >= 56) {  /* BITMAPV3INFOHEADER; adds alpha mask */
   193                     haveAlphaMask = SDL_TRUE;
   194                     Amask = SDL_ReadLE32(src);
   195                 }
   196             } else {
   197                 /* the mask fields are ignored for v2+ headers if not BI_BITFIELD. */
   198                 if (biSize >= 52) {  /* BITMAPV2INFOHEADER; adds RGB masks */
   199                     /*Rmask = */ SDL_ReadLE32(src);
   200                     /*Gmask = */ SDL_ReadLE32(src);
   201                     /*Bmask = */ SDL_ReadLE32(src);
   202                 }
   203                 if (biSize >= 56) {  /* BITMAPV3INFOHEADER; adds alpha mask */
   204                     /*Amask = */ SDL_ReadLE32(src);
   205                 }
   206             }
   207 
   208             /* Insert other fields here; Wikipedia and MSDN say we're up to
   209                v5 of this header, but we ignore those for now (they add gamma,
   210                color spaces, etc). Ignoring the weird OS/2 2.x format, we
   211                currently parse up to v3 correctly (hopefully!). */
   212         }
   213 
   214         /* skip any header bytes we didn't handle... */
   215         headerSize = (Uint32) (SDL_RWtell(src) - (fp_offset + 14));
   216         if (biSize > headerSize) {
   217             SDL_RWseek(src, (biSize - headerSize), RW_SEEK_CUR);
   218         }
   219     }
   220     if (biHeight < 0) {
   221         topDown = SDL_TRUE;
   222         biHeight = -biHeight;
   223     } else {
   224         topDown = SDL_FALSE;
   225     }
   226 
   227     /* Check for read error */
   228     if (SDL_strcmp(SDL_GetError(), "") != 0) {
   229         was_error = SDL_TRUE;
   230         goto done;
   231     }
   232 
   233     /* Expand 1 and 4 bit bitmaps to 8 bits per pixel */
   234     switch (biBitCount) {
   235     case 1:
   236     case 4:
   237         ExpandBMP = biBitCount;
   238         biBitCount = 8;
   239         break;
   240     default:
   241         ExpandBMP = 0;
   242         break;
   243     }
   244 
   245     /* We don't support any BMP compression right now */
   246     switch (biCompression) {
   247     case BI_RGB:
   248         /* If there are no masks, use the defaults */
   249         SDL_assert(!haveRGBMasks);
   250         SDL_assert(!haveAlphaMask);
   251         /* Default values for the BMP format */
   252         switch (biBitCount) {
   253         case 15:
   254         case 16:
   255             Rmask = 0x7C00;
   256             Gmask = 0x03E0;
   257             Bmask = 0x001F;
   258             break;
   259         case 24:
   260 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
   261             Rmask = 0x000000FF;
   262             Gmask = 0x0000FF00;
   263             Bmask = 0x00FF0000;
   264 #else
   265             Rmask = 0x00FF0000;
   266             Gmask = 0x0000FF00;
   267             Bmask = 0x000000FF;
   268 #endif
   269             break;
   270         case 32:
   271             /* We don't know if this has alpha channel or not */
   272             correctAlpha = SDL_TRUE;
   273             Amask = 0xFF000000;
   274             Rmask = 0x00FF0000;
   275             Gmask = 0x0000FF00;
   276             Bmask = 0x000000FF;
   277             break;
   278         default:
   279             break;
   280         }
   281         break;
   282 
   283     case BI_BITFIELDS:
   284         break;  /* we handled this in the info header. */
   285 
   286     default:
   287         SDL_SetError("Compressed BMP files not supported");
   288         was_error = SDL_TRUE;
   289         goto done;
   290     }
   291 
   292     /* Create a compatible surface, note that the colors are RGB ordered */
   293     surface =
   294         SDL_CreateRGBSurface(0, biWidth, biHeight, biBitCount, Rmask, Gmask,
   295                              Bmask, Amask);
   296     if (surface == NULL) {
   297         was_error = SDL_TRUE;
   298         goto done;
   299     }
   300 
   301     /* Load the palette, if any */
   302     palette = (surface->format)->palette;
   303     if (palette) {
   304         SDL_assert(biBitCount <= 8);
   305         if (biClrUsed == 0) {
   306             biClrUsed = 1 << biBitCount;
   307         }
   308         if ((int) biClrUsed > palette->ncolors) {
   309             SDL_Color *colors;
   310             int ncolors = biClrUsed;
   311             colors =
   312                 (SDL_Color *) SDL_realloc(palette->colors,
   313                                           ncolors *
   314                                           sizeof(*palette->colors));
   315             if (!colors) {
   316                 SDL_OutOfMemory();
   317                 was_error = SDL_TRUE;
   318                 goto done;
   319             }
   320             palette->ncolors = ncolors;
   321             palette->colors = colors;
   322         } else if ((int) biClrUsed < palette->ncolors) {
   323             palette->ncolors = biClrUsed;
   324         }
   325         if (biSize == 12) {
   326             for (i = 0; i < (int) biClrUsed; ++i) {
   327                 SDL_RWread(src, &palette->colors[i].b, 1, 1);
   328                 SDL_RWread(src, &palette->colors[i].g, 1, 1);
   329                 SDL_RWread(src, &palette->colors[i].r, 1, 1);
   330                 palette->colors[i].a = SDL_ALPHA_OPAQUE;
   331             }
   332         } else {
   333             for (i = 0; i < (int) biClrUsed; ++i) {
   334                 SDL_RWread(src, &palette->colors[i].b, 1, 1);
   335                 SDL_RWread(src, &palette->colors[i].g, 1, 1);
   336                 SDL_RWread(src, &palette->colors[i].r, 1, 1);
   337                 SDL_RWread(src, &palette->colors[i].a, 1, 1);
   338 
   339                 /* According to Microsoft documentation, the fourth element
   340                    is reserved and must be zero, so we shouldn't treat it as
   341                    alpha.
   342                 */
   343                 palette->colors[i].a = SDL_ALPHA_OPAQUE;
   344             }
   345         }
   346     }
   347 
   348     /* Read the surface pixels.  Note that the bmp image is upside down */
   349     if (SDL_RWseek(src, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
   350         SDL_Error(SDL_EFSEEK);
   351         was_error = SDL_TRUE;
   352         goto done;
   353     }
   354     top = (Uint8 *)surface->pixels;
   355     end = (Uint8 *)surface->pixels+(surface->h*surface->pitch);
   356     switch (ExpandBMP) {
   357     case 1:
   358         bmpPitch = (biWidth + 7) >> 3;
   359         pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
   360         break;
   361     case 4:
   362         bmpPitch = (biWidth + 1) >> 1;
   363         pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
   364         break;
   365     default:
   366         pad = ((surface->pitch % 4) ? (4 - (surface->pitch % 4)) : 0);
   367         break;
   368     }
   369     if (topDown) {
   370         bits = top;
   371     } else {
   372         bits = end - surface->pitch;
   373     }
   374     while (bits >= top && bits < end) {
   375         switch (ExpandBMP) {
   376         case 1:
   377         case 4:{
   378                 Uint8 pixel = 0;
   379                 int shift = (8 - ExpandBMP);
   380                 for (i = 0; i < surface->w; ++i) {
   381                     if (i % (8 / ExpandBMP) == 0) {
   382                         if (!SDL_RWread(src, &pixel, 1, 1)) {
   383                             SDL_SetError("Error reading from BMP");
   384                             was_error = SDL_TRUE;
   385                             goto done;
   386                         }
   387                     }
   388                     *(bits + i) = (pixel >> shift);
   389                     pixel <<= ExpandBMP;
   390                 }
   391             }
   392             break;
   393 
   394         default:
   395             if (SDL_RWread(src, bits, 1, surface->pitch)
   396                 != surface->pitch) {
   397                 SDL_Error(SDL_EFREAD);
   398                 was_error = SDL_TRUE;
   399                 goto done;
   400             }
   401 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
   402             /* Byte-swap the pixels if needed. Note that the 24bpp
   403                case has already been taken care of above. */
   404             switch (biBitCount) {
   405             case 15:
   406             case 16:{
   407                     Uint16 *pix = (Uint16 *) bits;
   408                     for (i = 0; i < surface->w; i++)
   409                         pix[i] = SDL_Swap16(pix[i]);
   410                     break;
   411                 }
   412 
   413             case 32:{
   414                     Uint32 *pix = (Uint32 *) bits;
   415                     for (i = 0; i < surface->w; i++)
   416                         pix[i] = SDL_Swap32(pix[i]);
   417                     break;
   418                 }
   419             }
   420 #endif
   421             break;
   422         }
   423         /* Skip padding bytes, ugh */
   424         if (pad) {
   425             Uint8 padbyte;
   426             for (i = 0; i < pad; ++i) {
   427                 SDL_RWread(src, &padbyte, 1, 1);
   428             }
   429         }
   430         if (topDown) {
   431             bits += surface->pitch;
   432         } else {
   433             bits -= surface->pitch;
   434         }
   435     }
   436     if (correctAlpha) {
   437         CorrectAlphaChannel(surface);
   438     }
   439   done:
   440     if (was_error) {
   441         if (src) {
   442             SDL_RWseek(src, fp_offset, RW_SEEK_SET);
   443         }
   444         SDL_FreeSurface(surface);
   445         surface = NULL;
   446     }
   447     if (freesrc && src) {
   448         SDL_RWclose(src);
   449     }
   450     return (surface);
   451 }
   452 
   453 int
   454 SDL_SaveBMP_RW(SDL_Surface * saveme, SDL_RWops * dst, int freedst)
   455 {
   456     Sint64 fp_offset;
   457     int i, pad;
   458     SDL_Surface *surface;
   459     Uint8 *bits;
   460 
   461     /* The Win32 BMP file header (14 bytes) */
   462     char magic[2] = { 'B', 'M' };
   463     Uint32 bfSize;
   464     Uint16 bfReserved1;
   465     Uint16 bfReserved2;
   466     Uint32 bfOffBits;
   467 
   468     /* The Win32 BITMAPINFOHEADER struct (40 bytes) */
   469     Uint32 biSize;
   470     Sint32 biWidth;
   471     Sint32 biHeight;
   472     Uint16 biPlanes;
   473     Uint16 biBitCount;
   474     Uint32 biCompression;
   475     Uint32 biSizeImage;
   476     Sint32 biXPelsPerMeter;
   477     Sint32 biYPelsPerMeter;
   478     Uint32 biClrUsed;
   479     Uint32 biClrImportant;
   480 
   481     /* Make sure we have somewhere to save */
   482     surface = NULL;
   483     if (dst) {
   484         SDL_bool save32bit = SDL_FALSE;
   485 #ifdef SAVE_32BIT_BMP
   486         /* We can save alpha information in a 32-bit BMP */
   487         if (saveme->map->info.flags & SDL_COPY_COLORKEY ||
   488             saveme->format->Amask) {
   489             save32bit = SDL_TRUE;
   490         }
   491 #endif /* SAVE_32BIT_BMP */
   492 
   493         if (saveme->format->palette && !save32bit) {
   494             if (saveme->format->BitsPerPixel == 8) {
   495                 surface = saveme;
   496             } else {
   497                 SDL_SetError("%d bpp BMP files not supported",
   498                              saveme->format->BitsPerPixel);
   499             }
   500         } else if ((saveme->format->BitsPerPixel == 24) &&
   501 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
   502                    (saveme->format->Rmask == 0x00FF0000) &&
   503                    (saveme->format->Gmask == 0x0000FF00) &&
   504                    (saveme->format->Bmask == 0x000000FF)
   505 #else
   506                    (saveme->format->Rmask == 0x000000FF) &&
   507                    (saveme->format->Gmask == 0x0000FF00) &&
   508                    (saveme->format->Bmask == 0x00FF0000)
   509 #endif
   510             ) {
   511             surface = saveme;
   512         } else {
   513             SDL_PixelFormat format;
   514 
   515             /* If the surface has a colorkey or alpha channel we'll save a
   516                32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */
   517             if (save32bit) {
   518                 SDL_InitFormat(&format,
   519 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
   520                                SDL_PIXELFORMAT_ARGB8888
   521 #else
   522                                SDL_PIXELFORMAT_BGRA8888
   523 #endif
   524                                );
   525             } else {
   526                 SDL_InitFormat(&format, SDL_PIXELFORMAT_BGR24);
   527             }
   528             surface = SDL_ConvertSurface(saveme, &format, 0);
   529             if (!surface) {
   530                 SDL_SetError("Couldn't convert image to %d bpp",
   531                              format.BitsPerPixel);
   532             }
   533         }
   534     } else {
   535         /* Set no error here because it may overwrite a more useful message from
   536            SDL_RWFromFile() if SDL_SaveBMP_RW() is called from SDL_SaveBMP(). */
   537         return -1;
   538     }
   539 
   540     if (surface && (SDL_LockSurface(surface) == 0)) {
   541         const int bw = surface->w * surface->format->BytesPerPixel;
   542 
   543         /* Set the BMP file header values */
   544         bfSize = 0;             /* We'll write this when we're done */
   545         bfReserved1 = 0;
   546         bfReserved2 = 0;
   547         bfOffBits = 0;          /* We'll write this when we're done */
   548 
   549         /* Write the BMP file header values */
   550         fp_offset = SDL_RWtell(dst);
   551         SDL_ClearError();
   552         SDL_RWwrite(dst, magic, 2, 1);
   553         SDL_WriteLE32(dst, bfSize);
   554         SDL_WriteLE16(dst, bfReserved1);
   555         SDL_WriteLE16(dst, bfReserved2);
   556         SDL_WriteLE32(dst, bfOffBits);
   557 
   558         /* Set the BMP info values */
   559         biSize = 40;
   560         biWidth = surface->w;
   561         biHeight = surface->h;
   562         biPlanes = 1;
   563         biBitCount = surface->format->BitsPerPixel;
   564         biCompression = BI_RGB;
   565         biSizeImage = surface->h * surface->pitch;
   566         biXPelsPerMeter = 0;
   567         biYPelsPerMeter = 0;
   568         if (surface->format->palette) {
   569             biClrUsed = surface->format->palette->ncolors;
   570         } else {
   571             biClrUsed = 0;
   572         }
   573         biClrImportant = 0;
   574 
   575         /* Write the BMP info values */
   576         SDL_WriteLE32(dst, biSize);
   577         SDL_WriteLE32(dst, biWidth);
   578         SDL_WriteLE32(dst, biHeight);
   579         SDL_WriteLE16(dst, biPlanes);
   580         SDL_WriteLE16(dst, biBitCount);
   581         SDL_WriteLE32(dst, biCompression);
   582         SDL_WriteLE32(dst, biSizeImage);
   583         SDL_WriteLE32(dst, biXPelsPerMeter);
   584         SDL_WriteLE32(dst, biYPelsPerMeter);
   585         SDL_WriteLE32(dst, biClrUsed);
   586         SDL_WriteLE32(dst, biClrImportant);
   587 
   588         /* Write the palette (in BGR color order) */
   589         if (surface->format->palette) {
   590             SDL_Color *colors;
   591             int ncolors;
   592 
   593             colors = surface->format->palette->colors;
   594             ncolors = surface->format->palette->ncolors;
   595             for (i = 0; i < ncolors; ++i) {
   596                 SDL_RWwrite(dst, &colors[i].b, 1, 1);
   597                 SDL_RWwrite(dst, &colors[i].g, 1, 1);
   598                 SDL_RWwrite(dst, &colors[i].r, 1, 1);
   599                 SDL_RWwrite(dst, &colors[i].a, 1, 1);
   600             }
   601         }
   602 
   603         /* Write the bitmap offset */
   604         bfOffBits = (Uint32)(SDL_RWtell(dst) - fp_offset);
   605         if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) {
   606             SDL_Error(SDL_EFSEEK);
   607         }
   608         SDL_WriteLE32(dst, bfOffBits);
   609         if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
   610             SDL_Error(SDL_EFSEEK);
   611         }
   612 
   613         /* Write the bitmap image upside down */
   614         bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
   615         pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
   616         while (bits > (Uint8 *) surface->pixels) {
   617             bits -= surface->pitch;
   618             if (SDL_RWwrite(dst, bits, 1, bw) != bw) {
   619                 SDL_Error(SDL_EFWRITE);
   620                 break;
   621             }
   622             if (pad) {
   623                 const Uint8 padbyte = 0;
   624                 for (i = 0; i < pad; ++i) {
   625                     SDL_RWwrite(dst, &padbyte, 1, 1);
   626                 }
   627             }
   628         }
   629 
   630         /* Write the BMP file size */
   631         bfSize = (Uint32)(SDL_RWtell(dst) - fp_offset);
   632         if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) {
   633             SDL_Error(SDL_EFSEEK);
   634         }
   635         SDL_WriteLE32(dst, bfSize);
   636         if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) {
   637             SDL_Error(SDL_EFSEEK);
   638         }
   639 
   640         /* Close it up.. */
   641         SDL_UnlockSurface(surface);
   642         if (surface != saveme) {
   643             SDL_FreeSurface(surface);
   644         }
   645     }
   646 
   647     if (freedst && dst) {
   648         SDL_RWclose(dst);
   649     }
   650     return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
   651 }
   652 
   653 /* vi: set ts=4 sw=4 expandtab: */