/*
   +----------------------------------------------------------------------+
   | PHP version 4.0                                                      |
   +----------------------------------------------------------------------+
   | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group                   |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.02 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available at through the world-wide-web at                           |
   | http://www.php.net/license/2_02.txt.                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Original author: Matt McClanahan <cardinal@dodds.net>                |
   | Current maintainer: Piotr Pawlow <pp@siedziba.pl>                    |
   +----------------------------------------------------------------------+
 */

#include "php.h"
#include "php_ini.h"
#include "php_imlib.h"
#include "php_globals.h"
#include "php_open_temporary_file.h"
#include "ext/standard/info.h"

/* #define IMLIB_DEBUG */

#ifdef IMLIB_DEBUG
#define ID_PRINTF(format, args...) \
fprintf(stderr, "php-imlib: " format "\n" , ## args); fflush(stdout)
#endif

#if HAVE_IMLIB
#ifdef ZTS
int gd_imlib_id;
#else
zend_imlib_globals imlib_globals;
#endif

        ZEND_BEGIN_ARG_INFO(second_arg_force_ref, 0)
                ZEND_ARG_INFO(0, arg1)
                ZEND_ARG_INFO(1, arg2)
        ZEND_END_ARG_INFO();

        ZEND_BEGIN_ARG_INFO(third_arg_force_ref, 0)
                ZEND_ARG_INFO(0, arg1)
                ZEND_ARG_INFO(0, arg2)
                ZEND_ARG_INFO(1, arg3)
        ZEND_END_ARG_INFO();

        ZEND_BEGIN_ARG_INFO(third_and_fourth_arg_force_ref, 0)
                ZEND_ARG_INFO(0, arg1)
                ZEND_ARG_INFO(0, arg2)
                ZEND_ARG_INFO(1, arg3)
                ZEND_ARG_INFO(1, arg4)
        ZEND_END_ARG_INFO();

        ZEND_BEGIN_ARG_INFO(second_through_fifth_arg_force_ref, 0)
                ZEND_ARG_INFO(0, arg1)
                ZEND_ARG_INFO(1, arg2)
                ZEND_ARG_INFO(1, arg3)
                ZEND_ARG_INFO(1, arg4)
                ZEND_ARG_INFO(1, arg5)
        ZEND_END_ARG_INFO();

        ZEND_BEGIN_ARG_INFO(third_through_sixth_arg_force_ref, 0)
                ZEND_ARG_INFO(0, arg1)
                ZEND_ARG_INFO(0, arg2)
                ZEND_ARG_INFO(1, arg3)
                ZEND_ARG_INFO(1, arg4)
                ZEND_ARG_INFO(1, arg5)
                ZEND_ARG_INFO(1, arg6)
        ZEND_END_ARG_INFO();

static const char le_imlib_cr_name[] = "Imlib Color Range";
static int le_imlib_cr;
static const char le_imlib_font_name[] = "Imlib Font";
static int le_imlib_font;
static const char le_imlib_img_name[] = "Imlib Image";
static int le_imlib_img;
static const char le_imlib_poly_name[] = "Imlib Polygon";
static int le_imlib_poly;
static const char le_imlib_filter_name[] = "Imlib Filter";
static int le_imlib_filter;
static const char le_imlib_cm_name[] = "Imlib Color Modifier";
static int le_imlib_cm;
#if HAVE_LIBT1
static const char le_ps_font_name[] = "Type 1 font";
static int le_ps_font;
static int le_ps_enc;
#endif

zend_function_entry imlib_functions[] = {
	PHP_FE(imlib_add_color_to_color_range,NULL)
	PHP_FE(imlib_blend_image_onto_image,NULL)
	PHP_FE(imlib_clone_image,NULL)
	PHP_FE(imlib_create_color_range,NULL)
	PHP_FE(imlib_create_color_modifier,NULL)
	PHP_FE(imlib_create_cropped_image,NULL)
	PHP_FE(imlib_create_cropped_scaled_image,NULL)
	PHP_FE(imlib_create_image,NULL)
	PHP_FE(imlib_create_rotated_image,NULL)
	PHP_FE(imlib_create_scaled_image,NULL)
	PHP_FE(imlib_dump_image,second_arg_force_ref)
	PHP_FE(imlib_free_color_range,NULL)
	PHP_FE(imlib_free_color_modifier,NULL)
	PHP_FE(imlib_free_font,NULL)
	PHP_FE(imlib_free_image,NULL)
	PHP_FE(imlib_get_text_size,third_and_fourth_arg_force_ref)
	PHP_FE(imlib_get_text_advance,third_and_fourth_arg_force_ref)
	PHP_FE(imlib_image_blur,NULL)
	PHP_FE(imlib_image_draw_ellipse,NULL)
	PHP_FE(imlib_image_draw_line,NULL)
	PHP_FE(imlib_image_draw_polygon,NULL)
	PHP_FE(imlib_image_draw_rectangle,NULL)
	PHP_FE(imlib_image_fill_color_range_rectangle,NULL)
	PHP_FE(imlib_image_fill_ellipse,NULL)
	PHP_FE(imlib_image_fill_polygon,NULL)
	PHP_FE(imlib_image_fill_rectangle,NULL)
	PHP_FE(imlib_image_flip_horizontal,NULL)
	PHP_FE(imlib_image_flip_vertical,NULL)
	PHP_FE(imlib_image_flip_diagonal,NULL)
	PHP_FE(imlib_image_orientate,NULL)
	PHP_FE(imlib_image_format,NULL)
	PHP_FE(imlib_image_get_filename,NULL)
	PHP_FE(imlib_image_get_height,NULL)
	PHP_FE(imlib_image_get_width,NULL)
	PHP_FE(imlib_image_has_alpha,NULL)
	PHP_FE(imlib_image_modify_alpha,NULL)
	PHP_FE(imlib_image_sharpen,NULL)
	PHP_FE(imlib_image_set_format,NULL)
	PHP_FE(imlib_image_tile_horizontal,NULL)
	PHP_FE(imlib_image_tile_vertical,NULL)
	PHP_FE(imlib_image_tile,NULL)
	PHP_FE(imlib_list_fonts,NULL)
	PHP_FE(imlib_load_font,NULL)
	PHP_FE(imlib_load_image,second_arg_force_ref)
	PHP_FALIAS(imlib_load_image_with_error_return,imlib_load_image,second_arg_force_ref)
	PHP_FE(imlib_polygon_add_point,NULL)
	PHP_FE(imlib_polygon_contains_point,NULL)
	PHP_FE(imlib_polygon_free,NULL)
	PHP_FE(imlib_polygon_get_bounds,second_through_fifth_arg_force_ref)
	PHP_FE(imlib_polygon_new,NULL)
	PHP_FE(imlib_save_image,third_arg_force_ref)
	PHP_FALIAS(imlib_save_image_with_error_return,imlib_save_image,third_arg_force_ref)
	PHP_FE(imlib_text_draw,NULL)
	PHP_FE(imlib_get_cache_size,NULL)
	PHP_FE(imlib_set_cache_size,NULL)
	PHP_FE(imlib_create_filter,NULL)
	PHP_FE(imlib_free_filter,NULL)
	PHP_FE(imlib_image_filter,NULL)
	PHP_FE(imlib_filter_set,NULL)
	PHP_FE(imlib_filter_set_alpha,NULL)
	PHP_FE(imlib_filter_set_red,NULL)
	PHP_FE(imlib_filter_set_green,NULL)
	PHP_FE(imlib_filter_set_blue,NULL)
	PHP_FE(imlib_filter_constants,NULL)
	PHP_FE(imlib_filter_divisors,NULL)
	PHP_FE(imlib_apply_filter,NULL)
	PHP_FE(imlib_modify_color_modifier_gamma,NULL)
	PHP_FE(imlib_modify_color_modifier_brightness,NULL)
	PHP_FE(imlib_modify_color_modifier_contrast,NULL)
	PHP_FE(imlib_reset_color_modifier,NULL)
	PHP_FE(imlib_apply_color_modifier,NULL)
	PHP_FE(imlib_set_color_modifier,NULL)
	PHP_FE(imlib_get_color_modifier,third_through_sixth_arg_force_ref)
        PHP_FE(imlib_psloadfont,NULL)
        PHP_FE(imlib_psfreefont,NULL)
        PHP_FE(imlib_psencodefont,NULL)
        PHP_FE(imlib_psextendfont,NULL)
        PHP_FE(imlib_psslantfont,NULL)
	PHP_FE(imlib_pstext,NULL)
        PHP_FE(imlib_psbbox,NULL)

	{NULL, NULL, NULL}
};

ZEND_DECLARE_MODULE_GLOBALS(imlib)

PHP_INI_BEGIN()
STD_PHP_INI_ENTRY("imlib.font_path","/usr/local/share/fonts",PHP_INI_SYSTEM|PHP_INI_PERDIR,OnUpdateString,font_path,zend_imlib_globals,imlib_globals)
STD_PHP_INI_ENTRY("imlib.min_cache_size","0",PHP_INI_SYSTEM,OnUpdateLong,min_cache_size,zend_imlib_globals,imlib_globals)
STD_PHP_INI_ENTRY("imlib.max_cache_size","4194304",PHP_INI_SYSTEM,OnUpdateLong,max_cache_size,zend_imlib_globals,imlib_globals)
STD_PHP_INI_ENTRY("imlib.cache_size","0",PHP_INI_SYSTEM|PHP_INI_PERDIR,OnUpdateLong,cache_size,zend_imlib_globals,imlib_globals)
PHP_INI_ENTRY("imlib.font_cache_size","524288",PHP_INI_SYSTEM,OnUpdateFontCacheSize)
STD_PHP_INI_ENTRY("imlib.filter_path",PHP_IMLIB_FILTER_PATH,PHP_INI_SYSTEM,OnUpdateString,filter_path,zend_imlib_globals,imlib_globals)
PHP_INI_END()

/* {{{ php_imlib_init_globals
 */
static void php_imlib_init_globals(zend_imlib_globals *imlib_globals)
{
        imlib_globals->font_path = NULL;
	imlib_globals->min_cache_size = 0;
	imlib_globals->max_cache_size = 4194304;
	imlib_globals->cache_size = 0;
	imlib_globals->filter_path = NULL;
	imlib_globals->saved_path = NULL;
	imlib_globals->filters = NULL;
}

zend_module_entry imlib_module_entry = {
	STANDARD_MODULE_HEADER,
	"imlib",
	imlib_functions,
	PHP_MINIT(imlib),
	PHP_MSHUTDOWN(imlib),
	PHP_RINIT(imlib),
	PHP_RSHUTDOWN(imlib),
	PHP_MINFO(imlib),
	NO_VERSION_YET,
	STANDARD_MODULE_PROPERTIES
};

PHP_INI_MH(OnUpdateFontCacheSize)
{
    int size;
    if (sscanf(new_value->val,"%d",&size)==1)
    {
        imlib_set_font_cache_size(size);
        return SUCCESS;
    }
    else
    {
	return FAILURE;
    }
}

ZEND_RSRC_DTOR_FUNC(_php_imlib_free_cm)
{
   imlib_context_set_color_modifier(((PHP_Imlib_Color_Modifier)res->ptr)->cm);
   efree(res->ptr);
   imlib_free_color_modifier();
}

ZEND_RSRC_DTOR_FUNC(_php_imlib_free_filter)
{
   imlib_context_set_filter(res->ptr);
   imlib_free_filter();
}

ZEND_RSRC_DTOR_FUNC(_php_imlib_free_cr)
{
   imlib_context_set_color_range(res->ptr);
   imlib_free_color_range();
}

ZEND_RSRC_DTOR_FUNC(_php_imlib_free_font)
{
   imlib_context_set_font(((PHP_Imlib_Font)res->ptr)->font);
   efree(res->ptr);
   imlib_free_font();
}

ZEND_RSRC_DTOR_FUNC(_php_imlib_free_img)
{
   imlib_context_set_image(res->ptr);
   imlib_free_image();
}

ZEND_RSRC_DTOR_FUNC(_php_imlib_free_poly)
{
   imlib_polygon_free(res->ptr);
}

void _php_imlib_set_cache_size(int size TSRMLS_DC)
{
   if (size>IMLIBG(max_cache_size)) {
      size=IMLIBG(max_cache_size);
   }
   if (size<IMLIBG(min_cache_size)) {
      size=IMLIBG(min_cache_size);
   }
   imlib_set_cache_size(size);
}

struct php_imlib_filter* _php_imlib_load_filter(char* file)
{
	struct php_imlib_filter* ptr=NULL;
	struct php_imlib_filter_info* info=NULL;
	char* path;
	int initrv=FAILURE;
#ifdef IMLIB_DEBUG
	ID_PRINTF("Loading library %s...",file);
#endif
	ptr=calloc(1,sizeof(struct php_imlib_filter));
	if (ptr==NULL) goto error;
	ptr->filename=strdup(file);
	ptr->handle=lt_dlopenext(file);
	if (!ptr->handle) goto error;
#ifdef IMLIB_DEBUG
	ID_PRINTF("Library loaded, handle=%p. Looking for entry points...",ptr->handle);
#endif
	ptr->init=lt_dlsym(ptr->handle,"php_filter_init");
	ptr->deinit=lt_dlsym(ptr->handle,"php_filter_deinit");
	ptr->exec=lt_dlsym(ptr->handle,"php_filter_exec");
	ptr->getfiltercount=lt_dlsym(ptr->handle,"php_filter_getfiltercount");
	ptr->getfilternames=lt_dlsym(ptr->handle,"php_filter_getfilternames");
        ptr->getextinfo=lt_dlsym(ptr->handle,"php_filter_getextinfo");
        ptr->getparams=lt_dlsym(ptr->handle,"php_filter_getparams");
	
#ifdef IMLIB_DEBUG
	ID_PRINTF("Function pointers: init=%p, deinit=%p, exec=%p, count=%p, names=%p",ptr->init,ptr->deinit,ptr->exec,ptr->getfiltercount,ptr->getfilternames);
#endif
	if (!ptr->getfiltercount || !ptr->getfilternames || !ptr->exec) goto error;
#ifdef IMLIB_DEBUG
	ID_PRINTF("Getting filter info...");
#endif
	if (ptr->init)
	{
		initrv=ptr->init();
		if (initrv==FAILURE) goto error;
	}
	ptr->filters=ptr->getfiltercount();
	ptr->names=malloc(ptr->filters*sizeof(char*));
	if (!ptr->names) goto error;
	ptr->getfilternames(ptr->names);
	ptr->next=NULL;
	return ptr;
error:
#ifdef IMLIB_DEBUG
	ID_PRINTF("Error loading library!");
#endif
	if (ptr)
	{
		if (ptr->handle)
		{
			if (ptr->deinit)
			{
				if (initrv==SUCCESS) ptr->deinit();
			}
			lt_dlclose(ptr->handle);
		}
		if (ptr->names) free(ptr->names);
		if (ptr->filename) free(ptr->filename);
		free(ptr);
	}
	return NULL;
}

void _php_imlib_unload_filter(struct php_imlib_filter* ptr)
{
	if (ptr==NULL) return;
	if (ptr->deinit) ptr->deinit();
	if (ptr->names) free(ptr->names);
	if (ptr->filename) free(ptr->filename);
	lt_dlclose(ptr->handle);
	free(ptr);
}

void _php_imlib_unload_filters(TSRMLS_D)
{
	struct php_imlib_filter* f_ptr;

	f_ptr=IMLIBG(filters);
	while (f_ptr!=NULL)
	{
		struct php_imlib_filter* f_ptr_next;
		f_ptr_next=f_ptr->next;
		_php_imlib_unload_filter(f_ptr);
		f_ptr=f_ptr_next;		
	}
	IMLIBG(filters)=NULL;

	lt_dlexit();
}

void _php_imlib_load_filters(TSRMLS_D)
{
	struct php_imlib_filter* f_ptr;
	char* path;
	DIR* dirp=NULL;
	struct dirent *dp;
	char** names=NULL;
	int names_size,names_index,i;
	int ltinitrv=0;

	f_ptr=IMLIBG(filters);
	if (f_ptr!=NULL) return;
#ifdef IMLIB_DEBUG
	ID_PRINTF("Initializing libltdl...");
#endif
	if ((ltinitrv=lt_dlinit())>0) goto error;

#ifdef IMLIB_DEBUG
	ID_PRINTF("Loading filters...");
#endif
	path=IMLIBG(filter_path);
	lt_dladdsearchdir(path);
#ifdef IMLIB_DEBUG
	ID_PRINTF("Opening directory %s...",path);
#endif
	if ((dirp=opendir(path))==NULL) goto error;

	names_size=20;
	names_index=0;
	if ((names=malloc(names_size*sizeof(char*)))==NULL) goto error;

#ifdef IMLIB_DEBUG
	ID_PRINTF("Scanning directory...");
#endif
	errno=0;
	while ((dp=readdir(dirp))!=NULL)
	{
		char* name;

		if ((name=strdup(dp->d_name))==NULL) goto error;
		if ((strcmp(name, ".")) && (strcmp(name, "..")))
		{
			char* ext;

			ext=strchr(name,'.');
			if (ext)
			{
				*ext='\0';
				for (i=0;i<names_index;i++)
				{
					if (strcmp(names[i],name)==0)
						break;
				}
				if (i==names_index)
				{
					if (names_index==names_size)
					{
						char** names_new;

						names_size*=2;
						names_new=realloc(names,names_size*sizeof(char*));
						if (names_new==NULL)
						{
							free(name);
							goto error;
						}
						names=names_new;
					}
#ifdef IMLIB_DEBUG
	ID_PRINTF("Found library %s",name);
#endif
					names[names_index++]=name;
				}
			}
		}
	}
	if (errno!=0) goto error;
	if (names_index>0)
	{
		IMLIBG(filters)=f_ptr=malloc(sizeof(struct php_imlib_filter));
				
		for (i=0;i<names_index;i++)
		{
			if ((f_ptr->next=_php_imlib_load_filter(names[i]))!=NULL)
				f_ptr=f_ptr->next;
		}
		IMLIBG(filters)=IMLIBG(filters)->next;
	}
	goto cleanup;

error:
#ifdef IMLIB_DEBUG
	ID_PRINTF("Error loading filters!");
#endif
	_php_imlib_unload_filters(TSRMLS_C);
cleanup:
	if (names!=NULL)
	{
		for (i=0;i<names_index;i++)
		{
			free(names[i]);
		}
		free(names);
	}
	if (dirp!=NULL) closedir(dirp);
}

struct php_imlib_filter* _php_imlib_find_filter(char *filter_name TSRMLS_DC)
{
	struct php_imlib_filter* f_ptr;
	int i;

	_php_imlib_load_filters(TSRMLS_C);
	f_ptr=IMLIBG(filters);
	while (f_ptr!=NULL)
	{
		for (i=0;i<f_ptr->filters;i++)
		{
			if (strcmp(f_ptr->names[i],filter_name)==0)
			{
				return f_ptr;
			}
		}
		f_ptr=f_ptr->next;
	}
	return NULL;
}

Imlib_Image _php_imlib_get_image(zval* im_resource)
{
	Imlib_Image im;
	TSRMLS_FETCH();
	im = (Imlib_Image) zend_fetch_resource(Z_RES_P(im_resource), le_imlib_img_name, le_imlib_img);
	return im;
}

Imlib_Filter _php_imlib_get_filter(zval* fil_resource)
{
	Imlib_Filter fil;
	TSRMLS_FETCH();
	fil = (Imlib_Filter) zend_fetch_resource(Z_RES_P(fil_resource), le_imlib_filter_name, le_imlib_filter);
	return fil;
}

void _php_imlib_color_modifier_synch(PHP_Imlib_Color_Modifier cm)
{
	if ((cm->modified)&&(!cm->valid))
	{
	    fprintf(stderr,"Panic!! Color Modifier in invalid state!");
	    return;
	}
	imlib_context_set_color_modifier(cm->cm);
        if (cm->modified)
	{
	    imlib_set_color_modifier_tables(cm->channels[0],cm->channels[1],cm->channels[2],cm->channels[3]);
	    cm->modified=0;
	}
	if (!cm->valid)
	{
	    imlib_get_color_modifier_tables(cm->channels[0],cm->channels[1],cm->channels[2],cm->channels[3]);
	    cm->valid=1;
	}
	imlib_context_set_color_modifier(NULL);
}

Imlib_Color_Modifier _php_imlib_get_cm(zval* cm_resource)
{
	PHP_Imlib_Color_Modifier cm;
	TSRMLS_FETCH();
	cm = (Imlib_Color_Modifier) zend_fetch_resource(Z_RES_P(cm_resource), le_imlib_cm_name, le_imlib_cm);
	if (cm->modified) _php_imlib_color_modifier_synch(cm);
	cm->valid=0;
	return cm->cm;
}

Imlib_Font _php_imlib_get_font(zval* font_resource)
{
	PHP_Imlib_Font php_font;
	TSRMLS_FETCH();
	php_font = (PHP_Imlib_Font) zend_fetch_resource(Z_RES_P(font_resource), le_imlib_font_name, le_imlib_font);
	return php_font->font;
}

Imlib_Color_Range _php_imlib_get_cr(zval* cr_resource)
{
	Imlib_Color_Range cr;
	TSRMLS_FETCH();
	cr = (Imlib_Color_Range) zend_fetch_resource(Z_RES_P(cr_resource), le_imlib_cr_name, le_imlib_cr);
	return cr;
}

ImlibPolygon _php_imlib_get_poly(zval* poly_resource)
{
	ImlibPolygon poly;
	TSRMLS_FETCH();
	poly = (ImlibPolygon) zend_fetch_resource(Z_RES_P(poly_resource), le_imlib_poly_name, le_imlib_poly);
	return poly;
}

#if HAVE_LIBT1

/* {{{ _php_imlib_free_ps_font
 */
ZEND_RSRC_DTOR_FUNC(_php_imlib_free_ps_font)
{
        int *font = (int *)res->ptr;

        T1_DeleteFont(*font);
        efree(font);
}
/* }}} */

/* {{{ _php_imlib_free_ps_enc
 */
ZEND_RSRC_DTOR_FUNC(_php_imlib_free_ps_enc)
{
        char **enc = (char **)res->ptr;

        T1_DeleteEncoding(enc);
}
/* }}} */

#endif


#ifdef COMPILE_DL_IMLIB
ZEND_GET_MODULE(imlib)
#endif

/* {{{ PHP_MINIT_FUNCTION
 */
ZEND_MODULE_STARTUP_D(imlib)
{
	ZEND_INIT_MODULE_GLOBALS(imlib, php_imlib_init_globals, NULL);

	le_imlib_cr = zend_register_list_destructors_ex(_php_imlib_free_cr,NULL,"imlib color range",module_number);
	le_imlib_font = zend_register_list_destructors_ex(_php_imlib_free_font,NULL,"imlib font",module_number);
	le_imlib_img = zend_register_list_destructors_ex(_php_imlib_free_img,NULL,"imlib image",module_number);
	le_imlib_poly = zend_register_list_destructors_ex(_php_imlib_free_poly,NULL,"imlib polygon",module_number);
	le_imlib_filter = zend_register_list_destructors_ex(_php_imlib_free_filter,NULL,"imlib filter",module_number);
	le_imlib_cm = zend_register_list_destructors_ex(_php_imlib_free_cm,NULL,"imlib color modifier",module_number);
#if HAVE_LIBT1
        T1_SetBitmapPad(8);
        T1_InitLib(NO_LOGFILE|IGNORE_CONFIGFILE|IGNORE_FONTDATABASE);
        T1_SetLogLevel(T1LOG_DEBUG);
        le_ps_font = zend_register_list_destructors_ex(_php_imlib_free_ps_font, NULL, "imlib PS font", module_number);
        le_ps_enc = zend_register_list_destructors_ex(_php_imlib_free_ps_enc, NULL, "imlib PS encoding", module_number);
#endif

	REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_RIGHT", IMLIB_TEXT_TO_RIGHT, CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_LEFT", IMLIB_TEXT_TO_LEFT, CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_DOWN", IMLIB_TEXT_TO_DOWN, CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_UP", IMLIB_TEXT_TO_UP, CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_TEXT_TO_ANGLE", IMLIB_TEXT_TO_ANGLE, CONST_CS|CONST_PERSISTENT);

	REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_RED", 1, CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_GREEN", 2, CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_BLUE", 4, CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_CHANNEL_ALPHA", 8, CONST_CS|CONST_PERSISTENT);

	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_NONE", IMLIB_LOAD_ERROR_NONE,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST",
	                       IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY",
	                       IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ",
	                       IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT",
	                       IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_TOO_LONG",
	                       IMLIB_LOAD_ERROR_PATH_TOO_LONG,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT",
	                       IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY",
	                       IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE",
	                       IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS",
	                       IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_OUT_OF_MEMORY",
	                       IMLIB_LOAD_ERROR_OUT_OF_MEMORY,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS",
	                       IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE",
	                       IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE",
	                       IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE,
	                       CONST_CS|CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("IMLIB_LOAD_ERROR_UNKNOWN", IMLIB_LOAD_ERROR_UNKNOWN,
	                       CONST_CS|CONST_PERSISTENT);

	REGISTER_INI_ENTRIES();

	return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(imlib)
{
	_php_imlib_unload_filters(TSRMLS_C);

	UNREGISTER_INI_ENTRIES();

	return SUCCESS;
}

PHP_RINIT_FUNCTION(imlib)
{
	char **font_list;
	char *pathbuf, *ptr, *end;
	int i, font_count;

	/* Set default cache size */
        _php_imlib_set_cache_size(IMLIBG(cache_size) TSRMLS_CC);
	font_list = imlib_list_font_path(&font_count);
	if (!font_count) {
		IMLIBG(saved_path) = NULL;
	} else {
		/* Save the current path where we can retrieve it later. */
		IMLIBG(saved_path) = (char **) emalloc(sizeof(char *) * (font_count + 1));
		for (i = 0; i < font_count; i++) {
			IMLIBG(saved_path)[i] = estrdup(font_list[i]);
		}
		IMLIBG(saved_path)[i] = NULL;

		/* Now clear the imlib path... */
		for (i = 0; i < font_count; i++) {
			imlib_remove_path_from_font_path(IMLIBG(saved_path)[i]);
		}
	}

	if (!IMLIBG(font_path)) {
		return SUCCESS;
	}

	/* And repopulate it with the ini-specified default. */
	ptr = pathbuf = estrdup(IMLIBG(font_path));

	while (ptr && *ptr) {
		end = strchr(ptr, ':');

		if (end != NULL) {
			*end = '\0';
			end++;
		}
		imlib_add_path_to_font_path(ptr);
		ptr = end;
	}
	efree(pathbuf);

	return SUCCESS;
}

PHP_RSHUTDOWN_FUNCTION(imlib)
{
	char **font_list;
	int i, font_count;

	/* Restore cache size */
        _php_imlib_set_cache_size(0 TSRMLS_CC);
	/* Retrieve the current path and clear it out. */
	font_list = imlib_list_font_path(&font_count);
	for (i = 0; i < font_count; i++) {
		imlib_remove_path_from_font_path(font_list[i]);
	}

	/* Restore the saved font path. */
	if (!IMLIBG(saved_path)) {
		return SUCCESS;
	}
	for (i = 0; IMLIBG(saved_path)[i] != NULL; i++) {
		imlib_add_path_to_font_path(IMLIBG(saved_path)[i]);
		efree(IMLIBG(saved_path)[i]);
	}

	efree(IMLIBG(saved_path));
	return SUCCESS;
}

PHP_MINFO_FUNCTION(imlib)
{
        struct php_imlib_filter* f_ptr;
        int i;
        
        _php_imlib_load_filters(TSRMLS_C);
        f_ptr=IMLIBG(filters);

	DISPLAY_INI_ENTRIES();

#ifdef HAVE_LIBT1
        php_info_print_table_start();
        php_info_print_table_row(2, "T1Lib Support", "enabled");
        php_info_print_table_end();
#endif

        while (f_ptr!=NULL)
        {
		char* extinfo[3] = {NULL, NULL, NULL};
		php_info_print_table_start();
		if (f_ptr->getextinfo) f_ptr->getextinfo(extinfo);
		if (extinfo[0])
		{
			char* infostr;
			f_ptr->getextinfo(extinfo);
			infostr=emalloc((strlen(extinfo[0])+strlen(f_ptr->filename)+4)*sizeof(char));
			strcpy(infostr,extinfo[0]);
			strcat(infostr," (");
			strcat(infostr,f_ptr->filename);
			strcat(infostr,")");
			php_info_print_table_row(2, "Filter name", infostr);
			efree(infostr);
		}
		else
		{
			php_info_print_table_row(2, "Filter name", f_ptr->filename);
		}
		if (extinfo[1]) php_info_print_table_row(2,"Description",extinfo[1]);
		if (extinfo[2]) php_info_print_table_row(2,"Author",extinfo[2]);
	
		{
			char* filters;
			filters=estrdup("");
			for (i=0;i<f_ptr->filters;i++)
			{
				int newlen;
				char* params=NULL;
				if (f_ptr->getparams) params=f_ptr->getparams(f_ptr->names[i]);
				newlen=strlen(filters)+strlen(f_ptr->names[i])+2;
				if (params) newlen+=strlen(params)+3;
				filters=erealloc(filters,newlen*sizeof(char));
				if (filters)
				{
					strcat(filters,f_ptr->names[i]);
					if (params)
					{
						strcat(filters," (");
						strcat(filters,params);
						strcat(filters,")");
					}
					strcat(filters,"\n");
				}
			}
			php_info_print_table_row(2,"Filters",filters);
			efree(filters);
		}
		f_ptr=f_ptr->next;
		php_info_print_table_end();
	}       
}

static int _php_handle_cliprect_array(zval **dbox, char *func_name,
                                      int *x, int *y, int *w, int *h TSRMLS_DC)
{
   zval *element, **box_coords;
   int i,arrcount;
   HashTable *box;

   box = HASH_OF(*dbox);
   if (!box) {
      php_error(E_WARNING, "Wrong datatype in call to %s, need array",func_name);
      return 0;
   }

   arrcount = zend_hash_num_elements(box);
   if (arrcount != 4) {
      php_error(E_WARNING, "Wrong number of array elements in call to %s, need four (x,y,w,h)",
                func_name);
      return 0;
   }

   box_coords = (zval **)emalloc(arrcount * sizeof(zval *));

   for (i = 0; i < arrcount; i++)
   {
      if (element = zend_hash_index_find(box, i))
      {
         convert_to_long_ex(element);
         box_coords[i] = element;
      }
   }
   *x = Z_LVAL_P(box_coords[0]);
   *y = Z_LVAL_P(box_coords[1]);
   *w = Z_LVAL_P(box_coords[2]);
   *h = Z_LVAL_P(box_coords[3]);

   efree(box_coords);
   return 1;
}

static int _php_handle_imlib_error(INTERNAL_FUNCTION_PARAMETERS,
                                    Imlib_Load_Error err, const char *img)
{
   int errnum;

   switch (err)
   {
      case IMLIB_LOAD_ERROR_NONE:
         errnum = 0;
         break;
      case IMLIB_LOAD_ERROR_FILE_DOES_NOT_EXIST:
         php_error(E_WARNING, "%s - File does not exist", img);
         errnum = 1;
         break;
      case IMLIB_LOAD_ERROR_FILE_IS_DIRECTORY:
         php_error(E_WARNING, "%s - Directory specified for image filename", img);
         errnum = 2;
         break;
      case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_READ:
         php_error(E_WARNING, "%s - No read access to directory", img);
         errnum = 3;
         break;
      case IMLIB_LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT:
         php_error(E_WARNING, "%s - No Imlib2 loader for that file format", img);
         errnum = 4;
         break;
      case IMLIB_LOAD_ERROR_PATH_TOO_LONG:
         php_error(E_WARNING, "%s - Path specified is too long", img);
         errnum = 5;
         break;
      case IMLIB_LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT:
         php_error(E_WARNING, "%s - Path component does not exist", img);
         errnum = 6;
         break;
      case IMLIB_LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY:
         php_error(E_WARNING, "%s - Path component is not a directory", img);
         errnum = 7;
         break;
      case IMLIB_LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE:
         php_error(E_WARNING, "%s - Path points outside address space", img);
         errnum = 8;
         break;
      case IMLIB_LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS:
         php_error(E_WARNING, "%s - Too many levels of symbolic links", img);
         errnum = 9;
         break;
      case IMLIB_LOAD_ERROR_OUT_OF_MEMORY:
         php_error(E_WARNING, "While loading %s - Out of memory", img);
         errnum = 10;
         break;
      case IMLIB_LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS:
         php_error(E_WARNING, "While loading %s - Out of file descriptors", img);
         errnum = 11;
         break;
      case IMLIB_LOAD_ERROR_PERMISSION_DENIED_TO_WRITE:
         php_error(E_WARNING, "%s - Cannot write to directory", img);
         errnum = 12;
         break;
      case IMLIB_LOAD_ERROR_OUT_OF_DISK_SPACE:
         php_error(E_WARNING, "%s - Cannot write - out of disk space", img);
         errnum = 13;
         break;
      case IMLIB_LOAD_ERROR_UNKNOWN:
      default:
         php_error(E_WARNING, "While loading %s - Unknown error.", img);
         errnum = 14;
   }
   return errnum;
}

static void _php_imlib_draw_something(INTERNAL_FUNCTION_PARAMETERS, void (*func)(), char *func_name)
{
   int argc;
   int cx, cy, cw, ch;
   zval *img, *dbox;
   zend_long x,y,w,h,r,g,b,a;
   Imlib_Image im;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "rllllllll|a", &img, &x, &y, &w, &h, &r, &g, &b, &a, &dbox) == FAILURE) {
      return;
   }

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_context_set_color(r,g,b,a);

   /* FIXME: This should take an optional antialias option, with on as default */
   imlib_context_set_anti_alias(0);

   if (argc > 9)
   {
      if (!_php_handle_cliprect_array(&dbox, func_name, &cx,&cy,&cw,&ch TSRMLS_CC))
         RETURN_FALSE;
      imlib_context_set_cliprect(cx,cy,cw,ch);
   }

   (*func)(x,y,w,h);
   imlib_context_set_cliprect(0,0,0,0);
   RETURN_TRUE;
}

