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