/
IMG_lbm.c
514 lines (434 loc) · 12.7 KB
1
/*
2
3
SDL_image: An example image loading library for use with SDL
Copyright (C) 1997-2012 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
23
/* This is a ILBM image file loading framework
Load IFF pictures, PBM & ILBM packing methods, with or without stencil
24
25
26
Written by Daniel Morais ( Daniel AT Morais DOT com ) in September 2001.
24 bits ILBM files support added by Marc Le Douarain (http://www.multimania.com/mavati)
in December 2002.
27
EHB and HAM (specific Amiga graphic chip modes) support added by Marc Le Douarain
28
29
(http://www.multimania.com/mavati) in December 2003.
Stencil and colorkey fixes by David Raulo (david.raulo AT free DOT fr) in February 2004.
30
Buffer overflow fix in RLE decompression by David Raulo in January 2008.
31
32
33
34
*/
#include <stdio.h>
#include <stdlib.h>
35
#include <string.h>
36
37
38
39
40
41
42
43
44
#include "SDL_endian.h"
#include "SDL_image.h"
#ifdef LOAD_LBM
#define MAXCOLORS 256
45
/* Structure for an IFF picture ( BMHD = Bitmap Header ) */
46
47
48
typedef struct
{
49
50
51
52
53
54
55
56
Uint16 w, h; /* width & height of the bitmap in pixels */
Sint16 x, y; /* screen coordinates of the bitmap */
Uint8 planes; /* number of planes of the bitmap */
Uint8 mask; /* mask type ( 0 => no mask ) */
Uint8 tcomp; /* compression type */
Uint8 pad1; /* dummy value, for padding */
Uint16 tcolor; /* transparent color */
Uint8 xAspect, /* pixel aspect ratio */
57
yAspect;
58
59
Sint16 Lpage; /* width of the screen in pixels */
Sint16 Hpage; /* height of the screen in pixels */
60
61
62
63
} BMHD;
int IMG_isLBM( SDL_RWops *src )
{
64
int start;
65
66
67
int is_LBM;
Uint8 magic[4+4+4];
68
69
if ( !src )
return 0;
70
start = SDL_RWtell(src);
71
is_LBM = 0;
72
if ( SDL_RWread( src, magic, sizeof(magic), 1 ) )
73
{
74
75
76
if ( !memcmp( magic, "FORM", 4 ) &&
( !memcmp( magic + 8, "PBM ", 4 ) ||
!memcmp( magic + 8, "ILBM", 4 ) ) )
77
78
79
80
{
is_LBM = 1;
}
}
81
SDL_RWseek(src, start, RW_SEEK_SET);
82
83
84
85
86
return( is_LBM );
}
SDL_Surface *IMG_LoadLBM_RW( SDL_RWops *src )
{
87
int start;
88
89
SDL_Surface *Image;
Uint8 id[4], pbm, colormap[MAXCOLORS*3], *MiniBuf, *ptr, count, color, msk;
90
Uint32 size, bytesloaded, nbcolors;
91
Uint32 i, j, bytesperline, nbplanes, stencil, plane, h;
92
Uint32 remainingbytes;
93
Uint32 width;
94
95
BMHD bmhd;
char *error;
96
Uint8 flagHAM,flagEHB;
97
98
99
100
101
Image = NULL;
error = NULL;
MiniBuf = NULL;
102
103
104
105
if ( !src ) {
/* The error message has been set in SDL_RWFromFile */
return NULL;
}
106
107
start = SDL_RWtell(src);
108
if ( !SDL_RWread( src, id, 4, 1 ) )
109
{
110
error="error reading IFF chunk";
111
112
113
goto done;
}
114
115
/* Should be the size of the file minus 4+4 ( 'FORM'+size ) */
if ( !SDL_RWread( src, &size, 4, 1 ) )
116
{
117
error="error reading IFF chunk size";
118
119
120
goto done;
}
121
/* As size is not used here, no need to swap it */
122
123
if ( memcmp( id, "FORM", 4 ) != 0 )
124
{
125
error="not a IFF file";
126
127
128
goto done;
}
129
if ( !SDL_RWread( src, id, 4, 1 ) )
130
{
131
error="error reading IFF chunk";
132
133
134
135
136
goto done;
}
pbm = 0;
137
138
/* File format : PBM=Packed Bitmap, ILBM=Interleaved Bitmap */
if ( !memcmp( id, "PBM ", 4 ) ) pbm = 1;
139
140
else if ( memcmp( id, "ILBM", 4 ) )
{
141
error="not a IFF picture";
142
143
144
145
146
147
goto done;
}
nbcolors = 0;
memset( &bmhd, 0, sizeof( BMHD ) );
148
149
flagHAM = 0;
flagEHB = 0;
150
151
while ( memcmp( id, "BODY", 4 ) != 0 )
152
153
154
{
if ( !SDL_RWread( src, id, 4, 1 ) )
{
155
error="error reading IFF chunk";
156
157
158
goto done;
}
159
if ( !SDL_RWread( src, &size, 4, 1 ) )
160
{
161
error="error reading IFF chunk size";
162
163
164
165
166
167
goto done;
}
bytesloaded = 0;
size = SDL_SwapBE32( size );
168
169
if ( !memcmp( id, "BMHD", 4 ) ) /* Bitmap header */
170
171
172
{
if ( !SDL_RWread( src, &bmhd, sizeof( BMHD ), 1 ) )
{
173
error="error reading BMHD chunk";
174
175
176
177
178
179
180
181
182
183
184
185
186
187
goto done;
}
bytesloaded = sizeof( BMHD );
bmhd.w = SDL_SwapBE16( bmhd.w );
bmhd.h = SDL_SwapBE16( bmhd.h );
bmhd.x = SDL_SwapBE16( bmhd.x );
bmhd.y = SDL_SwapBE16( bmhd.y );
bmhd.tcolor = SDL_SwapBE16( bmhd.tcolor );
bmhd.Lpage = SDL_SwapBE16( bmhd.Lpage );
bmhd.Hpage = SDL_SwapBE16( bmhd.Hpage );
}
188
if ( !memcmp( id, "CMAP", 4 ) ) /* palette ( Color Map ) */
189
{
190
191
192
193
194
if (size > sizeof (colormap)) {
error="colormap size is too large";
goto done;
}
195
196
if ( !SDL_RWread( src, &colormap, size, 1 ) )
{
197
error="error reading CMAP chunk";
198
199
200
201
202
203
204
goto done;
}
bytesloaded = size;
nbcolors = size / 3;
}
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
if ( !memcmp( id, "CAMG", 4 ) ) /* Amiga ViewMode */
{
Uint32 viewmodes;
if ( !SDL_RWread( src, &viewmodes, sizeof(viewmodes), 1 ) )
{
error="error reading CAMG chunk";
goto done;
}
bytesloaded = size;
viewmodes = SDL_SwapBE32( viewmodes );
if ( viewmodes & 0x0800 )
flagHAM = 1;
if ( viewmodes & 0x0080 )
flagEHB = 1;
}
222
223
if ( memcmp( id, "BODY", 4 ) )
{
224
if ( size & 1 ) ++size; /* padding ! */
225
size -= bytesloaded;
226
/* skip the remaining bytes of this chunk */
227
if ( size ) SDL_RWseek( src, size, RW_SEEK_CUR );
228
229
230
}
}
231
/* compute some usefull values, based on the bitmap header */
232
233
width = ( bmhd.w + 15 ) & 0xFFFFFFF0; /* Width in pixels modulo 16 */
234
235
bytesperline = ( ( bmhd.w + 15 ) / 16 ) * 2;
236
237
nbplanes = bmhd.planes;
238
239
if ( pbm ) /* File format : 'Packed Bitmap' */
240
{
241
bytesperline *= 8;
242
nbplanes = 1;
243
244
}
245
246
247
248
249
250
if ((nbplanes != 1) && (nbplanes != 4) && (nbplanes != 8) && (nbplanes != 24))
{
error="unsupported number of color planes";
goto done;
}
251
stencil = (bmhd.mask & 1); /* There is a mask ( 'stencil' ) */
252
253
254
/* Allocate memory for a temporary buffer ( used for
decompression/deinterleaving ) */
255
256
MiniBuf = (Uint8 *)malloc( bytesperline * (nbplanes + stencil) );
257
if ( MiniBuf == NULL )
258
{
259
error="not enough memory for temporary buffer";
260
261
262
goto done;
}
263
if ( ( Image = SDL_CreateRGBSurface( SDL_SWSURFACE, width, bmhd.h, (nbplanes==24 || flagHAM==1)?24:8, 0, 0, 0, 0 ) ) == NULL )
264
265
goto done;
266
267
268
if ( bmhd.mask & 2 ) /* There is a transparent color */
SDL_SetColorKey( Image, SDL_SRCCOLORKEY, bmhd.tcolor );
269
/* Update palette informations */
270
271
/* There is no palette in 24 bits ILBM file */
272
if ( nbcolors>0 && flagHAM==0 )
273
{
274
275
/* FIXME: Should this include the stencil? See comment below */
int nbrcolorsfinal = 1 << (nbplanes + stencil);
276
ptr = &colormap[0];
277
278
279
280
281
282
283
for ( i=0; i<nbcolors; i++ )
{
Image->format->palette->colors[i].r = *ptr++;
Image->format->palette->colors[i].g = *ptr++;
Image->format->palette->colors[i].b = *ptr++;
}
284
285
286
287
/* Amiga EHB mode (Extra-Half-Bright) */
/* 6 bitplanes mode with a 32 colors palette */
/* The 32 last colors are the same but divided by 2 */
288
/* Some Amiga pictures save 64 colors with 32 last wrong colors, */
289
/* they shouldn't !, and here we overwrite these 32 bad colors. */
290
if ( (nbcolors==32 || flagEHB ) && (1<<nbplanes)==64 )
291
{
292
nbcolors = 64;
293
294
295
296
297
298
299
300
ptr = &colormap[0];
for ( i=32; i<64; i++ )
{
Image->format->palette->colors[i].r = (*ptr++)/2;
Image->format->palette->colors[i].g = (*ptr++)/2;
Image->format->palette->colors[i].b = (*ptr++)/2;
}
}
301
302
303
/* If nbcolors < 2^nbplanes, repeat the colormap */
/* This happens when pictures have a stencil mask */
304
305
if ( nbrcolorsfinal > (1<<nbplanes) ) {
nbrcolorsfinal = (1<<nbplanes);
306
}
307
for ( i=nbcolors; i < (Uint32)nbrcolorsfinal; i++ )
308
309
310
311
312
{
Image->format->palette->colors[i].r = Image->format->palette->colors[i%nbcolors].r;
Image->format->palette->colors[i].g = Image->format->palette->colors[i%nbcolors].g;
Image->format->palette->colors[i].b = Image->format->palette->colors[i%nbcolors].b;
}
313
314
if ( !pbm )
Image->format->palette->ncolors = nbrcolorsfinal;
315
316
}
317
/* Get the bitmap */
318
319
320
for ( h=0; h < bmhd.h; h++ )
{
321
322
/* uncompress the datas of each planes */
323
for ( plane=0; plane < (nbplanes+stencil); plane++ )
324
{
325
326
ptr = MiniBuf + ( plane * bytesperline );
327
remainingbytes = bytesperline;
328
329
if ( bmhd.tcomp == 1 ) /* Datas are compressed */
330
{
331
do
332
{
333
if ( !SDL_RWread( src, &count, 1, 1 ) )
334
{
335
error="error reading BODY chunk";
336
337
goto done;
}
338
339
340
if ( count & 0x80 )
{
341
342
343
count ^= 0xFF;
count += 2; /* now it */
344
if ( ( count > remainingbytes ) || !SDL_RWread( src, &color, 1, 1 ) )
345
{
346
error="error reading BODY chunk";
347
348
349
350
351
352
goto done;
}
memset( ptr, color, count );
}
else
{
353
++count;
354
355
if ( ( count > remainingbytes ) || !SDL_RWread( src, ptr, count, 1 ) )
356
357
358
359
360
{
error="error reading BODY chunk";
goto done;
}
}
361
362
363
ptr += count;
remainingbytes -= count;
364
365
366
} while ( remainingbytes > 0 );
}
367
else
368
{
369
if ( !SDL_RWread( src, ptr, bytesperline, 1 ) )
370
{
371
error="error reading BODY chunk";
372
373
374
375
goto done;
}
}
}
376
377
/* One line has been read, store it ! */
378
379
ptr = (Uint8 *)Image->pixels;
380
if ( nbplanes==24 || flagHAM==1 )
381
382
383
384
ptr += h * width * 3;
else
ptr += h * width;
385
if ( pbm ) /* File format : 'Packed Bitmap' */
386
387
388
{
memcpy( ptr, MiniBuf, width );
}
389
else /* We have to un-interlace the bits ! */
390
{
391
if ( nbplanes!=24 && flagHAM==0 )
392
393
394
395
396
397
398
{
size = ( width + 7 ) / 8;
for ( i=0; i < size; i++ )
{
memset( ptr, 0, 8 );
399
for ( plane=0; plane < (nbplanes + stencil); plane++ )
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
{
color = *( MiniBuf + i + ( plane * bytesperline ) );
msk = 0x80;
for ( j=0; j<8; j++ )
{
if ( ( plane + j ) <= 7 ) ptr[j] |= (Uint8)( color & msk ) >> ( 7 - plane - j );
else ptr[j] |= (Uint8)( color & msk ) << ( plane + j - 7 );
msk >>= 1;
}
}
ptr += 8;
}
}
else
416
{
417
Uint32 finalcolor = 0;
418
419
size = ( width + 7 ) / 8;
/* 24 bitplanes ILBM : R0...R7,G0...G7,B0...B7 */
420
/* or HAM (6 bitplanes) or HAM8 (8 bitplanes) modes */
421
for ( i=0; i<width; i=i+8 )
422
{
423
Uint8 maskBit = 0x80;
424
425
for ( j=0; j<8; j++ )
{
426
427
Uint32 pixelcolor = 0;
Uint32 maskColor = 1;
428
429
430
431
432
Uint8 dataBody;
for ( plane=0; plane < nbplanes; plane++ )
{
dataBody = MiniBuf[ plane*size+i/8 ];
if ( dataBody&maskBit )
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
pixelcolor = pixelcolor | maskColor;
maskColor = maskColor<<1;
}
/* HAM : 12 bits RGB image (4 bits per color component) */
/* HAM8 : 18 bits RGB image (6 bits per color component) */
if ( flagHAM )
{
switch( pixelcolor>>(nbplanes-2) )
{
case 0: /* take direct color from palette */
finalcolor = colormap[ pixelcolor*3 ] + (colormap[ pixelcolor*3+1 ]<<8) + (colormap[ pixelcolor*3+2 ]<<16);
break;
case 1: /* modify only blue component */
finalcolor = finalcolor&0x00FFFF;
finalcolor = finalcolor | (pixelcolor<<(16+(10-nbplanes)));
break;
case 2: /* modify only red component */
finalcolor = finalcolor&0xFFFF00;
finalcolor = finalcolor | pixelcolor<<(10-nbplanes);
break;
case 3: /* modify only green component */
finalcolor = finalcolor&0xFF00FF;
finalcolor = finalcolor | (pixelcolor<<(8+(10-nbplanes)));
break;
}
}
else
{
finalcolor = pixelcolor;
462
463
464
}
if ( SDL_BYTEORDER == SDL_LIL_ENDIAN )
{
465
466
467
*ptr++ = (Uint8)(finalcolor>>16);
*ptr++ = (Uint8)(finalcolor>>8);
*ptr++ = (Uint8)(finalcolor);
468
469
470
}
else
{
471
472
473
*ptr++ = (Uint8)(finalcolor);
*ptr++ = (Uint8)(finalcolor>>8);
*ptr++ = (Uint8)(finalcolor>>16);
474
475
476
}
maskBit = maskBit>>1;
477
478
479
480
481
482
483
484
485
486
}
}
}
}
}
done:
if ( MiniBuf ) free( MiniBuf );
487
if ( error )
488
{
489
SDL_RWseek(src, start, RW_SEEK_SET);
490
491
492
493
if ( Image ) {
SDL_FreeSurface( Image );
Image = NULL;
}
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
IMG_SetError( error );
}
return( Image );
}
#else /* LOAD_LBM */
/* See if an image is contained in a data source */
int IMG_isLBM(SDL_RWops *src)
{
return(0);
}
/* Load an IFF type image from an SDL datasource */
SDL_Surface *IMG_LoadLBM_RW(SDL_RWops *src)
{
return(NULL);
}
#endif /* LOAD_LBM */