rt-thread/components/rtgui/common/image_xpm.c

/*
 * File      : image_xpm.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006 - 2009, RT-Thread Development Team
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://www.rt-thread.org/license/LICENSE
 *
 * Change Logs:
 * Date           Author       Notes
 * 2009-10-16     Bernard      first version
 */
#include <stdio.h>
#include <string.h>

#include <rtgui/filerw.h>
#include <rtgui/image_xpm.h>
#include <rtgui/rtgui_system.h>

#ifdef RTGUI_IMAGE_XPM
#define XPM_MAGIC_LEN       9

static rt_bool_t rtgui_image_xpm_check(struct rtgui_filerw * file);
static rt_bool_t rtgui_image_xpm_load(struct rtgui_image* image, struct rtgui_filerw* file, rt_bool_t load);
static void rtgui_image_xpm_unload(struct rtgui_image* image);
static void rtgui_image_xpm_blit(struct rtgui_image* image, struct rtgui_dc* dc, struct rtgui_rect* rect);

struct rtgui_image_engine rtgui_image_xpm_engine =
{
	"xpm",
	{RT_NULL},
	rtgui_image_xpm_check,
	rtgui_image_xpm_load,
	rtgui_image_xpm_unload,
	rtgui_image_xpm_blit
};

struct rgb_item
{
	char *name;
	int r;
	int g;
	int b;
};

