/
IMG_xpm.c
507 lines (454 loc) · 10.9 KB
1
/*
2
SDL_image: An example image loading library for use with SDL
3
Copyright (C) 1997-2006 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
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
22
*/
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*
* XPM (X PixMap) image loader:
*
* Supports the XPMv3 format, EXCEPT:
* - hotspot coordinates are ignored
* - only colour ('c') colour symbols are used
* - rgb.txt is not used (for portability), so only RGB colours
* are recognized (#rrggbb etc) - only a few basic colour names are
* handled
*
* The result is an 8bpp indexed surface if possible, otherwise 32bpp.
* The colourkey is correctly set if transparency is used.
*
* Besides the standard API, also provides
*
* SDL_Surface *IMG_ReadXPMFromArray(char **xpm)
*
* that reads the image data from an XPM file included in the C source.
*
* TODO: include rgb.txt here. The full table (from solaris 2.6) only
* requires about 13K in binary form.
*/
45
46
#include <stdlib.h>
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "SDL_image.h"
#ifdef LOAD_XPM
/* See if an image is contained in a data source */
int IMG_isXPM(SDL_RWops *src)
{
58
59
int start;
int is_XPM;
60
char magic[9];
61
62
63
if ( !src )
return 0;
64
65
66
67
68
69
70
71
72
start = SDL_RWtell(src);
is_XPM = 0;
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
if ( memcmp(magic, "/* XPM */", sizeof(magic)) == 0 ) {
is_XPM = 1;
}
}
SDL_RWseek(src, start, SEEK_SET);
return(is_XPM);
73
74
75
}
/* Hash table to look up colors from pixel strings */
76
77
78
79
80
81
82
83
#define STARTING_HASH_SIZE 256
struct hash_entry {
char *key;
Uint32 color;
struct hash_entry *next;
};
84
struct color_hash {
85
86
87
88
89
struct hash_entry **table;
struct hash_entry *entries; /* array of all entries */
struct hash_entry *next_free;
int size;
int maxnum;
90
91
};
92
static int hash_key(const char *key, int cpp, int size)
93
94
95
96
97
{
int hash;
hash = 0;
while ( cpp-- > 0 ) {
98
hash = hash * 33 + *key++;
99
}
100
return hash & (size - 1);
101
102
}
103
static struct color_hash *create_colorhash(int maxnum)
104
{
105
int bytes, s;
106
107
struct color_hash *hash;
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/* we know how many entries we need, so we can allocate
everything here */
hash = malloc(sizeof *hash);
if(!hash)
return NULL;
/* use power-of-2 sized hash table for decoding speed */
for(s = STARTING_HASH_SIZE; s < maxnum; s <<= 1)
;
hash->size = s;
hash->maxnum = maxnum;
bytes = hash->size * sizeof(struct hash_entry **);
hash->entries = NULL; /* in case malloc fails */
hash->table = malloc(bytes);
if(!hash->table)
return NULL;
memset(hash->table, 0, bytes);
hash->entries = malloc(maxnum * sizeof(struct hash_entry));
if(!hash->entries)
return NULL;
hash->next_free = hash->entries;
return hash;
130
131
132
}
static int add_colorhash(struct color_hash *hash,
133
char *key, int cpp, Uint32 color)
134
{
135
136
137
138
139
140
141
int index = hash_key(key, cpp, hash->size);
struct hash_entry *e = hash->next_free++;
e->color = color;
e->key = key;
e->next = hash->table[index];
hash->table[index] = e;
return 1;
142
143
}
144
/* fast lookup that works if cpp == 1 */
145
#define QUICK_COLORHASH(hash, key) ((hash)->table[*(Uint8 *)(key)]->color)
146
147
static Uint32 get_colorhash(struct color_hash *hash, const char *key, int cpp)
148
{
149
150
151
152
153
struct hash_entry *entry = hash->table[hash_key(key, cpp, hash->size)];
while(entry) {
if(memcmp(key, entry->key, cpp) == 0)
return entry->color;
entry = entry->next;
154
}
155
return 0; /* garbage in - garbage out */
156
157
158
159
}
static void free_colorhash(struct color_hash *hash)
{
160
161
162
163
if(hash && hash->table) {
free(hash->table);
free(hash->entries);
free(hash);
164
165
166
}
}
167
168
169
170
171
172
173
174
175
176
177
178
179
/* portable case-insensitive string comparison */
static int string_equal(const char *a, const char *b, int n)
{
while(*a && *b && n) {
if(toupper((unsigned char)*a) != toupper((unsigned char)*b))
return 0;
a++;
b++;
n--;
}
return *a == *b;
}
180
#define ARRAYSIZE(a) (int)(sizeof(a) / sizeof((a)[0]))
181
182
183
/*
* convert colour spec to RGB (in 0xrrggbb format).
184
* return 1 if successful.
185
*/
186
static int color_to_rgb(char *spec, int speclen, Uint32 *rgb)
187
188
189
190
191
192
193
194
195
196
197
198
199
{
/* poor man's rgb.txt */
static struct { char *name; Uint32 rgb; } known[] = {
{"none", 0xffffffff},
{"black", 0x00000000},
{"white", 0x00ffffff},
{"red", 0x00ff0000},
{"green", 0x0000ff00},
{"blue", 0x000000ff}
};
if(spec[0] == '#') {
char buf[7];
200
201
202
203
204
switch(speclen) {
case 4:
buf[0] = buf[1] = spec[1];
buf[2] = buf[3] = spec[2];
buf[4] = buf[5] = spec[3];
205
break;
206
207
case 7:
memcpy(buf, spec + 1, 6);
208
break;
209
210
211
212
213
214
215
case 13:
buf[0] = spec[1];
buf[1] = spec[2];
buf[2] = spec[5];
buf[3] = spec[6];
buf[4] = spec[9];
buf[5] = spec[10];
216
break;
217
218
219
220
221
222
223
}
buf[6] = '\0';
*rgb = strtol(buf, NULL, 16);
return 1;
} else {
int i;
for(i = 0; i < ARRAYSIZE(known); i++)
224
if(string_equal(known[i].name, spec, speclen)) {
225
226
227
228
*rgb = known[i].rgb;
return 1;
}
return 0;
229
230
231
}
}
232
233
234
#ifndef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
235
236
237
238
239
240
241
242
243
244
static char *linebuf;
static int buflen;
static char *error;
/*
* Read next line from the source.
* If len > 0, it's assumed to be at least len chars (for efficiency).
* Return NULL and set error upon EOF or parse error.
*/
245
static char *get_next_line(char ***lines, SDL_RWops *src, int len)
246
{
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
if(lines) {
return *(*lines)++;
} else {
char c;
int n;
do {
if(SDL_RWread(src, &c, 1, 1) <= 0) {
error = "Premature end of data";
return NULL;
}
} while(c != '"');
if(len) {
len += 4; /* "\",\n\0" */
if(len > buflen){
buflen = len;
linebuf = realloc(linebuf, buflen);
if(!linebuf) {
error = "Out of memory";
return NULL;
}
}
if(SDL_RWread(src, linebuf, len - 1, 1) <= 0) {
error = "Premature end of data";
return NULL;
}
n = len - 2;
} else {
n = 0;
do {
if(n >= buflen - 1) {
if(buflen == 0)
buflen = 16;
buflen *= 2;
linebuf = realloc(linebuf, buflen);
if(!linebuf) {
error = "Out of memory";
return NULL;
}
}
if(SDL_RWread(src, linebuf + n, 1, 1) <= 0) {
error = "Premature end of data";
return NULL;
}
} while(linebuf[n++] != '"');
n--;
}
linebuf[n] = '\0';
return linebuf;
}
296
297
}
298
299
300
301
302
#define SKIPSPACE(p) \
do { \
while(isspace((unsigned char)*(p))) \
++(p); \
} while(0)
303
304
305
306
307
308
309
310
311
#define SKIPNONSPACE(p) \
do { \
while(!isspace((unsigned char)*(p)) && *p) \
++(p); \
} while(0)
/* read XPM from either array or RWops */
static SDL_Surface *load_xpm(char **xpm, SDL_RWops *src)
312
{
313
int start = 0;
314
SDL_Surface *image = NULL;
315
int index;
316
int x, y;
317
318
319
int w, h, ncolors, cpp;
int indexed;
Uint8 *dst;
320
struct color_hash *colors = NULL;
321
SDL_Color *im_colors = NULL;
322
323
324
325
326
char *keystrings = NULL, *nextkey;
char *line;
char ***xpmlines = NULL;
int pixels_len;
327
328
329
330
error = NULL;
linebuf = NULL;
buflen = 0;
331
332
if ( src )
start = SDL_RWtell(src);
333
334
335
336
337
338
339
if(xpm)
xpmlines = &xpm;
line = get_next_line(xpmlines, src, 0);
if(!line)
goto done;
340
341
342
343
344
345
346
347
348
/*
* The header string of an XPMv3 image has the format
*
* <width> <height> <ncolors> <cpp> [ <hotspot_x> <hotspot_y> ]
*
* where the hotspot coords are intended for mouse cursors.
* Right now we don't use the hotspots but it should be handled
* one day.
*/
349
if(sscanf(line, "%d %d %d %d", &w, &h, &ncolors, &cpp) != 4
350
|| w <= 0 || h <= 0 || ncolors <= 0 || cpp <= 0) {
351
352
error = "Invalid format description";
goto done;
353
}
354
355
356
keystrings = malloc(ncolors * cpp);
if(!keystrings) {
357
358
error = "Out of memory";
goto done;
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
}
nextkey = keystrings;
/* Create the new surface */
if(ncolors <= 256) {
indexed = 1;
image = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 8,
0, 0, 0, 0);
im_colors = image->format->palette->colors;
image->format->palette->ncolors = ncolors;
} else {
indexed = 0;
image = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32,
0xff0000, 0x00ff00, 0x0000ff, 0);
}
if(!image) {
/* Hmm, some SDL error (out of memory?) */
376
goto done;
377
}
378
379
/* Read the colors */
380
colors = create_colorhash(ncolors);
381
if (!colors) {
382
383
error = "Out of memory";
goto done;
384
}
385
for(index = 0; index < ncolors; ++index ) {
386
387
388
389
char *p;
line = get_next_line(xpmlines, src, 0);
if(!line)
goto done;
390
391
p = line + cpp + 1;
392
393
394
395
396
/* parse a colour definition */
for(;;) {
char nametype;
char *colname;
397
398
399
400
401
Uint32 rgb, pixel;
SKIPSPACE(p);
if(!*p) {
error = "colour parse error";
402
goto done;
403
}
404
405
406
407
408
nametype = *p;
SKIPNONSPACE(p);
SKIPSPACE(p);
colname = p;
SKIPNONSPACE(p);
409
410
411
if(nametype == 's')
continue; /* skip symbolic colour names */
412
if(!color_to_rgb(colname, p - colname, &rgb))
413
414
continue;
415
memcpy(nextkey, line, cpp);
416
417
if(indexed) {
SDL_Color *c = im_colors + index;
418
419
420
c->r = (Uint8)(rgb >> 16);
c->g = (Uint8)(rgb >> 8);
c->b = (Uint8)(rgb);
421
pixel = index;
422
} else
423
424
pixel = rgb;
add_colorhash(colors, nextkey, cpp, pixel);
425
426
nextkey += cpp;
if(rgb == 0xffffffff)
427
SDL_SetColorKey(image, SDL_SRCCOLORKEY, pixel);
428
break;
429
430
431
432
}
}
/* Read the pixels */
433
434
pixels_len = w * cpp;
dst = image->pixels;
435
436
for(y = 0; y < h; y++) {
line = get_next_line(xpmlines, src, pixels_len);
437
438
439
440
if(indexed) {
/* optimization for some common cases */
if(cpp == 1)
for(x = 0; x < w; x++)
441
dst[x] = (Uint8)QUICK_COLORHASH(colors,
442
line + x);
443
444
else
for(x = 0; x < w; x++)
445
dst[x] = (Uint8)get_colorhash(colors,
446
line + x * cpp,
447
448
449
450
cpp);
} else {
for (x = 0; x < w; x++)
((Uint32*)dst)[x] = get_colorhash(colors,
451
line + x * cpp,
452
453
454
cpp);
}
dst += image->pitch;
455
}
456
457
done:
458
if(error) {
459
460
if ( src )
SDL_RWseek(src, start, SEEK_SET);
461
462
463
464
if ( image ) {
SDL_FreeSurface(image);
image = NULL;
}
465
466
467
IMG_SetError(error);
}
free(keystrings);
468
free_colorhash(colors);
469
free(linebuf);
470
471
472
return(image);
}
473
474
475
/* Load a XPM type image from an RWops datasource */
SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src)
{
476
477
478
479
if ( !src ) {
/* The error message has been set in SDL_RWFromFile */
return NULL;
}
480
481
482
483
484
485
486
487
488
return load_xpm(NULL, src);
}
SDL_Surface *IMG_ReadXPMFromArray(char **xpm)
{
return load_xpm(xpm, NULL);
}
#else /* not LOAD_XPM */
489
490
491
492
493
494
495
/* See if an image is contained in a data source */
int IMG_isXPM(SDL_RWops *src)
{
return(0);
}
496
497
498
499
500
501
502
/* Load a XPM type image from an SDL datasource */
SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src)
{
return(NULL);
}
503
504
505
506
507
SDL_Surface *IMG_ReadXPMFromArray(char **xpm)
{
return NULL;
}
#endif /* not LOAD_XPM */