/
IMG_xpm.c
523 lines (470 loc) · 11.3 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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
* 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.
*/
44
45
#include <stdlib.h>
46
47
48
49
50
51
52
53
54
55
56
#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)
{
57
58
int start;
int is_XPM;
59
char magic[9];
60
61
62
if ( !src )
return 0;
63
64
65
66
67
68
69
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;
}
}
70
SDL_RWseek(src, start, RW_SEEK_SET);
71
return(is_XPM);
72
73
74
}
/* Hash table to look up colors from pixel strings */
75
76
77
78
79
80
81
82
#define STARTING_HASH_SIZE 256
struct hash_entry {
char *key;
Uint32 color;
struct hash_entry *next;
};
83
struct color_hash {
84
85
86
87
88
struct hash_entry **table;
struct hash_entry *entries; /* array of all entries */
struct hash_entry *next_free;
int size;
int maxnum;
89
90
};
91
static int hash_key(const char *key, int cpp, int size)
92
93
94
95
96
{
int hash;
hash = 0;
while ( cpp-- > 0 ) {
97
hash = hash * 33 + *key++;
98
}
99
return hash & (size - 1);
100
101
}
102
static struct color_hash *create_colorhash(int maxnum)
103
{
104
int bytes, s;
105
106
struct color_hash *hash;
107
108
/* we know how many entries we need, so we can allocate
everything here */
109
hash = (struct color_hash *)malloc(sizeof *hash);
110
111
112
113
114
115
116
117
118
119
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 */
120
121
122
hash->table = (struct hash_entry **)malloc(bytes);
if(!hash->table) {
free(hash);
123
return NULL;
124
}
125
memset(hash->table, 0, bytes);
126
hash->entries = (struct hash_entry *)malloc(maxnum * sizeof(struct hash_entry));
127
128
if(!hash->entries) {
free(hash->table);
129
free(hash);
130
return NULL;
131
}
132
133
hash->next_free = hash->entries;
return hash;
134
135
136
}
static int add_colorhash(struct color_hash *hash,
137
char *key, int cpp, Uint32 color)
138
{
139
140
141
142
143
144
145
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;
146
147
}
148
/* fast lookup that works if cpp == 1 */
149
#define QUICK_COLORHASH(hash, key) ((hash)->table[*(Uint8 *)(key)]->color)
150
151
static Uint32 get_colorhash(struct color_hash *hash, const char *key, int cpp)
152
{
153
154
155
156
157
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;
158
}
159
return 0; /* garbage in - garbage out */
160
161
162
163
}
static void free_colorhash(struct color_hash *hash)
{
164
if(hash) {
165
166
167
free(hash->table);
free(hash->entries);
free(hash);
168
169
170
}
}
171
172
173
174
175
176
177
178
179
180
181
182
183
/* 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;
}
184
#define ARRAYSIZE(a) (int)(sizeof(a) / sizeof((a)[0]))
185
186
187
/*
* convert colour spec to RGB (in 0xrrggbb format).
188
* return 1 if successful.
189
*/
190
static int color_to_rgb(char *spec, int speclen, Uint32 *rgb)
191
192
193
194
195
196
197
198
199
200
201
202
203
{
/* 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];
204
205
206
207
208
switch(speclen) {
case 4:
buf[0] = buf[1] = spec[1];
buf[2] = buf[3] = spec[2];
buf[4] = buf[5] = spec[3];
209
break;
210
211
case 7:
memcpy(buf, spec + 1, 6);
212
break;
213
214
215
216
217
218
219
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];
220
break;
221
222
223
224
225
226
227
}
buf[6] = '\0';
*rgb = strtol(buf, NULL, 16);
return 1;
} else {
int i;
for(i = 0; i < ARRAYSIZE(known); i++)
228
if(string_equal(known[i].name, spec, speclen)) {
229
230
231
232
*rgb = known[i].rgb;
return 1;
}
return 0;
233
234
235
}
}
236
237
238
#ifndef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
239
240
241
242
243
244
245
246
247
248
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.
*/
249
static char *get_next_line(char ***lines, SDL_RWops *src, int len)
250
{
251
252
char *linebufnew;
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
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;
268
linebufnew = (char *)realloc(linebuf, buflen);
269
270
if(!linebufnew) {
free(linebuf);
271
272
273
error = "Out of memory";
return NULL;
}
274
linebuf = linebufnew;
275
276
277
278
279
280
281
282
283
284
285
286
287
}
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;
288
linebufnew = (char *)realloc(linebuf, buflen);
289
290
if(!linebufnew) {
free(linebuf);
291
292
293
error = "Out of memory";
return NULL;
}
294
linebuf = linebufnew;
295
296
297
298
299
300
301
302
303
304
305
}
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;
}
306
307
}
308
309
310
311
312
#define SKIPSPACE(p) \
do { \
while(isspace((unsigned char)*(p))) \
++(p); \
} while(0)
313
314
315
316
317
318
319
320
321
#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)
322
{
323
int start = 0;
324
SDL_Surface *image = NULL;
325
int index;
326
int x, y;
327
328
329
int w, h, ncolors, cpp;
int indexed;
Uint8 *dst;
330
struct color_hash *colors = NULL;
331
SDL_Color *im_colors = NULL;
332
333
334
335
336
char *keystrings = NULL, *nextkey;
char *line;
char ***xpmlines = NULL;
int pixels_len;
337
338
339
340
error = NULL;
linebuf = NULL;
buflen = 0;
341
if ( src )
342
start = SDL_RWtell(src);
343
344
345
346
347
348
349
if(xpm)
xpmlines = &xpm;
line = get_next_line(xpmlines, src, 0);
if(!line)
goto done;
350
351
352
353
354
355
356
357
358
/*
* 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.
*/
359
if(sscanf(line, "%d %d %d %d", &w, &h, &ncolors, &cpp) != 4
360
|| w <= 0 || h <= 0 || ncolors <= 0 || cpp <= 0) {
361
362
error = "Invalid format description";
goto done;
363
}
364
365
keystrings = (char *)malloc(ncolors * cpp);
366
if(!keystrings) {
367
368
error = "Out of memory";
goto done;
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
}
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?) */
386
goto done;
387
}
388
389
/* Read the colors */
390
colors = create_colorhash(ncolors);
391
if (!colors) {
392
393
error = "Out of memory";
goto done;
394
}
395
for(index = 0; index < ncolors; ++index ) {
396
397
398
399
char *p;
line = get_next_line(xpmlines, src, 0);
if(!line)
goto done;
400
401
p = line + cpp + 1;
402
403
404
405
406
/* parse a colour definition */
for(;;) {
char nametype;
char *colname;
407
408
409
410
411
Uint32 rgb, pixel;
SKIPSPACE(p);
if(!*p) {
error = "colour parse error";
412
goto done;
413
}
414
415
416
417
418
nametype = *p;
SKIPNONSPACE(p);
SKIPSPACE(p);
colname = p;
SKIPNONSPACE(p);
419
420
421
if(nametype == 's')
continue; /* skip symbolic colour names */
422
if(!color_to_rgb(colname, p - colname, &rgb))
423
424
continue;
425
memcpy(nextkey, line, cpp);
426
427
if(indexed) {
SDL_Color *c = im_colors + index;
428
429
430
c->r = (Uint8)(rgb >> 16);
c->g = (Uint8)(rgb >> 8);
c->b = (Uint8)(rgb);
431
pixel = index;
432
} else
433
434
pixel = rgb;
add_colorhash(colors, nextkey, cpp, pixel);
435
436
nextkey += cpp;
if(rgb == 0xffffffff)
437
SDL_SetColorKey(image, SDL_SRCCOLORKEY, pixel);
438
break;
439
440
441
442
}
}
/* Read the pixels */
443
pixels_len = w * cpp;
444
dst = (Uint8 *)image->pixels;
445
446
for(y = 0; y < h; y++) {
line = get_next_line(xpmlines, src, pixels_len);
447
448
if (!line)
goto done;
449
450
451
452
if(indexed) {
/* optimization for some common cases */
if(cpp == 1)
for(x = 0; x < w; x++)
453
dst[x] = (Uint8)QUICK_COLORHASH(colors,
454
line + x);
455
456
else
for(x = 0; x < w; x++)
457
dst[x] = (Uint8)get_colorhash(colors,
458
line + x * cpp,
459
460
461
462
cpp);
} else {
for (x = 0; x < w; x++)
((Uint32*)dst)[x] = get_colorhash(colors,
463
line + x * cpp,
464
465
466
cpp);
}
dst += image->pitch;
467
}
468
469
done:
470
if(error) {
471
if ( src )
472
SDL_RWseek(src, start, RW_SEEK_SET);
473
474
475
476
if ( image ) {
SDL_FreeSurface(image);
image = NULL;
}
477
478
479
IMG_SetError(error);
}
free(keystrings);
480
free_colorhash(colors);
481
free(linebuf);
482
483
484
return(image);
}
485
486
487
/* Load a XPM type image from an RWops datasource */
SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src)
{
488
489
490
491
if ( !src ) {
/* The error message has been set in SDL_RWFromFile */
return NULL;
}
492
493
494
495
496
return load_xpm(NULL, src);
}
SDL_Surface *IMG_ReadXPMFromArray(char **xpm)
{
497
498
499
500
if ( !xpm ) {
IMG_SetError("array is NULL");
return NULL;
}
501
502
503
504
return load_xpm(xpm, NULL);
}
#else /* not LOAD_XPM */
505
506
507
508
509
510
511
/* See if an image is contained in a data source */
int IMG_isXPM(SDL_RWops *src)
{
return(0);
}
512
513
514
515
516
517
518
/* Load a XPM type image from an SDL datasource */
SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src)
{
return(NULL);
}
519
520
521
522
523
SDL_Surface *IMG_ReadXPMFromArray(char **xpm)
{
return NULL;
}
#endif /* not LOAD_XPM */