const struct rgb_item rgbRecord[234] = {
	{"AliceBlue", 240, 248, 255},
	{"AntiqueWhite", 250, 235, 215},
	{"Aquamarine", 50, 191, 193},
	{"Azure", 240, 255, 255},
	{"Beige", 245, 245, 220},
	{"Bisque", 255, 228, 196},
	{"Black", 0, 0, 0},
	{"BlanchedAlmond", 255, 235, 205},
	{"Blue", 0, 0, 255},
	{"BlueViolet", 138, 43, 226},
	{"Brown", 165, 42, 42},
	{"burlywood", 222, 184, 135},
	{"CadetBlue", 95, 146, 158},
	{"chartreuse", 127, 255, 0},
	{"chocolate", 210, 105, 30},
	{"Coral", 255, 114, 86},
	{"CornflowerBlue", 34, 34, 152},
	{"cornsilk", 255, 248, 220},
	{"Cyan", 0, 255, 255},
	{"DarkGoldenrod", 184, 134, 11},
	{"DarkGreen", 0, 86, 45},
	{"DarkKhaki", 189, 183, 107},
	{"DarkOliveGreen", 85, 86, 47},
	{"DarkOrange", 255, 140, 0},
	{"DarkOrchid", 139, 32, 139},
	{"DarkSalmon", 233, 150, 122},
	{"DarkSeaGreen", 143, 188, 143},
	{"DarkSlateBlue", 56, 75, 102},
	{"DarkSlateGray", 47, 79, 79},
	{"DarkTurquoise", 0, 166, 166},
	{"DarkViolet", 148, 0, 211},
	{"DeepPink", 255, 20, 147},
	{"DeepSkyBlue", 0, 191, 255},
	{"DimGray", 84, 84, 84},
	{"DodgerBlue", 30, 144, 255},
	{"Firebrick", 142, 35, 35},
	{"FloralWhite", 255, 250, 240},
	{"ForestGreen", 80, 159, 105},
	{"gainsboro", 220, 220, 220},
	{"GhostWhite", 248, 248, 255},
	{"Gold", 218, 170, 0},
	{"Goldenrod", 239, 223, 132},
	{"Gray", 126, 126, 126},
	{"Gray0", 0, 0, 0},
	{"Gray1", 3, 3, 3},
	{"Gray10", 26, 26, 26},
	{"Gray100", 255, 255, 255},
	{"Gray11", 28, 28, 28},
	{"Gray12", 31, 31, 31},
	{"Gray13", 33, 33, 33},
	{"Gray14", 36, 36, 36},
	{"Gray15", 38, 38, 38},
	{"Gray16", 41, 41, 41},
	{"Gray17", 43, 43, 43},
	{"Gray18", 46, 46, 46},
	{"Gray19", 48, 48, 48},
	{"Gray2", 5, 5, 5},
	{"Gray20", 51, 51, 51},
	{"Gray21", 54, 54, 54},
	{"Gray22", 56, 56, 56},
	{"Gray23", 59, 59, 59},
	{"Gray24", 61, 61, 61},
	{"Gray25", 64, 64, 64},
	{"Gray26", 66, 66, 66},
	{"Gray27", 69, 69, 69},
	{"Gray28", 71, 71, 71},
	{"Gray29", 74, 74, 74},
	{"Gray3", 8, 8, 8},
	{"Gray30", 77, 77, 77},
	{"Gray31", 79, 79, 79},
	{"Gray32", 82, 82, 82},
	{"Gray33", 84, 84, 84},
	{"Gray34", 87, 87, 87},
	{"Gray35", 89, 89, 89},
	{"Gray36", 92, 92, 92},
	{"Gray37", 94, 94, 94},
	{"Gray38", 97, 97, 97},
	{"Gray39", 99, 99, 99},
	{"Gray4", 10, 10, 10},
	{"Gray40", 102, 102, 102},
	{"Gray41", 105, 105, 105},
	{"Gray42", 107, 107, 107},
	{"Gray43", 110, 110, 110},
	{"Gray44", 112, 112, 112},
	{"Gray45", 115, 115, 115},
	{"Gray46", 117, 117, 117},
	{"Gray47", 120, 120, 120},
	{"Gray48", 122, 122, 122},
	{"Gray49", 125, 125, 125},
	{"Gray5", 13, 13, 13},
	{"Gray50", 127, 127, 127},
	{"Gray51", 130, 130, 130},
	{"Gray52", 133, 133, 133},
	{"Gray53", 135, 135, 135},
	{"Gray54", 138, 138, 138},
	{"Gray55", 140, 140, 140},
	{"Gray56", 143, 143, 143},
	{"Gray57", 145, 145, 145},
	{"Gray58", 148, 148, 148},
	{"Gray59", 150, 150, 150},
	{"Gray6", 15, 15, 15},
	{"Gray60", 153, 153, 153},
	{"Gray61", 156, 156, 156},
	{"Gray62", 158, 158, 158},
	{"Gray63", 161, 161, 161},
	{"Gray64", 163, 163, 163},
	{"Gray65", 166, 166, 166},
	{"Gray66", 168, 168, 168},
	{"Gray67", 171, 171, 171},
	{"Gray68", 173, 173, 173},
	{"Gray69", 176, 176, 176},
	{"Gray7", 18, 18, 18},
	{"Gray70", 179, 179, 179},
	{"Gray71", 181, 181, 181},
	{"Gray72", 184, 184, 184},
	{"Gray73", 186, 186, 186},
	{"Gray74", 189, 189, 189},
	{"Gray75", 191, 191, 191},
	{"Gray76", 194, 194, 194},
	{"Gray77", 196, 196, 196},
	{"Gray78", 199, 199, 199},
	{"Gray79", 201, 201, 201},
	{"Gray8", 20, 20, 20},
	{"Gray80", 204, 204, 204},
	{"Gray81", 207, 207, 207},
	{"Gray82", 209, 209, 209},
	{"Gray83", 212, 212, 212},
	{"Gray84", 214, 214, 214},
	{"Gray85", 217, 217, 217},
	{"Gray86", 219, 219, 219},
	{"Gray87", 222, 222, 222},
	{"Gray88", 224, 224, 224},
	{"Gray89", 227, 227, 227},
	{"Gray9", 23, 23, 23},
	{"Gray90", 229, 229, 229},
	{"Gray91", 232, 232, 232},
	{"Gray92", 235, 235, 235},
	{"Gray93", 237, 237, 237},
	{"Gray94", 240, 240, 240},
	{"Gray95", 242, 242, 242},
	{"Gray96", 245, 245, 245},
	{"Gray97", 247, 247, 247},
	{"Gray98", 250, 250, 250},
	{"Gray99", 252, 252, 252},
	{"Green", 0, 255, 0},
	{"GreenYellow", 173, 255, 47},
	{"honeydew", 240, 255, 240},
	{"HotPink", 255, 105, 180},
	{"IndianRed", 107, 57, 57},
	{"ivory", 255, 255, 240},
	{"Khaki", 179, 179, 126},
	{"lavender", 230, 230, 250},
	{"LavenderBlush", 255, 240, 245},
	{"LawnGreen", 124, 252, 0},
	{"LemonChiffon", 255, 250, 205},
	{"LightBlue", 176, 226, 255},
	{"LightCoral", 240, 128, 128},
	{"LightCyan", 224, 255, 255},
	{"LightGoldenrod", 238, 221, 130},
	{"LightGoldenrodYellow", 250, 250, 210},
	{"LightGray", 168, 168, 168},
	{"LightPink", 255, 182, 193},
	{"LightSalmon", 255, 160, 122},
	{"LightSeaGreen", 32, 178, 170},
	{"LightSkyBlue", 135, 206, 250},
	{"LightSlateBlue", 132, 112, 255},
	{"LightSlateGray", 119, 136, 153},
	{"LightSteelBlue", 124, 152, 211},
	{"LightYellow", 255, 255, 224},
	{"LimeGreen", 0, 175, 20},
	{"linen", 250, 240, 230},
	{"Magenta", 255, 0, 255},
	{"Maroon", 143, 0, 82},
	{"MediumAquamarine", 0, 147, 143},
	{"MediumBlue", 50, 50, 204},
	{"MediumForestGreen", 50, 129, 75},
	{"MediumGoldenrod", 209, 193, 102},
	{"MediumOrchid", 189, 82, 189},
	{"MediumPurple", 147, 112, 219},
	{"MediumSeaGreen", 52, 119, 102},
	{"MediumSlateBlue", 106, 106, 141},
	{"MediumSpringGreen", 35, 142, 35},
	{"MediumTurquoise", 0, 210, 210},
	{"MediumVioletRed", 213, 32, 121},
	{"MidnightBlue", 47, 47, 100},
	{"MintCream", 245, 255, 250},
	{"MistyRose", 255, 228, 225},
	{"moccasin", 255, 228, 181},
	{"NavajoWhite", 255, 222, 173},
	{"Navy", 35, 35, 117},
	{"NavyBlue", 35, 35, 117},
	{"OldLace", 253, 245, 230},
	{"OliveDrab", 107, 142, 35},
	{"Orange", 255, 135, 0},
	{"OrangeRed", 255, 69, 0},
	{"Orchid", 239, 132, 239},
	{"PaleGoldenrod", 238, 232, 170},
	{"PaleGreen", 115, 222, 120},
	{"PaleTurquoise", 175, 238, 238},
	{"PaleVioletRed", 219, 112, 147},
	{"PapayaWhip", 255, 239, 213},
	{"PeachPuff", 255, 218, 185},
	{"peru", 205, 133, 63},
	{"Pink", 255, 181, 197},
	{"Plum", 197, 72, 155},
	{"PowderBlue", 176, 224, 230},
	{"purple", 160, 32, 240},
	{"Red", 255, 0, 0},
	{"RosyBrown", 188, 143, 143},
	{"RoyalBlue", 65, 105, 225},
	{"SaddleBrown", 139, 69, 19},
	{"Salmon", 233, 150, 122},
	{"SandyBrown", 244, 164, 96},
	{"SeaGreen", 82, 149, 132},
	{"seashell", 255, 245, 238},
	{"Sienna", 150, 82, 45},
	{"SkyBlue", 114, 159, 255},
	{"SlateBlue", 126, 136, 171},
	{"SlateGray", 112, 128, 144},
	{"snow", 255, 250, 250},
	{"SpringGreen", 65, 172, 65},
	{"SteelBlue", 84, 112, 170},
	{"Tan", 222, 184, 135},
	{"Thistle", 216, 191, 216},
	{"tomato", 255, 99, 71},
	{"Transparent", 0, 0, 1},
	{"Turquoise", 25, 204, 223},
	{"Violet", 156, 62, 206},
	{"VioletRed", 243, 62, 150},
	{"Wheat", 245, 222, 179},
	{"White", 255, 255, 255},
	{"WhiteSmoke", 245, 245, 245},
	{"Yellow", 255, 255, 0},
	{"YellowGreen", 50, 216, 56}
};
/* Hash table to look up colors from pixel strings */
#define STARTING_HASH_SIZE 256

