src/video/SDL_bmp.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 04 Jan 2009 17:14:27 +0000
changeset 2990 502adab079a4
parent 2969 1ee69e7e7cea
child 3024 1a08749aebce
permissions -rw-r--r--
indent
slouken@0
     1
/*
slouken@0
     2
    SDL - Simple DirectMedia Layer
slouken@2859
     3
    Copyright (C) 1997-2009 Sam Lantinga
slouken@0
     4
slouken@0
     5
    This library is free software; you can redistribute it and/or
slouken@1312
     6
    modify it under the terms of the GNU Lesser General Public
slouken@0
     7
    License as published by the Free Software Foundation; either
slouken@1312
     8
    version 2.1 of the License, or (at your option) any later version.
slouken@0
     9
slouken@0
    10
    This library is distributed in the hope that it will be useful,
slouken@0
    11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
slouken@0
    12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
slouken@1312
    13
    Lesser General Public License for more details.
slouken@0
    14
slouken@1312
    15
    You should have received a copy of the GNU Lesser General Public
slouken@1312
    16
    License along with this library; if not, write to the Free Software
slouken@1312
    17
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
slouken@0
    18
slouken@0
    19
    Sam Lantinga
slouken@252
    20
    slouken@libsdl.org
slouken@0
    21
*/
slouken@1402
    22
#include "SDL_config.h"
slouken@0
    23
slouken@0
    24
/* 
slouken@0
    25
   Code to load and save surfaces in Windows BMP format.
slouken@0
    26
slouken@0
    27
   Why support BMP format?  Well, it's a native format for Windows, and
slouken@0
    28
   most image processing programs can read and write it.  It would be nice
slouken@0
    29
   to be able to have at least one image format that we can natively load
slouken@0
    30
   and save, and since PNG is so complex that it would bloat the library,
slouken@0
    31
   BMP is a good alternative. 
slouken@0
    32
slouken@0
    33
   This code currently supports Win32 DIBs in uncompressed 8 and 24 bpp.
slouken@0
    34
*/
slouken@0
    35
slouken@0
    36
#include "SDL_video.h"
slouken@0
    37
#include "SDL_endian.h"
slouken@2823
    38
#include "SDL_pixels_c.h"
slouken@0
    39
slouken@0
    40
/* Compression encodings for BMP files */
slouken@0
    41
#ifndef BI_RGB
slouken@0
    42
#define BI_RGB		0
slouken@0
    43
#define BI_RLE8		1
slouken@0
    44
#define BI_RLE4		2
slouken@0
    45
#define BI_BITFIELDS	3
slouken@0
    46
#endif
slouken@0
    47
slouken@0
    48
slouken@1895
    49
SDL_Surface *
slouken@1895
    50
