(dired-listing-switches): apparently, "ls -b" is actually supposed to work
[emacs.git] / src / image.c
blob73490fe28659afbdd199e56dbbd6d206adbb400b
1 /* Functions for image support on window system.
2 Copyright (C) 1989, 1992-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19 #include <config.h>
20 #include <stdio.h>
21 #include <math.h>
22 #include <ctype.h>
23 #include <unistd.h>
25 #ifdef HAVE_PNG
26 #if defined HAVE_LIBPNG_PNG_H
27 # include <libpng/png.h>
28 #else
29 # include <png.h>
30 #endif
31 #endif
33 #include <setjmp.h>
35 /* This makes the fields of a Display accessible, in Xlib header files. */
37 #define XLIB_ILLEGAL_ACCESS
39 #include "lisp.h"
40 #include "frame.h"
41 #include "window.h"
42 #include "dispextern.h"
43 #include "blockinput.h"
44 #include "systime.h"
45 #include <epaths.h>
46 #include "character.h"
47 #include "coding.h"
48 #include "termhooks.h"
49 #include "font.h"
51 #ifdef HAVE_X_WINDOWS
52 #include "xterm.h"
53 #include <sys/types.h>
54 #include <sys/stat.h>
56 #define COLOR_TABLE_SUPPORT 1
58 typedef struct x_bitmap_record Bitmap_Record;
59 #define GET_PIXEL(ximg, x, y) XGetPixel (ximg, x, y)
60 #define NO_PIXMAP None
62 #define RGB_PIXEL_COLOR unsigned long
64 #define PIX_MASK_RETAIN 0
65 #define PIX_MASK_DRAW 1
66 #endif /* HAVE_X_WINDOWS */
69 #ifdef HAVE_NTGUI
70 #include "w32.h"
71 #include "w32term.h"
73 /* W32_TODO : Color tables on W32. */
74 #undef COLOR_TABLE_SUPPORT
76 typedef struct w32_bitmap_record Bitmap_Record;
77 #define GET_PIXEL(ximg, x, y) GetPixel (ximg, x, y)
78 #define NO_PIXMAP 0
80 #define RGB_PIXEL_COLOR COLORREF
82 #define PIX_MASK_RETAIN 0
83 #define PIX_MASK_DRAW 1
85 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
86 #define x_defined_color w32_defined_color
87 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
89 /* Functions from w32term.c that depend on XColor (so can't go in w32term.h
90 without modifying lots of files). */
91 extern void x_query_colors (struct frame *f, XColor *colors, int ncolors);
92 extern void x_query_color (struct frame *f, XColor *color);
94 /* Version of libpng that we were compiled with, or -1 if no PNG
95 support was compiled in. This is tested by w32-win.el to correctly
96 set up the alist used to search for PNG libraries. */
97 Lisp_Object Qlibpng_version;
98 #endif /* HAVE_NTGUI */
100 #ifdef HAVE_NS
101 #include "nsterm.h"
102 #include <sys/types.h>
103 #include <sys/stat.h>
105 #undef COLOR_TABLE_SUPPORT
107 typedef struct ns_bitmap_record Bitmap_Record;
109 #define GET_PIXEL(ximg, x, y) XGetPixel (ximg, x, y)
110 #define NO_PIXMAP 0
112 #define RGB_PIXEL_COLOR unsigned long
113 #define ZPixmap 0
115 #define PIX_MASK_RETAIN 0
116 #define PIX_MASK_DRAW 1
118 #define FRAME_X_VISUAL FRAME_NS_DISPLAY_INFO (f)->visual
119 #define x_defined_color(f, name, color_def, alloc) \
120 ns_defined_color (f, name, color_def, alloc, 0)
121 #define FRAME_X_SCREEN(f) 0
122 #define DefaultDepthOfScreen(screen) x_display_list->n_planes
123 #endif /* HAVE_NS */
126 /* The symbol `postscript' identifying images of this type. */
128 static Lisp_Object Qpostscript;
130 static void x_disable_image (struct frame *, struct image *);
131 static void x_edge_detection (struct frame *, struct image *, Lisp_Object,
132 Lisp_Object);
134 static void init_color_table (void);
135 static unsigned long lookup_rgb_color (struct frame *f, int r, int g, int b);
136 #ifdef COLOR_TABLE_SUPPORT
137 static void free_color_table (void);
138 static unsigned long *colors_in_color_table (int *n);
139 #endif
140 static Lisp_Object Finit_image_library (Lisp_Object, Lisp_Object);
142 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
143 id, which is just an int that this section returns. Bitmaps are
144 reference counted so they can be shared among frames.
146 Bitmap indices are guaranteed to be > 0, so a negative number can
147 be used to indicate no bitmap.
149 If you use x_create_bitmap_from_data, then you must keep track of
150 the bitmaps yourself. That is, creating a bitmap from the same
151 data more than once will not be caught. */
153 #ifdef HAVE_NS
154 XImagePtr
155 XGetImage (Display *display, Pixmap pixmap, int x, int y,
156 unsigned int width, unsigned int height,
157 unsigned long plane_mask, int format)
159 /* TODO: not sure what this function is supposed to do.. */
160 ns_retain_object (pixmap);
161 return pixmap;
164 /* use with imgs created by ns_image_for_XPM */
165 unsigned long
166 XGetPixel (XImagePtr ximage, int x, int y)
168 return ns_get_pixel (ximage, x, y);
171 /* use with imgs created by ns_image_for_XPM; alpha set to 1;
172 pixel is assumed to be in form RGB */
173 void
174 XPutPixel (XImagePtr ximage, int x, int y, unsigned long pixel)
176 ns_put_pixel (ximage, x, y, pixel);
178 #endif /* HAVE_NS */
181 /* Functions to access the contents of a bitmap, given an id. */
184 x_bitmap_height (FRAME_PTR f, ptrdiff_t id)
186 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].height;
190 x_bitmap_width (FRAME_PTR f, ptrdiff_t id)
192 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].width;
195 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
197 x_bitmap_pixmap (FRAME_PTR f, ptrdiff_t id)
199 /* HAVE_NTGUI needs the explicit cast here. */
200 return (int) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap;
202 #endif
204 #ifdef HAVE_X_WINDOWS
206 x_bitmap_mask (FRAME_PTR f, ptrdiff_t id)
208 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].mask;
210 #endif
212 /* Allocate a new bitmap record. Returns index of new record. */
214 static ptrdiff_t
215 x_allocate_bitmap_record (FRAME_PTR f)
217 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
218 ptrdiff_t i;
220 if (dpyinfo->bitmaps_last < dpyinfo->bitmaps_size)
221 return ++dpyinfo->bitmaps_last;
223 for (i = 0; i < dpyinfo->bitmaps_size; ++i)
224 if (dpyinfo->bitmaps[i].refcount == 0)
225 return i + 1;
227 dpyinfo->bitmaps =
228 xpalloc (dpyinfo->bitmaps, &dpyinfo->bitmaps_size,
229 10, -1, sizeof *dpyinfo->bitmaps);
230 return ++dpyinfo->bitmaps_last;
233 /* Add one reference to the reference count of the bitmap with id ID. */
235 void
236 x_reference_bitmap (FRAME_PTR f, ptrdiff_t id)
238 ++FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].refcount;
241 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
243 ptrdiff_t
244 x_create_bitmap_from_data (struct frame *f, char *bits, unsigned int width, unsigned int height)
246 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
247 ptrdiff_t id;
249 #ifdef HAVE_X_WINDOWS
250 Pixmap bitmap;
251 bitmap = XCreateBitmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
252 bits, width, height);
253 if (! bitmap)
254 return -1;
255 #endif /* HAVE_X_WINDOWS */
257 #ifdef HAVE_NTGUI
258 Pixmap bitmap;
259 bitmap = CreateBitmap (width, height,
260 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_planes,
261 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_cbits,
262 bits);
263 if (! bitmap)
264 return -1;
265 #endif /* HAVE_NTGUI */
267 #ifdef HAVE_NS
268 void *bitmap = ns_image_from_XBM (bits, width, height);
269 if (!bitmap)
270 return -1;
271 #endif
273 id = x_allocate_bitmap_record (f);
275 #ifdef HAVE_NS
276 dpyinfo->bitmaps[id - 1].img = bitmap;
277 dpyinfo->bitmaps[id - 1].depth = 1;
278 #endif
280 dpyinfo->bitmaps[id - 1].file = NULL;
281 dpyinfo->bitmaps[id - 1].height = height;
282 dpyinfo->bitmaps[id - 1].width = width;
283 dpyinfo->bitmaps[id - 1].refcount = 1;
285 #ifdef HAVE_X_WINDOWS
286 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
287 dpyinfo->bitmaps[id - 1].have_mask = 0;
288 dpyinfo->bitmaps[id - 1].depth = 1;
289 #endif /* HAVE_X_WINDOWS */
291 #ifdef HAVE_NTGUI
292 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
293 dpyinfo->bitmaps[id - 1].hinst = NULL;
294 dpyinfo->bitmaps[id - 1].depth = 1;
295 #endif /* HAVE_NTGUI */
297 return id;
300 /* Create bitmap from file FILE for frame F. */
302 ptrdiff_t
303 x_create_bitmap_from_file (struct frame *f, Lisp_Object file)
305 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
307 #ifdef HAVE_NTGUI
308 return -1; /* W32_TODO : bitmap support */
309 #endif /* HAVE_NTGUI */
311 #ifdef HAVE_NS
312 ptrdiff_t id;
313 void *bitmap = ns_image_from_file (file);
315 if (!bitmap)
316 return -1;
319 id = x_allocate_bitmap_record (f);
320 dpyinfo->bitmaps[id - 1].img = bitmap;
321 dpyinfo->bitmaps[id - 1].refcount = 1;
322 dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SBYTES (file) + 1);
323 dpyinfo->bitmaps[id - 1].depth = 1;
324 dpyinfo->bitmaps[id - 1].height = ns_image_width (bitmap);
325 dpyinfo->bitmaps[id - 1].width = ns_image_height (bitmap);
326 strcpy (dpyinfo->bitmaps[id - 1].file, SDATA (file));
327 return id;
328 #endif
330 #ifdef HAVE_X_WINDOWS
331 unsigned int width, height;
332 Pixmap bitmap;
333 int xhot, yhot, result;
334 ptrdiff_t id;
335 Lisp_Object found;
336 int fd;
337 char *filename;
339 /* Look for an existing bitmap with the same name. */
340 for (id = 0; id < dpyinfo->bitmaps_last; ++id)
342 if (dpyinfo->bitmaps[id].refcount
343 && dpyinfo->bitmaps[id].file
344 && !strcmp (dpyinfo->bitmaps[id].file, SSDATA (file)))
346 ++dpyinfo->bitmaps[id].refcount;
347 return id + 1;
351 /* Search bitmap-file-path for the file, if appropriate. */
352 fd = openp (Vx_bitmap_file_path, file, Qnil, &found, Qnil);
353 if (fd < 0)
354 return -1;
355 emacs_close (fd);
357 filename = SSDATA (found);
359 result = XReadBitmapFile (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
360 filename, &width, &height, &bitmap, &xhot, &yhot);
361 if (result != BitmapSuccess)
362 return -1;
364 id = x_allocate_bitmap_record (f);
365 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
366 dpyinfo->bitmaps[id - 1].have_mask = 0;
367 dpyinfo->bitmaps[id - 1].refcount = 1;
368 dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SBYTES (file) + 1);
369 dpyinfo->bitmaps[id - 1].depth = 1;
370 dpyinfo->bitmaps[id - 1].height = height;
371 dpyinfo->bitmaps[id - 1].width = width;
372 strcpy (dpyinfo->bitmaps[id - 1].file, SSDATA (file));
374 return id;
375 #endif /* HAVE_X_WINDOWS */
378 /* Free bitmap B. */
380 static void
381 free_bitmap_record (Display_Info *dpyinfo, Bitmap_Record *bm)
383 #ifdef HAVE_X_WINDOWS
384 XFreePixmap (dpyinfo->display, bm->pixmap);
385 if (bm->have_mask)
386 XFreePixmap (dpyinfo->display, bm->mask);
387 #endif /* HAVE_X_WINDOWS */
389 #ifdef HAVE_NTGUI
390 DeleteObject (bm->pixmap);
391 #endif /* HAVE_NTGUI */
393 #ifdef HAVE_NS
394 ns_release_object (bm->img);
395 #endif
397 if (bm->file)
399 xfree (bm->file);
400 bm->file = NULL;
404 /* Remove reference to bitmap with id number ID. */
406 void
407 x_destroy_bitmap (FRAME_PTR f, ptrdiff_t id)
409 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
411 if (id > 0)
413 Bitmap_Record *bm = &dpyinfo->bitmaps[id - 1];
415 if (--bm->refcount == 0)
417 BLOCK_INPUT;
418 free_bitmap_record (dpyinfo, bm);
419 UNBLOCK_INPUT;
424 /* Free all the bitmaps for the display specified by DPYINFO. */
426 void
427 x_destroy_all_bitmaps (Display_Info *dpyinfo)
429 ptrdiff_t i;
430 Bitmap_Record *bm = dpyinfo->bitmaps;
432 for (i = 0; i < dpyinfo->bitmaps_last; i++, bm++)
433 if (bm->refcount > 0)
434 free_bitmap_record (dpyinfo, bm);
436 dpyinfo->bitmaps_last = 0;
440 #ifdef HAVE_X_WINDOWS
442 /* Useful functions defined in the section
443 `Image type independent image structures' below. */
445 static unsigned long four_corners_best (XImagePtr ximg,
446 int *corners,
447 unsigned long width,
448 unsigned long height);
450 static int x_create_x_image_and_pixmap (struct frame *f, int width, int height,
451 int depth, XImagePtr *ximg,
452 Pixmap *pixmap);
454 static void x_destroy_x_image (XImagePtr ximg);
457 /* Create a mask of a bitmap. Note is this not a perfect mask.
458 It's nicer with some borders in this context */
461 x_create_bitmap_mask (struct frame *f, ptrdiff_t id)
463 Pixmap pixmap, mask;
464 XImagePtr ximg, mask_img;
465 unsigned long width, height;
466 int result;
467 unsigned long bg;
468 unsigned long x, y, xp, xm, yp, ym;
469 GC gc;
471 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
473 if (!(id > 0))
474 return -1;
476 pixmap = x_bitmap_pixmap (f, id);
477 width = x_bitmap_width (f, id);
478 height = x_bitmap_height (f, id);
480 BLOCK_INPUT;
481 ximg = XGetImage (FRAME_X_DISPLAY (f), pixmap, 0, 0, width, height,
482 ~0, ZPixmap);
484 if (!ximg)
486 UNBLOCK_INPUT;
487 return -1;
490 result = x_create_x_image_and_pixmap (f, width, height, 1, &mask_img, &mask);
492 UNBLOCK_INPUT;
493 if (!result)
495 XDestroyImage (ximg);
496 return -1;
499 bg = four_corners_best (ximg, NULL, width, height);
501 for (y = 0; y < ximg->height; ++y)
503 for (x = 0; x < ximg->width; ++x)
505 xp = x != ximg->width - 1 ? x + 1 : 0;
506 xm = x != 0 ? x - 1 : ximg->width - 1;
507 yp = y != ximg->height - 1 ? y + 1 : 0;
508 ym = y != 0 ? y - 1 : ximg->height - 1;
509 if (XGetPixel (ximg, x, y) == bg
510 && XGetPixel (ximg, x, yp) == bg
511 && XGetPixel (ximg, x, ym) == bg
512 && XGetPixel (ximg, xp, y) == bg
513 && XGetPixel (ximg, xp, yp) == bg
514 && XGetPixel (ximg, xp, ym) == bg
515 && XGetPixel (ximg, xm, y) == bg
516 && XGetPixel (ximg, xm, yp) == bg
517 && XGetPixel (ximg, xm, ym) == bg)
518 XPutPixel (mask_img, x, y, 0);
519 else
520 XPutPixel (mask_img, x, y, 1);
524 xassert (interrupt_input_blocked);
525 gc = XCreateGC (FRAME_X_DISPLAY (f), mask, 0, NULL);
526 XPutImage (FRAME_X_DISPLAY (f), mask, gc, mask_img, 0, 0, 0, 0,
527 width, height);
528 XFreeGC (FRAME_X_DISPLAY (f), gc);
530 dpyinfo->bitmaps[id - 1].have_mask = 1;
531 dpyinfo->bitmaps[id - 1].mask = mask;
533 XDestroyImage (ximg);
534 x_destroy_x_image (mask_img);
536 return 0;
539 #endif /* HAVE_X_WINDOWS */
542 /***********************************************************************
543 Image types
544 ***********************************************************************/
546 /* List of supported image types. Use define_image_type to add new
547 types. Use lookup_image_type to find a type for a given symbol. */
549 static struct image_type *image_types;
551 /* The symbol `xbm' which is used as the type symbol for XBM images. */
553 static Lisp_Object Qxbm;
555 /* Keywords. */
557 Lisp_Object QCascent, QCmargin, QCrelief;
558 Lisp_Object QCconversion;
559 static Lisp_Object QCheuristic_mask;
560 static Lisp_Object QCcolor_symbols;
561 static Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask, QCgeometry;
562 static Lisp_Object QCcrop, QCrotation;
564 /* Other symbols. */
566 static Lisp_Object Qcount, Qextension_data, Qdelay;
567 static Lisp_Object Qlaplace, Qemboss, Qedge_detection, Qheuristic;
569 /* Function prototypes. */
571 static Lisp_Object define_image_type (struct image_type *type, int loaded);
572 static struct image_type *lookup_image_type (Lisp_Object symbol);
573 static void image_error (const char *format, Lisp_Object, Lisp_Object);
574 static void x_laplace (struct frame *, struct image *);
575 static void x_emboss (struct frame *, struct image *);
576 static int x_build_heuristic_mask (struct frame *, struct image *,
577 Lisp_Object);
578 #ifdef HAVE_NTGUI
579 #define CACHE_IMAGE_TYPE(type, status) \
580 do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
581 #else
582 #define CACHE_IMAGE_TYPE(type, status)
583 #endif
585 #define ADD_IMAGE_TYPE(type) \
586 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
588 /* Define a new image type from TYPE. This adds a copy of TYPE to
589 image_types and caches the loading status of TYPE. */
591 static Lisp_Object
592 define_image_type (struct image_type *type, int loaded)
594 Lisp_Object success;
596 if (!loaded)
597 success = Qnil;
598 else
600 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
601 The initialized data segment is read-only. */
602 struct image_type *p = (struct image_type *) xmalloc (sizeof *p);
603 memcpy (p, type, sizeof *p);
604 p->next = image_types;
605 image_types = p;
606 success = Qt;
609 CACHE_IMAGE_TYPE (*type->type, success);
610 return success;
614 /* Look up image type SYMBOL, and return a pointer to its image_type
615 structure. Value is null if SYMBOL is not a known image type. */
617 static inline struct image_type *
618 lookup_image_type (Lisp_Object symbol)
620 struct image_type *type;
622 /* We must initialize the image-type if it hasn't been already. */
623 if (NILP (Finit_image_library (symbol, Vdynamic_library_alist)))
624 return 0; /* unimplemented */
626 for (type = image_types; type; type = type->next)
627 if (EQ (symbol, *type->type))
628 break;
630 return type;
634 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
635 valid image specification is a list whose car is the symbol
636 `image', and whose rest is a property list. The property list must
637 contain a value for key `:type'. That value must be the name of a
638 supported image type. The rest of the property list depends on the
639 image type. */
642 valid_image_p (Lisp_Object object)
644 int valid_p = 0;
646 if (IMAGEP (object))
648 Lisp_Object tem;
650 for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem))
651 if (EQ (XCAR (tem), QCtype))
653 tem = XCDR (tem);
654 if (CONSP (tem) && SYMBOLP (XCAR (tem)))
656 struct image_type *type;
657 type = lookup_image_type (XCAR (tem));
658 if (type)
659 valid_p = type->valid_p (object);
662 break;
666 return valid_p;
670 /* Log error message with format string FORMAT and argument ARG.
671 Signaling an error, e.g. when an image cannot be loaded, is not a
672 good idea because this would interrupt redisplay, and the error
673 message display would lead to another redisplay. This function
674 therefore simply displays a message. */
676 static void
677 image_error (const char *format, Lisp_Object arg1, Lisp_Object arg2)
679 add_to_log (format, arg1, arg2);
684 /***********************************************************************
685 Image specifications
686 ***********************************************************************/
688 enum image_value_type
690 IMAGE_DONT_CHECK_VALUE_TYPE,
691 IMAGE_STRING_VALUE,
692 IMAGE_STRING_OR_NIL_VALUE,
693 IMAGE_SYMBOL_VALUE,
694 IMAGE_POSITIVE_INTEGER_VALUE,
695 IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR,
696 IMAGE_NON_NEGATIVE_INTEGER_VALUE,
697 IMAGE_ASCENT_VALUE,
698 IMAGE_INTEGER_VALUE,
699 IMAGE_FUNCTION_VALUE,
700 IMAGE_NUMBER_VALUE,
701 IMAGE_BOOL_VALUE
704 /* Structure used when parsing image specifications. */
706 struct image_keyword
708 /* Name of keyword. */
709 const char *name;
711 /* The type of value allowed. */
712 enum image_value_type type;
714 /* Non-zero means key must be present. */
715 int mandatory_p;
717 /* Used to recognize duplicate keywords in a property list. */
718 int count;
720 /* The value that was found. */
721 Lisp_Object value;
725 static int parse_image_spec (Lisp_Object, struct image_keyword *,
726 int, Lisp_Object);
727 static Lisp_Object image_spec_value (Lisp_Object, Lisp_Object, int *);
730 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
731 has the format (image KEYWORD VALUE ...). One of the keyword/
732 value pairs must be `:type TYPE'. KEYWORDS is a vector of
733 image_keywords structures of size NKEYWORDS describing other
734 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
736 static int
737 parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
738 int nkeywords, Lisp_Object type)
740 int i;
741 Lisp_Object plist;
743 if (!IMAGEP (spec))
744 return 0;
746 plist = XCDR (spec);
747 while (CONSP (plist))
749 Lisp_Object key, value;
751 /* First element of a pair must be a symbol. */
752 key = XCAR (plist);
753 plist = XCDR (plist);
754 if (!SYMBOLP (key))
755 return 0;
757 /* There must follow a value. */
758 if (!CONSP (plist))
759 return 0;
760 value = XCAR (plist);
761 plist = XCDR (plist);
763 /* Find key in KEYWORDS. Error if not found. */
764 for (i = 0; i < nkeywords; ++i)
765 if (strcmp (keywords[i].name, SSDATA (SYMBOL_NAME (key))) == 0)
766 break;
768 if (i == nkeywords)
769 continue;
771 /* Record that we recognized the keyword. If a keywords
772 was found more than once, it's an error. */
773 keywords[i].value = value;
774 ++keywords[i].count;
776 if (keywords[i].count > 1)
777 return 0;
779 /* Check type of value against allowed type. */
780 switch (keywords[i].type)
782 case IMAGE_STRING_VALUE:
783 if (!STRINGP (value))
784 return 0;
785 break;
787 case IMAGE_STRING_OR_NIL_VALUE:
788 if (!STRINGP (value) && !NILP (value))
789 return 0;
790 break;
792 case IMAGE_SYMBOL_VALUE:
793 if (!SYMBOLP (value))
794 return 0;
795 break;
797 case IMAGE_POSITIVE_INTEGER_VALUE:
798 if (! RANGED_INTEGERP (1, value, INT_MAX))
799 return 0;
800 break;
802 case IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR:
803 if (RANGED_INTEGERP (0, value, INT_MAX))
804 break;
805 if (CONSP (value)
806 && RANGED_INTEGERP (0, XCAR (value), INT_MAX)
807 && RANGED_INTEGERP (0, XCDR (value), INT_MAX))
808 break;
809 return 0;
811 case IMAGE_ASCENT_VALUE:
812 if (SYMBOLP (value) && EQ (value, Qcenter))
813 break;
814 else if (RANGED_INTEGERP (0, value, 100))
815 break;
816 return 0;
818 case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
819 /* Unlike the other integer-related cases, this one does not
820 verify that VALUE fits in 'int'. This is because callers
821 want EMACS_INT. */
822 if (!INTEGERP (value) || XINT (value) < 0)
823 return 0;
824 break;
826 case IMAGE_DONT_CHECK_VALUE_TYPE:
827 break;
829 case IMAGE_FUNCTION_VALUE:
830 value = indirect_function (value);
831 if (!NILP (Ffunctionp (value)))
832 break;
833 return 0;
835 case IMAGE_NUMBER_VALUE:
836 if (!INTEGERP (value) && !FLOATP (value))
837 return 0;
838 break;
840 case IMAGE_INTEGER_VALUE:
841 if (! TYPE_RANGED_INTEGERP (int, value))
842 return 0;
843 break;
845 case IMAGE_BOOL_VALUE:
846 if (!NILP (value) && !EQ (value, Qt))
847 return 0;
848 break;
850 default:
851 abort ();
852 break;
855 if (EQ (key, QCtype) && !EQ (type, value))
856 return 0;
859 /* Check that all mandatory fields are present. */
860 for (i = 0; i < nkeywords; ++i)
861 if (keywords[i].mandatory_p && keywords[i].count == 0)
862 return 0;
864 return NILP (plist);
868 /* Return the value of KEY in image specification SPEC. Value is nil
869 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
870 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
872 static Lisp_Object
873 image_spec_value (Lisp_Object spec, Lisp_Object key, int *found)
875 Lisp_Object tail;
877 xassert (valid_image_p (spec));
879 for (tail = XCDR (spec);
880 CONSP (tail) && CONSP (XCDR (tail));
881 tail = XCDR (XCDR (tail)))
883 if (EQ (XCAR (tail), key))
885 if (found)
886 *found = 1;
887 return XCAR (XCDR (tail));
891 if (found)
892 *found = 0;
893 return Qnil;
897 DEFUN ("image-size", Fimage_size, Simage_size, 1, 3, 0,
898 doc: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
899 PIXELS non-nil means return the size in pixels, otherwise return the
900 size in canonical character units.
901 FRAME is the frame on which the image will be displayed. FRAME nil
902 or omitted means use the selected frame. */)
903 (Lisp_Object spec, Lisp_Object pixels, Lisp_Object frame)
905 Lisp_Object size;
907 size = Qnil;
908 if (valid_image_p (spec))
910 struct frame *f = check_x_frame (frame);
911 ptrdiff_t id = lookup_image (f, spec);
912 struct image *img = IMAGE_FROM_ID (f, id);
913 int width = img->width + 2 * img->hmargin;
914 int height = img->height + 2 * img->vmargin;
916 if (NILP (pixels))
917 size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
918 make_float ((double) height / FRAME_LINE_HEIGHT (f)));
919 else
920 size = Fcons (make_number (width), make_number (height));
922 else
923 error ("Invalid image specification");
925 return size;
929 DEFUN ("image-mask-p", Fimage_mask_p, Simage_mask_p, 1, 2, 0,
930 doc: /* Return t if image SPEC has a mask bitmap.
931 FRAME is the frame on which the image will be displayed. FRAME nil
932 or omitted means use the selected frame. */)
933 (Lisp_Object spec, Lisp_Object frame)
935 Lisp_Object mask;
937 mask = Qnil;
938 if (valid_image_p (spec))
940 struct frame *f = check_x_frame (frame);
941 ptrdiff_t id = lookup_image (f, spec);
942 struct image *img = IMAGE_FROM_ID (f, id);
943 if (img->mask)
944 mask = Qt;
946 else
947 error ("Invalid image specification");
949 return mask;
952 DEFUN ("image-metadata", Fimage_metadata, Simage_metadata, 1, 2, 0,
953 doc: /* Return metadata for image SPEC.
954 FRAME is the frame on which the image will be displayed. FRAME nil
955 or omitted means use the selected frame. */)
956 (Lisp_Object spec, Lisp_Object frame)
958 Lisp_Object ext;
960 ext = Qnil;
961 if (valid_image_p (spec))
963 struct frame *f = check_x_frame (frame);
964 ptrdiff_t id = lookup_image (f, spec);
965 struct image *img = IMAGE_FROM_ID (f, id);
966 ext = img->lisp_data;
969 return ext;
973 /***********************************************************************
974 Image type independent image structures
975 ***********************************************************************/
977 static void free_image (struct frame *f, struct image *img);
979 #define MAX_IMAGE_SIZE 10.0
980 /* Allocate and return a new image structure for image specification
981 SPEC. SPEC has a hash value of HASH. */
983 static struct image *
984 make_image (Lisp_Object spec, EMACS_UINT hash)
986 struct image *img = (struct image *) xmalloc (sizeof *img);
987 Lisp_Object file = image_spec_value (spec, QCfile, NULL);
989 xassert (valid_image_p (spec));
990 memset (img, 0, sizeof *img);
991 img->dependencies = NILP (file) ? Qnil : list1 (file);
992 img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
993 xassert (img->type != NULL);
994 img->spec = spec;
995 img->lisp_data = Qnil;
996 img->ascent = DEFAULT_IMAGE_ASCENT;
997 img->hash = hash;
998 img->corners[BOT_CORNER] = -1; /* Full image */
999 return img;
1003 /* Free image IMG which was used on frame F, including its resources. */
1005 static void
1006 free_image (struct frame *f, struct image *img)
1008 if (img)
1010 struct image_cache *c = FRAME_IMAGE_CACHE (f);
1012 /* Remove IMG from the hash table of its cache. */
1013 if (img->prev)
1014 img->prev->next = img->next;
1015 else
1016 c->buckets[img->hash % IMAGE_CACHE_BUCKETS_SIZE] = img->next;
1018 if (img->next)
1019 img->next->prev = img->prev;
1021 c->images[img->id] = NULL;
1023 /* Free resources, then free IMG. */
1024 img->type->free (f, img);
1025 xfree (img);
1029 /* Return 1 if the given widths and heights are valid for display;
1030 otherwise, return 0. */
1032 static int
1033 check_image_size (struct frame *f, int width, int height)
1035 int w, h;
1037 if (width <= 0 || height <= 0)
1038 return 0;
1040 if (INTEGERP (Vmax_image_size))
1041 return (width <= XINT (Vmax_image_size)
1042 && height <= XINT (Vmax_image_size));
1043 else if (FLOATP (Vmax_image_size))
1045 if (f != NULL)
1047 w = FRAME_PIXEL_WIDTH (f);
1048 h = FRAME_PIXEL_HEIGHT (f);
1050 else
1051 w = h = 1024; /* Arbitrary size for unknown frame. */
1052 return (width <= XFLOAT_DATA (Vmax_image_size) * w
1053 && height <= XFLOAT_DATA (Vmax_image_size) * h);
1055 else
1056 return 1;
1059 /* Prepare image IMG for display on frame F. Must be called before
1060 drawing an image. */
1062 void
1063 prepare_image_for_display (struct frame *f, struct image *img)
1065 EMACS_TIME t;
1067 /* We're about to display IMG, so set its timestamp to `now'. */
1068 EMACS_GET_TIME (t);
1069 img->timestamp = EMACS_SECS (t);
1071 /* If IMG doesn't have a pixmap yet, load it now, using the image
1072 type dependent loader function. */
1073 if (img->pixmap == NO_PIXMAP && !img->load_failed_p)
1074 img->load_failed_p = img->type->load (f, img) == 0;
1079 /* Value is the number of pixels for the ascent of image IMG when
1080 drawn in face FACE. */
1083 image_ascent (struct image *img, struct face *face, struct glyph_slice *slice)
1085 int height;
1086 int ascent;
1088 if (slice->height == img->height)
1089 height = img->height + img->vmargin;
1090 else if (slice->y == 0)
1091 height = slice->height + img->vmargin;
1092 else
1093 height = slice->height;
1095 if (img->ascent == CENTERED_IMAGE_ASCENT)
1097 if (face->font)
1099 #ifdef HAVE_NTGUI
1100 /* W32 specific version. Why?. ++kfs */
1101 ascent = height / 2 - (FONT_DESCENT (face->font)
1102 - FONT_BASE (face->font)) / 2;
1103 #else
1104 /* This expression is arranged so that if the image can't be
1105 exactly centered, it will be moved slightly up. This is
1106 because a typical font is `top-heavy' (due to the presence
1107 uppercase letters), so the image placement should err towards
1108 being top-heavy too. It also just generally looks better. */
1109 ascent = (height + FONT_BASE (face->font)
1110 - FONT_DESCENT (face->font) + 1) / 2;
1111 #endif /* HAVE_NTGUI */
1113 else
1114 ascent = height / 2;
1116 else
1117 ascent = height * (img->ascent / 100.0);
1119 return ascent;
1123 /* Image background colors. */
1125 /* Find the "best" corner color of a bitmap.
1126 On W32, XIMG is assumed to a device context with the bitmap selected. */
1128 static RGB_PIXEL_COLOR
1129 four_corners_best (XImagePtr_or_DC ximg, int *corners,
1130 unsigned long width, unsigned long height)
1132 RGB_PIXEL_COLOR corner_pixels[4], best IF_LINT (= 0);
1133 int i, best_count;
1135 if (corners && corners[BOT_CORNER] >= 0)
1137 /* Get the colors at the corner_pixels of ximg. */
1138 corner_pixels[0] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[TOP_CORNER]);
1139 corner_pixels[1] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[TOP_CORNER]);
1140 corner_pixels[2] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[BOT_CORNER] - 1);
1141 corner_pixels[3] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[BOT_CORNER] - 1);
1143 else
1145 /* Get the colors at the corner_pixels of ximg. */
1146 corner_pixels[0] = GET_PIXEL (ximg, 0, 0);
1147 corner_pixels[1] = GET_PIXEL (ximg, width - 1, 0);
1148 corner_pixels[2] = GET_PIXEL (ximg, width - 1, height - 1);
1149 corner_pixels[3] = GET_PIXEL (ximg, 0, height - 1);
1151 /* Choose the most frequently found color as background. */
1152 for (i = best_count = 0; i < 4; ++i)
1154 int j, n;
1156 for (j = n = 0; j < 4; ++j)
1157 if (corner_pixels[i] == corner_pixels[j])
1158 ++n;
1160 if (n > best_count)
1161 best = corner_pixels[i], best_count = n;
1164 return best;
1167 /* Portability macros */
1169 #ifdef HAVE_NTGUI
1171 #define Destroy_Image(img_dc, prev) \
1172 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1174 #define Free_Pixmap(display, pixmap) \
1175 DeleteObject (pixmap)
1177 #elif defined (HAVE_NS)
1179 #define Destroy_Image(ximg, dummy) \
1180 ns_release_object (ximg)
1182 #define Free_Pixmap(display, pixmap) \
1183 ns_release_object (pixmap)
1185 #else
1187 #define Destroy_Image(ximg, dummy) \
1188 XDestroyImage (ximg)
1190 #define Free_Pixmap(display, pixmap) \
1191 XFreePixmap (display, pixmap)
1193 #endif /* !HAVE_NTGUI && !HAVE_NS */
1196 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1197 it is guessed heuristically. If non-zero, XIMG is an existing
1198 XImage object (or device context with the image selected on W32) to
1199 use for the heuristic. */
1201 RGB_PIXEL_COLOR
1202 image_background (struct image *img, struct frame *f, XImagePtr_or_DC ximg)
1204 if (! img->background_valid)
1205 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1207 int free_ximg = !ximg;
1208 #ifdef HAVE_NTGUI
1209 HGDIOBJ prev;
1210 #endif /* HAVE_NTGUI */
1212 if (free_ximg)
1214 #ifndef HAVE_NTGUI
1215 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
1216 0, 0, img->width, img->height, ~0, ZPixmap);
1217 #else
1218 HDC frame_dc = get_frame_dc (f);
1219 ximg = CreateCompatibleDC (frame_dc);
1220 release_frame_dc (f, frame_dc);
1221 prev = SelectObject (ximg, img->pixmap);
1222 #endif /* !HAVE_NTGUI */
1225 img->background = four_corners_best (ximg, img->corners, img->width, img->height);
1227 if (free_ximg)
1228 Destroy_Image (ximg, prev);
1230 img->background_valid = 1;
1233 return img->background;
1236 /* Return the `background_transparent' field of IMG. If IMG doesn't
1237 have one yet, it is guessed heuristically. If non-zero, MASK is an
1238 existing XImage object to use for the heuristic. */
1241 image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_DC mask)
1243 if (! img->background_transparent_valid)
1244 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1246 if (img->mask)
1248 int free_mask = !mask;
1249 #ifdef HAVE_NTGUI
1250 HGDIOBJ prev;
1251 #endif /* HAVE_NTGUI */
1253 if (free_mask)
1255 #ifndef HAVE_NTGUI
1256 mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
1257 0, 0, img->width, img->height, ~0, ZPixmap);
1258 #else
1259 HDC frame_dc = get_frame_dc (f);
1260 mask = CreateCompatibleDC (frame_dc);
1261 release_frame_dc (f, frame_dc);
1262 prev = SelectObject (mask, img->mask);
1263 #endif /* HAVE_NTGUI */
1266 img->background_transparent
1267 = (four_corners_best (mask, img->corners, img->width, img->height) == PIX_MASK_RETAIN);
1269 if (free_mask)
1270 Destroy_Image (mask, prev);
1272 else
1273 img->background_transparent = 0;
1275 img->background_transparent_valid = 1;
1278 return img->background_transparent;
1282 /***********************************************************************
1283 Helper functions for X image types
1284 ***********************************************************************/
1286 static void x_clear_image_1 (struct frame *, struct image *, int,
1287 int, int);
1288 static void x_clear_image (struct frame *f, struct image *img);
1289 static unsigned long x_alloc_image_color (struct frame *f,
1290 struct image *img,
1291 Lisp_Object color_name,
1292 unsigned long dflt);
1295 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1296 free the pixmap if any. MASK_P non-zero means clear the mask
1297 pixmap if any. COLORS_P non-zero means free colors allocated for
1298 the image, if any. */
1300 static void
1301 x_clear_image_1 (struct frame *f, struct image *img, int pixmap_p, int mask_p,
1302 int colors_p)
1304 if (pixmap_p && img->pixmap)
1306 Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
1307 img->pixmap = NO_PIXMAP;
1308 /* NOTE (HAVE_NS): background color is NOT an indexed color! */
1309 img->background_valid = 0;
1312 if (mask_p && img->mask)
1314 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
1315 img->mask = NO_PIXMAP;
1316 img->background_transparent_valid = 0;
1319 if (colors_p && img->ncolors)
1321 /* W32_TODO: color table support. */
1322 #ifdef HAVE_X_WINDOWS
1323 x_free_colors (f, img->colors, img->ncolors);
1324 #endif /* HAVE_X_WINDOWS */
1325 xfree (img->colors);
1326 img->colors = NULL;
1327 img->ncolors = 0;
1332 /* Free X resources of image IMG which is used on frame F. */
1334 static void
1335 x_clear_image (struct frame *f, struct image *img)
1337 BLOCK_INPUT;
1338 x_clear_image_1 (f, img, 1, 1, 1);
1339 UNBLOCK_INPUT;
1343 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1344 cannot be allocated, use DFLT. Add a newly allocated color to
1345 IMG->colors, so that it can be freed again. Value is the pixel
1346 color. */
1348 static unsigned long
1349 x_alloc_image_color (struct frame *f, struct image *img, Lisp_Object color_name,
1350 unsigned long dflt)
1352 XColor color;
1353 unsigned long result;
1355 xassert (STRINGP (color_name));
1357 if (x_defined_color (f, SSDATA (color_name), &color, 1)
1358 && img->ncolors < min (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *img->colors,
1359 INT_MAX))
1361 /* This isn't called frequently so we get away with simply
1362 reallocating the color vector to the needed size, here. */
1363 ptrdiff_t ncolors = img->ncolors + 1;
1364 img->colors =
1365 (unsigned long *) xrealloc (img->colors,
1366 ncolors * sizeof *img->colors);
1367 img->colors[ncolors - 1] = color.pixel;
1368 img->ncolors = ncolors;
1369 result = color.pixel;
1371 else
1372 result = dflt;
1374 return result;
1379 /***********************************************************************
1380 Image Cache
1381 ***********************************************************************/
1383 static void cache_image (struct frame *f, struct image *img);
1384 static void postprocess_image (struct frame *, struct image *);
1386 /* Return a new, initialized image cache that is allocated from the
1387 heap. Call free_image_cache to free an image cache. */
1389 struct image_cache *
1390 make_image_cache (void)
1392 struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
1393 int size;
1395 memset (c, 0, sizeof *c);
1396 size = 50;
1397 c->images = (struct image **) xmalloc (size * sizeof *c->images);
1398 c->size = size;
1399 size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
1400 c->buckets = (struct image **) xmalloc (size);
1401 memset (c->buckets, 0, size);
1402 return c;
1406 /* Find an image matching SPEC in the cache, and return it. If no
1407 image is found, return NULL. */
1408 static struct image *
1409 search_image_cache (struct frame *f, Lisp_Object spec, EMACS_UINT hash)
1411 struct image *img;
1412 struct image_cache *c = FRAME_IMAGE_CACHE (f);
1413 int i = hash % IMAGE_CACHE_BUCKETS_SIZE;
1415 if (!c) return NULL;
1417 /* If the image spec does not specify a background color, the cached
1418 image must have the same background color as the current frame.
1419 The foreground color must also match, for the sake of monochrome
1420 images.
1422 In fact, we could ignore the foreground color matching condition
1423 for color images, or if the image spec specifies :foreground;
1424 similarly we could ignore the background color matching condition
1425 for formats that don't use transparency (such as jpeg), or if the
1426 image spec specifies :background. However, the extra memory
1427 usage is probably negligible in practice, so we don't bother. */
1429 for (img = c->buckets[i]; img; img = img->next)
1430 if (img->hash == hash
1431 && !NILP (Fequal (img->spec, spec))
1432 && img->frame_foreground == FRAME_FOREGROUND_PIXEL (f)
1433 && img->frame_background == FRAME_BACKGROUND_PIXEL (f))
1434 break;
1435 return img;
1439 /* Search frame F for an image with spec SPEC, and free it. */
1441 static void
1442 uncache_image (struct frame *f, Lisp_Object spec)
1444 struct image *img = search_image_cache (f, spec, sxhash (spec, 0));
1445 if (img)
1447 free_image (f, img);
1448 /* As display glyphs may still be referring to the image ID, we
1449 must garbage the frame (Bug#6426). */
1450 SET_FRAME_GARBAGED (f);
1455 /* Free image cache of frame F. Be aware that X frames share images
1456 caches. */
1458 void
1459 free_image_cache (struct frame *f)
1461 struct image_cache *c = FRAME_IMAGE_CACHE (f);
1462 if (c)
1464 ptrdiff_t i;
1466 /* Cache should not be referenced by any frame when freed. */
1467 xassert (c->refcount == 0);
1469 for (i = 0; i < c->used; ++i)
1470 free_image (f, c->images[i]);
1471 xfree (c->images);
1472 xfree (c->buckets);
1473 xfree (c);
1474 FRAME_IMAGE_CACHE (f) = NULL;
1479 /* Clear image cache of frame F. FILTER=t means free all images.
1480 FILTER=nil means clear only images that haven't been
1481 displayed for some time.
1482 Else, only free the images which have FILTER in their `dependencies'.
1483 Should be called from time to time to reduce the number of loaded images.
1484 If image-cache-eviction-delay is non-nil, this frees images in the cache
1485 which weren't displayed for at least that many seconds. */
1487 static void
1488 clear_image_cache (struct frame *f, Lisp_Object filter)
1490 struct image_cache *c = FRAME_IMAGE_CACHE (f);
1492 if (c)
1494 ptrdiff_t i, nfreed = 0;
1496 /* Block input so that we won't be interrupted by a SIGIO
1497 while being in an inconsistent state. */
1498 BLOCK_INPUT;
1500 if (!NILP (filter))
1502 /* Filter image cache. */
1503 for (i = 0; i < c->used; ++i)
1505 struct image *img = c->images[i];
1506 if (img && (EQ (Qt, filter)
1507 || !NILP (Fmember (filter, img->dependencies))))
1509 free_image (f, img);
1510 ++nfreed;
1514 else if (INTEGERP (Vimage_cache_eviction_delay))
1516 /* Free cache based on timestamp. */
1517 EMACS_TIME t;
1518 double old, delay;
1519 ptrdiff_t nimages = 0;
1521 for (i = 0; i < c->used; ++i)
1522 if (c->images[i])
1523 nimages++;
1525 /* If the number of cached images has grown unusually large,
1526 decrease the cache eviction delay (Bug#6230). */
1527 delay = XINT (Vimage_cache_eviction_delay);
1528 if (nimages > 40)
1529 delay = 1600 * delay / nimages / nimages;
1530 delay = max (delay, 1);
1532 EMACS_GET_TIME (t);
1533 old = EMACS_SECS (t) - delay;
1535 for (i = 0; i < c->used; ++i)
1537 struct image *img = c->images[i];
1538 if (img && img->timestamp < old)
1540 free_image (f, img);
1541 ++nfreed;
1546 /* We may be clearing the image cache because, for example,
1547 Emacs was iconified for a longer period of time. In that
1548 case, current matrices may still contain references to
1549 images freed above. So, clear these matrices. */
1550 if (nfreed)
1552 Lisp_Object tail, frame;
1554 FOR_EACH_FRAME (tail, frame)
1556 struct frame *fr = XFRAME (frame);
1557 if (FRAME_IMAGE_CACHE (fr) == c)
1558 clear_current_matrices (fr);
1561 ++windows_or_buffers_changed;
1564 UNBLOCK_INPUT;
1568 void
1569 clear_image_caches (Lisp_Object filter)
1571 /* FIXME: We want to do
1572 * struct terminal *t;
1573 * for (t = terminal_list; t; t = t->next_terminal)
1574 * clear_image_cache (t, filter); */
1575 Lisp_Object tail, frame;
1576 FOR_EACH_FRAME (tail, frame)
1577 if (FRAME_WINDOW_P (XFRAME (frame)))
1578 clear_image_cache (XFRAME (frame), filter);
1581 DEFUN ("clear-image-cache", Fclear_image_cache, Sclear_image_cache,
1582 0, 1, 0,
1583 doc: /* Clear the image cache.
1584 FILTER nil or a frame means clear all images in the selected frame.
1585 FILTER t means clear the image caches of all frames.
1586 Anything else, means only clear those images which refer to FILTER,
1587 which is then usually a filename. */)
1588 (Lisp_Object filter)
1590 if (!(EQ (filter, Qnil) || FRAMEP (filter)))
1591 clear_image_caches (filter);
1592 else
1593 clear_image_cache (check_x_frame (filter), Qt);
1595 return Qnil;
1599 DEFUN ("image-flush", Fimage_flush, Simage_flush,
1600 1, 2, 0,
1601 doc: /* Fush the image with specification SPEC on frame FRAME.
1602 This removes the image from the Emacs image cache. If SPEC specifies
1603 an image file, the next redisplay of this image will read from the
1604 current contents of that file.
1606 FRAME nil or omitted means use the selected frame.
1607 FRAME t means refresh the image on all frames. */)
1608 (Lisp_Object spec, Lisp_Object frame)
1610 if (!valid_image_p (spec))
1611 error ("Invalid image specification");
1613 if (EQ (frame, Qt))
1615 Lisp_Object tail;
1616 FOR_EACH_FRAME (tail, frame)
1618 struct frame *f = XFRAME (frame);
1619 if (FRAME_WINDOW_P (f))
1620 uncache_image (f, spec);
1623 else
1624 uncache_image (check_x_frame (frame), spec);
1626 return Qnil;
1630 /* Compute masks and transform image IMG on frame F, as specified
1631 by the image's specification, */
1633 static void
1634 postprocess_image (struct frame *f, struct image *img)
1636 /* Manipulation of the image's mask. */
1637 if (img->pixmap)
1639 Lisp_Object conversion, spec;
1640 Lisp_Object mask;
1642 spec = img->spec;
1644 /* `:heuristic-mask t'
1645 `:mask heuristic'
1646 means build a mask heuristically.
1647 `:heuristic-mask (R G B)'
1648 `:mask (heuristic (R G B))'
1649 means build a mask from color (R G B) in the
1650 image.
1651 `:mask nil'
1652 means remove a mask, if any. */
1654 mask = image_spec_value (spec, QCheuristic_mask, NULL);
1655 if (!NILP (mask))
1656 x_build_heuristic_mask (f, img, mask);
1657 else
1659 int found_p;
1661 mask = image_spec_value (spec, QCmask, &found_p);
1663 if (EQ (mask, Qheuristic))
1664 x_build_heuristic_mask (f, img, Qt);
1665 else if (CONSP (mask)
1666 && EQ (XCAR (mask), Qheuristic))
1668 if (CONSP (XCDR (mask)))
1669 x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
1670 else
1671 x_build_heuristic_mask (f, img, XCDR (mask));
1673 else if (NILP (mask) && found_p && img->mask)
1675 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
1676 img->mask = NO_PIXMAP;
1681 /* Should we apply an image transformation algorithm? */
1682 conversion = image_spec_value (spec, QCconversion, NULL);
1683 if (EQ (conversion, Qdisabled))
1684 x_disable_image (f, img);
1685 else if (EQ (conversion, Qlaplace))
1686 x_laplace (f, img);
1687 else if (EQ (conversion, Qemboss))
1688 x_emboss (f, img);
1689 else if (CONSP (conversion)
1690 && EQ (XCAR (conversion), Qedge_detection))
1692 Lisp_Object tem;
1693 tem = XCDR (conversion);
1694 if (CONSP (tem))
1695 x_edge_detection (f, img,
1696 Fplist_get (tem, QCmatrix),
1697 Fplist_get (tem, QCcolor_adjustment));
1703 /* Return the id of image with Lisp specification SPEC on frame F.
1704 SPEC must be a valid Lisp image specification (see valid_image_p). */
1706 ptrdiff_t
1707 lookup_image (struct frame *f, Lisp_Object spec)
1709 struct image *img;
1710 EMACS_UINT hash;
1711 EMACS_TIME now;
1713 /* F must be a window-system frame, and SPEC must be a valid image
1714 specification. */
1715 xassert (FRAME_WINDOW_P (f));
1716 xassert (valid_image_p (spec));
1718 /* Look up SPEC in the hash table of the image cache. */
1719 hash = sxhash (spec, 0);
1720 img = search_image_cache (f, spec, hash);
1721 if (img && img->load_failed_p)
1723 free_image (f, img);
1724 img = NULL;
1727 /* If not found, create a new image and cache it. */
1728 if (img == NULL)
1730 BLOCK_INPUT;
1731 img = make_image (spec, hash);
1732 cache_image (f, img);
1733 img->load_failed_p = img->type->load (f, img) == 0;
1734 img->frame_foreground = FRAME_FOREGROUND_PIXEL (f);
1735 img->frame_background = FRAME_BACKGROUND_PIXEL (f);
1737 /* If we can't load the image, and we don't have a width and
1738 height, use some arbitrary width and height so that we can
1739 draw a rectangle for it. */
1740 if (img->load_failed_p)
1742 Lisp_Object value;
1744 value = image_spec_value (spec, QCwidth, NULL);
1745 img->width = (INTEGERP (value)
1746 ? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
1747 value = image_spec_value (spec, QCheight, NULL);
1748 img->height = (INTEGERP (value)
1749 ? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
1751 else
1753 /* Handle image type independent image attributes
1754 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1755 `:background COLOR'. */
1756 Lisp_Object ascent, margin, relief, bg;
1758 ascent = image_spec_value (spec, QCascent, NULL);
1759 if (INTEGERP (ascent))
1760 img->ascent = XFASTINT (ascent);
1761 else if (EQ (ascent, Qcenter))
1762 img->ascent = CENTERED_IMAGE_ASCENT;
1764 margin = image_spec_value (spec, QCmargin, NULL);
1765 if (INTEGERP (margin))
1766 img->vmargin = img->hmargin = XFASTINT (margin);
1767 else if (CONSP (margin))
1769 img->hmargin = XFASTINT (XCAR (margin));
1770 img->vmargin = XFASTINT (XCDR (margin));
1773 relief = image_spec_value (spec, QCrelief, NULL);
1774 if (INTEGERP (relief))
1776 img->relief = XINT (relief);
1777 img->hmargin += eabs (img->relief);
1778 img->vmargin += eabs (img->relief);
1781 if (! img->background_valid)
1783 bg = image_spec_value (img->spec, QCbackground, NULL);
1784 if (!NILP (bg))
1786 img->background
1787 = x_alloc_image_color (f, img, bg,
1788 FRAME_BACKGROUND_PIXEL (f));
1789 img->background_valid = 1;
1793 /* Do image transformations and compute masks, unless we
1794 don't have the image yet. */
1795 if (!EQ (*img->type->type, Qpostscript))
1796 postprocess_image (f, img);
1799 UNBLOCK_INPUT;
1802 /* We're using IMG, so set its timestamp to `now'. */
1803 EMACS_GET_TIME (now);
1804 img->timestamp = EMACS_SECS (now);
1806 /* Value is the image id. */
1807 return img->id;
1811 /* Cache image IMG in the image cache of frame F. */
1813 static void
1814 cache_image (struct frame *f, struct image *img)
1816 struct image_cache *c = FRAME_IMAGE_CACHE (f);
1817 ptrdiff_t i;
1819 /* Find a free slot in c->images. */
1820 for (i = 0; i < c->used; ++i)
1821 if (c->images[i] == NULL)
1822 break;
1824 /* If no free slot found, maybe enlarge c->images. */
1825 if (i == c->used && c->used == c->size)
1826 c->images = xpalloc (c->images, &c->size, 1, -1, sizeof *c->images);
1828 /* Add IMG to c->images, and assign IMG an id. */
1829 c->images[i] = img;
1830 img->id = i;
1831 if (i == c->used)
1832 ++c->used;
1834 /* Add IMG to the cache's hash table. */
1835 i = img->hash % IMAGE_CACHE_BUCKETS_SIZE;
1836 img->next = c->buckets[i];
1837 if (img->next)
1838 img->next->prev = img;
1839 img->prev = NULL;
1840 c->buckets[i] = img;
1844 /* Call FN on every image in the image cache of frame F. Used to mark
1845 Lisp Objects in the image cache. */
1847 /* Mark Lisp objects in image IMG. */
1849 static void
1850 mark_image (struct image *img)
1852 mark_object (img->spec);
1853 mark_object (img->dependencies);
1855 if (!NILP (img->lisp_data))
1856 mark_object (img->lisp_data);
1860 void
1861 mark_image_cache (struct image_cache *c)
1863 if (c)
1865 ptrdiff_t i;
1866 for (i = 0; i < c->used; ++i)
1867 if (c->images[i])
1868 mark_image (c->images[i]);
1874 /***********************************************************************
1875 X / NS / W32 support code
1876 ***********************************************************************/
1878 #ifdef HAVE_NTGUI
1880 /* Macro for defining functions that will be loaded from image DLLs. */
1881 #define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
1883 /* Macro for loading those image functions from the library. */
1884 #define LOAD_IMGLIB_FN(lib,func) { \
1885 fn_##func = (void *) GetProcAddress (lib, #func); \
1886 if (!fn_##func) return 0; \
1889 #endif /* HAVE_NTGUI */
1891 static int x_create_x_image_and_pixmap (struct frame *, int, int, int,
1892 XImagePtr *, Pixmap *);
1893 static void x_destroy_x_image (XImagePtr);
1894 static void x_put_x_image (struct frame *, XImagePtr, Pixmap, int, int);
1896 /* Return nonzero if XIMG's size WIDTH x HEIGHT doesn't break the
1897 windowing system.
1898 WIDTH and HEIGHT must both be positive.
1899 If XIMG is null, assume it is a bitmap. */
1900 static int
1901 x_check_image_size (XImagePtr ximg, int width, int height)
1903 #ifdef HAVE_X_WINDOWS
1904 /* Respect Xlib's limits: it cannot deal with images that have more
1905 than INT_MAX (and/or UINT_MAX) bytes. And respect Emacs's limits
1906 of PTRDIFF_MAX (and/or SIZE_MAX) bytes for any object. */
1907 enum
1909 XLIB_BYTES_MAX = min (INT_MAX, UINT_MAX),
1910 X_IMAGE_BYTES_MAX = min (XLIB_BYTES_MAX, min (PTRDIFF_MAX, SIZE_MAX))
1913 int bitmap_pad, depth, bytes_per_line;
1914 if (ximg)
1916 bitmap_pad = ximg->bitmap_pad;
1917 depth = ximg->depth;
1918 bytes_per_line = ximg->bytes_per_line;
1920 else
1922 bitmap_pad = 8;
1923 depth = 1;
1924 bytes_per_line = (width >> 3) + ((width & 7) != 0);
1926 return (width <= (INT_MAX - (bitmap_pad - 1)) / depth
1927 && height <= X_IMAGE_BYTES_MAX / bytes_per_line);
1928 #else
1929 /* FIXME: Implement this check for the HAVE_NS and HAVE_NTGUI cases.
1930 For now, assume that every image size is allowed on these systems. */
1931 return 1;
1932 #endif
1935 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1936 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1937 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1938 via xmalloc. Print error messages via image_error if an error
1939 occurs. Value is non-zero if successful.
1941 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1942 should indicate the bit depth of the image. */
1944 static int
1945 x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
1946 XImagePtr *ximg, Pixmap *pixmap)
1948 #ifdef HAVE_X_WINDOWS
1949 Display *display = FRAME_X_DISPLAY (f);
1950 Window window = FRAME_X_WINDOW (f);
1951 Screen *screen = FRAME_X_SCREEN (f);
1953 xassert (interrupt_input_blocked);
1955 if (depth <= 0)
1956 depth = DefaultDepthOfScreen (screen);
1957 *ximg = XCreateImage (display, DefaultVisualOfScreen (screen),
1958 depth, ZPixmap, 0, NULL, width, height,
1959 depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
1960 if (*ximg == NULL)
1962 image_error ("Unable to allocate X image", Qnil, Qnil);
1963 return 0;
1966 if (! x_check_image_size (*ximg, width, height))
1968 x_destroy_x_image (*ximg);
1969 *ximg = NULL;
1970 image_error ("Image too large (%dx%d)",
1971 make_number (width), make_number (height));
1972 return 0;
1975 /* Allocate image raster. */
1976 (*ximg)->data = (char *) xmalloc ((*ximg)->bytes_per_line * height);
1978 /* Allocate a pixmap of the same size. */
1979 *pixmap = XCreatePixmap (display, window, width, height, depth);
1980 if (*pixmap == NO_PIXMAP)
1982 x_destroy_x_image (*ximg);
1983 *ximg = NULL;
1984 image_error ("Unable to create X pixmap", Qnil, Qnil);
1985 return 0;
1988 return 1;
1989 #endif /* HAVE_X_WINDOWS */
1991 #ifdef HAVE_NTGUI
1993 BITMAPINFOHEADER *header;
1994 HDC hdc;
1995 int scanline_width_bits;
1996 int remainder;
1997 int palette_colors = 0;
1999 if (depth == 0)
2000 depth = 24;
2002 if (depth != 1 && depth != 4 && depth != 8
2003 && depth != 16 && depth != 24 && depth != 32)
2005 image_error ("Invalid image bit depth specified", Qnil, Qnil);
2006 return 0;
2009 scanline_width_bits = width * depth;
2010 remainder = scanline_width_bits % 32;
2012 if (remainder)
2013 scanline_width_bits += 32 - remainder;
2015 /* Bitmaps with a depth less than 16 need a palette. */
2016 /* BITMAPINFO structure already contains the first RGBQUAD. */
2017 if (depth < 16)
2018 palette_colors = 1 << (depth - 1);
2020 *ximg = xmalloc (sizeof (XImage) + palette_colors * sizeof (RGBQUAD));
2022 header = &(*ximg)->info.bmiHeader;
2023 memset (&(*ximg)->info, 0, sizeof (BITMAPINFO));
2024 header->biSize = sizeof (*header);
2025 header->biWidth = width;
2026 header->biHeight = -height; /* negative indicates a top-down bitmap. */
2027 header->biPlanes = 1;
2028 header->biBitCount = depth;
2029 header->biCompression = BI_RGB;
2030 header->biClrUsed = palette_colors;
2032 /* TODO: fill in palette. */
2033 if (depth == 1)
2035 (*ximg)->info.bmiColors[0].rgbBlue = 0;
2036 (*ximg)->info.bmiColors[0].rgbGreen = 0;
2037 (*ximg)->info.bmiColors[0].rgbRed = 0;
2038 (*ximg)->info.bmiColors[0].rgbReserved = 0;
2039 (*ximg)->info.bmiColors[1].rgbBlue = 255;
2040 (*ximg)->info.bmiColors[1].rgbGreen = 255;
2041 (*ximg)->info.bmiColors[1].rgbRed = 255;
2042 (*ximg)->info.bmiColors[1].rgbReserved = 0;
2045 hdc = get_frame_dc (f);
2047 /* Create a DIBSection and raster array for the bitmap,
2048 and store its handle in *pixmap. */
2049 *pixmap = CreateDIBSection (hdc, &((*ximg)->info),
2050 (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
2051 /* casting avoids a GCC warning */
2052 (void **)&((*ximg)->data), NULL, 0);
2054 /* Realize display palette and garbage all frames. */
2055 release_frame_dc (f, hdc);
2057 if (*pixmap == NULL)
2059 DWORD err = GetLastError ();
2060 Lisp_Object errcode;
2061 /* All system errors are < 10000, so the following is safe. */
2062 XSETINT (errcode, err);
2063 image_error ("Unable to create bitmap, error code %d", errcode, Qnil);
2064 x_destroy_x_image (*ximg);
2065 return 0;
2068 return 1;
2070 #endif /* HAVE_NTGUI */
2072 #ifdef HAVE_NS
2073 *pixmap = ns_image_for_XPM (width, height, depth);
2074 if (*pixmap == 0)
2076 *ximg = NULL;
2077 image_error ("Unable to allocate NSImage for XPM pixmap", Qnil, Qnil);
2078 return 0;
2080 *ximg = *pixmap;
2081 return 1;
2082 #endif
2086 /* Destroy XImage XIMG. Free XIMG->data. */
2088 static void
2089 x_destroy_x_image (XImagePtr ximg)
2091 xassert (interrupt_input_blocked);
2092 if (ximg)
2094 #ifdef HAVE_X_WINDOWS
2095 xfree (ximg->data);
2096 ximg->data = NULL;
2097 XDestroyImage (ximg);
2098 #endif /* HAVE_X_WINDOWS */
2099 #ifdef HAVE_NTGUI
2100 /* Data will be freed by DestroyObject. */
2101 ximg->data = NULL;
2102 xfree (ximg);
2103 #endif /* HAVE_NTGUI */
2104 #ifdef HAVE_NS
2105 ns_release_object (ximg);
2106 #endif /* HAVE_NS */
2111 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2112 are width and height of both the image and pixmap. */
2114 static void
2115 x_put_x_image (struct frame *f, XImagePtr ximg, Pixmap pixmap, int width, int height)
2117 #ifdef HAVE_X_WINDOWS
2118 GC gc;
2120 xassert (interrupt_input_blocked);
2121 gc = XCreateGC (FRAME_X_DISPLAY (f), pixmap, 0, NULL);
2122 XPutImage (FRAME_X_DISPLAY (f), pixmap, gc, ximg, 0, 0, 0, 0, width, height);
2123 XFreeGC (FRAME_X_DISPLAY (f), gc);
2124 #endif /* HAVE_X_WINDOWS */
2126 #ifdef HAVE_NTGUI
2127 #if 0 /* I don't think this is necessary looking at where it is used. */
2128 HDC hdc = get_frame_dc (f);
2129 SetDIBits (hdc, pixmap, 0, height, ximg->data, &(ximg->info), DIB_RGB_COLORS);
2130 release_frame_dc (f, hdc);
2131 #endif
2132 #endif /* HAVE_NTGUI */
2134 #ifdef HAVE_NS
2135 xassert (ximg == pixmap);
2136 ns_retain_object (ximg);
2137 #endif
2141 /***********************************************************************
2142 File Handling
2143 ***********************************************************************/
2145 /* Find image file FILE. Look in data-directory/images, then
2146 x-bitmap-file-path. Value is the encoded full name of the file
2147 found, or nil if not found. */
2149 Lisp_Object
2150 x_find_image_file (Lisp_Object file)
2152 Lisp_Object file_found, search_path;
2153 int fd;
2155 /* TODO I think this should use something like image-load-path
2156 instead. Unfortunately, that can contain non-string elements. */
2157 search_path = Fcons (Fexpand_file_name (build_string ("images"),
2158 Vdata_directory),
2159 Vx_bitmap_file_path);
2161 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2162 fd = openp (search_path, file, Qnil, &file_found, Qnil);
2164 if (fd == -1)
2165 file_found = Qnil;
2166 else
2168 file_found = ENCODE_FILE (file_found);
2169 close (fd);
2172 return file_found;
2176 /* Read FILE into memory. Value is a pointer to a buffer allocated
2177 with xmalloc holding FILE's contents. Value is null if an error
2178 occurred. *SIZE is set to the size of the file. */
2180 static unsigned char *
2181 slurp_file (char *file, ptrdiff_t *size)
2183 FILE *fp = NULL;
2184 unsigned char *buf = NULL;
2185 struct stat st;
2187 if (stat (file, &st) == 0
2188 && (fp = fopen (file, "rb")) != NULL
2189 && 0 <= st.st_size && st.st_size <= min (PTRDIFF_MAX, SIZE_MAX)
2190 && (buf = (unsigned char *) xmalloc (st.st_size),
2191 fread (buf, 1, st.st_size, fp) == st.st_size))
2193 *size = st.st_size;
2194 fclose (fp);
2196 else
2198 if (fp)
2199 fclose (fp);
2200 if (buf)
2202 xfree (buf);
2203 buf = NULL;
2207 return buf;
2212 /***********************************************************************
2213 XBM images
2214 ***********************************************************************/
2216 static int xbm_scan (unsigned char **, unsigned char *, char *, int *);
2217 static int xbm_load (struct frame *f, struct image *img);
2218 static int xbm_load_image (struct frame *f, struct image *img,
2219 unsigned char *, unsigned char *);
2220 static int xbm_image_p (Lisp_Object object);
2221 static int xbm_read_bitmap_data (struct frame *f,
2222 unsigned char *, unsigned char *,
2223 int *, int *, char **, int);
2224 static int xbm_file_p (Lisp_Object);
2227 /* Indices of image specification fields in xbm_format, below. */
2229 enum xbm_keyword_index
2231 XBM_TYPE,
2232 XBM_FILE,
2233 XBM_WIDTH,
2234 XBM_HEIGHT,
2235 XBM_DATA,
2236 XBM_FOREGROUND,
2237 XBM_BACKGROUND,
2238 XBM_ASCENT,
2239 XBM_MARGIN,
2240 XBM_RELIEF,
2241 XBM_ALGORITHM,
2242 XBM_HEURISTIC_MASK,
2243 XBM_MASK,
2244 XBM_LAST
2247 /* Vector of image_keyword structures describing the format
2248 of valid XBM image specifications. */
2250 static const struct image_keyword xbm_format[XBM_LAST] =
2252 {":type", IMAGE_SYMBOL_VALUE, 1},
2253 {":file", IMAGE_STRING_VALUE, 0},
2254 {":width", IMAGE_POSITIVE_INTEGER_VALUE, 0},
2255 {":height", IMAGE_POSITIVE_INTEGER_VALUE, 0},
2256 {":data", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2257 {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
2258 {":background", IMAGE_STRING_OR_NIL_VALUE, 0},
2259 {":ascent", IMAGE_ASCENT_VALUE, 0},
2260 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
2261 {":relief", IMAGE_INTEGER_VALUE, 0},
2262 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2263 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2264 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
2267 /* Structure describing the image type XBM. */
2269 static struct image_type xbm_type =
2271 &Qxbm,
2272 xbm_image_p,
2273 xbm_load,
2274 x_clear_image,
2275 NULL
2278 /* Tokens returned from xbm_scan. */
2280 enum xbm_token
2282 XBM_TK_IDENT = 256,
2283 XBM_TK_NUMBER
2287 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2288 A valid specification is a list starting with the symbol `image'
2289 The rest of the list is a property list which must contain an
2290 entry `:type xbm..
2292 If the specification specifies a file to load, it must contain
2293 an entry `:file FILENAME' where FILENAME is a string.
2295 If the specification is for a bitmap loaded from memory it must
2296 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2297 WIDTH and HEIGHT are integers > 0. DATA may be:
2299 1. a string large enough to hold the bitmap data, i.e. it must
2300 have a size >= (WIDTH + 7) / 8 * HEIGHT
2302 2. a bool-vector of size >= WIDTH * HEIGHT
2304 3. a vector of strings or bool-vectors, one for each line of the
2305 bitmap.
2307 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2308 may not be specified in this case because they are defined in the
2309 XBM file.
2311 Both the file and data forms may contain the additional entries
2312 `:background COLOR' and `:foreground COLOR'. If not present,
2313 foreground and background of the frame on which the image is
2314 displayed is used. */
2316 static int
2317 xbm_image_p (Lisp_Object object)
2319 struct image_keyword kw[XBM_LAST];
2321 memcpy (kw, xbm_format, sizeof kw);
2322 if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
2323 return 0;
2325 xassert (EQ (kw[XBM_TYPE].value, Qxbm));
2327 if (kw[XBM_FILE].count)
2329 if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_DATA].count)
2330 return 0;
2332 else if (kw[XBM_DATA].count && xbm_file_p (kw[XBM_DATA].value))
2334 /* In-memory XBM file. */
2335 if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_FILE].count)
2336 return 0;
2338 else
2340 Lisp_Object data;
2341 int width, height;
2343 /* Entries for `:width', `:height' and `:data' must be present. */
2344 if (!kw[XBM_WIDTH].count
2345 || !kw[XBM_HEIGHT].count
2346 || !kw[XBM_DATA].count)
2347 return 0;
2349 data = kw[XBM_DATA].value;
2350 width = XFASTINT (kw[XBM_WIDTH].value);
2351 height = XFASTINT (kw[XBM_HEIGHT].value);
2353 /* Check type of data, and width and height against contents of
2354 data. */
2355 if (VECTORP (data))
2357 EMACS_INT i;
2359 /* Number of elements of the vector must be >= height. */
2360 if (ASIZE (data) < height)
2361 return 0;
2363 /* Each string or bool-vector in data must be large enough
2364 for one line of the image. */
2365 for (i = 0; i < height; ++i)
2367 Lisp_Object elt = XVECTOR (data)->contents[i];
2369 if (STRINGP (elt))
2371 if (SCHARS (elt)
2372 < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR)
2373 return 0;
2375 else if (BOOL_VECTOR_P (elt))
2377 if (XBOOL_VECTOR (elt)->size < width)
2378 return 0;
2380 else
2381 return 0;
2384 else if (STRINGP (data))
2386 if (SCHARS (data)
2387 < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR * height)
2388 return 0;
2390 else if (BOOL_VECTOR_P (data))
2392 if (XBOOL_VECTOR (data)->size / height < width)
2393 return 0;
2395 else
2396 return 0;
2399 return 1;
2403 /* Scan a bitmap file. FP is the stream to read from. Value is
2404 either an enumerator from enum xbm_token, or a character for a
2405 single-character token, or 0 at end of file. If scanning an
2406 identifier, store the lexeme of the identifier in SVAL. If
2407 scanning a number, store its value in *IVAL. */
2409 static int
2410 xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
2412 unsigned int c;
2414 loop:
2416 /* Skip white space. */
2417 while (*s < end && (c = *(*s)++, isspace (c)))
2420 if (*s >= end)
2421 c = 0;
2422 else if (isdigit (c))
2424 int value = 0, digit;
2426 if (c == '0' && *s < end)
2428 c = *(*s)++;
2429 if (c == 'x' || c == 'X')
2431 while (*s < end)
2433 c = *(*s)++;
2434 if (isdigit (c))
2435 digit = c - '0';
2436 else if (c >= 'a' && c <= 'f')
2437 digit = c - 'a' + 10;
2438 else if (c >= 'A' && c <= 'F')
2439 digit = c - 'A' + 10;
2440 else
2441 break;
2442 value = 16 * value + digit;
2445 else if (isdigit (c))
2447 value = c - '0';
2448 while (*s < end
2449 && (c = *(*s)++, isdigit (c)))
2450 value = 8 * value + c - '0';
2453 else
2455 value = c - '0';
2456 while (*s < end
2457 && (c = *(*s)++, isdigit (c)))
2458 value = 10 * value + c - '0';
2461 if (*s < end)
2462 *s = *s - 1;
2463 *ival = value;
2464 c = XBM_TK_NUMBER;
2466 else if (isalpha (c) || c == '_')
2468 *sval++ = c;
2469 while (*s < end
2470 && (c = *(*s)++, (isalnum (c) || c == '_')))
2471 *sval++ = c;
2472 *sval = 0;
2473 if (*s < end)
2474 *s = *s - 1;
2475 c = XBM_TK_IDENT;
2477 else if (c == '/' && **s == '*')
2479 /* C-style comment. */
2480 ++*s;
2481 while (**s && (**s != '*' || *(*s + 1) != '/'))
2482 ++*s;
2483 if (**s)
2485 *s += 2;
2486 goto loop;
2490 return c;
2493 #ifdef HAVE_NTGUI
2495 /* Create a Windows bitmap from X bitmap data. */
2496 static HBITMAP
2497 w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
2499 static unsigned char swap_nibble[16]
2500 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2501 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2502 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2503 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2504 int i, j, w1, w2;
2505 unsigned char *bits, *p;
2506 HBITMAP bmp;
2508 w1 = (width + 7) / 8; /* nb of 8bits elt in X bitmap */
2509 w2 = ((width + 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2510 bits = (unsigned char *) alloca (height * w2);
2511 memset (bits, 0, height * w2);
2512 for (i = 0; i < height; i++)
2514 p = bits + i*w2;
2515 for (j = 0; j < w1; j++)
2517 /* Bitswap XBM bytes to match how Windows does things. */
2518 unsigned char c = *data++;
2519 *p++ = (unsigned char)((swap_nibble[c & 0xf] << 4)
2520 | (swap_nibble[(c>>4) & 0xf]));
2523 bmp = CreateBitmap (width, height, 1, 1, (char *) bits);
2525 return bmp;
2528 static void
2529 convert_mono_to_color_image (struct frame *f, struct image *img,
2530 COLORREF foreground, COLORREF background)
2532 HDC hdc, old_img_dc, new_img_dc;
2533 HGDIOBJ old_prev, new_prev;
2534 HBITMAP new_pixmap;
2536 hdc = get_frame_dc (f);
2537 old_img_dc = CreateCompatibleDC (hdc);
2538 new_img_dc = CreateCompatibleDC (hdc);
2539 new_pixmap = CreateCompatibleBitmap (hdc, img->width, img->height);
2540 release_frame_dc (f, hdc);
2541 old_prev = SelectObject (old_img_dc, img->pixmap);
2542 new_prev = SelectObject (new_img_dc, new_pixmap);
2543 /* Windows convention for mono bitmaps is black = background,
2544 white = foreground. */
2545 SetTextColor (new_img_dc, background);
2546 SetBkColor (new_img_dc, foreground);
2548 BitBlt (new_img_dc, 0, 0, img->width, img->height, old_img_dc,
2549 0, 0, SRCCOPY);
2551 SelectObject (old_img_dc, old_prev);
2552 SelectObject (new_img_dc, new_prev);
2553 DeleteDC (old_img_dc);
2554 DeleteDC (new_img_dc);
2555 DeleteObject (img->pixmap);
2556 if (new_pixmap == 0)
2557 fprintf (stderr, "Failed to convert image to color.\n");
2558 else
2559 img->pixmap = new_pixmap;
2562 #define XBM_BIT_SHUFFLE(b) (~(b))
2564 #else
2566 #define XBM_BIT_SHUFFLE(b) (b)
2568 #endif /* HAVE_NTGUI */
2571 static void
2572 Create_Pixmap_From_Bitmap_Data (struct frame *f, struct image *img, char *data,
2573 RGB_PIXEL_COLOR fg, RGB_PIXEL_COLOR bg,
2574 int non_default_colors)
2576 #ifdef HAVE_NTGUI
2577 img->pixmap
2578 = w32_create_pixmap_from_bitmap_data (img->width, img->height, data);
2580 /* If colors were specified, transfer the bitmap to a color one. */
2581 if (non_default_colors)
2582 convert_mono_to_color_image (f, img, fg, bg);
2584 #elif defined (HAVE_NS)
2585 img->pixmap = ns_image_from_XBM (data, img->width, img->height);
2587 #else
2588 img->pixmap =
2589 (x_check_image_size (0, img->width, img->height)
2590 ? XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f),
2591 FRAME_X_WINDOW (f),
2592 data,
2593 img->width, img->height,
2594 fg, bg,
2595 DefaultDepthOfScreen (FRAME_X_SCREEN (f)))
2596 : NO_PIXMAP);
2597 #endif /* !HAVE_NTGUI && !HAVE_NS */
2602 /* Replacement for XReadBitmapFileData which isn't available under old
2603 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2604 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2605 the image. Return in *DATA the bitmap data allocated with xmalloc.
2606 Value is non-zero if successful. DATA null means just test if
2607 CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR
2608 is non-zero, inhibit the call to image_error when the image size is
2609 invalid (the bitmap remains unread). */
2611 static int
2612 xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *end,
2613 int *width, int *height, char **data,
2614 int inhibit_image_error)
2616 unsigned char *s = contents;
2617 char buffer[BUFSIZ];
2618 int padding_p = 0;
2619 int v10 = 0;
2620 int bytes_per_line, i, nbytes;
2621 char *p;
2622 int value;
2623 int LA1;
2625 #define match() \
2626 LA1 = xbm_scan (&s, end, buffer, &value)
2628 #define expect(TOKEN) \
2629 if (LA1 != (TOKEN)) \
2630 goto failure; \
2631 else \
2632 match ()
2634 #define expect_ident(IDENT) \
2635 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2636 match (); \
2637 else \
2638 goto failure
2640 *width = *height = -1;
2641 if (data)
2642 *data = NULL;
2643 LA1 = xbm_scan (&s, end, buffer, &value);
2645 /* Parse defines for width, height and hot-spots. */
2646 while (LA1 == '#')
2648 match ();
2649 expect_ident ("define");
2650 expect (XBM_TK_IDENT);
2652 if (LA1 == XBM_TK_NUMBER)
2654 char *q = strrchr (buffer, '_');
2655 q = q ? q + 1 : buffer;
2656 if (strcmp (q, "width") == 0)
2657 *width = value;
2658 else if (strcmp (q, "height") == 0)
2659 *height = value;
2661 expect (XBM_TK_NUMBER);
2664 if (!check_image_size (f, *width, *height))
2666 if (!inhibit_image_error)
2667 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
2668 goto failure;
2670 else if (data == NULL)
2671 goto success;
2673 /* Parse bits. Must start with `static'. */
2674 expect_ident ("static");
2675 if (LA1 == XBM_TK_IDENT)
2677 if (strcmp (buffer, "unsigned") == 0)
2679 match ();
2680 expect_ident ("char");
2682 else if (strcmp (buffer, "short") == 0)
2684 match ();
2685 v10 = 1;
2686 if (*width % 16 && *width % 16 < 9)
2687 padding_p = 1;
2689 else if (strcmp (buffer, "char") == 0)
2690 match ();
2691 else
2692 goto failure;
2694 else
2695 goto failure;
2697 expect (XBM_TK_IDENT);
2698 expect ('[');
2699 expect (']');
2700 expect ('=');
2701 expect ('{');
2703 if (! x_check_image_size (0, *width, *height))
2705 if (!inhibit_image_error)
2706 image_error ("Image too large (%dx%d)",
2707 make_number (*width), make_number (*height));
2708 goto failure;
2710 bytes_per_line = (*width + 7) / 8 + padding_p;
2711 nbytes = bytes_per_line * *height;
2712 p = *data = (char *) xmalloc (nbytes);
2714 if (v10)
2716 for (i = 0; i < nbytes; i += 2)
2718 int val = value;
2719 expect (XBM_TK_NUMBER);
2721 *p++ = XBM_BIT_SHUFFLE (val);
2722 if (!padding_p || ((i + 2) % bytes_per_line))
2723 *p++ = XBM_BIT_SHUFFLE (value >> 8);
2725 if (LA1 == ',' || LA1 == '}')
2726 match ();
2727 else
2728 goto failure;
2731 else
2733 for (i = 0; i < nbytes; ++i)
2735 int val = value;
2736 expect (XBM_TK_NUMBER);
2738 *p++ = XBM_BIT_SHUFFLE (val);
2740 if (LA1 == ',' || LA1 == '}')
2741 match ();
2742 else
2743 goto failure;
2747 success:
2748 return 1;
2750 failure:
2752 if (data && *data)
2754 xfree (*data);
2755 *data = NULL;
2757 return 0;
2759 #undef match
2760 #undef expect
2761 #undef expect_ident
2765 /* Load XBM image IMG which will be displayed on frame F from buffer
2766 CONTENTS. END is the end of the buffer. Value is non-zero if
2767 successful. */
2769 static int
2770 xbm_load_image (struct frame *f, struct image *img, unsigned char *contents,
2771 unsigned char *end)
2773 int rc;
2774 char *data;
2775 int success_p = 0;
2777 rc = xbm_read_bitmap_data (f, contents, end, &img->width, &img->height,
2778 &data, 0);
2779 if (rc)
2781 unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
2782 unsigned long background = FRAME_BACKGROUND_PIXEL (f);
2783 int non_default_colors = 0;
2784 Lisp_Object value;
2786 xassert (img->width > 0 && img->height > 0);
2788 /* Get foreground and background colors, maybe allocate colors. */
2789 value = image_spec_value (img->spec, QCforeground, NULL);
2790 if (!NILP (value))
2792 foreground = x_alloc_image_color (f, img, value, foreground);
2793 non_default_colors = 1;
2795 value = image_spec_value (img->spec, QCbackground, NULL);
2796 if (!NILP (value))
2798 background = x_alloc_image_color (f, img, value, background);
2799 img->background = background;
2800 img->background_valid = 1;
2801 non_default_colors = 1;
2804 Create_Pixmap_From_Bitmap_Data (f, img, data,
2805 foreground, background,
2806 non_default_colors);
2807 xfree (data);
2809 if (img->pixmap == NO_PIXMAP)
2811 x_clear_image (f, img);
2812 image_error ("Unable to create X pixmap for `%s'", img->spec, Qnil);
2814 else
2815 success_p = 1;
2817 else
2818 image_error ("Error loading XBM image `%s'", img->spec, Qnil);
2820 return success_p;
2824 /* Value is non-zero if DATA looks like an in-memory XBM file. */
2826 static int
2827 xbm_file_p (Lisp_Object data)
2829 int w, h;
2830 return (STRINGP (data)
2831 && xbm_read_bitmap_data (NULL, SDATA (data),
2832 (SDATA (data) + SBYTES (data)),
2833 &w, &h, NULL, 1));
2837 /* Fill image IMG which is used on frame F with pixmap data. Value is
2838 non-zero if successful. */
2840 static int
2841 xbm_load (struct frame *f, struct image *img)
2843 int success_p = 0;
2844 Lisp_Object file_name;
2846 xassert (xbm_image_p (img->spec));
2848 /* If IMG->spec specifies a file name, create a non-file spec from it. */
2849 file_name = image_spec_value (img->spec, QCfile, NULL);
2850 if (STRINGP (file_name))
2852 Lisp_Object file;
2853 unsigned char *contents;
2854 ptrdiff_t size;
2856 file = x_find_image_file (file_name);
2857 if (!STRINGP (file))
2859 image_error ("Cannot find image file `%s'", file_name, Qnil);
2860 return 0;
2863 contents = slurp_file (SSDATA (file), &size);
2864 if (contents == NULL)
2866 image_error ("Error loading XBM image `%s'", img->spec, Qnil);
2867 return 0;
2870 success_p = xbm_load_image (f, img, contents, contents + size);
2871 xfree (contents);
2873 else
2875 struct image_keyword fmt[XBM_LAST];
2876 Lisp_Object data;
2877 unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
2878 unsigned long background = FRAME_BACKGROUND_PIXEL (f);
2879 int non_default_colors = 0;
2880 char *bits;
2881 int parsed_p;
2882 int in_memory_file_p = 0;
2884 /* See if data looks like an in-memory XBM file. */
2885 data = image_spec_value (img->spec, QCdata, NULL);
2886 in_memory_file_p = xbm_file_p (data);
2888 /* Parse the image specification. */
2889 memcpy (fmt, xbm_format, sizeof fmt);
2890 parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
2891 (void) parsed_p;
2892 xassert (parsed_p);
2894 /* Get specified width, and height. */
2895 if (!in_memory_file_p)
2897 img->width = XFASTINT (fmt[XBM_WIDTH].value);
2898 img->height = XFASTINT (fmt[XBM_HEIGHT].value);
2899 xassert (img->width > 0 && img->height > 0);
2900 if (!check_image_size (f, img->width, img->height))
2902 image_error ("Invalid image size (see `max-image-size')",
2903 Qnil, Qnil);
2904 return 0;
2908 /* Get foreground and background colors, maybe allocate colors. */
2909 if (fmt[XBM_FOREGROUND].count
2910 && STRINGP (fmt[XBM_FOREGROUND].value))
2912 foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
2913 foreground);
2914 non_default_colors = 1;
2917 if (fmt[XBM_BACKGROUND].count
2918 && STRINGP (fmt[XBM_BACKGROUND].value))
2920 background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
2921 background);
2922 non_default_colors = 1;
2925 if (in_memory_file_p)
2926 success_p = xbm_load_image (f, img, SDATA (data),
2927 (SDATA (data)
2928 + SBYTES (data)));
2929 else
2931 if (VECTORP (data))
2933 int i;
2934 char *p;
2935 int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
2937 p = bits = (char *) alloca (nbytes * img->height);
2938 for (i = 0; i < img->height; ++i, p += nbytes)
2940 Lisp_Object line = XVECTOR (data)->contents[i];
2941 if (STRINGP (line))
2942 memcpy (p, SDATA (line), nbytes);
2943 else
2944 memcpy (p, XBOOL_VECTOR (line)->data, nbytes);
2947 else if (STRINGP (data))
2948 bits = SSDATA (data);
2949 else
2950 bits = (char *) XBOOL_VECTOR (data)->data;
2952 #ifdef WINDOWSNT
2954 char *invertedBits;
2955 int nbytes, i;
2956 /* Windows mono bitmaps are reversed compared with X. */
2957 invertedBits = bits;
2958 nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR
2959 * img->height;
2960 bits = (char *) alloca (nbytes);
2961 for (i = 0; i < nbytes; i++)
2962 bits[i] = XBM_BIT_SHUFFLE (invertedBits[i]);
2964 #endif
2965 /* Create the pixmap. */
2967 if (x_check_image_size (0, img->width, img->height))
2968 Create_Pixmap_From_Bitmap_Data (f, img, bits,
2969 foreground, background,
2970 non_default_colors);
2971 else
2972 img->pixmap = NO_PIXMAP;
2974 if (img->pixmap)
2975 success_p = 1;
2976 else
2978 image_error ("Unable to create pixmap for XBM image `%s'",
2979 img->spec, Qnil);
2980 x_clear_image (f, img);
2985 return success_p;
2990 /***********************************************************************
2991 XPM images
2992 ***********************************************************************/
2994 #if defined (HAVE_XPM) || defined (HAVE_NS)
2996 static int xpm_image_p (Lisp_Object object);
2997 static int xpm_load (struct frame *f, struct image *img);
2998 static int xpm_valid_color_symbols_p (Lisp_Object);
3000 #endif /* HAVE_XPM || HAVE_NS */
3002 #ifdef HAVE_XPM
3003 #ifdef HAVE_NTGUI
3004 /* Indicate to xpm.h that we don't have Xlib. */
3005 #define FOR_MSW
3006 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3007 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3008 #define XColor xpm_XColor
3009 #define XImage xpm_XImage
3010 #define Display xpm_Display
3011 #define PIXEL_ALREADY_TYPEDEFED
3012 #include "X11/xpm.h"
3013 #undef FOR_MSW
3014 #undef XColor
3015 #undef XImage
3016 #undef Display
3017 #undef PIXEL_ALREADY_TYPEDEFED
3018 #else
3019 #include "X11/xpm.h"
3020 #endif /* HAVE_NTGUI */
3021 #endif /* HAVE_XPM */
3023 #if defined (HAVE_XPM) || defined (HAVE_NS)
3024 /* The symbol `xpm' identifying XPM-format images. */
3026 static Lisp_Object Qxpm;
3028 /* Indices of image specification fields in xpm_format, below. */
3030 enum xpm_keyword_index
3032 XPM_TYPE,
3033 XPM_FILE,
3034 XPM_DATA,
3035 XPM_ASCENT,
3036 XPM_MARGIN,
3037 XPM_RELIEF,
3038 XPM_ALGORITHM,
3039 XPM_HEURISTIC_MASK,
3040 XPM_MASK,
3041 XPM_COLOR_SYMBOLS,
3042 XPM_BACKGROUND,
3043 XPM_LAST
3046 /* Vector of image_keyword structures describing the format
3047 of valid XPM image specifications. */
3049 static const struct image_keyword xpm_format[XPM_LAST] =
3051 {":type", IMAGE_SYMBOL_VALUE, 1},
3052 {":file", IMAGE_STRING_VALUE, 0},
3053 {":data", IMAGE_STRING_VALUE, 0},
3054 {":ascent", IMAGE_ASCENT_VALUE, 0},
3055 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
3056 {":relief", IMAGE_INTEGER_VALUE, 0},
3057 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3058 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3059 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3060 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3061 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
3064 /* Structure describing the image type XPM. */
3066 static struct image_type xpm_type =
3068 &Qxpm,
3069 xpm_image_p,
3070 xpm_load,
3071 x_clear_image,
3072 NULL
3075 #ifdef HAVE_X_WINDOWS
3077 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3078 functions for allocating image colors. Our own functions handle
3079 color allocation failures more gracefully than the ones on the XPM
3080 lib. */
3082 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3083 #define ALLOC_XPM_COLORS
3084 #endif
3085 #endif /* HAVE_X_WINDOWS */
3087 #ifdef ALLOC_XPM_COLORS
3089 static void xpm_init_color_cache (struct frame *, XpmAttributes *);
3090 static void xpm_free_color_cache (void);
3091 static int xpm_lookup_color (struct frame *, char *, XColor *);
3092 static int xpm_color_bucket (char *);
3093 static struct xpm_cached_color *xpm_cache_color (struct frame *, char *,
3094 XColor *, int);
3096 /* An entry in a hash table used to cache color definitions of named
3097 colors. This cache is necessary to speed up XPM image loading in
3098 case we do color allocations ourselves. Without it, we would need
3099 a call to XParseColor per pixel in the image. */
3101 struct xpm_cached_color
3103 /* Next in collision chain. */
3104 struct xpm_cached_color *next;
3106 /* Color definition (RGB and pixel color). */
3107 XColor color;
3109 /* Color name. */
3110 char name[1];
3113 /* The hash table used for the color cache, and its bucket vector
3114 size. */
3116 #define XPM_COLOR_CACHE_BUCKETS 1001
3117 static struct xpm_cached_color **xpm_color_cache;
3119 /* Initialize the color cache. */
3121 static void
3122 xpm_init_color_cache (struct frame *f, XpmAttributes *attrs)
3124 size_t nbytes = XPM_COLOR_CACHE_BUCKETS * sizeof *xpm_color_cache;
3125 xpm_color_cache = (struct xpm_cached_color **) xmalloc (nbytes);
3126 memset (xpm_color_cache, 0, nbytes);
3127 init_color_table ();
3129 if (attrs->valuemask & XpmColorSymbols)
3131 int i;
3132 XColor color;
3134 for (i = 0; i < attrs->numsymbols; ++i)
3135 if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
3136 attrs->colorsymbols[i].value, &color))
3138 color.pixel = lookup_rgb_color (f, color.red, color.green,
3139 color.blue);
3140 xpm_cache_color (f, attrs->colorsymbols[i].name, &color, -1);
3145 /* Free the color cache. */
3147 static void
3148 xpm_free_color_cache (void)
3150 struct xpm_cached_color *p, *next;
3151 int i;
3153 for (i = 0; i < XPM_COLOR_CACHE_BUCKETS; ++i)
3154 for (p = xpm_color_cache[i]; p; p = next)
3156 next = p->next;
3157 xfree (p);
3160 xfree (xpm_color_cache);
3161 xpm_color_cache = NULL;
3162 free_color_table ();
3165 /* Return the bucket index for color named COLOR_NAME in the color
3166 cache. */
3168 static int
3169 xpm_color_bucket (char *color_name)
3171 EMACS_UINT hash = hash_string (color_name, strlen (color_name));
3172 return hash % XPM_COLOR_CACHE_BUCKETS;
3176 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3177 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3178 entry added. */
3180 static struct xpm_cached_color *
3181 xpm_cache_color (struct frame *f, char *color_name, XColor *color, int bucket)
3183 size_t nbytes;
3184 struct xpm_cached_color *p;
3186 if (bucket < 0)
3187 bucket = xpm_color_bucket (color_name);
3189 nbytes = offsetof (struct xpm_cached_color, name) + strlen (color_name) + 1;
3190 p = (struct xpm_cached_color *) xmalloc (nbytes);
3191 strcpy (p->name, color_name);
3192 p->color = *color;
3193 p->next = xpm_color_cache[bucket];
3194 xpm_color_cache[bucket] = p;
3195 return p;
3198 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3199 return the cached definition in *COLOR. Otherwise, make a new
3200 entry in the cache and allocate the color. Value is zero if color
3201 allocation failed. */
3203 static int
3204 xpm_lookup_color (struct frame *f, char *color_name, XColor *color)
3206 struct xpm_cached_color *p;
3207 int h = xpm_color_bucket (color_name);
3209 for (p = xpm_color_cache[h]; p; p = p->next)
3210 if (strcmp (p->name, color_name) == 0)
3211 break;
3213 if (p != NULL)
3214 *color = p->color;
3215 else if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
3216 color_name, color))
3218 color->pixel = lookup_rgb_color (f, color->red, color->green,
3219 color->blue);
3220 p = xpm_cache_color (f, color_name, color, h);
3222 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3223 with transparency, and it's useful. */
3224 else if (strcmp ("opaque", color_name) == 0)
3226 memset (color, 0, sizeof (XColor)); /* Is this necessary/correct? */
3227 color->pixel = FRAME_FOREGROUND_PIXEL (f);
3228 p = xpm_cache_color (f, color_name, color, h);
3231 return p != NULL;
3235 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3236 CLOSURE is a pointer to the frame on which we allocate the
3237 color. Return in *COLOR the allocated color. Value is non-zero
3238 if successful. */
3240 static int
3241 xpm_alloc_color (Display *dpy, Colormap cmap, char *color_name, XColor *color,
3242 void *closure)
3244 return xpm_lookup_color ((struct frame *) closure, color_name, color);
3248 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3249 is a pointer to the frame on which we allocate the color. Value is
3250 non-zero if successful. */
3252 static int
3253 xpm_free_colors (Display *dpy, Colormap cmap, Pixel *pixels, int npixels, void *closure)
3255 return 1;
3258 #endif /* ALLOC_XPM_COLORS */
3261 #ifdef HAVE_NTGUI
3263 /* XPM library details. */
3265 DEF_IMGLIB_FN (void, XpmFreeAttributes, (XpmAttributes *));
3266 DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer, (Display *, char *, xpm_XImage **,
3267 xpm_XImage **, XpmAttributes *));
3268 DEF_IMGLIB_FN (int, XpmReadFileToImage, (Display *, char *, xpm_XImage **,
3269 xpm_XImage **, XpmAttributes *));
3270 DEF_IMGLIB_FN (void, XImageFree, (xpm_XImage *));
3272 static int
3273 init_xpm_functions (Lisp_Object libraries)
3275 HMODULE library;
3277 if (!(library = w32_delayed_load (libraries, Qxpm)))
3278 return 0;
3280 LOAD_IMGLIB_FN (library, XpmFreeAttributes);
3281 LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
3282 LOAD_IMGLIB_FN (library, XpmReadFileToImage);
3283 LOAD_IMGLIB_FN (library, XImageFree);
3284 return 1;
3287 #endif /* HAVE_NTGUI */
3290 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3291 for XPM images. Such a list must consist of conses whose car and
3292 cdr are strings. */
3294 static int
3295 xpm_valid_color_symbols_p (Lisp_Object color_symbols)
3297 while (CONSP (color_symbols))
3299 Lisp_Object sym = XCAR (color_symbols);
3300 if (!CONSP (sym)
3301 || !STRINGP (XCAR (sym))
3302 || !STRINGP (XCDR (sym)))
3303 break;
3304 color_symbols = XCDR (color_symbols);
3307 return NILP (color_symbols);
3311 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3313 static int
3314 xpm_image_p (Lisp_Object object)
3316 struct image_keyword fmt[XPM_LAST];
3317 memcpy (fmt, xpm_format, sizeof fmt);
3318 return (parse_image_spec (object, fmt, XPM_LAST, Qxpm)
3319 /* Either `:file' or `:data' must be present. */
3320 && fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
3321 /* Either no `:color-symbols' or it's a list of conses
3322 whose car and cdr are strings. */
3323 && (fmt[XPM_COLOR_SYMBOLS].count == 0
3324 || xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value)));
3327 #endif /* HAVE_XPM || HAVE_NS */
3329 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3330 ptrdiff_t
3331 x_create_bitmap_from_xpm_data (struct frame *f, const char **bits)
3333 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3334 ptrdiff_t id;
3335 int rc;
3336 XpmAttributes attrs;
3337 Pixmap bitmap, mask;
3339 memset (&attrs, 0, sizeof attrs);
3341 attrs.visual = FRAME_X_VISUAL (f);
3342 attrs.colormap = FRAME_X_COLORMAP (f);
3343 attrs.valuemask |= XpmVisual;
3344 attrs.valuemask |= XpmColormap;
3346 rc = XpmCreatePixmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3347 (char **) bits, &bitmap, &mask, &attrs);
3348 if (rc != XpmSuccess)
3350 XpmFreeAttributes (&attrs);
3351 return -1;
3354 id = x_allocate_bitmap_record (f);
3355 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
3356 dpyinfo->bitmaps[id - 1].have_mask = 1;
3357 dpyinfo->bitmaps[id - 1].mask = mask;
3358 dpyinfo->bitmaps[id - 1].file = NULL;
3359 dpyinfo->bitmaps[id - 1].height = attrs.height;
3360 dpyinfo->bitmaps[id - 1].width = attrs.width;
3361 dpyinfo->bitmaps[id - 1].depth = attrs.depth;
3362 dpyinfo->bitmaps[id - 1].refcount = 1;
3364 XpmFreeAttributes (&attrs);
3365 return id;
3367 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3369 /* Load image IMG which will be displayed on frame F. Value is
3370 non-zero if successful. */
3372 #ifdef HAVE_XPM
3374 static int
3375 xpm_load (struct frame *f, struct image *img)
3377 int rc;
3378 XpmAttributes attrs;
3379 Lisp_Object specified_file, color_symbols;
3380 #ifdef HAVE_NTGUI
3381 HDC hdc;
3382 xpm_XImage * xpm_image = NULL, * xpm_mask = NULL;
3383 #endif /* HAVE_NTGUI */
3385 /* Configure the XPM lib. Use the visual of frame F. Allocate
3386 close colors. Return colors allocated. */
3387 memset (&attrs, 0, sizeof attrs);
3389 #ifndef HAVE_NTGUI
3390 attrs.visual = FRAME_X_VISUAL (f);
3391 attrs.colormap = FRAME_X_COLORMAP (f);
3392 attrs.valuemask |= XpmVisual;
3393 attrs.valuemask |= XpmColormap;
3394 #endif /* HAVE_NTGUI */
3396 #ifdef ALLOC_XPM_COLORS
3397 /* Allocate colors with our own functions which handle
3398 failing color allocation more gracefully. */
3399 attrs.color_closure = f;
3400 attrs.alloc_color = xpm_alloc_color;
3401 attrs.free_colors = xpm_free_colors;
3402 attrs.valuemask |= XpmAllocColor | XpmFreeColors | XpmColorClosure;
3403 #else /* not ALLOC_XPM_COLORS */
3404 /* Let the XPM lib allocate colors. */
3405 attrs.valuemask |= XpmReturnAllocPixels;
3406 #ifdef XpmAllocCloseColors
3407 attrs.alloc_close_colors = 1;
3408 attrs.valuemask |= XpmAllocCloseColors;
3409 #else /* not XpmAllocCloseColors */
3410 attrs.closeness = 600;
3411 attrs.valuemask |= XpmCloseness;
3412 #endif /* not XpmAllocCloseColors */
3413 #endif /* ALLOC_XPM_COLORS */
3415 /* If image specification contains symbolic color definitions, add
3416 these to `attrs'. */
3417 color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
3418 if (CONSP (color_symbols))
3420 Lisp_Object tail;
3421 XpmColorSymbol *xpm_syms;
3422 int i, size;
3424 attrs.valuemask |= XpmColorSymbols;
3426 /* Count number of symbols. */
3427 attrs.numsymbols = 0;
3428 for (tail = color_symbols; CONSP (tail); tail = XCDR (tail))
3429 ++attrs.numsymbols;
3431 /* Allocate an XpmColorSymbol array. */
3432 size = attrs.numsymbols * sizeof *xpm_syms;
3433 xpm_syms = (XpmColorSymbol *) alloca (size);
3434 memset (xpm_syms, 0, size);
3435 attrs.colorsymbols = xpm_syms;
3437 /* Fill the color symbol array. */
3438 for (tail = color_symbols, i = 0;
3439 CONSP (tail);
3440 ++i, tail = XCDR (tail))
3442 Lisp_Object name;
3443 Lisp_Object color;
3444 char *empty_string = (char *) "";
3446 if (!CONSP (XCAR (tail)))
3448 xpm_syms[i].name = empty_string;
3449 xpm_syms[i].value = empty_string;
3450 continue;
3452 name = XCAR (XCAR (tail));
3453 color = XCDR (XCAR (tail));
3454 if (STRINGP (name))
3456 xpm_syms[i].name = (char *) alloca (SCHARS (name) + 1);
3457 strcpy (xpm_syms[i].name, SSDATA (name));
3459 else
3460 xpm_syms[i].name = empty_string;
3461 if (STRINGP (color))
3463 xpm_syms[i].value = (char *) alloca (SCHARS (color) + 1);
3464 strcpy (xpm_syms[i].value, SSDATA (color));
3466 else
3467 xpm_syms[i].value = empty_string;
3471 /* Create a pixmap for the image, either from a file, or from a
3472 string buffer containing data in the same format as an XPM file. */
3473 #ifdef ALLOC_XPM_COLORS
3474 xpm_init_color_cache (f, &attrs);
3475 #endif
3477 specified_file = image_spec_value (img->spec, QCfile, NULL);
3479 #ifdef HAVE_NTGUI
3481 HDC frame_dc = get_frame_dc (f);
3482 hdc = CreateCompatibleDC (frame_dc);
3483 release_frame_dc (f, frame_dc);
3485 #endif /* HAVE_NTGUI */
3487 if (STRINGP (specified_file))
3489 Lisp_Object file = x_find_image_file (specified_file);
3490 if (!STRINGP (file))
3492 image_error ("Cannot find image file `%s'", specified_file, Qnil);
3493 #ifdef ALLOC_XPM_COLORS
3494 xpm_free_color_cache ();
3495 #endif
3496 return 0;
3499 #ifdef HAVE_NTGUI
3500 /* XpmReadFileToPixmap is not available in the Windows port of
3501 libxpm. But XpmReadFileToImage almost does what we want. */
3502 rc = fn_XpmReadFileToImage (&hdc, SDATA (file),
3503 &xpm_image, &xpm_mask,
3504 &attrs);
3505 #else
3506 rc = XpmReadFileToPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3507 SSDATA (file), &img->pixmap, &img->mask,
3508 &attrs);
3509 #endif /* HAVE_NTGUI */
3511 else
3513 Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
3514 if (!STRINGP (buffer))
3516 image_error ("Invalid image data `%s'", buffer, Qnil);
3517 #ifdef ALLOC_XPM_COLORS
3518 xpm_free_color_cache ();
3519 #endif
3520 return 0;
3522 #ifdef HAVE_NTGUI
3523 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3524 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3525 rc = fn_XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
3526 &xpm_image, &xpm_mask,
3527 &attrs);
3528 #else
3529 rc = XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3530 SSDATA (buffer),
3531 &img->pixmap, &img->mask,
3532 &attrs);
3533 #endif /* HAVE_NTGUI */
3536 if (rc == XpmSuccess)
3538 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3539 img->colors = colors_in_color_table (&img->ncolors);
3540 #else /* not ALLOC_XPM_COLORS */
3541 int i;
3543 #ifdef HAVE_NTGUI
3544 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3545 plus some duplicate attributes. */
3546 if (xpm_image && xpm_image->bitmap)
3548 img->pixmap = xpm_image->bitmap;
3549 /* XImageFree in libXpm frees XImage struct without destroying
3550 the bitmap, which is what we want. */
3551 fn_XImageFree (xpm_image);
3553 if (xpm_mask && xpm_mask->bitmap)
3555 /* The mask appears to be inverted compared with what we expect.
3556 TODO: invert our expectations. See other places where we
3557 have to invert bits because our idea of masks is backwards. */
3558 HGDIOBJ old_obj;
3559 old_obj = SelectObject (hdc, xpm_mask->bitmap);
3561 PatBlt (hdc, 0, 0, xpm_mask->width, xpm_mask->height, DSTINVERT);
3562 SelectObject (hdc, old_obj);
3564 img->mask = xpm_mask->bitmap;
3565 fn_XImageFree (xpm_mask);
3566 DeleteDC (hdc);
3569 DeleteDC (hdc);
3570 #endif /* HAVE_NTGUI */
3572 /* Remember allocated colors. */
3573 img->colors = xnmalloc (attrs.nalloc_pixels, sizeof *img->colors);
3574 img->ncolors = attrs.nalloc_pixels;
3575 for (i = 0; i < attrs.nalloc_pixels; ++i)
3577 img->colors[i] = attrs.alloc_pixels[i];
3578 #ifdef DEBUG_X_COLORS
3579 register_color (img->colors[i]);
3580 #endif
3582 #endif /* not ALLOC_XPM_COLORS */
3584 img->width = attrs.width;
3585 img->height = attrs.height;
3586 xassert (img->width > 0 && img->height > 0);
3588 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3589 #ifdef HAVE_NTGUI
3590 fn_XpmFreeAttributes (&attrs);
3591 #else
3592 XpmFreeAttributes (&attrs);
3593 #endif /* HAVE_NTGUI */
3595 else
3597 #ifdef HAVE_NTGUI
3598 DeleteDC (hdc);
3599 #endif /* HAVE_NTGUI */
3601 switch (rc)
3603 case XpmOpenFailed:
3604 image_error ("Error opening XPM file (%s)", img->spec, Qnil);
3605 break;
3607 case XpmFileInvalid:
3608 image_error ("Invalid XPM file (%s)", img->spec, Qnil);
3609 break;
3611 case XpmNoMemory:
3612 image_error ("Out of memory (%s)", img->spec, Qnil);
3613 break;
3615 case XpmColorFailed:
3616 image_error ("Color allocation error (%s)", img->spec, Qnil);
3617 break;
3619 default:
3620 image_error ("Unknown error (%s)", img->spec, Qnil);
3621 break;
3625 #ifdef ALLOC_XPM_COLORS
3626 xpm_free_color_cache ();
3627 #endif
3628 return rc == XpmSuccess;
3631 #endif /* HAVE_XPM */
3633 #if defined (HAVE_NS) && !defined (HAVE_XPM)
3635 /* XPM support functions for NS where libxpm is not available.
3636 Only XPM version 3 (without any extensions) is supported. */
3638 static void xpm_put_color_table_v (Lisp_Object, const unsigned char *,
3639 int, Lisp_Object);
3640 static Lisp_Object xpm_get_color_table_v (Lisp_Object,
3641 const unsigned char *, int);
3642 static void xpm_put_color_table_h (Lisp_Object, const unsigned char *,
3643 int, Lisp_Object);
3644 static Lisp_Object xpm_get_color_table_h (Lisp_Object,
3645 const unsigned char *, int);
3647 /* Tokens returned from xpm_scan. */
3649 enum xpm_token
3651 XPM_TK_IDENT = 256,
3652 XPM_TK_STRING,
3653 XPM_TK_EOF
3656 /* Scan an XPM data and return a character (< 256) or a token defined
3657 by enum xpm_token above. *S and END are the start (inclusive) and
3658 the end (exclusive) addresses of the data, respectively. Advance
3659 *S while scanning. If token is either XPM_TK_IDENT or
3660 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3661 length of the corresponding token, respectively. */
3663 static int
3664 xpm_scan (const unsigned char **s,
3665 const unsigned char *end,
3666 const unsigned char **beg,
3667 ptrdiff_t *len)
3669 int c;
3671 while (*s < end)
3673 /* Skip white-space. */
3674 while (*s < end && (c = *(*s)++, isspace (c)))
3677 /* gnus-pointer.xpm uses '-' in its identifier.
3678 sb-dir-plus.xpm uses '+' in its identifier. */
3679 if (isalpha (c) || c == '_' || c == '-' || c == '+')
3681 *beg = *s - 1;
3682 while (*s < end
3683 && (c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))
3684 ++*s;
3685 *len = *s - *beg;
3686 return XPM_TK_IDENT;
3688 else if (c == '"')
3690 *beg = *s;
3691 while (*s < end && **s != '"')
3692 ++*s;
3693 *len = *s - *beg;
3694 if (*s < end)
3695 ++*s;
3696 return XPM_TK_STRING;
3698 else if (c == '/')
3700 if (*s < end && **s == '*')
3702 /* C-style comment. */
3703 ++*s;
3706 while (*s < end && *(*s)++ != '*')
3709 while (*s < end && **s != '/');
3710 if (*s < end)
3711 ++*s;
3713 else
3714 return c;
3716 else
3717 return c;
3720 return XPM_TK_EOF;
3723 /* Functions for color table lookup in XPM data. A key is a string
3724 specifying the color of each pixel in XPM data. A value is either
3725 an integer that specifies a pixel color, Qt that specifies
3726 transparency, or Qnil for the unspecified color. If the length of
3727 the key string is one, a vector is used as a table. Otherwise, a
3728 hash table is used. */
3730 static Lisp_Object
3731 xpm_make_color_table_v (void (**put_func) (Lisp_Object,
3732 const unsigned char *,
3733 int,
3734 Lisp_Object),
3735 Lisp_Object (**get_func) (Lisp_Object,
3736 const unsigned char *,
3737 int))
3739 *put_func = xpm_put_color_table_v;
3740 *get_func = xpm_get_color_table_v;
3741 return Fmake_vector (make_number (256), Qnil);
3744 static void
3745 xpm_put_color_table_v (Lisp_Object color_table,
3746 const unsigned char *chars_start,
3747 int chars_len,
3748 Lisp_Object color)
3750 XVECTOR (color_table)->contents[*chars_start] = color;
3753 static Lisp_Object
3754 xpm_get_color_table_v (Lisp_Object color_table,
3755 const unsigned char *chars_start,
3756 int chars_len)
3758 return XVECTOR (color_table)->contents[*chars_start];
3761 static Lisp_Object
3762 xpm_make_color_table_h (void (**put_func) (Lisp_Object,
3763 const unsigned char *,
3764 int,
3765 Lisp_Object),
3766 Lisp_Object (**get_func) (Lisp_Object,
3767 const unsigned char *,
3768 int))
3770 *put_func = xpm_put_color_table_h;
3771 *get_func = xpm_get_color_table_h;
3772 return make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
3773 make_float (DEFAULT_REHASH_SIZE),
3774 make_float (DEFAULT_REHASH_THRESHOLD),
3775 Qnil, Qnil, Qnil);
3778 static void
3779 xpm_put_color_table_h (Lisp_Object color_table,
3780 const unsigned char *chars_start,
3781 int chars_len,
3782 Lisp_Object color)
3784 struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
3785 EMACS_UINT hash_code;
3786 Lisp_Object chars = make_unibyte_string (chars_start, chars_len);
3788 hash_lookup (table, chars, &hash_code);
3789 hash_put (table, chars, color, hash_code);
3792 static Lisp_Object
3793 xpm_get_color_table_h (Lisp_Object color_table,
3794 const unsigned char *chars_start,
3795 int chars_len)
3797 struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
3798 ptrdiff_t i =
3799 hash_lookup (table, make_unibyte_string (chars_start, chars_len), NULL);
3801 return i >= 0 ? HASH_VALUE (table, i) : Qnil;
3804 enum xpm_color_key {
3805 XPM_COLOR_KEY_S,
3806 XPM_COLOR_KEY_M,
3807 XPM_COLOR_KEY_G4,
3808 XPM_COLOR_KEY_G,
3809 XPM_COLOR_KEY_C
3812 static const char xpm_color_key_strings[][4] = {"s", "m", "g4", "g", "c"};
3814 static int
3815 xpm_str_to_color_key (const char *s)
3817 int i;
3819 for (i = 0;
3820 i < sizeof xpm_color_key_strings / sizeof xpm_color_key_strings[0];
3821 i++)
3822 if (strcmp (xpm_color_key_strings[i], s) == 0)
3823 return i;
3824 return -1;
3827 static int
3828 xpm_load_image (struct frame *f,
3829 struct image *img,
3830 const unsigned char *contents,
3831 const unsigned char *end)
3833 const unsigned char *s = contents, *beg, *str;
3834 unsigned char buffer[BUFSIZ];
3835 int width, height, x, y;
3836 int num_colors, chars_per_pixel;
3837 ptrdiff_t len;
3838 int LA1;
3839 void (*put_color_table) (Lisp_Object, const unsigned char *, int, Lisp_Object);
3840 Lisp_Object (*get_color_table) (Lisp_Object, const unsigned char *, int);
3841 Lisp_Object frame, color_symbols, color_table;
3842 int best_key, have_mask = 0;
3843 XImagePtr ximg = NULL, mask_img = NULL;
3845 #define match() \
3846 LA1 = xpm_scan (&s, end, &beg, &len)
3848 #define expect(TOKEN) \
3849 if (LA1 != (TOKEN)) \
3850 goto failure; \
3851 else \
3852 match ()
3854 #define expect_ident(IDENT) \
3855 if (LA1 == XPM_TK_IDENT \
3856 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
3857 match (); \
3858 else \
3859 goto failure
3861 if (!(end - s >= 9 && memcmp (s, "/* XPM */", 9) == 0))
3862 goto failure;
3863 s += 9;
3864 match ();
3865 expect_ident ("static");
3866 expect_ident ("char");
3867 expect ('*');
3868 expect (XPM_TK_IDENT);
3869 expect ('[');
3870 expect (']');
3871 expect ('=');
3872 expect ('{');
3873 expect (XPM_TK_STRING);
3874 if (len >= BUFSIZ)
3875 goto failure;
3876 memcpy (buffer, beg, len);
3877 buffer[len] = '\0';
3878 if (sscanf (buffer, "%d %d %d %d", &width, &height,
3879 &num_colors, &chars_per_pixel) != 4
3880 || width <= 0 || height <= 0
3881 || num_colors <= 0 || chars_per_pixel <= 0)
3882 goto failure;
3884 if (!check_image_size (f, width, height))
3886 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
3887 goto failure;
3890 if (!x_create_x_image_and_pixmap (f, width, height, 0,
3891 &ximg, &img->pixmap)
3892 #ifndef HAVE_NS
3893 || !x_create_x_image_and_pixmap (f, width, height, 1,
3894 &mask_img, &img->mask)
3895 #endif
3898 image_error ("Image too large", Qnil, Qnil);
3899 goto failure;
3902 expect (',');
3904 XSETFRAME (frame, f);
3905 if (!NILP (Fxw_display_color_p (frame)))
3906 best_key = XPM_COLOR_KEY_C;
3907 else if (!NILP (Fx_display_grayscale_p (frame)))
3908 best_key = (XFASTINT (Fx_display_planes (frame)) > 2
3909 ? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
3910 else
3911 best_key = XPM_COLOR_KEY_M;
3913 color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
3914 if (chars_per_pixel == 1)
3915 color_table = xpm_make_color_table_v (&put_color_table,
3916 &get_color_table);
3917 else
3918 color_table = xpm_make_color_table_h (&put_color_table,
3919 &get_color_table);
3921 while (num_colors-- > 0)
3923 char *color, *max_color;
3924 int key, next_key, max_key = 0;
3925 Lisp_Object symbol_color = Qnil, color_val;
3926 XColor cdef;
3928 expect (XPM_TK_STRING);
3929 if (len <= chars_per_pixel || len >= BUFSIZ + chars_per_pixel)
3930 goto failure;
3931 memcpy (buffer, beg + chars_per_pixel, len - chars_per_pixel);
3932 buffer[len - chars_per_pixel] = '\0';
3934 str = strtok (buffer, " \t");
3935 if (str == NULL)
3936 goto failure;
3937 key = xpm_str_to_color_key (str);
3938 if (key < 0)
3939 goto failure;
3942 color = strtok (NULL, " \t");
3943 if (color == NULL)
3944 goto failure;
3946 while ((str = strtok (NULL, " \t")) != NULL)
3948 next_key = xpm_str_to_color_key (str);
3949 if (next_key >= 0)
3950 break;
3951 color[strlen (color)] = ' ';
3954 if (key == XPM_COLOR_KEY_S)
3956 if (NILP (symbol_color))
3957 symbol_color = build_string (color);
3959 else if (max_key < key && key <= best_key)
3961 max_key = key;
3962 max_color = color;
3964 key = next_key;
3966 while (str);
3968 color_val = Qnil;
3969 if (!NILP (color_symbols) && !NILP (symbol_color))
3971 Lisp_Object specified_color = Fassoc (symbol_color, color_symbols);
3973 if (CONSP (specified_color) && STRINGP (XCDR (specified_color)))
3975 if (xstrcasecmp (SSDATA (XCDR (specified_color)), "None") == 0)
3976 color_val = Qt;
3977 else if (x_defined_color (f, SDATA (XCDR (specified_color)),
3978 &cdef, 0))
3979 color_val = make_number (cdef.pixel);
3982 if (NILP (color_val) && max_key > 0)
3984 if (xstrcasecmp (max_color, "None") == 0)
3985 color_val = Qt;
3986 else if (x_defined_color (f, max_color, &cdef, 0))
3987 color_val = make_number (cdef.pixel);
3989 if (!NILP (color_val))
3990 (*put_color_table) (color_table, beg, chars_per_pixel, color_val);
3992 expect (',');
3995 for (y = 0; y < height; y++)
3997 expect (XPM_TK_STRING);
3998 str = beg;
3999 if (len < width * chars_per_pixel)
4000 goto failure;
4001 for (x = 0; x < width; x++, str += chars_per_pixel)
4003 Lisp_Object color_val =
4004 (*get_color_table) (color_table, str, chars_per_pixel);
4006 XPutPixel (ximg, x, y,
4007 (INTEGERP (color_val) ? XINT (color_val)
4008 : FRAME_FOREGROUND_PIXEL (f)));
4009 #ifndef HAVE_NS
4010 XPutPixel (mask_img, x, y,
4011 (!EQ (color_val, Qt) ? PIX_MASK_DRAW
4012 : (have_mask = 1, PIX_MASK_RETAIN)));
4013 #else
4014 if (EQ (color_val, Qt))
4015 ns_set_alpha (ximg, x, y, 0);
4016 #endif
4018 if (y + 1 < height)
4019 expect (',');
4022 img->width = width;
4023 img->height = height;
4025 /* Maybe fill in the background field while we have ximg handy. */
4026 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
4027 IMAGE_BACKGROUND (img, f, ximg);
4029 x_put_x_image (f, ximg, img->pixmap, width, height);
4030 x_destroy_x_image (ximg);
4031 #ifndef HAVE_NS
4032 if (have_mask)
4034 /* Fill in the background_transparent field while we have the
4035 mask handy. */
4036 image_background_transparent (img, f, mask_img);
4038 x_put_x_image (f, mask_img, img->mask, width, height);
4039 x_destroy_x_image (mask_img);
4041 else
4043 x_destroy_x_image (mask_img);
4044 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
4045 img->mask = NO_PIXMAP;
4047 #endif
4048 return 1;
4050 failure:
4051 image_error ("Invalid XPM file (%s)", img->spec, Qnil);
4052 error:
4053 x_destroy_x_image (ximg);
4054 x_destroy_x_image (mask_img);
4055 x_clear_image (f, img);
4056 return 0;
4058 #undef match
4059 #undef expect
4060 #undef expect_ident
4063 static int
4064 xpm_load (struct frame *f,
4065 struct image *img)
4067 int success_p = 0;
4068 Lisp_Object file_name;
4070 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4071 file_name = image_spec_value (img->spec, QCfile, NULL);
4072 if (STRINGP (file_name))
4074 Lisp_Object file;
4075 unsigned char *contents;
4076 ptrdiff_t size;
4078 file = x_find_image_file (file_name);
4079 if (!STRINGP (file))
4081 image_error ("Cannot find image file `%s'", file_name, Qnil);
4082 return 0;
4085 contents = slurp_file (SDATA (file), &size);
4086 if (contents == NULL)
4088 image_error ("Error loading XPM image `%s'", img->spec, Qnil);
4089 return 0;
4092 success_p = xpm_load_image (f, img, contents, contents + size);
4093 xfree (contents);
4095 else
4097 Lisp_Object data;
4099 data = image_spec_value (img->spec, QCdata, NULL);
4100 if (!STRINGP (data))
4102 image_error ("Invalid image data `%s'", data, Qnil);
4103 return 0;
4105 success_p = xpm_load_image (f, img, SDATA (data),
4106 SDATA (data) + SBYTES (data));
4109 return success_p;
4112 #endif /* HAVE_NS && !HAVE_XPM */
4116 /***********************************************************************
4117 Color table
4118 ***********************************************************************/
4120 #ifdef COLOR_TABLE_SUPPORT
4122 /* An entry in the color table mapping an RGB color to a pixel color. */
4124 struct ct_color
4126 int r, g, b;
4127 unsigned long pixel;
4129 /* Next in color table collision list. */
4130 struct ct_color *next;
4133 /* The bucket vector size to use. Must be prime. */
4135 #define CT_SIZE 101
4137 /* Value is a hash of the RGB color given by R, G, and B. */
4139 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4141 /* The color hash table. */
4143 static struct ct_color **ct_table;
4145 /* Number of entries in the color table. */
4147 static int ct_colors_allocated;
4148 enum
4150 ct_colors_allocated_max =
4151 min (INT_MAX,
4152 min (PTRDIFF_MAX, SIZE_MAX) / sizeof (unsigned long))
4155 /* Initialize the color table. */
4157 static void
4158 init_color_table (void)
4160 int size = CT_SIZE * sizeof (*ct_table);
4161 ct_table = (struct ct_color **) xmalloc (size);
4162 memset (ct_table, 0, size);
4163 ct_colors_allocated = 0;
4167 /* Free memory associated with the color table. */
4169 static void
4170 free_color_table (void)
4172 int i;
4173 struct ct_color *p, *next;
4175 for (i = 0; i < CT_SIZE; ++i)
4176 for (p = ct_table[i]; p; p = next)
4178 next = p->next;
4179 xfree (p);
4182 xfree (ct_table);
4183 ct_table = NULL;
4187 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4188 entry for that color already is in the color table, return the
4189 pixel color of that entry. Otherwise, allocate a new color for R,
4190 G, B, and make an entry in the color table. */
4192 static unsigned long
4193 lookup_rgb_color (struct frame *f, int r, int g, int b)
4195 unsigned hash = CT_HASH_RGB (r, g, b);
4196 int i = hash % CT_SIZE;
4197 struct ct_color *p;
4198 Display_Info *dpyinfo;
4200 /* Handle TrueColor visuals specially, which improves performance by
4201 two orders of magnitude. Freeing colors on TrueColor visuals is
4202 a nop, and pixel colors specify RGB values directly. See also
4203 the Xlib spec, chapter 3.1. */
4204 dpyinfo = FRAME_X_DISPLAY_INFO (f);
4205 if (dpyinfo->red_bits > 0)
4207 unsigned long pr, pg, pb;
4209 /* Apply gamma-correction like normal color allocation does. */
4210 if (f->gamma)
4212 XColor color;
4213 color.red = r, color.green = g, color.blue = b;
4214 gamma_correct (f, &color);
4215 r = color.red, g = color.green, b = color.blue;
4218 /* Scale down RGB values to the visual's bits per RGB, and shift
4219 them to the right position in the pixel color. Note that the
4220 original RGB values are 16-bit values, as usual in X. */
4221 pr = (r >> (16 - dpyinfo->red_bits)) << dpyinfo->red_offset;
4222 pg = (g >> (16 - dpyinfo->green_bits)) << dpyinfo->green_offset;
4223 pb = (b >> (16 - dpyinfo->blue_bits)) << dpyinfo->blue_offset;
4225 /* Assemble the pixel color. */
4226 return pr | pg | pb;
4229 for (p = ct_table[i]; p; p = p->next)
4230 if (p->r == r && p->g == g && p->b == b)
4231 break;
4233 if (p == NULL)
4236 #ifdef HAVE_X_WINDOWS
4237 XColor color;
4238 Colormap cmap;
4239 int rc;
4240 #else
4241 COLORREF color;
4242 #endif
4244 if (ct_colors_allocated_max <= ct_colors_allocated)
4245 return FRAME_FOREGROUND_PIXEL (f);
4247 #ifdef HAVE_X_WINDOWS
4248 color.red = r;
4249 color.green = g;
4250 color.blue = b;
4252 cmap = FRAME_X_COLORMAP (f);
4253 rc = x_alloc_nearest_color (f, cmap, &color);
4254 if (rc)
4256 ++ct_colors_allocated;
4257 p = (struct ct_color *) xmalloc (sizeof *p);
4258 p->r = r;
4259 p->g = g;
4260 p->b = b;
4261 p->pixel = color.pixel;
4262 p->next = ct_table[i];
4263 ct_table[i] = p;
4265 else
4266 return FRAME_FOREGROUND_PIXEL (f);
4268 #else
4269 #ifdef HAVE_NTGUI
4270 color = PALETTERGB (r, g, b);
4271 #else
4272 color = RGB_TO_ULONG (r, g, b);
4273 #endif /* HAVE_NTGUI */
4274 ++ct_colors_allocated;
4275 p = (struct ct_color *) xmalloc (sizeof *p);
4276 p->r = r;
4277 p->g = g;
4278 p->b = b;
4279 p->pixel = color;
4280 p->next = ct_table[i];
4281 ct_table[i] = p;
4282 #endif /* HAVE_X_WINDOWS */
4286 return p->pixel;
4290 /* Look up pixel color PIXEL which is used on frame F in the color
4291 table. If not already present, allocate it. Value is PIXEL. */
4293 static unsigned long
4294 lookup_pixel_color (struct frame *f, unsigned long pixel)
4296 int i = pixel % CT_SIZE;
4297 struct ct_color *p;
4299 for (p = ct_table[i]; p; p = p->next)
4300 if (p->pixel == pixel)
4301 break;
4303 if (p == NULL)
4305 XColor color;
4306 Colormap cmap;
4307 int rc;
4309 if (ct_colors_allocated_max <= ct_colors_allocated)
4310 return FRAME_FOREGROUND_PIXEL (f);
4312 #ifdef HAVE_X_WINDOWS
4313 cmap = FRAME_X_COLORMAP (f);
4314 color.pixel = pixel;
4315 x_query_color (f, &color);
4316 rc = x_alloc_nearest_color (f, cmap, &color);
4317 #else
4318 BLOCK_INPUT;
4319 cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
4320 color.pixel = pixel;
4321 XQueryColor (NULL, cmap, &color);
4322 rc = x_alloc_nearest_color (f, cmap, &color);
4323 UNBLOCK_INPUT;
4324 #endif /* HAVE_X_WINDOWS */
4326 if (rc)
4328 ++ct_colors_allocated;
4330 p = (struct ct_color *) xmalloc (sizeof *p);
4331 p->r = color.red;
4332 p->g = color.green;
4333 p->b = color.blue;
4334 p->pixel = pixel;
4335 p->next = ct_table[i];
4336 ct_table[i] = p;
4338 else
4339 return FRAME_FOREGROUND_PIXEL (f);
4341 return p->pixel;
4345 /* Value is a vector of all pixel colors contained in the color table,
4346 allocated via xmalloc. Set *N to the number of colors. */
4348 static unsigned long *
4349 colors_in_color_table (int *n)
4351 int i, j;
4352 struct ct_color *p;
4353 unsigned long *colors;
4355 if (ct_colors_allocated == 0)
4357 *n = 0;
4358 colors = NULL;
4360 else
4362 colors = (unsigned long *) xmalloc (ct_colors_allocated
4363 * sizeof *colors);
4364 *n = ct_colors_allocated;
4366 for (i = j = 0; i < CT_SIZE; ++i)
4367 for (p = ct_table[i]; p; p = p->next)
4368 colors[j++] = p->pixel;
4371 return colors;
4374 #else /* COLOR_TABLE_SUPPORT */
4376 static unsigned long
4377 lookup_rgb_color (struct frame *f, int r, int g, int b)
4379 unsigned long pixel;
4381 #ifdef HAVE_NTGUI
4382 pixel = PALETTERGB (r >> 8, g >> 8, b >> 8);
4383 #endif /* HAVE_NTGUI */
4385 #ifdef HAVE_NS
4386 pixel = RGB_TO_ULONG (r >> 8, g >> 8, b >> 8);
4387 #endif /* HAVE_NS */
4388 return pixel;
4391 static void
4392 init_color_table (void)
4395 #endif /* COLOR_TABLE_SUPPORT */
4398 /***********************************************************************
4399 Algorithms
4400 ***********************************************************************/
4402 static XColor *x_to_xcolors (struct frame *, struct image *, int);
4403 static void x_from_xcolors (struct frame *, struct image *, XColor *);
4404 static void x_detect_edges (struct frame *, struct image *, int[9], int);
4406 #ifdef HAVE_NTGUI
4407 static void XPutPixel (XImagePtr , int, int, COLORREF);
4408 #endif /* HAVE_NTGUI */
4410 /* Edge detection matrices for different edge-detection
4411 strategies. */
4413 static int emboss_matrix[9] = {
4414 /* x - 1 x x + 1 */
4415 2, -1, 0, /* y - 1 */
4416 -1, 0, 1, /* y */
4417 0, 1, -2 /* y + 1 */
4420 static int laplace_matrix[9] = {
4421 /* x - 1 x x + 1 */
4422 1, 0, 0, /* y - 1 */
4423 0, 0, 0, /* y */
4424 0, 0, -1 /* y + 1 */
4427 /* Value is the intensity of the color whose red/green/blue values
4428 are R, G, and B. */
4430 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4433 /* On frame F, return an array of XColor structures describing image
4434 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4435 non-zero means also fill the red/green/blue members of the XColor
4436 structures. Value is a pointer to the array of XColors structures,
4437 allocated with xmalloc; it must be freed by the caller. */
4439 static XColor *
4440 x_to_xcolors (struct frame *f, struct image *img, int rgb_p)
4442 int x, y;
4443 XColor *colors, *p;
4444 XImagePtr_or_DC ximg;
4445 #ifdef HAVE_NTGUI
4446 HDC hdc;
4447 HGDIOBJ prev;
4448 #endif /* HAVE_NTGUI */
4450 if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *colors / img->width < img->height)
4451 memory_full (SIZE_MAX);
4452 colors = (XColor *) xmalloc (sizeof *colors * img->width * img->height);
4454 #ifndef HAVE_NTGUI
4455 /* Get the X image IMG->pixmap. */
4456 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
4457 0, 0, img->width, img->height, ~0, ZPixmap);
4458 #else
4459 /* Load the image into a memory device context. */
4460 hdc = get_frame_dc (f);
4461 ximg = CreateCompatibleDC (hdc);
4462 release_frame_dc (f, hdc);
4463 prev = SelectObject (ximg, img->pixmap);
4464 #endif /* HAVE_NTGUI */
4466 /* Fill the `pixel' members of the XColor array. I wished there
4467 were an easy and portable way to circumvent XGetPixel. */
4468 p = colors;
4469 for (y = 0; y < img->height; ++y)
4471 XColor *row = p;
4473 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
4474 for (x = 0; x < img->width; ++x, ++p)
4475 p->pixel = GET_PIXEL (ximg, x, y);
4476 if (rgb_p)
4477 x_query_colors (f, row, img->width);
4479 #else
4481 for (x = 0; x < img->width; ++x, ++p)
4483 /* W32_TODO: palette support needed here? */
4484 p->pixel = GET_PIXEL (ximg, x, y);
4485 if (rgb_p)
4487 p->red = RED16_FROM_ULONG (p->pixel);
4488 p->green = GREEN16_FROM_ULONG (p->pixel);
4489 p->blue = BLUE16_FROM_ULONG (p->pixel);
4492 #endif /* HAVE_X_WINDOWS */
4495 Destroy_Image (ximg, prev);
4497 return colors;
4500 #ifdef HAVE_NTGUI
4502 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4503 created with CreateDIBSection, with the pointer to the bit values
4504 stored in ximg->data. */
4506 static void
4507 XPutPixel (XImagePtr ximg, int x, int y, COLORREF color)
4509 int width = ximg->info.bmiHeader.biWidth;
4510 unsigned char * pixel;
4512 /* True color images. */
4513 if (ximg->info.bmiHeader.biBitCount == 24)
4515 int rowbytes = width * 3;
4516 /* Ensure scanlines are aligned on 4 byte boundaries. */
4517 if (rowbytes % 4)
4518 rowbytes += 4 - (rowbytes % 4);
4520 pixel = ximg->data + y * rowbytes + x * 3;
4521 /* Windows bitmaps are in BGR order. */
4522 *pixel = GetBValue (color);
4523 *(pixel + 1) = GetGValue (color);
4524 *(pixel + 2) = GetRValue (color);
4526 /* Monochrome images. */
4527 else if (ximg->info.bmiHeader.biBitCount == 1)
4529 int rowbytes = width / 8;
4530 /* Ensure scanlines are aligned on 4 byte boundaries. */
4531 if (rowbytes % 4)
4532 rowbytes += 4 - (rowbytes % 4);
4533 pixel = ximg->data + y * rowbytes + x / 8;
4534 /* Filter out palette info. */
4535 if (color & 0x00ffffff)
4536 *pixel = *pixel | (1 << x % 8);
4537 else
4538 *pixel = *pixel & ~(1 << x % 8);
4540 else
4541 image_error ("XPutPixel: palette image not supported", Qnil, Qnil);
4544 #endif /* HAVE_NTGUI */
4546 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4547 RGB members are set. F is the frame on which this all happens.
4548 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4550 static void
4551 x_from_xcolors (struct frame *f, struct image *img, XColor *colors)
4553 int x, y;
4554 XImagePtr oimg = NULL;
4555 Pixmap pixmap;
4556 XColor *p;
4558 init_color_table ();
4560 x_create_x_image_and_pixmap (f, img->width, img->height, 0,
4561 &oimg, &pixmap);
4562 p = colors;
4563 for (y = 0; y < img->height; ++y)
4564 for (x = 0; x < img->width; ++x, ++p)
4566 unsigned long pixel;
4567 pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
4568 XPutPixel (oimg, x, y, pixel);
4571 xfree (colors);
4572 x_clear_image_1 (f, img, 1, 0, 1);
4574 x_put_x_image (f, oimg, pixmap, img->width, img->height);
4575 x_destroy_x_image (oimg);
4576 img->pixmap = pixmap;
4577 #ifdef COLOR_TABLE_SUPPORT
4578 img->colors = colors_in_color_table (&img->ncolors);
4579 free_color_table ();
4580 #endif /* COLOR_TABLE_SUPPORT */
4584 /* On frame F, perform edge-detection on image IMG.
4586 MATRIX is a nine-element array specifying the transformation
4587 matrix. See emboss_matrix for an example.
4589 COLOR_ADJUST is a color adjustment added to each pixel of the
4590 outgoing image. */
4592 static void
4593 x_detect_edges (struct frame *f, struct image *img, int *matrix, int color_adjust)
4595 XColor *colors = x_to_xcolors (f, img, 1);
4596 XColor *new, *p;
4597 int x, y, i, sum;
4599 for (i = sum = 0; i < 9; ++i)
4600 sum += eabs (matrix[i]);
4602 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4604 if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *new / img->width < img->height)
4605 memory_full (SIZE_MAX);
4606 new = (XColor *) xmalloc (sizeof *new * img->width * img->height);
4608 for (y = 0; y < img->height; ++y)
4610 p = COLOR (new, 0, y);
4611 p->red = p->green = p->blue = 0xffff/2;
4612 p = COLOR (new, img->width - 1, y);
4613 p->red = p->green = p->blue = 0xffff/2;
4616 for (x = 1; x < img->width - 1; ++x)
4618 p = COLOR (new, x, 0);
4619 p->red = p->green = p->blue = 0xffff/2;
4620 p = COLOR (new, x, img->height - 1);
4621 p->red = p->green = p->blue = 0xffff/2;
4624 for (y = 1; y < img->height - 1; ++y)
4626 p = COLOR (new, 1, y);
4628 for (x = 1; x < img->width - 1; ++x, ++p)
4630 int r, g, b, yy, xx;
4632 r = g = b = i = 0;
4633 for (yy = y - 1; yy < y + 2; ++yy)
4634 for (xx = x - 1; xx < x + 2; ++xx, ++i)
4635 if (matrix[i])
4637 XColor *t = COLOR (colors, xx, yy);
4638 r += matrix[i] * t->red;
4639 g += matrix[i] * t->green;
4640 b += matrix[i] * t->blue;
4643 r = (r / sum + color_adjust) & 0xffff;
4644 g = (g / sum + color_adjust) & 0xffff;
4645 b = (b / sum + color_adjust) & 0xffff;
4646 p->red = p->green = p->blue = COLOR_INTENSITY (r, g, b);
4650 xfree (colors);
4651 x_from_xcolors (f, img, new);
4653 #undef COLOR
4657 /* Perform the pre-defined `emboss' edge-detection on image IMG
4658 on frame F. */
4660 static void
4661 x_emboss (struct frame *f, struct image *img)
4663 x_detect_edges (f, img, emboss_matrix, 0xffff / 2);
4667 /* Transform image IMG which is used on frame F with a Laplace
4668 edge-detection algorithm. The result is an image that can be used
4669 to draw disabled buttons, for example. */
4671 static void
4672 x_laplace (struct frame *f, struct image *img)
4674 x_detect_edges (f, img, laplace_matrix, 45000);
4678 /* Perform edge-detection on image IMG on frame F, with specified
4679 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4681 MATRIX must be either
4683 - a list of at least 9 numbers in row-major form
4684 - a vector of at least 9 numbers
4686 COLOR_ADJUST nil means use a default; otherwise it must be a
4687 number. */
4689 static void
4690 x_edge_detection (struct frame *f, struct image *img, Lisp_Object matrix,
4691 Lisp_Object color_adjust)
4693 int i = 0;
4694 int trans[9];
4696 if (CONSP (matrix))
4698 for (i = 0;
4699 i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
4700 ++i, matrix = XCDR (matrix))
4701 trans[i] = XFLOATINT (XCAR (matrix));
4703 else if (VECTORP (matrix) && ASIZE (matrix) >= 9)
4705 for (i = 0; i < 9 && NUMBERP (AREF (matrix, i)); ++i)
4706 trans[i] = XFLOATINT (AREF (matrix, i));
4709 if (NILP (color_adjust))
4710 color_adjust = make_number (0xffff / 2);
4712 if (i == 9 && NUMBERP (color_adjust))
4713 x_detect_edges (f, img, trans, XFLOATINT (color_adjust));
4717 /* Transform image IMG on frame F so that it looks disabled. */
4719 static void
4720 x_disable_image (struct frame *f, struct image *img)
4722 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
4723 #ifdef HAVE_NTGUI
4724 int n_planes = dpyinfo->n_planes * dpyinfo->n_cbits;
4725 #else
4726 int n_planes = dpyinfo->n_planes;
4727 #endif /* HAVE_NTGUI */
4729 if (n_planes >= 2)
4731 /* Color (or grayscale). Convert to gray, and equalize. Just
4732 drawing such images with a stipple can look very odd, so
4733 we're using this method instead. */
4734 XColor *colors = x_to_xcolors (f, img, 1);
4735 XColor *p, *end;
4736 const int h = 15000;
4737 const int l = 30000;
4739 for (p = colors, end = colors + img->width * img->height;
4740 p < end;
4741 ++p)
4743 int i = COLOR_INTENSITY (p->red, p->green, p->blue);
4744 int i2 = (0xffff - h - l) * i / 0xffff + l;
4745 p->red = p->green = p->blue = i2;
4748 x_from_xcolors (f, img, colors);
4751 /* Draw a cross over the disabled image, if we must or if we
4752 should. */
4753 if (n_planes < 2 || cross_disabled_images)
4755 #ifndef HAVE_NTGUI
4756 Display *dpy = FRAME_X_DISPLAY (f);
4757 GC gc;
4759 #ifndef HAVE_NS /* TODO: NS support, however this not needed for toolbars */
4761 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4763 gc = XCreateGC (dpy, img->pixmap, 0, NULL);
4764 XSetForeground (dpy, gc, BLACK_PIX_DEFAULT (f));
4765 XDrawLine (dpy, img->pixmap, gc, 0, 0,
4766 img->width - 1, img->height - 1);
4767 XDrawLine (dpy, img->pixmap, gc, 0, img->height - 1,
4768 img->width - 1, 0);
4769 XFreeGC (dpy, gc);
4771 if (img->mask)
4773 gc = XCreateGC (dpy, img->mask, 0, NULL);
4774 XSetForeground (dpy, gc, MaskForeground (f));
4775 XDrawLine (dpy, img->mask, gc, 0, 0,
4776 img->width - 1, img->height - 1);
4777 XDrawLine (dpy, img->mask, gc, 0, img->height - 1,
4778 img->width - 1, 0);
4779 XFreeGC (dpy, gc);
4781 #endif /* !HAVE_NS */
4782 #else
4783 HDC hdc, bmpdc;
4784 HGDIOBJ prev;
4786 hdc = get_frame_dc (f);
4787 bmpdc = CreateCompatibleDC (hdc);
4788 release_frame_dc (f, hdc);
4790 prev = SelectObject (bmpdc, img->pixmap);
4792 SetTextColor (bmpdc, BLACK_PIX_DEFAULT (f));
4793 MoveToEx (bmpdc, 0, 0, NULL);
4794 LineTo (bmpdc, img->width - 1, img->height - 1);
4795 MoveToEx (bmpdc, 0, img->height - 1, NULL);
4796 LineTo (bmpdc, img->width - 1, 0);
4798 if (img->mask)
4800 SelectObject (bmpdc, img->mask);
4801 SetTextColor (bmpdc, WHITE_PIX_DEFAULT (f));
4802 MoveToEx (bmpdc, 0, 0, NULL);
4803 LineTo (bmpdc, img->width - 1, img->height - 1);
4804 MoveToEx (bmpdc, 0, img->height - 1, NULL);
4805 LineTo (bmpdc, img->width - 1, 0);
4807 SelectObject (bmpdc, prev);
4808 DeleteDC (bmpdc);
4809 #endif /* HAVE_NTGUI */
4814 /* Build a mask for image IMG which is used on frame F. FILE is the
4815 name of an image file, for error messages. HOW determines how to
4816 determine the background color of IMG. If it is a list '(R G B)',
4817 with R, G, and B being integers >= 0, take that as the color of the
4818 background. Otherwise, determine the background color of IMG
4819 heuristically. Value is non-zero if successful. */
4821 static int
4822 x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
4824 XImagePtr_or_DC ximg;
4825 #ifndef HAVE_NTGUI
4826 XImagePtr mask_img;
4827 #else
4828 HDC frame_dc;
4829 HGDIOBJ prev;
4830 char *mask_img;
4831 int row_width;
4832 #endif /* HAVE_NTGUI */
4833 int x, y, rc, use_img_background;
4834 unsigned long bg = 0;
4836 if (img->mask)
4838 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
4839 img->mask = NO_PIXMAP;
4840 img->background_transparent_valid = 0;
4843 #ifndef HAVE_NTGUI
4844 #ifndef HAVE_NS
4845 /* Create an image and pixmap serving as mask. */
4846 rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
4847 &mask_img, &img->mask);
4848 if (!rc)
4849 return 0;
4850 #endif /* !HAVE_NS */
4852 /* Get the X image of IMG->pixmap. */
4853 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap, 0, 0,
4854 img->width, img->height,
4855 ~0, ZPixmap);
4856 #else
4857 /* Create the bit array serving as mask. */
4858 row_width = (img->width + 7) / 8;
4859 mask_img = xmalloc (row_width * img->height);
4860 memset (mask_img, 0, row_width * img->height);
4862 /* Create a memory device context for IMG->pixmap. */
4863 frame_dc = get_frame_dc (f);
4864 ximg = CreateCompatibleDC (frame_dc);
4865 release_frame_dc (f, frame_dc);
4866 prev = SelectObject (ximg, img->pixmap);
4867 #endif /* HAVE_NTGUI */
4869 /* Determine the background color of ximg. If HOW is `(R G B)'
4870 take that as color. Otherwise, use the image's background color. */
4871 use_img_background = 1;
4873 if (CONSP (how))
4875 int rgb[3], i;
4877 for (i = 0; i < 3 && CONSP (how) && NATNUMP (XCAR (how)); ++i)
4879 rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
4880 how = XCDR (how);
4883 if (i == 3 && NILP (how))
4885 char color_name[30];
4886 sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
4887 bg = (
4888 #ifdef HAVE_NTGUI
4889 0x00ffffff & /* Filter out palette info. */
4890 #endif /* HAVE_NTGUI */
4891 x_alloc_image_color (f, img, build_string (color_name), 0));
4892 use_img_background = 0;
4896 if (use_img_background)
4897 bg = four_corners_best (ximg, img->corners, img->width, img->height);
4899 /* Set all bits in mask_img to 1 whose color in ximg is different
4900 from the background color bg. */
4901 #ifndef HAVE_NTGUI
4902 for (y = 0; y < img->height; ++y)
4903 for (x = 0; x < img->width; ++x)
4904 #ifndef HAVE_NS
4905 XPutPixel (mask_img, x, y, (XGetPixel (ximg, x, y) != bg
4906 ? PIX_MASK_DRAW : PIX_MASK_RETAIN));
4907 #else
4908 if (XGetPixel (ximg, x, y) == bg)
4909 ns_set_alpha (ximg, x, y, 0);
4910 #endif /* HAVE_NS */
4911 #ifndef HAVE_NS
4912 /* Fill in the background_transparent field while we have the mask handy. */
4913 image_background_transparent (img, f, mask_img);
4915 /* Put mask_img into img->mask. */
4916 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
4917 x_destroy_x_image (mask_img);
4918 #endif /* !HAVE_NS */
4919 #else
4920 for (y = 0; y < img->height; ++y)
4921 for (x = 0; x < img->width; ++x)
4923 COLORREF p = GetPixel (ximg, x, y);
4924 if (p != bg)
4925 mask_img[y * row_width + x / 8] |= 1 << (x % 8);
4928 /* Create the mask image. */
4929 img->mask = w32_create_pixmap_from_bitmap_data (img->width, img->height,
4930 mask_img);
4931 /* Fill in the background_transparent field while we have the mask handy. */
4932 SelectObject (ximg, img->mask);
4933 image_background_transparent (img, f, ximg);
4935 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
4936 xfree (mask_img);
4937 #endif /* HAVE_NTGUI */
4939 Destroy_Image (ximg, prev);
4941 return 1;
4945 /***********************************************************************
4946 PBM (mono, gray, color)
4947 ***********************************************************************/
4949 static int pbm_image_p (Lisp_Object object);
4950 static int pbm_load (struct frame *f, struct image *img);
4951 static int pbm_scan_number (unsigned char **, unsigned char *);
4953 /* The symbol `pbm' identifying images of this type. */
4955 static Lisp_Object Qpbm;
4957 /* Indices of image specification fields in gs_format, below. */
4959 enum pbm_keyword_index
4961 PBM_TYPE,
4962 PBM_FILE,
4963 PBM_DATA,
4964 PBM_ASCENT,
4965 PBM_MARGIN,
4966 PBM_RELIEF,
4967 PBM_ALGORITHM,
4968 PBM_HEURISTIC_MASK,
4969 PBM_MASK,
4970 PBM_FOREGROUND,
4971 PBM_BACKGROUND,
4972 PBM_LAST
4975 /* Vector of image_keyword structures describing the format
4976 of valid user-defined image specifications. */
4978 static const struct image_keyword pbm_format[PBM_LAST] =
4980 {":type", IMAGE_SYMBOL_VALUE, 1},
4981 {":file", IMAGE_STRING_VALUE, 0},
4982 {":data", IMAGE_STRING_VALUE, 0},
4983 {":ascent", IMAGE_ASCENT_VALUE, 0},
4984 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
4985 {":relief", IMAGE_INTEGER_VALUE, 0},
4986 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
4987 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
4988 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
4989 {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
4990 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
4993 /* Structure describing the image type `pbm'. */
4995 static struct image_type pbm_type =
4997 &Qpbm,
4998 pbm_image_p,
4999 pbm_load,
5000 x_clear_image,
5001 NULL
5005 /* Return non-zero if OBJECT is a valid PBM image specification. */
5007 static int
5008 pbm_image_p (Lisp_Object object)
5010 struct image_keyword fmt[PBM_LAST];
5012 memcpy (fmt, pbm_format, sizeof fmt);
5014 if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm))
5015 return 0;
5017 /* Must specify either :data or :file. */
5018 return fmt[PBM_DATA].count + fmt[PBM_FILE].count == 1;
5022 /* Scan a decimal number from *S and return it. Advance *S while
5023 reading the number. END is the end of the string. Value is -1 at
5024 end of input. */
5026 static int
5027 pbm_scan_number (unsigned char **s, unsigned char *end)
5029 int c = 0, val = -1;
5031 while (*s < end)
5033 /* Skip white-space. */
5034 while (*s < end && (c = *(*s)++, isspace (c)))
5037 if (c == '#')
5039 /* Skip comment to end of line. */
5040 while (*s < end && (c = *(*s)++, c != '\n'))
5043 else if (isdigit (c))
5045 /* Read decimal number. */
5046 val = c - '0';
5047 while (*s < end && (c = *(*s)++, isdigit (c)))
5048 val = 10 * val + c - '0';
5049 break;
5051 else
5052 break;
5055 return val;
5059 #ifdef HAVE_NTGUI
5060 #if 0 /* Unused. ++kfs */
5062 /* Read FILE into memory. Value is a pointer to a buffer allocated
5063 with xmalloc holding FILE's contents. Value is null if an error
5064 occurred. *SIZE is set to the size of the file. */
5066 static char *
5067 pbm_read_file (Lisp_Object file, int *size)
5069 FILE *fp = NULL;
5070 char *buf = NULL;
5071 struct stat st;
5073 if (stat (SDATA (file), &st) == 0
5074 && (fp = fopen (SDATA (file), "rb")) != NULL
5075 && 0 <= st.st_size && st.st_size <= min (PTRDIFF_MAX, SIZE_MAX)
5076 && (buf = (char *) xmalloc (st.st_size),
5077 fread (buf, 1, st.st_size, fp) == st.st_size))
5079 *size = st.st_size;
5080 fclose (fp);
5082 else
5084 if (fp)
5085 fclose (fp);
5086 if (buf)
5088 xfree (buf);
5089 buf = NULL;
5093 return buf;
5095 #endif
5096 #endif /* HAVE_NTGUI */
5098 /* Load PBM image IMG for use on frame F. */
5100 static int
5101 pbm_load (struct frame *f, struct image *img)
5103 int raw_p, x, y;
5104 int width, height, max_color_idx = 0;
5105 XImagePtr ximg;
5106 Lisp_Object file, specified_file;
5107 enum {PBM_MONO, PBM_GRAY, PBM_COLOR} type;
5108 unsigned char *contents = NULL;
5109 unsigned char *end, *p;
5110 ptrdiff_t size;
5112 specified_file = image_spec_value (img->spec, QCfile, NULL);
5114 if (STRINGP (specified_file))
5116 file = x_find_image_file (specified_file);
5117 if (!STRINGP (file))
5119 image_error ("Cannot find image file `%s'", specified_file, Qnil);
5120 return 0;
5123 contents = slurp_file (SSDATA (file), &size);
5124 if (contents == NULL)
5126 image_error ("Error reading `%s'", file, Qnil);
5127 return 0;
5130 p = contents;
5131 end = contents + size;
5133 else
5135 Lisp_Object data;
5136 data = image_spec_value (img->spec, QCdata, NULL);
5137 if (!STRINGP (data))
5139 image_error ("Invalid image data `%s'", data, Qnil);
5140 return 0;
5142 p = SDATA (data);
5143 end = p + SBYTES (data);
5146 /* Check magic number. */
5147 if (end - p < 2 || *p++ != 'P')
5149 image_error ("Not a PBM image: `%s'", img->spec, Qnil);
5150 error:
5151 xfree (contents);
5152 return 0;
5155 switch (*p++)
5157 case '1':
5158 raw_p = 0, type = PBM_MONO;
5159 break;
5161 case '2':
5162 raw_p = 0, type = PBM_GRAY;
5163 break;
5165 case '3':
5166 raw_p = 0, type = PBM_COLOR;
5167 break;
5169 case '4':
5170 raw_p = 1, type = PBM_MONO;
5171 break;
5173 case '5':
5174 raw_p = 1, type = PBM_GRAY;
5175 break;
5177 case '6':
5178 raw_p = 1, type = PBM_COLOR;
5179 break;
5181 default:
5182 image_error ("Not a PBM image: `%s'", img->spec, Qnil);
5183 goto error;
5186 /* Read width, height, maximum color-component. Characters
5187 starting with `#' up to the end of a line are ignored. */
5188 width = pbm_scan_number (&p, end);
5189 height = pbm_scan_number (&p, end);
5191 if (type != PBM_MONO)
5193 max_color_idx = pbm_scan_number (&p, end);
5194 if (max_color_idx > 65535 || max_color_idx < 0)
5196 image_error ("Unsupported maximum PBM color value", Qnil, Qnil);
5197 goto error;
5201 if (!check_image_size (f, width, height))
5203 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
5204 goto error;
5207 if (!x_create_x_image_and_pixmap (f, width, height, 0,
5208 &ximg, &img->pixmap))
5209 goto error;
5211 /* Initialize the color hash table. */
5212 init_color_table ();
5214 if (type == PBM_MONO)
5216 int c = 0, g;
5217 struct image_keyword fmt[PBM_LAST];
5218 unsigned long fg = FRAME_FOREGROUND_PIXEL (f);
5219 unsigned long bg = FRAME_BACKGROUND_PIXEL (f);
5221 /* Parse the image specification. */
5222 memcpy (fmt, pbm_format, sizeof fmt);
5223 parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
5225 /* Get foreground and background colors, maybe allocate colors. */
5226 if (fmt[PBM_FOREGROUND].count
5227 && STRINGP (fmt[PBM_FOREGROUND].value))
5228 fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
5229 if (fmt[PBM_BACKGROUND].count
5230 && STRINGP (fmt[PBM_BACKGROUND].value))
5232 bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
5233 img->background = bg;
5234 img->background_valid = 1;
5237 for (y = 0; y < height; ++y)
5238 for (x = 0; x < width; ++x)
5240 if (raw_p)
5242 if ((x & 7) == 0)
5244 if (p >= end)
5246 x_destroy_x_image (ximg);
5247 x_clear_image (f, img);
5248 image_error ("Invalid image size in image `%s'",
5249 img->spec, Qnil);
5250 goto error;
5252 c = *p++;
5254 g = c & 0x80;
5255 c <<= 1;
5257 else
5258 g = pbm_scan_number (&p, end);
5260 XPutPixel (ximg, x, y, g ? fg : bg);
5263 else
5265 int expected_size = height * width;
5266 if (max_color_idx > 255)
5267 expected_size *= 2;
5268 if (type == PBM_COLOR)
5269 expected_size *= 3;
5271 if (raw_p && p + expected_size > end)
5273 x_destroy_x_image (ximg);
5274 x_clear_image (f, img);
5275 image_error ("Invalid image size in image `%s'",
5276 img->spec, Qnil);
5277 goto error;
5280 for (y = 0; y < height; ++y)
5281 for (x = 0; x < width; ++x)
5283 int r, g, b;
5285 if (type == PBM_GRAY && raw_p)
5287 r = g = b = *p++;
5288 if (max_color_idx > 255)
5289 r = g = b = r * 256 + *p++;
5291 else if (type == PBM_GRAY)
5292 r = g = b = pbm_scan_number (&p, end);
5293 else if (raw_p)
5295 r = *p++;
5296 if (max_color_idx > 255)
5297 r = r * 256 + *p++;
5298 g = *p++;
5299 if (max_color_idx > 255)
5300 g = g * 256 + *p++;
5301 b = *p++;
5302 if (max_color_idx > 255)
5303 b = b * 256 + *p++;
5305 else
5307 r = pbm_scan_number (&p, end);
5308 g = pbm_scan_number (&p, end);
5309 b = pbm_scan_number (&p, end);
5312 if (r < 0 || g < 0 || b < 0)
5314 x_destroy_x_image (ximg);
5315 image_error ("Invalid pixel value in image `%s'",
5316 img->spec, Qnil);
5317 goto error;
5320 /* RGB values are now in the range 0..max_color_idx.
5321 Scale this to the range 0..0xffff supported by X. */
5322 r = (double) r * 65535 / max_color_idx;
5323 g = (double) g * 65535 / max_color_idx;
5324 b = (double) b * 65535 / max_color_idx;
5325 XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
5329 #ifdef COLOR_TABLE_SUPPORT
5330 /* Store in IMG->colors the colors allocated for the image, and
5331 free the color table. */
5332 img->colors = colors_in_color_table (&img->ncolors);
5333 free_color_table ();
5334 #endif /* COLOR_TABLE_SUPPORT */
5336 img->width = width;
5337 img->height = height;
5339 /* Maybe fill in the background field while we have ximg handy. */
5341 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
5342 /* Casting avoids a GCC warning. */
5343 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
5345 /* Put the image into a pixmap. */
5346 x_put_x_image (f, ximg, img->pixmap, width, height);
5347 x_destroy_x_image (ximg);
5349 /* X and W32 versions did it here, MAC version above. ++kfs
5350 img->width = width;
5351 img->height = height; */
5353 xfree (contents);
5354 return 1;
5358 /***********************************************************************
5360 ***********************************************************************/
5362 #if defined (HAVE_PNG) || defined (HAVE_NS)
5364 /* Function prototypes. */
5366 static int png_image_p (Lisp_Object object);
5367 static int png_load (struct frame *f, struct image *img);
5369 /* The symbol `png' identifying images of this type. */
5371 static Lisp_Object Qpng;
5373 /* Indices of image specification fields in png_format, below. */
5375 enum png_keyword_index
5377 PNG_TYPE,
5378 PNG_DATA,
5379 PNG_FILE,
5380 PNG_ASCENT,
5381 PNG_MARGIN,
5382 PNG_RELIEF,
5383 PNG_ALGORITHM,
5384 PNG_HEURISTIC_MASK,
5385 PNG_MASK,
5386 PNG_BACKGROUND,
5387 PNG_LAST
5390 /* Vector of image_keyword structures describing the format
5391 of valid user-defined image specifications. */
5393 static const struct image_keyword png_format[PNG_LAST] =
5395 {":type", IMAGE_SYMBOL_VALUE, 1},
5396 {":data", IMAGE_STRING_VALUE, 0},
5397 {":file", IMAGE_STRING_VALUE, 0},
5398 {":ascent", IMAGE_ASCENT_VALUE, 0},
5399 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
5400 {":relief", IMAGE_INTEGER_VALUE, 0},
5401 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5402 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5403 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5404 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
5407 /* Structure describing the image type `png'. */
5409 static struct image_type png_type =
5411 &Qpng,
5412 png_image_p,
5413 png_load,
5414 x_clear_image,
5415 NULL
5418 /* Return non-zero if OBJECT is a valid PNG image specification. */
5420 static int
5421 png_image_p (Lisp_Object object)
5423 struct image_keyword fmt[PNG_LAST];
5424 memcpy (fmt, png_format, sizeof fmt);
5426 if (!parse_image_spec (object, fmt, PNG_LAST, Qpng))
5427 return 0;
5429 /* Must specify either the :data or :file keyword. */
5430 return fmt[PNG_FILE].count + fmt[PNG_DATA].count == 1;
5433 #endif /* HAVE_PNG || HAVE_NS */
5436 #ifdef HAVE_PNG
5438 #ifdef HAVE_NTGUI
5439 /* PNG library details. */
5441 DEF_IMGLIB_FN (png_voidp, png_get_io_ptr, (png_structp));
5442 DEF_IMGLIB_FN (int, png_sig_cmp, (png_bytep, png_size_t, png_size_t));
5443 DEF_IMGLIB_FN (png_structp, png_create_read_struct, (png_const_charp, png_voidp,
5444 png_error_ptr, png_error_ptr));
5445 DEF_IMGLIB_FN (png_infop, png_create_info_struct, (png_structp));
5446 DEF_IMGLIB_FN (void, png_destroy_read_struct, (png_structpp, png_infopp, png_infopp));
5447 DEF_IMGLIB_FN (void, png_set_read_fn, (png_structp, png_voidp, png_rw_ptr));
5448 DEF_IMGLIB_FN (void, png_set_sig_bytes, (png_structp, int));
5449 DEF_IMGLIB_FN (void, png_read_info, (png_structp, png_infop));
5450 DEF_IMGLIB_FN (png_uint_32, png_get_IHDR, (png_structp, png_infop,
5451 png_uint_32 *, png_uint_32 *,
5452 int *, int *, int *, int *, int *));
5453 DEF_IMGLIB_FN (png_uint_32, png_get_valid, (png_structp, png_infop, png_uint_32));
5454 DEF_IMGLIB_FN (void, png_set_strip_16, (png_structp));
5455 DEF_IMGLIB_FN (void, png_set_expand, (png_structp));
5456 DEF_IMGLIB_FN (void, png_set_gray_to_rgb, (png_structp));
5457 DEF_IMGLIB_FN (void, png_set_background, (png_structp, png_color_16p,
5458 int, int, double));
5459 DEF_IMGLIB_FN (png_uint_32, png_get_bKGD, (png_structp, png_infop, png_color_16p *));
5460 DEF_IMGLIB_FN (void, png_read_update_info, (png_structp, png_infop));
5461 DEF_IMGLIB_FN (png_byte, png_get_channels, (png_structp, png_infop));
5462 DEF_IMGLIB_FN (png_size_t, png_get_rowbytes, (png_structp, png_infop));
5463 DEF_IMGLIB_FN (void, png_read_image, (png_structp, png_bytepp));
5464 DEF_IMGLIB_FN (void, png_read_end, (png_structp, png_infop));
5465 DEF_IMGLIB_FN (void, png_error, (png_structp, png_const_charp));
5467 #if (PNG_LIBPNG_VER >= 10500)
5468 DEF_IMGLIB_FN (void, png_longjmp, (png_structp, int));
5469 DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn, (png_structp, png_longjmp_ptr, size_t));
5470 #endif /* libpng version >= 1.5 */
5472 static int
5473 init_png_functions (Lisp_Object libraries)
5475 HMODULE library;
5477 if (!(library = w32_delayed_load (libraries, Qpng)))
5478 return 0;
5480 LOAD_IMGLIB_FN (library, png_get_io_ptr);
5481 LOAD_IMGLIB_FN (library, png_sig_cmp);
5482 LOAD_IMGLIB_FN (library, png_create_read_struct);
5483 LOAD_IMGLIB_FN (library, png_create_info_struct);
5484 LOAD_IMGLIB_FN (library, png_destroy_read_struct);
5485 LOAD_IMGLIB_FN (library, png_set_read_fn);
5486 LOAD_IMGLIB_FN (library, png_set_sig_bytes);
5487 LOAD_IMGLIB_FN (library, png_read_info);
5488 LOAD_IMGLIB_FN (library, png_get_IHDR);
5489 LOAD_IMGLIB_FN (library, png_get_valid);
5490 LOAD_IMGLIB_FN (library, png_set_strip_16);
5491 LOAD_IMGLIB_FN (library, png_set_expand);
5492 LOAD_IMGLIB_FN (library, png_set_gray_to_rgb);
5493 LOAD_IMGLIB_FN (library, png_set_background);
5494 LOAD_IMGLIB_FN (library, png_get_bKGD);
5495 LOAD_IMGLIB_FN (library, png_read_update_info);
5496 LOAD_IMGLIB_FN (library, png_get_channels);
5497 LOAD_IMGLIB_FN (library, png_get_rowbytes);
5498 LOAD_IMGLIB_FN (library, png_read_image);
5499 LOAD_IMGLIB_FN (library, png_read_end);
5500 LOAD_IMGLIB_FN (library, png_error);
5502 #if (PNG_LIBPNG_VER >= 10500)
5503 LOAD_IMGLIB_FN (library, png_longjmp);
5504 LOAD_IMGLIB_FN (library, png_set_longjmp_fn);
5505 #endif /* libpng version >= 1.5 */
5507 return 1;
5509 #else
5511 #define fn_png_get_io_ptr png_get_io_ptr
5512 #define fn_png_sig_cmp png_sig_cmp
5513 #define fn_png_create_read_struct png_create_read_struct
5514 #define fn_png_create_info_struct png_create_info_struct
5515 #define fn_png_destroy_read_struct png_destroy_read_struct
5516 #define fn_png_set_read_fn png_set_read_fn
5517 #define fn_png_set_sig_bytes png_set_sig_bytes
5518 #define fn_png_read_info png_read_info
5519 #define fn_png_get_IHDR png_get_IHDR
5520 #define fn_png_get_valid png_get_valid
5521 #define fn_png_set_strip_16 png_set_strip_16
5522 #define fn_png_set_expand png_set_expand
5523 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5524 #define fn_png_set_background png_set_background
5525 #define fn_png_get_bKGD png_get_bKGD
5526 #define fn_png_read_update_info png_read_update_info
5527 #define fn_png_get_channels png_get_channels
5528 #define fn_png_get_rowbytes png_get_rowbytes
5529 #define fn_png_read_image png_read_image
5530 #define fn_png_read_end png_read_end
5531 #define fn_png_error png_error
5533 #if (PNG_LIBPNG_VER >= 10500)
5534 #define fn_png_longjmp png_longjmp
5535 #define fn_png_set_longjmp_fn png_set_longjmp_fn
5536 #endif /* libpng version >= 1.5 */
5538 #endif /* HAVE_NTGUI */
5541 #if (PNG_LIBPNG_VER < 10500)
5542 #define PNG_LONGJMP(ptr) (longjmp ((ptr)->jmpbuf, 1))
5543 #define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
5544 #else
5545 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908) */
5546 #define PNG_LONGJMP(ptr) (fn_png_longjmp ((ptr), 1))
5547 #define PNG_JMPBUF(ptr) \
5548 (*fn_png_set_longjmp_fn ((ptr), longjmp, sizeof (jmp_buf)))
5549 #endif
5551 /* Error and warning handlers installed when the PNG library
5552 is initialized. */
5554 static void my_png_error (png_struct *, const char *) NO_RETURN;
5555 static void
5556 my_png_error (png_struct *png_ptr, const char *msg)
5558 xassert (png_ptr != NULL);
5559 /* Avoid compiler warning about deprecated direct access to
5560 png_ptr's fields in libpng versions 1.4.x. */
5561 image_error ("PNG error: %s", build_string (msg), Qnil);
5562 PNG_LONGJMP (png_ptr);
5566 static void
5567 my_png_warning (png_struct *png_ptr, const char *msg)
5569 xassert (png_ptr != NULL);
5570 image_error ("PNG warning: %s", build_string (msg), Qnil);
5573 /* Memory source for PNG decoding. */
5575 struct png_memory_storage
5577 unsigned char *bytes; /* The data */
5578 ptrdiff_t len; /* How big is it? */
5579 ptrdiff_t index; /* Where are we? */
5583 /* Function set as reader function when reading PNG image from memory.
5584 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5585 bytes from the input to DATA. */
5587 static void
5588 png_read_from_memory (png_structp png_ptr, png_bytep data, png_size_t length)
5590 struct png_memory_storage *tbr
5591 = (struct png_memory_storage *) fn_png_get_io_ptr (png_ptr);
5593 if (length > tbr->len - tbr->index)
5594 fn_png_error (png_ptr, "Read error");
5596 memcpy (data, tbr->bytes + tbr->index, length);
5597 tbr->index = tbr->index + length;
5601 /* Function set as reader function when reading PNG image from a file.
5602 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5603 bytes from the input to DATA. */
5605 static void
5606 png_read_from_file (png_structp png_ptr, png_bytep data, png_size_t length)
5608 FILE *fp = (FILE *) fn_png_get_io_ptr (png_ptr);
5610 if (fread (data, 1, length, fp) < length)
5611 fn_png_error (png_ptr, "Read error");
5615 /* Load PNG image IMG for use on frame F. Value is non-zero if
5616 successful. */
5618 static int
5619 png_load (struct frame *f, struct image *img)
5621 Lisp_Object file, specified_file;
5622 Lisp_Object specified_data;
5623 int x, y;
5624 ptrdiff_t i;
5625 XImagePtr ximg, mask_img = NULL;
5626 png_struct *png_ptr = NULL;
5627 png_info *info_ptr = NULL, *end_info = NULL;
5628 FILE *volatile fp = NULL;
5629 png_byte sig[8];
5630 png_byte * volatile pixels = NULL;
5631 png_byte ** volatile rows = NULL;
5632 png_uint_32 width, height;
5633 int bit_depth, color_type, interlace_type;
5634 png_byte channels;
5635 png_uint_32 row_bytes;
5636 int transparent_p;
5637 struct png_memory_storage tbr; /* Data to be read */
5639 /* Find out what file to load. */
5640 specified_file = image_spec_value (img->spec, QCfile, NULL);
5641 specified_data = image_spec_value (img->spec, QCdata, NULL);
5643 if (NILP (specified_data))
5645 file = x_find_image_file (specified_file);
5646 if (!STRINGP (file))
5648 image_error ("Cannot find image file `%s'", specified_file, Qnil);
5649 return 0;
5652 /* Open the image file. */
5653 fp = fopen (SSDATA (file), "rb");
5654 if (!fp)
5656 image_error ("Cannot open image file `%s'", file, Qnil);
5657 return 0;
5660 /* Check PNG signature. */
5661 if (fread (sig, 1, sizeof sig, fp) != sizeof sig
5662 || fn_png_sig_cmp (sig, 0, sizeof sig))
5664 image_error ("Not a PNG file: `%s'", file, Qnil);
5665 fclose (fp);
5666 return 0;
5669 else
5671 if (!STRINGP (specified_data))
5673 image_error ("Invalid image data `%s'", specified_data, Qnil);
5674 return 0;
5677 /* Read from memory. */
5678 tbr.bytes = SDATA (specified_data);
5679 tbr.len = SBYTES (specified_data);
5680 tbr.index = 0;
5682 /* Check PNG signature. */
5683 if (tbr.len < sizeof sig
5684 || fn_png_sig_cmp (tbr.bytes, 0, sizeof sig))
5686 image_error ("Not a PNG image: `%s'", img->spec, Qnil);
5687 return 0;
5690 /* Need to skip past the signature. */
5691 tbr.bytes += sizeof (sig);
5694 /* Initialize read and info structs for PNG lib. */
5695 png_ptr = fn_png_create_read_struct (PNG_LIBPNG_VER_STRING,
5696 NULL, my_png_error,
5697 my_png_warning);
5698 if (!png_ptr)
5700 if (fp) fclose (fp);
5701 return 0;
5704 info_ptr = fn_png_create_info_struct (png_ptr);
5705 if (!info_ptr)
5707 fn_png_destroy_read_struct (&png_ptr, NULL, NULL);
5708 if (fp) fclose (fp);
5709 return 0;
5712 end_info = fn_png_create_info_struct (png_ptr);
5713 if (!end_info)
5715 fn_png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
5716 if (fp) fclose (fp);
5717 return 0;
5720 /* Set error jump-back. We come back here when the PNG library
5721 detects an error. */
5722 if (setjmp (PNG_JMPBUF (png_ptr)))
5724 error:
5725 if (png_ptr)
5726 fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
5727 xfree (pixels);
5728 xfree (rows);
5729 if (fp) fclose (fp);
5730 return 0;
5733 /* Read image info. */
5734 if (!NILP (specified_data))
5735 fn_png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
5736 else
5737 fn_png_set_read_fn (png_ptr, (void *) fp, png_read_from_file);
5739 fn_png_set_sig_bytes (png_ptr, sizeof sig);
5740 fn_png_read_info (png_ptr, info_ptr);
5741 fn_png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
5742 &interlace_type, NULL, NULL);
5744 if (! (width <= INT_MAX && height <= INT_MAX
5745 && check_image_size (f, width, height)))
5747 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
5748 goto error;
5751 /* Create the X image and pixmap now, so that the work below can be
5752 omitted if the image is too large for X. */
5753 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
5754 &img->pixmap))
5755 goto error;
5757 /* If image contains simply transparency data, we prefer to
5758 construct a clipping mask. */
5759 if (fn_png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
5760 transparent_p = 1;
5761 else
5762 transparent_p = 0;
5764 /* This function is easier to write if we only have to handle
5765 one data format: RGB or RGBA with 8 bits per channel. Let's
5766 transform other formats into that format. */
5768 /* Strip more than 8 bits per channel. */
5769 if (bit_depth == 16)
5770 fn_png_set_strip_16 (png_ptr);
5772 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5773 if available. */
5774 fn_png_set_expand (png_ptr);
5776 /* Convert grayscale images to RGB. */
5777 if (color_type == PNG_COLOR_TYPE_GRAY
5778 || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
5779 fn_png_set_gray_to_rgb (png_ptr);
5781 /* Handle alpha channel by combining the image with a background
5782 color. Do this only if a real alpha channel is supplied. For
5783 simple transparency, we prefer a clipping mask. */
5784 if (!transparent_p)
5786 /* png_color_16 *image_bg; */
5787 Lisp_Object specified_bg
5788 = image_spec_value (img->spec, QCbackground, NULL);
5789 int shift = (bit_depth == 16) ? 0 : 8;
5791 if (STRINGP (specified_bg))
5792 /* The user specified `:background', use that. */
5794 XColor color;
5795 if (x_defined_color (f, SSDATA (specified_bg), &color, 0))
5797 png_color_16 user_bg;
5799 memset (&user_bg, 0, sizeof user_bg);
5800 user_bg.red = color.red >> shift;
5801 user_bg.green = color.green >> shift;
5802 user_bg.blue = color.blue >> shift;
5804 fn_png_set_background (png_ptr, &user_bg,
5805 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
5808 else
5810 /* We use the current frame background, ignoring any default
5811 background color set by the image. */
5812 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
5813 XColor color;
5814 png_color_16 frame_background;
5816 color.pixel = FRAME_BACKGROUND_PIXEL (f);
5817 x_query_color (f, &color);
5819 memset (&frame_background, 0, sizeof frame_background);
5820 frame_background.red = color.red >> shift;
5821 frame_background.green = color.green >> shift;
5822 frame_background.blue = color.blue >> shift;
5823 #endif /* HAVE_X_WINDOWS */
5825 fn_png_set_background (png_ptr, &frame_background,
5826 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
5830 /* Update info structure. */
5831 fn_png_read_update_info (png_ptr, info_ptr);
5833 /* Get number of channels. Valid values are 1 for grayscale images
5834 and images with a palette, 2 for grayscale images with transparency
5835 information (alpha channel), 3 for RGB images, and 4 for RGB
5836 images with alpha channel, i.e. RGBA. If conversions above were
5837 sufficient we should only have 3 or 4 channels here. */
5838 channels = fn_png_get_channels (png_ptr, info_ptr);
5839 xassert (channels == 3 || channels == 4);
5841 /* Number of bytes needed for one row of the image. */
5842 row_bytes = fn_png_get_rowbytes (png_ptr, info_ptr);
5844 /* Allocate memory for the image. */
5845 if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *rows < height
5846 || min (PTRDIFF_MAX, SIZE_MAX) / sizeof *pixels / height < row_bytes)
5847 memory_full (SIZE_MAX);
5848 pixels = (png_byte *) xmalloc (sizeof *pixels * row_bytes * height);
5849 rows = (png_byte **) xmalloc (height * sizeof *rows);
5850 for (i = 0; i < height; ++i)
5851 rows[i] = pixels + i * row_bytes;
5853 /* Read the entire image. */
5854 fn_png_read_image (png_ptr, rows);
5855 fn_png_read_end (png_ptr, info_ptr);
5856 if (fp)
5858 fclose (fp);
5859 fp = NULL;
5862 /* Create an image and pixmap serving as mask if the PNG image
5863 contains an alpha channel. */
5864 if (channels == 4
5865 && !transparent_p
5866 && !x_create_x_image_and_pixmap (f, width, height, 1,
5867 &mask_img, &img->mask))
5869 x_destroy_x_image (ximg);
5870 Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
5871 img->pixmap = NO_PIXMAP;
5872 goto error;
5875 /* Fill the X image and mask from PNG data. */
5876 init_color_table ();
5878 for (y = 0; y < height; ++y)
5880 png_byte *p = rows[y];
5882 for (x = 0; x < width; ++x)
5884 int r, g, b;
5886 r = *p++ << 8;
5887 g = *p++ << 8;
5888 b = *p++ << 8;
5889 XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
5890 /* An alpha channel, aka mask channel, associates variable
5891 transparency with an image. Where other image formats
5892 support binary transparency---fully transparent or fully
5893 opaque---PNG allows up to 254 levels of partial transparency.
5894 The PNG library implements partial transparency by combining
5895 the image with a specified background color.
5897 I'm not sure how to handle this here nicely: because the
5898 background on which the image is displayed may change, for
5899 real alpha channel support, it would be necessary to create
5900 a new image for each possible background.
5902 What I'm doing now is that a mask is created if we have
5903 boolean transparency information. Otherwise I'm using
5904 the frame's background color to combine the image with. */
5906 if (channels == 4)
5908 if (mask_img)
5909 XPutPixel (mask_img, x, y, *p > 0 ? PIX_MASK_DRAW : PIX_MASK_RETAIN);
5910 ++p;
5915 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
5916 /* Set IMG's background color from the PNG image, unless the user
5917 overrode it. */
5919 png_color_16 *bg;
5920 if (fn_png_get_bKGD (png_ptr, info_ptr, &bg))
5922 img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
5923 img->background_valid = 1;
5927 #ifdef COLOR_TABLE_SUPPORT
5928 /* Remember colors allocated for this image. */
5929 img->colors = colors_in_color_table (&img->ncolors);
5930 free_color_table ();
5931 #endif /* COLOR_TABLE_SUPPORT */
5933 /* Clean up. */
5934 fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
5935 xfree (rows);
5936 xfree (pixels);
5938 img->width = width;
5939 img->height = height;
5941 /* Maybe fill in the background field while we have ximg handy.
5942 Casting avoids a GCC warning. */
5943 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
5945 /* Put the image into the pixmap, then free the X image and its buffer. */
5946 x_put_x_image (f, ximg, img->pixmap, width, height);
5947 x_destroy_x_image (ximg);
5949 /* Same for the mask. */
5950 if (mask_img)
5952 /* Fill in the background_transparent field while we have the
5953 mask handy. Casting avoids a GCC warning. */
5954 image_background_transparent (img, f, (XImagePtr_or_DC)mask_img);
5956 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
5957 x_destroy_x_image (mask_img);
5960 return 1;
5963 #else /* HAVE_PNG */
5965 #ifdef HAVE_NS
5966 static int
5967 png_load (struct frame *f, struct image *img)
5969 return ns_load_image (f, img,
5970 image_spec_value (img->spec, QCfile, NULL),
5971 image_spec_value (img->spec, QCdata, NULL));
5973 #endif /* HAVE_NS */
5976 #endif /* !HAVE_PNG */
5980 /***********************************************************************
5981 JPEG
5982 ***********************************************************************/
5984 #if defined (HAVE_JPEG) || defined (HAVE_NS)
5986 static int jpeg_image_p (Lisp_Object object);
5987 static int jpeg_load (struct frame *f, struct image *img);
5989 /* The symbol `jpeg' identifying images of this type. */
5991 static Lisp_Object Qjpeg;
5993 /* Indices of image specification fields in gs_format, below. */
5995 enum jpeg_keyword_index
5997 JPEG_TYPE,
5998 JPEG_DATA,
5999 JPEG_FILE,
6000 JPEG_ASCENT,
6001 JPEG_MARGIN,
6002 JPEG_RELIEF,
6003 JPEG_ALGORITHM,
6004 JPEG_HEURISTIC_MASK,
6005 JPEG_MASK,
6006 JPEG_BACKGROUND,
6007 JPEG_LAST
6010 /* Vector of image_keyword structures describing the format
6011 of valid user-defined image specifications. */
6013 static const struct image_keyword jpeg_format[JPEG_LAST] =
6015 {":type", IMAGE_SYMBOL_VALUE, 1},
6016 {":data", IMAGE_STRING_VALUE, 0},
6017 {":file", IMAGE_STRING_VALUE, 0},
6018 {":ascent", IMAGE_ASCENT_VALUE, 0},
6019 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
6020 {":relief", IMAGE_INTEGER_VALUE, 0},
6021 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6022 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6023 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6024 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
6027 /* Structure describing the image type `jpeg'. */
6029 static struct image_type jpeg_type =
6031 &Qjpeg,
6032 jpeg_image_p,
6033 jpeg_load,
6034 x_clear_image,
6035 NULL
6038 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6040 static int
6041 jpeg_image_p (Lisp_Object object)
6043 struct image_keyword fmt[JPEG_LAST];
6045 memcpy (fmt, jpeg_format, sizeof fmt);
6047 if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg))
6048 return 0;
6050 /* Must specify either the :data or :file keyword. */
6051 return fmt[JPEG_FILE].count + fmt[JPEG_DATA].count == 1;
6054 #endif /* HAVE_JPEG || HAVE_NS */
6056 #ifdef HAVE_JPEG
6058 /* Work around a warning about HAVE_STDLIB_H being redefined in
6059 jconfig.h. */
6060 #ifdef HAVE_STDLIB_H
6061 #undef HAVE_STDLIB_H
6062 #endif /* HAVE_STLIB_H */
6064 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6065 /* In older releases of the jpeg library, jpeglib.h will define boolean
6066 differently depending on __WIN32__, so make sure it is defined. */
6067 #define __WIN32__ 1
6068 #endif
6070 #include <jpeglib.h>
6071 #include <jerror.h>
6073 #ifdef HAVE_STLIB_H_1
6074 #define HAVE_STDLIB_H 1
6075 #endif
6077 #ifdef HAVE_NTGUI
6079 /* JPEG library details. */
6080 DEF_IMGLIB_FN (void, jpeg_CreateDecompress, (j_decompress_ptr, int, size_t));
6081 DEF_IMGLIB_FN (boolean, jpeg_start_decompress, (j_decompress_ptr));
6082 DEF_IMGLIB_FN (boolean, jpeg_finish_decompress, (j_decompress_ptr));
6083 DEF_IMGLIB_FN (void, jpeg_destroy_decompress, (j_decompress_ptr));
6084 DEF_IMGLIB_FN (int, jpeg_read_header, (j_decompress_ptr, boolean));
6085 DEF_IMGLIB_FN (JDIMENSION, jpeg_read_scanlines, (j_decompress_ptr, JSAMPARRAY, JDIMENSION));
6086 DEF_IMGLIB_FN (struct jpeg_error_mgr *, jpeg_std_error, (struct jpeg_error_mgr *));
6087 DEF_IMGLIB_FN (boolean, jpeg_resync_to_restart, (j_decompress_ptr, int));
6089 static int
6090 init_jpeg_functions (Lisp_Object libraries)
6092 HMODULE library;
6094 if (!(library = w32_delayed_load (libraries, Qjpeg)))
6095 return 0;
6097 LOAD_IMGLIB_FN (library, jpeg_finish_decompress);
6098 LOAD_IMGLIB_FN (library, jpeg_read_scanlines);
6099 LOAD_IMGLIB_FN (library, jpeg_start_decompress);
6100 LOAD_IMGLIB_FN (library, jpeg_read_header);
6101 LOAD_IMGLIB_FN (library, jpeg_CreateDecompress);
6102 LOAD_IMGLIB_FN (library, jpeg_destroy_decompress);
6103 LOAD_IMGLIB_FN (library, jpeg_std_error);
6104 LOAD_IMGLIB_FN (library, jpeg_resync_to_restart);
6105 return 1;
6108 /* Wrapper since we can't directly assign the function pointer
6109 to another function pointer that was declared more completely easily. */
6110 static boolean
6111 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo, int desired)
6113 return fn_jpeg_resync_to_restart (cinfo, desired);
6116 #else
6118 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress (a)
6119 #define fn_jpeg_start_decompress jpeg_start_decompress
6120 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6121 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6122 #define fn_jpeg_read_header jpeg_read_header
6123 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6124 #define fn_jpeg_std_error jpeg_std_error
6125 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6127 #endif /* HAVE_NTGUI */
6129 struct my_jpeg_error_mgr
6131 struct jpeg_error_mgr pub;
6132 jmp_buf setjmp_buffer;
6136 static void my_error_exit (j_common_ptr) NO_RETURN;
6137 static void
6138 my_error_exit (j_common_ptr cinfo)
6140 struct my_jpeg_error_mgr *mgr = (struct my_jpeg_error_mgr *) cinfo->err;
6141 longjmp (mgr->setjmp_buffer, 1);
6145 /* Init source method for JPEG data source manager. Called by
6146 jpeg_read_header() before any data is actually read. See
6147 libjpeg.doc from the JPEG lib distribution. */
6149 static void
6150 our_common_init_source (j_decompress_ptr cinfo)
6155 /* Method to terminate data source. Called by
6156 jpeg_finish_decompress() after all data has been processed. */
6158 static void
6159 our_common_term_source (j_decompress_ptr cinfo)
6164 /* Fill input buffer method for JPEG data source manager. Called
6165 whenever more data is needed. We read the whole image in one step,
6166 so this only adds a fake end of input marker at the end. */
6168 static JOCTET our_memory_buffer[2];
6170 static boolean
6171 our_memory_fill_input_buffer (j_decompress_ptr cinfo)
6173 /* Insert a fake EOI marker. */
6174 struct jpeg_source_mgr *src = cinfo->src;
6176 our_memory_buffer[0] = (JOCTET) 0xFF;
6177 our_memory_buffer[1] = (JOCTET) JPEG_EOI;
6179 src->next_input_byte = our_memory_buffer;
6180 src->bytes_in_buffer = 2;
6181 return 1;
6185 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6186 is the JPEG data source manager. */
6188 static void
6189 our_memory_skip_input_data (j_decompress_ptr cinfo, long int num_bytes)
6191 struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
6193 if (src)
6195 if (num_bytes > src->bytes_in_buffer)
6196 ERREXIT (cinfo, JERR_INPUT_EOF);
6198 src->bytes_in_buffer -= num_bytes;
6199 src->next_input_byte += num_bytes;
6204 /* Set up the JPEG lib for reading an image from DATA which contains
6205 LEN bytes. CINFO is the decompression info structure created for
6206 reading the image. */
6208 static void
6209 jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, unsigned int len)
6211 struct jpeg_source_mgr *src;
6213 if (cinfo->src == NULL)
6215 /* First time for this JPEG object? */
6216 cinfo->src = (struct jpeg_source_mgr *)
6217 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
6218 sizeof (struct jpeg_source_mgr));
6219 src = (struct jpeg_source_mgr *) cinfo->src;
6220 src->next_input_byte = data;
6223 src = (struct jpeg_source_mgr *) cinfo->src;
6224 src->init_source = our_common_init_source;
6225 src->fill_input_buffer = our_memory_fill_input_buffer;
6226 src->skip_input_data = our_memory_skip_input_data;
6227 src->resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method. */
6228 src->term_source = our_common_term_source;
6229 src->bytes_in_buffer = len;
6230 src->next_input_byte = data;
6234 struct jpeg_stdio_mgr
6236 struct jpeg_source_mgr mgr;
6237 boolean finished;
6238 FILE *file;
6239 JOCTET *buffer;
6243 /* Size of buffer to read JPEG from file.
6244 Not too big, as we want to use alloc_small. */
6245 #define JPEG_STDIO_BUFFER_SIZE 8192
6248 /* Fill input buffer method for JPEG data source manager. Called
6249 whenever more data is needed. The data is read from a FILE *. */
6251 static boolean
6252 our_stdio_fill_input_buffer (j_decompress_ptr cinfo)
6254 struct jpeg_stdio_mgr *src;
6256 src = (struct jpeg_stdio_mgr *) cinfo->src;
6257 if (!src->finished)
6259 ptrdiff_t bytes;
6261 bytes = fread (src->buffer, 1, JPEG_STDIO_BUFFER_SIZE, src->file);
6262 if (bytes > 0)
6263 src->mgr.bytes_in_buffer = bytes;
6264 else
6266 WARNMS (cinfo, JWRN_JPEG_EOF);
6267 src->finished = 1;
6268 src->buffer[0] = (JOCTET) 0xFF;
6269 src->buffer[1] = (JOCTET) JPEG_EOI;
6270 src->mgr.bytes_in_buffer = 2;
6272 src->mgr.next_input_byte = src->buffer;
6275 return 1;
6279 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6280 is the JPEG data source manager. */
6282 static void
6283 our_stdio_skip_input_data (j_decompress_ptr cinfo, long int num_bytes)
6285 struct jpeg_stdio_mgr *src;
6286 src = (struct jpeg_stdio_mgr *) cinfo->src;
6288 while (num_bytes > 0 && !src->finished)
6290 if (num_bytes <= src->mgr.bytes_in_buffer)
6292 src->mgr.bytes_in_buffer -= num_bytes;
6293 src->mgr.next_input_byte += num_bytes;
6294 break;
6296 else
6298 num_bytes -= src->mgr.bytes_in_buffer;
6299 src->mgr.bytes_in_buffer = 0;
6300 src->mgr.next_input_byte = NULL;
6302 our_stdio_fill_input_buffer (cinfo);
6308 /* Set up the JPEG lib for reading an image from a FILE *.
6309 CINFO is the decompression info structure created for
6310 reading the image. */
6312 static void
6313 jpeg_file_src (j_decompress_ptr cinfo, FILE *fp)
6315 struct jpeg_stdio_mgr *src;
6317 if (cinfo->src != NULL)
6318 src = (struct jpeg_stdio_mgr *) cinfo->src;
6319 else
6321 /* First time for this JPEG object? */
6322 cinfo->src = (struct jpeg_source_mgr *)
6323 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
6324 sizeof (struct jpeg_stdio_mgr));
6325 src = (struct jpeg_stdio_mgr *) cinfo->src;
6326 src->buffer = (JOCTET *)
6327 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
6328 JPEG_STDIO_BUFFER_SIZE);
6331 src->file = fp;
6332 src->finished = 0;
6333 src->mgr.init_source = our_common_init_source;
6334 src->mgr.fill_input_buffer = our_stdio_fill_input_buffer;
6335 src->mgr.skip_input_data = our_stdio_skip_input_data;
6336 src->mgr.resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method. */
6337 src->mgr.term_source = our_common_term_source;
6338 src->mgr.bytes_in_buffer = 0;
6339 src->mgr.next_input_byte = NULL;
6343 /* Load image IMG for use on frame F. Patterned after example.c
6344 from the JPEG lib. */
6346 static int
6347 jpeg_load (struct frame *f, struct image *img)
6349 struct jpeg_decompress_struct cinfo;
6350 struct my_jpeg_error_mgr mgr;
6351 Lisp_Object file, specified_file;
6352 Lisp_Object specified_data;
6353 FILE * volatile fp = NULL;
6354 JSAMPARRAY buffer;
6355 int row_stride, x, y;
6356 XImagePtr ximg = NULL;
6357 int rc;
6358 unsigned long *colors;
6359 int width, height;
6361 /* Open the JPEG file. */
6362 specified_file = image_spec_value (img->spec, QCfile, NULL);
6363 specified_data = image_spec_value (img->spec, QCdata, NULL);
6365 if (NILP (specified_data))
6367 file = x_find_image_file (specified_file);
6368 if (!STRINGP (file))
6370 image_error ("Cannot find image file `%s'", specified_file, Qnil);
6371 return 0;
6374 fp = fopen (SSDATA (file), "rb");
6375 if (fp == NULL)
6377 image_error ("Cannot open `%s'", file, Qnil);
6378 return 0;
6381 else if (!STRINGP (specified_data))
6383 image_error ("Invalid image data `%s'", specified_data, Qnil);
6384 return 0;
6387 /* Customize libjpeg's error handling to call my_error_exit when an
6388 error is detected. This function will perform a longjmp. */
6389 cinfo.err = fn_jpeg_std_error (&mgr.pub);
6390 mgr.pub.error_exit = my_error_exit;
6392 if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
6394 if (rc == 1)
6396 /* Called from my_error_exit. Display a JPEG error. */
6397 char buf[JMSG_LENGTH_MAX];
6398 cinfo.err->format_message ((j_common_ptr) &cinfo, buf);
6399 image_error ("Error reading JPEG image `%s': %s", img->spec,
6400 build_string (buf));
6403 /* Close the input file and destroy the JPEG object. */
6404 if (fp)
6405 fclose ((FILE *) fp);
6406 fn_jpeg_destroy_decompress (&cinfo);
6408 /* If we already have an XImage, free that. */
6409 x_destroy_x_image (ximg);
6411 /* Free pixmap and colors. */
6412 x_clear_image (f, img);
6413 return 0;
6416 /* Create the JPEG decompression object. Let it read from fp.
6417 Read the JPEG image header. */
6418 fn_jpeg_CreateDecompress (&cinfo, JPEG_LIB_VERSION, sizeof (cinfo));
6420 if (NILP (specified_data))
6421 jpeg_file_src (&cinfo, (FILE *) fp);
6422 else
6423 jpeg_memory_src (&cinfo, SDATA (specified_data),
6424 SBYTES (specified_data));
6426 fn_jpeg_read_header (&cinfo, 1);
6428 /* Customize decompression so that color quantization will be used.
6429 Start decompression. */
6430 cinfo.quantize_colors = 1;
6431 fn_jpeg_start_decompress (&cinfo);
6432 width = img->width = cinfo.output_width;
6433 height = img->height = cinfo.output_height;
6435 if (!check_image_size (f, width, height))
6437 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
6438 longjmp (mgr.setjmp_buffer, 2);
6441 /* Create X image and pixmap. */
6442 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
6443 longjmp (mgr.setjmp_buffer, 2);
6445 /* Allocate colors. When color quantization is used,
6446 cinfo.actual_number_of_colors has been set with the number of
6447 colors generated, and cinfo.colormap is a two-dimensional array
6448 of color indices in the range 0..cinfo.actual_number_of_colors.
6449 No more than 255 colors will be generated. */
6451 int i, ir, ig, ib;
6453 if (cinfo.out_color_components > 2)
6454 ir = 0, ig = 1, ib = 2;
6455 else if (cinfo.out_color_components > 1)
6456 ir = 0, ig = 1, ib = 0;
6457 else
6458 ir = 0, ig = 0, ib = 0;
6460 /* Use the color table mechanism because it handles colors that
6461 cannot be allocated nicely. Such colors will be replaced with
6462 a default color, and we don't have to care about which colors
6463 can be freed safely, and which can't. */
6464 init_color_table ();
6465 colors = (unsigned long *) alloca (cinfo.actual_number_of_colors
6466 * sizeof *colors);
6468 for (i = 0; i < cinfo.actual_number_of_colors; ++i)
6470 /* Multiply RGB values with 255 because X expects RGB values
6471 in the range 0..0xffff. */
6472 int r = cinfo.colormap[ir][i] << 8;
6473 int g = cinfo.colormap[ig][i] << 8;
6474 int b = cinfo.colormap[ib][i] << 8;
6475 colors[i] = lookup_rgb_color (f, r, g, b);
6478 #ifdef COLOR_TABLE_SUPPORT
6479 /* Remember those colors actually allocated. */
6480 img->colors = colors_in_color_table (&img->ncolors);
6481 free_color_table ();
6482 #endif /* COLOR_TABLE_SUPPORT */
6485 /* Read pixels. */
6486 row_stride = width * cinfo.output_components;
6487 buffer = cinfo.mem->alloc_sarray ((j_common_ptr) &cinfo, JPOOL_IMAGE,
6488 row_stride, 1);
6489 for (y = 0; y < height; ++y)
6491 fn_jpeg_read_scanlines (&cinfo, buffer, 1);
6492 for (x = 0; x < cinfo.output_width; ++x)
6493 XPutPixel (ximg, x, y, colors[buffer[0][x]]);
6496 /* Clean up. */
6497 fn_jpeg_finish_decompress (&cinfo);
6498 fn_jpeg_destroy_decompress (&cinfo);
6499 if (fp)
6500 fclose ((FILE *) fp);
6502 /* Maybe fill in the background field while we have ximg handy. */
6503 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
6504 /* Casting avoids a GCC warning. */
6505 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
6507 /* Put the image into the pixmap. */
6508 x_put_x_image (f, ximg, img->pixmap, width, height);
6509 x_destroy_x_image (ximg);
6510 return 1;
6513 #else /* HAVE_JPEG */
6515 #ifdef HAVE_NS
6516 static int
6517 jpeg_load (struct frame *f, struct image *img)
6519 return ns_load_image (f, img,
6520 image_spec_value (img->spec, QCfile, NULL),
6521 image_spec_value (img->spec, QCdata, NULL));
6523 #endif /* HAVE_NS */
6525 #endif /* !HAVE_JPEG */
6529 /***********************************************************************
6530 TIFF
6531 ***********************************************************************/
6533 #if defined (HAVE_TIFF) || defined (HAVE_NS)
6535 static int tiff_image_p (Lisp_Object object);
6536 static int tiff_load (struct frame *f, struct image *img);
6538 /* The symbol `tiff' identifying images of this type. */
6540 static Lisp_Object Qtiff;
6542 /* Indices of image specification fields in tiff_format, below. */
6544 enum tiff_keyword_index
6546 TIFF_TYPE,
6547 TIFF_DATA,
6548 TIFF_FILE,
6549 TIFF_ASCENT,
6550 TIFF_MARGIN,
6551 TIFF_RELIEF,
6552 TIFF_ALGORITHM,
6553 TIFF_HEURISTIC_MASK,
6554 TIFF_MASK,
6555 TIFF_BACKGROUND,
6556 TIFF_INDEX,
6557 TIFF_LAST
6560 /* Vector of image_keyword structures describing the format
6561 of valid user-defined image specifications. */
6563 static const struct image_keyword tiff_format[TIFF_LAST] =
6565 {":type", IMAGE_SYMBOL_VALUE, 1},
6566 {":data", IMAGE_STRING_VALUE, 0},
6567 {":file", IMAGE_STRING_VALUE, 0},
6568 {":ascent", IMAGE_ASCENT_VALUE, 0},
6569 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
6570 {":relief", IMAGE_INTEGER_VALUE, 0},
6571 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6572 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6573 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6574 {":background", IMAGE_STRING_OR_NIL_VALUE, 0},
6575 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0}
6578 /* Structure describing the image type `tiff'. */
6580 static struct image_type tiff_type =
6582 &Qtiff,
6583 tiff_image_p,
6584 tiff_load,
6585 x_clear_image,
6586 NULL
6589 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6591 static int
6592 tiff_image_p (Lisp_Object object)
6594 struct image_keyword fmt[TIFF_LAST];
6595 memcpy (fmt, tiff_format, sizeof fmt);
6597 if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff))
6598 return 0;
6600 /* Must specify either the :data or :file keyword. */
6601 return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
6604 #endif /* HAVE_TIFF || HAVE_NS */
6606 #ifdef HAVE_TIFF
6608 #include <tiffio.h>
6610 #ifdef HAVE_NTGUI
6612 /* TIFF library details. */
6613 DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetErrorHandler, (TIFFErrorHandler));
6614 DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetWarningHandler, (TIFFErrorHandler));
6615 DEF_IMGLIB_FN (TIFF *, TIFFOpen, (const char *, const char *));
6616 DEF_IMGLIB_FN (TIFF *, TIFFClientOpen, (const char *, const char *, thandle_t,
6617 TIFFReadWriteProc, TIFFReadWriteProc,
6618 TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
6619 TIFFMapFileProc, TIFFUnmapFileProc));
6620 DEF_IMGLIB_FN (int, TIFFGetField, (TIFF *, ttag_t, ...));
6621 DEF_IMGLIB_FN (int, TIFFReadRGBAImage, (TIFF *, uint32, uint32, uint32 *, int));
6622 DEF_IMGLIB_FN (void, TIFFClose, (TIFF *));
6623 DEF_IMGLIB_FN (int, TIFFSetDirectory, (TIFF *, tdir_t));
6625 static int
6626 init_tiff_functions (Lisp_Object libraries)
6628 HMODULE library;
6630 if (!(library = w32_delayed_load (libraries, Qtiff)))
6631 return 0;
6633 LOAD_IMGLIB_FN (library, TIFFSetErrorHandler);
6634 LOAD_IMGLIB_FN (library, TIFFSetWarningHandler);
6635 LOAD_IMGLIB_FN (library, TIFFOpen);
6636 LOAD_IMGLIB_FN (library, TIFFClientOpen);
6637 LOAD_IMGLIB_FN (library, TIFFGetField);
6638 LOAD_IMGLIB_FN (library, TIFFReadRGBAImage);
6639 LOAD_IMGLIB_FN (library, TIFFClose);
6640 LOAD_IMGLIB_FN (library, TIFFSetDirectory);
6641 return 1;
6644 #else
6646 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6647 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6648 #define fn_TIFFOpen TIFFOpen
6649 #define fn_TIFFClientOpen TIFFClientOpen
6650 #define fn_TIFFGetField TIFFGetField
6651 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6652 #define fn_TIFFClose TIFFClose
6653 #define fn_TIFFSetDirectory TIFFSetDirectory
6654 #endif /* HAVE_NTGUI */
6657 /* Reading from a memory buffer for TIFF images Based on the PNG
6658 memory source, but we have to provide a lot of extra functions.
6659 Blah.
6661 We really only need to implement read and seek, but I am not
6662 convinced that the TIFF library is smart enough not to destroy
6663 itself if we only hand it the function pointers we need to
6664 override. */
6666 typedef struct
6668 unsigned char *bytes;
6669 ptrdiff_t len;
6670 ptrdiff_t index;
6672 tiff_memory_source;
6674 static tsize_t
6675 tiff_read_from_memory (thandle_t data, tdata_t buf, tsize_t size)
6677 tiff_memory_source *src = (tiff_memory_source *) data;
6679 size = min (size, src->len - src->index);
6680 memcpy (buf, src->bytes + src->index, size);
6681 src->index += size;
6682 return size;
6685 static tsize_t
6686 tiff_write_from_memory (thandle_t data, tdata_t buf, tsize_t size)
6688 return -1;
6691 static toff_t
6692 tiff_seek_in_memory (thandle_t data, toff_t off, int whence)
6694 tiff_memory_source *src = (tiff_memory_source *) data;
6695 ptrdiff_t idx;
6697 switch (whence)
6699 case SEEK_SET: /* Go from beginning of source. */
6700 idx = off;
6701 break;
6703 case SEEK_END: /* Go from end of source. */
6704 idx = src->len + off;
6705 break;
6707 case SEEK_CUR: /* Go from current position. */
6708 idx = src->index + off;
6709 break;
6711 default: /* Invalid `whence'. */
6712 return -1;
6715 if (idx > src->len || idx < 0)
6716 return -1;
6718 src->index = idx;
6719 return src->index;
6722 static int
6723 tiff_close_memory (thandle_t data)
6725 /* NOOP */
6726 return 0;
6729 static int
6730 tiff_mmap_memory (thandle_t data, tdata_t *pbase, toff_t *psize)
6732 /* It is already _IN_ memory. */
6733 return 0;
6736 static void
6737 tiff_unmap_memory (thandle_t data, tdata_t base, toff_t size)
6739 /* We don't need to do this. */
6742 static toff_t
6743 tiff_size_of_memory (thandle_t data)
6745 return ((tiff_memory_source *) data)->len;
6748 /* GCC 3.x on x86 Windows targets has a bug that triggers an internal
6749 compiler error compiling tiff_handler, see Bugzilla bug #17406
6750 (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=17406). Declaring
6751 this function as external works around that problem. */
6752 #if defined (__MINGW32__) && __GNUC__ == 3
6753 # define MINGW_STATIC
6754 #else
6755 # define MINGW_STATIC static
6756 #endif
6758 MINGW_STATIC void
6759 tiff_handler (const char *, const char *, const char *, va_list)
6760 ATTRIBUTE_FORMAT_PRINTF (3, 0);
6761 MINGW_STATIC void
6762 tiff_handler (const char *log_format, const char *title,
6763 const char *format, va_list ap)
6765 /* doprnt is not suitable here, as TIFF handlers are called from
6766 libtiff and are passed arbitrary printf directives. Instead, use
6767 vsnprintf, taking care to be portable to nonstandard environments
6768 where vsnprintf returns -1 on buffer overflow. Since it's just a
6769 log entry, it's OK to truncate it. */
6770 char buf[4000];
6771 int len = vsnprintf (buf, sizeof buf, format, ap);
6772 add_to_log (log_format, build_string (title),
6773 make_string (buf, max (0, min (len, sizeof buf - 1))));
6775 #undef MINGW_STATIC
6777 static void tiff_error_handler (const char *, const char *, va_list)
6778 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6779 static void
6780 tiff_error_handler (const char *title, const char *format, va_list ap)
6782 tiff_handler ("TIFF error: %s %s", title, format, ap);
6786 static void tiff_warning_handler (const char *, const char *, va_list)
6787 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6788 static void
6789 tiff_warning_handler (const char *title, const char *format, va_list ap)
6791 tiff_handler ("TIFF warning: %s %s", title, format, ap);
6795 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6796 successful. */
6798 static int
6799 tiff_load (struct frame *f, struct image *img)
6801 Lisp_Object file, specified_file;
6802 Lisp_Object specified_data;
6803 TIFF *tiff;
6804 int width, height, x, y, count;
6805 uint32 *buf;
6806 int rc;
6807 XImagePtr ximg;
6808 tiff_memory_source memsrc;
6809 Lisp_Object image;
6811 specified_file = image_spec_value (img->spec, QCfile, NULL);
6812 specified_data = image_spec_value (img->spec, QCdata, NULL);
6814 fn_TIFFSetErrorHandler ((TIFFErrorHandler) tiff_error_handler);
6815 fn_TIFFSetWarningHandler ((TIFFErrorHandler) tiff_warning_handler);
6817 if (NILP (specified_data))
6819 /* Read from a file */
6820 file = x_find_image_file (specified_file);
6821 if (!STRINGP (file))
6823 image_error ("Cannot find image file `%s'", specified_file, Qnil);
6824 return 0;
6827 /* Try to open the image file. */
6828 tiff = fn_TIFFOpen (SSDATA (file), "r");
6829 if (tiff == NULL)
6831 image_error ("Cannot open `%s'", file, Qnil);
6832 return 0;
6835 else
6837 if (!STRINGP (specified_data))
6839 image_error ("Invalid image data `%s'", specified_data, Qnil);
6840 return 0;
6843 /* Memory source! */
6844 memsrc.bytes = SDATA (specified_data);
6845 memsrc.len = SBYTES (specified_data);
6846 memsrc.index = 0;
6848 tiff = fn_TIFFClientOpen ("memory_source", "r", (thandle_t)&memsrc,
6849 tiff_read_from_memory,
6850 tiff_write_from_memory,
6851 tiff_seek_in_memory,
6852 tiff_close_memory,
6853 tiff_size_of_memory,
6854 tiff_mmap_memory,
6855 tiff_unmap_memory);
6857 if (!tiff)
6859 image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
6860 return 0;
6864 image = image_spec_value (img->spec, QCindex, NULL);
6865 if (INTEGERP (image))
6867 EMACS_INT ino = XFASTINT (image);
6868 if (! (TYPE_MINIMUM (tdir_t) <= ino && ino <= TYPE_MAXIMUM (tdir_t)
6869 && fn_TIFFSetDirectory (tiff, ino)))
6871 image_error ("Invalid image number `%s' in image `%s'",
6872 image, img->spec);
6873 fn_TIFFClose (tiff);
6874 return 0;
6878 /* Get width and height of the image, and allocate a raster buffer
6879 of width x height 32-bit values. */
6880 fn_TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
6881 fn_TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
6883 if (!check_image_size (f, width, height))
6885 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
6886 fn_TIFFClose (tiff);
6887 return 0;
6890 /* Create the X image and pixmap. */
6891 if (! (height <= min (PTRDIFF_MAX, SIZE_MAX) / sizeof *buf / width
6892 && x_create_x_image_and_pixmap (f, width, height, 0,
6893 &ximg, &img->pixmap)))
6895 fn_TIFFClose (tiff);
6896 return 0;
6899 buf = (uint32 *) xmalloc (sizeof *buf * width * height);
6901 rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
6903 /* Count the number of images in the file. */
6904 for (count = 1; fn_TIFFSetDirectory (tiff, count); count++)
6905 continue;
6907 if (count > 1)
6908 img->lisp_data = Fcons (Qcount,
6909 Fcons (make_number (count),
6910 img->lisp_data));
6912 fn_TIFFClose (tiff);
6913 if (!rc)
6915 image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
6916 xfree (buf);
6917 return 0;
6920 /* Initialize the color table. */
6921 init_color_table ();
6923 /* Process the pixel raster. Origin is in the lower-left corner. */
6924 for (y = 0; y < height; ++y)
6926 uint32 *row = buf + y * width;
6928 for (x = 0; x < width; ++x)
6930 uint32 abgr = row[x];
6931 int r = TIFFGetR (abgr) << 8;
6932 int g = TIFFGetG (abgr) << 8;
6933 int b = TIFFGetB (abgr) << 8;
6934 XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
6938 #ifdef COLOR_TABLE_SUPPORT
6939 /* Remember the colors allocated for the image. Free the color table. */
6940 img->colors = colors_in_color_table (&img->ncolors);
6941 free_color_table ();
6942 #endif /* COLOR_TABLE_SUPPORT */
6944 img->width = width;
6945 img->height = height;
6947 /* Maybe fill in the background field while we have ximg handy. */
6948 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
6949 /* Casting avoids a GCC warning on W32. */
6950 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
6952 /* Put the image into the pixmap, then free the X image and its buffer. */
6953 x_put_x_image (f, ximg, img->pixmap, width, height);
6954 x_destroy_x_image (ximg);
6955 xfree (buf);
6957 return 1;
6960 #else /* HAVE_TIFF */
6962 #ifdef HAVE_NS
6963 static int
6964 tiff_load (struct frame *f, struct image *img)
6966 return ns_load_image (f, img,
6967 image_spec_value (img->spec, QCfile, NULL),
6968 image_spec_value (img->spec, QCdata, NULL));
6970 #endif /* HAVE_NS */
6972 #endif /* !HAVE_TIFF */
6976 /***********************************************************************
6978 ***********************************************************************/
6980 #if defined (HAVE_GIF) || defined (HAVE_NS)
6982 static int gif_image_p (Lisp_Object object);
6983 static int gif_load (struct frame *f, struct image *img);
6984 static void gif_clear_image (struct frame *f, struct image *img);
6986 /* The symbol `gif' identifying images of this type. */
6988 static Lisp_Object Qgif;
6990 /* Indices of image specification fields in gif_format, below. */
6992 enum gif_keyword_index
6994 GIF_TYPE,
6995 GIF_DATA,
6996 GIF_FILE,
6997 GIF_ASCENT,
6998 GIF_MARGIN,
6999 GIF_RELIEF,
7000 GIF_ALGORITHM,
7001 GIF_HEURISTIC_MASK,
7002 GIF_MASK,
7003 GIF_IMAGE,
7004 GIF_BACKGROUND,
7005 GIF_LAST
7008 /* Vector of image_keyword structures describing the format
7009 of valid user-defined image specifications. */
7011 static const struct image_keyword gif_format[GIF_LAST] =
7013 {":type", IMAGE_SYMBOL_VALUE, 1},
7014 {":data", IMAGE_STRING_VALUE, 0},
7015 {":file", IMAGE_STRING_VALUE, 0},
7016 {":ascent", IMAGE_ASCENT_VALUE, 0},
7017 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
7018 {":relief", IMAGE_INTEGER_VALUE, 0},
7019 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7020 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7021 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7022 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
7023 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
7026 /* Structure describing the image type `gif'. */
7028 static struct image_type gif_type =
7030 &Qgif,
7031 gif_image_p,
7032 gif_load,
7033 gif_clear_image,
7034 NULL
7037 /* Free X resources of GIF image IMG which is used on frame F. */
7039 static void
7040 gif_clear_image (struct frame *f, struct image *img)
7042 img->lisp_data = Qnil;
7043 x_clear_image (f, img);
7046 /* Return non-zero if OBJECT is a valid GIF image specification. */
7048 static int
7049 gif_image_p (Lisp_Object object)
7051 struct image_keyword fmt[GIF_LAST];
7052 memcpy (fmt, gif_format, sizeof fmt);
7054 if (!parse_image_spec (object, fmt, GIF_LAST, Qgif))
7055 return 0;
7057 /* Must specify either the :data or :file keyword. */
7058 return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
7061 #endif /* HAVE_GIF */
7063 #ifdef HAVE_GIF
7065 #if defined (HAVE_NTGUI)
7066 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7067 Undefine before redefining to avoid a preprocessor warning. */
7068 #ifdef DrawText
7069 #undef DrawText
7070 #endif
7071 /* avoid conflict with QuickdrawText.h */
7072 #define DrawText gif_DrawText
7073 #include <gif_lib.h>
7074 #undef DrawText
7076 #else /* HAVE_NTGUI */
7078 #include <gif_lib.h>
7080 #endif /* HAVE_NTGUI */
7083 #ifdef HAVE_NTGUI
7085 /* GIF library details. */
7086 DEF_IMGLIB_FN (int, DGifCloseFile, (GifFileType *));
7087 DEF_IMGLIB_FN (int, DGifSlurp, (GifFileType *));
7088 DEF_IMGLIB_FN (GifFileType *, DGifOpen, (void *, InputFunc));
7089 DEF_IMGLIB_FN (GifFileType *, DGifOpenFileName, (const char *));
7091 static int
7092 init_gif_functions (Lisp_Object libraries)
7094 HMODULE library;
7096 if (!(library = w32_delayed_load (libraries, Qgif)))
7097 return 0;
7099 LOAD_IMGLIB_FN (library, DGifCloseFile);
7100 LOAD_IMGLIB_FN (library, DGifSlurp);
7101 LOAD_IMGLIB_FN (library, DGifOpen);
7102 LOAD_IMGLIB_FN (library, DGifOpenFileName);
7103 return 1;
7106 #else
7108 #define fn_DGifCloseFile DGifCloseFile
7109 #define fn_DGifSlurp DGifSlurp
7110 #define fn_DGifOpen DGifOpen
7111 #define fn_DGifOpenFileName DGifOpenFileName
7113 #endif /* HAVE_NTGUI */
7115 /* Reading a GIF image from memory
7116 Based on the PNG memory stuff to a certain extent. */
7118 typedef struct
7120 unsigned char *bytes;
7121 ptrdiff_t len;
7122 ptrdiff_t index;
7124 gif_memory_source;
7126 /* Make the current memory source available to gif_read_from_memory.
7127 It's done this way because not all versions of libungif support
7128 a UserData field in the GifFileType structure. */
7129 static gif_memory_source *current_gif_memory_src;
7131 static int
7132 gif_read_from_memory (GifFileType *file, GifByteType *buf, int len)
7134 gif_memory_source *src = current_gif_memory_src;
7136 if (len > src->len - src->index)
7137 return -1;
7139 memcpy (buf, src->bytes + src->index, len);
7140 src->index += len;
7141 return len;
7145 /* Load GIF image IMG for use on frame F. Value is non-zero if
7146 successful. */
7148 static const int interlace_start[] = {0, 4, 2, 1};
7149 static const int interlace_increment[] = {8, 8, 4, 2};
7151 #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249
7153 static int
7154 gif_load (struct frame *f, struct image *img)
7156 Lisp_Object file;
7157 int rc, width, height, x, y, i, j;
7158 XImagePtr ximg;
7159 ColorMapObject *gif_color_map;
7160 unsigned long pixel_colors[256];
7161 GifFileType *gif;
7162 gif_memory_source memsrc;
7163 Lisp_Object specified_bg = image_spec_value (img->spec, QCbackground, NULL);
7164 Lisp_Object specified_file = image_spec_value (img->spec, QCfile, NULL);
7165 Lisp_Object specified_data = image_spec_value (img->spec, QCdata, NULL);
7166 unsigned long bgcolor = 0;
7167 EMACS_INT idx;
7169 if (NILP (specified_data))
7171 file = x_find_image_file (specified_file);
7172 if (!STRINGP (file))
7174 image_error ("Cannot find image file `%s'", specified_file, Qnil);
7175 return 0;
7178 /* Open the GIF file. */
7179 gif = fn_DGifOpenFileName (SSDATA (file));
7180 if (gif == NULL)
7182 image_error ("Cannot open `%s'", file, Qnil);
7183 return 0;
7186 else
7188 if (!STRINGP (specified_data))
7190 image_error ("Invalid image data `%s'", specified_data, Qnil);
7191 return 0;
7194 /* Read from memory! */
7195 current_gif_memory_src = &memsrc;
7196 memsrc.bytes = SDATA (specified_data);
7197 memsrc.len = SBYTES (specified_data);
7198 memsrc.index = 0;
7200 gif = fn_DGifOpen (&memsrc, gif_read_from_memory);
7201 if (!gif)
7203 image_error ("Cannot open memory source `%s'", img->spec, Qnil);
7204 return 0;
7208 /* Before reading entire contents, check the declared image size. */
7209 if (!check_image_size (f, gif->SWidth, gif->SHeight))
7211 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
7212 fn_DGifCloseFile (gif);
7213 return 0;
7216 /* Read entire contents. */
7217 rc = fn_DGifSlurp (gif);
7218 if (rc == GIF_ERROR || gif->ImageCount <= 0)
7220 image_error ("Error reading `%s'", img->spec, Qnil);
7221 fn_DGifCloseFile (gif);
7222 return 0;
7225 /* Which sub-image are we to display? */
7227 Lisp_Object image_number = image_spec_value (img->spec, QCindex, NULL);
7228 idx = INTEGERP (image_number) ? XFASTINT (image_number) : 0;
7229 if (idx < 0 || idx >= gif->ImageCount)
7231 image_error ("Invalid image number `%s' in image `%s'",
7232 image_number, img->spec);
7233 fn_DGifCloseFile (gif);
7234 return 0;
7238 width = img->width = gif->SWidth;
7239 height = img->height = gif->SHeight;
7241 img->corners[TOP_CORNER] = gif->SavedImages[0].ImageDesc.Top;
7242 img->corners[LEFT_CORNER] = gif->SavedImages[0].ImageDesc.Left;
7243 img->corners[BOT_CORNER]
7244 = img->corners[TOP_CORNER] + gif->SavedImages[0].ImageDesc.Height;
7245 img->corners[RIGHT_CORNER]
7246 = img->corners[LEFT_CORNER] + gif->SavedImages[0].ImageDesc.Width;
7248 if (!check_image_size (f, width, height))
7250 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
7251 fn_DGifCloseFile (gif);
7252 return 0;
7255 /* Create the X image and pixmap. */
7256 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
7258 fn_DGifCloseFile (gif);
7259 return 0;
7262 /* Clear the part of the screen image not covered by the image.
7263 Full animated GIF support requires more here (see the gif89 spec,
7264 disposal methods). Let's simply assume that the part not covered
7265 by a sub-image is in the frame's background color. */
7266 for (y = 0; y < img->corners[TOP_CORNER]; ++y)
7267 for (x = 0; x < width; ++x)
7268 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7270 for (y = img->corners[BOT_CORNER]; y < height; ++y)
7271 for (x = 0; x < width; ++x)
7272 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7274 for (y = img->corners[TOP_CORNER]; y < img->corners[BOT_CORNER]; ++y)
7276 for (x = 0; x < img->corners[LEFT_CORNER]; ++x)
7277 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7278 for (x = img->corners[RIGHT_CORNER]; x < width; ++x)
7279 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7282 /* Read the GIF image into the X image. */
7284 /* FIXME: With the current implementation, loading an animated gif
7285 is quadratic in the number of animation frames, since each frame
7286 is a separate struct image. We must provide a way for a single
7287 gif_load call to construct and save all animation frames. */
7289 init_color_table ();
7290 if (STRINGP (specified_bg))
7291 bgcolor = x_alloc_image_color (f, img, specified_bg,
7292 FRAME_BACKGROUND_PIXEL (f));
7293 for (j = 0; j <= idx; ++j)
7295 /* We use a local variable `raster' here because RasterBits is a
7296 char *, which invites problems with bytes >= 0x80. */
7297 struct SavedImage *subimage = gif->SavedImages + j;
7298 unsigned char *raster = (unsigned char *) subimage->RasterBits;
7299 int transparency_color_index = -1;
7300 int disposal = 0;
7301 int subimg_width = subimage->ImageDesc.Width;
7302 int subimg_height = subimage->ImageDesc.Height;
7303 int subimg_top = subimage->ImageDesc.Top;
7304 int subimg_left = subimage->ImageDesc.Left;
7306 /* Find the Graphic Control Extension block for this sub-image.
7307 Extract the disposal method and transparency color. */
7308 for (i = 0; i < subimage->ExtensionBlockCount; i++)
7310 ExtensionBlock *extblock = subimage->ExtensionBlocks + i;
7312 if ((extblock->Function == GIF_LOCAL_DESCRIPTOR_EXTENSION)
7313 && extblock->ByteCount == 4
7314 && extblock->Bytes[0] & 1)
7316 /* From gif89a spec: 1 = "keep in place", 2 = "restore
7317 to background". Treat any other value like 2. */
7318 disposal = (extblock->Bytes[0] >> 2) & 7;
7319 transparency_color_index = (unsigned char) extblock->Bytes[3];
7320 break;
7324 /* We can't "keep in place" the first subimage. */
7325 if (j == 0)
7326 disposal = 2;
7328 /* For disposal == 0, the spec says "No disposal specified. The
7329 decoder is not required to take any action." In practice, it
7330 seems we need to treat this like "keep in place", see e.g.
7331 http://upload.wikimedia.org/wikipedia/commons/3/37/Clock.gif */
7332 if (disposal == 0)
7333 disposal = 1;
7335 /* Allocate subimage colors. */
7336 memset (pixel_colors, 0, sizeof pixel_colors);
7337 gif_color_map = subimage->ImageDesc.ColorMap;
7338 if (!gif_color_map)
7339 gif_color_map = gif->SColorMap;
7341 if (gif_color_map)
7342 for (i = 0; i < gif_color_map->ColorCount; ++i)
7344 if (transparency_color_index == i)
7345 pixel_colors[i] = STRINGP (specified_bg)
7346 ? bgcolor : FRAME_BACKGROUND_PIXEL (f);
7347 else
7349 int r = gif_color_map->Colors[i].Red << 8;
7350 int g = gif_color_map->Colors[i].Green << 8;
7351 int b = gif_color_map->Colors[i].Blue << 8;
7352 pixel_colors[i] = lookup_rgb_color (f, r, g, b);
7356 /* Apply the pixel values. */
7357 if (gif->SavedImages[j].ImageDesc.Interlace)
7359 int row, pass;
7361 for (y = 0, row = interlace_start[0], pass = 0;
7362 y < subimg_height;
7363 y++, row += interlace_increment[pass])
7365 if (row >= subimg_height)
7367 row = interlace_start[++pass];
7368 while (row >= subimg_height)
7369 row = interlace_start[++pass];
7372 for (x = 0; x < subimg_width; x++)
7374 int c = raster[y * subimg_width + x];
7375 if (transparency_color_index != c || disposal != 1)
7376 XPutPixel (ximg, x + subimg_left, row + subimg_top,
7377 pixel_colors[c]);
7381 else
7383 for (y = 0; y < subimg_height; ++y)
7384 for (x = 0; x < subimg_width; ++x)
7386 int c = raster[y * subimg_width + x];
7387 if (transparency_color_index != c || disposal != 1)
7388 XPutPixel (ximg, x + subimg_left, y + subimg_top,
7389 pixel_colors[c]);
7394 #ifdef COLOR_TABLE_SUPPORT
7395 img->colors = colors_in_color_table (&img->ncolors);
7396 free_color_table ();
7397 #endif /* COLOR_TABLE_SUPPORT */
7399 /* Save GIF image extension data for `image-metadata'.
7400 Format is (count IMAGES extension-data (FUNCTION "BYTES" ...)). */
7401 img->lisp_data = Qnil;
7402 if (gif->SavedImages[idx].ExtensionBlockCount > 0)
7404 int delay = 0;
7405 ExtensionBlock *ext = gif->SavedImages[idx].ExtensionBlocks;
7406 for (i = 0; i < gif->SavedImages[idx].ExtensionBlockCount; i++, ext++)
7407 /* Append (... FUNCTION "BYTES") */
7409 img->lisp_data
7410 = Fcons (make_number (ext->Function),
7411 Fcons (make_unibyte_string (ext->Bytes, ext->ByteCount),
7412 img->lisp_data));
7413 if (ext->Function == GIF_LOCAL_DESCRIPTOR_EXTENSION
7414 && ext->ByteCount == 4)
7416 delay = ext->Bytes[2] << CHAR_BIT;
7417 delay |= ext->Bytes[1];
7420 img->lisp_data = Fcons (Qextension_data,
7421 Fcons (img->lisp_data, Qnil));
7422 if (delay)
7423 img->lisp_data
7424 = Fcons (Qdelay,
7425 Fcons (make_float (delay / 100.0),
7426 img->lisp_data));
7429 if (gif->ImageCount > 1)
7430 img->lisp_data = Fcons (Qcount,
7431 Fcons (make_number (gif->ImageCount),
7432 img->lisp_data));
7434 fn_DGifCloseFile (gif);
7436 /* Maybe fill in the background field while we have ximg handy. */
7437 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
7438 /* Casting avoids a GCC warning. */
7439 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
7441 /* Put the image into the pixmap, then free the X image and its buffer. */
7442 x_put_x_image (f, ximg, img->pixmap, width, height);
7443 x_destroy_x_image (ximg);
7445 return 1;
7448 #else /* !HAVE_GIF */
7450 #ifdef HAVE_NS
7451 static int
7452 gif_load (struct frame *f, struct image *img)
7454 return ns_load_image (f, img,
7455 image_spec_value (img->spec, QCfile, NULL),
7456 image_spec_value (img->spec, QCdata, NULL));
7458 #endif /* HAVE_NS */
7460 #endif /* HAVE_GIF */
7463 /***********************************************************************
7464 ImageMagick
7465 ***********************************************************************/
7466 #if defined (HAVE_IMAGEMAGICK)
7468 static Lisp_Object Qimagemagick;
7470 static int imagemagick_image_p (Lisp_Object);
7471 static int imagemagick_load (struct frame *, struct image *);
7472 static void imagemagick_clear_image (struct frame *, struct image *);
7474 /* Indices of image specification fields in imagemagick_format. */
7476 enum imagemagick_keyword_index
7478 IMAGEMAGICK_TYPE,
7479 IMAGEMAGICK_DATA,
7480 IMAGEMAGICK_FILE,
7481 IMAGEMAGICK_ASCENT,
7482 IMAGEMAGICK_MARGIN,
7483 IMAGEMAGICK_RELIEF,
7484 IMAGEMAGICK_ALGORITHM,
7485 IMAGEMAGICK_HEURISTIC_MASK,
7486 IMAGEMAGICK_MASK,
7487 IMAGEMAGICK_BACKGROUND,
7488 IMAGEMAGICK_HEIGHT,
7489 IMAGEMAGICK_WIDTH,
7490 IMAGEMAGICK_ROTATION,
7491 IMAGEMAGICK_CROP,
7492 IMAGEMAGICK_LAST
7495 /* Vector of image_keyword structures describing the format
7496 of valid user-defined image specifications. */
7498 static struct image_keyword imagemagick_format[IMAGEMAGICK_LAST] =
7500 {":type", IMAGE_SYMBOL_VALUE, 1},
7501 {":data", IMAGE_STRING_VALUE, 0},
7502 {":file", IMAGE_STRING_VALUE, 0},
7503 {":ascent", IMAGE_ASCENT_VALUE, 0},
7504 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
7505 {":relief", IMAGE_INTEGER_VALUE, 0},
7506 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7507 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7508 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7509 {":background", IMAGE_STRING_OR_NIL_VALUE, 0},
7510 {":height", IMAGE_INTEGER_VALUE, 0},
7511 {":width", IMAGE_INTEGER_VALUE, 0},
7512 {":rotation", IMAGE_NUMBER_VALUE, 0},
7513 {":crop", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
7516 /* Structure describing the image type for any image handled via
7517 ImageMagick. */
7519 static struct image_type imagemagick_type =
7521 &Qimagemagick,
7522 imagemagick_image_p,
7523 imagemagick_load,
7524 imagemagick_clear_image,
7525 NULL
7528 /* Free X resources of imagemagick image IMG which is used on frame F. */
7530 static void
7531 imagemagick_clear_image (struct frame *f,
7532 struct image *img)
7534 x_clear_image (f, img);
7537 /* Return non-zero if OBJECT is a valid IMAGEMAGICK image specification. Do
7538 this by calling parse_image_spec and supplying the keywords that
7539 identify the IMAGEMAGICK format. */
7541 static int
7542 imagemagick_image_p (Lisp_Object object)
7544 struct image_keyword fmt[IMAGEMAGICK_LAST];
7545 memcpy (fmt, imagemagick_format, sizeof fmt);
7547 if (!parse_image_spec (object, fmt, IMAGEMAGICK_LAST, Qimagemagick))
7548 return 0;
7550 /* Must specify either the :data or :file keyword. */
7551 return fmt[IMAGEMAGICK_FILE].count + fmt[IMAGEMAGICK_DATA].count == 1;
7554 /* The GIF library also defines DrawRectangle, but its never used in Emacs.
7555 Therefore rename the function so it doesn't collide with ImageMagick. */
7556 #define DrawRectangle DrawRectangleGif
7557 #include <wand/MagickWand.h>
7559 /* ImageMagick 6.5.3 through 6.6.5 hid PixelGetMagickColor for some reason.
7560 Emacs seems to work fine with the hidden version, so unhide it. */
7561 #include <magick/version.h>
7562 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
7563 extern WandExport void PixelGetMagickColor (const PixelWand *,
7564 MagickPixelPacket *);
7565 #endif
7567 /* Log ImageMagick error message.
7568 Useful when a ImageMagick function returns the status `MagickFalse'. */
7570 static void
7571 imagemagick_error (MagickWand *wand)
7573 char *description;
7574 ExceptionType severity;
7576 description = MagickGetException (wand, &severity);
7577 image_error ("ImageMagick error: %s",
7578 make_string (description, strlen (description)),
7579 Qnil);
7580 description = (char *) MagickRelinquishMemory (description);
7583 /* Helper function for imagemagick_load, which does the actual loading
7584 given contents and size, apart from frame and image structures,
7585 passed from imagemagick_load. Uses librimagemagick to do most of
7586 the image processing.
7588 F is a pointer to the Emacs frame; IMG to the image structure to
7589 prepare; CONTENTS is the string containing the IMAGEMAGICK data to
7590 be parsed; SIZE is the number of bytes of data; and FILENAME is
7591 either the file name or the image data.
7593 Return non-zero if successful. */
7595 static int
7596 imagemagick_load_image (struct frame *f, struct image *img,
7597 unsigned char *contents, unsigned int size,
7598 char *filename)
7600 size_t width;
7601 size_t height;
7603 MagickBooleanType status;
7605 XImagePtr ximg;
7606 int x;
7607 int y;
7609 MagickWand *image_wand;
7610 MagickWand *ping_wand;
7611 PixelIterator *iterator;
7612 PixelWand **pixels;
7613 MagickPixelPacket pixel;
7614 Lisp_Object image;
7615 Lisp_Object value;
7616 Lisp_Object crop;
7617 EMACS_INT ino;
7618 int desired_width, desired_height;
7619 double rotation;
7620 int pixelwidth;
7621 ImageInfo *image_info;
7622 ExceptionInfo *exception;
7623 Image * im_image;
7626 /* Handle image index for image types who can contain more than one image.
7627 Interface :index is same as for GIF. First we "ping" the image to see how
7628 many sub-images it contains. Pinging is faster than loading the image to
7629 find out things about it. */
7631 /* Initialize the imagemagick environment. */
7632 MagickWandGenesis ();
7633 image = image_spec_value (img->spec, QCindex, NULL);
7634 ino = INTEGERP (image) ? XFASTINT (image) : 0;
7635 ping_wand = NewMagickWand ();
7636 /* MagickSetResolution (ping_wand, 2, 2); (Bug#10112) */
7638 if (filename != NULL)
7640 status = MagickPingImage (ping_wand, filename);
7642 else
7644 status = MagickPingImageBlob (ping_wand, contents, size);
7647 if (status == MagickFalse)
7649 imagemagick_error (ping_wand);
7650 DestroyMagickWand (ping_wand);
7651 return 0;
7654 if (! (0 <= ino && ino < MagickGetNumberImages (ping_wand)))
7656 image_error ("Invalid image number `%s' in image `%s'",
7657 image, img->spec);
7658 DestroyMagickWand (ping_wand);
7659 return 0;
7662 if (MagickGetNumberImages (ping_wand) > 1)
7663 img->lisp_data =
7664 Fcons (Qcount,
7665 Fcons (make_number (MagickGetNumberImages (ping_wand)),
7666 img->lisp_data));
7668 DestroyMagickWand (ping_wand);
7670 /* Now we know how many images are inside the file. If it's not a
7671 bundle, the number is one. */
7673 if (filename != NULL)
7675 image_info = CloneImageInfo ((ImageInfo *) NULL);
7676 (void) strcpy (image_info->filename, filename);
7677 image_info->number_scenes = 1;
7678 image_info->scene = ino;
7679 exception = AcquireExceptionInfo ();
7681 im_image = ReadImage (image_info, exception);
7682 DestroyExceptionInfo (exception);
7684 if (im_image == NULL)
7685 goto imagemagick_no_wand;
7686 image_wand = NewMagickWandFromImage (im_image);
7687 DestroyImage (im_image);
7689 else
7691 image_wand = NewMagickWand ();
7692 if (MagickReadImageBlob (image_wand, contents, size) == MagickFalse)
7694 imagemagick_error (image_wand);
7695 goto imagemagick_error;
7699 /* If width and/or height is set in the display spec assume we want
7700 to scale to those values. If either h or w is unspecified, the
7701 unspecified should be calculated from the specified to preserve
7702 aspect ratio. */
7704 value = image_spec_value (img->spec, QCwidth, NULL);
7705 desired_width = (INTEGERP (value) ? XFASTINT (value) : -1);
7706 value = image_spec_value (img->spec, QCheight, NULL);
7707 desired_height = (INTEGERP (value) ? XFASTINT (value) : -1);
7709 height = MagickGetImageHeight (image_wand);
7710 width = MagickGetImageWidth (image_wand);
7712 if (desired_width != -1 && desired_height == -1)
7713 /* w known, calculate h. */
7714 desired_height = (double) desired_width / width * height;
7715 if (desired_width == -1 && desired_height != -1)
7716 /* h known, calculate w. */
7717 desired_width = (double) desired_height / height * width;
7718 if (desired_width != -1 && desired_height != -1)
7720 status = MagickScaleImage (image_wand, desired_width, desired_height);
7721 if (status == MagickFalse)
7723 image_error ("Imagemagick scale failed", Qnil, Qnil);
7724 imagemagick_error (image_wand);
7725 goto imagemagick_error;
7729 /* crop behaves similar to image slicing in Emacs but is more memory
7730 efficient. */
7731 crop = image_spec_value (img->spec, QCcrop, NULL);
7733 if (CONSP (crop) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop)))
7735 /* After some testing, it seems MagickCropImage is the fastest crop
7736 function in ImageMagick. This crop function seems to do less copying
7737 than the alternatives, but it still reads the entire image into memory
7738 before cropping, which is apparently difficult to avoid when using
7739 imagemagick. */
7740 size_t crop_width = XINT (XCAR (crop));
7741 crop = XCDR (crop);
7742 if (CONSP (crop) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop)))
7744 size_t crop_height = XINT (XCAR (crop));
7745 crop = XCDR (crop);
7746 if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
7748 ssize_t crop_x = XINT (XCAR (crop));
7749 crop = XCDR (crop);
7750 if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
7752 ssize_t crop_y = XINT (XCAR (crop));
7753 MagickCropImage (image_wand, crop_width, crop_height,
7754 crop_x, crop_y);
7760 /* Furthermore :rotation. we need background color and angle for
7761 rotation. */
7763 TODO background handling for rotation specified_bg =
7764 image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
7765 (specified_bg). */
7766 value = image_spec_value (img->spec, QCrotation, NULL);
7767 if (FLOATP (value))
7769 PixelWand* background = NewPixelWand ();
7770 PixelSetColor (background, "#ffffff");/*TODO remove hardcode*/
7772 rotation = extract_float (value);
7774 status = MagickRotateImage (image_wand, background, rotation);
7775 DestroyPixelWand (background);
7776 if (status == MagickFalse)
7778 image_error ("Imagemagick image rotate failed", Qnil, Qnil);
7779 imagemagick_error (image_wand);
7780 goto imagemagick_error;
7784 /* Finally we are done manipulating the image. Figure out the
7785 resulting width/height and transfer ownership to Emacs. */
7786 height = MagickGetImageHeight (image_wand);
7787 width = MagickGetImageWidth (image_wand);
7789 if (! (width <= INT_MAX && height <= INT_MAX
7790 && check_image_size (f, width, height)))
7792 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
7793 goto imagemagick_error;
7796 /* We can now get a valid pixel buffer from the imagemagick file, if all
7797 went ok. */
7799 init_color_table ();
7801 if (imagemagick_render_type == 0)
7803 size_t image_height;
7805 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7806 if (!x_create_x_image_and_pixmap (f, width, height, 0,
7807 &ximg, &img->pixmap))
7809 #ifdef COLOR_TABLE_SUPPORT
7810 free_color_table ();
7811 #endif
7812 image_error ("Imagemagick X bitmap allocation failure", Qnil, Qnil);
7813 goto imagemagick_error;
7816 /* Copy imagemagick image to x with primitive yet robust pixel
7817 pusher loop. This has been tested a lot with many different
7818 images. */
7820 /* Copy pixels from the imagemagick image structure to the x image map. */
7821 iterator = NewPixelIterator (image_wand);
7822 if (iterator == (PixelIterator *) NULL)
7824 #ifdef COLOR_TABLE_SUPPORT
7825 free_color_table ();
7826 #endif
7827 x_destroy_x_image (ximg);
7828 image_error ("Imagemagick pixel iterator creation failed",
7829 Qnil, Qnil);
7830 goto imagemagick_error;
7833 image_height = MagickGetImageHeight (image_wand);
7834 for (y = 0; y < image_height; y++)
7836 pixels = PixelGetNextIteratorRow (iterator, &width);
7837 if (pixels == (PixelWand **) NULL)
7838 break;
7839 for (x = 0; x < (long) width; x++)
7841 PixelGetMagickColor (pixels[x], &pixel);
7842 XPutPixel (ximg, x, y,
7843 lookup_rgb_color (f,
7844 pixel.red,
7845 pixel.green,
7846 pixel.blue));
7849 DestroyPixelIterator (iterator);
7851 else /* imagemagick_render_type != 0 */
7853 /* Magicexportimage is normally faster than pixelpushing. This
7854 method is also well tested. Some aspects of this method are
7855 ad-hoc and needs to be more researched. */
7856 int imagedepth = 24;/*MagickGetImageDepth(image_wand);*/
7857 const char *exportdepth = imagedepth <= 8 ? "I" : "BGRP";/*"RGBP";*/
7858 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7859 if (!x_create_x_image_and_pixmap (f, width, height, imagedepth,
7860 &ximg, &img->pixmap))
7862 #ifdef COLOR_TABLE_SUPPORT
7863 free_color_table ();
7864 #endif
7865 image_error ("Imagemagick X bitmap allocation failure", Qnil, Qnil);
7866 goto imagemagick_error;
7870 /* Oddly, the below code doesn't seem to work:*/
7871 /* switch(ximg->bitmap_unit){ */
7872 /* case 8: */
7873 /* pixelwidth=CharPixel; */
7874 /* break; */
7875 /* case 16: */
7876 /* pixelwidth=ShortPixel; */
7877 /* break; */
7878 /* case 32: */
7879 /* pixelwidth=LongPixel; */
7880 /* break; */
7881 /* } */
7883 Here im just guessing the format of the bitmap.
7884 happens to work fine for:
7885 - bw djvu images
7886 on rgb display.
7887 seems about 3 times as fast as pixel pushing(not carefully measured)
7889 pixelwidth = CharPixel;/*??? TODO figure out*/
7890 #ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
7891 MagickExportImagePixels (image_wand,
7892 0, 0,
7893 width, height,
7894 exportdepth,
7895 pixelwidth,
7896 /*&(img->pixmap));*/
7897 ximg->data);
7898 #else
7899 image_error ("You don't have MagickExportImagePixels, upgrade ImageMagick!",
7900 Qnil, Qnil);
7901 #endif
7905 #ifdef COLOR_TABLE_SUPPORT
7906 /* Remember colors allocated for this image. */
7907 img->colors = colors_in_color_table (&img->ncolors);
7908 free_color_table ();
7909 #endif /* COLOR_TABLE_SUPPORT */
7912 img->width = width;
7913 img->height = height;
7915 /* Put the image into the pixmap, then free the X image and its
7916 buffer. */
7917 x_put_x_image (f, ximg, img->pixmap, width, height);
7918 x_destroy_x_image (ximg);
7921 /* Final cleanup. image_wand should be the only resource left. */
7922 DestroyMagickWand (image_wand);
7923 /* `MagickWandTerminus' terminates the imagemagick environment. */
7924 MagickWandTerminus ();
7926 return 1;
7928 imagemagick_error:
7929 DestroyMagickWand (image_wand);
7930 imagemagick_no_wand:
7931 MagickWandTerminus ();
7932 /* TODO more cleanup. */
7933 image_error ("Error parsing IMAGEMAGICK image `%s'", img->spec, Qnil);
7934 return 0;
7938 /* Load IMAGEMAGICK image IMG for use on frame F. Value is non-zero if
7939 successful. this function will go into the imagemagick_type structure, and
7940 the prototype thus needs to be compatible with that structure. */
7942 static int
7943 imagemagick_load (struct frame *f, struct image *img)
7945 int success_p = 0;
7946 Lisp_Object file_name;
7948 /* If IMG->spec specifies a file name, create a non-file spec from it. */
7949 file_name = image_spec_value (img->spec, QCfile, NULL);
7950 if (STRINGP (file_name))
7952 Lisp_Object file;
7954 file = x_find_image_file (file_name);
7955 if (!STRINGP (file))
7957 image_error ("Cannot find image file `%s'", file_name, Qnil);
7958 return 0;
7960 success_p = imagemagick_load_image (f, img, 0, 0, SSDATA (file));
7962 /* Else its not a file, its a lisp object. Load the image from a
7963 lisp object rather than a file. */
7964 else
7966 Lisp_Object data;
7968 data = image_spec_value (img->spec, QCdata, NULL);
7969 if (!STRINGP (data))
7971 image_error ("Invalid image data `%s'", data, Qnil);
7972 return 0;
7974 success_p = imagemagick_load_image (f, img, SDATA (data),
7975 SBYTES (data), NULL);
7978 return success_p;
7981 DEFUN ("imagemagick-types", Fimagemagick_types, Simagemagick_types, 0, 0, 0,
7982 doc: /* Return a list of image types supported by ImageMagick.
7983 Each entry in this list is a symbol named after an ImageMagick format
7984 tag. See the ImageMagick manual for a list of ImageMagick formats and
7985 their descriptions (http://www.imagemagick.org/script/formats.php).
7986 You can also try the shell command: `identify -list format'.
7988 Note that ImageMagick recognizes many file-types that Emacs does not
7989 recognize as images, such as C. See `imagemagick-types-inhibit'. */)
7990 (void)
7992 Lisp_Object typelist = Qnil;
7993 size_t numf = 0;
7994 ExceptionInfo ex;
7995 char **imtypes = GetMagickList ("*", &numf, &ex);
7996 size_t i;
7997 Lisp_Object Qimagemagicktype;
7998 for (i = 0; i < numf; i++)
8000 Qimagemagicktype = intern (imtypes[i]);
8001 typelist = Fcons (Qimagemagicktype, typelist);
8003 return Fnreverse (typelist);
8006 #endif /* defined (HAVE_IMAGEMAGICK) */
8010 /***********************************************************************
8012 ***********************************************************************/
8014 #if defined (HAVE_RSVG)
8016 /* Function prototypes. */
8018 static int svg_image_p (Lisp_Object object);
8019 static int svg_load (struct frame *f, struct image *img);
8021 static int svg_load_image (struct frame *, struct image *,
8022 unsigned char *, ptrdiff_t);
8024 /* The symbol `svg' identifying images of this type. */
8026 static Lisp_Object Qsvg;
8028 /* Indices of image specification fields in svg_format, below. */
8030 enum svg_keyword_index
8032 SVG_TYPE,
8033 SVG_DATA,
8034 SVG_FILE,
8035 SVG_ASCENT,
8036 SVG_MARGIN,
8037 SVG_RELIEF,
8038 SVG_ALGORITHM,
8039 SVG_HEURISTIC_MASK,
8040 SVG_MASK,
8041 SVG_BACKGROUND,
8042 SVG_LAST
8045 /* Vector of image_keyword structures describing the format
8046 of valid user-defined image specifications. */
8048 static const struct image_keyword svg_format[SVG_LAST] =
8050 {":type", IMAGE_SYMBOL_VALUE, 1},
8051 {":data", IMAGE_STRING_VALUE, 0},
8052 {":file", IMAGE_STRING_VALUE, 0},
8053 {":ascent", IMAGE_ASCENT_VALUE, 0},
8054 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
8055 {":relief", IMAGE_INTEGER_VALUE, 0},
8056 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8057 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8058 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8059 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
8062 /* Structure describing the image type `svg'. Its the same type of
8063 structure defined for all image formats, handled by emacs image
8064 functions. See struct image_type in dispextern.h. */
8066 static struct image_type svg_type =
8068 /* An identifier showing that this is an image structure for the SVG format. */
8069 &Qsvg,
8070 /* Handle to a function that can be used to identify a SVG file. */
8071 svg_image_p,
8072 /* Handle to function used to load a SVG file. */
8073 svg_load,
8074 /* Handle to function to free sresources for SVG. */
8075 x_clear_image,
8076 /* An internal field to link to the next image type in a list of
8077 image types, will be filled in when registering the format. */
8078 NULL
8082 /* Return non-zero if OBJECT is a valid SVG image specification. Do
8083 this by calling parse_image_spec and supplying the keywords that
8084 identify the SVG format. */
8086 static int
8087 svg_image_p (Lisp_Object object)
8089 struct image_keyword fmt[SVG_LAST];
8090 memcpy (fmt, svg_format, sizeof fmt);
8092 if (!parse_image_spec (object, fmt, SVG_LAST, Qsvg))
8093 return 0;
8095 /* Must specify either the :data or :file keyword. */
8096 return fmt[SVG_FILE].count + fmt[SVG_DATA].count == 1;
8099 #include <librsvg/rsvg.h>
8101 #ifdef HAVE_NTGUI
8103 /* SVG library functions. */
8104 DEF_IMGLIB_FN (RsvgHandle *, rsvg_handle_new);
8105 DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions);
8106 DEF_IMGLIB_FN (gboolean, rsvg_handle_write);
8107 DEF_IMGLIB_FN (gboolean, rsvg_handle_close);
8108 DEF_IMGLIB_FN (GdkPixbuf *, rsvg_handle_get_pixbuf);
8110 DEF_IMGLIB_FN (int, gdk_pixbuf_get_width);
8111 DEF_IMGLIB_FN (int, gdk_pixbuf_get_height);
8112 DEF_IMGLIB_FN (guchar *, gdk_pixbuf_get_pixels);
8113 DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride);
8114 DEF_IMGLIB_FN (GdkColorspace, gdk_pixbuf_get_colorspace);
8115 DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels);
8116 DEF_IMGLIB_FN (gboolean, gdk_pixbuf_get_has_alpha);
8117 DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample);
8119 DEF_IMGLIB_FN (void, g_type_init);
8120 DEF_IMGLIB_FN (void, g_object_unref);
8121 DEF_IMGLIB_FN (void, g_error_free);
8123 Lisp_Object Qgdk_pixbuf, Qglib, Qgobject;
8125 static int
8126 init_svg_functions (Lisp_Object libraries)
8128 HMODULE library, gdklib, glib, gobject;
8130 if (!(glib = w32_delayed_load (libraries, Qglib))
8131 || !(gobject = w32_delayed_load (libraries, Qgobject))
8132 || !(gdklib = w32_delayed_load (libraries, Qgdk_pixbuf))
8133 || !(library = w32_delayed_load (libraries, Qsvg)))
8134 return 0;
8136 LOAD_IMGLIB_FN (library, rsvg_handle_new);
8137 LOAD_IMGLIB_FN (library, rsvg_handle_get_dimensions);
8138 LOAD_IMGLIB_FN (library, rsvg_handle_write);
8139 LOAD_IMGLIB_FN (library, rsvg_handle_close);
8140 LOAD_IMGLIB_FN (library, rsvg_handle_get_pixbuf);
8142 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_width);
8143 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_height);
8144 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_pixels);
8145 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_rowstride);
8146 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_colorspace);
8147 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_n_channels);
8148 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_has_alpha);
8149 LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_bits_per_sample);
8151 LOAD_IMGLIB_FN (gobject, g_type_init);
8152 LOAD_IMGLIB_FN (gobject, g_object_unref);
8153 LOAD_IMGLIB_FN (glib, g_error_free);
8155 return 1;
8158 #else
8159 /* The following aliases for library functions allow dynamic loading
8160 to be used on some platforms. */
8161 #define fn_rsvg_handle_new rsvg_handle_new
8162 #define fn_rsvg_handle_get_dimensions rsvg_handle_get_dimensions
8163 #define fn_rsvg_handle_write rsvg_handle_write
8164 #define fn_rsvg_handle_close rsvg_handle_close
8165 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8167 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8168 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8169 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8170 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8171 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8172 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8173 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8174 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8176 #define fn_g_type_init g_type_init
8177 #define fn_g_object_unref g_object_unref
8178 #define fn_g_error_free g_error_free
8179 #endif /* !HAVE_NTGUI */
8181 /* Load SVG image IMG for use on frame F. Value is non-zero if
8182 successful. this function will go into the svg_type structure, and
8183 the prototype thus needs to be compatible with that structure. */
8185 static int
8186 svg_load (struct frame *f, struct image *img)
8188 int success_p = 0;
8189 Lisp_Object file_name;
8191 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8192 file_name = image_spec_value (img->spec, QCfile, NULL);
8193 if (STRINGP (file_name))
8195 Lisp_Object file;
8196 unsigned char *contents;
8197 ptrdiff_t size;
8199 file = x_find_image_file (file_name);
8200 if (!STRINGP (file))
8202 image_error ("Cannot find image file `%s'", file_name, Qnil);
8203 return 0;
8206 /* Read the entire file into memory. */
8207 contents = slurp_file (SSDATA (file), &size);
8208 if (contents == NULL)
8210 image_error ("Error loading SVG image `%s'", img->spec, Qnil);
8211 return 0;
8213 /* If the file was slurped into memory properly, parse it. */
8214 success_p = svg_load_image (f, img, contents, size);
8215 xfree (contents);
8217 /* Else its not a file, its a lisp object. Load the image from a
8218 lisp object rather than a file. */
8219 else
8221 Lisp_Object data;
8223 data = image_spec_value (img->spec, QCdata, NULL);
8224 if (!STRINGP (data))
8226 image_error ("Invalid image data `%s'", data, Qnil);
8227 return 0;
8229 success_p = svg_load_image (f, img, SDATA (data), SBYTES (data));
8232 return success_p;
8235 /* svg_load_image is a helper function for svg_load, which does the
8236 actual loading given contents and size, apart from frame and image
8237 structures, passed from svg_load.
8239 Uses librsvg to do most of the image processing.
8241 Returns non-zero when successful. */
8242 static int
8243 svg_load_image (struct frame *f, /* Pointer to emacs frame structure. */
8244 struct image *img, /* Pointer to emacs image structure. */
8245 unsigned char *contents, /* String containing the SVG XML data to be parsed. */
8246 ptrdiff_t size) /* Size of data in bytes. */
8248 RsvgHandle *rsvg_handle;
8249 RsvgDimensionData dimension_data;
8250 GError *err = NULL;
8251 GdkPixbuf *pixbuf;
8252 int width;
8253 int height;
8254 const guint8 *pixels;
8255 int rowstride;
8256 XImagePtr ximg;
8257 Lisp_Object specified_bg;
8258 XColor background;
8259 int x;
8260 int y;
8262 /* g_type_init is a glib function that must be called prior to using
8263 gnome type library functions. */
8264 fn_g_type_init ();
8265 /* Make a handle to a new rsvg object. */
8266 rsvg_handle = fn_rsvg_handle_new ();
8268 /* Parse the contents argument and fill in the rsvg_handle. */
8269 fn_rsvg_handle_write (rsvg_handle, contents, size, &err);
8270 if (err) goto rsvg_error;
8272 /* The parsing is complete, rsvg_handle is ready to used, close it
8273 for further writes. */
8274 fn_rsvg_handle_close (rsvg_handle, &err);
8275 if (err) goto rsvg_error;
8277 fn_rsvg_handle_get_dimensions (rsvg_handle, &dimension_data);
8278 if (! check_image_size (f, dimension_data.width, dimension_data.height))
8280 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
8281 goto rsvg_error;
8284 /* We can now get a valid pixel buffer from the svg file, if all
8285 went ok. */
8286 pixbuf = fn_rsvg_handle_get_pixbuf (rsvg_handle);
8287 if (!pixbuf) goto rsvg_error;
8288 fn_g_object_unref (rsvg_handle);
8290 /* Extract some meta data from the svg handle. */
8291 width = fn_gdk_pixbuf_get_width (pixbuf);
8292 height = fn_gdk_pixbuf_get_height (pixbuf);
8293 pixels = fn_gdk_pixbuf_get_pixels (pixbuf);
8294 rowstride = fn_gdk_pixbuf_get_rowstride (pixbuf);
8296 /* Validate the svg meta data. */
8297 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
8298 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf) == 4);
8299 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf));
8300 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
8302 /* Try to create a x pixmap to hold the svg pixmap. */
8303 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
8305 fn_g_object_unref (pixbuf);
8306 return 0;
8309 init_color_table ();
8311 /* Handle alpha channel by combining the image with a background
8312 color. */
8313 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
8314 if (!STRINGP (specified_bg)
8315 || !x_defined_color (f, SSDATA (specified_bg), &background, 0))
8317 #ifndef HAVE_NS
8318 background.pixel = FRAME_BACKGROUND_PIXEL (f);
8319 x_query_color (f, &background);
8320 #else
8321 ns_query_color (FRAME_BACKGROUND_COLOR (f), &background, 1);
8322 #endif
8325 /* SVG pixmaps specify transparency in the last byte, so right
8326 shift 8 bits to get rid of it, since emacs doesn't support
8327 transparency. */
8328 background.red >>= 8;
8329 background.green >>= 8;
8330 background.blue >>= 8;
8332 /* This loop handles opacity values, since Emacs assumes
8333 non-transparent images. Each pixel must be "flattened" by
8334 calculating the resulting color, given the transparency of the
8335 pixel, and the image background color. */
8336 for (y = 0; y < height; ++y)
8338 for (x = 0; x < width; ++x)
8340 int red;
8341 int green;
8342 int blue;
8343 int opacity;
8345 red = *pixels++;
8346 green = *pixels++;
8347 blue = *pixels++;
8348 opacity = *pixels++;
8350 red = ((red * opacity)
8351 + (background.red * ((1 << 8) - opacity)));
8352 green = ((green * opacity)
8353 + (background.green * ((1 << 8) - opacity)));
8354 blue = ((blue * opacity)
8355 + (background.blue * ((1 << 8) - opacity)));
8357 XPutPixel (ximg, x, y, lookup_rgb_color (f, red, green, blue));
8360 pixels += rowstride - 4 * width;
8363 #ifdef COLOR_TABLE_SUPPORT
8364 /* Remember colors allocated for this image. */
8365 img->colors = colors_in_color_table (&img->ncolors);
8366 free_color_table ();
8367 #endif /* COLOR_TABLE_SUPPORT */
8369 fn_g_object_unref (pixbuf);
8371 img->width = width;
8372 img->height = height;
8374 /* Maybe fill in the background field while we have ximg handy.
8375 Casting avoids a GCC warning. */
8376 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
8378 /* Put the image into the pixmap, then free the X image and its
8379 buffer. */
8380 x_put_x_image (f, ximg, img->pixmap, width, height);
8381 x_destroy_x_image (ximg);
8383 return 1;
8385 rsvg_error:
8386 fn_g_object_unref (rsvg_handle);
8387 /* FIXME: Use error->message so the user knows what is the actual
8388 problem with the image. */
8389 image_error ("Error parsing SVG image `%s'", img->spec, Qnil);
8390 fn_g_error_free (err);
8391 return 0;
8394 #endif /* defined (HAVE_RSVG) */
8399 /***********************************************************************
8400 Ghostscript
8401 ***********************************************************************/
8403 #ifdef HAVE_X_WINDOWS
8404 #define HAVE_GHOSTSCRIPT 1
8405 #endif /* HAVE_X_WINDOWS */
8407 #ifdef HAVE_GHOSTSCRIPT
8409 static int gs_image_p (Lisp_Object object);
8410 static int gs_load (struct frame *f, struct image *img);
8411 static void gs_clear_image (struct frame *f, struct image *img);
8413 /* Keyword symbols. */
8415 static Lisp_Object QCloader, QCbounding_box, QCpt_width, QCpt_height;
8417 /* Indices of image specification fields in gs_format, below. */
8419 enum gs_keyword_index
8421 GS_TYPE,
8422 GS_PT_WIDTH,
8423 GS_PT_HEIGHT,
8424 GS_FILE,
8425 GS_LOADER,
8426 GS_BOUNDING_BOX,
8427 GS_ASCENT,
8428 GS_MARGIN,
8429 GS_RELIEF,
8430 GS_ALGORITHM,
8431 GS_HEURISTIC_MASK,
8432 GS_MASK,
8433 GS_BACKGROUND,
8434 GS_LAST
8437 /* Vector of image_keyword structures describing the format
8438 of valid user-defined image specifications. */
8440 static const struct image_keyword gs_format[GS_LAST] =
8442 {":type", IMAGE_SYMBOL_VALUE, 1},
8443 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE, 1},
8444 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE, 1},
8445 {":file", IMAGE_STRING_VALUE, 1},
8446 {":loader", IMAGE_FUNCTION_VALUE, 0},
8447 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE, 1},
8448 {":ascent", IMAGE_ASCENT_VALUE, 0},
8449 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR, 0},
8450 {":relief", IMAGE_INTEGER_VALUE, 0},
8451 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8452 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8453 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8454 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
8457 /* Structure describing the image type `ghostscript'. */
8459 static struct image_type gs_type =
8461 &Qpostscript,
8462 gs_image_p,
8463 gs_load,
8464 gs_clear_image,
8465 NULL
8469 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8471 static void
8472 gs_clear_image (struct frame *f, struct image *img)
8474 x_clear_image (f, img);
8478 /* Return non-zero if OBJECT is a valid Ghostscript image
8479 specification. */
8481 static int
8482 gs_image_p (Lisp_Object object)
8484 struct image_keyword fmt[GS_LAST];
8485 Lisp_Object tem;
8486 int i;
8488 memcpy (fmt, gs_format, sizeof fmt);
8490 if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript))
8491 return 0;
8493 /* Bounding box must be a list or vector containing 4 integers. */
8494 tem = fmt[GS_BOUNDING_BOX].value;
8495 if (CONSP (tem))
8497 for (i = 0; i < 4; ++i, tem = XCDR (tem))
8498 if (!CONSP (tem) || !INTEGERP (XCAR (tem)))
8499 return 0;
8500 if (!NILP (tem))
8501 return 0;
8503 else if (VECTORP (tem))
8505 if (ASIZE (tem) != 4)
8506 return 0;
8507 for (i = 0; i < 4; ++i)
8508 if (!INTEGERP (XVECTOR (tem)->contents[i]))
8509 return 0;
8511 else
8512 return 0;
8514 return 1;
8518 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8519 if successful. */
8521 static int
8522 gs_load (struct frame *f, struct image *img)
8524 uprintmax_t printnum1, printnum2;
8525 char buffer[sizeof " " + INT_STRLEN_BOUND (printmax_t)];
8526 Lisp_Object window_and_pixmap_id = Qnil, loader, pt_height, pt_width;
8527 Lisp_Object frame;
8528 double in_width, in_height;
8529 Lisp_Object pixel_colors = Qnil;
8531 /* Compute pixel size of pixmap needed from the given size in the
8532 image specification. Sizes in the specification are in pt. 1 pt
8533 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8534 info. */
8535 pt_width = image_spec_value (img->spec, QCpt_width, NULL);
8536 in_width = INTEGERP (pt_width) ? XFASTINT (pt_width) / 72.0 : 0;
8537 in_width *= FRAME_X_DISPLAY_INFO (f)->resx;
8538 pt_height = image_spec_value (img->spec, QCpt_height, NULL);
8539 in_height = INTEGERP (pt_height) ? XFASTINT (pt_height) / 72.0 : 0;
8540 in_height *= FRAME_X_DISPLAY_INFO (f)->resy;
8542 if (! (in_width <= INT_MAX && in_height <= INT_MAX
8543 && check_image_size (f, in_width, in_height)))
8545 image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
8546 return 0;
8548 img->width = in_width;
8549 img->height = in_height;
8551 /* Create the pixmap. */
8552 xassert (img->pixmap == NO_PIXMAP);
8554 if (x_check_image_size (0, img->width, img->height))
8556 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8557 BLOCK_INPUT;
8558 img->pixmap = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8559 img->width, img->height,
8560 DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
8561 UNBLOCK_INPUT;
8564 if (!img->pixmap)
8566 image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
8567 return 0;
8570 /* Call the loader to fill the pixmap. It returns a process object
8571 if successful. We do not record_unwind_protect here because
8572 other places in redisplay like calling window scroll functions
8573 don't either. Let the Lisp loader use `unwind-protect' instead. */
8574 printnum1 = FRAME_X_WINDOW (f);
8575 printnum2 = img->pixmap;
8576 sprintf (buffer, "%"pMu" %"pMu, printnum1, printnum2);
8577 window_and_pixmap_id = build_string (buffer);
8579 printnum1 = FRAME_FOREGROUND_PIXEL (f);
8580 printnum2 = FRAME_BACKGROUND_PIXEL (f);
8581 sprintf (buffer, "%"pMu" %"pMu, printnum1, printnum2);
8582 pixel_colors = build_string (buffer);
8584 XSETFRAME (frame, f);
8585 loader = image_spec_value (img->spec, QCloader, NULL);
8586 if (NILP (loader))
8587 loader = intern ("gs-load-image");
8589 img->lisp_data = call6 (loader, frame, img->spec,
8590 make_number (img->width),
8591 make_number (img->height),
8592 window_and_pixmap_id,
8593 pixel_colors);
8594 return PROCESSP (img->lisp_data);
8598 /* Kill the Ghostscript process that was started to fill PIXMAP on
8599 frame F. Called from XTread_socket when receiving an event
8600 telling Emacs that Ghostscript has finished drawing. */
8602 void
8603 x_kill_gs_process (Pixmap pixmap, struct frame *f)
8605 struct image_cache *c = FRAME_IMAGE_CACHE (f);
8606 int class;
8607 ptrdiff_t i;
8608 struct image *img;
8610 /* Find the image containing PIXMAP. */
8611 for (i = 0; i < c->used; ++i)
8612 if (c->images[i]->pixmap == pixmap)
8613 break;
8615 /* Should someone in between have cleared the image cache, for
8616 instance, give up. */
8617 if (i == c->used)
8618 return;
8620 /* Kill the GS process. We should have found PIXMAP in the image
8621 cache and its image should contain a process object. */
8622 img = c->images[i];
8623 xassert (PROCESSP (img->lisp_data));
8624 Fkill_process (img->lisp_data, Qnil);
8625 img->lisp_data = Qnil;
8627 #if defined (HAVE_X_WINDOWS)
8629 /* On displays with a mutable colormap, figure out the colors
8630 allocated for the image by looking at the pixels of an XImage for
8631 img->pixmap. */
8632 class = FRAME_X_VISUAL (f)->class;
8633 if (class != StaticColor && class != StaticGray && class != TrueColor)
8635 XImagePtr ximg;
8637 BLOCK_INPUT;
8639 /* Try to get an XImage for img->pixmep. */
8640 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
8641 0, 0, img->width, img->height, ~0, ZPixmap);
8642 if (ximg)
8644 int x, y;
8646 /* Initialize the color table. */
8647 init_color_table ();
8649 /* For each pixel of the image, look its color up in the
8650 color table. After having done so, the color table will
8651 contain an entry for each color used by the image. */
8652 for (y = 0; y < img->height; ++y)
8653 for (x = 0; x < img->width; ++x)
8655 unsigned long pixel = XGetPixel (ximg, x, y);
8656 lookup_pixel_color (f, pixel);
8659 /* Record colors in the image. Free color table and XImage. */
8660 #ifdef COLOR_TABLE_SUPPORT
8661 img->colors = colors_in_color_table (&img->ncolors);
8662 free_color_table ();
8663 #endif
8664 XDestroyImage (ximg);
8666 #if 0 /* This doesn't seem to be the case. If we free the colors
8667 here, we get a BadAccess later in x_clear_image when
8668 freeing the colors. */
8669 /* We have allocated colors once, but Ghostscript has also
8670 allocated colors on behalf of us. So, to get the
8671 reference counts right, free them once. */
8672 if (img->ncolors)
8673 x_free_colors (f, img->colors, img->ncolors);
8674 #endif
8676 else
8677 image_error ("Cannot get X image of `%s'; colors will not be freed",
8678 img->spec, Qnil);
8680 UNBLOCK_INPUT;
8682 #endif /* HAVE_X_WINDOWS */
8684 /* Now that we have the pixmap, compute mask and transform the
8685 image if requested. */
8686 BLOCK_INPUT;
8687 postprocess_image (f, img);
8688 UNBLOCK_INPUT;
8691 #endif /* HAVE_GHOSTSCRIPT */
8694 /***********************************************************************
8695 Tests
8696 ***********************************************************************/
8698 #if GLYPH_DEBUG
8700 DEFUN ("imagep", Fimagep, Simagep, 1, 1, 0,
8701 doc: /* Value is non-nil if SPEC is a valid image specification. */)
8702 (Lisp_Object spec)
8704 return valid_image_p (spec) ? Qt : Qnil;
8708 DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
8709 (Lisp_Object spec)
8711 ptrdiff_t id = -1;
8713 if (valid_image_p (spec))
8714 id = lookup_image (SELECTED_FRAME (), spec);
8716 debug_print (spec);
8717 return make_number (id);
8720 #endif /* GLYPH_DEBUG != 0 */
8723 /***********************************************************************
8724 Initialization
8725 ***********************************************************************/
8727 #ifdef HAVE_NTGUI
8728 /* Image types that rely on external libraries are loaded dynamically
8729 if the library is available. */
8730 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8731 define_image_type (image_type, init_lib_fn (libraries))
8732 #else
8733 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8734 define_image_type (image_type, 1)
8735 #endif /* HAVE_NTGUI */
8737 DEFUN ("init-image-library", Finit_image_library, Sinit_image_library, 2, 2, 0,
8738 doc: /* Initialize image library implementing image type TYPE.
8739 Return non-nil if TYPE is a supported image type.
8741 Image types pbm and xbm are prebuilt; other types are loaded here.
8742 Libraries to load are specified in alist LIBRARIES (usually, the value
8743 of `dynamic-library-alist', which see). */)
8744 (Lisp_Object type, Lisp_Object libraries)
8746 #ifdef HAVE_NTGUI
8747 /* Don't try to reload the library. */
8748 Lisp_Object tested = Fassq (type, Vlibrary_cache);
8749 if (CONSP (tested))
8750 return XCDR (tested);
8751 #endif
8753 /* Types pbm and xbm are built-in and always available. */
8754 if (EQ (type, Qpbm) || EQ (type, Qxbm))
8755 return Qt;
8757 #if defined (HAVE_XPM) || defined (HAVE_NS)
8758 if (EQ (type, Qxpm))
8759 return CHECK_LIB_AVAILABLE (&xpm_type, init_xpm_functions, libraries);
8760 #endif
8762 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8763 if (EQ (type, Qjpeg))
8764 return CHECK_LIB_AVAILABLE (&jpeg_type, init_jpeg_functions, libraries);
8765 #endif
8767 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8768 if (EQ (type, Qtiff))
8769 return CHECK_LIB_AVAILABLE (&tiff_type, init_tiff_functions, libraries);
8770 #endif
8772 #if defined (HAVE_GIF) || defined (HAVE_NS)
8773 if (EQ (type, Qgif))
8774 return CHECK_LIB_AVAILABLE (&gif_type, init_gif_functions, libraries);
8775 #endif
8777 #if defined (HAVE_PNG) || defined (HAVE_NS)
8778 if (EQ (type, Qpng))
8779 return CHECK_LIB_AVAILABLE (&png_type, init_png_functions, libraries);
8780 #endif
8782 #if defined (HAVE_RSVG)
8783 if (EQ (type, Qsvg))
8784 return CHECK_LIB_AVAILABLE (&svg_type, init_svg_functions, libraries);
8785 #endif
8787 #if defined (HAVE_IMAGEMAGICK)
8788 if (EQ (type, Qimagemagick))
8789 return CHECK_LIB_AVAILABLE (&imagemagick_type, init_imagemagick_functions,
8790 libraries);
8791 #endif
8793 #ifdef HAVE_GHOSTSCRIPT
8794 if (EQ (type, Qpostscript))
8795 return CHECK_LIB_AVAILABLE (&gs_type, init_gs_functions, libraries);
8796 #endif
8798 /* If the type is not recognized, avoid testing it ever again. */
8799 CACHE_IMAGE_TYPE (type, Qnil);
8800 return Qnil;
8803 void
8804 syms_of_image (void)
8806 /* Initialize this only once, since that's what we do with Vimage_types
8807 and they are supposed to be in sync. Initializing here gives correct
8808 operation on GNU/Linux of calling dump-emacs after loading some images. */
8809 image_types = NULL;
8811 /* Must be defined now because we're going to update it below, while
8812 defining the supported image types. */
8813 DEFVAR_LISP ("image-types", Vimage_types,
8814 doc: /* List of potentially supported image types.
8815 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
8816 To check whether it is really supported, use `image-type-available-p'. */);
8817 Vimage_types = Qnil;
8819 DEFVAR_LISP ("max-image-size", Vmax_image_size,
8820 doc: /* Maximum size of images.
8821 Emacs will not load an image into memory if its pixel width or
8822 pixel height exceeds this limit.
8824 If the value is an integer, it directly specifies the maximum
8825 image height and width, measured in pixels. If it is a floating
8826 point number, it specifies the maximum image height and width
8827 as a ratio to the frame height and width. If the value is
8828 non-numeric, there is no explicit limit on the size of images. */);
8829 Vmax_image_size = make_float (MAX_IMAGE_SIZE);
8831 DEFSYM (Qpbm, "pbm");
8832 ADD_IMAGE_TYPE (Qpbm);
8834 DEFSYM (Qxbm, "xbm");
8835 ADD_IMAGE_TYPE (Qxbm);
8837 define_image_type (&xbm_type, 1);
8838 define_image_type (&pbm_type, 1);
8840 DEFSYM (Qcount, "count");
8841 DEFSYM (Qextension_data, "extension-data");
8842 DEFSYM (Qdelay, "delay");
8844 DEFSYM (QCascent, ":ascent");
8845 DEFSYM (QCmargin, ":margin");
8846 DEFSYM (QCrelief, ":relief");
8847 DEFSYM (QCconversion, ":conversion");
8848 DEFSYM (QCcolor_symbols, ":color-symbols");
8849 DEFSYM (QCheuristic_mask, ":heuristic-mask");
8850 DEFSYM (QCindex, ":index");
8851 DEFSYM (QCgeometry, ":geometry");
8852 DEFSYM (QCcrop, ":crop");
8853 DEFSYM (QCrotation, ":rotation");
8854 DEFSYM (QCmatrix, ":matrix");
8855 DEFSYM (QCcolor_adjustment, ":color-adjustment");
8856 DEFSYM (QCmask, ":mask");
8858 DEFSYM (Qlaplace, "laplace");
8859 DEFSYM (Qemboss, "emboss");
8860 DEFSYM (Qedge_detection, "edge-detection");
8861 DEFSYM (Qheuristic, "heuristic");
8863 DEFSYM (Qpostscript, "postscript");
8864 #ifdef HAVE_GHOSTSCRIPT
8865 ADD_IMAGE_TYPE (Qpostscript);
8866 DEFSYM (QCloader, ":loader");
8867 DEFSYM (QCbounding_box, ":bounding-box");
8868 DEFSYM (QCpt_width, ":pt-width");
8869 DEFSYM (QCpt_height, ":pt-height");
8870 #endif /* HAVE_GHOSTSCRIPT */
8872 #ifdef HAVE_NTGUI
8873 DEFSYM (Qlibpng_version, "libpng-version");
8874 Fset (Qlibpng_version,
8875 #if HAVE_PNG
8876 make_number (PNG_LIBPNG_VER)
8877 #else
8878 make_number (-1)
8879 #endif
8881 #endif
8883 #if defined (HAVE_XPM) || defined (HAVE_NS)
8884 DEFSYM (Qxpm, "xpm");
8885 ADD_IMAGE_TYPE (Qxpm);
8886 #endif
8888 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8889 DEFSYM (Qjpeg, "jpeg");
8890 ADD_IMAGE_TYPE (Qjpeg);
8891 #endif
8893 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8894 DEFSYM (Qtiff, "tiff");
8895 ADD_IMAGE_TYPE (Qtiff);
8896 #endif
8898 #if defined (HAVE_GIF) || defined (HAVE_NS)
8899 DEFSYM (Qgif, "gif");
8900 ADD_IMAGE_TYPE (Qgif);
8901 #endif
8903 #if defined (HAVE_PNG) || defined (HAVE_NS)
8904 DEFSYM (Qpng, "png");
8905 ADD_IMAGE_TYPE (Qpng);
8906 #endif
8908 #if defined (HAVE_IMAGEMAGICK)
8909 DEFSYM (Qimagemagick, "imagemagick");
8910 ADD_IMAGE_TYPE (Qimagemagick);
8911 #endif
8913 #if defined (HAVE_RSVG)
8914 DEFSYM (Qsvg, "svg");
8915 ADD_IMAGE_TYPE (Qsvg);
8916 #ifdef HAVE_NTGUI
8917 /* Other libraries used directly by svg code. */
8918 DEFSYM (Qgdk_pixbuf, "gdk-pixbuf");
8919 DEFSYM (Qglib, "glib");
8920 DEFSYM (Qgobject, "gobject");
8921 #endif /* HAVE_NTGUI */
8922 #endif /* HAVE_RSVG */
8924 defsubr (&Sinit_image_library);
8925 #ifdef HAVE_IMAGEMAGICK
8926 defsubr (&Simagemagick_types);
8927 #endif
8928 defsubr (&Sclear_image_cache);
8929 defsubr (&Simage_flush);
8930 defsubr (&Simage_size);
8931 defsubr (&Simage_mask_p);
8932 defsubr (&Simage_metadata);
8934 #if GLYPH_DEBUG
8935 defsubr (&Simagep);
8936 defsubr (&Slookup_image);
8937 #endif
8939 DEFVAR_BOOL ("cross-disabled-images", cross_disabled_images,
8940 doc: /* Non-nil means always draw a cross over disabled images.
8941 Disabled images are those having a `:conversion disabled' property.
8942 A cross is always drawn on black & white displays. */);
8943 cross_disabled_images = 0;
8945 DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path,
8946 doc: /* List of directories to search for window system bitmap files. */);
8947 Vx_bitmap_file_path = decode_env_path ((char *) 0, PATH_BITMAPS);
8949 DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay,
8950 doc: /* Maximum time after which images are removed from the cache.
8951 When an image has not been displayed this many seconds, Emacs
8952 automatically removes it from the image cache. If the cache contains
8953 a large number of images, the actual eviction time may be shorter.
8954 The value can also be nil, meaning the cache is never cleared.
8956 The function `clear-image-cache' disregards this variable. */);
8957 Vimage_cache_eviction_delay = make_number (300);
8958 #ifdef HAVE_IMAGEMAGICK
8959 DEFVAR_INT ("imagemagick-render-type", imagemagick_render_type,
8960 doc: /* Integer indicating which ImageMagick rendering method to use.
8961 The options are:
8962 0 -- the default method (pixel pushing)
8963 1 -- a newer method ("MagickExportImagePixels") that may perform
8964 better (speed etc) in some cases, but has not been as thoroughly
8965 tested with Emacs as the default method. This method requires
8966 ImageMagick version 6.4.6 (approximately) or later.
8967 */);
8968 /* MagickExportImagePixels is in 6.4.6-9, but not 6.4.4-10. */
8969 imagemagick_render_type = 0;
8970 #endif
8974 void
8975 init_image (void)