struct hash_entry
{
	char key[10];
	rtgui_color_t 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 = rtgui_malloc(sizeof *hash);
	if(!hash) return RT_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 = RT_NULL;	/* in case rt_malloc fails */
	hash->table = rtgui_malloc(bytes);
	if(!hash->table) return RT_NULL;

	rt_memset(hash->table, 0, bytes);
	hash->entries = rtgui_malloc(maxnum * sizeof(struct hash_entry));
	if(!hash->entries) return RT_NULL;

	hash->next_free = hash->entries;
	return hash;
}

static int add_colorhash(struct color_hash *hash,
                         char *key, int cpp, rtgui_color_t *color)
{
	int index = hash_key(key, cpp, hash->size);
	struct hash_entry *e = hash->next_free++;

	e->color = *color;
	rt_memset(e->key, 0, sizeof(e->key));
	rt_strncpy(e->key, key, cpp);
	e->next = hash->table[index];
	hash->table[index] = e;

	return 1;
}

static void get_colorhash(struct color_hash *hash, const char *key, int cpp, rtgui_color_t* c)
{
	struct hash_entry *entry = hash->table[hash_key(key, cpp, hash->size)];
	while(entry)
	{
		if(rt_memcmp(key, entry->key, cpp) == 0)
		{
			*c = entry->color;

			return;
		}

		entry = entry->next;
	}

	return ;		/* garbage in - garbage out */
}

