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