files/Source/FreeImage/PluginXPM.cpp - free_image - Git at Google

 // ==========================================================
 // XPM Loader and Writer
 //
 // Design and implementation by
 // - Ryan Rubley (ryan@lostreality.org)
 //
 // COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
 // OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
 // THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
 // OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
 // CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
 // THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
 // SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
 // PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
 // THIS DISCLAIMER.
 //
 // Use at your own risk!
 // ==========================================================

 #ifdef _MSC_VER
 #pragma warning (disable : 4786) // identifier was truncated to 'number' characters
 #endif

 // IMPLEMENTATION NOTES:
 // ------------------------
 // Initial design and implementation by
 // - Karl-Heinz Bussian (khbussian@moss.de)
 // - Hervé Drolon (drolon@infonie.fr)
 // Completely rewritten from scratch by Ryan Rubley (ryan@lostreality.org)
 // in order to address the following major fixes:
 // * Supports any number of chars per pixel (not just 1 or 2)
 // * Files with 2 chars per pixel but <= 256colors are loaded as 256 color (not 24bit)
 // * Loads much faster, uses much less memory
 // * supports #rgb #rrrgggbbb and #rrrrggggbbbb colors (not just #rrggbb)
 // * supports symbolic color names
 // ==========================================================

 #include "FreeImage.h"
 #include "Utilities.h"

 // ==========================================================
 // Plugin Interface
 // ==========================================================
 static int s_format_id;

 // ==========================================================
 // Internal Functions
 // ==========================================================

 // read in and skip all junk until we find a certain char
 static BOOL
 FindChar(FreeImageIO *io, fi_handle handle, BYTE look_for) {
 	BYTE c = '\0';
 	io->read_proc(&c, sizeof(BYTE), 1, handle);
 	while(c != look_for) {
 		if( io->read_proc(&c, sizeof(BYTE), 1, handle) != 1 )
 			return FALSE;
 	}
 	return TRUE;
 }

 // find start of string, read data until ending quote found, allocate memory and return a string
 static char *
 ReadString(FreeImageIO *io, fi_handle handle) {
 	if( !FindChar(io, handle,'"') )
 		return NULL;
 	BYTE c;
 	std::string s;
 	io->read_proc(&c, sizeof(BYTE), 1, handle);
 	while(c != '"') {
 		s += c;
 		if( io->read_proc(&c, sizeof(BYTE), 1, handle) != 1 )
 			return NULL;
 	}
 	char *cstr = (char *)malloc(s.length()+1);
 	strcpy(cstr,s.c_str());
 	return cstr;
 }

 static char *
 Base92(unsigned int num) {
 	static char b92[16]; //enough for more then 64 bits
 	static char digit[] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}|";
 	b92[15] = '\0';
 	int i = 14;
 	do {
 		b92[i--] = digit[num % 92];
 		num /= 92;
 	} while( num && i >= 0 );
 	return b92+i+1;
 }

 // ==========================================================
 // Plugin Implementation
 // ==========================================================

 static const char * DLL_CALLCONV
 Format() {
 	return "XPM";
 }

 static const char * DLL_CALLCONV
 Description() {
 	return "X11 Pixmap Format";
 }

 static const char * DLL_CALLCONV
 Extension() {
 	return "xpm";
 }

 static const char * DLL_CALLCONV
 RegExpr() {
 	return "^[ \\t]*/\\* XPM \\*/[ \\t]$";
 }

 static const char * DLL_CALLCONV
 MimeType() {
 	return "image/x-xpixmap";
 }

 static BOOL DLL_CALLCONV
 Validate(FreeImageIO *io, fi_handle handle) {
 	char buffer[256];

 	// checks the first 256 characters for the magic string
 	int count = io->read_proc(buffer, 1, 256, handle);
 	if(count <= 9) return FALSE;
 	for(int i = 0; i < (count - 9); i++) {
 		if(strncmp(&buffer[i], "/* XPM */", 9) == 0)
 			return TRUE;
 	}
 	return FALSE;
 }

 static BOOL DLL_CALLCONV
 SupportsExportDepth(int depth) {
 	return (
 			(depth == 8) ||
 			(depth == 24)
 		);
 }

 static BOOL DLL_CALLCONV
 SupportsExportType(FREE_IMAGE_TYPE type) {
 	return (type == FIT_BITMAP) ? TRUE : FALSE;
 }

 static BOOL DLL_CALLCONV
 SupportsNoPixels() {
 	return TRUE;
 }

 // ----------------------------------------------------------

 static FIBITMAP * DLL_CALLCONV
 Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
 	char msg[256];
     FIBITMAP *dib = NULL;

     if (!handle) return NULL;

     try {
 		char *str;

 		BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;

 		//find the starting brace
 		if( !FindChar(io, handle,'{') )
 			throw "Could not find starting brace";

 		//read info string
 		str = ReadString(io, handle);
 		if(!str)
 			throw "Error reading info string";

 		int width, height, colors, cpp;
 		if( sscanf(str, "%d %d %d %d", &width, &height, &colors, &cpp) != 4 ) {
 			free(str);
 			throw "Improperly formed info string";
 		}
 		free(str);

         if (colors > 256) {
 			dib = FreeImage_AllocateHeader(header_only, width, height, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
 		} else {
 			dib = FreeImage_AllocateHeader(header_only, width, height, 8);
 		}

 		//build a map of color chars to rgb values
 		std::map<std::string,FILE_RGBA> rawpal; //will store index in Alpha if 8bpp
 		for(int i = 0; i < colors; i++ ) {
 			FILE_RGBA rgba;

 			str = ReadString(io, handle);
 			if(!str)
 				throw "Error reading color strings";

 			std::string chrs(str,cpp); //create a string for the color chars using the first cpp chars
 			char *keys = str + cpp; //the color keys for these chars start after the first cpp chars

 			//translate all the tabs to spaces
 			char *tmp = keys;
 			while( strchr(tmp,'\t') ) {
 				tmp = strchr(tmp,'\t');
 				*tmp++ = ' ';
 			}

 			//prefer the color visual
 			if( strstr(keys," c ") ) {
 				char *clr = strstr(keys," c ") + 3;
 				while( *clr == ' ' ) clr++; //find the start of the hex rgb value
 				if( *clr == '#' ) {
 					int red = 0, green = 0, blue = 0, n;
 					clr++;
 					//end string at first space, if any found
 					if( strchr(clr,' ') )
 						*(strchr(clr,' ')) = '\0';
 					//parse hex color, it can be #rgb #rrggbb #rrrgggbbb or #rrrrggggbbbb
 					switch( strlen(clr) ) {
 						case 3:	n = sscanf(clr,"%01x%01x%01x",&red,&green,&blue);
 							red |= (red << 4);
 							green |= (green << 4);
 							blue |= (blue << 4);
 							break;
 						case 6:	n = sscanf(clr,"%02x%02x%02x",&red,&green,&blue);
 							break;
 						case 9:	n = sscanf(clr,"%03x%03x%03x",&red,&green,&blue);
 							red >>= 4;
 							green >>= 4;
 							blue >>= 4;
 							break;
 						case 12: n = sscanf(clr,"%04x%04x%04x",&red,&green,&blue);
 							red >>= 8;
 							green >>= 8;
 							blue >>= 8;
 							break;
 						default:
 							n = 0;
 							break;
 					}
 					if( n != 3 ) {
 						free(str);
 						throw "Improperly formed hex color value";
 					}
 					rgba.r = (BYTE)red;
 					rgba.g = (BYTE)green;
 					rgba.b = (BYTE)blue;
 				} else if( !strncmp(clr,"None",4) || !strncmp(clr,"none",4) ) {
 					rgba.r = rgba.g = rgba.b = 0xFF;
 				} else {
 					char *tmp = clr;

 					//scan forward for each space, if its " x " or " xx " end the string there
 					//this means its probably some other visual data beyond that point and not
 					//part of the color name.  How many named color end with a 1 or 2 character
 					//word? Probably none in our list at least.
 					while( (tmp = strchr(tmp,' ')) != NULL ) {
 						if( tmp[1] != ' ' ) {
 							if( (tmp[2] == ' ') || (tmp[2] != ' ' && tmp[3] == ' ') ) {
 								tmp[0] = '\0';
 								break;
 							}
 						}
 						tmp++;
 					}

 					//remove any trailing spaces
 					tmp = clr+strlen(clr)-1;
 					while( *tmp == ' ' ) {
 						*tmp = '\0';
 						tmp--;
 					}

 					if (!FreeImage_LookupX11Color(clr,  &rgba.r, &rgba.g, &rgba.b)) {
 						sprintf(msg, "Unknown color name '%s'", str);
 						free(str);
 						throw msg;
 					}
 				}
 			} else {
 				free(str);
 				throw "Only color visuals are supported";
 			}

 			//add color to map
 			rgba.a = (BYTE)((colors > 256) ? 0 : i);
 			rawpal[chrs] = rgba;

 			//build palette if needed
 			if( colors <= 256 ) {
 				RGBQUAD *pal = FreeImage_GetPalette(dib);
 				pal[i].rgbBlue = rgba.b;
 				pal[i].rgbGreen = rgba.g;
 				pal[i].rgbRed = rgba.r;
 			}

 			free(str);
 		}
 		//done parsing color map

 		if(header_only) {
 			// header only mode
 			return dib;
 		}

 		//read in pixel data
 		for(int y = 0; y < height; y++ ) {
 			BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);
 			str = ReadString(io, handle);
 			if(!str)
 				throw "Error reading pixel strings";
 			char *pixel_ptr = str;

 			for(int x = 0; x < width; x++ ) {
 				//locate the chars in the color map
 				std::string chrs(pixel_ptr,cpp);
 				FILE_RGBA rgba = rawpal[chrs];

 				if( colors > 256 ) {
 					line[FI_RGBA_BLUE] = rgba.b;
 					line[FI_RGBA_GREEN] = rgba.g;
 					line[FI_RGBA_RED] = rgba.r;
 					line += 3;
 				} else {
 					*line = rgba.a;
 					line++;
 				}

 				pixel_ptr += cpp;
 			}

 			free(str);
 		}
 		//done reading pixel data

 		return dib;
 	} catch(const char *text) {
        FreeImage_OutputMessageProc(s_format_id, text);

        if( dib != NULL )
            FreeImage_Unload(dib);

        return NULL;
     }
 }

 static BOOL DLL_CALLCONV
 Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
 	if ((dib != NULL) && (handle != NULL)) {
 		char header[] = "/* XPM */\nstatic char *freeimage[] = {\n/* width height num_colors chars_per_pixel */\n\"",
 		start_colors[] = "\",\n/* colors */\n\"",
 		start_pixels[] = "\",\n/* pixels */\n\"",
 		new_line[] = "\",\n\"",
 		footer[] = "\"\n};\n",
 		buf[256]; //256 is more then enough to sprintf 4 ints into, or the base-92 chars and #rrggbb line

 		if( io->write_proc(header, (unsigned int)strlen(header), 1, handle) != 1 )
 			return FALSE;

 		int width = FreeImage_GetWidth(dib), height = FreeImage_GetHeight(dib), bpp = FreeImage_GetBPP(dib);
 		RGBQUAD *pal = FreeImage_GetPalette(dib);
 		int x,y;

 		//map base92 chrs to the rgb value to create the palette
 		std::map<DWORD,FILE_RGB> chrs2color;
 		//map 8bpp index or 24bpp rgb value to the base92 chrs to create pixel data
 		typedef union {
 			DWORD index;
 			FILE_RGBA rgba;
 		} DWORDRGBA;
 		std::map<DWORD,std::string> color2chrs;

 		//loop thru entire dib, if new color, inc num_colors and add to both maps
 		int num_colors = 0;
 		for(y = 0; y < height; y++ ) {
 			BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);
 			for(x = 0; x < width; x++ ) {
 				FILE_RGB rgb;
 				DWORDRGBA u;
 				if( bpp > 8 ) {
 					u.rgba.b = rgb.b = line[FI_RGBA_BLUE];
 					u.rgba.g = rgb.g = line[FI_RGBA_GREEN];
 					u.rgba.r = rgb.r = line[FI_RGBA_RED];
 					u.rgba.a = 0;
 					line += 3;
 				} else {
 					u.index = *line;
 					rgb.b = pal[u.index].rgbBlue;
 					rgb.g = pal[u.index].rgbGreen;
 					rgb.r = pal[u.index].rgbRed;
 					line++;
 				}
 				if( color2chrs.find(u.index) == color2chrs.end() ) { //new color
 					std::string chrs(Base92(num_colors));
 					color2chrs[u.index] = chrs;
 					chrs2color[num_colors] = rgb;
 					num_colors++;
 				}
 			}
 		}

 		int cpp = (int)(log((double)num_colors)/log(92.0)) + 1;

 		sprintf(buf, "%d %d %d %d", FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), num_colors, cpp );
 		if( io->write_proc(buf, (unsigned int)strlen(buf), 1, handle) != 1 )
 			return FALSE;

 		if( io->write_proc(start_colors, (unsigned int)strlen(start_colors), 1, handle) != 1 )
 			return FALSE;

 		//write colors, using map of chrs->rgb
 		for(x = 0; x < num_colors; x++ ) {
 			sprintf(buf, "%*s c #%02x%02x%02x", cpp, Base92(x), chrs2color[x].r, chrs2color[x].g, chrs2color[x].b );
 			if( io->write_proc(buf, (unsigned int)strlen(buf), 1, handle) != 1 )
 				return FALSE;
 			if( x == num_colors - 1 ) {
 				if( io->write_proc(start_pixels, (unsigned int)strlen(start_pixels), 1, handle) != 1 )
 					return FALSE;
 			} else {
 				if( io->write_proc(new_line, (unsigned int)strlen(new_line), 1, handle) != 1 )
 					return FALSE;
 			}
 		}


 		//write pixels, using map of rgb(if 24bpp) or index(if 8bpp)->chrs
 		for(y = 0; y < height; y++ ) {
 			BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);
 			for(x = 0; x < width; x++ ) {
 				DWORDRGBA u;
 				if( bpp > 8 ) {
 					u.rgba.b = line[FI_RGBA_BLUE];
 					u.rgba.g = line[FI_RGBA_GREEN];
 					u.rgba.r = line[FI_RGBA_RED];
 					u.rgba.a = 0;
 					line += 3;
 				} else {
 					u.index = *line;
 					line++;
 				}
 				sprintf(buf, "%*s", cpp, (char *)color2chrs[u.index].c_str());
 				if( io->write_proc(buf, cpp, 1, handle) != 1 )
 					return FALSE;
 			}
 			if( y == height - 1 ) {
 				if( io->write_proc(footer, (unsigned int)strlen(footer), 1, handle) != 1 )
 					return FALSE;
 			} else {
 				if( io->write_proc(new_line, (unsigned int)strlen(new_line), 1, handle) != 1 )
 					return FALSE;
 			}
 		}

 		return TRUE;
 	} else {
 		return FALSE;
 	}
 }

 // ==========================================================
 //   Init
 // ==========================================================

 void DLL_CALLCONV
 InitXPM(Plugin *plugin, int format_id)
 {
     s_format_id = format_id;

 	plugin->format_proc = Format;
 	plugin->description_proc = Description;
 	plugin->extension_proc = Extension;
 	plugin->regexpr_proc = RegExpr;
 	plugin->open_proc = NULL;
 	plugin->close_proc = NULL;
 	plugin->pagecount_proc = NULL;
 	plugin->pagecapability_proc = NULL;
 	plugin->load_proc = Load;
 	plugin->save_proc = Save;
 	plugin->validate_proc = Validate;
 	plugin->mime_proc = MimeType;
 	plugin->supports_export_bpp_proc = SupportsExportDepth;
 	plugin->supports_export_type_proc = SupportsExportType;
 	plugin->supports_icc_profiles_proc = NULL;
 	plugin->supports_no_pixels_proc = SupportsNoPixels;
 }
	// ==========================================================
	// XPM Loader and Writer
	//
	// Design and implementation by
	// - Ryan Rubley (ryan@lostreality.org)
	//
	// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
	// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
	// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
	// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
	// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
	// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
	// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
	// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
	// THIS DISCLAIMER.
	//
	// Use at your own risk!
	// ==========================================================

	#ifdef _MSC_VER
	#pragma warning (disable : 4786) // identifier was truncated to 'number' characters
	#endif

	// IMPLEMENTATION NOTES:
	// ------------------------
	// Initial design and implementation by
	// - Karl-Heinz Bussian (khbussian@moss.de)
	// - Hervé Drolon (drolon@infonie.fr)
	// Completely rewritten from scratch by Ryan Rubley (ryan@lostreality.org)
	// in order to address the following major fixes:
	// * Supports any number of chars per pixel (not just 1 or 2)
	// * Files with 2 chars per pixel but <= 256colors are loaded as 256 color (not 24bit)
	// * Loads much faster, uses much less memory
	// * supports #rgb #rrrgggbbb and #rrrrggggbbbb colors (not just #rrggbb)
	// * supports symbolic color names
	// ==========================================================

	#include "FreeImage.h"
	#include "Utilities.h"

	// ==========================================================
	// Plugin Interface
	// ==========================================================
	static int s_format_id;

	// ==========================================================
	// Internal Functions
	// ==========================================================

	// read in and skip all junk until we find a certain char
	static BOOL
	FindChar(FreeImageIO *io, fi_handle handle, BYTE look_for) {
	BYTE c = '\0';
	io->read_proc(&c, sizeof(BYTE), 1, handle);
	while(c != look_for) {
	if( io->read_proc(&c, sizeof(BYTE), 1, handle) != 1 )
	return FALSE;
	}
	return TRUE;
	}

	// find start of string, read data until ending quote found, allocate memory and return a string
	static char *
	ReadString(FreeImageIO *io, fi_handle handle) {
	if( !FindChar(io, handle,'"') )
	return NULL;
	BYTE c;
	std::string s;
	io->read_proc(&c, sizeof(BYTE), 1, handle);
	while(c != '"') {
	s += c;
	if( io->read_proc(&c, sizeof(BYTE), 1, handle) != 1 )
	return NULL;
	}
	char cstr = (char )malloc(s.length()+1);
	strcpy(cstr,s.c_str());
	return cstr;
	}

	static char *
	Base92(unsigned int num) {
	static char b92[16]; //enough for more then 64 bits
	static char digit[] = " .XoO+@#$%&*=-;:>,<1234567890qwertyuipasdfghjklzxcvbnmMNBVCZASDFGHJKLPIUYTREWQ!~^/()_`'][{}\|";
	b92[15] = '\0';
	int i = 14;
	do {
	b92[i--] = digit[num % 92];
	num /= 92;
	} while( num && i >= 0 );
	return b92+i+1;
	}

	// ==========================================================
	// Plugin Implementation
	// ==========================================================

	static const char * DLL_CALLCONV
	Format() {
	return "XPM";
	}

	static const char * DLL_CALLCONV
	Description() {
	return "X11 Pixmap Format";
	}

	static const char * DLL_CALLCONV
	Extension() {
	return "xpm";
	}

	static const char * DLL_CALLCONV
	RegExpr() {
	return "^[ \\t]/\\ XPM \\*/[ \\t]$";
	}

	static const char * DLL_CALLCONV
	MimeType() {
	return "image/x-xpixmap";
	}

	static BOOL DLL_CALLCONV
	Validate(FreeImageIO *io, fi_handle handle) {
	char buffer[256];

	// checks the first 256 characters for the magic string
	int count = io->read_proc(buffer, 1, 256, handle);
	if(count <= 9) return FALSE;
	for(int i = 0; i < (count - 9); i++) {
	if(strncmp(&buffer[i], "/* XPM */", 9) == 0)
	return TRUE;
	}
	return FALSE;
	}

	static BOOL DLL_CALLCONV
	SupportsExportDepth(int depth) {
	return (
	(depth == 8) \|\|
	(depth == 24)
	);
	}

	static BOOL DLL_CALLCONV
	SupportsExportType(FREE_IMAGE_TYPE type) {
	return (type == FIT_BITMAP) ? TRUE : FALSE;
	}

	static BOOL DLL_CALLCONV
	SupportsNoPixels() {
	return TRUE;
	}

	// ----------------------------------------------------------

	static FIBITMAP * DLL_CALLCONV
	Load(FreeImageIO io, fi_handle handle, int page, int flags, void data) {
	char msg[256];
	FIBITMAP *dib = NULL;

	if (!handle) return NULL;

	try {
	char *str;

	BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;

	//find the starting brace
	if( !FindChar(io, handle,'{') )
	throw "Could not find starting brace";

	//read info string
	str = ReadString(io, handle);
	if(!str)
	throw "Error reading info string";

	int width, height, colors, cpp;
	if( sscanf(str, "%d %d %d %d", &width, &height, &colors, &cpp) != 4 ) {
	free(str);
	throw "Improperly formed info string";
	}
	free(str);

	if (colors > 256) {
	dib = FreeImage_AllocateHeader(header_only, width, height, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
	} else {
	dib = FreeImage_AllocateHeader(header_only, width, height, 8);
	}

	//build a map of color chars to rgb values
	std::map<std::string,FILE_RGBA> rawpal; //will store index in Alpha if 8bpp
	for(int i = 0; i < colors; i++ ) {
	FILE_RGBA rgba;

	str = ReadString(io, handle);
	if(!str)
	throw "Error reading color strings";

	std::string chrs(str,cpp); //create a string for the color chars using the first cpp chars
	char *keys = str + cpp; //the color keys for these chars start after the first cpp chars

	//translate all the tabs to spaces
	char *tmp = keys;
	while( strchr(tmp,'\t') ) {
	tmp = strchr(tmp,'\t');
	*tmp++ = ' ';
	}

	//prefer the color visual
	if( strstr(keys," c ") ) {
	char *clr = strstr(keys," c ") + 3;
	while( *clr == ' ' ) clr++; //find the start of the hex rgb value
	if( *clr == '#' ) {
	int red = 0, green = 0, blue = 0, n;
	clr++;
	//end string at first space, if any found
	if( strchr(clr,' ') )
	*(strchr(clr,' ')) = '\0';
	//parse hex color, it can be #rgb #rrggbb #rrrgggbbb or #rrrrggggbbbb
	switch( strlen(clr) ) {
	case 3: n = sscanf(clr,"%01x%01x%01x",&red,&green,&blue);
	red \|= (red << 4);
	green \|= (green << 4);
	blue \|= (blue << 4);
	break;
	case 6: n = sscanf(clr,"%02x%02x%02x",&red,&green,&blue);
	break;
	case 9: n = sscanf(clr,"%03x%03x%03x",&red,&green,&blue);
	red >>= 4;
	green >>= 4;
	blue >>= 4;
	break;
	case 12: n = sscanf(clr,"%04x%04x%04x",&red,&green,&blue);
	red >>= 8;
	green >>= 8;
	blue >>= 8;
	break;
	default:
	n = 0;
	break;
	}
	if( n != 3 ) {
	free(str);
	throw "Improperly formed hex color value";
	}
	rgba.r = (BYTE)red;
	rgba.g = (BYTE)green;
	rgba.b = (BYTE)blue;
	} else if( !strncmp(clr,"None",4) \|\| !strncmp(clr,"none",4) ) {
	rgba.r = rgba.g = rgba.b = 0xFF;
	} else {
	char *tmp = clr;

	//scan forward for each space, if its " x " or " xx " end the string there
	//this means its probably some other visual data beyond that point and not
	//part of the color name. How many named color end with a 1 or 2 character
	//word? Probably none in our list at least.
	while( (tmp = strchr(tmp,' ')) != NULL ) {
	if( tmp[1] != ' ' ) {
	if( (tmp[2] == ' ') \|\| (tmp[2] != ' ' && tmp[3] == ' ') ) {
	tmp[0] = '\0';
	break;
	}
	}
	tmp++;
	}

	//remove any trailing spaces
	tmp = clr+strlen(clr)-1;
	while( *tmp == ' ' ) {
	*tmp = '\0';
	tmp--;
	}

	if (!FreeImage_LookupX11Color(clr, &rgba.r, &rgba.g, &rgba.b)) {
	sprintf(msg, "Unknown color name '%s'", str);
	free(str);
	throw msg;
	}
	}
	} else {
	free(str);
	throw "Only color visuals are supported";
	}

	//add color to map
	rgba.a = (BYTE)((colors > 256) ? 0 : i);
	rawpal[chrs] = rgba;

	//build palette if needed
	if( colors <= 256 ) {
	RGBQUAD *pal = FreeImage_GetPalette(dib);
	pal[i].rgbBlue = rgba.b;
	pal[i].rgbGreen = rgba.g;
	pal[i].rgbRed = rgba.r;
	}

	free(str);
	}
	//done parsing color map

	if(header_only) {
	// header only mode
	return dib;
	}

	//read in pixel data
	for(int y = 0; y < height; y++ ) {
	BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);
	str = ReadString(io, handle);
	if(!str)
	throw "Error reading pixel strings";
	char *pixel_ptr = str;

	for(int x = 0; x < width; x++ ) {
	//locate the chars in the color map
	std::string chrs(pixel_ptr,cpp);
	FILE_RGBA rgba = rawpal[chrs];

	if( colors > 256 ) {
	line[FI_RGBA_BLUE] = rgba.b;
	line[FI_RGBA_GREEN] = rgba.g;
	line[FI_RGBA_RED] = rgba.r;
	line += 3;
	} else {
	*line = rgba.a;
	line++;
	}

	pixel_ptr += cpp;
	}

	free(str);
	}
	//done reading pixel data

	return dib;
	} catch(const char *text) {
	FreeImage_OutputMessageProc(s_format_id, text);

	if( dib != NULL )
	FreeImage_Unload(dib);

	return NULL;
	}
	}

	static BOOL DLL_CALLCONV
	Save(FreeImageIO io, FIBITMAP dib, fi_handle handle, int page, int flags, void *data) {
	if ((dib != NULL) && (handle != NULL)) {
	char header[] = "/* XPM /\nstatic char freeimage[] = {\n/* width height num_colors chars_per_pixel */\n\"",
	start_colors[] = "\",\n/* colors */\n\"",
	start_pixels[] = "\",\n/* pixels */\n\"",
	new_line[] = "\",\n\"",
	footer[] = "\"\n};\n",
	buf[256]; //256 is more then enough to sprintf 4 ints into, or the base-92 chars and #rrggbb line

	if( io->write_proc(header, (unsigned int)strlen(header), 1, handle) != 1 )
	return FALSE;

	int width = FreeImage_GetWidth(dib), height = FreeImage_GetHeight(dib), bpp = FreeImage_GetBPP(dib);
	RGBQUAD *pal = FreeImage_GetPalette(dib);
	int x,y;

	//map base92 chrs to the rgb value to create the palette
	std::map<DWORD,FILE_RGB> chrs2color;
	//map 8bpp index or 24bpp rgb value to the base92 chrs to create pixel data
	typedef union {
	DWORD index;
	FILE_RGBA rgba;
	} DWORDRGBA;
	std::map<DWORD,std::string> color2chrs;

	//loop thru entire dib, if new color, inc num_colors and add to both maps
	int num_colors = 0;
	for(y = 0; y < height; y++ ) {
	BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);
	for(x = 0; x < width; x++ ) {
	FILE_RGB rgb;
	DWORDRGBA u;
	if( bpp > 8 ) {
	u.rgba.b = rgb.b = line[FI_RGBA_BLUE];
	u.rgba.g = rgb.g = line[FI_RGBA_GREEN];
	u.rgba.r = rgb.r = line[FI_RGBA_RED];
	u.rgba.a = 0;
	line += 3;
	} else {
	u.index = *line;
	rgb.b = pal[u.index].rgbBlue;
	rgb.g = pal[u.index].rgbGreen;
	rgb.r = pal[u.index].rgbRed;
	line++;
	}
	if( color2chrs.find(u.index) == color2chrs.end() ) { //new color
	std::string chrs(Base92(num_colors));
	color2chrs[u.index] = chrs;
	chrs2color[num_colors] = rgb;
	num_colors++;
	}
	}
	}

	int cpp = (int)(log((double)num_colors)/log(92.0)) + 1;

	sprintf(buf, "%d %d %d %d", FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), num_colors, cpp );
	if( io->write_proc(buf, (unsigned int)strlen(buf), 1, handle) != 1 )
	return FALSE;

	if( io->write_proc(start_colors, (unsigned int)strlen(start_colors), 1, handle) != 1 )
	return FALSE;

	//write colors, using map of chrs->rgb
	for(x = 0; x < num_colors; x++ ) {
	sprintf(buf, "%*s c #%02x%02x%02x", cpp, Base92(x), chrs2color[x].r, chrs2color[x].g, chrs2color[x].b );
	if( io->write_proc(buf, (unsigned int)strlen(buf), 1, handle) != 1 )
	return FALSE;
	if( x == num_colors - 1 ) {
	if( io->write_proc(start_pixels, (unsigned int)strlen(start_pixels), 1, handle) != 1 )
	return FALSE;
	} else {
	if( io->write_proc(new_line, (unsigned int)strlen(new_line), 1, handle) != 1 )
	return FALSE;
	}
	}


	//write pixels, using map of rgb(if 24bpp) or index(if 8bpp)->chrs
	for(y = 0; y < height; y++ ) {
	BYTE *line = FreeImage_GetScanLine(dib, height - y - 1);
	for(x = 0; x < width; x++ ) {
	DWORDRGBA u;
	if( bpp > 8 ) {
	u.rgba.b = line[FI_RGBA_BLUE];
	u.rgba.g = line[FI_RGBA_GREEN];
	u.rgba.r = line[FI_RGBA_RED];
	u.rgba.a = 0;
	line += 3;
	} else {
	u.index = *line;
	line++;
	}
	sprintf(buf, "%s", cpp, (char )color2chrs[u.index].c_str());
	if( io->write_proc(buf, cpp, 1, handle) != 1 )
	return FALSE;
	}
	if( y == height - 1 ) {
	if( io->write_proc(footer, (unsigned int)strlen(footer), 1, handle) != 1 )
	return FALSE;
	} else {
	if( io->write_proc(new_line, (unsigned int)strlen(new_line), 1, handle) != 1 )
	return FALSE;
	}
	}

	return TRUE;
	} else {
	return FALSE;
	}
	}

	// ==========================================================
	// Init
	// ==========================================================

	void DLL_CALLCONV
	InitXPM(Plugin *plugin, int format_id)
	{
	s_format_id = format_id;

	plugin->format_proc = Format;
	plugin->description_proc = Description;
	plugin->extension_proc = Extension;
	plugin->regexpr_proc = RegExpr;
	plugin->open_proc = NULL;
	plugin->close_proc = NULL;
	plugin->pagecount_proc = NULL;
	plugin->pagecapability_proc = NULL;
	plugin->load_proc = Load;
	plugin->save_proc = Save;
	plugin->validate_proc = Validate;
	plugin->mime_proc = MimeType;
	plugin->supports_export_bpp_proc = SupportsExportDepth;
	plugin->supports_export_type_proc = SupportsExportType;
	plugin->supports_icc_profiles_proc = NULL;
	plugin->supports_no_pixels_proc = SupportsNoPixels;
	}