static void free_colorhash(struct color_hash *hash)
{
	if(hash && hash->table)
	{
		rtgui_free(hash->table);
		rtgui_free(hash->entries);
		rtgui_free(hash);
	}
}

#if defined(_MSC_VER) || defined(__CC_ARM)
int strcasecmp( const char* s1, const char* s2 )
{
    register unsigned int  x2;
    register unsigned int  x1;

    while (1) {
        x2 = *s2 - 'A'; if (x2 < 26u) x2 += 32;
        x1 = *s1 - 'A'; if (x1 < 26u) x1 += 32;
		s1++; s2++;
        if (x2 != x1)
            break;
        if (x1 == (unsigned int)-'A')
            break;
    }

    return x1 - x2;
}
#endif

static int hex2int (char *str)
{
    int i = 0;
    int r = 0;

    for (i = 0; i < 2; i++)
	{
		if (str[i] >= '0' && str[i] <= '9') r += str[i] - '0';
		else if (str[i] >= 'a' && str[i] <= 'f') r += str[i] - 'a' + 10;
		else if (str[i] >= 'A' && str[i] <= 'F') r += str[i] - 'A' + 10;

		if (!i) r *= 16;
    }

    return r;
}

void rtgui_image_xpm_init()
{
	/* register xpm engine */
	rtgui_image_register_engine(&rtgui_image_xpm_engine);
}

static rt_bool_t rtgui_image_xpm_check(struct rtgui_filerw* file)
{
#if 0
	rt_uint8_t buffer[XPM_MAGIC_LEN];
	rt_size_t start;
	rt_bool_t result;

	result = RT_FALSE;

	start = rtgui_filerw_tell(file);

	/* seek to the begining of file */
	if (start != 0) rtgui_filerw_seek(file, 0, SEEK_SET);
	rtgui_filerw_read(file, &buffer[0], XPM_MAGIC_LEN, 1);

    if (rt_memcmp(buffer, "/* XPM */", (rt_ubase_t)XPM_MAGIC_LEN) == 0)
        result = RT_TRUE;

	rtgui_filerw_seek(file, start, SEEK_SET);

    return result;
#else
	/* we can not check image type for memory file */
	return RT_TRUE;
#endif
}

