| 0,0 → 1,462 |
|---|
| /* |
| IMGLIB: An example image loading library for use with SDL |
| Copyright (C) 1999 Sam Lantinga |
| |
| 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 |
| 5635-34 Springhouse Dr. |
| Pleasanton, CA 94588 (USA) |
| slouken@devolution.com |
| */ |
| |
| /* This is an XPM image file loading framework */ |
| |
| #include <stdlib.h> |
| #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) |
| { |
| int is_XPM; |
| char magic[10]; |
| |
| is_XPM = 0; |
| if ( SDL_RWread(src, magic, sizeof(magic), 1) ) { |
| if(memcmp(magic, "/* XPM */", 9) == 0) { |
| is_XPM = 1; |
| } |
| } |
| return(is_XPM); |
| } |
| |
| static char *SDL_RWgets(char *string, int maxlen, SDL_RWops *src) |
| { |
| int i; |
| |
| for ( i=0; i<(maxlen-1); ++i ) { |
| if ( SDL_RWread(src, &string[i], 1, 1) <= 0 ) { |
| /* EOF or error */ |
| if ( i == 0 ) { |
| /* Hmm, EOF on initial read, return NULL */ |
| return NULL; |
| } |
| break; |
| } |
| /* In this case it's okay to use either '\r' or '\n' |
| as line separators because blank lines are just |
| ignored by the XPM format. |
| */ |
| if ( (string[i] == '\n') || (string[i] == '\r') ) { |
| break; |
| } |
| } |
| string[i] = '\0'; |
| return(string); |
| } |
| |
| /* Hash table to look up colors from pixel strings */ |
| #define STARTING_HASH_SIZE 256 |
| |
| struct hash_entry { |
| char *key; |
| Uint32 color; |
| struct hash_entry *next; |
| }; |
| |
| struct color_hash { |
| struct hash_entry **table; |
| struct hash_entry *entries; /* array of all entries */ |
| struct hash_entry *next_free; |
| int size; |
| int maxnum; |
| }; |
| |
| static int hash_key(const char *key, int cpp, int size) |
| { |
| int hash; |
| |
| hash = 0; |
| while ( cpp-- > 0 ) { |
| hash = hash * 33 + *key++; |
| } |
| return hash & (size - 1); |
| } |
| |
| static struct color_hash *create_colorhash(int maxnum) |
| { |
| int bytes, s; |
| struct color_hash *hash; |
| |
| /* 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; |
| } |
| |
| static int add_colorhash(struct color_hash *hash, |
| char *key, int cpp, Uint32 color) |
| { |
| 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; |
| } |
| |
| /* fast lookup that works if cpp == 1 */ |
| #define QUICK_COLORHASH(hash, key) ((hash)->table[*(Uint8 *)(key)]->color) |
| |
| static Uint32 get_colorhash(struct color_hash *hash, const char *key, int cpp) |
| { |
| 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; |
| } |
| return 0; /* garbage in - garbage out */ |
| } |
| |
| static void free_colorhash(struct color_hash *hash) |
| { |
| if(hash && hash->table) { |
| free(hash->table); |
| free(hash->entries); |
| free(hash); |
| } |
| } |
| |
| #define ARRAYSIZE(a) (int)(sizeof(a) / sizeof((a)[0])) |
| |
| /* |
| * convert colour spec to RGB (in 0xrrggbb format). |
| * return 1 if successful. may scribble on the colorspec buffer. |
| */ |
| static int color_to_rgb(char *spec, Uint32 *rgb) |
| { |
| /* 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]; |
| ++spec; |
| switch(strlen(spec)) { |
| case 3: |
| buf[0] = buf[1] = spec[0]; |
| buf[2] = buf[3] = spec[1]; |
| buf[4] = buf[5] = spec[2]; |
| break; |
| case 6: |
| memcpy(buf, spec, 6); |
| break; |
| case 12: |
| buf[0] = spec[0]; |
| buf[1] = spec[1]; |
| buf[2] = spec[4]; |
| buf[3] = spec[5]; |
| buf[4] = spec[8]; |
| buf[5] = spec[9]; |
| break; |
| } |
| buf[6] = '\0'; |
| *rgb = strtol(buf, NULL, 16); |
| return 1; |
| } else { |
| int i; |
| for(i = 0; i < ARRAYSIZE(known); i++) |
| if(IMG_string_equals(known[i].name, spec)) { |
| *rgb = known[i].rgb; |
| return 1; |
| } |
| return 0; |
| } |
| } |
| |
| static char *skipspace(char *p) |
| { |
| while(isspace((unsigned char)*p)) |
| ++p; |
| return p; |
| } |
| |
| static char *skipnonspace(char *p) |
| { |
| while(!isspace((unsigned char)*p) && *p) |
| ++p; |
| return p; |
| } |
| |
| #ifndef MAX |
| #define MAX(a, b) ((a) > (b) ? (a) : (b)) |
| #endif |
| |
| /* Load a XPM type image from an SDL datasource */ |
| SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src) |
| { |
| SDL_Surface *image; |
| char line[1024]; |
| char *here; |
| int index; |
| int x, y; |
| int w, h, ncolors, cpp; |
| int pixels_len; |
| char *pixels = NULL; |
| int indexed; |
| Uint8 *dst; |
| struct color_hash *colors; |
| SDL_Color *im_colors = NULL; |
| char *keystrings, *nextkey; |
| char *error = NULL; |
| |
| /* Skip to the first string, which describes the image */ |
| do { |
| here = SDL_RWgets(line, sizeof(line), src); |
| if ( !here ) { |
| IMG_SetError("Premature end of data"); |
| return(NULL); |
| } |
| here = skipspace(here); |
| } while(*here != '"'); |
| /* |
| * 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. |
| */ |
| if(sscanf(here + 1, "%d %d %d %d", &w, &h, &ncolors, &cpp) != 4 |
| || w <= 0 || h <= 0 || ncolors <= 0 || cpp <= 0) { |
| IMG_SetError("Invalid format description"); |
| return(NULL); |
| } |
| |
| keystrings = malloc(ncolors * cpp); |
| if(!keystrings) { |
| IMG_SetError("Out of memory"); |
| free(pixels); |
| return NULL; |
| } |
| 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?) */ |
| free(pixels); |
| return(NULL); |
| } |
| |
| /* Read the colors */ |
| colors = create_colorhash(ncolors); |
| if ( ! colors ) { |
| error = "Out of memory"; |
| goto done; |
| } |
| for(index = 0; index < ncolors; ++index ) { |
| char *key; |
| int len; |
| |
| do { |
| here = SDL_RWgets(line, sizeof(line), src); |
| if(!here) { |
| error = "Premature end of data"; |
| goto done; |
| } |
| here = skipspace(here); |
| } while(*here != '"'); |
| |
| ++here; |
| len = strlen(here); |
| if(len < cpp + 7) |
| continue; /* cannot be a valid line */ |
| |
| key = here; |
| key[cpp] = '\0'; |
| here += cpp + 1; |
| |
| /* parse a colour definition */ |
| for(;;) { |
| char nametype; |
| char *colname; |
| char delim; |
| Uint32 rgb; |
| |
| here = skipspace(here); |
| nametype = *here; |
| here = skipnonspace(here); |
| here = skipspace(here); |
| colname = here; |
| while(*here && !isspace((unsigned char)*here) |
| && *here != '"') |
| here++; |
| if(!*here) { |
| error = "color parse error"; |
| goto done; |
| } |
| if(nametype == 's') |
| continue; /* skip symbolic colour names */ |
| |
| delim = *here; |
| *here = '\0'; |
| if(delim) |
| here++; |
| |
| if(!color_to_rgb(colname, &rgb)) |
| continue; |
| |
| memcpy(nextkey, key, cpp); |
| if(indexed) { |
| SDL_Color *c = im_colors + index; |
| c->r = rgb >> 16; |
| c->g = rgb >> 8; |
| c->b = rgb; |
| add_colorhash(colors, nextkey, cpp, index); |
| } else |
| add_colorhash(colors, nextkey, cpp, rgb); |
| nextkey += cpp; |
| if(rgb == 0xffffffff) |
| SDL_SetColorKey(image, SDL_SRCCOLORKEY, |
| indexed ? index : rgb); |
| break; |
| } |
| } |
| |
| /* Read the pixels */ |
| pixels_len = w * cpp; |
| pixels = malloc(MAX(pixels_len + 5, 20)); |
| if(!pixels) { |
| error = "Out of memory"; |
| goto done; |
| } |
| dst = image->pixels; |
| for (y = 0; y < h; ) { |
| char *s; |
| char c; |
| do { |
| if(SDL_RWread(src, &c, 1, 1) <= 0) { |
| error = "Premature end of data"; |
| goto done; |
| } |
| } while(c == ' '); |
| if(c != '"') { |
| /* comment or empty line, skip it */ |
| while(c != '\n' && c != '\r') { |
| if(SDL_RWread(src, &c, 1, 1) <= 0) { |
| error = "Premature end of data"; |
| goto done; |
| } |
| } |
| continue; |
| } |
| if(SDL_RWread(src, pixels, pixels_len + 3, 1) <= 0) { |
| error = "Premature end of data"; |
| goto done; |
| } |
| s = pixels; |
| if(indexed) { |
| /* optimization for some common cases */ |
| if(cpp == 1) |
| for(x = 0; x < w; x++) |
| dst[x] = QUICK_COLORHASH(colors, |
| s + x); |
| else |
| for(x = 0; x < w; x++) |
| dst[x] = get_colorhash(colors, |
| s + x * cpp, |
| cpp); |
| } else { |
| for (x = 0; x < w; x++) |
| ((Uint32*)dst)[x] = get_colorhash(colors, |
| s + x * cpp, |
| cpp); |
| } |
| dst += image->pitch; |
| y++; |
| } |
| |
| done: |
| if(error) { |
| if(image) |
| SDL_FreeSurface(image); |
| image = NULL; |
| IMG_SetError(error); |
| } |
| free(pixels); |
| free(keystrings); |
| free_colorhash(colors); |
| return(image); |
| } |
| |
| #else |
| |
| /* See if an image is contained in a data source */ |
| int IMG_isXPM(SDL_RWops *src) |
| { |
| return(0); |
| } |
| |
| /* Load a XPM type image from an SDL datasource */ |
| SDL_Surface *IMG_LoadXPM_RW(SDL_RWops *src) |
| { |
| return(NULL); |
| } |
| |
| #endif /* LOAD_XPM */ |