static void _php_imlib_single_arg(INTERNAL_FUNCTION_PARAMETERS, void (*func)())
{
   zval *img;
   Imlib_Image im;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   (*func)();
}

/* We wrap imlib_image_draw_line, because it doesn't return a void like all
   the other drawing functions do.  So, since we don't care about
   Imlib_Updates, we're going to return our own void.  Nyeh. */
static void _php_wrap_draw_line(int x1, int y1, int x2, int y2)
{
   imlib_image_draw_line(x1,y1,x2,y2,0);
}

/* {{{ proto void imlib_add_color_to_color_range(int cr, int x, int r, int g, int b, int a)
   Add a color to a color range at a specified distance from the previous color in the range.  A distance of 0 centers it */
PHP_FUNCTION(imlib_add_color_to_color_range)
{
   zval *crange;
   zend_long x,r,g,b,a;
   Imlib_Color_Range range;

   if (zend_parse_parameters(6 TSRMLS_CC, "rlllll", &crange, &x, &r, &g, &b, &a) == FAILURE) return;

   if ((range = (Imlib_Color_Range)zend_fetch_resource(Z_RES_P(crange), le_imlib_cr_name, le_imlib_cr)) == NULL)
      RETURN_FALSE;

   imlib_context_set_color_range(range);
   imlib_context_set_color(r,g,b,a);
   imlib_add_color_to_color_range(x);
}
/* }}} */


