#include <config.h>
#include <stdio.h>
#include <math.h>
#include <ctype.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#define XLIB_ILLEGAL_ACCESS
#include "lisp.h"
#include "frame.h"
#include "window.h"
#include "dispextern.h"
#include "blockinput.h"
#include "systime.h"
#include <epaths.h>
#include "charset.h"
#include "coding.h"
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#include <sys/types.h>
#include <sys/stat.h>
#define COLOR_TABLE_SUPPORT 1
typedef struct x_bitmap_record Bitmap_Record;
#define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
#define NO_PIXMAP None
#define RGB_PIXEL_COLOR unsigned long
#define PIX_MASK_RETAIN 0
#define PIX_MASK_DRAW 1
#endif
#ifdef HAVE_NTGUI
#include "w32term.h"
#undef COLOR_TABLE_SUPPORT
typedef struct w32_bitmap_record Bitmap_Record;
#define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
#define NO_PIXMAP 0
#define RGB_PIXEL_COLOR COLORREF
#define PIX_MASK_RETAIN 0
#define PIX_MASK_DRAW 1
#define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
#define x_defined_color w32_defined_color
#define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
#endif
#ifdef MAC_OS
#include "macterm.h"
#include <sys/stat.h>
#ifndef MAC_OSX
#include <alloca.h>
#include <sys/param.h>
#endif
#if TARGET_API_MAC_CARBON
#ifdef MAC_OSX
#include <QuickTime/QuickTime.h>
#else
#include <QuickTime.h>
#endif
#else
#include <Windows.h>
#include <Gestalt.h>
#include <TextUtils.h>
#include <ImageCompression.h>
#include <QuickTimeComponents.h>
#endif
#undef COLOR_TABLE_SUPPORT
#define ZPixmap 0
typedef struct mac_bitmap_record Bitmap_Record;
#define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
#define NO_PIXMAP 0
#define RGB_PIXEL_COLOR unsigned long
#define PIX_MASK_DRAW RGB_TO_ULONG(0,0,0)
#define PIX_MASK_RETAIN RGB_TO_ULONG(255,255,255)
#define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
#define x_defined_color mac_defined_color
#define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
#endif
Lisp_Object Vx_bitmap_file_path;
static void x_disable_image P_ ((struct frame *, struct image *));
static void x_edge_detection P_ ((struct frame *, struct image *, Lisp_Object,
Lisp_Object));
static void init_color_table P_ ((void));
static unsigned long lookup_rgb_color P_ ((struct frame *f, int r, int g, int b));
#ifdef COLOR_TABLE_SUPPORT
static void free_color_table P_ ((void));
static unsigned long *colors_in_color_table P_ ((int *n));
static unsigned long lookup_pixel_color P_ ((struct frame *f, unsigned long p));
#endif
#ifdef MAC_OS
static XImagePtr
XGetImage (display, pixmap, x, y, width, height, plane_mask, format)
Display *display;
Pixmap pixmap;
int x, y;
unsigned int width, height;
unsigned long plane_mask;
int format;
{
#if GLYPH_DEBUG
xassert (x == 0 && y == 0);
{
Rect ri, rp;
SetRect (&ri, 0, 0, width, height);
xassert (EqualRect (&ri, GetPixBounds (GetGWorldPixMap (pixmap), &rp)));
}
xassert (! (pixelsLocked & GetPixelsState (GetGWorldPixMap (pixmap))));
#endif
LockPixels (GetGWorldPixMap (pixmap));
return pixmap;
}
static void
XPutPixel (ximage, x, y, pixel)
XImagePtr ximage;
int x, y;
unsigned long pixel;
{
PixMapHandle pixmap = GetGWorldPixMap (ximage);
short depth = GetPixDepth (pixmap);
#if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
if (depth == 32)
{
char *base_addr = GetPixBaseAddr (pixmap);
short row_bytes = GetPixRowBytes (pixmap);
((unsigned long *) (base_addr + y * row_bytes))[x] = 0xff000000 | pixel;
}
else
#endif
if (depth == 1)
{
char *base_addr = GetPixBaseAddr (pixmap);
short row_bytes = GetPixRowBytes (pixmap);
if (pixel == PIX_MASK_DRAW)
base_addr[y * row_bytes + x / 8] |= (1 << 7) >> (x & 7);
else
base_addr[y * row_bytes + x / 8] &= ~((1 << 7) >> (x & 7));
}
else
{
CGrafPtr old_port;
GDHandle old_gdh;
RGBColor color;
GetGWorld (&old_port, &old_gdh);
SetGWorld (ximage, NULL);
color.red = RED16_FROM_ULONG (pixel);
color.green = GREEN16_FROM_ULONG (pixel);
color.blue = BLUE16_FROM_ULONG (pixel);
SetCPixel (x, y, &color);
SetGWorld (old_port, old_gdh);
}
}
static unsigned long
XGetPixel (ximage, x, y)
XImagePtr ximage;
int x, y;
{
PixMapHandle pixmap = GetGWorldPixMap (ximage);
short depth = GetPixDepth (pixmap);
#if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
if (depth == 32)
{
char *base_addr = GetPixBaseAddr (pixmap);
short row_bytes = GetPixRowBytes (pixmap);
return ((unsigned long *) (base_addr + y * row_bytes))[x] & 0x00ffffff;
}
else
#endif
if (depth == 1)
{
char *base_addr = GetPixBaseAddr (pixmap);
short row_bytes = GetPixRowBytes (pixmap);
if (base_addr[y * row_bytes + x / 8] & (1 << (~x & 7)))
return PIX_MASK_DRAW;
else
return PIX_MASK_RETAIN;
}
else
{
CGrafPtr old_port;
GDHandle old_gdh;
RGBColor color;
GetGWorld (&old_port, &old_gdh);
SetGWorld (ximage, NULL);
GetCPixel (x, y, &color);
SetGWorld (old_port, old_gdh);
return RGB_TO_ULONG (color.red >> 8, color.green >> 8, color.blue >> 8);
}
}
static void
XDestroyImage (ximg)
XImagePtr ximg;
{
UnlockPixels (GetGWorldPixMap (ximg));
}
#if USE_CG_DRAWING
static CGImageRef
mac_create_cg_image_from_image (f, img)
struct frame *f;
struct image *img;
{
Pixmap mask;
CGImageRef result = NULL;
BLOCK_INPUT;
if (img->mask)
mask = img->mask;
else
{
mask = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
img->width, img->height, 1);
if (mask)
{
CGrafPtr old_port;
GDHandle old_gdh;
Rect r;
GetGWorld (&old_port, &old_gdh);
SetGWorld (mask, NULL);
BackColor (blackColor);
SetRect (&r, 0, 0, img->width, img->height);
EraseRect (&r);
SetGWorld (old_port, old_gdh);
}
}
if (mask)
{
CreateCGImageFromPixMaps (GetGWorldPixMap (img->pixmap),
GetGWorldPixMap (mask), &result);
if (mask != img->mask)
XFreePixmap (FRAME_X_DISPLAY (f), mask);
}
UNBLOCK_INPUT;
return result;
}
#endif
#endif
int
x_bitmap_height (f, id)
FRAME_PTR f;
int id;
{
return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].height;
}
int
x_bitmap_width (f, id)
FRAME_PTR f;
int id;
{
return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].width;
}
#if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
int
x_bitmap_pixmap (f, id)
FRAME_PTR f;
int id;
{
return (int) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap;
}
#endif
#ifdef HAVE_X_WINDOWS
int
x_bitmap_mask (f, id)
FRAME_PTR f;
int id;
{
return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].mask;
}
#endif
static int
x_allocate_bitmap_record (f)
FRAME_PTR f;
{
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
int i;
if (dpyinfo->bitmaps == NULL)
{
dpyinfo->bitmaps_size = 10;
dpyinfo->bitmaps
= (Bitmap_Record *) xmalloc (dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
dpyinfo->bitmaps_last = 1;
return 1;
}
if (dpyinfo->bitmaps_last < dpyinfo->bitmaps_size)
return ++dpyinfo->bitmaps_last;
for (i = 0; i < dpyinfo->bitmaps_size; ++i)
if (dpyinfo->bitmaps[i].refcount == 0)
return i + 1;
dpyinfo->bitmaps_size *= 2;
dpyinfo->bitmaps
= (Bitmap_Record *) xrealloc (dpyinfo->bitmaps,
dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
return ++dpyinfo->bitmaps_last;
}
void
x_reference_bitmap (f, id)
FRAME_PTR f;
int id;
{
++FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].refcount;
}
int
x_create_bitmap_from_data (f, bits, width, height)
struct frame *f;
char *bits;
unsigned int width, height;
{
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
int id;
#ifdef HAVE_X_WINDOWS
Pixmap bitmap;
bitmap = XCreateBitmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
bits, width, height);
if (! bitmap)
return -1;
#endif
#ifdef HAVE_NTGUI
Pixmap bitmap;
bitmap = CreateBitmap (width, height,
FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_planes,
FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_cbits,
bits);
if (! bitmap)
return -1;
#endif
#ifdef MAC_OS
if (width % 16 != 0)
return -1;
#endif
id = x_allocate_bitmap_record (f);
#ifdef MAC_OS
dpyinfo->bitmaps[id - 1].bitmap_data = (char *) xmalloc (height * width);
bcopy (bits, dpyinfo->bitmaps[id - 1].bitmap_data, height * width);
#endif
dpyinfo->bitmaps[id - 1].file = NULL;
dpyinfo->bitmaps[id - 1].height = height;
dpyinfo->bitmaps[id - 1].width = width;
dpyinfo->bitmaps[id - 1].refcount = 1;
#ifdef HAVE_X_WINDOWS
dpyinfo->bitmaps[id - 1].pixmap = bitmap;
dpyinfo->bitmaps[id - 1].have_mask = 0;
dpyinfo->bitmaps[id - 1].depth = 1;
#endif
#ifdef HAVE_NTGUI
dpyinfo->bitmaps[id - 1].pixmap = bitmap;
dpyinfo->bitmaps[id - 1].hinst = NULL;
dpyinfo->bitmaps[id - 1].depth = 1;
#endif
return id;
}
int
x_create_bitmap_from_file (f, file)
struct frame *f;
Lisp_Object file;
{
#ifdef MAC_OS
return -1;
#endif
#ifdef HAVE_NTGUI
return -1;
#endif
#ifdef HAVE_X_WINDOWS
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
unsigned int width, height;
Pixmap bitmap;
int xhot, yhot, result, id;
Lisp_Object found;
int fd;
char *filename;
for (id = 0; id < dpyinfo->bitmaps_last; ++id)
{
if (dpyinfo->bitmaps[id].refcount
&& dpyinfo->bitmaps[id].file
&& !strcmp (dpyinfo->bitmaps[id].file, (char *) SDATA (file)))
{
++dpyinfo->bitmaps[id].refcount;
return id + 1;
}
}
fd = openp (Vx_bitmap_file_path, file, Qnil, &found, Qnil);
if (fd < 0)
return -1;
emacs_close (fd);
filename = (char *) SDATA (found);
result = XReadBitmapFile (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
filename, &width, &height, &bitmap, &xhot, &yhot);
if (result != BitmapSuccess)
return -1;
id = x_allocate_bitmap_record (f);
dpyinfo->bitmaps[id - 1].pixmap = bitmap;
dpyinfo->bitmaps[id - 1].have_mask = 0;
dpyinfo->bitmaps[id - 1].refcount = 1;
dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SBYTES (file) + 1);
dpyinfo->bitmaps[id - 1].depth = 1;
dpyinfo->bitmaps[id - 1].height = height;
dpyinfo->bitmaps[id - 1].width = width;
strcpy (dpyinfo->bitmaps[id - 1].file, SDATA (file));
return id;
#endif
}
static void
Free_Bitmap_Record (dpyinfo, bm)
Display_Info *dpyinfo;
Bitmap_Record *bm;
{
#ifdef HAVE_X_WINDOWS
XFreePixmap (dpyinfo->display, bm->pixmap);
if (bm->have_mask)
XFreePixmap (dpyinfo->display, bm->mask);
#endif
#ifdef HAVE_NTGUI
DeleteObject (bm->pixmap);
#endif
#ifdef MAC_OS
xfree (bm->bitmap_data);
bm->bitmap_data = NULL;
#endif
if (bm->file)
{
xfree (bm->file);
bm->file = NULL;
}
}
void
x_destroy_bitmap (f, id)
FRAME_PTR f;
int id;
{
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
if (id > 0)
{
Bitmap_Record *bm = &dpyinfo->bitmaps[id - 1];
if (--bm->refcount == 0)
{
BLOCK_INPUT;
Free_Bitmap_Record (dpyinfo, bm);
UNBLOCK_INPUT;
}
}
}
void
x_destroy_all_bitmaps (dpyinfo)
Display_Info *dpyinfo;
{
int i;
Bitmap_Record *bm = dpyinfo->bitmaps;
for (i = 0; i < dpyinfo->bitmaps_last; i++, bm++)
if (bm->refcount > 0)
Free_Bitmap_Record (dpyinfo, bm);
dpyinfo->bitmaps_last = 0;
}
#ifdef HAVE_X_WINDOWS
static unsigned long four_corners_best P_ ((XImagePtr ximg,
int *corners,
unsigned long width,
unsigned long height));
static int x_create_x_image_and_pixmap P_ ((struct frame *f, int width, int height,
int depth, XImagePtr *ximg,
Pixmap *pixmap));
static void x_destroy_x_image P_ ((XImagePtr ximg));
int
x_create_bitmap_mask (f, id)
struct frame *f;
int id;
{
Pixmap pixmap, mask;
XImagePtr ximg, mask_img;
unsigned long width, height;
int result;
unsigned long bg;
unsigned long x, y, xp, xm, yp, ym;
GC gc;
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
if (!(id > 0))
return -1;
pixmap = x_bitmap_pixmap (f, id);
width = x_bitmap_width (f, id);
height = x_bitmap_height (f, id);
BLOCK_INPUT;
ximg = XGetImage (FRAME_X_DISPLAY (f), pixmap, 0, 0, width, height,
~0, ZPixmap);
if (!ximg)
{
UNBLOCK_INPUT;
return -1;
}
result = x_create_x_image_and_pixmap (f, width, height, 1, &mask_img, &mask);
UNBLOCK_INPUT;
if (!result)
{
XDestroyImage (ximg);
return -1;
}
bg = four_corners_best (ximg, NULL, width, height);
for (y = 0; y < ximg->height; ++y)
{
for (x = 0; x < ximg->width; ++x)
{
xp = x != ximg->width - 1 ? x + 1 : 0;
xm = x != 0 ? x - 1 : ximg->width - 1;
yp = y != ximg->height - 1 ? y + 1 : 0;
ym = y != 0 ? y - 1 : ximg->height - 1;
if (XGetPixel (ximg, x, y) == bg
&& XGetPixel (ximg, x, yp) == bg
&& XGetPixel (ximg, x, ym) == bg
&& XGetPixel (ximg, xp, y) == bg
&& XGetPixel (ximg, xp, yp) == bg
&& XGetPixel (ximg, xp, ym) == bg
&& XGetPixel (ximg, xm, y) == bg
&& XGetPixel (ximg, xm, yp) == bg
&& XGetPixel (ximg, xm, ym) == bg)
XPutPixel (mask_img, x, y, 0);
else
XPutPixel (mask_img, x, y, 1);
}
}
xassert (interrupt_input_blocked);
gc = XCreateGC (FRAME_X_DISPLAY (f), mask, 0, NULL);
XPutImage (FRAME_X_DISPLAY (f), mask, gc, mask_img, 0, 0, 0, 0,
width, height);
XFreeGC (FRAME_X_DISPLAY (f), gc);
dpyinfo->bitmaps[id - 1].have_mask = 1;
dpyinfo->bitmaps[id - 1].mask = mask;
XDestroyImage (ximg);
x_destroy_x_image (mask_img);
return 0;
}
#endif
#define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
static struct image_type *image_types;
Lisp_Object Vimage_types;
Lisp_Object Vimage_library_alist;
static Lisp_Object Vimage_type_cache;
Lisp_Object Qxbm;
extern Lisp_Object QCwidth, QCheight, QCforeground, QCbackground, QCfile;
extern Lisp_Object QCdata, QCtype, Qcount;
extern Lisp_Object Qcenter;
Lisp_Object QCascent, QCmargin, QCrelief;
Lisp_Object QCconversion, QCcolor_symbols, QCheuristic_mask;
Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask;
Lisp_Object Qlaplace, Qemboss, Qedge_detection, Qheuristic;
Lisp_Object Vimage_cache_eviction_delay;
static Lisp_Object define_image_type P_ ((struct image_type *type, int loaded));
static struct image_type *lookup_image_type P_ ((Lisp_Object symbol));
static void image_error P_ ((char *format, Lisp_Object, Lisp_Object));
static void x_laplace P_ ((struct frame *, struct image *));
static void x_emboss P_ ((struct frame *, struct image *));
static int x_build_heuristic_mask P_ ((struct frame *, struct image *,
Lisp_Object));
#define CACHE_IMAGE_TYPE(type, status) \
do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
#define ADD_IMAGE_TYPE(type) \
do { Vimage_types = Fcons (type, Vimage_types); } while (0)
static Lisp_Object
define_image_type (type, loaded)
struct image_type *type;
int loaded;
{
Lisp_Object success;
if (!loaded)
success = Qnil;
else
{
struct image_type *p = (struct image_type *) xmalloc (sizeof *p);
bcopy (type, p, sizeof *p);
p->next = image_types;
image_types = p;
success = Qt;
}
CACHE_IMAGE_TYPE (*type->type, success);
return success;
}
static INLINE struct image_type *
lookup_image_type (symbol)
Lisp_Object symbol;
{
struct image_type *type;
if (NILP (Finit_image_library (symbol, Vimage_library_alist)))
return 0;
for (type = image_types; type; type = type->next)
if (EQ (symbol, *type->type))
break;
return type;
}
int
valid_image_p (object)
Lisp_Object object;
{
int valid_p = 0;
if (IMAGEP (object))
{
Lisp_Object tem;
for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem))
if (EQ (XCAR (tem), QCtype))
{
tem = XCDR (tem);
if (CONSP (tem) && SYMBOLP (XCAR (tem)))
{
struct image_type *type;
type = lookup_image_type (XCAR (tem));
if (type)
valid_p = type->valid_p (object);
}
break;
}
}
return valid_p;
}
static void
image_error (format, arg1, arg2)
char *format;
Lisp_Object arg1, arg2;
{
add_to_log (format, arg1, arg2);
}
enum image_value_type
{
IMAGE_DONT_CHECK_VALUE_TYPE,
IMAGE_STRING_VALUE,
IMAGE_STRING_OR_NIL_VALUE,
IMAGE_SYMBOL_VALUE,
IMAGE_POSITIVE_INTEGER_VALUE,
IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
IMAGE_NON_NEGATIVE_INTEGER_VALUE,
IMAGE_ASCENT_VALUE,
IMAGE_INTEGER_VALUE,
IMAGE_FUNCTION_VALUE,
IMAGE_NUMBER_VALUE,
IMAGE_BOOL_VALUE
};
struct image_keyword
{
char *name;
enum image_value_type type;
int mandatory_p;
int count;
Lisp_Object value;
};
static int parse_image_spec P_ ((Lisp_Object, struct image_keyword *,
int, Lisp_Object));
static Lisp_Object image_spec_value P_ ((Lisp_Object, Lisp_Object, int *));
static int
parse_image_spec (spec, keywords, nkeywords, type)
Lisp_Object spec;
struct image_keyword *keywords;
int nkeywords;
Lisp_Object type;
{
int i;
Lisp_Object plist;
if (!IMAGEP (spec))
return 0;
plist = XCDR (spec);
while (CONSP (plist))
{
Lisp_Object key, value;
key = XCAR (plist);
plist = XCDR (plist);
if (!SYMBOLP (key))
return 0;
if (!CONSP (plist))
return 0;
value = XCAR (plist);
plist = XCDR (plist);
for (i = 0; i < nkeywords; ++i)
if (strcmp (keywords[i].name, SDATA (SYMBOL_NAME (key))) == 0)
break;
if (i == nkeywords)
continue;
keywords[i].value = value;
++keywords[i].count;
if (keywords[i].count > 1)
return 0;
switch (keywords[i].type)
{
case IMAGE_STRING_VALUE:
if (!STRINGP (value))
return 0;
break;
case IMAGE_STRING_OR_NIL_VALUE:
if (!STRINGP (value) && !NILP (value))
return 0;
break;
case IMAGE_SYMBOL_VALUE:
if (!SYMBOLP (value))
return 0;
break;
case IMAGE_POSITIVE_INTEGER_VALUE:
if (!INTEGERP (value) || XINT (value) <= 0)
return 0;
break;
case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR:
if (INTEGERP (value) && XINT (value) >= 0)
break;
if (CONSP (value)
&& INTEGERP (XCAR (value)) && INTEGERP (XCDR (value))
&& XINT (XCAR (value)) >= 0 && XINT (XCDR (value)) >= 0)
break;
return 0;
case IMAGE_ASCENT_VALUE:
if (SYMBOLP (value) && EQ (value, Qcenter))
break;
else if (INTEGERP (value)
&& XINT (value) >= 0
&& XINT (value) <= 100)
break;
return 0;
case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
if (!INTEGERP (value) || XINT (value) < 0)
return 0;
break;
case IMAGE_DONT_CHECK_VALUE_TYPE:
break;
case IMAGE_FUNCTION_VALUE:
value = indirect_function (value);
if (SUBRP (value)
|| COMPILEDP (value)
|| (CONSP (value) && EQ (XCAR (value), Qlambda)))
break;
return 0;
case IMAGE_NUMBER_VALUE:
if (!INTEGERP (value) && !FLOATP (value))
return 0;
break;
case IMAGE_INTEGER_VALUE:
if (!INTEGERP (value))
return 0;
break;
case IMAGE_BOOL_VALUE:
if (!NILP (value) && !EQ (value, Qt))
return 0;
break;
default:
abort ();
break;
}
if (EQ (key, QCtype) && !EQ (type, value))
return 0;
}
for (i = 0; i < nkeywords; ++i)
if (keywords[i].mandatory_p && keywords[i].count == 0)
return 0;
return NILP (plist);
}
static Lisp_Object
image_spec_value (spec, key, found)
Lisp_Object spec, key;
int *found;
{
Lisp_Object tail;
xassert (valid_image_p (spec));
for (tail = XCDR (spec);
CONSP (tail) && CONSP (XCDR (tail));
tail = XCDR (XCDR (tail)))
{
if (EQ (XCAR (tail), key))
{
if (found)
*found = 1;
return XCAR (XCDR (tail));
}
}
if (found)
*found = 0;
return Qnil;
}
DEFUN ("image-size", Fimage_size, Simage_size, 1, 3, 0,
doc: )
(spec, pixels, frame)
Lisp_Object spec, pixels, frame;
{
Lisp_Object size;
size = Qnil;
if (valid_image_p (spec))
{
struct frame *f = check_x_frame (frame);
int id = lookup_image (f, spec);
struct image *img = IMAGE_FROM_ID (f, id);
int width = img->width + 2 * img->hmargin;
int height = img->height + 2 * img->vmargin;
if (NILP (pixels))
size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
make_float ((double) height / FRAME_LINE_HEIGHT (f)));
else
size = Fcons (make_number (width), make_number (height));
}
else
error ("Invalid image specification");
return size;
}
DEFUN ("image-mask-p", Fimage_mask_p, Simage_mask_p, 1, 2, 0,
doc: )
(spec, frame)
Lisp_Object spec, frame;
{
Lisp_Object mask;
mask = Qnil;
if (valid_image_p (spec))
{
struct frame *f = check_x_frame (frame);
int id = lookup_image (f, spec);
struct image *img = IMAGE_FROM_ID (f, id);
if (img->mask)
mask = Qt;
}
else
error ("Invalid image specification");
return mask;
}
DEFUN ("image-extension-data", Fimage_extension_data, Simage_extension_data, 1, 2, 0,
doc: )
(spec, frame)
Lisp_Object spec, frame;
{
Lisp_Object ext;
ext = Qnil;
if (valid_image_p (spec))
{
struct frame *f = check_x_frame (frame);
int id = lookup_image (f, spec);
struct image *img = IMAGE_FROM_ID (f, id);
ext = img->data.lisp_val;
}
return ext;
}
static struct image *make_image P_ ((Lisp_Object spec, unsigned hash));
static void free_image P_ ((struct frame *f, struct image *img));
static int check_image_size P_ ((struct frame *f, int width, int height));
#define MAX_IMAGE_SIZE 6.0
Lisp_Object Vmax_image_size;
static struct image *
make_image (spec, hash)
Lisp_Object spec;
unsigned hash;
{
struct image *img = (struct image *) xmalloc (sizeof *img);
xassert (valid_image_p (spec));
bzero (img, sizeof *img);
img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
xassert (img->type != NULL);
img->spec = spec;
img->data.lisp_val = Qnil;
img->ascent = DEFAULT_IMAGE_ASCENT;
img->hash = hash;
img->corners[BOT_CORNER] = -1;
return img;
}
static void
free_image (f, img)
struct frame *f;
struct image *img;
{
if (img)
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
if (img->prev)
img->prev->next = img->next;
else
c->buckets[img->hash % IMAGE_CACHE_BUCKETS_SIZE] = img->next;
if (img->next)
img->next->prev = img->prev;
c->images[img->id] = NULL;
img->type->free (f, img);
xfree (img);
}
}
int
check_image_size (f, width, height)
struct frame *f;
int width;
int height;
{
int w, h;
if (width <= 0 || height <= 0)
return 0;
if (INTEGERP (Vmax_image_size))
w = h = XINT (Vmax_image_size);
else if (FLOATP (Vmax_image_size))
{
if (f != NULL)
{
w = FRAME_PIXEL_WIDTH (f);
h = FRAME_PIXEL_HEIGHT (f);
}
else
w = h = 1024;
w = (int) (XFLOAT_DATA (Vmax_image_size) * w);
h = (int) (XFLOAT_DATA (Vmax_image_size) * h);
}
else
return 1;
return (width <= w && height <= h);
}
void
prepare_image_for_display (f, img)
struct frame *f;
struct image *img;
{
EMACS_TIME t;
EMACS_GET_TIME (t);
img->timestamp = EMACS_SECS (t);
if (img->pixmap == NO_PIXMAP && !img->load_failed_p)
img->load_failed_p = img->type->load (f, img) == 0;
#if defined (MAC_OS) && USE_CG_DRAWING
if (!img->load_failed_p && img->data.ptr_val == NULL)
{
img->data.ptr_val = mac_create_cg_image_from_image (f, img);
if (img->data.ptr_val == NULL)
{
img->load_failed_p = 1;
img->type->free (f, img);
}
}
#endif
}
int
image_ascent (img, face, slice)
struct image *img;
struct face *face;
struct glyph_slice *slice;
{
int height;
int ascent;
if (slice->height == img->height)
height = img->height + img->vmargin;
else if (slice->y == 0)
height = slice->height + img->vmargin;
else
height = slice->height;
if (img->ascent == CENTERED_IMAGE_ASCENT)
{
if (face->font)
{
#ifdef HAVE_NTGUI
ascent = height / 2 - (FONT_DESCENT(face->font)
- FONT_BASE(face->font)) / 2;
#else
ascent = (height + face->font->ascent - face->font->descent + 1) / 2;
#endif
}
else
ascent = height / 2;
}
else
ascent = (int) (height * img->ascent / 100.0);
return ascent;
}
static RGB_PIXEL_COLOR
four_corners_best (ximg, corners, width, height)
XImagePtr_or_DC ximg;
int *corners;
unsigned long width, height;
{
RGB_PIXEL_COLOR corner_pixels[4], best;
int i, best_count;
if (corners && corners[BOT_CORNER] >= 0)
{
corner_pixels[0] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[TOP_CORNER]);
corner_pixels[1] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[TOP_CORNER]);
corner_pixels[2] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[BOT_CORNER] - 1);
corner_pixels[3] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[BOT_CORNER] - 1);
}
else
{
corner_pixels[0] = GET_PIXEL (ximg, 0, 0);
corner_pixels[1] = GET_PIXEL (ximg, width - 1, 0);
corner_pixels[2] = GET_PIXEL (ximg, width - 1, height - 1);
corner_pixels[3] = GET_PIXEL (ximg, 0, height - 1);
}
for (i = best_count = 0; i < 4; ++i)
{
int j, n;
for (j = n = 0; j < 4; ++j)
if (corner_pixels[i] == corner_pixels[j])
++n;
if (n > best_count)
best = corner_pixels[i], best_count = n;
}
return best;
}
#ifdef HAVE_NTGUI
#define Destroy_Image(img_dc, prev) \
do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
#define Free_Pixmap(display, pixmap) \
DeleteObject (pixmap)
#else
#define Destroy_Image(ximg, dummy) \
XDestroyImage (ximg)
#define Free_Pixmap(display, pixmap) \
XFreePixmap (display, pixmap)
#endif
RGB_PIXEL_COLOR
image_background (img, f, ximg)
struct image *img;
struct frame *f;
XImagePtr_or_DC ximg;
{
if (! img->background_valid)
{
int free_ximg = !ximg;
#ifdef HAVE_NTGUI
HGDIOBJ prev;
#endif
if (free_ximg)
{
#ifndef HAVE_NTGUI
ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
0, 0, img->width, img->height, ~0, ZPixmap);
#else
HDC frame_dc = get_frame_dc (f);
ximg = CreateCompatibleDC (frame_dc);
release_frame_dc (f, frame_dc);
prev = SelectObject (ximg, img->pixmap);
#endif
}
img->background = four_corners_best (ximg, img->corners, img->width, img->height);
if (free_ximg)
Destroy_Image (ximg, prev);
img->background_valid = 1;
}
return img->background;
}
int
image_background_transparent (img, f, mask)
struct image *img;
struct frame *f;
XImagePtr_or_DC mask;
{
if (! img->background_transparent_valid)
{
if (img->mask)
{
int free_mask = !mask;
#ifdef HAVE_NTGUI
HGDIOBJ prev;
#endif
if (free_mask)
{
#ifndef HAVE_NTGUI
mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
0, 0, img->width, img->height, ~0, ZPixmap);
#else
HDC frame_dc = get_frame_dc (f);
mask = CreateCompatibleDC (frame_dc);
release_frame_dc (f, frame_dc);
prev = SelectObject (mask, img->mask);
#endif
}
img->background_transparent
= (four_corners_best (mask, img->corners, img->width, img->height) == PIX_MASK_RETAIN);
if (free_mask)
Destroy_Image (mask, prev);
}
else
img->background_transparent = 0;
img->background_transparent_valid = 1;
}
return img->background_transparent;
}
static void x_clear_image_1 P_ ((struct frame *, struct image *, int,
int, int));
static void x_clear_image P_ ((struct frame *f, struct image *img));
static unsigned long x_alloc_image_color P_ ((struct frame *f,
struct image *img,
Lisp_Object color_name,
unsigned long dflt));
static void
x_clear_image_1 (f, img, pixmap_p, mask_p, colors_p)
struct frame *f;
struct image *img;
int pixmap_p, mask_p, colors_p;
{
if (pixmap_p && img->pixmap)
{
Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
img->pixmap = NO_PIXMAP;
img->background_valid = 0;
}
if (mask_p && img->mask)
{
Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
img->mask = NO_PIXMAP;
img->background_transparent_valid = 0;
}
if (colors_p && img->ncolors)
{
#ifdef HAVE_X_WINDOWS
x_free_colors (f, img->colors, img->ncolors);
#endif
xfree (img->colors);
img->colors = NULL;
img->ncolors = 0;
}
#if defined (MAC_OS) && USE_CG_DRAWING
if (img->data.ptr_val)
{
CGImageRelease (img->data.ptr_val);
img->data.ptr_val = NULL;
}
#endif
}
static void
x_clear_image (f, img)
struct frame *f;
struct image *img;
{
BLOCK_INPUT;
x_clear_image_1 (f, img, 1, 1, 1);
UNBLOCK_INPUT;
}
static unsigned long
x_alloc_image_color (f, img, color_name, dflt)
struct frame *f;
struct image *img;
Lisp_Object color_name;
unsigned long dflt;
{
XColor color;
unsigned long result;
xassert (STRINGP (color_name));
if (x_defined_color (f, SDATA (color_name), &color, 1))
{
++img->ncolors;
img->colors =
(unsigned long *) xrealloc (img->colors,
img->ncolors * sizeof *img->colors);
img->colors[img->ncolors - 1] = color.pixel;
result = color.pixel;
}
else
result = dflt;
return result;
}
static void cache_image P_ ((struct frame *f, struct image *img));
static void postprocess_image P_ ((struct frame *, struct image *));
struct image_cache *
make_image_cache ()
{
struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
int size;
bzero (c, sizeof *c);
c->size = 50;
c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
c->buckets = (struct image **) xmalloc (size);
bzero (c->buckets, size);
return c;
}
void
free_image_cache (f)
struct frame *f;
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
if (c)
{
int i;
xassert (c->refcount == 0);
for (i = 0; i < c->used; ++i)
free_image (f, c->images[i]);
xfree (c->images);
xfree (c->buckets);
xfree (c);
FRAME_X_IMAGE_CACHE (f) = NULL;
}
}
void
clear_image_cache (f, force_p)
struct frame *f;
int force_p;
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
if (c && INTEGERP (Vimage_cache_eviction_delay))
{
EMACS_TIME t;
unsigned long old;
int i, nfreed;
EMACS_GET_TIME (t);
old = EMACS_SECS (t) - XFASTINT (Vimage_cache_eviction_delay);
BLOCK_INPUT;
for (i = nfreed = 0; i < c->used; ++i)
{
struct image *img = c->images[i];
if (img != NULL
&& (force_p || img->timestamp < old))
{
free_image (f, img);
++nfreed;
}
}
if (nfreed)
{
Lisp_Object tail, frame;
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
if (FRAME_WINDOW_P (f)
&& FRAME_X_IMAGE_CACHE (f) == c)
clear_current_matrices (f);
}
++windows_or_buffers_changed;
}
UNBLOCK_INPUT;
}
}
DEFUN ("clear-image-cache", Fclear_image_cache, Sclear_image_cache,
0, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
if (EQ (frame, Qt))
{
Lisp_Object tail;
FOR_EACH_FRAME (tail, frame)
if (FRAME_WINDOW_P (XFRAME (frame)))
clear_image_cache (XFRAME (frame), 1);
}
else
clear_image_cache (check_x_frame (frame), 1);
return Qnil;
}
static void
postprocess_image (f, img)
struct frame *f;
struct image *img;
{
if (img->pixmap)
{
Lisp_Object conversion, spec;
Lisp_Object mask;
spec = img->spec;
mask = image_spec_value (spec, QCheuristic_mask, NULL);
if (!NILP (mask))
x_build_heuristic_mask (f, img, mask);
else
{
int found_p;
mask = image_spec_value (spec, QCmask, &found_p);
if (EQ (mask, Qheuristic))
x_build_heuristic_mask (f, img, Qt);
else if (CONSP (mask)
&& EQ (XCAR (mask), Qheuristic))
{
if (CONSP (XCDR (mask)))
x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
else
x_build_heuristic_mask (f, img, XCDR (mask));
}
else if (NILP (mask) && found_p && img->mask)
{
Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
img->mask = NO_PIXMAP;
}
}
conversion = image_spec_value (spec, QCconversion, NULL);
if (EQ (conversion, Qdisabled))
x_disable_image (f, img);
else if (EQ (conversion, Qlaplace))
x_laplace (f, img);
else if (EQ (conversion, Qemboss))
x_emboss (f, img);
else if (CONSP (conversion)
&& EQ (XCAR (conversion), Qedge_detection))
{
Lisp_Object tem;
tem = XCDR (conversion);
if (CONSP (tem))
x_edge_detection (f, img,
Fplist_get (tem, QCmatrix),
Fplist_get (tem, QCcolor_adjustment));
}
}
}
int
lookup_image (f, spec)
struct frame *f;
Lisp_Object spec;
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
struct image *img;
int i;
unsigned hash;
struct gcpro gcpro1;
EMACS_TIME now;
xassert (FRAME_WINDOW_P (f));
xassert (valid_image_p (spec));
GCPRO1 (spec);
hash = sxhash (spec, 0);
i = hash % IMAGE_CACHE_BUCKETS_SIZE;
for (img = c->buckets[i]; img; img = img->next)
if (img->hash == hash && !NILP (Fequal (img->spec, spec)))
break;
if (img && img->load_failed_p)
{
free_image (f, img);
img = NULL;
}
if (img == NULL)
{
extern Lisp_Object Qpostscript;
BLOCK_INPUT;
img = make_image (spec, hash);
cache_image (f, img);
img->load_failed_p = img->type->load (f, img) == 0;
if (img->load_failed_p)
{
Lisp_Object value;
value = image_spec_value (spec, QCwidth, NULL);
img->width = (INTEGERP (value)
? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
value = image_spec_value (spec, QCheight, NULL);
img->height = (INTEGERP (value)
? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
}
else
{
Lisp_Object ascent, margin, relief, bg;
ascent = image_spec_value (spec, QCascent, NULL);
if (INTEGERP (ascent))
img->ascent = XFASTINT (ascent);
else if (EQ (ascent, Qcenter))
img->ascent = CENTERED_IMAGE_ASCENT;
margin = image_spec_value (spec, QCmargin, NULL);
if (INTEGERP (margin) && XINT (margin) >= 0)
img->vmargin = img->hmargin = XFASTINT (margin);
else if (CONSP (margin) && INTEGERP (XCAR (margin))
&& INTEGERP (XCDR (margin)))
{
if (XINT (XCAR (margin)) > 0)
img->hmargin = XFASTINT (XCAR (margin));
if (XINT (XCDR (margin)) > 0)
img->vmargin = XFASTINT (XCDR (margin));
}
relief = image_spec_value (spec, QCrelief, NULL);
if (INTEGERP (relief))
{
img->relief = XINT (relief);
img->hmargin += abs (img->relief);
img->vmargin += abs (img->relief);
}
if (! img->background_valid)
{
bg = image_spec_value (img->spec, QCbackground, NULL);
if (!NILP (bg))
{
img->background
= x_alloc_image_color (f, img, bg,
FRAME_BACKGROUND_PIXEL (f));
img->background_valid = 1;
}
}
if (!EQ (*img->type->type, Qpostscript))
postprocess_image (f, img);
}
UNBLOCK_INPUT;
}
EMACS_GET_TIME (now);
img->timestamp = EMACS_SECS (now);
UNGCPRO;
return img->id;
}
static void
cache_image (f, img)
struct frame *f;
struct image *img;
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
int i;
for (i = 0; i < c->used; ++i)
if (c->images[i] == NULL)
break;
if (i == c->used && c->used == c->size)
{
c->size *= 2;
c->images = (struct image **) xrealloc (c->images,
c->size * sizeof *c->images);
}
c->images[i] = img;
img->id = i;
if (i == c->used)
++c->used;
i = img->hash % IMAGE_CACHE_BUCKETS_SIZE;
img->next = c->buckets[i];
if (img->next)
img->next->prev = img;
img->prev = NULL;
c->buckets[i] = img;
}
void
forall_images_in_image_cache (f, fn)
struct frame *f;
void (*fn) P_ ((struct image *img));
{
if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f))
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
if (c)
{
int i;
for (i = 0; i < c->used; ++i)
if (c->images[i])
fn (c->images[i]);
}
}
}
#ifdef HAVE_NTGUI
#define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
#define LOAD_IMGLIB_FN(lib,func) { \
fn_##func = (void *) GetProcAddress (lib, #func); \
if (!fn_##func) return 0; \
}
static HMODULE
w32_delayed_load (Lisp_Object libraries, Lisp_Object type)
{
HMODULE library = NULL;
if (CONSP (libraries) && NILP (Fassq (type, Vimage_type_cache)))
{
Lisp_Object dlls = Fassq (type, libraries);
if (CONSP (dlls))
for (dlls = XCDR (dlls); CONSP (dlls); dlls = XCDR (dlls))
{
CHECK_STRING_CAR (dlls);
if (library = LoadLibrary (SDATA (XCAR (dlls))))
break;
}
}
return library;
}
#endif
static int x_create_x_image_and_pixmap P_ ((struct frame *, int, int, int,
XImagePtr *, Pixmap *));
static void x_destroy_x_image P_ ((XImagePtr));
static void x_put_x_image P_ ((struct frame *, XImagePtr, Pixmap, int, int));
static int
x_create_x_image_and_pixmap (f, width, height, depth, ximg, pixmap)
struct frame *f;
int width, height, depth;
XImagePtr *ximg;
Pixmap *pixmap;
{
#ifdef HAVE_X_WINDOWS
Display *display = FRAME_X_DISPLAY (f);
Window window = FRAME_X_WINDOW (f);
Screen *screen = FRAME_X_SCREEN (f);
xassert (interrupt_input_blocked);
if (depth <= 0)
depth = DefaultDepthOfScreen (screen);
*ximg = XCreateImage (display, DefaultVisualOfScreen (screen),
depth, ZPixmap, 0, NULL, width, height,
depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
if (*ximg == NULL)
{
image_error ("Unable to allocate X image", Qnil, Qnil);
return 0;
}
(*ximg)->data = (char *) xmalloc ((*ximg)->bytes_per_line * height);
*pixmap = XCreatePixmap (display, window, width, height, depth);
if (*pixmap == NO_PIXMAP)
{
x_destroy_x_image (*ximg);
*ximg = NULL;
image_error ("Unable to create X pixmap", Qnil, Qnil);
return 0;
}
return 1;
#endif
#ifdef HAVE_NTGUI
BITMAPINFOHEADER *header;
HDC hdc;
int scanline_width_bits;
int remainder;
int palette_colors = 0;
if (depth == 0)
depth = 24;
if (depth != 1 && depth != 4 && depth != 8
&& depth != 16 && depth != 24 && depth != 32)
{
image_error ("Invalid image bit depth specified", Qnil, Qnil);
return 0;
}
scanline_width_bits = width * depth;
remainder = scanline_width_bits % 32;
if (remainder)
scanline_width_bits += 32 - remainder;
if (depth < 16)
palette_colors = 1 << depth - 1;
*ximg = xmalloc (sizeof (XImage) + palette_colors * sizeof (RGBQUAD));
if (*ximg == NULL)
{
image_error ("Unable to allocate memory for XImage", Qnil, Qnil);
return 0;
}
header = &((*ximg)->info.bmiHeader);
bzero (&((*ximg)->info), sizeof (BITMAPINFO));
header->biSize = sizeof (*header);
header->biWidth = width;
header->biHeight = -height;
header->biPlanes = 1;
header->biBitCount = depth;
header->biCompression = BI_RGB;
header->biClrUsed = palette_colors;
if (depth == 1)
{
(*ximg)->info.bmiColors[0].rgbBlue = 0;
(*ximg)->info.bmiColors[0].rgbGreen = 0;
(*ximg)->info.bmiColors[0].rgbRed = 0;
(*ximg)->info.bmiColors[0].rgbReserved = 0;
(*ximg)->info.bmiColors[1].rgbBlue = 255;
(*ximg)->info.bmiColors[1].rgbGreen = 255;
(*ximg)->info.bmiColors[1].rgbRed = 255;
(*ximg)->info.bmiColors[1].rgbReserved = 0;
}
hdc = get_frame_dc (f);
*pixmap = CreateDIBSection (hdc, &((*ximg)->info),
(depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
(void **)&((*ximg)->data), NULL, 0);
release_frame_dc (f, hdc);
if (*pixmap == NULL)
{
DWORD err = GetLastError();
Lisp_Object errcode;
XSETINT (errcode, (int) err);
image_error ("Unable to create bitmap, error code %d", errcode, Qnil);
x_destroy_x_image (*ximg);
return 0;
}
return 1;
#endif
#ifdef MAC_OS
Display *display = FRAME_X_DISPLAY (f);
Window window = FRAME_X_WINDOW (f);
xassert (interrupt_input_blocked);
*pixmap = XCreatePixmap (display, window, width, height, depth);
if (*pixmap == NO_PIXMAP)
{
*ximg = NULL;
image_error ("Unable to create X pixmap", Qnil, Qnil);
return 0;
}
LockPixels (GetGWorldPixMap (*pixmap));
*ximg = *pixmap;
return 1;
#endif
}
static void
x_destroy_x_image (ximg)
XImagePtr ximg;
{
xassert (interrupt_input_blocked);
if (ximg)
{
#ifdef HAVE_X_WINDOWS
xfree (ximg->data);
ximg->data = NULL;
XDestroyImage (ximg);
#endif
#ifdef HAVE_NTGUI
ximg->data = NULL;
xfree (ximg);
#endif
#ifdef MAC_OS
XDestroyImage (ximg);
#endif
}
}
static void
x_put_x_image (f, ximg, pixmap, width, height)
struct frame *f;
XImagePtr ximg;
Pixmap pixmap;
int width, height;
{
#ifdef HAVE_X_WINDOWS
GC gc;
xassert (interrupt_input_blocked);
gc = XCreateGC (FRAME_X_DISPLAY (f), pixmap, 0, NULL);
XPutImage (FRAME_X_DISPLAY (f), pixmap, gc, ximg, 0, 0, 0, 0, width, height);
XFreeGC (FRAME_X_DISPLAY (f), gc);
#endif
#ifdef HAVE_NTGUI
#if 0
HDC hdc = get_frame_dc (f);
SetDIBits (hdc, pixmap, 0, height, ximg->data, &(ximg->info), DIB_RGB_COLORS);
release_frame_dc (f, hdc);
#endif
#endif
#ifdef MAC_OS
xassert (ximg == pixmap);
#endif
}
static unsigned char *slurp_file P_ ((char *, int *));
Lisp_Object
x_find_image_file (file)
Lisp_Object file;
{
Lisp_Object file_found, search_path;
struct gcpro gcpro1, gcpro2;
int fd;
file_found = Qnil;
search_path = Fcons (Vdata_directory, Vx_bitmap_file_path);
GCPRO2 (file_found, search_path);
fd = openp (search_path, file, Qnil, &file_found, Qnil);
if (fd == -1)
file_found = Qnil;
else
{
file_found = ENCODE_FILE (file_found);
close (fd);
}
UNGCPRO;
return file_found;
}
static unsigned char *
slurp_file (file, size)
char *file;
int *size;
{
FILE *fp = NULL;
unsigned char *buf = NULL;
struct stat st;
if (stat (file, &st) == 0
&& (fp = fopen (file, "rb")) != NULL
&& (buf = (unsigned char *) xmalloc (st.st_size),
fread (buf, 1, st.st_size, fp) == st.st_size))
{
*size = st.st_size;
fclose (fp);
}
else
{
if (fp)
fclose (fp);
if (buf)
{
xfree (buf);
buf = NULL;
}
}
return buf;
}
#ifdef MAC_OS
static int image_load_quicktime P_ ((struct frame *, struct image *img,
OSType));
#ifdef MAC_OSX
static int image_load_quartz2d P_ ((struct frame *, struct image *img, int));
#endif
static OSErr
find_image_fsspec (specified_file, file, fss)
Lisp_Object specified_file, *file;
FSSpec *fss;
{
OSErr err;
AEDesc desc;
*file = x_find_image_file (specified_file);
if (!STRINGP (*file))
return fnfErr;
err = AECoercePtr (TYPE_FILE_NAME, SDATA (*file),
SBYTES (*file), typeFSS, &desc);
if (err == noErr)
{
#if TARGET_API_MAC_CARBON
err = AEGetDescData (&desc, fss, sizeof (FSSpec));
#else
*fss = *(FSSpec *)(*(desc.dataHandle));
#endif
AEDisposeDesc (&desc);
}
return err;
}
static int
image_load_qt_1 (f, img, type, fss, dh)
struct frame *f;
struct image *img;
OSType type;
const FSSpec *fss;
Handle dh;
{
ComponentResult err;
GraphicsImportComponent gi;
Rect rect;
int width, height;
ImageDescriptionHandle desc_handle;
short draw_all_pixels;
Lisp_Object specified_bg;
XColor color;
XImagePtr ximg;
RGBColor bg_color;
err = OpenADefaultComponent (GraphicsImporterComponentType, type, &gi);
if (err != noErr)
{
image_error ("Cannot get importer component for `%s'", img->spec, Qnil);
return 0;
}
if (dh == NULL)
{
err = GraphicsImportSetDataFile (gi, fss);
if (err != noErr)
{
image_error ("Cannot set fsspec to graphics importer for '%s'",
img->spec, Qnil);
goto error;
}
}
else
{
err = GraphicsImportSetDataHandle (gi, dh);
if (err != noErr)
{
image_error ("Cannot set data handle to graphics importer for `%s'",
img->spec, Qnil);
goto error;
}
}
err = GraphicsImportGetImageDescription (gi, &desc_handle);
if (err != noErr || desc_handle == NULL)
{
image_error ("Error reading `%s'", img->spec, Qnil);
goto error;
}
width = img->width = (*desc_handle)->width;
height = img->height = (*desc_handle)->height;
DisposeHandle ((Handle)desc_handle);
if (!check_image_size (f, width, height))
{
image_error ("Invalid image size", Qnil, Qnil);
goto error;
}
err = GraphicsImportDoesDrawAllPixels (gi, &draw_all_pixels);
#if 0
if (err != noErr)
{
image_error ("Error reading `%s'", img->spec, Qnil);
goto error;
}
#endif
if (draw_all_pixels != graphicsImporterDrawsAllPixels)
{
specified_bg = image_spec_value (img->spec, QCbackground, NULL);
if (!STRINGP (specified_bg) ||
!mac_defined_color (f, SDATA (specified_bg), &color, 0))
{
color.pixel = FRAME_BACKGROUND_PIXEL (f);
color.red = RED16_FROM_ULONG (color.pixel);
color.green = GREEN16_FROM_ULONG (color.pixel);
color.blue = BLUE16_FROM_ULONG (color.pixel);
}
}
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
goto error;
if (draw_all_pixels != graphicsImporterDrawsAllPixels)
{
CGrafPtr old_port;
GDHandle old_gdh;
GetGWorld (&old_port, &old_gdh);
SetGWorld (ximg, NULL);
bg_color.red = color.red;
bg_color.green = color.green;
bg_color.blue = color.blue;
RGBBackColor (&bg_color);
#if TARGET_API_MAC_CARBON
GetPortBounds (ximg, &rect);
EraseRect (&rect);
#else
EraseRect (&(ximg->portRect));
#endif
SetGWorld (old_port, old_gdh);
}
GraphicsImportSetGWorld (gi, ximg, NULL);
GraphicsImportDraw (gi);
CloseComponent (gi);
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
return 1;
error:
CloseComponent (gi);
return 0;
}
static int
image_load_quicktime (f, img, type)
struct frame *f;
struct image *img;
OSType type;
{
Lisp_Object specified_file;
Lisp_Object specified_data;
OSErr err;
specified_file = image_spec_value (img->spec, QCfile, NULL);
specified_data = image_spec_value (img->spec, QCdata, NULL);
if (NILP (specified_data))
{
Lisp_Object file;
FSSpec fss;
err = find_image_fsspec (specified_file, &file, &fss);
if (err != noErr)
{
if (err == fnfErr)
image_error ("Cannot find image file `%s'", specified_file, Qnil);
else
image_error ("Cannot open `%s'", file, Qnil);
return 0;
}
return image_load_qt_1 (f, img, type, &fss, NULL);
}
else
{
int success_p;
Handle dh;
err = PtrToHand (SDATA (specified_data), &dh, SBYTES (specified_data));
if (err != noErr)
{
image_error ("Cannot allocate data handle for `%s'",
img->spec, Qnil);
return 0;
}
success_p = image_load_qt_1 (f, img, type, NULL, dh);
DisposeHandle (dh);
return success_p;
}
}
#ifdef MAC_OSX
typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType)
(CGDataProviderRef, const float [], bool, CGColorRenderingIntent);
static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider;
static void
init_image_func_pointer ()
{
if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
{
MyCGImageCreateWithPNGDataProvider
= (CGImageCreateWithPNGDataProviderProcType)
NSAddressOfSymbol (NSLookupAndBindSymbol
("_CGImageCreateWithPNGDataProvider"));
}
else
MyCGImageCreateWithPNGDataProvider = NULL;
}
static int
image_load_quartz2d (f, img, png_p)
struct frame *f;
struct image *img;
int png_p;
{
Lisp_Object file, specified_file;
Lisp_Object specified_data, specified_bg;
struct gcpro gcpro1;
CGDataProviderRef source;
CGImageRef image;
int width, height;
XColor color;
XImagePtr ximg = NULL;
CGContextRef context;
CGRect rectangle;
specified_file = image_spec_value (img->spec, QCfile, NULL);
specified_data = image_spec_value (img->spec, QCdata, NULL);
file = Qnil;
GCPRO1 (file);
if (NILP (specified_data))
{
CFStringRef path;
CFURLRef url;
file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNGCPRO;
return 0;
}
path = cfstring_create_with_utf8_cstring (SDATA (file));
url = CFURLCreateWithFileSystemPath (NULL, path,
kCFURLPOSIXPathStyle, 0);
CFRelease (path);
source = CGDataProviderCreateWithURL (url);
CFRelease (url);
}
else
source = CGDataProviderCreateWithData (NULL, SDATA (specified_data),
SBYTES (specified_data), NULL);
if (png_p)
image = (*MyCGImageCreateWithPNGDataProvider) (source, NULL, FALSE,
kCGRenderingIntentDefault);
else
image = CGImageCreateWithJPEGDataProvider (source, NULL, FALSE,
kCGRenderingIntentDefault);
CGDataProviderRelease (source);
if (image == NULL)
{
UNGCPRO;
image_error ("Error reading image `%s'", img->spec, Qnil);
return 0;
}
width = img->width = CGImageGetWidth (image);
height = img->height = CGImageGetHeight (image);
if (!check_image_size (f, width, height))
{
CGImageRelease (image);
UNGCPRO;
image_error ("Invalid image size", Qnil, Qnil);
return 0;
}
if (png_p)
{
specified_bg = image_spec_value (img->spec, QCbackground, NULL);
if (!STRINGP (specified_bg) ||
!mac_defined_color (f, SDATA (specified_bg), &color, 0))
{
color.pixel = FRAME_BACKGROUND_PIXEL (f);
color.red = RED16_FROM_ULONG (color.pixel);
color.green = GREEN16_FROM_ULONG (color.pixel);
color.blue = BLUE16_FROM_ULONG (color.pixel);
}
}
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
CGImageRelease (image);
UNGCPRO;
return 0;
}
rectangle = CGRectMake (0, 0, width, height);
QDBeginCGContext (ximg, &context);
if (png_p)
{
CGContextSetRGBFillColor (context, color.red / 65535.0,
color.green / 65535.0,
color.blue / 65535.0, 1.0);
CGContextFillRect (context, rectangle);
}
CGContextDrawImage (context, rectangle, image);
QDEndCGContext (ximg, &context);
CGImageRelease (image);
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
UNGCPRO;
return 1;
}
#endif
#endif
static int xbm_scan P_ ((unsigned char **, unsigned char *, char *, int *));
static int xbm_load P_ ((struct frame *f, struct image *img));
static int xbm_load_image P_ ((struct frame *f, struct image *img,
unsigned char *, unsigned char *));
static int xbm_image_p P_ ((Lisp_Object object));
static int xbm_read_bitmap_data P_ ((struct frame *f,
unsigned char *, unsigned char *,
int *, int *, unsigned char **));
static int xbm_file_p P_ ((Lisp_Object));
enum xbm_keyword_index
{
XBM_TYPE,
XBM_FILE,
XBM_WIDTH,
XBM_HEIGHT,
XBM_DATA,
XBM_FOREGROUND,
XBM_BACKGROUND,
XBM_ASCENT,
XBM_MARGIN,
XBM_RELIEF,
XBM_ALGORITHM,
XBM_HEURISTIC_MASK,
XBM_MASK,
XBM_LAST
};
static struct image_keyword xbm_format[XBM_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":file", IMAGE_STRING_VALUE, 0},
{":width", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":height", IMAGE_POSITIVE_INTEGER_VALUE, 0},
{":data", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
};
static struct image_type xbm_type =
{
&Qxbm,
xbm_image_p,
xbm_load,
x_clear_image,
NULL
};
enum xbm_token
{
XBM_TK_IDENT = 256,
XBM_TK_NUMBER
};
static int
xbm_image_p (object)
Lisp_Object object;
{
struct image_keyword kw[XBM_LAST];
bcopy (xbm_format, kw, sizeof kw);
if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
return 0;
xassert (EQ (kw[XBM_TYPE].value, Qxbm));
if (kw[XBM_FILE].count)
{
if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_DATA].count)
return 0;
}
else if (kw[XBM_DATA].count && xbm_file_p (kw[XBM_DATA].value))
{
if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_FILE].count)
return 0;
}
else
{
Lisp_Object data;
int width, height;
if (!kw[XBM_WIDTH].count
|| !kw[XBM_HEIGHT].count
|| !kw[XBM_DATA].count)
return 0;
data = kw[XBM_DATA].value;
width = XFASTINT (kw[XBM_WIDTH].value);
height = XFASTINT (kw[XBM_HEIGHT].value);
if (VECTORP (data))
{
int i;
if (XVECTOR (data)->size < height)
return 0;
for (i = 0; i < height; ++i)
{
Lisp_Object elt = XVECTOR (data)->contents[i];
if (STRINGP (elt))
{
if (SCHARS (elt)
< (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR)
return 0;
}
else if (BOOL_VECTOR_P (elt))
{
if (XBOOL_VECTOR (elt)->size < width)
return 0;
}
else
return 0;
}
}
else if (STRINGP (data))
{
if (SCHARS (data)
< (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR * height)
return 0;
}
else if (BOOL_VECTOR_P (data))
{
if (XBOOL_VECTOR (data)->size < width * height)
return 0;
}
else
return 0;
}
return 1;
}
static int
xbm_scan (s, end, sval, ival)
unsigned char **s, *end;
char *sval;
int *ival;
{
unsigned int c;
loop:
while (*s < end && (c = *(*s)++, isspace (c)))
;
if (*s >= end)
c = 0;
else if (isdigit (c))
{
int value = 0, digit;
if (c == '0' && *s < end)
{
c = *(*s)++;
if (c == 'x' || c == 'X')
{
while (*s < end)
{
c = *(*s)++;
if (isdigit (c))
digit = c - '0';
else if (c >= 'a' && c <= 'f')
digit = c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
digit = c - 'A' + 10;
else
break;
value = 16 * value + digit;
}
}
else if (isdigit (c))
{
value = c - '0';
while (*s < end
&& (c = *(*s)++, isdigit (c)))
value = 8 * value + c - '0';
}
}
else
{
value = c - '0';
while (*s < end
&& (c = *(*s)++, isdigit (c)))
value = 10 * value + c - '0';
}
if (*s < end)
*s = *s - 1;
*ival = value;
c = XBM_TK_NUMBER;
}
else if (isalpha (c) || c == '_')
{
*sval++ = c;
while (*s < end
&& (c = *(*s)++, (isalnum (c) || c == '_')))
*sval++ = c;
*sval = 0;
if (*s < end)
*s = *s - 1;
c = XBM_TK_IDENT;
}
else if (c == '/' && **s == '*')
{
++*s;
while (**s && (**s != '*' || *(*s + 1) != '/'))
++*s;
if (**s)
{
*s += 2;
goto loop;
}
}
return c;
}
#ifdef HAVE_NTGUI
static HBITMAP
w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
{
static unsigned char swap_nibble[16]
= { 0x0, 0x8, 0x4, 0xc,
0x2, 0xa, 0x6, 0xe,
0x1, 0x9, 0x5, 0xd,
0x3, 0xb, 0x7, 0xf };
int i, j, w1, w2;
unsigned char *bits, *p;
HBITMAP bmp;
w1 = (width + 7) / 8;
w2 = ((width + 15) / 16) * 2;
bits = (unsigned char *) alloca (height * w2);
bzero (bits, height * w2);
for (i = 0; i < height; i++)
{
p = bits + i*w2;
for (j = 0; j < w1; j++)
{
unsigned char c = *data++;
*p++ = (unsigned char)((swap_nibble[c & 0xf] << 4)
| (swap_nibble[(c>>4) & 0xf]));
}
}
bmp = CreateBitmap (width, height, 1, 1, (char *) bits);
return bmp;
}
static void convert_mono_to_color_image (f, img, foreground, background)
struct frame *f;
struct image *img;
COLORREF foreground, background;
{
HDC hdc, old_img_dc, new_img_dc;
HGDIOBJ old_prev, new_prev;
HBITMAP new_pixmap;
hdc = get_frame_dc (f);
old_img_dc = CreateCompatibleDC (hdc);
new_img_dc = CreateCompatibleDC (hdc);
new_pixmap = CreateCompatibleBitmap (hdc, img->width, img->height);
release_frame_dc (f, hdc);
old_prev = SelectObject (old_img_dc, img->pixmap);
new_prev = SelectObject (new_img_dc, new_pixmap);
SetTextColor (new_img_dc, foreground);
SetBkColor (new_img_dc, background);
BitBlt (new_img_dc, 0, 0, img->width, img->height, old_img_dc,
0, 0, SRCCOPY);
SelectObject (old_img_dc, old_prev);
SelectObject (new_img_dc, new_prev);
DeleteDC (old_img_dc);
DeleteDC (new_img_dc);
DeleteObject (img->pixmap);
if (new_pixmap == 0)
fprintf (stderr, "Failed to convert image to color.\n");
else
img->pixmap = new_pixmap;
}
#define XBM_BIT_SHUFFLE(b) (~(b))
#else
#define XBM_BIT_SHUFFLE(b) (b)
#endif
static void
Create_Pixmap_From_Bitmap_Data(f, img, data, fg, bg, non_default_colors)
struct frame *f;
struct image *img;
char *data;
RGB_PIXEL_COLOR fg, bg;
int non_default_colors;
{
#ifdef HAVE_NTGUI
img->pixmap
= w32_create_pixmap_from_bitmap_data (img->width, img->height, data);
if (non_default_colors)
convert_mono_to_color_image (f, img, fg, bg);
#else
img->pixmap
= XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f),
FRAME_X_WINDOW (f),
data,
img->width, img->height,
fg, bg,
DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
#endif
}
static int
xbm_read_bitmap_data (f, contents, end, width, height, data)
struct frame *f;
unsigned char *contents, *end;
int *width, *height;
unsigned char **data;
{
unsigned char *s = contents;
char buffer[BUFSIZ];
int padding_p = 0;
int v10 = 0;
int bytes_per_line, i, nbytes;
unsigned char *p;
int value;
int LA1;
#define match() \
LA1 = xbm_scan (&s, end, buffer, &value)
#define expect(TOKEN) \
if (LA1 != (TOKEN)) \
goto failure; \
else \
match ()
#define expect_ident(IDENT) \
if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
match (); \
else \
goto failure
*width = *height = -1;
if (data)
*data = NULL;
LA1 = xbm_scan (&s, end, buffer, &value);
while (LA1 == '#')
{
match ();
expect_ident ("define");
expect (XBM_TK_IDENT);
if (LA1 == XBM_TK_NUMBER)
{
char *p = strrchr (buffer, '_');
p = p ? p + 1 : buffer;
if (strcmp (p, "width") == 0)
*width = value;
else if (strcmp (p, "height") == 0)
*height = value;
}
expect (XBM_TK_NUMBER);
}
if (!check_image_size (f, *width, *height))
goto failure;
else if (data == NULL)
goto success;
expect_ident ("static");
if (LA1 == XBM_TK_IDENT)
{
if (strcmp (buffer, "unsigned") == 0)
{
match ();
expect_ident ("char");
}
else if (strcmp (buffer, "short") == 0)
{
match ();
v10 = 1;
if (*width % 16 && *width % 16 < 9)
padding_p = 1;
}
else if (strcmp (buffer, "char") == 0)
match ();
else
goto failure;
}
else
goto failure;
expect (XBM_TK_IDENT);
expect ('[');
expect (']');
expect ('=');
expect ('{');
bytes_per_line = (*width + 7) / 8 + padding_p;
nbytes = bytes_per_line * *height;
p = *data = (unsigned char *) xmalloc (nbytes);
if (v10)
{
for (i = 0; i < nbytes; i += 2)
{
int val = value;
expect (XBM_TK_NUMBER);
*p++ = XBM_BIT_SHUFFLE (val);
if (!padding_p || ((i + 2) % bytes_per_line))
*p++ = XBM_BIT_SHUFFLE (value >> 8);
if (LA1 == ',' || LA1 == '}')
match ();
else
goto failure;
}
}
else
{
for (i = 0; i < nbytes; ++i)
{
int val = value;
expect (XBM_TK_NUMBER);
*p++ = XBM_BIT_SHUFFLE (val);
if (LA1 == ',' || LA1 == '}')
match ();
else
goto failure;
}
}
success:
return 1;
failure:
if (data && *data)
{
xfree (*data);
*data = NULL;
}
return 0;
#undef match
#undef expect
#undef expect_ident
}
static int
xbm_load_image (f, img, contents, end)
struct frame *f;
struct image *img;
unsigned char *contents, *end;
{
int rc;
unsigned char *data;
int success_p = 0;
rc = xbm_read_bitmap_data (f, contents, end, &img->width, &img->height, &data);
if (rc)
{
unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
unsigned long background = FRAME_BACKGROUND_PIXEL (f);
int non_default_colors = 0;
Lisp_Object value;
xassert (img->width > 0 && img->height > 0);
value = image_spec_value (img->spec, QCforeground, NULL);
if (!NILP (value))
{
foreground = x_alloc_image_color (f, img, value, foreground);
non_default_colors = 1;
}
value = image_spec_value (img->spec, QCbackground, NULL);
if (!NILP (value))
{
background = x_alloc_image_color (f, img, value, background);
img->background = background;
img->background_valid = 1;
non_default_colors = 1;
}
Create_Pixmap_From_Bitmap_Data (f, img, data,
foreground, background,
non_default_colors);
xfree (data);
if (img->pixmap == NO_PIXMAP)
{
x_clear_image (f, img);
image_error ("Unable to create X pixmap for `%s'", img->spec, Qnil);
}
else
success_p = 1;
}
else
image_error ("Error loading XBM image `%s'", img->spec, Qnil);
return success_p;
}
static int
xbm_file_p (data)
Lisp_Object data;
{
int w, h;
return (STRINGP (data)
&& xbm_read_bitmap_data (NULL, SDATA (data),
(SDATA (data)
+ SBYTES (data)),
&w, &h, NULL));
}
static int
xbm_load (f, img)
struct frame *f;
struct image *img;
{
int success_p = 0;
Lisp_Object file_name;
xassert (xbm_image_p (img->spec));
file_name = image_spec_value (img->spec, QCfile, NULL);
if (STRINGP (file_name))
{
Lisp_Object file;
unsigned char *contents;
int size;
struct gcpro gcpro1;
file = x_find_image_file (file_name);
GCPRO1 (file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", file_name, Qnil);
UNGCPRO;
return 0;
}
contents = slurp_file (SDATA (file), &size);
if (contents == NULL)
{
image_error ("Error loading XBM image `%s'", img->spec, Qnil);
UNGCPRO;
return 0;
}
success_p = xbm_load_image (f, img, contents, contents + size);
UNGCPRO;
}
else
{
struct image_keyword fmt[XBM_LAST];
Lisp_Object data;
unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
unsigned long background = FRAME_BACKGROUND_PIXEL (f);
int non_default_colors = 0;
char *bits;
int parsed_p;
int in_memory_file_p = 0;
data = image_spec_value (img->spec, QCdata, NULL);
in_memory_file_p = xbm_file_p (data);
bcopy (xbm_format, fmt, sizeof fmt);
parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
xassert (parsed_p);
if (!in_memory_file_p)
{
img->width = XFASTINT (fmt[XBM_WIDTH].value);
img->height = XFASTINT (fmt[XBM_HEIGHT].value);
xassert (img->width > 0 && img->height > 0);
}
if (fmt[XBM_FOREGROUND].count
&& STRINGP (fmt[XBM_FOREGROUND].value))
{
foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
foreground);
non_default_colors = 1;
}
if (fmt[XBM_BACKGROUND].count
&& STRINGP (fmt[XBM_BACKGROUND].value))
{
background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
background);
non_default_colors = 1;
}
if (in_memory_file_p)
success_p = xbm_load_image (f, img, SDATA (data),
(SDATA (data)
+ SBYTES (data)));
else
{
if (VECTORP (data))
{
int i;
char *p;
int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
p = bits = (char *) alloca (nbytes * img->height);
for (i = 0; i < img->height; ++i, p += nbytes)
{
Lisp_Object line = XVECTOR (data)->contents[i];
if (STRINGP (line))
bcopy (SDATA (line), p, nbytes);
else
bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
}
}
else if (STRINGP (data))
bits = SDATA (data);
else
bits = XBOOL_VECTOR (data)->data;
Create_Pixmap_From_Bitmap_Data (f, img, bits,
foreground, background,
non_default_colors);
if (img->pixmap)
success_p = 1;
else
{
image_error ("Unable to create pixmap for XBM image `%s'",
img->spec, Qnil);
x_clear_image (f, img);
}
}
}
return success_p;
}
#if defined (HAVE_XPM) || defined (MAC_OS)
static int xpm_image_p P_ ((Lisp_Object object));
static int xpm_load P_ ((struct frame *f, struct image *img));
static int xpm_valid_color_symbols_p P_ ((Lisp_Object));
#endif
#ifdef HAVE_XPM
#ifdef HAVE_NTGUI
#define FOR_MSW
#define XColor xpm_XColor
#define XImage xpm_XImage
#define Display xpm_Display
#define PIXEL_ALREADY_TYPEDEFED
#include "X11/xpm.h"
#undef FOR_MSW
#undef XColor
#undef XImage
#undef Display
#undef PIXEL_ALREADY_TYPEDEFED
#else
#include "X11/xpm.h"
#endif
#endif
#if defined (HAVE_XPM) || defined (MAC_OS)
Lisp_Object Qxpm;
enum xpm_keyword_index
{
XPM_TYPE,
XPM_FILE,
XPM_DATA,
XPM_ASCENT,
XPM_MARGIN,
XPM_RELIEF,
XPM_ALGORITHM,
XPM_HEURISTIC_MASK,
XPM_MASK,
XPM_COLOR_SYMBOLS,
XPM_BACKGROUND,
XPM_LAST
};
static struct image_keyword xpm_format[XPM_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":file", IMAGE_STRING_VALUE, 0},
{":data", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
static struct image_type xpm_type =
{
&Qxpm,
xpm_image_p,
xpm_load,
x_clear_image,
NULL
};
#ifdef HAVE_X_WINDOWS
#if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
#define ALLOC_XPM_COLORS
#endif
#endif
#ifdef ALLOC_XPM_COLORS
static void xpm_init_color_cache P_ ((struct frame *, XpmAttributes *));
static void xpm_free_color_cache P_ ((void));
static int xpm_lookup_color P_ ((struct frame *, char *, XColor *));
static int xpm_color_bucket P_ ((char *));
static struct xpm_cached_color *xpm_cache_color P_ ((struct frame *, char *,
XColor *, int));
struct xpm_cached_color
{
struct xpm_cached_color *next;
XColor color;
char name[1];
};
#define XPM_COLOR_CACHE_BUCKETS 1001
struct xpm_cached_color **xpm_color_cache;
static void
xpm_init_color_cache (f, attrs)
struct frame *f;
XpmAttributes *attrs;
{
size_t nbytes = XPM_COLOR_CACHE_BUCKETS * sizeof *xpm_color_cache;
xpm_color_cache = (struct xpm_cached_color **) xmalloc (nbytes);
memset (xpm_color_cache, 0, nbytes);
init_color_table ();
if (attrs->valuemask & XpmColorSymbols)
{
int i;
XColor color;
for (i = 0; i < attrs->numsymbols; ++i)
if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
attrs->colorsymbols[i].value, &color))
{
color.pixel = lookup_rgb_color (f, color.red, color.green,
color.blue);
xpm_cache_color (f, attrs->colorsymbols[i].name, &color, -1);
}
}
}
static void
xpm_free_color_cache ()
{
struct xpm_cached_color *p, *next;
int i;
for (i = 0; i < XPM_COLOR_CACHE_BUCKETS; ++i)
for (p = xpm_color_cache[i]; p; p = next)
{
next = p->next;
xfree (p);
}
xfree (xpm_color_cache);
xpm_color_cache = NULL;
free_color_table ();
}
static int
xpm_color_bucket (color_name)
char *color_name;
{
unsigned h = 0;
char *s;
for (s = color_name; *s; ++s)
h = (h << 2) ^ *s;
return h %= XPM_COLOR_CACHE_BUCKETS;
}
static struct xpm_cached_color *
xpm_cache_color (f, color_name, color, bucket)
struct frame *f;
char *color_name;
XColor *color;
int bucket;
{
size_t nbytes;
struct xpm_cached_color *p;
if (bucket < 0)
bucket = xpm_color_bucket (color_name);
nbytes = sizeof *p + strlen (color_name);
p = (struct xpm_cached_color *) xmalloc (nbytes);
strcpy (p->name, color_name);
p->color = *color;
p->next = xpm_color_cache[bucket];
xpm_color_cache[bucket] = p;
return p;
}
static int
xpm_lookup_color (f, color_name, color)
struct frame *f;
char *color_name;
XColor *color;
{
struct xpm_cached_color *p;
int h = xpm_color_bucket (color_name);
for (p = xpm_color_cache[h]; p; p = p->next)
if (strcmp (p->name, color_name) == 0)
break;
if (p != NULL)
*color = p->color;
else if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
color_name, color))
{
color->pixel = lookup_rgb_color (f, color->red, color->green,
color->blue);
p = xpm_cache_color (f, color_name, color, h);
}
else if (strcmp ("opaque", color_name) == 0)
{
bzero (color, sizeof (XColor));
color->pixel = FRAME_FOREGROUND_PIXEL (f);
p = xpm_cache_color (f, color_name, color, h);
}
return p != NULL;
}
static int
xpm_alloc_color (dpy, cmap, color_name, color, closure)
Display *dpy;
Colormap cmap;
char *color_name;
XColor *color;
void *closure;
{
return xpm_lookup_color ((struct frame *) closure, color_name, color);
}
static int
xpm_free_colors (dpy, cmap, pixels, npixels, closure)
Display *dpy;
Colormap cmap;
Pixel *pixels;
int npixels;
void *closure;
{
return 1;
}
#endif
#ifdef HAVE_NTGUI
DEF_IMGLIB_FN (XpmFreeAttributes);
DEF_IMGLIB_FN (XpmCreateImageFromBuffer);
DEF_IMGLIB_FN (XpmReadFileToImage);
DEF_IMGLIB_FN (XImageFree);
static int
init_xpm_functions (Lisp_Object libraries)
{
HMODULE library;
if (!(library = w32_delayed_load (libraries, Qxpm)))
return 0;
LOAD_IMGLIB_FN (library, XpmFreeAttributes);
LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
LOAD_IMGLIB_FN (library, XpmReadFileToImage);
LOAD_IMGLIB_FN (library, XImageFree);
return 1;
}
#endif
static int
xpm_valid_color_symbols_p (color_symbols)
Lisp_Object color_symbols;
{
while (CONSP (color_symbols))
{
Lisp_Object sym = XCAR (color_symbols);
if (!CONSP (sym)
|| !STRINGP (XCAR (sym))
|| !STRINGP (XCDR (sym)))
break;
color_symbols = XCDR (color_symbols);
}
return NILP (color_symbols);
}
static int
xpm_image_p (object)
Lisp_Object object;
{
struct image_keyword fmt[XPM_LAST];
bcopy (xpm_format, fmt, sizeof fmt);
return (parse_image_spec (object, fmt, XPM_LAST, Qxpm)
&& fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
&& (fmt[XPM_COLOR_SYMBOLS].count == 0
|| xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value)));
}
#endif
#if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
int
x_create_bitmap_from_xpm_data (f, bits)
struct frame *f;
char **bits;
{
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
int id, rc;
XpmAttributes attrs;
Pixmap bitmap, mask;
bzero (&attrs, sizeof attrs);
attrs.visual = FRAME_X_VISUAL (f);
attrs.colormap = FRAME_X_COLORMAP (f);
attrs.valuemask |= XpmVisual;
attrs.valuemask |= XpmColormap;
rc = XpmCreatePixmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
bits, &bitmap, &mask, &attrs);
if (rc != XpmSuccess)
{
XpmFreeAttributes (&attrs);
return -1;
}
id = x_allocate_bitmap_record (f);
dpyinfo->bitmaps[id - 1].pixmap = bitmap;
dpyinfo->bitmaps[id - 1].have_mask = 1;
dpyinfo->bitmaps[id - 1].mask = mask;
dpyinfo->bitmaps[id - 1].file = NULL;
dpyinfo->bitmaps[id - 1].height = attrs.height;
dpyinfo->bitmaps[id - 1].width = attrs.width;
dpyinfo->bitmaps[id - 1].depth = attrs.depth;
dpyinfo->bitmaps[id - 1].refcount = 1;
XpmFreeAttributes (&attrs);
return id;
}
#endif
#ifdef HAVE_XPM
static int
xpm_load (f, img)
struct frame *f;
struct image *img;
{
int rc;
XpmAttributes attrs;
Lisp_Object specified_file, color_symbols;
#ifdef HAVE_NTGUI
HDC hdc;
xpm_XImage * xpm_image = NULL, * xpm_mask = NULL;
#endif
bzero (&attrs, sizeof attrs);
#ifndef HAVE_NTGUI
attrs.visual = FRAME_X_VISUAL (f);
attrs.colormap = FRAME_X_COLORMAP (f);
attrs.valuemask |= XpmVisual;
attrs.valuemask |= XpmColormap;
#endif
#ifdef ALLOC_XPM_COLORS
attrs.color_closure = f;
attrs.alloc_color = xpm_alloc_color;
attrs.free_colors = xpm_free_colors;
attrs.valuemask |= XpmAllocColor | XpmFreeColors | XpmColorClosure;
#else
attrs.valuemask |= XpmReturnAllocPixels;
#ifdef XpmAllocCloseColors
attrs.alloc_close_colors = 1;
attrs.valuemask |= XpmAllocCloseColors;
#else
attrs.closeness = 600;
attrs.valuemask |= XpmCloseness;
#endif
#endif
#ifdef ALLOC_XPM_COLORS
xpm_init_color_cache (f, &attrs);
#endif
color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
if (CONSP (color_symbols))
{
Lisp_Object tail;
XpmColorSymbol *xpm_syms;
int i, size;
attrs.valuemask |= XpmColorSymbols;
attrs.numsymbols = 0;
for (tail = color_symbols; CONSP (tail); tail = XCDR (tail))
++attrs.numsymbols;
size = attrs.numsymbols * sizeof *xpm_syms;
xpm_syms = (XpmColorSymbol *) alloca (size);
bzero (xpm_syms, size);
attrs.colorsymbols = xpm_syms;
for (tail = color_symbols, i = 0;
CONSP (tail);
++i, tail = XCDR (tail))
{
Lisp_Object name = XCAR (XCAR (tail));
Lisp_Object color = XCDR (XCAR (tail));
xpm_syms[i].name = (char *) alloca (SCHARS (name) + 1);
strcpy (xpm_syms[i].name, SDATA (name));
xpm_syms[i].value = (char *) alloca (SCHARS (color) + 1);
strcpy (xpm_syms[i].value, SDATA (color));
}
}
#ifdef ALLOC_XPM_COLORS
xpm_init_color_cache (f, &attrs);
#endif
specified_file = image_spec_value (img->spec, QCfile, NULL);
#ifdef HAVE_NTGUI
{
HDC frame_dc = get_frame_dc (f);
hdc = CreateCompatibleDC (frame_dc);
release_frame_dc (f, frame_dc);
}
#endif
if (STRINGP (specified_file))
{
Lisp_Object file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
return 0;
}
#ifdef HAVE_NTGUI
rc = fn_XpmReadFileToImage (&hdc, SDATA (file),
&xpm_image, &xpm_mask,
&attrs);
#else
rc = XpmReadFileToPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
SDATA (file), &img->pixmap, &img->mask,
&attrs);
#endif
}
else
{
Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
#ifdef HAVE_NTGUI
rc = fn_XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
&xpm_image, &xpm_mask,
&attrs);
#else
rc = XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
SDATA (buffer),
&img->pixmap, &img->mask,
&attrs);
#endif
}
if (rc == XpmSuccess)
{
#if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
img->colors = colors_in_color_table (&img->ncolors);
#else
int i;
#ifdef HAVE_NTGUI
if (xpm_image && xpm_image->bitmap)
{
img->pixmap = xpm_image->bitmap;
fn_XImageFree (xpm_image);
}
if (xpm_mask && xpm_mask->bitmap)
{
HGDIOBJ old_obj;
old_obj = SelectObject (hdc, xpm_mask->bitmap);
PatBlt (hdc, 0, 0, xpm_mask->width, xpm_mask->height, DSTINVERT);
SelectObject (hdc, old_obj);
img->mask = xpm_mask->bitmap;
fn_XImageFree (xpm_mask);
DeleteDC (hdc);
}
DeleteDC (hdc);
#endif
img->ncolors = attrs.nalloc_pixels;
img->colors = (unsigned long *) xmalloc (img->ncolors
* sizeof *img->colors);
for (i = 0; i < attrs.nalloc_pixels; ++i)
{
img->colors[i] = attrs.alloc_pixels[i];
#ifdef DEBUG_X_COLORS
register_color (img->colors[i]);
#endif
}
#endif
img->width = attrs.width;
img->height = attrs.height;
xassert (img->width > 0 && img->height > 0);
#ifdef HAVE_NTGUI
fn_XpmFreeAttributes (&attrs);
#else
XpmFreeAttributes (&attrs);
#endif
}
else
{
#ifdef HAVE_NTGUI
DeleteDC (hdc);
#endif
switch (rc)
{
case XpmOpenFailed:
image_error ("Error opening XPM file (%s)", img->spec, Qnil);
break;
case XpmFileInvalid:
image_error ("Invalid XPM file (%s)", img->spec, Qnil);
break;
case XpmNoMemory:
image_error ("Out of memory (%s)", img->spec, Qnil);
break;
case XpmColorFailed:
image_error ("Color allocation error (%s)", img->spec, Qnil);
break;
default:
image_error ("Unknown error (%s)", img->spec, Qnil);
break;
}
}
#ifdef ALLOC_XPM_COLORS
xpm_free_color_cache ();
#endif
return rc == XpmSuccess;
}
#endif
#ifdef MAC_OS
static int xpm_scan P_ ((const unsigned char **, const unsigned char *,
const unsigned char **, int *));
static Lisp_Object xpm_make_color_table_v
P_ ((void (**) (Lisp_Object, const unsigned char *, int, Lisp_Object),
Lisp_Object (**) (Lisp_Object, const unsigned char *, int)));
static void xpm_put_color_table_v P_ ((Lisp_Object, const unsigned char *,
int, Lisp_Object));
static Lisp_Object xpm_get_color_table_v P_ ((Lisp_Object,
const unsigned char *, int));
static Lisp_Object xpm_make_color_table_h
P_ ((void (**) (Lisp_Object, const unsigned char *, int, Lisp_Object),
Lisp_Object (**) (Lisp_Object, const unsigned char *, int)));
static void xpm_put_color_table_h P_ ((Lisp_Object, const unsigned char *,
int, Lisp_Object));
static Lisp_Object xpm_get_color_table_h P_ ((Lisp_Object,
const unsigned char *, int));
static int xpm_str_to_color_key P_ ((const char *));
static int xpm_load_image P_ ((struct frame *, struct image *,
const unsigned char *, const unsigned char *));
enum xpm_token
{
XPM_TK_IDENT = 256,
XPM_TK_STRING,
XPM_TK_EOF
};
static int
xpm_scan (s, end, beg, len)
const unsigned char **s, *end, **beg;
int *len;
{
int c;
while (*s < end)
{
while (*s < end && (c = *(*s)++, isspace (c)))
;
if (isalpha (c) || c == '_' || c == '-' || c == '+')
{
*beg = *s - 1;
while (*s < end &&
(c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))
++*s;
*len = *s - *beg;
return XPM_TK_IDENT;
}
else if (c == '"')
{
*beg = *s;
while (*s < end && **s != '"')
++*s;
*len = *s - *beg;
if (*s < end)
++*s;
return XPM_TK_STRING;
}
else if (c == '/')
{
if (*s < end && **s == '*')
{
++*s;
do
{
while (*s < end && *(*s)++ != '*')
;
}
while (*s < end && **s != '/');
if (*s < end)
++*s;
}
else
return c;
}
else
return c;
}
return XPM_TK_EOF;
}
static Lisp_Object
xpm_make_color_table_v (put_func, get_func)
void (**put_func) (Lisp_Object, const unsigned char *, int, Lisp_Object);
Lisp_Object (**get_func) (Lisp_Object, const unsigned char *, int);
{
*put_func = xpm_put_color_table_v;
*get_func = xpm_get_color_table_v;
return Fmake_vector (make_number (256), Qnil);
}
static void
xpm_put_color_table_v (color_table, chars_start, chars_len, color)
Lisp_Object color_table;
const unsigned char *chars_start;
int chars_len;
Lisp_Object color;
{
XVECTOR (color_table)->contents[*chars_start] = color;
}
static Lisp_Object
xpm_get_color_table_v (color_table, chars_start, chars_len)
Lisp_Object color_table;
const unsigned char *chars_start;
int chars_len;
{
return XVECTOR (color_table)->contents[*chars_start];
}
static Lisp_Object
xpm_make_color_table_h (put_func, get_func)
void (**put_func) (Lisp_Object, const unsigned char *, int, Lisp_Object);
Lisp_Object (**get_func) (Lisp_Object, const unsigned char *, int);
{
*put_func = xpm_put_color_table_h;
*get_func = xpm_get_color_table_h;
return make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
make_float (DEFAULT_REHASH_SIZE),
make_float (DEFAULT_REHASH_THRESHOLD),
Qnil, Qnil, Qnil);
}
static void
xpm_put_color_table_h (color_table, chars_start, chars_len, color)
Lisp_Object color_table;
const unsigned char *chars_start;
int chars_len;
Lisp_Object color;
{
struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
unsigned hash_code;
Lisp_Object chars = make_unibyte_string (chars_start, chars_len);
hash_lookup (table, chars, &hash_code);
hash_put (table, chars, color, hash_code);
}
static Lisp_Object
xpm_get_color_table_h (color_table, chars_start, chars_len)
Lisp_Object color_table;
const unsigned char *chars_start;
int chars_len;
{
struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
int i = hash_lookup (table, make_unibyte_string (chars_start, chars_len),
NULL);
return i >= 0 ? HASH_VALUE (table, i) : Qnil;
}
enum xpm_color_key {
XPM_COLOR_KEY_S,
XPM_COLOR_KEY_M,
XPM_COLOR_KEY_G4,
XPM_COLOR_KEY_G,
XPM_COLOR_KEY_C
};
static const char xpm_color_key_strings[][4] = {"s", "m", "g4", "g", "c"};
static int
xpm_str_to_color_key (s)
const char *s;
{
int i;
for (i = 0;
i < sizeof xpm_color_key_strings / sizeof xpm_color_key_strings[0];
i++)
if (strcmp (xpm_color_key_strings[i], s) == 0)
return i;
return -1;
}
static int
xpm_load_image (f, img, contents, end)
struct frame *f;
struct image *img;
const unsigned char *contents, *end;
{
const unsigned char *s = contents, *beg, *str;
unsigned char buffer[BUFSIZ];
int width, height, x, y;
int num_colors, chars_per_pixel;
int len, LA1;
void (*put_color_table) (Lisp_Object, const unsigned char *, int, Lisp_Object);
Lisp_Object (*get_color_table) (Lisp_Object, const unsigned char *, int);
Lisp_Object frame, color_symbols, color_table;
int best_key, have_mask = 0;
XImagePtr ximg = NULL, mask_img = NULL;
#define match() \
LA1 = xpm_scan (&s, end, &beg, &len)
#define expect(TOKEN) \
if (LA1 != (TOKEN)) \
goto failure; \
else \
match ()
#define expect_ident(IDENT) \
if (LA1 == XPM_TK_IDENT \
&& strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
match (); \
else \
goto failure
if (!(end - s >= 9 && memcmp (s, "/* XPM */", 9) == 0))
goto failure;
s += 9;
match();
expect_ident ("static");
expect_ident ("char");
expect ('*');
expect (XPM_TK_IDENT);
expect ('[');
expect (']');
expect ('=');
expect ('{');
expect (XPM_TK_STRING);
if (len >= BUFSIZ)
goto failure;
memcpy (buffer, beg, len);
buffer[len] = '\0';
if (sscanf (buffer, "%d %d %d %d", &width, &height,
&num_colors, &chars_per_pixel) != 4
|| width <= 0 || height <= 0
|| num_colors <= 0 || chars_per_pixel <= 0)
goto failure;
if (!check_image_size (f, width, height))
{
image_error ("Invalid image size", Qnil, Qnil);
goto failure;
}
expect (',');
XSETFRAME (frame, f);
if (!NILP (Fxw_display_color_p (frame)))
best_key = XPM_COLOR_KEY_C;
else if (!NILP (Fx_display_grayscale_p (frame)))
best_key = (XFASTINT (Fx_display_planes (frame)) > 2
? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
else
best_key = XPM_COLOR_KEY_M;
color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
if (chars_per_pixel == 1)
color_table = xpm_make_color_table_v (&put_color_table,
&get_color_table);
else
color_table = xpm_make_color_table_h (&put_color_table,
&get_color_table);
while (num_colors-- > 0)
{
unsigned char *color, *max_color;
int key, next_key, max_key = 0;
Lisp_Object symbol_color = Qnil, color_val;
XColor cdef;
expect (XPM_TK_STRING);
if (len <= chars_per_pixel || len >= BUFSIZ + chars_per_pixel)
goto failure;
memcpy (buffer, beg + chars_per_pixel, len - chars_per_pixel);
buffer[len - chars_per_pixel] = '\0';
str = strtok (buffer, " \t");
if (str == NULL)
goto failure;
key = xpm_str_to_color_key (str);
if (key < 0)
goto failure;
do
{
color = strtok (NULL, " \t");
if (color == NULL)
goto failure;
while ((str = strtok (NULL, " \t")) != NULL)
{
next_key = xpm_str_to_color_key (str);
if (next_key >= 0)
break;
color[strlen (color)] = ' ';
}
if (key == XPM_COLOR_KEY_S)
{
if (NILP (symbol_color))
symbol_color = build_string (color);
}
else if (max_key < key && key <= best_key)
{
max_key = key;
max_color = color;
}
key = next_key;
}
while (str);
color_val = Qnil;
if (!NILP (color_symbols) && !NILP (symbol_color))
{
Lisp_Object specified_color = Fassoc (symbol_color, color_symbols);
if (CONSP (specified_color) && STRINGP (XCDR (specified_color)))
{
if (xstricmp (SDATA (XCDR (specified_color)), "None") == 0)
color_val = Qt;
else if (x_defined_color (f, SDATA (XCDR (specified_color)),
&cdef, 0))
color_val = make_number (cdef.pixel);
}
}
if (NILP (color_val) && max_key > 0)
{
if (xstricmp (max_color, "None") == 0)
color_val = Qt;
else if (x_defined_color (f, max_color, &cdef, 0))
color_val = make_number (cdef.pixel);
}
if (!NILP (color_val))
(*put_color_table) (color_table, beg, chars_per_pixel, color_val);
expect (',');
}
if (!x_create_x_image_and_pixmap (f, width, height, 0,
&ximg, &img->pixmap)
|| !x_create_x_image_and_pixmap (f, width, height, 1,
&mask_img, &img->mask))
{
image_error ("Out of memory (%s)", img->spec, Qnil);
goto error;
}
for (y = 0; y < height; y++)
{
expect (XPM_TK_STRING);
str = beg;
if (len < width * chars_per_pixel)
goto failure;
for (x = 0; x < width; x++, str += chars_per_pixel)
{
Lisp_Object color_val =
(*get_color_table) (color_table, str, chars_per_pixel);
XPutPixel (ximg, x, y,
(INTEGERP (color_val) ? XINT (color_val)
: FRAME_FOREGROUND_PIXEL (f)));
XPutPixel (mask_img, x, y,
(!EQ (color_val, Qt) ? PIX_MASK_DRAW
: (have_mask = 1, PIX_MASK_RETAIN)));
}
if (y + 1 < height)
expect (',');
}
img->width = width;
img->height = height;
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
if (have_mask)
{
image_background_transparent (img, f, mask_img);
x_put_x_image (f, mask_img, img->mask, width, height);
x_destroy_x_image (mask_img);
}
else
{
x_destroy_x_image (mask_img);
Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
img->mask = NO_PIXMAP;
}
return 1;
failure:
image_error ("Invalid XPM file (%s)", img->spec, Qnil);
error:
x_destroy_x_image (ximg);
x_destroy_x_image (mask_img);
x_clear_image (f, img);
return 0;
#undef match
#undef expect
#undef expect_ident
}
static int
xpm_load (f, img)
struct frame *f;
struct image *img;
{
int success_p = 0;
Lisp_Object file_name;
file_name = image_spec_value (img->spec, QCfile, NULL);
if (STRINGP (file_name))
{
Lisp_Object file;
unsigned char *contents;
int size;
struct gcpro gcpro1;
file = x_find_image_file (file_name);
GCPRO1 (file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", file_name, Qnil);
UNGCPRO;
return 0;
}
contents = slurp_file (SDATA (file), &size);
if (contents == NULL)
{
image_error ("Error loading XPM image `%s'", img->spec, Qnil);
UNGCPRO;
return 0;
}
success_p = xpm_load_image (f, img, contents, contents + size);
xfree (contents);
UNGCPRO;
}
else
{
Lisp_Object data;
data = image_spec_value (img->spec, QCdata, NULL);
success_p = xpm_load_image (f, img, SDATA (data),
SDATA (data) + SBYTES (data));
}
return success_p;
}
#endif
#ifdef COLOR_TABLE_SUPPORT
struct ct_color
{
int r, g, b;
unsigned long pixel;
struct ct_color *next;
};
#define CT_SIZE 101
#define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
struct ct_color **ct_table;
int ct_colors_allocated;
static void
init_color_table ()
{
int size = CT_SIZE * sizeof (*ct_table);
ct_table = (struct ct_color **) xmalloc (size);
bzero (ct_table, size);
ct_colors_allocated = 0;
}
static void
free_color_table ()
{
int i;
struct ct_color *p, *next;
for (i = 0; i < CT_SIZE; ++i)
for (p = ct_table[i]; p; p = next)
{
next = p->next;
xfree (p);
}
xfree (ct_table);
ct_table = NULL;
}
static unsigned long
lookup_rgb_color (f, r, g, b)
struct frame *f;
int r, g, b;
{
unsigned hash = CT_HASH_RGB (r, g, b);
int i = hash % CT_SIZE;
struct ct_color *p;
Display_Info *dpyinfo;
dpyinfo = FRAME_X_DISPLAY_INFO (f);
if (dpyinfo->red_bits > 0)
{
unsigned long pr, pg, pb;
if (f->gamma)
{
XColor color;
color.red = r, color.green = g, color.blue = b;
gamma_correct (f, &color);
r = color.red, g = color.green, b = color.blue;
}
pr = (r >> (16 - dpyinfo->red_bits)) << dpyinfo->red_offset;
pg = (g >> (16 - dpyinfo->green_bits)) << dpyinfo->green_offset;
pb = (b >> (16 - dpyinfo->blue_bits)) << dpyinfo->blue_offset;
return pr | pg | pb;
}
for (p = ct_table[i]; p; p = p->next)
if (p->r == r && p->g == g && p->b == b)
break;
if (p == NULL)
{
#ifdef HAVE_X_WINDOWS
XColor color;
Colormap cmap;
int rc;
color.red = r;
color.green = g;
color.blue = b;
cmap = FRAME_X_COLORMAP (f);
rc = x_alloc_nearest_color (f, cmap, &color);
if (rc)
{
++ct_colors_allocated;
p = (struct ct_color *) xmalloc (sizeof *p);
p->r = r;
p->g = g;
p->b = b;
p->pixel = color.pixel;
p->next = ct_table[i];
ct_table[i] = p;
}
else
return FRAME_FOREGROUND_PIXEL (f);
#else
COLORREF color;
#ifdef HAVE_NTGUI
color = PALETTERGB (r, g, b);
#else
color = RGB_TO_ULONG (r, g, b);
#endif
++ct_colors_allocated;
p = (struct ct_color *) xmalloc (sizeof *p);
p->r = r;
p->g = g;
p->b = b;
p->pixel = color;
p->next = ct_table[i];
ct_table[i] = p;
#endif
}
return p->pixel;
}
static unsigned long
lookup_pixel_color (f, pixel)
struct frame *f;
unsigned long pixel;
{
int i = pixel % CT_SIZE;
struct ct_color *p;
for (p = ct_table[i]; p; p = p->next)
if (p->pixel == pixel)
break;
if (p == NULL)
{
XColor color;
Colormap cmap;
int rc;
#ifdef HAVE_X_WINDOWS
cmap = FRAME_X_COLORMAP (f);
color.pixel = pixel;
x_query_color (f, &color);
rc = x_alloc_nearest_color (f, cmap, &color);
#else
BLOCK_INPUT;
cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
color.pixel = pixel;
XQueryColor (NULL, cmap, &color);
rc = x_alloc_nearest_color (f, cmap, &color);
UNBLOCK_INPUT;
#endif
if (rc)
{
++ct_colors_allocated;
p = (struct ct_color *) xmalloc (sizeof *p);
p->r = color.red;
p->g = color.green;
p->b = color.blue;
p->pixel = pixel;
p->next = ct_table[i];
ct_table[i] = p;
}
else
return FRAME_FOREGROUND_PIXEL (f);
}
return p->pixel;
}
static unsigned long *
colors_in_color_table (n)
int *n;
{
int i, j;
struct ct_color *p;
unsigned long *colors;
if (ct_colors_allocated == 0)
{
*n = 0;
colors = NULL;
}
else
{
colors = (unsigned long *) xmalloc (ct_colors_allocated
* sizeof *colors);
*n = ct_colors_allocated;
for (i = j = 0; i < CT_SIZE; ++i)
for (p = ct_table[i]; p; p = p->next)
colors[j++] = p->pixel;
}
return colors;
}
#else
static unsigned long
lookup_rgb_color (f, r, g, b)
struct frame *f;
int r, g, b;
{
unsigned long pixel;
#ifdef MAC_OS
pixel = RGB_TO_ULONG (r >> 8, g >> 8, b >> 8);
gamma_correct (f, &pixel);
#endif
#ifdef HAVE_NTGUI
pixel = PALETTERGB (r >> 8, g >> 8, b >> 8);
#endif
return pixel;
}
static void
init_color_table ()
{
}
#endif
static XColor *x_to_xcolors P_ ((struct frame *, struct image *, int));
static void x_from_xcolors P_ ((struct frame *, struct image *, XColor *));
static void x_detect_edges P_ ((struct frame *, struct image *, int[9], int));
#ifdef HAVE_NTGUI
static void XPutPixel (XImagePtr , int, int, COLORREF);
#endif
int cross_disabled_images;
static int emboss_matrix[9] = {
2, -1, 0,
-1, 0, 1,
0, 1, -2
};
static int laplace_matrix[9] = {
1, 0, 0,
0, 0, 0,
0, 0, -1
};
#define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
static XColor *
x_to_xcolors (f, img, rgb_p)
struct frame *f;
struct image *img;
int rgb_p;
{
int x, y;
XColor *colors, *p;
XImagePtr_or_DC ximg;
#ifdef HAVE_NTGUI
HDC hdc;
HGDIOBJ prev;
#endif
colors = (XColor *) xmalloc (img->width * img->height * sizeof *colors);
#ifndef HAVE_NTGUI
ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
0, 0, img->width, img->height, ~0, ZPixmap);
#else
hdc = get_frame_dc (f);
ximg = CreateCompatibleDC (hdc);
release_frame_dc (f, hdc);
prev = SelectObject (ximg, img->pixmap);
#endif
p = colors;
for (y = 0; y < img->height; ++y)
{
XColor *row = p;
#ifdef HAVE_X_WINDOWS
for (x = 0; x < img->width; ++x, ++p)
p->pixel = XGetPixel (ximg, x, y);
if (rgb_p)
x_query_colors (f, row, img->width);
#else
for (x = 0; x < img->width; ++x, ++p)
{
p->pixel = GET_PIXEL (ximg, x, y);
if (rgb_p)
{
#ifdef MAC_OS
p->red = RED16_FROM_ULONG (p->pixel);
p->green = GREEN16_FROM_ULONG (p->pixel);
p->blue = BLUE16_FROM_ULONG (p->pixel);
#endif
#ifdef HAVE_NTGUI
p->red = 256 * GetRValue (p->pixel);
p->green = 256 * GetGValue (p->pixel);
p->blue = 256 * GetBValue (p->pixel);
#endif
}
}
#endif
}
Destroy_Image (ximg, prev);
return colors;
}
#ifdef HAVE_NTGUI
static void XPutPixel (ximg, x, y, color)
XImagePtr ximg;
int x, y;
COLORREF color;
{
int width = ximg->info.bmiHeader.biWidth;
int height = ximg->info.bmiHeader.biHeight;
unsigned char * pixel;
if (ximg->info.bmiHeader.biBitCount == 24)
{
int rowbytes = width * 3;
if (rowbytes % 4)
rowbytes += 4 - (rowbytes % 4);
pixel = ximg->data + y * rowbytes + x * 3;
*pixel = GetBValue (color);
*(pixel + 1) = GetGValue (color);
*(pixel + 2) = GetRValue (color);
}
else if (ximg->info.bmiHeader.biBitCount == 1)
{
int rowbytes = width / 8;
if (rowbytes % 4)
rowbytes += 4 - (rowbytes % 4);
pixel = ximg->data + y * rowbytes + x / 8;
if (color & 0x00ffffff)
*pixel = *pixel | (1 << x % 8);
else
*pixel = *pixel & ~(1 << x % 8);
}
else
image_error ("XPutPixel: palette image not supported", Qnil, Qnil);
}
#endif
static void
x_from_xcolors (f, img, colors)
struct frame *f;
struct image *img;
XColor *colors;
{
int x, y;
XImagePtr oimg;
Pixmap pixmap;
XColor *p;
init_color_table ();
x_create_x_image_and_pixmap (f, img->width, img->height, 0,
&oimg, &pixmap);
p = colors;
for (y = 0; y < img->height; ++y)
for (x = 0; x < img->width; ++x, ++p)
{
unsigned long pixel;
pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
XPutPixel (oimg, x, y, pixel);
}
xfree (colors);
x_clear_image_1 (f, img, 1, 0, 1);
x_put_x_image (f, oimg, pixmap, img->width, img->height);
x_destroy_x_image (oimg);
img->pixmap = pixmap;
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
#endif
}
static void
x_detect_edges (f, img, matrix, color_adjust)
struct frame *f;
struct image *img;
int matrix[9], color_adjust;
{
XColor *colors = x_to_xcolors (f, img, 1);
XColor *new, *p;
int x, y, i, sum;
for (i = sum = 0; i < 9; ++i)
sum += abs (matrix[i]);
#define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
new = (XColor *) xmalloc (img->width * img->height * sizeof *new);
for (y = 0; y < img->height; ++y)
{
p = COLOR (new, 0, y);
p->red = p->green = p->blue = 0xffff/2;
p = COLOR (new, img->width - 1, y);
p->red = p->green = p->blue = 0xffff/2;
}
for (x = 1; x < img->width - 1; ++x)
{
p = COLOR (new, x, 0);
p->red = p->green = p->blue = 0xffff/2;
p = COLOR (new, x, img->height - 1);
p->red = p->green = p->blue = 0xffff/2;
}
for (y = 1; y < img->height - 1; ++y)
{
p = COLOR (new, 1, y);
for (x = 1; x < img->width - 1; ++x, ++p)
{
int r, g, b, y1, x1;
r = g = b = i = 0;
for (y1 = y - 1; y1 < y + 2; ++y1)
for (x1 = x - 1; x1 < x + 2; ++x1, ++i)
if (matrix[i])
{
XColor *t = COLOR (colors, x1, y1);
r += matrix[i] * t->red;
g += matrix[i] * t->green;
b += matrix[i] * t->blue;
}
r = (r / sum + color_adjust) & 0xffff;
g = (g / sum + color_adjust) & 0xffff;
b = (b / sum + color_adjust) & 0xffff;
p->red = p->green = p->blue = COLOR_INTENSITY (r, g, b);
}
}
xfree (colors);
x_from_xcolors (f, img, new);
#undef COLOR
}
static void
x_emboss (f, img)
struct frame *f;
struct image *img;
{
x_detect_edges (f, img, emboss_matrix, 0xffff / 2);
}
static void
x_laplace (f, img)
struct frame *f;
struct image *img;
{
x_detect_edges (f, img, laplace_matrix, 45000);
}
static void
x_edge_detection (f, img, matrix, color_adjust)
struct frame *f;
struct image *img;
Lisp_Object matrix, color_adjust;
{
int i = 0;
int trans[9];
if (CONSP (matrix))
{
for (i = 0;
i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
++i, matrix = XCDR (matrix))
trans[i] = XFLOATINT (XCAR (matrix));
}
else if (VECTORP (matrix) && ASIZE (matrix) >= 9)
{
for (i = 0; i < 9 && NUMBERP (AREF (matrix, i)); ++i)
trans[i] = XFLOATINT (AREF (matrix, i));
}
if (NILP (color_adjust))
color_adjust = make_number (0xffff / 2);
if (i == 9 && NUMBERP (color_adjust))
x_detect_edges (f, img, trans, (int) XFLOATINT (color_adjust));
}
static void
x_disable_image (f, img)
struct frame *f;
struct image *img;
{
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
#ifdef HAVE_NTGUI
int n_planes = dpyinfo->n_planes * dpyinfo->n_cbits;
#else
int n_planes = dpyinfo->n_planes;
#endif
if (n_planes >= 2)
{
XColor *colors = x_to_xcolors (f, img, 1);
XColor *p, *end;
const int h = 15000;
const int l = 30000;
for (p = colors, end = colors + img->width * img->height;
p < end;
++p)
{
int i = COLOR_INTENSITY (p->red, p->green, p->blue);
int i2 = (0xffff - h - l) * i / 0xffff + l;
p->red = p->green = p->blue = i2;
}
x_from_xcolors (f, img, colors);
}
if (n_planes < 2 || cross_disabled_images)
{
#ifndef HAVE_NTGUI
Display *dpy = FRAME_X_DISPLAY (f);
GC gc;
#ifdef MAC_OS
#define MaskForeground(f) PIX_MASK_DRAW
#else
#define MaskForeground(f) WHITE_PIX_DEFAULT (f)
#endif
gc = XCreateGC (dpy, img->pixmap, 0, NULL);
XSetForeground (dpy, gc, BLACK_PIX_DEFAULT (f));
XDrawLine (dpy, img->pixmap, gc, 0, 0,
img->width - 1, img->height - 1);
XDrawLine (dpy, img->pixmap, gc, 0, img->height - 1,
img->width - 1, 0);
XFreeGC (dpy, gc);
if (img->mask)
{
gc = XCreateGC (dpy, img->mask, 0, NULL);
XSetForeground (dpy, gc, MaskForeground (f));
XDrawLine (dpy, img->mask, gc, 0, 0,
img->width - 1, img->height - 1);
XDrawLine (dpy, img->mask, gc, 0, img->height - 1,
img->width - 1, 0);
XFreeGC (dpy, gc);
}
#else
HDC hdc, bmpdc;
HGDIOBJ prev;
hdc = get_frame_dc (f);
bmpdc = CreateCompatibleDC (hdc);
release_frame_dc (f, hdc);
prev = SelectObject (bmpdc, img->pixmap);
SetTextColor (bmpdc, BLACK_PIX_DEFAULT (f));
MoveToEx (bmpdc, 0, 0, NULL);
LineTo (bmpdc, img->width - 1, img->height - 1);
MoveToEx (bmpdc, 0, img->height - 1, NULL);
LineTo (bmpdc, img->width - 1, 0);
if (img->mask)
{
SelectObject (bmpdc, img->mask);
SetTextColor (bmpdc, WHITE_PIX_DEFAULT (f));
MoveToEx (bmpdc, 0, 0, NULL);
LineTo (bmpdc, img->width - 1, img->height - 1);
MoveToEx (bmpdc, 0, img->height - 1, NULL);
LineTo (bmpdc, img->width - 1, 0);
}
SelectObject (bmpdc, prev);
DeleteDC (bmpdc);
#endif
}
}
static int
x_build_heuristic_mask (f, img, how)
struct frame *f;
struct image *img;
Lisp_Object how;
{
XImagePtr_or_DC ximg;
#ifndef HAVE_NTGUI
XImagePtr mask_img;
#else
HDC frame_dc;
HGDIOBJ prev;
char *mask_img;
int row_width;
#endif
int x, y, rc, use_img_background;
unsigned long bg = 0;
if (img->mask)
{
Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
img->mask = NO_PIXMAP;
img->background_transparent_valid = 0;
}
#ifndef HAVE_NTGUI
rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
&mask_img, &img->mask);
if (!rc)
return 0;
ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap, 0, 0,
img->width, img->height,
~0, ZPixmap);
#else
row_width = (img->width + 7) / 8;
mask_img = xmalloc (row_width * img->height);
bzero (mask_img, row_width * img->height);
frame_dc = get_frame_dc (f);
ximg = CreateCompatibleDC (frame_dc);
release_frame_dc (f, frame_dc);
prev = SelectObject (ximg, img->pixmap);
#endif
use_img_background = 1;
if (CONSP (how))
{
int rgb[3], i;
for (i = 0; i < 3 && CONSP (how) && NATNUMP (XCAR (how)); ++i)
{
rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
how = XCDR (how);
}
if (i == 3 && NILP (how))
{
char color_name[30];
sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
bg = (
#ifdef HAVE_NTGUI
0x00ffffff &
#endif
x_alloc_image_color (f, img, build_string (color_name), 0));
use_img_background = 0;
}
}
if (use_img_background)
bg = four_corners_best (ximg, img->corners, img->width, img->height);
#ifndef HAVE_NTGUI
for (y = 0; y < img->height; ++y)
for (x = 0; x < img->width; ++x)
XPutPixel (mask_img, x, y, (XGetPixel (ximg, x, y) != bg
? PIX_MASK_DRAW : PIX_MASK_RETAIN));
image_background_transparent (img, f, mask_img);
x_put_x_image (f, mask_img, img->mask, img->width, img->height);
x_destroy_x_image (mask_img);
#else
for (y = 0; y < img->height; ++y)
for (x = 0; x < img->width; ++x)
{
COLORREF p = GetPixel (ximg, x, y);
if (p != bg)
mask_img[y * row_width + x / 8] |= 1 << (x % 8);
}
img->mask = w32_create_pixmap_from_bitmap_data (img->width, img->height,
mask_img);
SelectObject (ximg, img->mask);
image_background_transparent (img, f, ximg);
xfree (mask_img);
#endif
Destroy_Image (ximg, prev);
return 1;
}
static int pbm_image_p P_ ((Lisp_Object object));
static int pbm_load P_ ((struct frame *f, struct image *img));
static int pbm_scan_number P_ ((unsigned char **, unsigned char *));
Lisp_Object Qpbm;
enum pbm_keyword_index
{
PBM_TYPE,
PBM_FILE,
PBM_DATA,
PBM_ASCENT,
PBM_MARGIN,
PBM_RELIEF,
PBM_ALGORITHM,
PBM_HEURISTIC_MASK,
PBM_MASK,
PBM_FOREGROUND,
PBM_BACKGROUND,
PBM_LAST
};
static struct image_keyword pbm_format[PBM_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":file", IMAGE_STRING_VALUE, 0},
{":data", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
static struct image_type pbm_type =
{
&Qpbm,
pbm_image_p,
pbm_load,
x_clear_image,
NULL
};
static int
pbm_image_p (object)
Lisp_Object object;
{
struct image_keyword fmt[PBM_LAST];
bcopy (pbm_format, fmt, sizeof fmt);
if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm))
return 0;
return fmt[PBM_DATA].count + fmt[PBM_FILE].count == 1;
}
static int
pbm_scan_number (s, end)
unsigned char **s, *end;
{
int c = 0, val = -1;
while (*s < end)
{
while (*s < end && (c = *(*s)++, isspace (c)))
;
if (c == '#')
{
while (*s < end && (c = *(*s)++, c != '\n'))
;
}
else if (isdigit (c))
{
val = c - '0';
while (*s < end && (c = *(*s)++, isdigit (c)))
val = 10 * val + c - '0';
break;
}
else
break;
}
return val;
}
#ifdef HAVE_NTGUI
#if 0
static char *
pbm_read_file (file, size)
Lisp_Object file;
int *size;
{
FILE *fp = NULL;
char *buf = NULL;
struct stat st;
if (stat (SDATA (file), &st) == 0
&& (fp = fopen (SDATA (file), "rb")) != NULL
&& (buf = (char *) xmalloc (st.st_size),
fread (buf, 1, st.st_size, fp) == st.st_size))
{
*size = st.st_size;
fclose (fp);
}
else
{
if (fp)
fclose (fp);
if (buf)
{
xfree (buf);
buf = NULL;
}
}
return buf;
}
#endif
#endif
static int
pbm_load (f, img)
struct frame *f;
struct image *img;
{
int raw_p, x, y;
int width, height, max_color_idx = 0;
XImagePtr ximg;
Lisp_Object file, specified_file;
enum {PBM_MONO, PBM_GRAY, PBM_COLOR} type;
struct gcpro gcpro1;
unsigned char *contents = NULL;
unsigned char *end, *p;
int size;
specified_file = image_spec_value (img->spec, QCfile, NULL);
file = Qnil;
GCPRO1 (file);
if (STRINGP (specified_file))
{
file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNGCPRO;
return 0;
}
contents = slurp_file (SDATA (file), &size);
if (contents == NULL)
{
image_error ("Error reading `%s'", file, Qnil);
UNGCPRO;
return 0;
}
p = contents;
end = contents + size;
}
else
{
Lisp_Object data;
data = image_spec_value (img->spec, QCdata, NULL);
p = SDATA (data);
end = p + SBYTES (data);
}
if (end - p < 2 || *p++ != 'P')
{
image_error ("Not a PBM image: `%s'", img->spec, Qnil);
error:
xfree (contents);
UNGCPRO;
return 0;
}
switch (*p++)
{
case '1':
raw_p = 0, type = PBM_MONO;
break;
case '2':
raw_p = 0, type = PBM_GRAY;
break;
case '3':
raw_p = 0, type = PBM_COLOR;
break;
case '4':
raw_p = 1, type = PBM_MONO;
break;
case '5':
raw_p = 1, type = PBM_GRAY;
break;
case '6':
raw_p = 1, type = PBM_COLOR;
break;
default:
image_error ("Not a PBM image: `%s'", img->spec, Qnil);
goto error;
}
width = pbm_scan_number (&p, end);
height = pbm_scan_number (&p, end);
if (type != PBM_MONO)
{
max_color_idx = pbm_scan_number (&p, end);
if (raw_p && max_color_idx > 255)
max_color_idx = 255;
}
if (!check_image_size (f, width, height)
|| (type != PBM_MONO && max_color_idx < 0))
goto error;
if (!x_create_x_image_and_pixmap (f, width, height, 0,
&ximg, &img->pixmap))
goto error;
init_color_table ();
if (type == PBM_MONO)
{
int c = 0, g;
struct image_keyword fmt[PBM_LAST];
unsigned long fg = FRAME_FOREGROUND_PIXEL (f);
unsigned long bg = FRAME_BACKGROUND_PIXEL (f);
bcopy (pbm_format, fmt, sizeof fmt);
parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
if (fmt[PBM_FOREGROUND].count
&& STRINGP (fmt[PBM_FOREGROUND].value))
fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
if (fmt[PBM_BACKGROUND].count
&& STRINGP (fmt[PBM_BACKGROUND].value))
{
bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
img->background = bg;
img->background_valid = 1;
}
for (y = 0; y < height; ++y)
for (x = 0; x < width; ++x)
{
if (raw_p)
{
if ((x & 7) == 0)
c = *p++;
g = c & 0x80;
c <<= 1;
}
else
g = pbm_scan_number (&p, end);
XPutPixel (ximg, x, y, g ? fg : bg);
}
}
else
{
if (raw_p
&& ((type == PBM_GRAY)
? (p + height * width > end)
: (p + 3 * height * width > end)))
{
x_destroy_x_image (ximg);
x_clear_image (f, img);
image_error ("Invalid image size in image `%s'",
img->spec, Qnil);
goto error;
}
for (y = 0; y < height; ++y)
for (x = 0; x < width; ++x)
{
int r, g, b;
if (type == PBM_GRAY)
r = g = b = raw_p ? *p++ : pbm_scan_number (&p, end);
else if (raw_p)
{
r = *p++;
g = *p++;
b = *p++;
}
else
{
r = pbm_scan_number (&p, end);
g = pbm_scan_number (&p, end);
b = pbm_scan_number (&p, end);
}
if (r < 0 || g < 0 || b < 0)
{
x_destroy_x_image (ximg);
image_error ("Invalid pixel value in image `%s'",
img->spec, Qnil);
goto error;
}
r = (double) r * 65535 / max_color_idx;
g = (double) g * 65535 / max_color_idx;
b = (double) b * 65535 / max_color_idx;
XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
}
}
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
#endif
img->width = width;
img->height = height;
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
UNGCPRO;
xfree (contents);
return 1;
}
#if defined (HAVE_PNG) || defined (MAC_OS)
static int png_image_p P_ ((Lisp_Object object));
static int png_load P_ ((struct frame *f, struct image *img));
Lisp_Object Qpng;
enum png_keyword_index
{
PNG_TYPE,
PNG_DATA,
PNG_FILE,
PNG_ASCENT,
PNG_MARGIN,
PNG_RELIEF,
PNG_ALGORITHM,
PNG_HEURISTIC_MASK,
PNG_MASK,
PNG_BACKGROUND,
PNG_LAST
};
static struct image_keyword png_format[PNG_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
static struct image_type png_type =
{
&Qpng,
png_image_p,
png_load,
x_clear_image,
NULL
};
static int
png_image_p (object)
Lisp_Object object;
{
struct image_keyword fmt[PNG_LAST];
bcopy (png_format, fmt, sizeof fmt);
if (!parse_image_spec (object, fmt, PNG_LAST, Qpng))
return 0;
return fmt[PNG_FILE].count + fmt[PNG_DATA].count == 1;
}
#endif
#ifdef HAVE_PNG
#if defined HAVE_LIBPNG_PNG_H
# include <libpng/png.h>
#else
# include <png.h>
#endif
#ifdef HAVE_NTGUI
DEF_IMGLIB_FN (png_get_io_ptr);
DEF_IMGLIB_FN (png_check_sig);
DEF_IMGLIB_FN (png_create_read_struct);
DEF_IMGLIB_FN (png_create_info_struct);
DEF_IMGLIB_FN (png_destroy_read_struct);
DEF_IMGLIB_FN (png_set_read_fn);
DEF_IMGLIB_FN (png_set_sig_bytes);
DEF_IMGLIB_FN (png_read_info);
DEF_IMGLIB_FN (png_get_IHDR);
DEF_IMGLIB_FN (png_get_valid);
DEF_IMGLIB_FN (png_set_strip_16);
DEF_IMGLIB_FN (png_set_expand);
DEF_IMGLIB_FN (png_set_gray_to_rgb);
DEF_IMGLIB_FN (png_set_background);
DEF_IMGLIB_FN (png_get_bKGD);
DEF_IMGLIB_FN (png_read_update_info);
DEF_IMGLIB_FN (png_get_channels);
DEF_IMGLIB_FN (png_get_rowbytes);
DEF_IMGLIB_FN (png_read_image);
DEF_IMGLIB_FN (png_read_end);
DEF_IMGLIB_FN (png_error);
static int
init_png_functions (Lisp_Object libraries)
{
HMODULE library;
if (!(library = w32_delayed_load (libraries, Qpng)))
return 0;
LOAD_IMGLIB_FN (library, png_get_io_ptr);
LOAD_IMGLIB_FN (library, png_check_sig);
LOAD_IMGLIB_FN (library, png_create_read_struct);
LOAD_IMGLIB_FN (library, png_create_info_struct);
LOAD_IMGLIB_FN (library, png_destroy_read_struct);
LOAD_IMGLIB_FN (library, png_set_read_fn);
LOAD_IMGLIB_FN (library, png_set_sig_bytes);
LOAD_IMGLIB_FN (library, png_read_info);
LOAD_IMGLIB_FN (library, png_get_IHDR);
LOAD_IMGLIB_FN (library, png_get_valid);
LOAD_IMGLIB_FN (library, png_set_strip_16);
LOAD_IMGLIB_FN (library, png_set_expand);
LOAD_IMGLIB_FN (library, png_set_gray_to_rgb);
LOAD_IMGLIB_FN (library, png_set_background);
LOAD_IMGLIB_FN (library, png_get_bKGD);
LOAD_IMGLIB_FN (library, png_read_update_info);
LOAD_IMGLIB_FN (library, png_get_channels);
LOAD_IMGLIB_FN (library, png_get_rowbytes);
LOAD_IMGLIB_FN (library, png_read_image);
LOAD_IMGLIB_FN (library, png_read_end);
LOAD_IMGLIB_FN (library, png_error);
return 1;
}
#else
#define fn_png_get_io_ptr png_get_io_ptr
#define fn_png_check_sig png_check_sig
#define fn_png_create_read_struct png_create_read_struct
#define fn_png_create_info_struct png_create_info_struct
#define fn_png_destroy_read_struct png_destroy_read_struct
#define fn_png_set_read_fn png_set_read_fn
#define fn_png_set_sig_bytes png_set_sig_bytes
#define fn_png_read_info png_read_info
#define fn_png_get_IHDR png_get_IHDR
#define fn_png_get_valid png_get_valid
#define fn_png_set_strip_16 png_set_strip_16
#define fn_png_set_expand png_set_expand
#define fn_png_set_gray_to_rgb png_set_gray_to_rgb
#define fn_png_set_background png_set_background
#define fn_png_get_bKGD png_get_bKGD
#define fn_png_read_update_info png_read_update_info
#define fn_png_get_channels png_get_channels
#define fn_png_get_rowbytes png_get_rowbytes
#define fn_png_read_image png_read_image
#define fn_png_read_end png_read_end
#define fn_png_error png_error
#endif
static void
my_png_error (png_ptr, msg)
png_struct *png_ptr;
char *msg;
{
xassert (png_ptr != NULL);
image_error ("PNG error: %s", build_string (msg), Qnil);
longjmp (png_ptr->jmpbuf, 1);
}
static void
my_png_warning (png_ptr, msg)
png_struct *png_ptr;
char *msg;
{
xassert (png_ptr != NULL);
image_error ("PNG warning: %s", build_string (msg), Qnil);
}
struct png_memory_storage
{
unsigned char *bytes;
size_t len;
int index;
};
static void
png_read_from_memory (png_ptr, data, length)
png_structp png_ptr;
png_bytep data;
png_size_t length;
{
struct png_memory_storage *tbr
= (struct png_memory_storage *) fn_png_get_io_ptr (png_ptr);
if (length > tbr->len - tbr->index)
fn_png_error (png_ptr, "Read error");
bcopy (tbr->bytes + tbr->index, data, length);
tbr->index = tbr->index + length;
}
static void
png_read_from_file (png_ptr, data, length)
png_structp png_ptr;
png_bytep data;
png_size_t length;
{
FILE *fp = (FILE *) fn_png_get_io_ptr (png_ptr);
if (fread (data, 1, length, fp) < length)
fn_png_error (png_ptr, "Read error");
}
static int
png_load (f, img)
struct frame *f;
struct image *img;
{
Lisp_Object file, specified_file;
Lisp_Object specified_data;
int x, y, i;
XImagePtr ximg, mask_img = NULL;
struct gcpro gcpro1;
png_struct *png_ptr = NULL;
png_info *info_ptr = NULL, *end_info = NULL;
FILE *volatile fp = NULL;
png_byte sig[8];
png_byte * volatile pixels = NULL;
png_byte ** volatile rows = NULL;
png_uint_32 width, height;
int bit_depth, color_type, interlace_type;
png_byte channels;
png_uint_32 row_bytes;
int transparent_p;
double screen_gamma;
struct png_memory_storage tbr;
specified_file = image_spec_value (img->spec, QCfile, NULL);
specified_data = image_spec_value (img->spec, QCdata, NULL);
file = Qnil;
GCPRO1 (file);
if (NILP (specified_data))
{
file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNGCPRO;
return 0;
}
fp = fopen (SDATA (file), "rb");
if (!fp)
{
image_error ("Cannot open image file `%s'", file, Qnil);
UNGCPRO;
return 0;
}
if (fread (sig, 1, sizeof sig, fp) != sizeof sig
|| !fn_png_check_sig (sig, sizeof sig))
{
image_error ("Not a PNG file: `%s'", file, Qnil);
UNGCPRO;
fclose (fp);
return 0;
}
}
else
{
tbr.bytes = SDATA (specified_data);
tbr.len = SBYTES (specified_data);
tbr.index = 0;
if (tbr.len < sizeof sig
|| !fn_png_check_sig (tbr.bytes, sizeof sig))
{
image_error ("Not a PNG image: `%s'", img->spec, Qnil);
UNGCPRO;
return 0;
}
tbr.bytes += sizeof (sig);
}
png_ptr = (png_structp)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING,
NULL, my_png_error,
my_png_warning);
if (!png_ptr)
{
if (fp) fclose (fp);
UNGCPRO;
return 0;
}
info_ptr = (png_infop)fn_png_create_info_struct (png_ptr);
if (!info_ptr)
{
fn_png_destroy_read_struct (&png_ptr, NULL, NULL);
if (fp) fclose (fp);
UNGCPRO;
return 0;
}
end_info = (png_infop)fn_png_create_info_struct (png_ptr);
if (!end_info)
{
fn_png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
if (fp) fclose (fp);
UNGCPRO;
return 0;
}
if (setjmp (png_ptr->jmpbuf))
{
error:
if (png_ptr)
fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
xfree (pixels);
xfree (rows);
if (fp) fclose (fp);
UNGCPRO;
return 0;
}
if (!NILP (specified_data))
fn_png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
else
fn_png_set_read_fn (png_ptr, (void *) fp, png_read_from_file);
fn_png_set_sig_bytes (png_ptr, sizeof sig);
fn_png_read_info (png_ptr, info_ptr);
fn_png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, NULL, NULL);
if (!check_image_size (f, width, height))
goto error;
if (fn_png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
transparent_p = 1;
else
transparent_p = 0;
if (bit_depth == 16)
fn_png_set_strip_16 (png_ptr);
fn_png_set_expand (png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY
|| color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
fn_png_set_gray_to_rgb (png_ptr);
screen_gamma = (f->gamma ? 1 / f->gamma / 0.45455 : 2.2);
#if 0
{
int intent;
double image_gamma;
#if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
if (png_get_sRGB (png_ptr, info_ptr, &intent))
png_set_gamma (png_ptr, screen_gamma, 0.45455);
else
#endif
if (png_get_gAMA (png_ptr, info_ptr, &image_gamma))
png_set_gamma (png_ptr, screen_gamma, image_gamma);
else
png_set_gamma (png_ptr, screen_gamma, 0.45455);
}
#endif
if (!transparent_p)
{
png_color_16 *image_bg;
Lisp_Object specified_bg
= image_spec_value (img->spec, QCbackground, NULL);
if (STRINGP (specified_bg))
{
XColor color;
if (x_defined_color (f, SDATA (specified_bg), &color, 0))
{
png_color_16 user_bg;
bzero (&user_bg, sizeof user_bg);
user_bg.red = color.red >> 8;
user_bg.green = color.green >> 8;
user_bg.blue = color.blue >> 8;
fn_png_set_background (png_ptr, &user_bg,
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
}
}
else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
fn_png_set_background (png_ptr, image_bg,
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
else
{
#ifdef HAVE_X_WINDOWS
XColor color;
png_color_16 frame_background;
color.pixel = FRAME_BACKGROUND_PIXEL (f);
x_query_color (f, &color);
bzero (&frame_background, sizeof frame_background);
frame_background.red = color.red >> 8;
frame_background.green = color.green >> 8;
frame_background.blue = color.blue >> 8;
#endif
#ifdef HAVE_NTGUI
COLORREF color;
png_color_16 frame_background;
color = FRAME_BACKGROUND_PIXEL (f);
#if 0
x_query_color (f, &color);
#endif
bzero (&frame_background, sizeof frame_background);
frame_background.red = GetRValue (color);
frame_background.green = GetGValue (color);
frame_background.blue = GetBValue (color);
#endif
#ifdef MAC_OS
unsigned long color;
png_color_16 frame_background;
color = FRAME_BACKGROUND_PIXEL (f);
#if 0
x_query_color (f, &color);
#endif
bzero (&frame_background, sizeof frame_background);
frame_background.red = RED_FROM_ULONG (color);
frame_background.green = GREEN_FROM_ULONG (color);
frame_background.blue = BLUE_FROM_ULONG (color);
#endif
fn_png_set_background (png_ptr, &frame_background,
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
}
}
fn_png_read_update_info (png_ptr, info_ptr);
channels = fn_png_get_channels (png_ptr, info_ptr);
xassert (channels == 3 || channels == 4);
row_bytes = fn_png_get_rowbytes (png_ptr, info_ptr);
pixels = (png_byte *) xmalloc (row_bytes * height * sizeof *pixels);
rows = (png_byte **) xmalloc (height * sizeof *rows);
for (i = 0; i < height; ++i)
rows[i] = pixels + i * row_bytes;
fn_png_read_image (png_ptr, rows);
fn_png_read_end (png_ptr, info_ptr);
if (fp)
{
fclose (fp);
fp = NULL;
}
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
&img->pixmap))
goto error;
if (channels == 4
&& !transparent_p
&& !x_create_x_image_and_pixmap (f, width, height, 1,
&mask_img, &img->mask))
{
x_destroy_x_image (ximg);
Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
img->pixmap = NO_PIXMAP;
goto error;
}
init_color_table ();
for (y = 0; y < height; ++y)
{
png_byte *p = rows[y];
for (x = 0; x < width; ++x)
{
unsigned r, g, b;
r = *p++ << 8;
g = *p++ << 8;
b = *p++ << 8;
XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
if (channels == 4)
{
if (mask_img)
XPutPixel (mask_img, x, y, *p > 0 ? PIX_MASK_DRAW : PIX_MASK_RETAIN);
++p;
}
}
}
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
{
png_color_16 *bg;
if (fn_png_get_bKGD (png_ptr, info_ptr, &bg))
{
img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
img->background_valid = 1;
}
}
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
#endif
fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
xfree (rows);
xfree (pixels);
img->width = width;
img->height = height;
IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
if (mask_img)
{
image_background_transparent (img, f, (XImagePtr_or_DC)mask_img);
x_put_x_image (f, mask_img, img->mask, img->width, img->height);
x_destroy_x_image (mask_img);
}
UNGCPRO;
return 1;
}
#else
#ifdef MAC_OS
static int
png_load (f, img)
struct frame *f;
struct image *img;
{
#ifdef MAC_OSX
if (MyCGImageCreateWithPNGDataProvider)
return image_load_quartz2d (f, img, 1);
else
#endif
return image_load_quicktime (f, img, kQTFileTypePNG);
}
#endif
#endif
#if defined (HAVE_JPEG) || defined (MAC_OS)
static int jpeg_image_p P_ ((Lisp_Object object));
static int jpeg_load P_ ((struct frame *f, struct image *img));
Lisp_Object Qjpeg;
enum jpeg_keyword_index
{
JPEG_TYPE,
JPEG_DATA,
JPEG_FILE,
JPEG_ASCENT,
JPEG_MARGIN,
JPEG_RELIEF,
JPEG_ALGORITHM,
JPEG_HEURISTIC_MASK,
JPEG_MASK,
JPEG_BACKGROUND,
JPEG_LAST
};
static struct image_keyword jpeg_format[JPEG_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
static struct image_type jpeg_type =
{
&Qjpeg,
jpeg_image_p,
jpeg_load,
x_clear_image,
NULL
};
static int
jpeg_image_p (object)
Lisp_Object object;
{
struct image_keyword fmt[JPEG_LAST];
bcopy (jpeg_format, fmt, sizeof fmt);
if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg))
return 0;
return fmt[JPEG_FILE].count + fmt[JPEG_DATA].count == 1;
}
#endif
#ifdef HAVE_JPEG
#ifdef HAVE_STDLIB_H
#define HAVE_STDLIB_H_1
#undef HAVE_STDLIB_H
#endif
#if defined (HAVE_NTGUI) && !defined (__WIN32__)
#define __WIN32__ 1
#endif
#include <jpeglib.h>
#include <jerror.h>
#include <setjmp.h>
#ifdef HAVE_STLIB_H_1
#define HAVE_STDLIB_H 1
#endif
#ifdef HAVE_NTGUI
DEF_IMGLIB_FN (jpeg_CreateDecompress);
DEF_IMGLIB_FN (jpeg_start_decompress);
DEF_IMGLIB_FN (jpeg_finish_decompress);
DEF_IMGLIB_FN (jpeg_destroy_decompress);
DEF_IMGLIB_FN (jpeg_read_header);
DEF_IMGLIB_FN (jpeg_read_scanlines);
DEF_IMGLIB_FN (jpeg_std_error);
DEF_IMGLIB_FN (jpeg_resync_to_restart);
static int
init_jpeg_functions (Lisp_Object libraries)
{
HMODULE library;
if (!(library = w32_delayed_load (libraries, Qjpeg)))
return 0;
LOAD_IMGLIB_FN (library, jpeg_finish_decompress);
LOAD_IMGLIB_FN (library, jpeg_read_scanlines);
LOAD_IMGLIB_FN (library, jpeg_start_decompress);
LOAD_IMGLIB_FN (library, jpeg_read_header);
LOAD_IMGLIB_FN (library, jpeg_CreateDecompress);
LOAD_IMGLIB_FN (library, jpeg_destroy_decompress);
LOAD_IMGLIB_FN (library, jpeg_std_error);
LOAD_IMGLIB_FN (library, jpeg_resync_to_restart);
return 1;
}
static boolean
jpeg_resync_to_restart_wrapper(cinfo, desired)
j_decompress_ptr cinfo;
int desired;
{
return fn_jpeg_resync_to_restart (cinfo, desired);
}
#else
#define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
#define fn_jpeg_start_decompress jpeg_start_decompress
#define fn_jpeg_finish_decompress jpeg_finish_decompress
#define fn_jpeg_destroy_decompress jpeg_destroy_decompress
#define fn_jpeg_read_header jpeg_read_header
#define fn_jpeg_read_scanlines jpeg_read_scanlines
#define fn_jpeg_std_error jpeg_std_error
#define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
#endif
struct my_jpeg_error_mgr
{
struct jpeg_error_mgr pub;
jmp_buf setjmp_buffer;
};
static void
my_error_exit (cinfo)
j_common_ptr cinfo;
{
struct my_jpeg_error_mgr *mgr = (struct my_jpeg_error_mgr *) cinfo->err;
longjmp (mgr->setjmp_buffer, 1);
}
static void
our_common_init_source (cinfo)
j_decompress_ptr cinfo;
{
}
static void
our_common_term_source (cinfo)
j_decompress_ptr cinfo;
{
}
static boolean
our_memory_fill_input_buffer (cinfo)
j_decompress_ptr cinfo;
{
struct jpeg_source_mgr *src = cinfo->src;
static JOCTET buffer[2];
buffer[0] = (JOCTET) 0xFF;
buffer[1] = (JOCTET) JPEG_EOI;
src->next_input_byte = buffer;
src->bytes_in_buffer = 2;
return 1;
}
static void
our_memory_skip_input_data (cinfo, num_bytes)
j_decompress_ptr cinfo;
long num_bytes;
{
struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
if (src)
{
if (num_bytes > src->bytes_in_buffer)
ERREXIT (cinfo, JERR_INPUT_EOF);
src->bytes_in_buffer -= num_bytes;
src->next_input_byte += num_bytes;
}
}
static void
jpeg_memory_src (cinfo, data, len)
j_decompress_ptr cinfo;
JOCTET *data;
unsigned int len;
{
struct jpeg_source_mgr *src;
if (cinfo->src == NULL)
{
cinfo->src = (struct jpeg_source_mgr *)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
sizeof (struct jpeg_source_mgr));
src = (struct jpeg_source_mgr *) cinfo->src;
src->next_input_byte = data;
}
src = (struct jpeg_source_mgr *) cinfo->src;
src->init_source = our_common_init_source;
src->fill_input_buffer = our_memory_fill_input_buffer;
src->skip_input_data = our_memory_skip_input_data;
src->resync_to_restart = jpeg_resync_to_restart_wrapper;
src->term_source = our_common_term_source;
src->bytes_in_buffer = len;
src->next_input_byte = data;
}
struct jpeg_stdio_mgr
{
struct jpeg_source_mgr mgr;
boolean finished;
FILE *file;
JOCTET *buffer;
};
#define JPEG_STDIO_BUFFER_SIZE 8192
static boolean
our_stdio_fill_input_buffer (cinfo)
j_decompress_ptr cinfo;
{
struct jpeg_stdio_mgr *src;
src = (struct jpeg_stdio_mgr *) cinfo->src;
if (!src->finished)
{
size_t bytes;
bytes = fread (src->buffer, 1, JPEG_STDIO_BUFFER_SIZE, src->file);
if (bytes > 0)
src->mgr.bytes_in_buffer = bytes;
else
{
WARNMS (cinfo, JWRN_JPEG_EOF);
src->finished = 1;
src->buffer[0] = (JOCTET) 0xFF;
src->buffer[1] = (JOCTET) JPEG_EOI;
src->mgr.bytes_in_buffer = 2;
}
src->mgr.next_input_byte = src->buffer;
}
return 1;
}
static void
our_stdio_skip_input_data (cinfo, num_bytes)
j_decompress_ptr cinfo;
long num_bytes;
{
struct jpeg_stdio_mgr *src;
src = (struct jpeg_stdio_mgr *) cinfo->src;
while (num_bytes > 0 && !src->finished)
{
if (num_bytes <= src->mgr.bytes_in_buffer)
{
src->mgr.bytes_in_buffer -= num_bytes;
src->mgr.next_input_byte += num_bytes;
break;
}
else
{
num_bytes -= src->mgr.bytes_in_buffer;
src->mgr.bytes_in_buffer = 0;
src->mgr.next_input_byte = NULL;
our_stdio_fill_input_buffer (cinfo);
}
}
}
static void
jpeg_file_src (cinfo, fp)
j_decompress_ptr cinfo;
FILE *fp;
{
struct jpeg_stdio_mgr *src;
if (cinfo->src != NULL)
src = (struct jpeg_stdio_mgr *) cinfo->src;
else
{
cinfo->src = (struct jpeg_source_mgr *)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
sizeof (struct jpeg_stdio_mgr));
src = (struct jpeg_stdio_mgr *) cinfo->src;
src->buffer = (JOCTET *)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
JPEG_STDIO_BUFFER_SIZE);
}
src->file = fp;
src->finished = 0;
src->mgr.init_source = our_common_init_source;
src->mgr.fill_input_buffer = our_stdio_fill_input_buffer;
src->mgr.skip_input_data = our_stdio_skip_input_data;
src->mgr.resync_to_restart = jpeg_resync_to_restart_wrapper;
src->mgr.term_source = our_common_term_source;
src->mgr.bytes_in_buffer = 0;
src->mgr.next_input_byte = NULL;
}
static int
jpeg_load (f, img)
struct frame *f;
struct image *img;
{
struct jpeg_decompress_struct cinfo;
struct my_jpeg_error_mgr mgr;
Lisp_Object file, specified_file;
Lisp_Object specified_data;
FILE * volatile fp = NULL;
JSAMPARRAY buffer;
int row_stride, x, y;
XImagePtr ximg = NULL;
int rc;
unsigned long *colors;
int width, height;
struct gcpro gcpro1;
specified_file = image_spec_value (img->spec, QCfile, NULL);
specified_data = image_spec_value (img->spec, QCdata, NULL);
file = Qnil;
GCPRO1 (file);
if (NILP (specified_data))
{
file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNGCPRO;
return 0;
}
fp = fopen (SDATA (file), "rb");
if (fp == NULL)
{
image_error ("Cannot open `%s'", file, Qnil);
UNGCPRO;
return 0;
}
}
cinfo.err = (struct jpeg_error_mgr *)fn_jpeg_std_error (&mgr.pub);
mgr.pub.error_exit = my_error_exit;
if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
{
if (rc == 1)
{
char buffer[JMSG_LENGTH_MAX];
cinfo.err->format_message ((j_common_ptr) &cinfo, buffer);
image_error ("Error reading JPEG image `%s': %s", img->spec,
build_string (buffer));
}
if (fp)
fclose ((FILE *) fp);
fn_jpeg_destroy_decompress (&cinfo);
x_destroy_x_image (ximg);
x_clear_image (f, img);
UNGCPRO;
return 0;
}
fn_jpeg_CreateDecompress (&cinfo, JPEG_LIB_VERSION, sizeof (cinfo));
if (NILP (specified_data))
jpeg_file_src (&cinfo, (FILE *) fp);
else
jpeg_memory_src (&cinfo, SDATA (specified_data),
SBYTES (specified_data));
fn_jpeg_read_header (&cinfo, 1);
cinfo.quantize_colors = 1;
fn_jpeg_start_decompress (&cinfo);
width = img->width = cinfo.output_width;
height = img->height = cinfo.output_height;
if (!check_image_size (f, width, height))
{
image_error ("Invalid image size", Qnil, Qnil);
longjmp (mgr.setjmp_buffer, 2);
}
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
longjmp (mgr.setjmp_buffer, 2);
{
int i, ir, ig, ib;
if (cinfo.out_color_components > 2)
ir = 0, ig = 1, ib = 2;
else if (cinfo.out_color_components > 1)
ir = 0, ig = 1, ib = 0;
else
ir = 0, ig = 0, ib = 0;
init_color_table ();
colors = (unsigned long *) alloca (cinfo.actual_number_of_colors
* sizeof *colors);
for (i = 0; i < cinfo.actual_number_of_colors; ++i)
{
int r = cinfo.colormap[ir][i] << 8;
int g = cinfo.colormap[ig][i] << 8;
int b = cinfo.colormap[ib][i] << 8;
colors[i] = lookup_rgb_color (f, r, g, b);
}
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
#endif
}
row_stride = width * cinfo.output_components;
buffer = cinfo.mem->alloc_sarray ((j_common_ptr) &cinfo, JPOOL_IMAGE,
row_stride, 1);
for (y = 0; y < height; ++y)
{
fn_jpeg_read_scanlines (&cinfo, buffer, 1);
for (x = 0; x < cinfo.output_width; ++x)
XPutPixel (ximg, x, y, colors[buffer[0][x]]);
}
fn_jpeg_finish_decompress (&cinfo);
fn_jpeg_destroy_decompress (&cinfo);
if (fp)
fclose ((FILE *) fp);
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
UNGCPRO;
return 1;
}
#else
#ifdef MAC_OS
static int
jpeg_load (f, img)
struct frame *f;
struct image *img;
{
#ifdef MAC_OSX
return image_load_quartz2d (f, img, 0);
#else
return image_load_quicktime (f, img, kQTFileTypeJPEG);
#endif
}
#endif
#endif
#if defined (HAVE_TIFF) || defined (MAC_OS)
static int tiff_image_p P_ ((Lisp_Object object));
static int tiff_load P_ ((struct frame *f, struct image *img));
Lisp_Object Qtiff;
enum tiff_keyword_index
{
TIFF_TYPE,
TIFF_DATA,
TIFF_FILE,
TIFF_ASCENT,
TIFF_MARGIN,
TIFF_RELIEF,
TIFF_ALGORITHM,
TIFF_HEURISTIC_MASK,
TIFF_MASK,
TIFF_BACKGROUND,
TIFF_LAST
};
static struct image_keyword tiff_format[TIFF_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
static struct image_type tiff_type =
{
&Qtiff,
tiff_image_p,
tiff_load,
x_clear_image,
NULL
};
static int
tiff_image_p (object)
Lisp_Object object;
{
struct image_keyword fmt[TIFF_LAST];
bcopy (tiff_format, fmt, sizeof fmt);
if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff))
return 0;
return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
}
#endif
#ifdef HAVE_TIFF
#include <tiffio.h>
#ifdef HAVE_NTGUI
DEF_IMGLIB_FN (TIFFSetErrorHandler);
DEF_IMGLIB_FN (TIFFSetWarningHandler);
DEF_IMGLIB_FN (TIFFOpen);
DEF_IMGLIB_FN (TIFFClientOpen);
DEF_IMGLIB_FN (TIFFGetField);
DEF_IMGLIB_FN (TIFFReadRGBAImage);
DEF_IMGLIB_FN (TIFFClose);
static int
init_tiff_functions (Lisp_Object libraries)
{
HMODULE library;
if (!(library = w32_delayed_load (libraries, Qtiff)))
return 0;
LOAD_IMGLIB_FN (library, TIFFSetErrorHandler);
LOAD_IMGLIB_FN (library, TIFFSetWarningHandler);
LOAD_IMGLIB_FN (library, TIFFOpen);
LOAD_IMGLIB_FN (library, TIFFClientOpen);
LOAD_IMGLIB_FN (library, TIFFGetField);
LOAD_IMGLIB_FN (library, TIFFReadRGBAImage);
LOAD_IMGLIB_FN (library, TIFFClose);
return 1;
}
#else
#define fn_TIFFSetErrorHandler TIFFSetErrorHandler
#define fn_TIFFSetWarningHandler TIFFSetWarningHandler
#define fn_TIFFOpen TIFFOpen
#define fn_TIFFClientOpen TIFFClientOpen
#define fn_TIFFGetField TIFFGetField
#define fn_TIFFReadRGBAImage TIFFReadRGBAImage
#define fn_TIFFClose TIFFClose
#endif
typedef struct
{
unsigned char *bytes;
size_t len;
int index;
}
tiff_memory_source;
static size_t
tiff_read_from_memory (data, buf, size)
thandle_t data;
tdata_t buf;
tsize_t size;
{
tiff_memory_source *src = (tiff_memory_source *) data;
if (size > src->len - src->index)
return (size_t) -1;
bcopy (src->bytes + src->index, buf, size);
src->index += size;
return size;
}
static size_t
tiff_write_from_memory (data, buf, size)
thandle_t data;
tdata_t buf;
tsize_t size;
{
return (size_t) -1;
}
static toff_t
tiff_seek_in_memory (data, off, whence)
thandle_t data;
toff_t off;
int whence;
{
tiff_memory_source *src = (tiff_memory_source *) data;
int idx;
switch (whence)
{
case SEEK_SET:
idx = off;
break;
case SEEK_END:
idx = src->len + off;
break;
case SEEK_CUR:
idx = src->index + off;
break;
default:
return -1;
}
if (idx > src->len || idx < 0)
return -1;
src->index = idx;
return src->index;
}
static int
tiff_close_memory (data)
thandle_t data;
{
return 0;
}
static int
tiff_mmap_memory (data, pbase, psize)
thandle_t data;
tdata_t *pbase;
toff_t *psize;
{
return 0;
}
static void
tiff_unmap_memory (data, base, size)
thandle_t data;
tdata_t base;
toff_t size;
{
}
static toff_t
tiff_size_of_memory (data)
thandle_t data;
{
return ((tiff_memory_source *) data)->len;
}
static void
tiff_error_handler (title, format, ap)
const char *title, *format;
va_list ap;
{
char buf[512];
int len;
len = sprintf (buf, "TIFF error: %s ", title);
vsprintf (buf + len, format, ap);
add_to_log (buf, Qnil, Qnil);
}
static void
tiff_warning_handler (title, format, ap)
const char *title, *format;
va_list ap;
{
char buf[512];
int len;
len = sprintf (buf, "TIFF warning: %s ", title);
vsprintf (buf + len, format, ap);
add_to_log (buf, Qnil, Qnil);
}
static int
tiff_load (f, img)
struct frame *f;
struct image *img;
{
Lisp_Object file, specified_file;
Lisp_Object specified_data;
TIFF *tiff;
int width, height, x, y;
uint32 *buf;
int rc;
XImagePtr ximg;
struct gcpro gcpro1;
tiff_memory_source memsrc;
specified_file = image_spec_value (img->spec, QCfile, NULL);
specified_data = image_spec_value (img->spec, QCdata, NULL);
file = Qnil;
GCPRO1 (file);
fn_TIFFSetErrorHandler (tiff_error_handler);
fn_TIFFSetWarningHandler (tiff_warning_handler);
if (NILP (specified_data))
{
file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNGCPRO;
return 0;
}
tiff = (TIFF *)fn_TIFFOpen (SDATA (file), "r");
if (tiff == NULL)
{
image_error ("Cannot open `%s'", file, Qnil);
UNGCPRO;
return 0;
}
}
else
{
memsrc.bytes = SDATA (specified_data);
memsrc.len = SBYTES (specified_data);
memsrc.index = 0;
tiff = (TIFF *)fn_TIFFClientOpen ("memory_source", "r", &memsrc,
(TIFFReadWriteProc) tiff_read_from_memory,
(TIFFReadWriteProc) tiff_write_from_memory,
tiff_seek_in_memory,
tiff_close_memory,
tiff_size_of_memory,
tiff_mmap_memory,
tiff_unmap_memory);
if (!tiff)
{
image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
UNGCPRO;
return 0;
}
}
fn_TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
fn_TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
if (!check_image_size (f, width, height))
{
image_error ("Invalid image size", Qnil, Qnil);
UNGCPRO;
return 0;
}
buf = (uint32 *) xmalloc (width * height * sizeof *buf);
rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
fn_TIFFClose (tiff);
if (!rc)
{
image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
xfree (buf);
UNGCPRO;
return 0;
}
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
xfree (buf);
UNGCPRO;
return 0;
}
init_color_table ();
for (y = 0; y < height; ++y)
{
uint32 *row = buf + y * width;
for (x = 0; x < width; ++x)
{
uint32 abgr = row[x];
int r = TIFFGetR (abgr) << 8;
int g = TIFFGetG (abgr) << 8;
int b = TIFFGetB (abgr) << 8;
XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
}
}
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
#endif
img->width = width;
img->height = height;
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
xfree (buf);
UNGCPRO;
return 1;
}
#else
#ifdef MAC_OS
static int
tiff_load (f, img)
struct frame *f;
struct image *img;
{
return image_load_quicktime (f, img, kQTFileTypeTIFF);
}
#endif
#endif
#if defined (HAVE_GIF) || defined (MAC_OS)
static int gif_image_p P_ ((Lisp_Object object));
static int gif_load P_ ((struct frame *f, struct image *img));
static void gif_clear_image P_ ((struct frame *f, struct image *img));
Lisp_Object Qgif;
enum gif_keyword_index
{
GIF_TYPE,
GIF_DATA,
GIF_FILE,
GIF_ASCENT,
GIF_MARGIN,
GIF_RELIEF,
GIF_ALGORITHM,
GIF_HEURISTIC_MASK,
GIF_MASK,
GIF_IMAGE,
GIF_BACKGROUND,
GIF_LAST
};
static struct image_keyword gif_format[GIF_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":data", IMAGE_STRING_VALUE, 0},
{":file", IMAGE_STRING_VALUE, 0},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
static struct image_type gif_type =
{
&Qgif,
gif_image_p,
gif_load,
gif_clear_image,
NULL
};
static void
gif_clear_image (f, img)
struct frame *f;
struct image *img;
{
img->data.lisp_val = Qnil;
x_clear_image (f, img);
}
static int
gif_image_p (object)
Lisp_Object object;
{
struct image_keyword fmt[GIF_LAST];
bcopy (gif_format, fmt, sizeof fmt);
if (!parse_image_spec (object, fmt, GIF_LAST, Qgif))
return 0;
return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
}
#endif
#ifdef HAVE_GIF
#if defined (HAVE_NTGUI) || defined (MAC_OS)
#ifdef DrawText
#undef DrawText
#endif
#define DrawText gif_DrawText
#include <gif_lib.h>
#undef DrawText
#else
#include <gif_lib.h>
#endif
#ifdef HAVE_NTGUI
DEF_IMGLIB_FN (DGifCloseFile);
DEF_IMGLIB_FN (DGifSlurp);
DEF_IMGLIB_FN (DGifOpen);
DEF_IMGLIB_FN (DGifOpenFileName);
static int
init_gif_functions (Lisp_Object libraries)
{
HMODULE library;
if (!(library = w32_delayed_load (libraries, Qgif)))
return 0;
LOAD_IMGLIB_FN (library, DGifCloseFile);
LOAD_IMGLIB_FN (library, DGifSlurp);
LOAD_IMGLIB_FN (library, DGifOpen);
LOAD_IMGLIB_FN (library, DGifOpenFileName);
return 1;
}
#else
#define fn_DGifCloseFile DGifCloseFile
#define fn_DGifSlurp DGifSlurp
#define fn_DGifOpen DGifOpen
#define fn_DGifOpenFileName DGifOpenFileName
#endif
typedef struct
{
unsigned char *bytes;
size_t len;
int index;
}
gif_memory_source;
static gif_memory_source *current_gif_memory_src;
static int
gif_read_from_memory (file, buf, len)
GifFileType *file;
GifByteType *buf;
int len;
{
gif_memory_source *src = current_gif_memory_src;
if (len > src->len - src->index)
return -1;
bcopy (src->bytes + src->index, buf, len);
src->index += len;
return len;
}
static int
gif_load (f, img)
struct frame *f;
struct image *img;
{
Lisp_Object file, specified_file;
Lisp_Object specified_data;
int rc, width, height, x, y, i;
XImagePtr ximg;
ColorMapObject *gif_color_map;
unsigned long pixel_colors[256];
GifFileType *gif;
struct gcpro gcpro1;
Lisp_Object image;
int ino, image_height, image_width;
gif_memory_source memsrc;
unsigned char *raster;
specified_file = image_spec_value (img->spec, QCfile, NULL);
specified_data = image_spec_value (img->spec, QCdata, NULL);
file = Qnil;
GCPRO1 (file);
if (NILP (specified_data))
{
file = x_find_image_file (specified_file);
if (!STRINGP (file))
{
image_error ("Cannot find image file `%s'", specified_file, Qnil);
UNGCPRO;
return 0;
}
gif = (GifFileType *)fn_DGifOpenFileName (SDATA (file));
if (gif == NULL)
{
image_error ("Cannot open `%s'", file, Qnil);
UNGCPRO;
return 0;
}
}
else
{
current_gif_memory_src = &memsrc;
memsrc.bytes = SDATA (specified_data);
memsrc.len = SBYTES (specified_data);
memsrc.index = 0;
gif = (GifFileType *)fn_DGifOpen(&memsrc, gif_read_from_memory);
if (!gif)
{
image_error ("Cannot open memory source `%s'", img->spec, Qnil);
UNGCPRO;
return 0;
}
}
if (!check_image_size (f, gif->SWidth, gif->SHeight))
{
image_error ("Invalid image size", Qnil, Qnil);
fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
rc = fn_DGifSlurp (gif);
if (rc == GIF_ERROR)
{
image_error ("Error reading `%s'", img->spec, Qnil);
fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
image = image_spec_value (img->spec, QCindex, NULL);
ino = INTEGERP (image) ? XFASTINT (image) : 0;
if (ino >= gif->ImageCount)
{
image_error ("Invalid image number `%s' in image `%s'",
image, img->spec);
fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
img->corners[TOP_CORNER] = gif->SavedImages[ino].ImageDesc.Top;
img->corners[LEFT_CORNER] = gif->SavedImages[ino].ImageDesc.Left;
image_height = gif->SavedImages[ino].ImageDesc.Height;
img->corners[BOT_CORNER] = img->corners[TOP_CORNER] + image_height;
image_width = gif->SavedImages[ino].ImageDesc.Width;
img->corners[RIGHT_CORNER] = img->corners[LEFT_CORNER] + image_width;
width = img->width = max (gif->SWidth,
max (gif->Image.Left + gif->Image.Width,
img->corners[RIGHT_CORNER]));
height = img->height = max (gif->SHeight,
max (gif->Image.Top + gif->Image.Height,
img->corners[BOT_CORNER]));
if (!check_image_size (f, width, height))
{
image_error ("Invalid image size", Qnil, Qnil);
fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
{
fn_DGifCloseFile (gif);
UNGCPRO;
return 0;
}
gif_color_map = gif->SavedImages[ino].ImageDesc.ColorMap;
if (!gif_color_map)
gif_color_map = gif->SColorMap;
init_color_table ();
bzero (pixel_colors, sizeof pixel_colors);
for (i = 0; i < gif_color_map->ColorCount; ++i)
{
int r = gif_color_map->Colors[i].Red << 8;
int g = gif_color_map->Colors[i].Green << 8;
int b = gif_color_map->Colors[i].Blue << 8;
pixel_colors[i] = lookup_rgb_color (f, r, g, b);
}
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
#endif
for (y = 0; y < img->corners[TOP_CORNER]; ++y)
for (x = 0; x < width; ++x)
XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
for (y = img->corners[BOT_CORNER]; y < height; ++y)
for (x = 0; x < width; ++x)
XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
for (y = img->corners[TOP_CORNER]; y < img->corners[BOT_CORNER]; ++y)
{
for (x = 0; x < img->corners[LEFT_CORNER]; ++x)
XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
for (x = img->corners[RIGHT_CORNER]; x < width; ++x)
XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
}
raster = (unsigned char *) gif->SavedImages[ino].RasterBits;
if (gif->SavedImages[ino].ImageDesc.Interlace)
{
static int interlace_start[] = {0, 4, 2, 1};
static int interlace_increment[] = {8, 8, 4, 2};
int pass;
int row = interlace_start[0];
pass = 0;
for (y = 0; y < image_height; y++)
{
if (row >= image_height)
{
row = interlace_start[++pass];
while (row >= image_height)
row = interlace_start[++pass];
}
for (x = 0; x < image_width; x++)
{
int i = raster[(y * image_width) + x];
XPutPixel (ximg, x + img->corners[LEFT_CORNER],
row + img->corners[TOP_CORNER], pixel_colors[i]);
}
row += interlace_increment[pass];
}
}
else
{
for (y = 0; y < image_height; ++y)
for (x = 0; x < image_width; ++x)
{
int i = raster[y * image_width + x];
XPutPixel (ximg, x + img->corners[LEFT_CORNER],
y + img->corners[TOP_CORNER], pixel_colors[i]);
}
}
img->data.lisp_val = Qnil;
if (gif->SavedImages[ino].ExtensionBlockCount > 0)
{
ExtensionBlock *ext = gif->SavedImages[ino].ExtensionBlocks;
for (i = 0; i < gif->SavedImages[ino].ExtensionBlockCount; i++, ext++)
img->data.lisp_val = Fcons (make_unibyte_string (ext->Bytes, ext->ByteCount),
Fcons (make_number (ext->Function),
img->data.lisp_val));
img->data.lisp_val = Fnreverse (img->data.lisp_val);
}
if (gif->ImageCount > 1)
img->data.lisp_val = Fcons (Qcount,
Fcons (make_number (gif->ImageCount),
img->data.lisp_val));
fn_DGifCloseFile (gif);
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
UNGCPRO;
return 1;
}
#else
#ifdef MAC_OS
static int
gif_load (f, img)
struct frame *f;
struct image *img;
{
Lisp_Object specified_file, file;
Lisp_Object specified_data;
OSErr err;
Boolean graphic_p, movie_p, prefer_graphic_p;
Handle dh = NULL;
Movie movie = NULL;
Lisp_Object image;
Track track = NULL;
Media media = NULL;
long nsamples;
Rect rect;
Lisp_Object specified_bg;
XColor color;
RGBColor bg_color;
int width, height;
XImagePtr ximg;
TimeScale time_scale;
TimeValue time, duration;
int ino;
CGrafPtr old_port;
GDHandle old_gdh;
specified_file = image_spec_value (img->spec, QCfile, NULL);
specified_data = image_spec_value (img->spec, QCdata, NULL);
EnterMovies ();
if (NILP (specified_data))
{
FSSpec fss;
short refnum;
err = find_image_fsspec (specified_file, &file, &fss);
if (err != noErr)
{
if (err == fnfErr)
image_error ("Cannot find image file `%s'", specified_file, Qnil);
else
goto open_error;
}
err = CanQuickTimeOpenFile (&fss, kQTFileTypeGIF, 0,
&graphic_p, &movie_p, &prefer_graphic_p, 0);
if (err != noErr)
goto open_error;
if (!graphic_p && !movie_p)
goto open_error;
if (prefer_graphic_p)
return image_load_qt_1 (f, img, kQTFileTypeGIF, &fss, NULL);
err = OpenMovieFile (&fss, &refnum, fsRdPerm);
if (err != noErr)
goto open_error;
err = NewMovieFromFile (&movie, refnum, NULL, NULL, 0, NULL);
CloseMovieFile (refnum);
if (err != noErr)
{
image_error ("Error reading `%s'", file, Qnil);
return 0;
}
}
else
{
Handle dref = NULL;
long file_type_atom[3];
err = PtrToHand (SDATA (specified_data), &dh, SBYTES (specified_data));
if (err != noErr)
{
image_error ("Cannot allocate data handle for `%s'",
img->spec, Qnil);
goto error;
}
file_type_atom[0] = EndianU32_NtoB (sizeof (long) * 3);
file_type_atom[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType);
file_type_atom[2] = EndianU32_NtoB (kQTFileTypeGIF);
err = PtrToHand (&dh, &dref, sizeof (Handle));
if (err == noErr)
err = PtrAndHand ("\p", dref, 1);
if (err == noErr)
err = PtrAndHand (file_type_atom, dref, sizeof (long) * 3);
if (err != noErr)
{
image_error ("Cannot allocate handle data ref for `%s'", img->spec, Qnil);
goto error;
}
err = CanQuickTimeOpenDataRef (dref, HandleDataHandlerSubType, &graphic_p,
&movie_p, &prefer_graphic_p, 0);
if (err != noErr)
goto open_error;
if (!graphic_p && !movie_p)
goto open_error;
if (prefer_graphic_p)
{
int success_p;
DisposeHandle (dref);
success_p = image_load_qt_1 (f, img, kQTFileTypeGIF, NULL, dh);
DisposeHandle (dh);
return success_p;
}
err = NewMovieFromDataRef (&movie, 0, NULL, dref,
HandleDataHandlerSubType);
DisposeHandle (dref);
if (err != noErr)
goto open_error;
}
image = image_spec_value (img->spec, QCindex, NULL);
ino = INTEGERP (image) ? XFASTINT (image) : 0;
track = GetMovieIndTrack (movie, 1);
media = GetTrackMedia (track);
nsamples = GetMediaSampleCount (media);
if (ino >= nsamples)
{
image_error ("Invalid image number `%s' in image `%s'",
image, img->spec);
goto error;
}
time_scale = GetMediaTimeScale (media);
specified_bg = image_spec_value (img->spec, QCbackground, NULL);
if (!STRINGP (specified_bg) ||
!mac_defined_color (f, SDATA (specified_bg), &color, 0))
{
color.pixel = FRAME_BACKGROUND_PIXEL (f);
color.red = RED16_FROM_ULONG (color.pixel);
color.green = GREEN16_FROM_ULONG (color.pixel);
color.blue = BLUE16_FROM_ULONG (color.pixel);
}
GetMovieBox (movie, &rect);
width = img->width = rect.right - rect.left;
height = img->height = rect.bottom - rect.top;
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
goto error;
GetGWorld (&old_port, &old_gdh);
SetGWorld (ximg, NULL);
bg_color.red = color.red;
bg_color.green = color.green;
bg_color.blue = color.blue;
RGBBackColor (&bg_color);
SetGWorld (old_port, old_gdh);
SetMovieActive (movie, 1);
SetMovieGWorld (movie, ximg, NULL);
SampleNumToMediaTime (media, ino + 1, &time, &duration);
SetMovieTimeValue (movie, time);
MoviesTask (movie, 0L);
DisposeTrackMedia (media);
DisposeMovieTrack (track);
DisposeMovie (movie);
if (dh)
DisposeHandle (dh);
{
Lisp_Object gce = make_uninit_string (4);
int centisec = ((float)duration / time_scale) * 100.0f + 0.5f;
SSET (gce, 1, centisec & 0xff);
SSET (gce, 2, (centisec >> 8) & 0xff);
SSET (gce, 0, 0);
SSET (gce, 3, 0);
img->data.lisp_val = list4 (Qcount, make_number (nsamples),
make_number (0xf9), gce);
}
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
return 1;
open_error:
image_error ("Cannot open `%s'", file, Qnil);
error:
if (media)
DisposeTrackMedia (media);
if (track)
DisposeMovieTrack (track);
if (movie)
DisposeMovie (movie);
if (dh)
DisposeHandle (dh);
return 0;
}
#endif
#endif
#ifdef HAVE_X_WINDOWS
#define HAVE_GHOSTSCRIPT 1
#endif
Lisp_Object Qpostscript;
#ifdef HAVE_GHOSTSCRIPT
static int gs_image_p P_ ((Lisp_Object object));
static int gs_load P_ ((struct frame *f, struct image *img));
static void gs_clear_image P_ ((struct frame *f, struct image *img));
Lisp_Object QCloader, QCbounding_box, QCpt_width, QCpt_height;
enum gs_keyword_index
{
GS_TYPE,
GS_PT_WIDTH,
GS_PT_HEIGHT,
GS_FILE,
GS_LOADER,
GS_BOUNDING_BOX,
GS_ASCENT,
GS_MARGIN,
GS_RELIEF,
GS_ALGORITHM,
GS_HEURISTIC_MASK,
GS_MASK,
GS_BACKGROUND,
GS_LAST
};
static struct image_keyword gs_format[GS_LAST] =
{
{":type", IMAGE_SYMBOL_VALUE, 1},
{":pt-width", IMAGE_POSITIVE_INTEGER_VALUE, 1},
{":pt-height", IMAGE_POSITIVE_INTEGER_VALUE, 1},
{":file", IMAGE_STRING_VALUE, 1},
{":loader", IMAGE_FUNCTION_VALUE, 0},
{":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE, 1},
{":ascent", IMAGE_ASCENT_VALUE, 0},
{":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
{":relief", IMAGE_INTEGER_VALUE, 0},
{":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
{":background", IMAGE_STRING_OR_NIL_VALUE, 0}
};
static struct image_type gs_type =
{
&Qpostscript,
gs_image_p,
gs_load,
gs_clear_image,
NULL
};
static void
gs_clear_image (f, img)
struct frame *f;
struct image *img;
{
xfree (img->data.ptr_val);
x_clear_image (f, img);
}
static int
gs_image_p (object)
Lisp_Object object;
{
struct image_keyword fmt[GS_LAST];
Lisp_Object tem;
int i;
bcopy (gs_format, fmt, sizeof fmt);
if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript))
return 0;
tem = fmt[GS_BOUNDING_BOX].value;
if (CONSP (tem))
{
for (i = 0; i < 4; ++i, tem = XCDR (tem))
if (!CONSP (tem) || !INTEGERP (XCAR (tem)))
return 0;
if (!NILP (tem))
return 0;
}
else if (VECTORP (tem))
{
if (XVECTOR (tem)->size != 4)
return 0;
for (i = 0; i < 4; ++i)
if (!INTEGERP (XVECTOR (tem)->contents[i]))
return 0;
}
else
return 0;
return 1;
}
static int
gs_load (f, img)
struct frame *f;
struct image *img;
{
char buffer[100];
Lisp_Object window_and_pixmap_id = Qnil, loader, pt_height, pt_width;
struct gcpro gcpro1, gcpro2;
Lisp_Object frame;
double in_width, in_height;
Lisp_Object pixel_colors = Qnil;
pt_width = image_spec_value (img->spec, QCpt_width, NULL);
in_width = XFASTINT (pt_width) / 72.0;
img->width = in_width * FRAME_X_DISPLAY_INFO (f)->resx;
pt_height = image_spec_value (img->spec, QCpt_height, NULL);
in_height = XFASTINT (pt_height) / 72.0;
img->height = in_height * FRAME_X_DISPLAY_INFO (f)->resy;
if (!check_image_size (f, img->width, img->height))
{
image_error ("Invalid image size", Qnil, Qnil);
return 0;
}
xassert (img->pixmap == NO_PIXMAP);
BLOCK_INPUT;
img->pixmap = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
img->width, img->height,
DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
UNBLOCK_INPUT;
if (!img->pixmap)
{
image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
return 0;
}
GCPRO2 (window_and_pixmap_id, pixel_colors);
sprintf (buffer, "%lu %lu",
(unsigned long) FRAME_X_WINDOW (f),
(unsigned long) img->pixmap);
window_and_pixmap_id = build_string (buffer);
sprintf (buffer, "%lu %lu",
FRAME_FOREGROUND_PIXEL (f),
FRAME_BACKGROUND_PIXEL (f));
pixel_colors = build_string (buffer);
XSETFRAME (frame, f);
loader = image_spec_value (img->spec, QCloader, NULL);
if (NILP (loader))
loader = intern ("gs-load-image");
img->data.lisp_val = call6 (loader, frame, img->spec,
make_number (img->width),
make_number (img->height),
window_and_pixmap_id,
pixel_colors);
UNGCPRO;
return PROCESSP (img->data.lisp_val);
}
void
x_kill_gs_process (pixmap, f)
Pixmap pixmap;
struct frame *f;
{
struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
int class, i;
struct image *img;
for (i = 0; i < c->used; ++i)
if (c->images[i]->pixmap == pixmap)
break;
if (i == c->used)
return;
img = c->images[i];
xassert (PROCESSP (img->data.lisp_val));
Fkill_process (img->data.lisp_val, Qnil);
img->data.lisp_val = Qnil;
#if defined (HAVE_X_WINDOWS)
class = FRAME_X_VISUAL (f)->class;
if (class != StaticColor && class != StaticGray && class != TrueColor)
{
XImagePtr ximg;
BLOCK_INPUT;
ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
0, 0, img->width, img->height, ~0, ZPixmap);
if (ximg)
{
int x, y;
init_color_table ();
for (y = 0; y < img->height; ++y)
for (x = 0; x < img->width; ++x)
{
unsigned long pixel = XGetPixel (ximg, x, y);
lookup_pixel_color (f, pixel);
}
#ifdef COLOR_TABLE_SUPPORT
img->colors = colors_in_color_table (&img->ncolors);
free_color_table ();
#endif
XDestroyImage (ximg);
#if 0
if (img->ncolors)
x_free_colors (f, img->colors, img->ncolors);
#endif
}
else
image_error ("Cannot get X image of `%s'; colors will not be freed",
img->spec, Qnil);
UNBLOCK_INPUT;
}
#endif
BLOCK_INPUT;
postprocess_image (f, img);
UNBLOCK_INPUT;
}
#endif
#if GLYPH_DEBUG
DEFUN ("imagep", Fimagep, Simagep, 1, 1, 0,
doc: )
(spec)
Lisp_Object spec;
{
return valid_image_p (spec) ? Qt : Qnil;
}
DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
(spec)
Lisp_Object spec;
{
int id = -1;
if (valid_image_p (spec))
id = lookup_image (SELECTED_FRAME (), spec);
debug_print (spec);
return make_number (id);
}
#endif
#ifdef HAVE_NTGUI
#define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
define_image_type (image_type, init_lib_fn (libraries))
#else
#define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
define_image_type (image_type, 1)
#endif
DEFUN ("init-image-library", Finit_image_library, Sinit_image_library, 2, 2, 0,
doc: )
(type, libraries)
Lisp_Object type, libraries;
{
Lisp_Object tested;
tested = Fassq (type, Vimage_type_cache);
if (CONSP (tested))
return XCDR (tested);
#if defined (HAVE_XPM) || defined (MAC_OS)
if (EQ (type, Qxpm))
return CHECK_LIB_AVAILABLE (&xpm_type, init_xpm_functions, libraries);
#endif
#if defined (HAVE_JPEG) || defined (MAC_OS)
if (EQ (type, Qjpeg))
return CHECK_LIB_AVAILABLE (&jpeg_type, init_jpeg_functions, libraries);
#endif
#if defined (HAVE_TIFF) || defined (MAC_OS)
if (EQ (type, Qtiff))
return CHECK_LIB_AVAILABLE (&tiff_type, init_tiff_functions, libraries);
#endif
#if defined (HAVE_GIF) || defined (MAC_OS)
if (EQ (type, Qgif))
return CHECK_LIB_AVAILABLE (&gif_type, init_gif_functions, libraries);
#endif
#if defined (HAVE_PNG) || defined (MAC_OS)
if (EQ (type, Qpng))
return CHECK_LIB_AVAILABLE (&png_type, init_png_functions, libraries);
#endif
#ifdef HAVE_GHOSTSCRIPT
if (EQ (type, Qpostscript))
return CHECK_LIB_AVAILABLE (&gs_type, init_gs_functions, libraries);
#endif
CACHE_IMAGE_TYPE (type, Qnil);
return Qnil;
}
void
syms_of_image ()
{
extern Lisp_Object Qrisky_local_variable;
image_types = NULL;
DEFVAR_LISP ("image-types", &Vimage_types,
doc: );
Vimage_types = Qnil;
DEFVAR_LISP ("image-library-alist", &Vimage_library_alist,
doc: );
Vimage_library_alist = Qnil;
Fput (intern ("image-library-alist"), Qrisky_local_variable, Qt);
DEFVAR_LISP ("max-image-size", &Vmax_image_size,
doc: );
Vmax_image_size = make_float (MAX_IMAGE_SIZE);
Vimage_type_cache = Qnil;
staticpro (&Vimage_type_cache);
Qpbm = intern ("pbm");
staticpro (&Qpbm);
ADD_IMAGE_TYPE(Qpbm);
Qxbm = intern ("xbm");
staticpro (&Qxbm);
ADD_IMAGE_TYPE(Qxbm);
define_image_type (&xbm_type, 1);
define_image_type (&pbm_type, 1);
QCascent = intern (":ascent");
staticpro (&QCascent);
QCmargin = intern (":margin");
staticpro (&QCmargin);
QCrelief = intern (":relief");
staticpro (&QCrelief);
QCconversion = intern (":conversion");
staticpro (&QCconversion);
QCcolor_symbols = intern (":color-symbols");
staticpro (&QCcolor_symbols);
QCheuristic_mask = intern (":heuristic-mask");
staticpro (&QCheuristic_mask);
QCindex = intern (":index");
staticpro (&QCindex);
QCmatrix = intern (":matrix");
staticpro (&QCmatrix);
QCcolor_adjustment = intern (":color-adjustment");
staticpro (&QCcolor_adjustment);
QCmask = intern (":mask");
staticpro (&QCmask);
Qlaplace = intern ("laplace");
staticpro (&Qlaplace);
Qemboss = intern ("emboss");
staticpro (&Qemboss);
Qedge_detection = intern ("edge-detection");
staticpro (&Qedge_detection);
Qheuristic = intern ("heuristic");
staticpro (&Qheuristic);
Qpostscript = intern ("postscript");
staticpro (&Qpostscript);
#ifdef HAVE_GHOSTSCRIPT
ADD_IMAGE_TYPE(Qpostscript);
QCloader = intern (":loader");
staticpro (&QCloader);
QCbounding_box = intern (":bounding-box");
staticpro (&QCbounding_box);
QCpt_width = intern (":pt-width");
staticpro (&QCpt_width);
QCpt_height = intern (":pt-height");
staticpro (&QCpt_height);
#endif
#if defined (HAVE_XPM) || defined (MAC_OS)
Qxpm = intern ("xpm");
staticpro (&Qxpm);
ADD_IMAGE_TYPE(Qxpm);
#endif
#if defined (HAVE_JPEG) || defined (MAC_OS)
Qjpeg = intern ("jpeg");
staticpro (&Qjpeg);
ADD_IMAGE_TYPE(Qjpeg);
#endif
#if defined (HAVE_TIFF) || defined (MAC_OS)
Qtiff = intern ("tiff");
staticpro (&Qtiff);
ADD_IMAGE_TYPE(Qtiff);
#endif
#if defined (HAVE_GIF) || defined (MAC_OS)
Qgif = intern ("gif");
staticpro (&Qgif);
ADD_IMAGE_TYPE(Qgif);
#endif
#if defined (HAVE_PNG) || defined (MAC_OS)
Qpng = intern ("png");
staticpro (&Qpng);
ADD_IMAGE_TYPE(Qpng);
#endif
defsubr (&Sinit_image_library);
defsubr (&Sclear_image_cache);
defsubr (&Simage_size);
defsubr (&Simage_mask_p);
defsubr (&Simage_extension_data);
#if GLYPH_DEBUG
defsubr (&Simagep);
defsubr (&Slookup_image);
#endif
DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images,
doc: );
cross_disabled_images = 0;
DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
doc: );
Vx_bitmap_file_path = decode_env_path ((char *) 0, PATH_BITMAPS);
DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay,
doc: );
Vimage_cache_eviction_delay = make_number (30 * 60);
}
void
init_image ()
{
#if defined (MAC_OSX) && TARGET_API_MAC_CARBON
init_image_func_pointer ();
#endif
}