static rt_bool_t rtgui_image_xpm_load(struct rtgui_image* image, struct rtgui_filerw* file, rt_bool_t load)
{
	const char **xpm;
	const char *buf;
	const char *buf_tmp;

	int w, h;
	int colors = 0;
	int colors_pp = 0;

	int i, j;

	/* color hash table */
	struct color_hash *colors_table = RT_NULL;

	if (image == RT_NULL) return RT_FALSE;

	xpm = (const char **)rtgui_filerw_mem_getdata(file);
	if (xpm == RT_NULL) return RT_FALSE;

	/* set image engine */
	image->engine = &rtgui_image_xpm_engine;

	/* parse xpm image */
	sscanf(xpm[0], "%d %d %d %d", &w, &h, &colors, &colors_pp);
	image->w = w;
	image->h = h;

	/* build color table */
	colors_table = create_colorhash(colors);
	if (!colors_table)
	{
		return RT_FALSE;
	}

	for (i = 0; i < colors; i++)
	{
		char color_name[10];
		rtgui_color_t c = 0;

		buf = xpm[i + 1];

		for (j = 0; j < colors_pp; j++)
		{
			color_name[j] = buf[j];
		}
		color_name[j] = '\0';

		/* build rtgui_color */
		if ((buf_tmp = strstr(buf, "c #")) != RT_NULL)
		{
			char color_hex[10];

			/* hexadecimal color value */
			sscanf(buf_tmp, "c #%s", color_hex);

			c = RTGUI_ARGB(0, hex2int(color_hex),
				hex2int(color_hex + 2),
				hex2int(color_hex + 4));
		}
		else if ((buf_tmp = strstr(buf, "c ")) != RT_NULL)
		{
			int k;

			/* color name */
			char rgbname[30];

			sscanf(buf_tmp, "c %s", rgbname);

			if (strcasecmp(rgbname, "None") == 0)
			{
				goto color_none;
			}

			for (k = 0; k < 234; k++)
			{
				if (strcasecmp(rgbname, rgbRecord[k].name) == 0)
				{
					c = RTGUI_ARGB(0, rgbRecord[k].r,
						rgbRecord[k].g,
						rgbRecord[k].b);
					break;
				}
			}
		}
		else
		{
color_none:
			c = RTGUI_RGB(0, 0, 0);
		}

		/* add to color hash table */
		add_colorhash(colors_table, color_name, colors_pp, &c);
	}

	/* build rgb pixel data */
	image->data = (rt_uint8_t*) rtgui_malloc(image->w * image->h * sizeof(rtgui_color_t));
	memset(image->data, 0, image->w * image->h * sizeof(rtgui_color_t));

	{
		rtgui_color_t *ptr = (rtgui_color_t*) image->data;

		for (h = 0; h < image->h; h++)
		{
			buf = xpm[colors + 1 + h];
			for (w = 0; w < image->w; w++, buf += colors_pp)
			{
				get_colorhash(colors_table, buf, colors_pp, ptr);

				ptr ++;
			}
		}
	}

	free_colorhash(colors_table);
	rtgui_filerw_close(file);

	return RT_TRUE;
}

static void rtgui_image_xpm_unload(struct rtgui_image* image)
{
	if (image != RT_NULL)
	{
		/* release data */
		rtgui_free(image->data);
		image->data = RT_NULL;
	}
}

static void rtgui_image_xpm_blit(struct rtgui_image* image, struct rtgui_dc* dc, struct rtgui_rect* rect)
{
	rt_uint16_t x, y;
	rtgui_color_t* ptr;

	RT_ASSERT(image != RT_NULL && dc != RT_NULL && rect != RT_NULL);
	RT_ASSERT(image->data != RT_NULL);

	ptr = (rtgui_color_t*) image->data;

	/* draw each point within dc */
	for (y = 0; y < image->h; y ++)
	{
		for (x = 0; x < image->w; x++)
		{
			/* not alpha */
			if ((*ptr >> 24) != 255)
			{
				rtgui_dc_draw_color_point(dc, x + rect->x1, y + rect->y1, *ptr);
			}

			/* move to next color buffer */
			ptr ++;
		}
	}
}
#endif