/* {{{ proto void imlib_blend_image_onto_image(int dstimg, int srcimg, int malpha, int srcx, int srcy, int srcw, int srch, int dstx, int dsty, int dstw, int dsth, char dither, char blend, char alias)
   Blend a rectangular area from an image onto an area of another image, scaling as necessary */
PHP_FUNCTION(imlib_blend_image_onto_image)
{
   zval *dstimg, *srcimg;
   Imlib_Image dst,src;
   zend_long sx,sy,sw,sh,dx,dy,dw,dh;
   zend_long calias, calpha, cblend, cdither;

   if (zend_parse_parameters(14 TSRMLS_CC, "rrllllllllllll", &dstimg, &srcimg, &calpha, &sx, &sy, &sw, &sh, &dx, &dy, &dw, &dh, &cdither, &cblend, &calias) == FAILURE) return;

   if ((src = (Imlib_Image)zend_fetch_resource(Z_RES_P(srcimg), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;
   if ((dst = (Imlib_Image)zend_fetch_resource(Z_RES_P(dstimg), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(dst);
   imlib_context_set_anti_alias(calias);
   imlib_context_set_dither(cdither);
   imlib_context_set_blend(cblend);
   imlib_context_set_angle(0);
   imlib_blend_image_onto_image(src,calpha,sx,sy,sw,sh,dx,dy,dw,dh);
}
/* }}} */


/* {{{ proto int imlib_clone_image(int img)
   Duplicate an image */
PHP_FUNCTION(imlib_clone_image)
{
   zval *img;
   Imlib_Image src,dst;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((src = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(src);
   dst = imlib_clone_image();

   if (dst) RETURN_RES(zend_register_resource(dst, le_imlib_img));
}
/* }}} */


/* {{{ proto int imlib_create_color_range()
   Create a new color range */
PHP_FUNCTION(imlib_create_color_range)
{
   Imlib_Color_Range cr;

   if (ZEND_NUM_ARGS() != 0) {
      WRONG_PARAM_COUNT;
   }

   cr = imlib_create_color_range();

   if (cr) RETURN_RES(zend_register_resource(cr, le_imlib_cr));
}
/* }}} */


/* {{{ proto int imlib_create_color_modifier(void)
   Create a new color modifier */
PHP_FUNCTION(imlib_create_color_modifier)
{
   PHP_Imlib_Color_Modifier cm;
   
   if (ZEND_NUM_ARGS() != 0) {
      WRONG_PARAM_COUNT;
   }
   
   cm=(PHP_Imlib_Color_Modifier)emalloc(sizeof(PHP_Imlib_Color_Modifier_struct));
   if (!cm) RETURN_FALSE;
   
   cm->cm = imlib_create_color_modifier();
   cm->modified=0;
   cm->valid=0;

   if (!cm->cm) {
      efree(cm);
      RETURN_FALSE;
   }
   
   RETURN_RES(zend_register_resource(cm, le_imlib_cm));
}
/* }}} */

/* {{{ proto int imlib_create_cropped_image(int img, int srcx, int srcy, int srcw, int srch)
   Create an image from a cropped region of another image */
PHP_FUNCTION(imlib_create_cropped_image)
{
   zval *img;
   zend_long sx,sy,sw,sh;
   Imlib_Image src,dst;

   if (zend_parse_parameters(5 TSRMLS_CC, "rllll", &img, &sx, &sy, &sw, &sh) == FAILURE) return;

   if ((src = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(src);
   dst = imlib_create_cropped_image(sx,sy,sw,sh);

   if (dst) RETURN_RES(zend_register_resource(dst, le_imlib_img));
}
/* }}} */

                     
/* {{{ proto int imlib_create_cropped_scaled_image(int img, int srcx, int srcy, int srcw, int srch, int dstw, int dsth)
   Create a scaled image from a cropped region of another image */
PHP_FUNCTION(imlib_create_cropped_scaled_image)
{
   zval *img;
   zend_long sx,sy,sw,sh,dw,dh;
   Imlib_Image src,dst;

   if (zend_parse_parameters(7 TSRMLS_CC, "rllllll", &img, &sx, &sy, &sw, &sh, &dw, &dh) == FAILURE) return;

   if ((src = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(src);
   dst = imlib_create_cropped_scaled_image(sx,sy, sw,sh, dw,dh);

   if (dst) RETURN_RES(zend_register_resource(dst, le_imlib_img));
}
/* }}} */


/* {{{ proto int imlib_create_image(int w, int h)
   Create a new image with the specified dimensions */
PHP_FUNCTION(imlib_create_image)
{
   Imlib_Image im;
   zend_long x,y;

   if (zend_parse_parameters(2 TSRMLS_CC, "ll", &x, &y) == FAILURE) return;

   im = imlib_create_image(x,y);

   if (im) {
      imlib_context_set_image(im);
      memset(imlib_image_get_data(), '\0', x * y * sizeof(DATA32));

      RETURN_RES(zend_register_resource(im, le_imlib_img));
   }
}
/* }}} */


/* {{{ proto int imlib_create_rotated_image(int srcimg, int degrees[, int radians])
   Create a rotated copy of an image.  If radians is specified, degrees will be ignored. */
PHP_FUNCTION(imlib_create_rotated_image)
{

  /* Contributed by Gareth Ardron */

   zval *srcimg;
   double angle, radians;
   int argc;
   Imlib_Image src, dst;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "rd|d", &srcimg, &angle, &radians) == FAILURE) return;

   if ((src = (Imlib_Image)zend_fetch_resource(Z_RES_P(srcimg), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   if (argc == 2) radians = angle * M_PI/180;

   imlib_context_set_image(src);
   dst = imlib_create_rotated_image(radians);

   if (dst) RETURN_RES(zend_register_resource(dst, le_imlib_img));
}
/* }}} */


/* {{{ proto int imlib_create_scaled_image(int img, int dstw, int dsth)
   Create a scaled copy of an image.  If dstw or dsth is left blank, the aspect ratio of the source image will be preserved. */
PHP_FUNCTION(imlib_create_scaled_image)
{
   zval *img;
   zval *dstw, *dsth;
   long sw,sh,dw,dh;
   Imlib_Image src,dst;

   if (zend_parse_parameters(3 TSRMLS_CC, "rzz", &img, &dstw, &dsth) == FAILURE) return;

   if ((src = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   convert_to_long_ex(dstw);
   convert_to_long_ex(dsth);
   dw = Z_LVAL_P(dstw);
   dh = Z_LVAL_P(dsth);

   if (!dw && !dh) {
      RETURN_FALSE;
   }

   imlib_context_set_image(src);
   sw = imlib_image_get_width();
   sh = imlib_image_get_height();
   if (!dw) {
      dw = (long) (((double)dh * sw) / sh);
   }
   if (!dh) {
      dh = (long) (((double) dw * sh) / sw);
   }

   dst = imlib_create_cropped_scaled_image(0,0, sw,sh, dw,dh);

   if (dst) RETURN_RES(zend_register_resource(dst, le_imlib_img));
}
/* }}} */


/* {{{ proto bool imlib_dump_image(int img[, int &err[, int quality]])
   Output an image at an optional quality setting */
PHP_FUNCTION(imlib_dump_image)
{
   int argc, retval;
   zend_long q;
   FILE *tmp;
   zend_string *tmpfile;
   zval *img, *err;
   Imlib_Image im;
   Imlib_Load_Error im_err;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "r|zl", &img, &err, &q) == FAILURE) return;

   if (argc > 1) {
      zval_dtor(err);
      ZVAL_LONG(err,0);
   }

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   tmp = php_open_temporary_file("", "", &tmpfile TSRMLS_CC);
   if (tmp == NULL) {
      php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open temporary file");
      RETURN_FALSE;
   }

   imlib_context_set_image(im);
   if(!imlib_image_format()) {
      imlib_image_set_format("png");
   }

   if (argc > 2)
   {
      imlib_image_attach_data_value("quality",NULL,q,NULL);
   }

   imlib_save_image_with_error_return(tmpfile->val,&im_err);

   if (im_err)
   {
      if (argc > 1)
      {
         ZVAL_LONG(err,im_err);
      }
      _php_handle_imlib_error(INTERNAL_FUNCTION_PARAM_PASSTHRU,
                              im_err,tmpfile->val);
      fclose(tmp);
      VCWD_UNLINK(tmpfile->val); /* make sure that the temporary file is removed */
      zend_string_release(tmpfile);
      RETURN_FALSE;
   }
   else
   {
      char buf[4096];

      /* fseek or something, then read the file and dump it out. */
      fseek(tmp, 0, SEEK_SET);

#if APACHE && defined(CHARSET_EBCDIC)
      SLS_FETCH();
      /* This is a binary file already: avoid EBCDIC->ASCII conversion */
      ap_bsetflag(php3_rqst->connection->client, B_EBCDIC2ASCII, 0);
#endif
      while ((retval = fread(buf, 1, sizeof(buf), tmp)) > 0) {
         php_write(buf, retval TSRMLS_CC);
      }

      fclose(tmp);
      VCWD_UNLINK(tmpfile->val); /* make sure that the temporary file is removed */
      zend_string_release(tmpfile);

      RETURN_TRUE;
   }
}
/* }}} */


/* {{{ proto void imlib_free_color_range(int cr)
   Free a color range */
PHP_FUNCTION(imlib_free_color_range)
{
   zval *fcr;
   Imlib_Color_Range cr;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &fcr) == FAILURE) return;

   if ((cr = (Imlib_Color_Range)zend_fetch_resource(Z_RES_P(fcr), le_imlib_cr_name, le_imlib_cr)) == NULL)
      RETURN_FALSE;
   zend_list_close(Z_RES_P(fcr));
}
/* }}} */


/* {{{ proto void imlib_free_color_modifier(int cm)
   Free a color modifier */
PHP_FUNCTION(imlib_free_color_modifier)
{
   zval *fcm;
   PHP_Imlib_Color_Modifier cm;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &fcm) == FAILURE) return;

   if ((cm = (Imlib_Color_Modifier)zend_fetch_resource(Z_RES_P(fcm), le_imlib_cm_name, le_imlib_cm)) == NULL)
      RETURN_FALSE;
   zend_list_close(Z_RES_P(fcm));
}
/* }}} */

/* {{{ proto void imlib_free_font(int font)
   Free a font */
PHP_FUNCTION(imlib_free_font)
{
   zval *font;
   PHP_Imlib_Font fn;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &font) == FAILURE) return;

   if ((fn = (PHP_Imlib_Font)zend_fetch_resource(Z_RES_P(font), le_imlib_font_name, le_imlib_font)) == NULL)
      RETURN_FALSE;
   zend_list_close(Z_RES_P(font));
}
/* }}} */


/* {{{ proto void imlib_free_image(int img)
   Free an image */
PHP_FUNCTION(imlib_free_image)
{
   zval *img;
   Imlib_Image im;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;
   zend_list_close(Z_RES_P(img));
}
/* }}} */


/* {{{ proto void imlib_get_text_advance(int font, string str, int &horiz_adv, int &vert_adv, int direction)
   Determines the horizontal and vertical advance of a string if drawn with a given font in the specified direction*/
PHP_FUNCTION(imlib_get_text_advance)
{
   zval *font;
   zval *thoriz_adv, *tvert_adv;
   PHP_Imlib_Font fn;
   char *text = NULL;
   size_t text_len;
   int horiz_adv, vert_adv;
   zend_long dir;

   if (zend_parse_parameters(5 TSRMLS_CC, "rszzl", &font, &text, &text_len, &thoriz_adv, &tvert_adv, &dir) == FAILURE) return;

   if ((fn = (PHP_Imlib_Font)zend_fetch_resource(Z_RES_P(font), le_imlib_font_name, le_imlib_font)) == NULL)
      RETURN_FALSE;

   imlib_context_set_font(fn->font);
   imlib_context_set_direction(dir);
   imlib_get_text_advance(text, &horiz_adv, &vert_adv);

   zval_dtor(thoriz_adv);
   zval_dtor(tvert_adv);
   ZVAL_LONG(thoriz_adv,horiz_adv);
   ZVAL_LONG(tvert_adv,vert_adv);
}
/* }}} */


/* {{{ proto void imlib_get_text_size(int font, string str, int &w, int &h, int direction)
   Determines the width and height of a string if drawn with a given font in the specified direction */
PHP_FUNCTION(imlib_get_text_size)
{
   zval *font;
   zval *tw, *th;
   PHP_Imlib_Font fn;
   char *text = NULL;
   size_t text_len;
   int w,h;
   zend_long dir;

   if (zend_parse_parameters(5 TSRMLS_CC, "rszzl", &font, &text, &text_len, &tw, &th, &dir) == FAILURE) return;

   if ((fn = (PHP_Imlib_Font)zend_fetch_resource(Z_RES_P(font), le_imlib_font_name, le_imlib_font)) == NULL)
      RETURN_FALSE;

   zval_dtor(tw);
   zval_dtor(th);

   imlib_context_set_font(fn->font);
   imlib_context_set_direction(dir);
   imlib_get_text_size(text, &w, &h);

   ZVAL_LONG(tw,w);
   ZVAL_LONG(th,h);
}
/* }}} */


/* {{{ proto void imlib_image_blur(int img, int radius)
   Blur an image with a given blur radius */
PHP_FUNCTION(imlib_image_blur)
{
   zval *img;
   zend_long r;
   Imlib_Image im;

   if (zend_parse_parameters(2 TSRMLS_CC, "rl", &img, &r) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_image_blur(r);
}
/* }}} */


/* {{{ proto bool imlib_image_draw_ellipse(int img, int xc, int yc, int w, int h, int r, int g, int b, int a[, array cliprect])
   Draw an ellipse of the specified size and color on an image */
PHP_FUNCTION(imlib_image_draw_ellipse)
{
   _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_draw_ellipse,
                             "imlib_image_draw_ellipse");
}
/* }}} */


/* {{{ proto bool imlib_image_draw_line(int img, int x1, int y1, int x2, int y2, int r, int g, int b, int a[, array cliprect])
   Draw a line of the specified size and color on an image */
PHP_FUNCTION(imlib_image_draw_line)
{
   _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,_php_wrap_draw_line,
                             "imlib_image_draw_ellipse");
}
/* }}} */


/* {{{ proto bool imlib_image_draw_polygon(int img, int polygon, bool closed, int r, int g, int b, int a[, array cliprect])
   Draw the defined polygon on an image */
PHP_FUNCTION(imlib_image_draw_polygon)
{
   zval *img, *polygon, *dbox;
   zend_long r,g,b,a;
   int cx,cy,cw,ch,argc;
   Imlib_Image im;
   ImlibPolygon poly;
   zend_bool closed;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "rrbllll|a", &img, &polygon, &closed, &r, &g, &b, &a, &dbox) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;
   if ((poly = (ImlibPolygon)zend_fetch_resource(Z_RES_P(polygon), le_imlib_poly_name, le_imlib_poly)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_context_set_color(r,g,b,a);

   if (argc > 7)
   {
      if (!_php_handle_cliprect_array(&dbox, "imlib_image_draw_polygon", &cx, &cy, &cw, &ch TSRMLS_CC))
         RETURN_FALSE;
      imlib_context_set_cliprect(cx,cy,cw,ch);
   }

   imlib_image_draw_polygon(poly,closed);
   imlib_context_set_cliprect(0,0,0,0);
}
/* }}} */


/* {{{ proto bool imlib_image_draw_rectangle(int img, int x, int y, int w, int h, int r, int g, int b, int a[, array cliprect])
   Draw a rectangle of the specified size and color on an image */
PHP_FUNCTION(imlib_image_draw_rectangle)
{
   _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_draw_rectangle,
                             "imlib_image_draw_rectangle");
}
/* }}} */


/* {{{ proto bool imlib_image_fill_color_range_rectangle(int im, int cr, int x, int y, int width, int height, int angle)
   Fill a rectangle with a color range at a given angle on an image */
PHP_FUNCTION(imlib_image_fill_color_range_rectangle)
{
   zval *fim, *fcr, *fbox;
   zend_long x,y,width,height;
   int argc,cx,cy,cw,ch;
   double angle;
   Imlib_Image im;
   Imlib_Color_Range cr;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "rrlllld|a", &fim, &fcr, &x, &y, &width, &height, &angle, &fbox) == FAILURE) return;

   if ((cr = (Imlib_Color_Range)zend_fetch_resource(Z_RES_P(fcr), le_imlib_cr_name, le_imlib_cr)) == NULL)
      RETURN_FALSE;
   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(fim), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_color_range(cr);
   imlib_context_set_image(im);

   if (argc > 7)
   {
      if (!_php_handle_cliprect_array(&fbox, "imlib_image_fill_color_range_rectangle", &cx,&cy,&cw,&ch TSRMLS_CC))
         RETURN_FALSE;
      imlib_context_set_cliprect(cx,cy,cw,ch);
   }

   imlib_image_fill_color_range_rectangle(x,y,width,height, angle);
   imlib_context_set_cliprect(0,0,0,0);
   RETURN_TRUE;
}
/* }}} */


/* {{{ proto void imlib_image_fill_ellipse(int img, int xc, int yc, int w, int h, int r, int g, int b, int a[, array cliprect])
   Fill an ellipse of the specified size and color on an image */
PHP_FUNCTION(imlib_image_fill_ellipse)
{
   _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_fill_ellipse,
                             "imlib_image_fill_ellipse");
}
/* }}} */


/* {{{ proto bool imlib_image_fill_polygon(int img, int polygon, int r, int g, int b, int a[, array cliprect])
   Draw and fill the defined polygon on an image */
PHP_FUNCTION(imlib_image_fill_polygon)
{
   zval *img, *polygon, *dbox;
   zend_long r,g,b,a;
   int cx,cy,cw,ch,argc;
   Imlib_Image im;
   ImlibPolygon poly;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "rrllll|a", &img, &polygon, &r, &g, &b, &a, &dbox) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;
   if ((poly = (ImlibPolygon)zend_fetch_resource(Z_RES_P(polygon), le_imlib_poly_name, le_imlib_poly)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_context_set_color(r,g,b,a);

   if (argc > 6)
   {
      if (!_php_handle_cliprect_array(&dbox, "imlib_image_fill_polygon", &cx, &cy, &cw, &ch TSRMLS_CC))
         RETURN_FALSE;
      imlib_context_set_cliprect(cx,cy,cw,ch);
   }

   imlib_image_fill_polygon(poly);
   imlib_context_set_cliprect(0,0,0,0);
   RETURN_TRUE;
}
/* }}} */


/* {{{ proto void imlib_image_fill_rectange(int img, int x, int y, int w, int h, int r, int g, int b, int a[, array cliprect])
   Fill a rectangle of the specified size and color on an image */
PHP_FUNCTION(imlib_image_fill_rectangle)
{
   _php_imlib_draw_something(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_fill_rectangle,
                             "imlib_image_fill_rectangle");
}
/* }}} */


/* {{{ proto void imlib_image_flip_horizontal(int img)
   Flip an image horizontally */
PHP_FUNCTION(imlib_image_flip_horizontal)
{
   _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_flip_horizontal);
}
/* }}} */


/* {{{ proto void imlib_image_flip_vertical(int img)
   Flip an Imlib_Image vertically */
PHP_FUNCTION(imlib_image_flip_vertical)
{
   _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_flip_vertical);
}
/* }}} */


/* {{{ proto void imlib_image_flip_diagonal(int img)
   Flip an image diagonally */
PHP_FUNCTION(imlib_image_flip_diagonal)
{
   _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_flip_diagonal);
}
/* }}} */


/* {{{ proto void imlib_image_orientate(int img, int stepping)
   Orientate an image 90 x steps */
PHP_FUNCTION(imlib_image_orientate)
{

  /* Contributed by Gareth Ardron */

   zval *img;
   zend_long r;
   Imlib_Image im;

   if (zend_parse_parameters(2 TSRMLS_CC, "rl", &img, &r) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_image_orientate(r);
}
/* }}} */


/* {{{ proto string imlib_image_format(int img)
   Returns the image format of an image */
PHP_FUNCTION(imlib_image_format)
{
   zval *img;
   Imlib_Image im;
   char *name;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   name = imlib_image_format();
   if (!name)
      RETURN_FALSE;

   RETURN_STRING(name);
}
/* }}} */


/* {{{ proto string imlib_image_get_filename(int img)
   Returns the filename of an image */
PHP_FUNCTION(imlib_image_get_filename)
{
   zval *img;
   Imlib_Image im;
   const char *name = NULL;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   name = imlib_image_get_filename();
   if (!name)
      RETURN_FALSE;

   RETURN_STRING((char*)name);
}
/* }}} */


/* {{{ proto int imlib_image_get_height(int img)
   Returns the height of an image */
PHP_FUNCTION(imlib_image_get_height)
{
   zval *img;
   Imlib_Image im;
   int height;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   height = imlib_image_get_height();

   RETURN_LONG((long)height);
}
/* }}} */


/* {{{ proto int imlib_image_get_width(int img)
   Returns the width of an image */
PHP_FUNCTION(imlib_image_get_width)
{
   zval *img;
   Imlib_Image im;
   int width;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   width = imlib_image_get_width();

   RETURN_LONG((long)width);
}
/* }}} */


/* {{{ proto bool imlib_image_has_alpha(int img)
   Return a boolean for whether or not an image has an alpha channel */
PHP_FUNCTION(imlib_image_has_alpha)
{
   zval *img;
   Imlib_Image im;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &img) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   if (imlib_image_has_alpha())
   {
      RETURN_TRUE;
   }
   else
   {
      RETURN_FALSE;
   }
}
/* }}} */


/* {{{ proto void imlib_image_modify_alpha(int img, int alpha)
   Set the alpha channel of an image, or modify it if one was already present */
PHP_FUNCTION(imlib_image_modify_alpha)
{
   zval *img;
   Imlib_Image im;
   DATA8 map[256];
   Imlib_Color_Modifier *cmod;
   zend_long malpha;
   int i;
   double ratio;

   if (zend_parse_parameters(2 TSRMLS_CC, "rl", &img, &malpha) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   ratio = ((double)malpha) / 255;

   imlib_context_set_image(im);
   if (imlib_image_has_alpha())
   {
      for (i = 0; i < 256; i++)
         map[i] = (DATA8) (i * ratio);
   }
   else
   {
      for (i = 0; i < 256; i++)
         map[i] = malpha;
      imlib_image_set_has_alpha(1);
   }

   cmod = imlib_create_color_modifier();
   imlib_context_set_color_modifier(cmod);
   imlib_set_color_modifier_tables(NULL, NULL, NULL, map);
   imlib_apply_color_modifier();
   imlib_free_color_modifier();
}
/* }}} */


/* {{{ proto void imlib_image_set_format(int img, string format)
   Sets the image format of an image. */
PHP_FUNCTION(imlib_image_set_format)
{
   zval *img;
   Imlib_Image im;
   char *format;
   size_t format_len;

   if (zend_parse_parameters(2 TSRMLS_CC, "rs", &img, &format, &format_len) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_image_set_format(format);

   RETURN_TRUE;
}
/* }}} */


/* {{{ proto void imlib_image_sharpen(int img, int radius)
   Sharpen an image with a given sharpen radius */
PHP_FUNCTION(imlib_image_sharpen)
{
   zval *img;
   zend_long r;
   Imlib_Image im;

   if (zend_parse_parameters(2 TSRMLS_CC, "rl", &img, &r) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_image_sharpen(r);
}
/* }}} */


/* {{{ proto void imlib_image_tile_horizontal(int img)
   Tile an image horizontally */
PHP_FUNCTION(imlib_image_tile_horizontal)
{
   _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_tile_horizontal);
}
/* }}} */


/* {{{ proto void imlib_image_tile_vertical(int img)
   Tile an image vertically */
PHP_FUNCTION(imlib_image_tile_vertical)
{
   _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_tile_vertical);
}
/* }}} */


/* {{{ proto void imlib_image_tile(int img)
   Tile an image horizontally and diagonally */
PHP_FUNCTION(imlib_image_tile)
{
   _php_imlib_single_arg(INTERNAL_FUNCTION_PARAM_PASSTHRU,imlib_image_tile);
}
/* }}} */


/* {{{ proto array imlib_list_fonts()
   Return an array of all the fonts available in the font path */
PHP_FUNCTION(imlib_list_fonts)
{
   int fcount, i;
   char **flist = imlib_list_fonts(&fcount);

   if (array_init(return_value) == FAILURE) {
      php_error(E_WARNING, "Cannot initialize return value");
      RETURN_FALSE;
   }

   if (!fcount)
      RETURN_FALSE;

   for (i = 0; i < fcount; i++)
   {
      add_next_index_string(return_value, flist[i]);
   }

   imlib_free_font_list(flist,fcount);
}
/* }}} */


/* {{{ proto int imlib_load_font(string fontname)
   Load a font */
PHP_FUNCTION(imlib_load_font)
{
   char *fontname;
   size_t fontname_len;
   PHP_Imlib_Font fn;
   int argc;

   if (zend_parse_parameters(1 TSRMLS_CC, "s", &fontname, &fontname_len) == FAILURE) return;

   fn=(PHP_Imlib_Font)emalloc(sizeof(PHP_Imlib_Font_struct));
   if (!fn) RETURN_FALSE;

   fn->font = imlib_load_font(fontname);

   if (!fn->font)
   {
      efree(fn);
      php_error(E_WARNING, "%s - Could not load font.", fontname);
      RETURN_FALSE;
   }

   RETURN_RES(zend_register_resource(fn, le_imlib_font));
}
/* }}} */


/* {{{ proto int imlib_load_image(string img[, int &err])
   Load a file into an image, optionally fetch an error parameter */
PHP_FUNCTION(imlib_load_image)
{
   zval *err;
   int argc;
   Imlib_Image im;
   Imlib_Load_Error im_err;
   FILE* f;
   zend_string* filename;
   char* img;
   size_t img_len;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "s|z", &img, &img_len, &err) == FAILURE) return;

   if (argc == 2) {
      zval_dtor(err);
      ZVAL_LONG(err,0);
   }

   f = php_stream_open_wrapper_as_file(img, "rb", IGNORE_PATH | REPORT_ERRORS, &filename);
   if (f == NULL) RETURN_FALSE;

   im = imlib_load_image_with_error_return(filename->val, &im_err);

   fclose(f);
   zend_string_release(filename);

   if ((im_err) || (!im))
   {
      if (argc == 2) {
         ZVAL_LONG(err,im_err);
      }
      _php_handle_imlib_error(INTERNAL_FUNCTION_PARAM_PASSTHRU,
                              im_err,img);
      RETURN_FALSE;
   }
   else
   {
      RETURN_RES(zend_register_resource(im, le_imlib_img));
   }
}
/* }}} */


