/
IMG_xpm.c
505 lines (451 loc) · 10.8 KB
1
/*
2
SDL_image: An example image loading library for use with SDL
3
Copyright (C) 1999-2004 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
20
slouken@libsdl.org
21
22
*/
23
24
/* $Id$ */
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/*
* 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.
*/
47
48
#include <stdlib.h>
49
50
51
52
53
54
55
56
57
58
59
#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)
{
60
61
int start;
int is_XPM;
62
char magic[9];
63
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;
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
start = SDL_RWtell(src);
333
334
335
336
337
338
if(xpm)
xpmlines = &xpm;
line = get_next_line(xpmlines, src, 0);
if(!line)
goto done;
339
340
341
342
343
344
345
346
347
/*
* 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.
*/
348
if(sscanf(line, "%d %d %d %d", &w, &h, &ncolors, &cpp) != 4
349
|| w <= 0 || h <= 0 || ncolors <= 0 || cpp <= 0) {
350
351
error = "Invalid format description";
goto done;
352
}
353
354
355
keystrings = malloc(ncolors * cpp);
if(!keystrings) {
356
357
error = "Out of memory";
goto done;
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
}
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?) */
375
goto done;
376
}
377
378
/* Read the colors */
379
colors = create_colorhash(ncolors);
380
if (!colors) {
381
382
error = "Out of memory";
goto done;
383
}
384
for(index = 0; index < ncolors; ++index ) {
385
386
387
388
char *p;
line = get_next_line(xpmlines, src, 0);
if(!line)
goto done;
389
390
p = line + cpp + 1;
391
392
393
394
395
/* parse a colour definition */
for(;;) {
char nametype;
char *colname;
396
397
398
399
400
Uint32 rgb, pixel;
SKIPSPACE(p);
if(!*p) {
error = "colour parse error";
401
goto done;
402
}
403
404
405
406
407
nametype = *p;
SKIPNONSPACE(p);
SKIPSPACE(p);
colname = p;
SKIPNONSPACE(p);
408
409
410
if(nametype == 's')
continue; /* skip symbolic colour names */
411
if(!color_to_rgb(colname, p - colname, &rgb))
412
413
continue;
414
memcpy(nextkey, line, cpp);
415
416
417
418
419
if(indexed) {
SDL_Color *c = im_colors + index;
c->r = rgb >> 16;
c->g = rgb >> 8;
c->b = rgb;
420
pixel = index;
421
} else
422
423
pixel = rgb;
add_colorhash(colors, nextkey, cpp, pixel);
424
425
nextkey += cpp;
if(rgb == 0xffffffff)
426
SDL_SetColorKey(image, SDL_SRCCOLORKEY, pixel);
427
break;
428
429
430
431
}
}
/* Read the pixels */
432
433
pixels_len = w * cpp;
dst = image->pixels;
434
435
for(y = 0; y < h; y++) {
line = get_next_line(xpmlines, src, pixels_len);
436
437
438
439
440
if(indexed) {
/* optimization for some common cases */
if(cpp == 1)
for(x = 0; x < w; x++)
dst[x] = QUICK_COLORHASH(colors,
441
line + x);
442
443
444
else
for(x = 0; x < w; x++)
dst[x] = get_colorhash(colors,
445
line + x * cpp,
446
447
448
449
cpp);
} else {
for (x = 0; x < w; x++)
((Uint32*)dst)[x] = get_colorhash(colors,
450
line + x * cpp,
451
452
453
cpp);
}
dst += image->pitch;
454
}
455
456
done:
457
if(error) {
458
459
460
461
462
SDL_RWseek(src, start, SEEK_SET);
if ( image ) {
SDL_FreeSurface(image);
image = NULL;
}
463
464
465
IMG_SetError(error);
}
free(keystrings);
466
free_colorhash(colors);
467
free(linebuf);
468
469
470
return(image);
}
471
472
473
/* Load a XPM type image from an RWops datasource */
SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src)
{
474
475
476
477
if ( !src ) {
/* The error message has been set in SDL_RWFromFile */
return NULL;
}
478
479
480
481
482
483
484
485
486
return load_xpm(NULL, src);
}
SDL_Surface *IMG_ReadXPMFromArray(char **xpm)
{
return load_xpm(xpm, NULL);
}
#else /* not LOAD_XPM */
487
488
489
490
491
492
493
/* See if an image is contained in a data source */
int IMG_isXPM(SDL_RWops *src)
{
return(0);
}
494
495
496
497
498
499
500
/* Load a XPM type image from an SDL datasource */
SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src)
{
return(NULL);
}
501
502
503
504
505
SDL_Surface *IMG_ReadXPMFromArray(char **xpm)
{
return NULL;
}
#endif /* not LOAD_XPM */