SDL_LoadBMP_RW(SDL_RWops * src, int freesrc)
slouken@0
    51
{
slouken@1895
    52
    int was_error;
slouken@1895
    53
    long fp_offset;
slouken@1895
    54
    int bmpPitch;
slouken@1895
    55
    int i, pad;
slouken@1895
    56
    SDL_Surface *surface;
slouken@1895
    57
    Uint32 Rmask;
slouken@1895
    58
    Uint32 Gmask;
slouken@1895
    59
    Uint32 Bmask;
slouken@1895
    60
    SDL_Palette *palette;
slouken@1895
    61
    Uint8 *bits;
slouken@1895
    62
    int ExpandBMP;
slouken@0
    63
slouken@1895
    64
    /* The Win32 BMP file header (14 bytes) */
slouken@1895
    65
    char magic[2];
slouken@1895
    66
    Uint32 bfSize;
slouken@1895
    67
    Uint16 bfReserved1;
slouken@1895
    68
    Uint16 bfReserved2;
slouken@1895
    69
    Uint32 bfOffBits;
slouken@0
    70
slouken@1895
    71
    /* The Win32 BITMAPINFOHEADER struct (40 bytes) */
slouken@1895
    72
    Uint32 biSize;
slouken@1895
    73
    Sint32 biWidth;
slouken@1895
    74
    Sint32 biHeight;
slouken@1895
    75
    Uint16 biPlanes;
slouken@1895
    76
    Uint16 biBitCount;
slouken@1895
    77
    Uint32 biCompression;
slouken@1895
    78
    Uint32 biSizeImage;
slouken@1895
    79
    Sint32 biXPelsPerMeter;
slouken@1895
    80
    Sint32 biYPelsPerMeter;
slouken@1895
    81
    Uint32 biClrUsed;
slouken@1895
    82
    Uint32 biClrImportant;
slouken@0
    83
slouken@1895
    84
    /* Make sure we are passed a valid data source */
slouken@1895
    85
    surface = NULL;
slouken@1895
    86
    was_error = 0;
slouken@1895
    87
    if (src == NULL) {
slouken@1895
    88
        was_error = 1;
slouken@1895
    89
        goto done;
slouken@1895
    90
    }
slouken@0
    91
slouken@1895
    92
    /* Read in the BMP file header */
slouken@1895
    93
    fp_offset = SDL_RWtell(src);
slouken@1895
    94
    SDL_ClearError();
slouken@1895
    95
    if (SDL_RWread(src, magic, 1, 2) != 2) {
slouken@1895
    96
        SDL_Error(SDL_EFREAD);
slouken@1895
    97
        was_error = 1;
slouken@1895
    98
        goto done;
slouken@1895
    99
    }
slouken@1895
   100
    if (SDL_strncmp(magic, "BM", 2) != 0) {
slouken@1895
   101
        SDL_SetError("File is not a Windows BMP file");
slouken@1895
   102
        was_error = 1;
slouken@1895
   103
        goto done;
slouken@1895
   104
    }
slouken@1895
   105
    bfSize = SDL_ReadLE32(src);
slouken@1895
   106
    bfReserved1 = SDL_ReadLE16(src);
slouken@1895
   107
    bfReserved2 = SDL_ReadLE16(src);
slouken@1895
   108
    bfOffBits = SDL_ReadLE32(src);
slouken@0
   109
slouken@1895
   110
    /* Read the Win32 BITMAPINFOHEADER */
slouken@1895
   111
    biSize = SDL_ReadLE32(src);
slouken@1895
   112
    if (biSize == 12) {
slouken@1895
   113
        biWidth = (Uint32) SDL_ReadLE16(src);
slouken@1895
   114
        biHeight = (Uint32) SDL_ReadLE16(src);
slouken@1895
   115
        biPlanes = SDL_ReadLE16(src);
slouken@1895
   116
        biBitCount = SDL_ReadLE16(src);
slouken@1895
   117
        biCompression = BI_RGB;
slouken@1895
   118
        biSizeImage = 0;
slouken@1895
   119
        biXPelsPerMeter = 0;
slouken@1895
   120
        biYPelsPerMeter = 0;
slouken@1895
   121
        biClrUsed = 0;
slouken@1895
   122
        biClrImportant = 0;
slouken@1895
   123
    } else {
slouken@1895
   124
        biWidth = SDL_ReadLE32(src);
slouken@1895
   125
        biHeight = SDL_ReadLE32(src);
slouken@1895
   126
        biPlanes = SDL_ReadLE16(src);
slouken@1895
   127
        biBitCount = SDL_ReadLE16(src);
slouken@1895
   128
        biCompression = SDL_ReadLE32(src);
slouken@1895
   129
        biSizeImage = SDL_ReadLE32(src);
slouken@1895
   130
        biXPelsPerMeter = SDL_ReadLE32(src);
slouken@1895
   131
        biYPelsPerMeter = SDL_ReadLE32(src);
slouken@1895
   132
        biClrUsed = SDL_ReadLE32(src);
slouken@1895
   133
        biClrImportant = SDL_ReadLE32(src);
slouken@1895
   134
    }
slouken@0
   135
slouken@1895
   136
    /* Check for read error */
slouken@1895
   137
    if (SDL_strcmp(SDL_GetError(), "") != 0) {
slouken@1895
   138
        was_error = 1;
slouken@1895
   139
        goto done;
slouken@1895
   140
    }
slouken@0
   141
slouken@1895
   142
    /* Expand 1 and 4 bit bitmaps to 8 bits per pixel */
slouken@1895
   143
    switch (biBitCount) {
slouken@1895
   144
    case 1:
slouken@1895
   145
    case 4:
slouken@1895
   146
        ExpandBMP = biBitCount;
slouken@1895
   147
        biBitCount = 8;
slouken@1895
   148
        break;
slouken@1895
   149
    default:
slouken@1895
   150
        ExpandBMP = 0;
slouken@1895
   151
        break;
slouken@1895
   152
    }
slouken@0
   153
slouken@1895
   154
    /* We don't support any BMP compression right now */
slouken@1895
   155
    Rmask = Gmask = Bmask = 0;
slouken@1895
   156
    switch (biCompression) {
slouken@1895
   157
    case BI_RGB:
slouken@1895
   158
        /* If there are no masks, use the defaults */
slouken@1895
   159
        if (bfOffBits == (14 + biSize)) {
slouken@1895
   160
            /* Default values for the BMP format */
slouken@1895
   161
            switch (biBitCount) {
slouken@1895
   162
            case 15:
slouken@1895
   163
            case 16:
slouken@1895
   164
                Rmask = 0x7C00;
slouken@1895
   165
                Gmask = 0x03E0;
slouken@1895
   166
                Bmask = 0x001F;
slouken@1895
   167
                break;
slouken@1895
   168
            case 24:
slouken@0
   169
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
slouken@1895
   170
                Rmask = 0x000000FF;
slouken@1895
   171
                Gmask = 0x0000FF00;
slouken@1895
   172
                Bmask = 0x00FF0000;
slouken@1895
   173
                break;
slouken@0
   174
#endif
slouken@1895
   175
            case 32:
slouken@1895
   176
                Rmask = 0x00FF0000;
slouken@1895
   177
                Gmask = 0x0000FF00;
slouken@1895
   178
                Bmask = 0x000000FF;
slouken@1895
   179
                break;
slouken@1895
   180
            default:
slouken@1895
   181
                break;
slouken@1895
   182
            }
slouken@1895
   183
            break;
slouken@1895
   184
        }
slouken@1895
   185
        /* Fall through -- read the RGB masks */
slouken@0
   186
slouken@1895
   187
    case BI_BITFIELDS:
slouken@1895
   188
        switch (biBitCount) {
slouken@1895
   189
        case 15:
slouken@1895
   190
        case 16:
slouken@1895
   191
        case 32:
slouken@1895
   192
            Rmask = SDL_ReadLE32(src);
slouken@1895
   193
            Gmask = SDL_ReadLE32(src);
slouken@1895
   194
            Bmask = SDL_ReadLE32(src);
slouken@1895
   195
            break;
slouken@1895
   196
        default:
slouken@1895
   197
            break;
slouken@1895
   198
        }
slouken@1895
   199
        break;
slouken@1895
   200
    default:
slouken@1895
   201
        SDL_SetError("Compressed BMP files not supported");
slouken@1895
   202
        was_error = 1;
slouken@1895
   203
        goto done;
slouken@1895
   204
    }
slouken@0
   205
slouken@1895
   206
    /* Create a compatible surface, note that the colors are RGB ordered */
slouken@1895
   207
    surface =
slouken@1895
   208
        SDL_CreateRGBSurface(0, biWidth, biHeight, biBitCount, Rmask, Gmask,
slouken@1895
   209
                             Bmask, 0);
slouken@1895
   210
    if (surface == NULL) {
slouken@1895
   211
        was_error = 1;
slouken@1895
   212
        goto done;
slouken@1895
   213
    }
slouken@0
   214
slouken@1895
   215
    /* Load the palette, if any */
slouken@1895
   216
    palette = (surface->format)->palette;
slouken@1895
   217
    if (palette) {
slouken@1895
   218
        if (biClrUsed == 0) {
slouken@1895
   219
            biClrUsed = 1 << biBitCount;
slouken@1895
   220
        }
slouken@2920
   221
        if ((int) biClrUsed > palette->ncolors) {
slouken@2851
   222
            palette->ncolors = biClrUsed;
slouken@2851
   223
            palette->colors =
slouken@2851
   224
                (SDL_Color *) SDL_realloc(palette->colors,
slouken@2851
   225
                                          palette->ncolors *
slouken@2851
   226
                                          sizeof(*palette->colors));
slouken@2851
   227
            if (!palette->colors) {
slouken@2851
   228
                SDL_OutOfMemory();
slouken@2851
   229
                was_error = 1;
slouken@2851
   230
                goto done;
slouken@2851
   231
            }
slouken@2920
   232
        } else if ((int) biClrUsed < palette->ncolors) {
slouken@2851
   233
            palette->ncolors = biClrUsed;
slouken@2851
   234
        }
slouken@1895
   235
        if (biSize == 12) {
slouken@1895
   236
            for (i = 0; i < (int) biClrUsed; ++i) {
slouken@1895
   237
                SDL_RWread(src, &palette->colors[i].b, 1, 1);
slouken@1895
   238
                SDL_RWread(src, &palette->colors[i].g, 1, 1);
slouken@1895
   239
                SDL_RWread(src, &palette->colors[i].r, 1, 1);
slouken@1895
   240
                palette->colors[i].unused = SDL_ALPHA_OPAQUE;
slouken@1895
   241
            }
slouken@1895
   242
        } else {
slouken@1895
   243
            for (i = 0; i < (int) biClrUsed; ++i) {
slouken@1895
   244
                SDL_RWread(src, &palette->colors[i].b, 1, 1);
slouken@1895
   245
                SDL_RWread(src, &palette->colors[i].g, 1, 1);
slouken@1895
   246
                SDL_RWread(src, &palette->colors[i].r, 1, 1);
slouken@1895
   247
                SDL_RWread(src, &palette->colors[i].unused, 1, 1);
slouken@1895
   248
            }
slouken@1895
   249
        }
slouken@1895
   250
    }
slouken@0
   251
slouken@1895
   252
    /* Read the surface pixels.  Note that the bmp image is upside down */
slouken@1895
   253
    if (SDL_RWseek(src, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
slouken@1895
   254
        SDL_Error(SDL_EFSEEK);
slouken@1895
   255
        was_error = 1;
slouken@1895
   256
        goto done;
slouken@1895
   257
    }
slouken@1895
   258
    bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
slouken@1895
   259
    switch (ExpandBMP) {
slouken@1895
   260
    case 1:
slouken@1895
   261
        bmpPitch = (biWidth + 7) >> 3;
slouken@1895
   262
        pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
slouken@1895
   263
        break;
slouken@1895
   264
    case 4:
slouken@1895
   265
        bmpPitch = (biWidth + 1) >> 1;
slouken@1895
   266
        pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
slouken@1895
   267
        break;
slouken@1895
   268
    default:
slouken@1895
   269
        pad = ((surface->pitch % 4) ? (4 - (surface->pitch % 4)) : 0);
slouken@1895
   270
        break;
slouken@1895
   271
    }
slouken@1895
   272
    while (bits > (Uint8 *) surface->pixels) {
slouken@1895
   273
        bits -= surface->pitch;
slouken@1895
   274
        switch (ExpandBMP) {
slouken@1895
   275
        case 1:
slouken@1895
   276
        case 4:
slouken@1895
   277
            {
slouken@1895
   278
                Uint8 pixel = 0;
slouken@1895
   279
                int shift = (8 - ExpandBMP);
slouken@1895
   280
                for (i = 0; i < surface->w; ++i) {
slouken@1895
   281
                    if (i % (8 / ExpandBMP) == 0) {
slouken@1895
   282
                        if (!SDL_RWread(src, &pixel, 1, 1)) {
slouken@1895
   283
                            SDL_SetError("Error reading from BMP");
slouken@1895
   284
                            was_error = 1;
slouken@1895
   285
                            goto done;
slouken@1895
   286
                        }
slouken@1895
   287
                    }
slouken@1895
   288
                    *(bits + i) = (pixel >> shift);
slouken@1895
   289
                    pixel <<= ExpandBMP;
slouken@1895
   290
                }
slouken@1895
   291
            }
slouken@1895
   292
            break;
slouken@0
   293
slouken@1895
   294
        default:
slouken@1895
   295
            if (SDL_RWread(src, bits, 1, surface->pitch)
slouken@1895
   296
                != surface->pitch) {
slouken@1895
   297
                SDL_Error(SDL_EFREAD);
slouken@1895
   298
                was_error = 1;
slouken@1895
   299
                goto done;
slouken@1895
   300
            }
slouken@0
   301
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
slouken@1895
   302
            /* Byte-swap the pixels if needed. Note that the 24bpp
slouken@1895
   303
               case has already been taken care of above. */
slouken@1895
   304
            switch (biBitCount) {
slouken@1895
   305
            case 15:
slouken@1895
   306
            case 16:
slouken@1895
   307
                {
slouken@1895
   308
                    Uint16 *pix = (Uint16 *) bits;
slouken@1895
   309
                    for (i = 0; i < surface->w; i++)
slouken@1895
   310
                        pix[i] = SDL_Swap16(pix[i]);
slouken@1895
   311
                    break;
slouken@1895
   312
                }
slouken@0
   313
slouken@1895
   314
            case 32:
slouken@1895
   315
                {
slouken@1895
   316
                    Uint32 *pix = (Uint32 *) bits;
slouken@1895
   317
                    for (i = 0; i < surface->w; i++)
slouken@1895
   318
                        pix[i] = SDL_Swap32(pix[i]);
slouken@1895
   319
                    break;
slouken@1895
   320
                }
slouken@1895
   321
            }
slouken@0
   322
#endif
slouken@1895
   323
            break;
slouken@1895
   324
        }
slouken@1895
   325
        /* Skip padding bytes, ugh */
slouken@1895
   326
        if (pad) {
slouken@1895
   327
            Uint8 padbyte;
slouken@1895
   328
            for (i = 0; i < pad; ++i) {
slouken@1895
   329
                SDL_RWread(src, &padbyte, 1, 1);
slouken@1895
   330
            }
slouken@1895
   331
        }
slouken@1895
   332
    }
slouken@1895
   333
  done:
slouken@1895
   334
    if (was_error) {
slouken@1895
   335
        if (src) {
slouken@1895
   336
            SDL_RWseek(src, fp_offset, RW_SEEK_SET);
slouken@1895
   337
        }
slouken@1895
   338
        if (surface) {
slouken@1895
   339
            SDL_FreeSurface(surface);
slouken@1895
   340
        }
slouken@1895
   341
        surface = NULL;
slouken@1895
   342
    }
slouken@1895
   343
    if (freesrc && src) {
slouken@1895
   344
        SDL_RWclose(src);
slouken@1895
   345
    }
slouken@1895
   346
    return (surface);
slouken@0
   347
}
slouken@0
   348
slouken@1895
   349
int
slouken@1895
   350
SDL_SaveBMP_RW(SDL_Surface * saveme, SDL_RWops * dst, int freedst)
slouken@0
   351
{
slouken@1895
   352
    long fp_offset;
slouken@1895
   353
    int i, pad;
slouken@1895
   354
    SDL_Surface *surface;
slouken@1895
   355
    Uint8 *bits;
slouken@0
   356
slouken@1895
   357
    /* The Win32 BMP file header (14 bytes) */
slouken@1895
   358
    char magic[2] = { 'B', 'M' };
slouken@1895
   359
    Uint32 bfSize;
slouken@1895
   360
    Uint16 bfReserved1;
slouken@1895
   361
    Uint16 bfReserved2;
slouken@1895
   362
    Uint32 bfOffBits;
slouken@0
   363
slouken@1895
   364
    /* The Win32 BITMAPINFOHEADER struct (40 bytes) */
slouken@1895
   365
    Uint32 biSize;
slouken@1895
   366
    Sint32 biWidth;
slouken@1895
   367
    Sint32 biHeight;
slouken@1895
   368
    Uint16 biPlanes;
slouken@1895
   369
    Uint16 biBitCount;
slouken@1895
   370
    Uint32 biCompression;
slouken@1895
   371
    Uint32 biSizeImage;
slouken@1895
   372
    Sint32 biXPelsPerMeter;
slouken@1895
   373
    Sint32 biYPelsPerMeter;
slouken@1895
   374
    Uint32 biClrUsed;
slouken@1895
   375
    Uint32 biClrImportant;
slouken@0
   376
slouken@1895
   377
    /* Make sure we have somewhere to save */
slouken@1895
   378
    surface = NULL;
slouken@1895
   379
    if (dst) {
slouken@2969
   380
        SDL_bool save32bit = SDL_FALSE;
slouken@2969
   381
#ifdef SAVE_32BIT_BMP
slouken@2969
   382
        /* We can save alpha information in a 32-bit BMP */
slouken@2969
   383
        if (saveme->map->info.flags & SDL_COPY_COLORKEY ||
slouken@2969
   384
            saveme->format->Amask) {
slouken@2969
   385
            save32bit = SDL_TRUE;
slouken@2969
   386
        }
slouken@2969
   387
#endif /* SAVE_32BIT_BMP */
slouken@2969
   388
slouken@2969
   389
        if (saveme->format->palette && !save32bit) {
slouken@1895
   390
            if (saveme->format->BitsPerPixel == 8) {
slouken@1895
   391
                surface = saveme;
slouken@1895
   392
            } else {
slouken@1895
   393
                SDL_SetError("%d bpp BMP files not supported",
slouken@1895
   394
                             saveme->format->BitsPerPixel);
slouken@1895
   395
            }
slouken@1895
   396
        } else if ((saveme->format->BitsPerPixel == 24) &&
slouken@0
   397
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
slouken@1895
   398
                   (saveme->format->Rmask == 0x00FF0000) &&
slouken@1895
   399
                   (saveme->format->Gmask == 0x0000FF00) &&
slouken@1895
   400
                   (saveme->format->Bmask == 0x000000FF)
slouken@0
   401
#else
slouken@1895
   402
                   (saveme->format->Rmask == 0x000000FF) &&
slouken@1895
   403
                   (saveme->format->Gmask == 0x0000FF00) &&
slouken@1895
   404
                   (saveme->format->Bmask == 0x00FF0000)
slouken@0
   405
#endif
slouken@1895
   406
            ) {
slouken@1895
   407
            surface = saveme;
slouken@1895
   408
        } else {
slouken@2967
   409
            SDL_PixelFormat format;
slouken@0
   410
slouken@2969
   411
            /* If the surface has a colorkey or alpha channel we'll save a
slouken@2969
   412
               32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */
slouken@2969
   413
            if (save32bit) {
slouken@2969
   414
                SDL_InitFormat(&format, 32,
slouken@2990
   415
                               0x00FF0000, 0x0000FF00, 0x000000FF,
slouken@2990
   416
                               0xFF000000);
slouken@2969
   417
            } else {
slouken@2969
   418
                SDL_InitFormat(&format, 24,
slouken@0
   419
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
slouken@2969
   420
                               0x00FF0000, 0x0000FF00, 0x000000FF,
slouken@0
   421
#else
slouken@2969
   422
                               0x000000FF, 0x0000FF00, 0x00FF0000,
slouken@0
   423
#endif
slouken@2969
   424
                               0);
slouken@2969
   425
            }
slouken@2967
   426
            surface = SDL_ConvertSurface(saveme, &format, 0);
slouken@2967
   427
            if (!surface) {
slouken@2990
   428
                SDL_SetError("Couldn't convert image to %d bpp",
slouken@2990
   429
                             format.BitsPerPixel);
slouken@1895
   430
            }
slouken@1895
   431
        }
slouken@1895
   432
    }
slouken@0
   433
slouken@1895
   434
    if (surface && (SDL_LockSurface(surface) == 0)) {
slouken@1895
   435
        const int bw = surface->w * surface->format->BytesPerPixel;
slouken@1012
   436
slouken@1895
   437
        /* Set the BMP file header values */
slouken@1895
   438
        bfSize = 0;             /* We'll write this when we're done */
slouken@1895
   439
        bfReserved1 = 0;
slouken@1895
   440
        bfReserved2 = 0;
slouken@1895
   441
        bfOffBits = 0;          /* We'll write this when we're done */
slouken@0
   442
slouken@1895
   443
        /* Write the BMP file header values */
slouken@1895
   444
        fp_offset = SDL_RWtell(dst);
slouken@1895
   445
        SDL_ClearError();
slouken@1895
   446
        SDL_RWwrite(dst, magic, 2, 1);
slouken@1895
   447
        SDL_WriteLE32(dst, bfSize);
slouken@1895
   448
        SDL_WriteLE16(dst, bfReserved1);
slouken@1895
   449
        SDL_WriteLE16(dst, bfReserved2);
slouken@1895
   450
        SDL_WriteLE32(dst, bfOffBits);
slouken@0
   451
slouken@1895
   452
        /* Set the BMP info values */
slouken@1895
   453
        biSize = 40;
slouken@1895
   454
        biWidth = surface->w;
slouken@1895
   455
        biHeight = surface->h;
slouken@1895
   456
        biPlanes = 1;
slouken@1895
   457
        biBitCount = surface->format->BitsPerPixel;
slouken@1895
   458
        biCompression = BI_RGB;
slouken@1895
   459
        biSizeImage = surface->h * surface->pitch;
slouken@1895
   460
        biXPelsPerMeter = 0;
slouken@1895
   461
        biYPelsPerMeter = 0;
slouken@1895
   462
        if (surface->format->palette) {
slouken@1895
   463
            biClrUsed = surface->format->palette->ncolors;
slouken@1895
   464
        } else {
slouken@1895
   465
            biClrUsed = 0;
slouken@1895
   466
        }
slouken@1895
   467
        biClrImportant = 0;
slouken@0
   468
slouken@1895
   469
        /* Write the BMP info values */
slouken@1895
   470
        SDL_WriteLE32(dst, biSize);
slouken@1895
   471
        SDL_WriteLE32(dst, biWidth);
slouken@1895
   472
        SDL_WriteLE32(dst, biHeight);
slouken@1895
   473
        SDL_WriteLE16(dst, biPlanes);
slouken@1895
   474
        SDL_WriteLE16(dst, biBitCount);
slouken@1895
   475
        SDL_WriteLE32(dst, biCompression);
slouken@1895
   476
        SDL_WriteLE32(dst, biSizeImage);
slouken@1895
   477
        SDL_WriteLE32(dst, biXPelsPerMeter);
slouken@1895
   478
        SDL_WriteLE32(dst, biYPelsPerMeter);
slouken@1895
   479
        SDL_WriteLE32(dst, biClrUsed);
slouken@1895
   480
        SDL_WriteLE32(dst, biClrImportant);
slouken@0
   481
slouken@1895
   482
        /* Write the palette (in BGR color order) */
slouken@1895
   483
        if (surface->format->palette) {
slouken@1895
   484
            SDL_Color *colors;
slouken@1895
   485
            int ncolors;
slouken@0
   486
slouken@1895
   487
            colors = surface->format->palette->colors;
slouken@1895
   488
            ncolors = surface->format->palette->ncolors;
slouken@1895
   489
            for (i = 0; i < ncolors; ++i) {
slouken@1895
   490
                SDL_RWwrite(dst, &colors[i].b, 1, 1);
slouken@1895
   491
                SDL_RWwrite(dst, &colors[i].g, 1, 1);
slouken@1895
   492
                SDL_RWwrite(dst, &colors[i].r, 1, 1);
slouken@1895
   493
                SDL_RWwrite(dst, &colors[i].unused, 1, 1);
slouken@1895
   494
            }
slouken@1895
   495
        }
slouken@0
   496
slouken@1895
   497
        /* Write the bitmap offset */
slouken@1895
   498
        bfOffBits = SDL_RWtell(dst) - fp_offset;
slouken@1895
   499
        if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) {
slouken@1895
   500
            SDL_Error(SDL_EFSEEK);
slouken@1895
   501
        }
slouken@1895
   502
        SDL_WriteLE32(dst, bfOffBits);
slouken@1895
   503
        if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
slouken@1895
   504
            SDL_Error(SDL_EFSEEK);
slouken@1895
   505
        }
slouken@0
   506
slouken@1895
   507
        /* Write the bitmap image upside down */
slouken@1895
   508
        bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
slouken@1895
   509
        pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
slouken@1895
   510
        while (bits > (Uint8 *) surface->pixels) {
slouken@1895
   511
            bits -= surface->pitch;
slouken@1895
   512
            if (SDL_RWwrite(dst, bits, 1, bw) != bw) {
slouken@1895
   513
                SDL_Error(SDL_EFWRITE);
slouken@1895
   514
                break;
slouken@1895
   515
            }
slouken@1895
   516
            if (pad) {
slouken@1895
   517
                const Uint8 padbyte = 0;
slouken@1895
   518
                for (i = 0; i < pad; ++i) {
slouken@1895
   519
                    SDL_RWwrite(dst, &padbyte, 1, 1);
slouken@1895
   520
                }
slouken@1895
   521
            }
slouken@1895
   522
        }
slouken@0
   523
slouken@1895
   524
        /* Write the BMP file size */
slouken@1895
   525
        bfSize = SDL_RWtell(dst) - fp_offset;
slouken@1895
   526
        if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) {
slouken@1895
   527
            SDL_Error(SDL_EFSEEK);
slouken@1895
   528
        }
slouken@1895
   529
        SDL_WriteLE32(dst, bfSize);
slouken@1895
   530
        if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) {
slouken@1895
   531
            SDL_Error(SDL_EFSEEK);
slouken@1895
   532
        }
slouken@0
   533
slouken@1895
   534
        /* Close it up.. */
slouken@1895
   535
        SDL_UnlockSurface(surface);
slouken@1895
   536
        if (surface != saveme) {
slouken@1895
   537
            SDL_FreeSurface(surface);
slouken@1895
   538
        }
slouken@1895
   539
    }
slouken@0
   540
slouken@1895
   541
    if (freedst && dst) {
slouken@1895
   542
        SDL_RWclose(dst);
slouken@1895
   543
    }
slouken@1895
   544
    return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
slouken@0
   545
}
slouken@1895
   546
slouken@1895
   547
/* vi: set ts=4 sw=4 expandtab: */