/* {{{ proto void imlib_polygon_add_point(int polygon, int x, int y)
   Add a point to a given polygon */
PHP_FUNCTION(imlib_polygon_add_point)
{
   zval *polygon;
   zend_long x,y;
   ImlibPolygon poly;

   if (zend_parse_parameters(3 TSRMLS_CC, "rll", &polygon, &x, &y) == FAILURE) return;

   if ((poly = (ImlibPolygon)zend_fetch_resource(Z_RES_P(polygon), le_imlib_poly_name, le_imlib_poly)) == NULL)
      RETURN_FALSE;

   imlib_polygon_add_point(poly,x,y);
}
/* }}} */


/* {{{ proto bool imlib_polygon_contains_point(int polygon, int x, int y)
   Check if a give point is inside a polygon */
PHP_FUNCTION(imlib_polygon_contains_point)
{
   zval *polygon;
   zend_long x,y;
   int ret;
   ImlibPolygon poly;

   if (zend_parse_parameters(3 TSRMLS_CC, "rll", &polygon, &x, &y) == FAILURE) return;

   if ((poly = (ImlibPolygon)zend_fetch_resource(Z_RES_P(polygon), le_imlib_poly_name, le_imlib_poly)) == NULL)
      RETURN_FALSE;

   ret = imlib_polygon_contains_point(poly,x,y);

   if (ret)
   {
      RETURN_TRUE;
   }
   else
   {
      RETURN_FALSE;
   }
}
/* }}} */


