/
IMG_bmp.c
468 lines (416 loc) · 12.3 KB
1
/*
2
SDL_image: An example image loading library for use with SDL
3
Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
8
9
10
11
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
12
13
14
15
16
17
18
19
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
21
*/
22
#if (!defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)) || !defined(BMP_USES_IMAGEIO)
23
24
25
26
27
28
29
30
31
/* This is a BMP image file loading framework
*
* ICO/CUR file support is here as well since it uses similar internal
* representation
*
* A good test suite of BMP images is available at:
* http://entropymine.com/jason/bmpsuite/bmpsuite/html/bmpsuite.html
*/
32
33
34
35
36
37
38
39
#include "SDL_image.h"
#ifdef LOAD_BMP
/* See if an image is contained in a data source */
int IMG_isBMP(SDL_RWops *src)
{
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
Sint64 start;
int is_BMP;
char magic[2];
if ( !src )
return 0;
start = SDL_RWtell(src);
is_BMP = 0;
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
if ( SDL_strncmp(magic, "BM", 2) == 0 ) {
is_BMP = 1;
}
}
SDL_RWseek(src, start, RW_SEEK_SET);
return(is_BMP);
55
56
}
57
58
static int IMG_isICOCUR(SDL_RWops *src, int type)
{
59
60
Sint64 start;
int is_ICOCUR;
61
62
/* The Win32 ICO file header (14 bytes) */
63
64
65
66
Uint16 bfReserved;
Uint16 bfType;
Uint16 bfCount;
67
68
69
70
if ( !src )
return 0;
start = SDL_RWtell(src);
is_ICOCUR = 0;
71
72
73
bfReserved = SDL_ReadLE16(src);
bfType = SDL_ReadLE16(src);
bfCount = SDL_ReadLE16(src);
74
75
76
if ((bfReserved == 0) && (bfType == type) && (bfCount != 0))
is_ICOCUR = 1;
SDL_RWseek(src, start, RW_SEEK_SET);
77
78
return (is_ICOCUR);
79
80
81
82
}
int IMG_isICO(SDL_RWops *src)
{
83
return IMG_isICOCUR(src, 1);
84
85
86
87
}
int IMG_isCUR(SDL_RWops *src)
{
88
return IMG_isICOCUR(src, 2);
89
90
}
91
92
93
94
95
96
#include "SDL_error.h"
#include "SDL_video.h"
#include "SDL_endian.h"
/* Compression encodings for BMP files */
#ifndef BI_RGB
97
98
99
100
#define BI_RGB 0
#define BI_RLE8 1
#define BI_RLE4 2
#define BI_BITFIELDS 3
101
102
103
104
#endif
static SDL_Surface *LoadBMP_RW (SDL_RWops *src, int freesrc)
{
105
return SDL_LoadBMP_RW(src, freesrc);
106
107
}
108
109
110
111
112
113
114
115
116
117
118
119
static Uint8
SDL_Read8(SDL_RWops * src)
{
Uint8 value;
SDL_RWread(src, &value, 1, 1);
return (value);
}
static SDL_Surface *
LoadICOCUR_RW(SDL_RWops * src, int type, int freesrc)
{
120
SDL_bool was_error;
121
Sint64 fp_offset = 0;
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
int bmpPitch;
int i, pad;
SDL_Surface *surface;
Uint32 Rmask;
Uint32 Gmask;
Uint32 Bmask;
Uint8 *bits;
int ExpandBMP;
int maxCol = 0;
int icoOfs = 0;
Uint32 palette[256];
/* The Win32 ICO file header (14 bytes) */
Uint16 bfReserved;
Uint16 bfType;
Uint16 bfCount;
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
Uint32 biSize;
Sint32 biWidth;
Sint32 biHeight;
Uint16 biPlanes;
Uint16 biBitCount;
Uint32 biCompression;
Uint32 biSizeImage;
Sint32 biXPelsPerMeter;
Sint32 biYPelsPerMeter;
Uint32 biClrUsed;
Uint32 biClrImportant;
/* Make sure we are passed a valid data source */
surface = NULL;
154
was_error = SDL_FALSE;
155
if (src == NULL) {
156
was_error = SDL_TRUE;
157
158
159
160
161
162
163
164
165
166
167
goto done;
}
/* Read in the ICO file header */
fp_offset = SDL_RWtell(src);
SDL_ClearError();
bfReserved = SDL_ReadLE16(src);
bfType = SDL_ReadLE16(src);
bfCount = SDL_ReadLE16(src);
if ((bfReserved != 0) || (bfType != type) || (bfCount == 0)) {
168
IMG_SetError("File is not a Windows %s file", type == 1 ? "ICO" : "CUR");
169
was_error = SDL_TRUE;
170
171
172
173
174
175
176
177
178
goto done;
}
/* Read the Win32 Icon Directory */
for (i = 0; i < bfCount; i++) {
/* Icon Directory Entries */
int bWidth = SDL_Read8(src); /* Uint8, but 0 = 256 ! */
int bHeight = SDL_Read8(src); /* Uint8, but 0 = 256 ! */
int bColorCount = SDL_Read8(src); /* Uint8, but 0 = 256 ! */
179
180
181
182
183
184
185
186
187
188
189
/* Uint8 bReserved;
Uint16 wPlanes;
Uint16 wBitCount;
Uint32 dwBytesInRes; */
Uint32 dwImageOffset;
/* bReserved = */ SDL_Read8(src);
/* wPlanes = */ SDL_ReadLE16(src);
/* wBitCount = */ SDL_ReadLE16(src);
/* dwBytesInRes = */ SDL_ReadLE32(src);
dwImageOffset = SDL_ReadLE32(src);
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
if (!bWidth)
bWidth = 256;
if (!bHeight)
bHeight = 256;
if (!bColorCount)
bColorCount = 256;
//printf("%dx%d@%d - %08x\n", bWidth, bHeight, bColorCount, dwImageOffset);
if (bColorCount > maxCol) {
maxCol = bColorCount;
icoOfs = dwImageOffset;
//printf("marked\n");
}
}
/* Advance to the DIB Data */
if (SDL_RWseek(src, icoOfs, RW_SEEK_SET) < 0) {
SDL_Error(SDL_EFSEEK);
209
was_error = SDL_TRUE;
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
goto done;
}
/* Read the Win32 BITMAPINFOHEADER */
biSize = SDL_ReadLE32(src);
if (biSize == 40) {
biWidth = SDL_ReadLE32(src);
biHeight = SDL_ReadLE32(src);
biPlanes = SDL_ReadLE16(src);
biBitCount = SDL_ReadLE16(src);
biCompression = SDL_ReadLE32(src);
biSizeImage = SDL_ReadLE32(src);
biXPelsPerMeter = SDL_ReadLE32(src);
biYPelsPerMeter = SDL_ReadLE32(src);
biClrUsed = SDL_ReadLE32(src);
biClrImportant = SDL_ReadLE32(src);
} else {
227
IMG_SetError("Unsupported ICO bitmap format");
228
was_error = SDL_TRUE;
229
230
231
232
233
goto done;
}
/* Check for read error */
if (SDL_strcmp(SDL_GetError(), "") != 0) {
234
was_error = SDL_TRUE;
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
goto done;
}
/* We don't support any BMP compression right now */
switch (biCompression) {
case BI_RGB:
/* Default values for the BMP format */
switch (biBitCount) {
case 1:
case 4:
ExpandBMP = biBitCount;
biBitCount = 8;
break;
case 8:
ExpandBMP = 8;
break;
case 32:
Rmask = 0x00FF0000;
Gmask = 0x0000FF00;
Bmask = 0x000000FF;
ExpandBMP = 0;
break;
default:
258
IMG_SetError("ICO file with unsupported bit count");
259
was_error = SDL_TRUE;
260
261
262
263
goto done;
}
break;
default:
264
IMG_SetError("Compressed ICO files not supported");
265
was_error = SDL_TRUE;
266
267
268
goto done;
}
269
270
271
272
273
274
275
276
/* sanity check image size, so we don't overflow integers, etc. */
if ((biWidth < 0) || (biWidth > 0xFFFFFF) ||
(biHeight < 0) || (biHeight > 0xFFFFFF)) {
IMG_SetError("Unsupported or invalid ICO dimensions");
was_error = SDL_TRUE;
goto done;
}
277
278
279
280
281
282
283
/* Create a RGBA surface */
biHeight = biHeight >> 1;
//printf("%d x %d\n", biWidth, biHeight);
surface =
SDL_CreateRGBSurface(0, biWidth, biHeight, 32, 0x00FF0000,
0x0000FF00, 0x000000FF, 0xFF000000);
if (surface == NULL) {
284
was_error = SDL_TRUE;
285
286
287
288
289
290
291
292
293
goto done;
}
/* Load the palette, if any */
//printf("bc %d bused %d\n", biBitCount, biClrUsed);
if (biBitCount <= 8) {
if (biClrUsed == 0) {
biClrUsed = 1 << biBitCount;
}
294
295
296
297
298
if (biClrUsed > SDL_arraysize(palette)) {
IMG_SetError("Unsupported or incorrect biClrUsed field");
was_error = SDL_TRUE;
goto done;
}
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
for (i = 0; i < (int) biClrUsed; ++i) {
SDL_RWread(src, &palette[i], 4, 1);
}
}
/* Read the surface pixels. Note that the bmp image is upside down */
bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
switch (ExpandBMP) {
case 1:
bmpPitch = (biWidth + 7) >> 3;
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
break;
case 4:
bmpPitch = (biWidth + 1) >> 1;
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
break;
case 8:
bmpPitch = biWidth;
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
break;
default:
bmpPitch = biWidth * 4;
pad = 0;
break;
}
while (bits > (Uint8 *) surface->pixels) {
bits -= surface->pitch;
switch (ExpandBMP) {
case 1:
case 4:
case 8:
{
Uint8 pixel = 0;
int shift = (8 - ExpandBMP);
for (i = 0; i < surface->w; ++i) {
if (i % (8 / ExpandBMP) == 0) {
if (!SDL_RWread(src, &pixel, 1, 1)) {
336
IMG_SetError("Error reading from ICO");
337
was_error = SDL_TRUE;
338
339
340
341
342
343
344
345
346
347
348
349
350
goto done;
}
}
*((Uint32 *) bits + i) = (palette[pixel >> shift]);
pixel <<= ExpandBMP;
}
}
break;
default:
if (SDL_RWread(src, bits, 1, surface->pitch)
!= surface->pitch) {
SDL_Error(SDL_EFREAD);
351
was_error = SDL_TRUE;
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
goto done;
}
break;
}
/* Skip padding bytes, ugh */
if (pad) {
Uint8 padbyte;
for (i = 0; i < pad; ++i) {
SDL_RWread(src, &padbyte, 1, 1);
}
}
}
/* Read the mask pixels. Note that the bmp image is upside down */
bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
ExpandBMP = 1;
bmpPitch = (biWidth + 7) >> 3;
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
while (bits > (Uint8 *) surface->pixels) {
Uint8 pixel = 0;
int shift = (8 - ExpandBMP);
bits -= surface->pitch;
for (i = 0; i < surface->w; ++i) {
if (i % (8 / ExpandBMP) == 0) {
if (!SDL_RWread(src, &pixel, 1, 1)) {
377
IMG_SetError("Error reading from ICO");
378
was_error = SDL_TRUE;
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
goto done;
}
}
*((Uint32 *) bits + i) |= ((pixel >> shift) ? 0 : 0xFF000000);
pixel <<= ExpandBMP;
}
/* Skip padding bytes, ugh */
if (pad) {
Uint8 padbyte;
for (i = 0; i < pad; ++i) {
SDL_RWread(src, &padbyte, 1, 1);
}
}
}
done:
if (was_error) {
if (src) {
SDL_RWseek(src, fp_offset, RW_SEEK_SET);
}
if (surface) {
SDL_FreeSurface(surface);
}
surface = NULL;
}
if (freesrc && src) {
SDL_RWclose(src);
}
return (surface);
}
409
410
411
/* Load a BMP type image from an SDL datasource */
SDL_Surface *IMG_LoadBMP_RW(SDL_RWops *src)
{
412
return(LoadBMP_RW(src, 0));
413
414
}
415
416
417
/* Load a ICO type image from an SDL datasource */
SDL_Surface *IMG_LoadICO_RW(SDL_RWops *src)
{
418
return(LoadICOCUR_RW(src, 1, 0));
419
420
421
422
423
}
/* Load a CUR type image from an SDL datasource */
SDL_Surface *IMG_LoadCUR_RW(SDL_RWops *src)
{
424
return(LoadICOCUR_RW(src, 2, 0));
425
426
}
427
#else
428
429
430
#if _MSC_VER >= 1300
#pragma warning(disable : 4100) /* warning C4100: 'op' : unreferenced formal parameter */
#endif
431
432
433
434
/* See if an image is contained in a data source */
int IMG_isBMP(SDL_RWops *src)
{
435
return(0);
436
437
}
438
439
int IMG_isICO(SDL_RWops *src)
{
440
return(0);
441
442
443
444
}
int IMG_isCUR(SDL_RWops *src)
{
445
return(0);
446
447
}
448
449
450
/* Load a BMP type image from an SDL datasource */
SDL_Surface *IMG_LoadBMP_RW(SDL_RWops *src)
{
451
return(NULL);
452
453
}
454
455
456
/* Load a BMP type image from an SDL datasource */
SDL_Surface *IMG_LoadCUR_RW(SDL_RWops *src)
{
457
return(NULL);
458
459
460
461
462
}
/* Load a BMP type image from an SDL datasource */
SDL_Surface *IMG_LoadICO_RW(SDL_RWops *src)
{
463
return(NULL);
464
465
}
466
#endif /* LOAD_BMP */
467
468
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */