/*    SDL_image:  An example image loading library for use with SDL    Copyright (C) 1997-2006 Sam Lantinga    This library is free software; you can redistribute it and/or    modify it under the terms of the GNU Lesser General Public    License as published by the Free Software Foundation; either    version 2.1 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    Lesser General Public License for more details.    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    Sam Lantinga    slouken@libsdl.org*//* This is a XCF image file loading framework */#include <stdio.h>#include <ctype.h>#include <string.h>#include <stdlib.h>#include "SDL_endian.h"#include "SDL_image.h"#ifdef LOAD_XCF#if DEBUGstatic char prop_names [][30] = {  "end",  "colormap",  "active_layer",  "active_channel",  "selection",  "floating_selection",  "opacity",  "mode",  "visible",  "linked",  "preserve_transparency",  "apply_mask",  "edit_mask",  "show_mask",  "show_masked",  "offsets",  "color",  "compression",  "guides",  "resolution",  "tattoo",  "parasites",  "unit",  "paths",  "user_unit"};#endiftypedef enum{  PROP_END = 0,  PROP_COLORMAP = 1,  PROP_ACTIVE_LAYER = 2,  PROP_ACTIVE_CHANNEL = 3,  PROP_SELECTION = 4,  PROP_FLOATING_SELECTION = 5,  PROP_OPACITY = 6,  PROP_MODE = 7,  PROP_VISIBLE = 8,  PROP_LINKED = 9,  PROP_PRESERVE_TRANSPARENCY = 10,  PROP_APPLY_MASK = 11,  PROP_EDIT_MASK = 12,  PROP_SHOW_MASK = 13,  PROP_SHOW_MASKED = 14,  PROP_OFFSETS = 15,  PROP_COLOR = 16,  PROP_COMPRESSION = 17,  PROP_GUIDES = 18,  PROP_RESOLUTION = 19,  PROP_TATTOO = 20,  PROP_PARASITES = 21,  PROP_UNIT = 22,  PROP_PATHS = 23,  PROP_USER_UNIT = 24} xcf_prop_type;typedef enum {  COMPR_NONE    = 0,  COMPR_RLE     = 1,  COMPR_ZLIB    = 2,  COMPR_FRACTAL = 3} xcf_compr_type;typedef enum {  IMAGE_RGB       = 0,  IMAGE_GREYSCALE = 1,  IMAGE_INDEXED   = 2} xcf_image_type;typedef struct {  Uint32 id;  Uint32 length;  union {    struct {      Uint32 num;      char * cmap;    } colormap; // 1    struct {      Uint32 drawable_offset;    } floating_selection; // 5    Sint32 opacity;    Sint32 mode;    int    visible;    int    linked;    int    preserve_transparency;    int    apply_mask;    int    show_mask;    struct {      Sint32 x;      Sint32 y;    } offset;    unsigned char color [3];    Uint8 compression;    struct {      Sint32 x;      Sint32 y;    } resolution;    struct {      char * name;      Uint32 flags;      Uint32 size;      char * data;    } parasite;  } data;} xcf_prop;typedef struct {  char   sign [14];  Uint32 width;  Uint32 height;  Sint32 image_type;  xcf_prop * properties;  Uint32 * layer_file_offsets;  Uint32 * channel_file_offsets;  xcf_compr_type compr;  Uint32         cm_num;  unsigned char * cm_map;} xcf_header;typedef struct {  Uint32 width;  Uint32 height;  Sint32 layer_type;  char * name;  xcf_prop * properties;  Uint32 hierarchy_file_offset;  Uint32 layer_mask_offset;  Uint32 offset_x;  Uint32 offset_y;  int visible;} xcf_layer;typedef struct {  Uint32 width;  Uint32 height;  char * name;  xcf_prop * properties;  Uint32 hierarchy_file_offset;  Uint32 color;  Uint32 opacity;  int selection;  int visible;} xcf_channel;typedef struct {  Uint32 width;  Uint32 height;  Uint32 bpp;  Uint32 * level_file_offsets;} xcf_hierarchy;typedef struct {  Uint32 width;  Uint32 height;  Uint32 * tile_file_offsets;} xcf_level;typedef unsigned char * xcf_tile;typedef unsigned char * (* load_tile_type) (SDL_RWops *, Uint32, int, int, int);/* See if an image is contained in a data source */int IMG_isXCF(SDL_RWops *src){	int start;	int is_XCF;	char magic[14];	if ( !src )		return 0;	start = SDL_RWtell(src);	is_XCF = 0;	if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {		if (strncmp(magic, "gimp xcf ", 9) == 0) {			is_XCF = 1;		}	}	SDL_RWseek(src, start, SEEK_SET);	return(is_XCF);}static char * read_string (SDL_RWops * src) {  Uint32 tmp;  char * data;  tmp = SDL_ReadBE32 (src);  if (tmp > 0) {    data = (char *) malloc (sizeof (char) * tmp);    SDL_RWread (src, data, tmp, 1);  }  else {    data = NULL;  }  return data;}static Uint32 Swap32 (Uint32 v) {  return    ((v & 0x000000FF) << 16)    |  ((v & 0x0000FF00))    |  ((v & 0x00FF0000) >> 16)    |  ((v & 0xFF000000));}void xcf_read_property (SDL_RWops * src, xcf_prop * prop) {  prop->id = SDL_ReadBE32 (src);  prop->length = SDL_ReadBE32 (src);#if DEBUG  printf ("%.8X: %s: %d\n", SDL_RWtell (src), prop->id < 25 ? prop_names [prop->id] : "unknown", prop->length);#endif  switch (prop->id) {  case PROP_COLORMAP:    prop->data.colormap.num = SDL_ReadBE32 (src);    prop->data.colormap.cmap = (char *) malloc (sizeof (char) * prop->data.colormap.num * 3);    SDL_RWread (src, prop->data.colormap.cmap, prop->data.colormap.num*3, 1);    break;  case PROP_OFFSETS:    prop->data.offset.x = SDL_ReadBE32 (src);    prop->data.offset.y = SDL_ReadBE32 (src);    break;  case PROP_OPACITY:    prop->data.opacity = SDL_ReadBE32 (src);    break;  case PROP_COMPRESSION:  case PROP_COLOR:    SDL_RWread (src, &prop->data, prop->length, 1);    break;  case PROP_VISIBLE:    prop->data.visible = SDL_ReadBE32 (src);    break;  default:    //    SDL_RWread (src, &prop->data, prop->length, 1);    SDL_RWseek (src, prop->length, SEEK_CUR);  }}void free_xcf_header (xcf_header * h) {  if (h->cm_num)    free (h->cm_map);  free (h);}xcf_header * read_xcf_header (SDL_RWops * src) {  xcf_header * h;  xcf_prop prop;  h = (xcf_header *) malloc (sizeof (xcf_header));  SDL_RWread (src, h->sign, 14, 1);  h->width       = SDL_ReadBE32 (src);  h->height      = SDL_ReadBE32 (src);  h->image_type  = SDL_ReadBE32 (src);  h->properties = NULL;  h->compr      = COMPR_NONE;  h->cm_num = 0;  h->cm_map = NULL;  // Just read, don't save  do {    xcf_read_property (src, &prop);    if (prop.id == PROP_COMPRESSION)      h->compr = prop.data.compression;    else if (prop.id == PROP_COLORMAP) {      // unused var: int i;      h->cm_num = prop.data.colormap.num;      h->cm_map = (unsigned char *) malloc (sizeof (unsigned char) * 3 * h->cm_num);      memcpy (h->cm_map, prop.data.colormap.cmap, 3*sizeof (char)*h->cm_num);      free (prop.data.colormap.cmap);    }  } while (prop.id != PROP_END);  return h;}void free_xcf_layer (xcf_layer * l) {  free (l->name);  free (l);}xcf_layer * read_xcf_layer (SDL_RWops * src) {  xcf_layer * l;  xcf_prop    prop;  l = (xcf_layer *) malloc (sizeof (xcf_layer));  l->width  = SDL_ReadBE32 (src);  l->height = SDL_ReadBE32 (src);  l->layer_type = SDL_ReadBE32 (src);  l->name = read_string (src);  do {    xcf_read_property (src, &prop);    if (prop.id == PROP_OFFSETS) {      l->offset_x = prop.data.offset.x;      l->offset_y = prop.data.offset.y;    } else if (prop.id == PROP_VISIBLE) {      l->visible = prop.data.visible ? 1 : 0;    }  } while (prop.id != PROP_END);  l->hierarchy_file_offset = SDL_ReadBE32 (src);  l->layer_mask_offset     = SDL_ReadBE32 (src);  return l;}void free_xcf_channel (xcf_channel * c) {  free (c->name);  free (c);}xcf_channel * read_xcf_channel (SDL_RWops * src) {  xcf_channel * l;  xcf_prop    prop;  l = (xcf_channel *) malloc (sizeof (xcf_channel));  l->width  = SDL_ReadBE32 (src);  l->height = SDL_ReadBE32 (src);  l->name = read_string (src);  l->selection = 0;  do {    xcf_read_property (src, &prop);    switch (prop.id) {    case PROP_OPACITY:      l->opacity = prop.data.opacity << 24;      break;    case PROP_COLOR:      l->color = ((Uint32) prop.data.color[0] << 16)	| ((Uint32) prop.data.color[1] << 8)	| ((Uint32) prop.data.color[2]);      break;    case PROP_SELECTION:      l->selection = 1;      break;    case PROP_VISIBLE:      l->visible = prop.data.visible ? 1 : 0;      break;    default:        ;    }  } while (prop.id != PROP_END);  l->hierarchy_file_offset = SDL_ReadBE32 (src);  return l;}void free_xcf_hierarchy (xcf_hierarchy * h) {  free (h->level_file_offsets);  free (h);}xcf_hierarchy * read_xcf_hierarchy (SDL_RWops * src) {  xcf_hierarchy * h;  int i;  h = (xcf_hierarchy *) malloc (sizeof (xcf_hierarchy));