/* {{{ proto void imlib_polygon_free(int polygon)
   Free a polygon */
PHP_FUNCTION(imlib_polygon_free)
{
   zval *polygon;
   ImlibPolygon poly;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &polygon) == FAILURE) return;

   if ((poly = (ImlibPolygon)zend_fetch_resource(Z_RES_P(polygon), le_imlib_poly_name, le_imlib_poly)) == NULL)
      RETURN_FALSE;
   zend_list_close(Z_RES_P(polygon));
}
/* }}} */


/* {{{ proto void imlib_polygon_get_bounds(int polygon, int &x1, int &y1, int &x2, int &y2)
   Get the bounding coords of a polygon */
PHP_FUNCTION(imlib_polygon_get_bounds)
{
   zval *polygon;
   zval *px1, *py1, *px2, *py2;
   int x1,y1,x2,y2;
   ImlibPolygon poly;

   if (zend_parse_parameters(5 TSRMLS_CC, "rzzzz", &polygon, &px1, &py1, &px2, &py2) == FAILURE) return;

   if ((poly = (ImlibPolygon)zend_fetch_resource(Z_RES_P(polygon), le_imlib_poly_name, le_imlib_poly)) == NULL)
      RETURN_FALSE;

   zval_dtor(px1);
   zval_dtor(py1);
   zval_dtor(px2);
   zval_dtor(py2);

   imlib_polygon_get_bounds(poly,&x1,&y1,&x2,&y2);

   ZVAL_LONG(px1,x1);
   ZVAL_LONG(py1,y1);
   ZVAL_LONG(px2,x2);
   ZVAL_LONG(py2,y2);
}
/* }}} */


/* {{{ proto int imlib_polygon_new()
   Create a new polygon */
PHP_FUNCTION(imlib_polygon_new)
{
   ImlibPolygon poly;

   if (ZEND_NUM_ARGS() != 0) {
      WRONG_PARAM_COUNT;
   }

   poly = imlib_polygon_new();
   if (poly) RETURN_RES(zend_register_resource(poly, le_imlib_poly));
}
/* }}} */


/* {{{ proto bool imlib_save_image(int img, string name[, int &err[, int quality]])
   Save an image to a file, at an optional quality level (1-100) for jpegs.  For pngs, the value will be converted to a compression level (0-9) */
PHP_FUNCTION(imlib_save_image)
{
   zval *img, *err;
   char* name;
   size_t name_len;
   Imlib_Image im;
   Imlib_Load_Error im_err;
   int argc;
   zend_long q;
   zend_string* filename;
   FILE* f;

   argc = ZEND_NUM_ARGS();
   if (zend_parse_parameters(argc TSRMLS_CC, "rs|zl", &img, &name, &name_len, &err, &q) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);

   if (argc > 2) {
      zval_dtor(err);
      ZVAL_LONG(err,0);
   }

   if (argc > 3)
   {
      imlib_image_attach_data_value("quality",NULL,q,NULL);
   }

   f = php_stream_open_wrapper_as_file(name, "wb", IGNORE_PATH | REPORT_ERRORS, &filename);
   if (f == NULL) RETURN_FALSE;

   imlib_save_image_with_error_return(filename->val, &im_err);

   fclose(f);
   zend_string_release(filename);

   if (im_err)
   {
      if (argc > 2)
      {
         ZVAL_LONG(err,im_err);
      }
      _php_handle_imlib_error(INTERNAL_FUNCTION_PARAM_PASSTHRU,
                              im_err,name);
      RETURN_FALSE;
   }

   RETURN_TRUE;
}
/* }}} */


/* {{{ proto void imlib_text_draw(int img, int font, int x, int y, string str, int direction, int r, int g, int b, int a)
   Draw a text string using a font onto an image */
PHP_FUNCTION(imlib_text_draw)
{                               
   zval *img, *font;
   Imlib_Image im;
   PHP_Imlib_Font fn;
   char *text;
   size_t text_len;
   zend_long x,y,dir,r,g,b,a;

   if (zend_parse_parameters(10 TSRMLS_CC, "rrllslllll", &img, &font, &x, &y, &text, &text_len, &dir, &r, &g, &b, &a) == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;
   if ((fn = (PHP_Imlib_Font)zend_fetch_resource(Z_RES_P(font), le_imlib_font_name, le_imlib_font)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_context_set_color(r,g,b,a);
   imlib_context_set_font(fn->font);
   imlib_context_set_direction(dir);
   imlib_text_draw(x, y, text);

   RETURN_TRUE;	/* TODO: Useful return value? */
}
/* }}} */
                        
/* {{{ proto int imlib_get_cache_size() 
   Get the size of image cache */
PHP_FUNCTION(imlib_get_cache_size)
{
   RETURN_LONG((long)imlib_get_cache_size());
}
/* }}} */

/* {{{ proto void imlib_set_cache_size(int bytes) 
   Set the size of image cache */
PHP_FUNCTION(imlib_set_cache_size)
{
   zend_long size;
   if (zend_parse_parameters(1 TSRMLS_CC, "l", &size) == FAILURE) return;
   _php_imlib_set_cache_size(size TSRMLS_CC);
   RETURN_TRUE;
}
/* }}} */

/* {{{ proto void imlib_apply_filter(int img, string filter, array params) 
   Apply external filter to an image */
PHP_FUNCTION(imlib_apply_filter)
{
   zval *img, *tparams;
   Imlib_Image im;
   struct php_imlib_filter* filter;
   char* filter_name;
   size_t filter_name_len;
   HashTable* arg_ht;
   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|a", &img, &filter_name, &filter_name_len, &tparams) == FAILURE) return;
   
   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;

   filter = _php_imlib_find_filter(filter_name TSRMLS_CC);

   if (!filter) {
      php_error(E_WARNING, "%s - Filter not found.", filter_name);
      RETURN_FALSE;
   }

   arg_ht=HASH_OF(tparams);

/* ID_PRINTF("Image before: %p",im); */
   if (filter->exec(im, filter_name, arg_ht)==FAILURE)
   {
      php_error(E_WARNING, "Error executing filter %s.", filter_name);
      RETURN_FALSE;
   }
/* ID_PRINTF("Image after: %p",imlib_context_get_image()); */
   
   RETURN_TRUE;
}
/* }}} */

/* {{{ proto int imlib_create_filter(void)
   Create a new filter */
PHP_FUNCTION(imlib_create_filter)
{
   Imlib_Filter fil;

   if (ZEND_NUM_ARGS() != 0) {
      WRONG_PARAM_COUNT;
   }

   fil = imlib_create_filter(0);

   if (fil) RETURN_RES(zend_register_resource(fil, le_imlib_filter));
}
/* }}} */


/* {{{ proto void imlib_free_filter(int filter)
   Free a filter */
PHP_FUNCTION(imlib_free_filter)
{
   zval *filter;
   Imlib_Filter fil;

   if (zend_parse_parameters(1 TSRMLS_CC, "r", &filter) == FAILURE) return;

   if ((fil = (Imlib_Filter)zend_fetch_resource(Z_RES_P(filter), le_imlib_filter_name, le_imlib_filter)) == NULL)
      RETURN_FALSE;
   zend_list_close(Z_RES_P(filter));
}
/* }}} */

/* {{{ proto void imlib_image_filter(int img, int filter)
   Apply filter to an image */
PHP_FUNCTION(imlib_image_filter)
{
   zval *filter, *img;
   Imlib_Filter fil;
   Imlib_Image im;

   if (zend_parse_parameters(2 TSRMLS_CC, "rr", &img, &filter)  == FAILURE) return;

   if ((im = (Imlib_Image)zend_fetch_resource(Z_RES_P(img), le_imlib_img_name, le_imlib_img)) == NULL)
      RETURN_FALSE;
   if ((fil = (Imlib_Filter)zend_fetch_resource(Z_RES_P(filter), le_imlib_filter_name, le_imlib_filter)) == NULL)
      RETURN_FALSE;

   imlib_context_set_image(im);
   imlib_context_set_filter(fil);
   imlib_image_filter();   
}
/* }}} */

static void _php_imlib_filter_set(INTERNAL_FUNCTION_PARAMETERS, int type)
{
    zval *filter;
    int argc;
    zend_long xoff,yoff,a,r,g,b;
    Imlib_Filter fil;
	
    if (zend_parse_parameters(7 TSRMLS_CC, "rllllll", &filter, &xoff, &yoff, &a, &r, &g, &b) == FAILURE) return;
	
   if ((fil = (Imlib_Filter)zend_fetch_resource(Z_RES_P(filter), le_imlib_filter_name, le_imlib_filter)) == NULL)
      RETURN_FALSE;
	
    imlib_context