1 /* Functions for image support on window system.
2 Copyright (C) 1989, 1992-2011 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/>. */
26 #if defined HAVE_LIBPNG_PNG_H
27 # include <libpng/png.h>
35 /* This makes the fields of a Display accessible, in Xlib header files. */
37 #define XLIB_ILLEGAL_ACCESS
42 #include "dispextern.h"
43 #include "blockinput.h"
46 #include "character.h"
48 #include "termhooks.h"
53 #include <sys/types.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 */
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)
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 */
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)
112 #define RGB_PIXEL_COLOR unsigned long
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
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
,
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 static unsigned long lookup_pixel_color (struct frame
*f
, unsigned long p
);
141 static Lisp_Object
Finit_image_library (Lisp_Object
, Lisp_Object
);
143 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
144 id, which is just an int that this section returns. Bitmaps are
145 reference counted so they can be shared among frames.
147 Bitmap indices are guaranteed to be > 0, so a negative number can
148 be used to indicate no bitmap.
150 If you use x_create_bitmap_from_data, then you must keep track of
151 the bitmaps yourself. That is, creating a bitmap from the same
152 data more than once will not be caught. */
156 XGetImage (Display
*display
, Pixmap pixmap
, int x
, int y
,
157 unsigned int width
, unsigned int height
,
158 unsigned long plane_mask
, int format
)
160 /* TODO: not sure what this function is supposed to do.. */
161 ns_retain_object (pixmap
);
165 /* use with imgs created by ns_image_for_XPM */
167 XGetPixel (XImagePtr ximage
, int x
, int y
)
169 return ns_get_pixel (ximage
, x
, y
);
172 /* use with imgs created by ns_image_for_XPM; alpha set to 1;
173 pixel is assumed to be in form RGB */
175 XPutPixel (XImagePtr ximage
, int x
, int y
, unsigned long pixel
)
177 ns_put_pixel (ximage
, x
, y
, pixel
);
182 /* Functions to access the contents of a bitmap, given an id. */
185 x_bitmap_height (FRAME_PTR f
, ptrdiff_t id
)
187 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
191 x_bitmap_width (FRAME_PTR f
, ptrdiff_t id
)
193 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
196 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
198 x_bitmap_pixmap (FRAME_PTR f
, ptrdiff_t id
)
200 return (int) FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
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
;
212 /* Allocate a new bitmap record. Returns index of new record. */
215 x_allocate_bitmap_record (FRAME_PTR f
)
217 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
220 if (dpyinfo
->bitmaps
== NULL
)
222 dpyinfo
->bitmaps_size
= 10;
224 = (Bitmap_Record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
225 dpyinfo
->bitmaps_last
= 1;
229 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
230 return ++dpyinfo
->bitmaps_last
;
232 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
233 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
236 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (Bitmap_Record
) / 2
237 < dpyinfo
->bitmaps_size
)
238 memory_full (SIZE_MAX
);
239 dpyinfo
->bitmaps_size
*= 2;
241 = (Bitmap_Record
*) xrealloc (dpyinfo
->bitmaps
,
242 dpyinfo
->bitmaps_size
* sizeof (Bitmap_Record
));
243 return ++dpyinfo
->bitmaps_last
;
246 /* Add one reference to the reference count of the bitmap with id ID. */
249 x_reference_bitmap (FRAME_PTR f
, int id
)
251 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
254 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
257 x_create_bitmap_from_data (struct frame
*f
, char *bits
, unsigned int width
, unsigned int height
)
259 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
262 #ifdef HAVE_X_WINDOWS
264 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
265 bits
, width
, height
);
268 #endif /* HAVE_X_WINDOWS */
272 bitmap
= CreateBitmap (width
, height
,
273 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
274 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
278 #endif /* HAVE_NTGUI */
281 void *bitmap
= ns_image_from_XBM (bits
, width
, height
);
286 id
= x_allocate_bitmap_record (f
);
289 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
290 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
293 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
294 dpyinfo
->bitmaps
[id
- 1].height
= height
;
295 dpyinfo
->bitmaps
[id
- 1].width
= width
;
296 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
298 #ifdef HAVE_X_WINDOWS
299 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
300 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
301 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
302 #endif /* HAVE_X_WINDOWS */
305 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
306 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
307 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
308 #endif /* HAVE_NTGUI */
313 /* Create bitmap from file FILE for frame F. */
316 x_create_bitmap_from_file (struct frame
*f
, Lisp_Object file
)
318 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
321 return -1; /* W32_TODO : bitmap support */
322 #endif /* HAVE_NTGUI */
326 void *bitmap
= ns_image_from_file (file
);
332 id
= x_allocate_bitmap_record (f
);
333 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
334 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
335 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
336 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
337 dpyinfo
->bitmaps
[id
- 1].height
= ns_image_width (bitmap
);
338 dpyinfo
->bitmaps
[id
- 1].width
= ns_image_height (bitmap
);
339 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
343 #ifdef HAVE_X_WINDOWS
344 unsigned int width
, height
;
346 int xhot
, yhot
, result
;
352 /* Look for an existing bitmap with the same name. */
353 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
355 if (dpyinfo
->bitmaps
[id
].refcount
356 && dpyinfo
->bitmaps
[id
].file
357 && !strcmp (dpyinfo
->bitmaps
[id
].file
, SSDATA (file
)))
359 ++dpyinfo
->bitmaps
[id
].refcount
;
364 /* Search bitmap-file-path for the file, if appropriate. */
365 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
370 filename
= SSDATA (found
);
372 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
373 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
374 if (result
!= BitmapSuccess
)
377 id
= x_allocate_bitmap_record (f
);
378 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
379 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
380 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
381 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
382 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
383 dpyinfo
->bitmaps
[id
- 1].height
= height
;
384 dpyinfo
->bitmaps
[id
- 1].width
= width
;
385 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SSDATA (file
));
388 #endif /* HAVE_X_WINDOWS */
394 free_bitmap_record (Display_Info
*dpyinfo
, Bitmap_Record
*bm
)
396 #ifdef HAVE_X_WINDOWS
397 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
399 XFreePixmap (dpyinfo
->display
, bm
->mask
);
400 #endif /* HAVE_X_WINDOWS */
403 DeleteObject (bm
->pixmap
);
404 #endif /* HAVE_NTGUI */
407 ns_release_object (bm
->img
);
417 /* Remove reference to bitmap with id number ID. */
420 x_destroy_bitmap (FRAME_PTR f
, ptrdiff_t id
)
422 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
426 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
428 if (--bm
->refcount
== 0)
431 free_bitmap_record (dpyinfo
, bm
);
437 /* Free all the bitmaps for the display specified by DPYINFO. */
440 x_destroy_all_bitmaps (Display_Info
*dpyinfo
)
443 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
445 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
446 if (bm
->refcount
> 0)
447 free_bitmap_record (dpyinfo
, bm
);
449 dpyinfo
->bitmaps_last
= 0;
453 #ifdef HAVE_X_WINDOWS
455 /* Useful functions defined in the section
456 `Image type independent image structures' below. */
458 static unsigned long four_corners_best (XImagePtr ximg
,
461 unsigned long height
);
463 static int x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
,
464 int depth
, XImagePtr
*ximg
,
467 static void x_destroy_x_image (XImagePtr ximg
);
470 /* Create a mask of a bitmap. Note is this not a perfect mask.
471 It's nicer with some borders in this context */
474 x_create_bitmap_mask (struct frame
*f
, ptrdiff_t id
)
477 XImagePtr ximg
, mask_img
;
478 unsigned long width
, height
;
481 unsigned long x
, y
, xp
, xm
, yp
, ym
;
484 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
489 pixmap
= x_bitmap_pixmap (f
, id
);
490 width
= x_bitmap_width (f
, id
);
491 height
= x_bitmap_height (f
, id
);
494 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
503 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
508 XDestroyImage (ximg
);
512 bg
= four_corners_best (ximg
, NULL
, width
, height
);
514 for (y
= 0; y
< ximg
->height
; ++y
)
516 for (x
= 0; x
< ximg
->width
; ++x
)
518 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
519 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
520 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
521 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
522 if (XGetPixel (ximg
, x
, y
) == bg
523 && XGetPixel (ximg
, x
, yp
) == bg
524 && XGetPixel (ximg
, x
, ym
) == bg
525 && XGetPixel (ximg
, xp
, y
) == bg
526 && XGetPixel (ximg
, xp
, yp
) == bg
527 && XGetPixel (ximg
, xp
, ym
) == bg
528 && XGetPixel (ximg
, xm
, y
) == bg
529 && XGetPixel (ximg
, xm
, yp
) == bg
530 && XGetPixel (ximg
, xm
, ym
) == bg
)
531 XPutPixel (mask_img
, x
, y
, 0);
533 XPutPixel (mask_img
, x
, y
, 1);
537 xassert (interrupt_input_blocked
);
538 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
539 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
541 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
543 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
544 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
546 XDestroyImage (ximg
);
547 x_destroy_x_image (mask_img
);
552 #endif /* HAVE_X_WINDOWS */
555 /***********************************************************************
557 ***********************************************************************/
559 /* List of supported image types. Use define_image_type to add new
560 types. Use lookup_image_type to find a type for a given symbol. */
562 static struct image_type
*image_types
;
564 /* The symbol `xbm' which is used as the type symbol for XBM images. */
566 static Lisp_Object Qxbm
;
570 Lisp_Object QCascent
, QCmargin
, QCrelief
;
571 Lisp_Object QCconversion
;
572 static Lisp_Object QCheuristic_mask
;
573 static Lisp_Object QCcolor_symbols
;
574 static Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
, QCgeometry
;
575 static Lisp_Object QCcrop
, QCrotation
;
579 static Lisp_Object Qcount
, Qextension_data
, Qdelay
;
580 static Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
582 /* Function prototypes. */
584 static Lisp_Object
define_image_type (struct image_type
*type
, int loaded
);
585 static struct image_type
*lookup_image_type (Lisp_Object symbol
);
586 static void image_error (const char *format
, Lisp_Object
, Lisp_Object
);
587 static void x_laplace (struct frame
*, struct image
*);
588 static void x_emboss (struct frame
*, struct image
*);
589 static int x_build_heuristic_mask (struct frame
*, struct image
*,
592 #define CACHE_IMAGE_TYPE(type, status) \
593 do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
595 #define CACHE_IMAGE_TYPE(type, status)
598 #define ADD_IMAGE_TYPE(type) \
599 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
601 /* Define a new image type from TYPE. This adds a copy of TYPE to
602 image_types and caches the loading status of TYPE. */
605 define_image_type (struct image_type
*type
, int loaded
)
613 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
614 The initialized data segment is read-only. */
615 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
616 memcpy (p
, type
, sizeof *p
);
617 p
->next
= image_types
;
622 CACHE_IMAGE_TYPE (*type
->type
, success
);
627 /* Look up image type SYMBOL, and return a pointer to its image_type
628 structure. Value is null if SYMBOL is not a known image type. */
630 static inline struct image_type
*
631 lookup_image_type (Lisp_Object symbol
)
633 struct image_type
*type
;
635 /* We must initialize the image-type if it hasn't been already. */
636 if (NILP (Finit_image_library (symbol
, Vdynamic_library_alist
)))
637 return 0; /* unimplemented */
639 for (type
= image_types
; type
; type
= type
->next
)
640 if (EQ (symbol
, *type
->type
))
647 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
648 valid image specification is a list whose car is the symbol
649 `image', and whose rest is a property list. The property list must
650 contain a value for key `:type'. That value must be the name of a
651 supported image type. The rest of the property list depends on the
655 valid_image_p (Lisp_Object object
)
663 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
664 if (EQ (XCAR (tem
), QCtype
))
667 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
669 struct image_type
*type
;
670 type
= lookup_image_type (XCAR (tem
));
672 valid_p
= type
->valid_p (object
);
683 /* Log error message with format string FORMAT and argument ARG.
684 Signaling an error, e.g. when an image cannot be loaded, is not a
685 good idea because this would interrupt redisplay, and the error
686 message display would lead to another redisplay. This function
687 therefore simply displays a message. */
690 image_error (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
692 add_to_log (format
, arg1
, arg2
);
697 /***********************************************************************
699 ***********************************************************************/
701 enum image_value_type
703 IMAGE_DONT_CHECK_VALUE_TYPE
,
705 IMAGE_STRING_OR_NIL_VALUE
,
707 IMAGE_POSITIVE_INTEGER_VALUE
,
708 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
709 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
712 IMAGE_FUNCTION_VALUE
,
717 /* Structure used when parsing image specifications. */
721 /* Name of keyword. */
724 /* The type of value allowed. */
725 enum image_value_type type
;
727 /* Non-zero means key must be present. */
730 /* Used to recognize duplicate keywords in a property list. */
733 /* The value that was found. */
738 static int parse_image_spec (Lisp_Object
, struct image_keyword
*,
740 static Lisp_Object
image_spec_value (Lisp_Object
, Lisp_Object
, int *);
743 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
744 has the format (image KEYWORD VALUE ...). One of the keyword/
745 value pairs must be `:type TYPE'. KEYWORDS is a vector of
746 image_keywords structures of size NKEYWORDS describing other
747 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
750 parse_image_spec (Lisp_Object spec
, struct image_keyword
*keywords
,
751 int nkeywords
, Lisp_Object type
)
760 while (CONSP (plist
))
762 Lisp_Object key
, value
;
764 /* First element of a pair must be a symbol. */
766 plist
= XCDR (plist
);
770 /* There must follow a value. */
773 value
= XCAR (plist
);
774 plist
= XCDR (plist
);
776 /* Find key in KEYWORDS. Error if not found. */
777 for (i
= 0; i
< nkeywords
; ++i
)
778 if (strcmp (keywords
[i
].name
, SSDATA (SYMBOL_NAME (key
))) == 0)
784 /* Record that we recognized the keyword. If a keywords
785 was found more than once, it's an error. */
786 keywords
[i
].value
= value
;
789 if (keywords
[i
].count
> 1)
792 /* Check type of value against allowed type. */
793 switch (keywords
[i
].type
)
795 case IMAGE_STRING_VALUE
:
796 if (!STRINGP (value
))
800 case IMAGE_STRING_OR_NIL_VALUE
:
801 if (!STRINGP (value
) && !NILP (value
))
805 case IMAGE_SYMBOL_VALUE
:
806 if (!SYMBOLP (value
))
810 case IMAGE_POSITIVE_INTEGER_VALUE
:
811 if (!INTEGERP (value
) || XINT (value
) <= 0)
815 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
816 if (INTEGERP (value
) && XINT (value
) >= 0)
819 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
820 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
824 case IMAGE_ASCENT_VALUE
:
825 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
827 else if (INTEGERP (value
)
829 && XINT (value
) <= 100)
833 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
834 if (!INTEGERP (value
) || XINT (value
) < 0)
838 case IMAGE_DONT_CHECK_VALUE_TYPE
:
841 case IMAGE_FUNCTION_VALUE
:
842 value
= indirect_function (value
);
843 if (!NILP (Ffunctionp (value
)))
847 case IMAGE_NUMBER_VALUE
:
848 if (!INTEGERP (value
) && !FLOATP (value
))
852 case IMAGE_INTEGER_VALUE
:
853 if (!INTEGERP (value
))
857 case IMAGE_BOOL_VALUE
:
858 if (!NILP (value
) && !EQ (value
, Qt
))
867 if (EQ (key
, QCtype
) && !EQ (type
, value
))
871 /* Check that all mandatory fields are present. */
872 for (i
= 0; i
< nkeywords
; ++i
)
873 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
880 /* Return the value of KEY in image specification SPEC. Value is nil
881 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
882 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
885 image_spec_value (Lisp_Object spec
, Lisp_Object key
, int *found
)
889 xassert (valid_image_p (spec
));
891 for (tail
= XCDR (spec
);
892 CONSP (tail
) && CONSP (XCDR (tail
));
893 tail
= XCDR (XCDR (tail
)))
895 if (EQ (XCAR (tail
), key
))
899 return XCAR (XCDR (tail
));
909 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
910 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
911 PIXELS non-nil means return the size in pixels, otherwise return the
912 size in canonical character units.
913 FRAME is the frame on which the image will be displayed. FRAME nil
914 or omitted means use the selected frame. */)
915 (Lisp_Object spec
, Lisp_Object pixels
, Lisp_Object frame
)
920 if (valid_image_p (spec
))
922 struct frame
*f
= check_x_frame (frame
);
923 int id
= lookup_image (f
, spec
);
924 struct image
*img
= IMAGE_FROM_ID (f
, id
);
925 int width
= img
->width
+ 2 * img
->hmargin
;
926 int height
= img
->height
+ 2 * img
->vmargin
;
929 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
930 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
932 size
= Fcons (make_number (width
), make_number (height
));
935 error ("Invalid image specification");
941 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
942 doc
: /* Return t if image SPEC has a mask bitmap.
943 FRAME is the frame on which the image will be displayed. FRAME nil
944 or omitted means use the selected frame. */)
945 (Lisp_Object spec
, Lisp_Object frame
)
950 if (valid_image_p (spec
))
952 struct frame
*f
= check_x_frame (frame
);
953 int id
= lookup_image (f
, spec
);
954 struct image
*img
= IMAGE_FROM_ID (f
, id
);
959 error ("Invalid image specification");
964 DEFUN ("image-metadata", Fimage_metadata
, Simage_metadata
, 1, 2, 0,
965 doc
: /* Return metadata for image SPEC.
966 FRAME is the frame on which the image will be displayed. FRAME nil
967 or omitted means use the selected frame. */)
968 (Lisp_Object spec
, Lisp_Object frame
)
973 if (valid_image_p (spec
))
975 struct frame
*f
= check_x_frame (frame
);
976 int id
= lookup_image (f
, spec
);
977 struct image
*img
= IMAGE_FROM_ID (f
, id
);
978 ext
= img
->lisp_data
;
985 /***********************************************************************
986 Image type independent image structures
987 ***********************************************************************/
989 static void free_image (struct frame
*f
, struct image
*img
);
990 static int check_image_size (struct frame
*f
, int width
, int height
);
992 #define MAX_IMAGE_SIZE 6.0
993 /* Allocate and return a new image structure for image specification
994 SPEC. SPEC has a hash value of HASH. */
996 static struct image
*
997 make_image (Lisp_Object spec
, EMACS_UINT hash
)
999 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
1000 Lisp_Object file
= image_spec_value (spec
, QCfile
, NULL
);
1002 xassert (valid_image_p (spec
));
1003 memset (img
, 0, sizeof *img
);
1004 img
->dependencies
= NILP (file
) ? Qnil
: list1 (file
);
1005 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
1006 xassert (img
->type
!= NULL
);
1008 img
->lisp_data
= Qnil
;
1009 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
1011 img
->corners
[BOT_CORNER
] = -1; /* Full image */
1016 /* Free image IMG which was used on frame F, including its resources. */
1019 free_image (struct frame
*f
, struct image
*img
)
1023 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1025 /* Remove IMG from the hash table of its cache. */
1027 img
->prev
->next
= img
->next
;
1029 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1032 img
->next
->prev
= img
->prev
;
1034 c
->images
[img
->id
] = NULL
;
1036 /* Free resources, then free IMG. */
1037 img
->type
->free (f
, img
);
1042 /* Return 1 if the given widths and heights are valid for display;
1043 otherwise, return 0. */
1046 check_image_size (struct frame
*f
, int width
, int height
)
1050 if (width
<= 0 || height
<= 0)
1053 if (INTEGERP (Vmax_image_size
))
1054 w
= h
= XINT (Vmax_image_size
);
1055 else if (FLOATP (Vmax_image_size
))
1059 w
= FRAME_PIXEL_WIDTH (f
);
1060 h
= FRAME_PIXEL_HEIGHT (f
);
1063 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1064 w
= (int) (XFLOAT_DATA (Vmax_image_size
) * w
);
1065 h
= (int) (XFLOAT_DATA (Vmax_image_size
) * h
);
1070 return (width
<= w
&& height
<= h
);
1073 /* Prepare image IMG for display on frame F. Must be called before
1074 drawing an image. */
1077 prepare_image_for_display (struct frame
*f
, struct image
*img
)
1081 /* We're about to display IMG, so set its timestamp to `now'. */
1083 img
->timestamp
= EMACS_SECS (t
);
1085 /* If IMG doesn't have a pixmap yet, load it now, using the image
1086 type dependent loader function. */
1087 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1088 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1093 /* Value is the number of pixels for the ascent of image IMG when
1094 drawn in face FACE. */
1097 image_ascent (struct image
*img
, struct face
*face
, struct glyph_slice
*slice
)
1102 if (slice
->height
== img
->height
)
1103 height
= img
->height
+ img
->vmargin
;
1104 else if (slice
->y
== 0)
1105 height
= slice
->height
+ img
->vmargin
;
1107 height
= slice
->height
;
1109 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1114 /* W32 specific version. Why?. ++kfs */
1115 ascent
= height
/ 2 - (FONT_DESCENT (face
->font
)
1116 - FONT_BASE (face
->font
)) / 2;
1118 /* This expression is arranged so that if the image can't be
1119 exactly centered, it will be moved slightly up. This is
1120 because a typical font is `top-heavy' (due to the presence
1121 uppercase letters), so the image placement should err towards
1122 being top-heavy too. It also just generally looks better. */
1123 ascent
= (height
+ FONT_BASE(face
->font
)
1124 - FONT_DESCENT(face
->font
) + 1) / 2;
1125 #endif /* HAVE_NTGUI */
1128 ascent
= height
/ 2;
1131 ascent
= (int) (height
* img
->ascent
/ 100.0);
1137 /* Image background colors. */
1139 /* Find the "best" corner color of a bitmap.
1140 On W32, XIMG is assumed to a device context with the bitmap selected. */
1142 static RGB_PIXEL_COLOR
1143 four_corners_best (XImagePtr_or_DC ximg
, int *corners
,
1144 unsigned long width
, unsigned long height
)
1146 RGB_PIXEL_COLOR corner_pixels
[4], best
IF_LINT (= 0);
1149 if (corners
&& corners
[BOT_CORNER
] >= 0)
1151 /* Get the colors at the corner_pixels of ximg. */
1152 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1153 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1154 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1155 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1159 /* Get the colors at the corner_pixels of ximg. */
1160 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1161 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1162 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1163 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1165 /* Choose the most frequently found color as background. */
1166 for (i
= best_count
= 0; i
< 4; ++i
)
1170 for (j
= n
= 0; j
< 4; ++j
)
1171 if (corner_pixels
[i
] == corner_pixels
[j
])
1175 best
= corner_pixels
[i
], best_count
= n
;
1181 /* Portability macros */
1185 #define Destroy_Image(img_dc, prev) \
1186 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1188 #define Free_Pixmap(display, pixmap) \
1189 DeleteObject (pixmap)
1191 #elif defined (HAVE_NS)
1193 #define Destroy_Image(ximg, dummy) \
1194 ns_release_object (ximg)
1196 #define Free_Pixmap(display, pixmap) \
1197 ns_release_object (pixmap)
1201 #define Destroy_Image(ximg, dummy) \
1202 XDestroyImage (ximg)
1204 #define Free_Pixmap(display, pixmap) \
1205 XFreePixmap (display, pixmap)
1207 #endif /* !HAVE_NTGUI && !HAVE_NS */
1210 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1211 it is guessed heuristically. If non-zero, XIMG is an existing
1212 XImage object (or device context with the image selected on W32) to
1213 use for the heuristic. */
1216 image_background (struct image
*img
, struct frame
*f
, XImagePtr_or_DC ximg
)
1218 if (! img
->background_valid
)
1219 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1221 int free_ximg
= !ximg
;
1224 #endif /* HAVE_NTGUI */
1229 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1230 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1232 HDC frame_dc
= get_frame_dc (f
);
1233 ximg
= CreateCompatibleDC (frame_dc
);
1234 release_frame_dc (f
, frame_dc
);
1235 prev
= SelectObject (ximg
, img
->pixmap
);
1236 #endif /* !HAVE_NTGUI */
1239 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1242 Destroy_Image (ximg
, prev
);
1244 img
->background_valid
= 1;
1247 return img
->background
;
1250 /* Return the `background_transparent' field of IMG. If IMG doesn't
1251 have one yet, it is guessed heuristically. If non-zero, MASK is an
1252 existing XImage object to use for the heuristic. */
1255 image_background_transparent (struct image
*img
, struct frame
*f
, XImagePtr_or_DC mask
)
1257 if (! img
->background_transparent_valid
)
1258 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1262 int free_mask
= !mask
;
1265 #endif /* HAVE_NTGUI */
1270 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1271 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1273 HDC frame_dc
= get_frame_dc (f
);
1274 mask
= CreateCompatibleDC (frame_dc
);
1275 release_frame_dc (f
, frame_dc
);
1276 prev
= SelectObject (mask
, img
->mask
);
1277 #endif /* HAVE_NTGUI */
1280 img
->background_transparent
1281 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1284 Destroy_Image (mask
, prev
);
1287 img
->background_transparent
= 0;
1289 img
->background_transparent_valid
= 1;
1292 return img
->background_transparent
;
1296 /***********************************************************************
1297 Helper functions for X image types
1298 ***********************************************************************/
1300 static void x_clear_image_1 (struct frame
*, struct image
*, int,
1302 static void x_clear_image (struct frame
*f
, struct image
*img
);
1303 static unsigned long x_alloc_image_color (struct frame
*f
,
1305 Lisp_Object color_name
,
1306 unsigned long dflt
);
1309 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1310 free the pixmap if any. MASK_P non-zero means clear the mask
1311 pixmap if any. COLORS_P non-zero means free colors allocated for
1312 the image, if any. */
1315 x_clear_image_1 (struct frame
*f
, struct image
*img
, int pixmap_p
, int mask_p
,
1318 if (pixmap_p
&& img
->pixmap
)
1320 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1321 img
->pixmap
= NO_PIXMAP
;
1322 /* NOTE (HAVE_NS): background color is NOT an indexed color! */
1323 img
->background_valid
= 0;
1326 if (mask_p
&& img
->mask
)
1328 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1329 img
->mask
= NO_PIXMAP
;
1330 img
->background_transparent_valid
= 0;
1333 if (colors_p
&& img
->ncolors
)
1335 /* W32_TODO: color table support. */
1336 #ifdef HAVE_X_WINDOWS
1337 x_free_colors (f
, img
->colors
, img
->ncolors
);
1338 #endif /* HAVE_X_WINDOWS */
1339 xfree (img
->colors
);
1346 /* Free X resources of image IMG which is used on frame F. */
1349 x_clear_image (struct frame
*f
, struct image
*img
)
1352 x_clear_image_1 (f
, img
, 1, 1, 1);
1357 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1358 cannot be allocated, use DFLT. Add a newly allocated color to
1359 IMG->colors, so that it can be freed again. Value is the pixel
1362 static unsigned long
1363 x_alloc_image_color (struct frame
*f
, struct image
*img
, Lisp_Object color_name
,
1367 unsigned long result
;
1369 xassert (STRINGP (color_name
));
1371 if (x_defined_color (f
, SSDATA (color_name
), &color
, 1))
1373 /* This isn't called frequently so we get away with simply
1374 reallocating the color vector to the needed size, here. */
1377 (unsigned long *) xrealloc (img
->colors
,
1378 img
->ncolors
* sizeof *img
->colors
);
1379 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
1380 result
= color
.pixel
;
1390 /***********************************************************************
1392 ***********************************************************************/
1394 static void cache_image (struct frame
*f
, struct image
*img
);
1395 static void postprocess_image (struct frame
*, struct image
*);
1397 /* Return a new, initialized image cache that is allocated from the
1398 heap. Call free_image_cache to free an image cache. */
1400 struct image_cache
*
1401 make_image_cache (void)
1403 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1406 memset (c
, 0, sizeof *c
);
1408 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
1409 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1410 c
->buckets
= (struct image
**) xmalloc (size
);
1411 memset (c
->buckets
, 0, size
);
1416 /* Find an image matching SPEC in the cache, and return it. If no
1417 image is found, return NULL. */
1418 static struct image
*
1419 search_image_cache (struct frame
*f
, Lisp_Object spec
, EMACS_UINT hash
)
1422 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1423 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1425 if (!c
) return NULL
;
1427 /* If the image spec does not specify a background color, the cached
1428 image must have the same background color as the current frame.
1429 The foreground color must also match, for the sake of monochrome
1432 In fact, we could ignore the foreground color matching condition
1433 for color images, or if the image spec specifies :foreground;
1434 similarly we could ignore the background color matching condition
1435 for formats that don't use transparency (such as jpeg), or if the
1436 image spec specifies :background. However, the extra memory
1437 usage is probably negligible in practice, so we don't bother. */
1439 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1440 if (img
->hash
== hash
1441 && !NILP (Fequal (img
->spec
, spec
))
1442 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1443 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1449 /* Search frame F for an image with spec SPEC, and free it. */
1452 uncache_image (struct frame
*f
, Lisp_Object spec
)
1454 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1457 free_image (f
, img
);
1458 /* As display glyphs may still be referring to the image ID, we
1459 must garbage the frame (Bug#6426). */
1460 SET_FRAME_GARBAGED (f
);
1465 /* Free image cache of frame F. Be aware that X frames share images
1469 free_image_cache (struct frame
*f
)
1471 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1476 /* Cache should not be referenced by any frame when freed. */
1477 xassert (c
->refcount
== 0);
1479 for (i
= 0; i
< c
->used
; ++i
)
1480 free_image (f
, c
->images
[i
]);
1484 FRAME_IMAGE_CACHE (f
) = NULL
;
1489 /* Clear image cache of frame F. FILTER=t means free all images.
1490 FILTER=nil means clear only images that haven't been
1491 displayed for some time.
1492 Else, only free the images which have FILTER in their `dependencies'.
1493 Should be called from time to time to reduce the number of loaded images.
1494 If image-cache-eviction-delay is non-nil, this frees images in the cache
1495 which weren't displayed for at least that many seconds. */
1498 clear_image_cache (struct frame
*f
, Lisp_Object filter
)
1500 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1506 /* Block input so that we won't be interrupted by a SIGIO
1507 while being in an inconsistent state. */
1512 /* Filter image cache. */
1513 for (i
= 0; i
< c
->used
; ++i
)
1515 struct image
*img
= c
->images
[i
];
1516 if (img
&& (EQ (Qt
, filter
)
1517 || !NILP (Fmember (filter
, img
->dependencies
))))
1519 free_image (f
, img
);
1524 else if (INTEGERP (Vimage_cache_eviction_delay
))
1526 /* Free cache based on timestamp. */
1529 int delay
, nimages
= 0;
1531 for (i
= 0; i
< c
->used
; ++i
)
1535 /* If the number of cached images has grown unusually large,
1536 decrease the cache eviction delay (Bug#6230). */
1537 delay
= XFASTINT (Vimage_cache_eviction_delay
);
1539 delay
= max (1, 1600 * delay
/ (nimages
*nimages
));
1542 old
= EMACS_SECS (t
) - delay
;
1544 for (i
= 0; i
< c
->used
; ++i
)
1546 struct image
*img
= c
->images
[i
];
1547 if (img
&& img
->timestamp
< old
)
1549 free_image (f
, img
);
1555 /* We may be clearing the image cache because, for example,
1556 Emacs was iconified for a longer period of time. In that
1557 case, current matrices may still contain references to
1558 images freed above. So, clear these matrices. */
1561 Lisp_Object tail
, frame
;
1563 FOR_EACH_FRAME (tail
, frame
)
1565 struct frame
*fr
= XFRAME (frame
);
1566 if (FRAME_IMAGE_CACHE (fr
) == c
)
1567 clear_current_matrices (fr
);
1570 ++windows_or_buffers_changed
;
1578 clear_image_caches (Lisp_Object filter
)
1580 /* FIXME: We want to do
1581 * struct terminal *t;
1582 * for (t = terminal_list; t; t = t->next_terminal)
1583 * clear_image_cache (t, filter); */
1584 Lisp_Object tail
, frame
;
1585 FOR_EACH_FRAME (tail
, frame
)
1586 if (FRAME_WINDOW_P (XFRAME (frame
)))
1587 clear_image_cache (XFRAME (frame
), filter
);
1590 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1592 doc
: /* Clear the image cache.
1593 FILTER nil or a frame means clear all images in the selected frame.
1594 FILTER t means clear the image caches of all frames.
1595 Anything else, means only clear those images which refer to FILTER,
1596 which is then usually a filename. */)
1597 (Lisp_Object filter
)
1599 if (!(EQ (filter
, Qnil
) || FRAMEP (filter
)))
1600 clear_image_caches (filter
);
1602 clear_image_cache (check_x_frame (filter
), Qt
);
1608 DEFUN ("image-flush", Fimage_flush
, Simage_flush
,
1610 doc
: /* Fush the image with specification SPEC on frame FRAME.
1611 This removes the image from the Emacs image cache. If SPEC specifies
1612 an image file, the next redisplay of this image will read from the
1613 current contents of that file.
1615 FRAME nil or omitted means use the selected frame.
1616 FRAME t means refresh the image on all frames. */)
1617 (Lisp_Object spec
, Lisp_Object frame
)
1619 if (!valid_image_p (spec
))
1620 error ("Invalid image specification");
1625 FOR_EACH_FRAME (tail
, frame
)
1627 struct frame
*f
= XFRAME (frame
);
1628 if (FRAME_WINDOW_P (f
))
1629 uncache_image (f
, spec
);
1633 uncache_image (check_x_frame (frame
), spec
);
1639 /* Compute masks and transform image IMG on frame F, as specified
1640 by the image's specification, */
1643 postprocess_image (struct frame
*f
, struct image
*img
)
1645 /* Manipulation of the image's mask. */
1648 Lisp_Object conversion
, spec
;
1653 /* `:heuristic-mask t'
1655 means build a mask heuristically.
1656 `:heuristic-mask (R G B)'
1657 `:mask (heuristic (R G B))'
1658 means build a mask from color (R G B) in the
1661 means remove a mask, if any. */
1663 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1665 x_build_heuristic_mask (f
, img
, mask
);
1670 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1672 if (EQ (mask
, Qheuristic
))
1673 x_build_heuristic_mask (f
, img
, Qt
);
1674 else if (CONSP (mask
)
1675 && EQ (XCAR (mask
), Qheuristic
))
1677 if (CONSP (XCDR (mask
)))
1678 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1680 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1682 else if (NILP (mask
) && found_p
&& img
->mask
)
1684 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1685 img
->mask
= NO_PIXMAP
;
1690 /* Should we apply an image transformation algorithm? */
1691 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1692 if (EQ (conversion
, Qdisabled
))
1693 x_disable_image (f
, img
);
1694 else if (EQ (conversion
, Qlaplace
))
1696 else if (EQ (conversion
, Qemboss
))
1698 else if (CONSP (conversion
)
1699 && EQ (XCAR (conversion
), Qedge_detection
))
1702 tem
= XCDR (conversion
);
1704 x_edge_detection (f
, img
,
1705 Fplist_get (tem
, QCmatrix
),
1706 Fplist_get (tem
, QCcolor_adjustment
));
1712 /* Return the id of image with Lisp specification SPEC on frame F.
1713 SPEC must be a valid Lisp image specification (see valid_image_p). */
1716 lookup_image (struct frame
*f
, Lisp_Object spec
)
1722 /* F must be a window-system frame, and SPEC must be a valid image
1724 xassert (FRAME_WINDOW_P (f
));
1725 xassert (valid_image_p (spec
));
1727 /* Look up SPEC in the hash table of the image cache. */
1728 hash
= sxhash (spec
, 0);
1729 img
= search_image_cache (f
, spec
, hash
);
1730 if (img
&& img
->load_failed_p
)
1732 free_image (f
, img
);
1736 /* If not found, create a new image and cache it. */
1740 img
= make_image (spec
, hash
);
1741 cache_image (f
, img
);
1742 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1743 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1744 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1746 /* If we can't load the image, and we don't have a width and
1747 height, use some arbitrary width and height so that we can
1748 draw a rectangle for it. */
1749 if (img
->load_failed_p
)
1753 value
= image_spec_value (spec
, QCwidth
, NULL
);
1754 img
->width
= (INTEGERP (value
)
1755 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1756 value
= image_spec_value (spec
, QCheight
, NULL
);
1757 img
->height
= (INTEGERP (value
)
1758 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1762 /* Handle image type independent image attributes
1763 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1764 `:background COLOR'. */
1765 Lisp_Object ascent
, margin
, relief
, bg
;
1767 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1768 if (INTEGERP (ascent
))
1769 img
->ascent
= XFASTINT (ascent
);
1770 else if (EQ (ascent
, Qcenter
))
1771 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1773 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1774 if (INTEGERP (margin
) && XINT (margin
) >= 0)
1775 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1776 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
1777 && INTEGERP (XCDR (margin
)))
1779 if (XINT (XCAR (margin
)) > 0)
1780 img
->hmargin
= XFASTINT (XCAR (margin
));
1781 if (XINT (XCDR (margin
)) > 0)
1782 img
->vmargin
= XFASTINT (XCDR (margin
));
1785 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1786 if (INTEGERP (relief
))
1788 img
->relief
= XINT (relief
);
1789 img
->hmargin
+= eabs (img
->relief
);
1790 img
->vmargin
+= eabs (img
->relief
);
1793 if (! img
->background_valid
)
1795 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1799 = x_alloc_image_color (f
, img
, bg
,
1800 FRAME_BACKGROUND_PIXEL (f
));
1801 img
->background_valid
= 1;
1805 /* Do image transformations and compute masks, unless we
1806 don't have the image yet. */
1807 if (!EQ (*img
->type
->type
, Qpostscript
))
1808 postprocess_image (f
, img
);
1814 /* We're using IMG, so set its timestamp to `now'. */
1815 EMACS_GET_TIME (now
);
1816 img
->timestamp
= EMACS_SECS (now
);
1818 /* Value is the image id. */
1823 /* Cache image IMG in the image cache of frame F. */
1826 cache_image (struct frame
*f
, struct image
*img
)
1828 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1831 /* Find a free slot in c->images. */
1832 for (i
= 0; i
< c
->used
; ++i
)
1833 if (c
->images
[i
] == NULL
)
1836 /* If no free slot found, maybe enlarge c->images. */
1837 if (i
== c
->used
&& c
->used
== c
->size
)
1839 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *c
->images
/ 2 < c
->size
)
1840 memory_full (SIZE_MAX
);
1842 c
->images
= (struct image
**) xrealloc (c
->images
,
1843 c
->size
* sizeof *c
->images
);
1846 /* Add IMG to c->images, and assign IMG an id. */
1852 /* Add IMG to the cache's hash table. */
1853 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1854 img
->next
= c
->buckets
[i
];
1856 img
->next
->prev
= img
;
1858 c
->buckets
[i
] = img
;
1862 /* Call FN on every image in the image cache of frame F. Used to mark
1863 Lisp Objects in the image cache. */
1865 /* Mark Lisp objects in image IMG. */
1868 mark_image (struct image
*img
)
1870 mark_object (img
->spec
);
1871 mark_object (img
->dependencies
);
1873 if (!NILP (img
->lisp_data
))
1874 mark_object (img
->lisp_data
);
1879 mark_image_cache (struct image_cache
*c
)
1884 for (i
= 0; i
< c
->used
; ++i
)
1886 mark_image (c
->images
[i
]);
1892 /***********************************************************************
1893 X / NS / W32 support code
1894 ***********************************************************************/
1898 /* Macro for defining functions that will be loaded from image DLLs. */
1899 #define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
1901 /* Macro for loading those image functions from the library. */
1902 #define LOAD_IMGLIB_FN(lib,func) { \
1903 fn_##func = (void *) GetProcAddress (lib, #func); \
1904 if (!fn_##func) return 0; \
1907 #endif /* HAVE_NTGUI */
1909 static int x_create_x_image_and_pixmap (struct frame
*, int, int, int,
1910 XImagePtr
*, Pixmap
*);
1911 static void x_destroy_x_image (XImagePtr
);
1912 static void x_put_x_image (struct frame
*, XImagePtr
, Pixmap
, int, int);
1915 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1916 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1917 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1918 via xmalloc. Print error messages via image_error if an error
1919 occurs. Value is non-zero if successful.
1921 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1922 should indicate the bit depth of the image. */
1925 x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
, int depth
,
1926 XImagePtr
*ximg
, Pixmap
*pixmap
)
1928 #ifdef HAVE_X_WINDOWS
1929 Display
*display
= FRAME_X_DISPLAY (f
);
1930 Window window
= FRAME_X_WINDOW (f
);
1931 Screen
*screen
= FRAME_X_SCREEN (f
);
1933 xassert (interrupt_input_blocked
);
1936 depth
= DefaultDepthOfScreen (screen
);
1937 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1938 depth
, ZPixmap
, 0, NULL
, width
, height
,
1939 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1942 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1946 /* Allocate image raster. */
1947 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1949 /* Allocate a pixmap of the same size. */
1950 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1951 if (*pixmap
== NO_PIXMAP
)
1953 x_destroy_x_image (*ximg
);
1955 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1960 #endif /* HAVE_X_WINDOWS */
1964 BITMAPINFOHEADER
*header
;
1966 int scanline_width_bits
;
1968 int palette_colors
= 0;
1973 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1974 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1976 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1980 scanline_width_bits
= width
* depth
;
1981 remainder
= scanline_width_bits
% 32;
1984 scanline_width_bits
+= 32 - remainder
;
1986 /* Bitmaps with a depth less than 16 need a palette. */
1987 /* BITMAPINFO structure already contains the first RGBQUAD. */
1989 palette_colors
= 1 << depth
- 1;
1991 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
1994 image_error ("Unable to allocate memory for XImage", Qnil
, Qnil
);
1998 header
= &(*ximg
)->info
.bmiHeader
;
1999 memset (&(*ximg
)->info
, 0, sizeof (BITMAPINFO
));
2000 header
->biSize
= sizeof (*header
);
2001 header
->biWidth
= width
;
2002 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2003 header
->biPlanes
= 1;
2004 header
->biBitCount
= depth
;
2005 header
->biCompression
= BI_RGB
;
2006 header
->biClrUsed
= palette_colors
;
2008 /* TODO: fill in palette. */
2011 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2012 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2013 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2014 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2015 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2016 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2017 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2018 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2021 hdc
= get_frame_dc (f
);
2023 /* Create a DIBSection and raster array for the bitmap,
2024 and store its handle in *pixmap. */
2025 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2026 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2027 /* casting avoids a GCC warning */
2028 (void **)&((*ximg
)->data
), NULL
, 0);
2030 /* Realize display palette and garbage all frames. */
2031 release_frame_dc (f
, hdc
);
2033 if (*pixmap
== NULL
)
2035 DWORD err
= GetLastError ();
2036 Lisp_Object errcode
;
2037 /* All system errors are < 10000, so the following is safe. */
2038 XSETINT (errcode
, (int) err
);
2039 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2040 x_destroy_x_image (*ximg
);
2046 #endif /* HAVE_NTGUI */
2049 *pixmap
= ns_image_for_XPM (width
, height
, depth
);
2053 image_error ("Unable to allocate NSImage for XPM pixmap", Qnil
, Qnil
);
2062 /* Destroy XImage XIMG. Free XIMG->data. */
2065 x_destroy_x_image (XImagePtr ximg
)
2067 xassert (interrupt_input_blocked
);
2070 #ifdef HAVE_X_WINDOWS
2073 XDestroyImage (ximg
);
2074 #endif /* HAVE_X_WINDOWS */
2076 /* Data will be freed by DestroyObject. */
2079 #endif /* HAVE_NTGUI */
2081 ns_release_object (ximg
);
2082 #endif /* HAVE_NS */
2087 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2088 are width and height of both the image and pixmap. */
2091 x_put_x_image (struct frame
*f
, XImagePtr ximg
, Pixmap pixmap
, int width
, int height
)
2093 #ifdef HAVE_X_WINDOWS
2096 xassert (interrupt_input_blocked
);
2097 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2098 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2099 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2100 #endif /* HAVE_X_WINDOWS */
2103 #if 0 /* I don't think this is necessary looking at where it is used. */
2104 HDC hdc
= get_frame_dc (f
);
2105 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2106 release_frame_dc (f
, hdc
);
2108 #endif /* HAVE_NTGUI */
2111 xassert (ximg
== pixmap
);
2112 ns_retain_object (ximg
);
2117 /***********************************************************************
2119 ***********************************************************************/
2121 /* Find image file FILE. Look in data-directory/images, then
2122 x-bitmap-file-path. Value is the encoded full name of the file
2123 found, or nil if not found. */
2126 x_find_image_file (Lisp_Object file
)
2128 Lisp_Object file_found
, search_path
;
2131 /* TODO I think this should use something like image-load-path
2132 instead. Unfortunately, that can contain non-string elements. */
2133 search_path
= Fcons (Fexpand_file_name (build_string ("images"),
2135 Vx_bitmap_file_path
);
2137 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2138 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2144 file_found
= ENCODE_FILE (file_found
);
2152 /* Read FILE into memory. Value is a pointer to a buffer allocated
2153 with xmalloc holding FILE's contents. Value is null if an error
2154 occurred. *SIZE is set to the size of the file. */
2156 static unsigned char *
2157 slurp_file (char *file
, ptrdiff_t *size
)
2160 unsigned char *buf
= NULL
;
2163 if (stat (file
, &st
) == 0
2164 && (fp
= fopen (file
, "rb")) != NULL
2165 && 0 <= st
.st_size
&& st
.st_size
<= min (PTRDIFF_MAX
, SIZE_MAX
)
2166 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2167 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2188 /***********************************************************************
2190 ***********************************************************************/
2192 static int xbm_scan (unsigned char **, unsigned char *, char *, int *);
2193 static int xbm_load (struct frame
*f
, struct image
*img
);
2194 static int xbm_load_image (struct frame
*f
, struct image
*img
,
2195 unsigned char *, unsigned char *);
2196 static int xbm_image_p (Lisp_Object object
);
2197 static int xbm_read_bitmap_data (struct frame
*f
,
2198 unsigned char *, unsigned char *,
2199 int *, int *, char **, int);
2200 static int xbm_file_p (Lisp_Object
);
2203 /* Indices of image specification fields in xbm_format, below. */
2205 enum xbm_keyword_index
2223 /* Vector of image_keyword structures describing the format
2224 of valid XBM image specifications. */
2226 static const struct image_keyword xbm_format
[XBM_LAST
] =
2228 {":type", IMAGE_SYMBOL_VALUE
, 1},
2229 {":file", IMAGE_STRING_VALUE
, 0},
2230 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2231 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2232 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2233 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2234 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2235 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2236 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2237 {":relief", IMAGE_INTEGER_VALUE
, 0},
2238 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2239 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2240 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2243 /* Structure describing the image type XBM. */
2245 static struct image_type xbm_type
=
2254 /* Tokens returned from xbm_scan. */
2263 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2264 A valid specification is a list starting with the symbol `image'
2265 The rest of the list is a property list which must contain an
2268 If the specification specifies a file to load, it must contain
2269 an entry `:file FILENAME' where FILENAME is a string.
2271 If the specification is for a bitmap loaded from memory it must
2272 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2273 WIDTH and HEIGHT are integers > 0. DATA may be:
2275 1. a string large enough to hold the bitmap data, i.e. it must
2276 have a size >= (WIDTH + 7) / 8 * HEIGHT
2278 2. a bool-vector of size >= WIDTH * HEIGHT
2280 3. a vector of strings or bool-vectors, one for each line of the
2283 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2284 may not be specified in this case because they are defined in the
2287 Both the file and data forms may contain the additional entries
2288 `:background COLOR' and `:foreground COLOR'. If not present,
2289 foreground and background of the frame on which the image is
2290 displayed is used. */
2293 xbm_image_p (Lisp_Object object
)
2295 struct image_keyword kw
[XBM_LAST
];
2297 memcpy (kw
, xbm_format
, sizeof kw
);
2298 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2301 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2303 if (kw
[XBM_FILE
].count
)
2305 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2308 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2310 /* In-memory XBM file. */
2311 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2317 EMACS_INT width
, height
;
2319 /* Entries for `:width', `:height' and `:data' must be present. */
2320 if (!kw
[XBM_WIDTH
].count
2321 || !kw
[XBM_HEIGHT
].count
2322 || !kw
[XBM_DATA
].count
)
2325 data
= kw
[XBM_DATA
].value
;
2326 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2327 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2329 /* Check type of data, and width and height against contents of
2335 /* Number of elements of the vector must be >= height. */
2336 if (ASIZE (data
) < height
)
2339 /* Each string or bool-vector in data must be large enough
2340 for one line of the image. */
2341 for (i
= 0; i
< height
; ++i
)
2343 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2348 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2351 else if (BOOL_VECTOR_P (elt
))
2353 if (XBOOL_VECTOR (elt
)->size
< width
)
2360 else if (STRINGP (data
))
2363 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2366 else if (BOOL_VECTOR_P (data
))
2368 if (XBOOL_VECTOR (data
)->size
< width
* height
)
2379 /* Scan a bitmap file. FP is the stream to read from. Value is
2380 either an enumerator from enum xbm_token, or a character for a
2381 single-character token, or 0 at end of file. If scanning an
2382 identifier, store the lexeme of the identifier in SVAL. If
2383 scanning a number, store its value in *IVAL. */
2386 xbm_scan (unsigned char **s
, unsigned char *end
, char *sval
, int *ival
)
2392 /* Skip white space. */
2393 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2398 else if (isdigit (c
))
2400 int value
= 0, digit
;
2402 if (c
== '0' && *s
< end
)
2405 if (c
== 'x' || c
== 'X')
2412 else if (c
>= 'a' && c
<= 'f')
2413 digit
= c
- 'a' + 10;
2414 else if (c
>= 'A' && c
<= 'F')
2415 digit
= c
- 'A' + 10;
2418 value
= 16 * value
+ digit
;
2421 else if (isdigit (c
))
2425 && (c
= *(*s
)++, isdigit (c
)))
2426 value
= 8 * value
+ c
- '0';
2433 && (c
= *(*s
)++, isdigit (c
)))
2434 value
= 10 * value
+ c
- '0';
2442 else if (isalpha (c
) || c
== '_')
2446 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2453 else if (c
== '/' && **s
== '*')
2455 /* C-style comment. */
2457 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2471 /* Create a Windows bitmap from X bitmap data. */
2473 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2475 static unsigned char swap_nibble
[16]
2476 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2477 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2478 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2479 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2481 unsigned char *bits
, *p
;
2484 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2485 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2486 bits
= (unsigned char *) alloca (height
* w2
);
2487 memset (bits
, 0, height
* w2
);
2488 for (i
= 0; i
< height
; i
++)
2491 for (j
= 0; j
< w1
; j
++)
2493 /* Bitswap XBM bytes to match how Windows does things. */
2494 unsigned char c
= *data
++;
2495 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2496 | (swap_nibble
[(c
>>4) & 0xf]));
2499 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2505 convert_mono_to_color_image (struct frame
*f
, struct image
*img
,
2506 COLORREF foreground
, COLORREF background
)
2508 HDC hdc
, old_img_dc
, new_img_dc
;
2509 HGDIOBJ old_prev
, new_prev
;
2512 hdc
= get_frame_dc (f
);
2513 old_img_dc
= CreateCompatibleDC (hdc
);
2514 new_img_dc
= CreateCompatibleDC (hdc
);
2515 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2516 release_frame_dc (f
, hdc
);
2517 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2518 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2519 /* Windows convention for mono bitmaps is black = background,
2520 white = foreground. */
2521 SetTextColor (new_img_dc
, background
);
2522 SetBkColor (new_img_dc
, foreground
);
2524 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2527 SelectObject (old_img_dc
, old_prev
);
2528 SelectObject (new_img_dc
, new_prev
);
2529 DeleteDC (old_img_dc
);
2530 DeleteDC (new_img_dc
);
2531 DeleteObject (img
->pixmap
);
2532 if (new_pixmap
== 0)
2533 fprintf (stderr
, "Failed to convert image to color.\n");
2535 img
->pixmap
= new_pixmap
;
2538 #define XBM_BIT_SHUFFLE(b) (~(b))
2542 #define XBM_BIT_SHUFFLE(b) (b)
2544 #endif /* HAVE_NTGUI */
2548 Create_Pixmap_From_Bitmap_Data (struct frame
*f
, struct image
*img
, char *data
,
2549 RGB_PIXEL_COLOR fg
, RGB_PIXEL_COLOR bg
,
2550 int non_default_colors
)
2554 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2556 /* If colors were specified, transfer the bitmap to a color one. */
2557 if (non_default_colors
)
2558 convert_mono_to_color_image (f
, img
, fg
, bg
);
2560 #elif defined (HAVE_NS)
2561 img
->pixmap
= ns_image_from_XBM (data
, img
->width
, img
->height
);
2565 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2568 img
->width
, img
->height
,
2570 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
2571 #endif /* !HAVE_NTGUI && !HAVE_NS */
2576 /* Replacement for XReadBitmapFileData which isn't available under old
2577 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2578 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2579 the image. Return in *DATA the bitmap data allocated with xmalloc.
2580 Value is non-zero if successful. DATA null means just test if
2581 CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR
2582 is non-zero, inhibit the call to image_error when the image size is
2583 invalid (the bitmap remains unread). */
2586 xbm_read_bitmap_data (struct frame
*f
, unsigned char *contents
, unsigned char *end
,
2587 int *width
, int *height
, char **data
,
2588 int inhibit_image_error
)
2590 unsigned char *s
= contents
;
2591 char buffer
[BUFSIZ
];
2594 int bytes_per_line
, i
, nbytes
;
2600 LA1 = xbm_scan (&s, end, buffer, &value)
2602 #define expect(TOKEN) \
2603 if (LA1 != (TOKEN)) \
2608 #define expect_ident(IDENT) \
2609 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2614 *width
= *height
= -1;
2617 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2619 /* Parse defines for width, height and hot-spots. */
2623 expect_ident ("define");
2624 expect (XBM_TK_IDENT
);
2626 if (LA1
== XBM_TK_NUMBER
)
2628 char *q
= strrchr (buffer
, '_');
2629 q
= q
? q
+ 1 : buffer
;
2630 if (strcmp (q
, "width") == 0)
2632 else if (strcmp (q
, "height") == 0)
2635 expect (XBM_TK_NUMBER
);
2638 if (!check_image_size (f
, *width
, *height
))
2640 if (!inhibit_image_error
)
2641 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
2644 else if (data
== NULL
)
2647 /* Parse bits. Must start with `static'. */
2648 expect_ident ("static");
2649 if (LA1
== XBM_TK_IDENT
)
2651 if (strcmp (buffer
, "unsigned") == 0)
2654 expect_ident ("char");
2656 else if (strcmp (buffer
, "short") == 0)
2660 if (*width
% 16 && *width
% 16 < 9)
2663 else if (strcmp (buffer
, "char") == 0)
2671 expect (XBM_TK_IDENT
);
2677 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2678 nbytes
= bytes_per_line
* *height
;
2679 p
= *data
= (char *) xmalloc (nbytes
);
2683 for (i
= 0; i
< nbytes
; i
+= 2)
2686 expect (XBM_TK_NUMBER
);
2688 *p
++ = XBM_BIT_SHUFFLE (val
);
2689 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2690 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2692 if (LA1
== ',' || LA1
== '}')
2700 for (i
= 0; i
< nbytes
; ++i
)
2703 expect (XBM_TK_NUMBER
);
2705 *p
++ = XBM_BIT_SHUFFLE (val
);
2707 if (LA1
== ',' || LA1
== '}')
2732 /* Load XBM image IMG which will be displayed on frame F from buffer
2733 CONTENTS. END is the end of the buffer. Value is non-zero if
2737 xbm_load_image (struct frame
*f
, struct image
*img
, unsigned char *contents
,
2744 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
,
2748 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2749 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2750 int non_default_colors
= 0;
2753 xassert (img
->width
> 0 && img
->height
> 0);
2755 /* Get foreground and background colors, maybe allocate colors. */
2756 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
2759 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
2760 non_default_colors
= 1;
2762 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2765 background
= x_alloc_image_color (f
, img
, value
, background
);
2766 img
->background
= background
;
2767 img
->background_valid
= 1;
2768 non_default_colors
= 1;
2771 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
2772 foreground
, background
,
2773 non_default_colors
);
2776 if (img
->pixmap
== NO_PIXMAP
)
2778 x_clear_image (f
, img
);
2779 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
2785 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2791 /* Value is non-zero if DATA looks like an in-memory XBM file. */
2794 xbm_file_p (Lisp_Object data
)
2797 return (STRINGP (data
)
2798 && xbm_read_bitmap_data (NULL
, SDATA (data
),
2799 (SDATA (data
) + SBYTES (data
)),
2804 /* Fill image IMG which is used on frame F with pixmap data. Value is
2805 non-zero if successful. */
2808 xbm_load (struct frame
*f
, struct image
*img
)
2811 Lisp_Object file_name
;
2813 xassert (xbm_image_p (img
->spec
));
2815 /* If IMG->spec specifies a file name, create a non-file spec from it. */
2816 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
2817 if (STRINGP (file_name
))
2820 unsigned char *contents
;
2823 file
= x_find_image_file (file_name
);
2824 if (!STRINGP (file
))
2826 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
2830 contents
= slurp_file (SSDATA (file
), &size
);
2831 if (contents
== NULL
)
2833 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2837 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
2842 struct image_keyword fmt
[XBM_LAST
];
2844 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2845 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2846 int non_default_colors
= 0;
2849 int in_memory_file_p
= 0;
2851 /* See if data looks like an in-memory XBM file. */
2852 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2853 in_memory_file_p
= xbm_file_p (data
);
2855 /* Parse the image specification. */
2856 memcpy (fmt
, xbm_format
, sizeof fmt
);
2857 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
2861 /* Get specified width, and height. */
2862 if (!in_memory_file_p
)
2864 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
2865 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
2866 xassert (img
->width
> 0 && img
->height
> 0);
2869 /* Get foreground and background colors, maybe allocate colors. */
2870 if (fmt
[XBM_FOREGROUND
].count
2871 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
2873 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
2875 non_default_colors
= 1;
2878 if (fmt
[XBM_BACKGROUND
].count
2879 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
2881 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
2883 non_default_colors
= 1;
2886 if (in_memory_file_p
)
2887 success_p
= xbm_load_image (f
, img
, SDATA (data
),
2896 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
2898 p
= bits
= (char *) alloca (nbytes
* img
->height
);
2899 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
2901 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
2903 memcpy (p
, SDATA (line
), nbytes
);
2905 memcpy (p
, XBOOL_VECTOR (line
)->data
, nbytes
);
2908 else if (STRINGP (data
))
2909 bits
= SSDATA (data
);
2911 bits
= (char *) XBOOL_VECTOR (data
)->data
;
2917 /* Windows mono bitmaps are reversed compared with X. */
2918 invertedBits
= bits
;
2919 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
2921 bits
= (char *) alloca (nbytes
);
2922 for (i
= 0; i
< nbytes
; i
++)
2923 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
2926 /* Create the pixmap. */
2928 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
2929 foreground
, background
,
2930 non_default_colors
);
2935 image_error ("Unable to create pixmap for XBM image `%s'",
2937 x_clear_image (f
, img
);
2947 /***********************************************************************
2949 ***********************************************************************/
2951 #if defined (HAVE_XPM) || defined (HAVE_NS)
2953 static int xpm_image_p (Lisp_Object object
);
2954 static int xpm_load (struct frame
*f
, struct image
*img
);
2955 static int xpm_valid_color_symbols_p (Lisp_Object
);
2957 #endif /* HAVE_XPM || HAVE_NS */
2961 /* Indicate to xpm.h that we don't have Xlib. */
2963 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
2964 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
2965 #define XColor xpm_XColor
2966 #define XImage xpm_XImage
2967 #define Display xpm_Display
2968 #define PIXEL_ALREADY_TYPEDEFED
2969 #include "X11/xpm.h"
2974 #undef PIXEL_ALREADY_TYPEDEFED
2976 #include "X11/xpm.h"
2977 #endif /* HAVE_NTGUI */
2978 #endif /* HAVE_XPM */
2980 #if defined (HAVE_XPM) || defined (HAVE_NS)
2981 /* The symbol `xpm' identifying XPM-format images. */
2983 static Lisp_Object Qxpm
;
2985 /* Indices of image specification fields in xpm_format, below. */
2987 enum xpm_keyword_index
3003 /* Vector of image_keyword structures describing the format
3004 of valid XPM image specifications. */
3006 static const struct image_keyword xpm_format
[XPM_LAST
] =
3008 {":type", IMAGE_SYMBOL_VALUE
, 1},
3009 {":file", IMAGE_STRING_VALUE
, 0},
3010 {":data", IMAGE_STRING_VALUE
, 0},
3011 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3012 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3013 {":relief", IMAGE_INTEGER_VALUE
, 0},
3014 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3015 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3016 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3017 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3018 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3021 /* Structure describing the image type XPM. */
3023 static struct image_type xpm_type
=
3032 #ifdef HAVE_X_WINDOWS
3034 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3035 functions for allocating image colors. Our own functions handle
3036 color allocation failures more gracefully than the ones on the XPM
3039 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3040 #define ALLOC_XPM_COLORS
3042 #endif /* HAVE_X_WINDOWS */
3044 #ifdef ALLOC_XPM_COLORS
3046 static void xpm_init_color_cache (struct frame
*, XpmAttributes
*);
3047 static void xpm_free_color_cache (void);
3048 static int xpm_lookup_color (struct frame
*, char *, XColor
*);
3049 static int xpm_color_bucket (char *);
3050 static struct xpm_cached_color
*xpm_cache_color (struct frame
*, char *,
3053 /* An entry in a hash table used to cache color definitions of named
3054 colors. This cache is necessary to speed up XPM image loading in
3055 case we do color allocations ourselves. Without it, we would need
3056 a call to XParseColor per pixel in the image. */
3058 struct xpm_cached_color
3060 /* Next in collision chain. */
3061 struct xpm_cached_color
*next
;
3063 /* Color definition (RGB and pixel color). */
3070 /* The hash table used for the color cache, and its bucket vector
3073 #define XPM_COLOR_CACHE_BUCKETS 1001
3074 static struct xpm_cached_color
**xpm_color_cache
;
3076 /* Initialize the color cache. */
3079 xpm_init_color_cache (struct frame
*f
, XpmAttributes
*attrs
)
3081 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3082 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3083 memset (xpm_color_cache
, 0, nbytes
);
3084 init_color_table ();
3086 if (attrs
->valuemask
& XpmColorSymbols
)
3091 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3092 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3093 attrs
->colorsymbols
[i
].value
, &color
))
3095 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3097 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3102 /* Free the color cache. */
3105 xpm_free_color_cache (void)
3107 struct xpm_cached_color
*p
, *next
;
3110 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3111 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3117 xfree (xpm_color_cache
);
3118 xpm_color_cache
= NULL
;
3119 free_color_table ();
3122 /* Return the bucket index for color named COLOR_NAME in the color
3126 xpm_color_bucket (char *color_name
)
3131 for (s
= color_name
; *s
; ++s
)
3133 return h
%= XPM_COLOR_CACHE_BUCKETS
;
3137 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3138 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3141 static struct xpm_cached_color
*
3142 xpm_cache_color (struct frame
*f
, char *color_name
, XColor
*color
, int bucket
)
3145 struct xpm_cached_color
*p
;
3148 bucket
= xpm_color_bucket (color_name
);
3150 nbytes
= sizeof *p
+ strlen (color_name
);
3151 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3152 strcpy (p
->name
, color_name
);
3154 p
->next
= xpm_color_cache
[bucket
];
3155 xpm_color_cache
[bucket
] = p
;
3159 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3160 return the cached definition in *COLOR. Otherwise, make a new
3161 entry in the cache and allocate the color. Value is zero if color
3162 allocation failed. */
3165 xpm_lookup_color (struct frame
*f
, char *color_name
, XColor
*color
)
3167 struct xpm_cached_color
*p
;
3168 int h
= xpm_color_bucket (color_name
);
3170 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3171 if (strcmp (p
->name
, color_name
) == 0)
3176 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3179 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3181 p
= xpm_cache_color (f
, color_name
, color
, h
);
3183 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3184 with transparency, and it's useful. */
3185 else if (strcmp ("opaque", color_name
) == 0)
3187 memset (color
, 0, sizeof (XColor
)); /* Is this necessary/correct? */
3188 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3189 p
= xpm_cache_color (f
, color_name
, color
, h
);
3196 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3197 CLOSURE is a pointer to the frame on which we allocate the
3198 color. Return in *COLOR the allocated color. Value is non-zero
3202 xpm_alloc_color (Display
*dpy
, Colormap cmap
, char *color_name
, XColor
*color
,
3205 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3209 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3210 is a pointer to the frame on which we allocate the color. Value is
3211 non-zero if successful. */
3214 xpm_free_colors (Display
*dpy
, Colormap cmap
, Pixel
*pixels
, int npixels
, void *closure
)
3219 #endif /* ALLOC_XPM_COLORS */
3224 /* XPM library details. */
3226 DEF_IMGLIB_FN (void, XpmFreeAttributes
, (XpmAttributes
*));
3227 DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer
, (Display
*, char *, xpm_XImage
**,
3228 xpm_XImage
**, XpmAttributes
*));
3229 DEF_IMGLIB_FN (int, XpmReadFileToImage
, (Display
*, char *, xpm_XImage
**,
3230 xpm_XImage
**, XpmAttributes
*));
3231 DEF_IMGLIB_FN (void, XImageFree
, (xpm_XImage
*));
3234 init_xpm_functions (Lisp_Object libraries
)
3238 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3241 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3242 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3243 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3244 LOAD_IMGLIB_FN (library
, XImageFree
);
3248 #endif /* HAVE_NTGUI */
3251 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3252 for XPM images. Such a list must consist of conses whose car and
3256 xpm_valid_color_symbols_p (Lisp_Object color_symbols
)
3258 while (CONSP (color_symbols
))
3260 Lisp_Object sym
= XCAR (color_symbols
);
3262 || !STRINGP (XCAR (sym
))
3263 || !STRINGP (XCDR (sym
)))
3265 color_symbols
= XCDR (color_symbols
);
3268 return NILP (color_symbols
);
3272 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3275 xpm_image_p (Lisp_Object object
)
3277 struct image_keyword fmt
[XPM_LAST
];
3278 memcpy (fmt
, xpm_format
, sizeof fmt
);
3279 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3280 /* Either `:file' or `:data' must be present. */
3281 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3282 /* Either no `:color-symbols' or it's a list of conses
3283 whose car and cdr are strings. */
3284 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3285 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3288 #endif /* HAVE_XPM || HAVE_NS */
3290 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3292 x_create_bitmap_from_xpm_data (struct frame
*f
, const char **bits
)
3294 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3297 XpmAttributes attrs
;
3298 Pixmap bitmap
, mask
;
3300 memset (&attrs
, 0, sizeof attrs
);
3302 attrs
.visual
= FRAME_X_VISUAL (f
);
3303 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3304 attrs
.valuemask
|= XpmVisual
;
3305 attrs
.valuemask
|= XpmColormap
;
3307 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3308 (char **) bits
, &bitmap
, &mask
, &attrs
);
3309 if (rc
!= XpmSuccess
)
3311 XpmFreeAttributes (&attrs
);
3315 id
= x_allocate_bitmap_record (f
);
3316 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3317 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3318 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3319 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3320 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3321 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3322 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3323 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3325 XpmFreeAttributes (&attrs
);
3328 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3330 /* Load image IMG which will be displayed on frame F. Value is
3331 non-zero if successful. */
3336 xpm_load (struct frame
*f
, struct image
*img
)
3339 XpmAttributes attrs
;
3340 Lisp_Object specified_file
, color_symbols
;
3343 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3344 #endif /* HAVE_NTGUI */
3346 /* Configure the XPM lib. Use the visual of frame F. Allocate
3347 close colors. Return colors allocated. */
3348 memset (&attrs
, 0, sizeof attrs
);
3351 attrs
.visual
= FRAME_X_VISUAL (f
);
3352 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3353 attrs
.valuemask
|= XpmVisual
;
3354 attrs
.valuemask
|= XpmColormap
;
3355 #endif /* HAVE_NTGUI */
3357 #ifdef ALLOC_XPM_COLORS
3358 /* Allocate colors with our own functions which handle
3359 failing color allocation more gracefully. */
3360 attrs
.color_closure
= f
;
3361 attrs
.alloc_color
= xpm_alloc_color
;
3362 attrs
.free_colors
= xpm_free_colors
;
3363 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3364 #else /* not ALLOC_XPM_COLORS */
3365 /* Let the XPM lib allocate colors. */
3366 attrs
.valuemask
|= XpmReturnAllocPixels
;
3367 #ifdef XpmAllocCloseColors
3368 attrs
.alloc_close_colors
= 1;
3369 attrs
.valuemask
|= XpmAllocCloseColors
;
3370 #else /* not XpmAllocCloseColors */
3371 attrs
.closeness
= 600;
3372 attrs
.valuemask
|= XpmCloseness
;
3373 #endif /* not XpmAllocCloseColors */
3374 #endif /* ALLOC_XPM_COLORS */
3376 /* If image specification contains symbolic color definitions, add
3377 these to `attrs'. */
3378 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3379 if (CONSP (color_symbols
))
3382 XpmColorSymbol
*xpm_syms
;
3385 attrs
.valuemask
|= XpmColorSymbols
;
3387 /* Count number of symbols. */
3388 attrs
.numsymbols
= 0;
3389 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3392 /* Allocate an XpmColorSymbol array. */
3393 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3394 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3395 memset (xpm_syms
, 0, size
);
3396 attrs
.colorsymbols
= xpm_syms
;
3398 /* Fill the color symbol array. */
3399 for (tail
= color_symbols
, i
= 0;
3401 ++i
, tail
= XCDR (tail
))
3405 char *empty_string
= (char *) "";
3407 if (!CONSP (XCAR (tail
)))
3409 xpm_syms
[i
].name
= empty_string
;
3410 xpm_syms
[i
].value
= empty_string
;
3413 name
= XCAR (XCAR (tail
));
3414 color
= XCDR (XCAR (tail
));
3417 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3418 strcpy (xpm_syms
[i
].name
, SSDATA (name
));
3421 xpm_syms
[i
].name
= empty_string
;
3422 if (STRINGP (color
))
3424 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3425 strcpy (xpm_syms
[i
].value
, SSDATA (color
));
3428 xpm_syms
[i
].value
= empty_string
;
3432 /* Create a pixmap for the image, either from a file, or from a
3433 string buffer containing data in the same format as an XPM file. */
3434 #ifdef ALLOC_XPM_COLORS
3435 xpm_init_color_cache (f
, &attrs
);
3438 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3442 HDC frame_dc
= get_frame_dc (f
);
3443 hdc
= CreateCompatibleDC (frame_dc
);
3444 release_frame_dc (f
, frame_dc
);
3446 #endif /* HAVE_NTGUI */
3448 if (STRINGP (specified_file
))
3450 Lisp_Object file
= x_find_image_file (specified_file
);
3451 if (!STRINGP (file
))
3453 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3454 #ifdef ALLOC_XPM_COLORS
3455 xpm_free_color_cache ();
3461 /* XpmReadFileToPixmap is not available in the Windows port of
3462 libxpm. But XpmReadFileToImage almost does what we want. */
3463 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3464 &xpm_image
, &xpm_mask
,
3467 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3468 SSDATA (file
), &img
->pixmap
, &img
->mask
,
3470 #endif /* HAVE_NTGUI */
3474 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3475 if (!STRINGP (buffer
))
3477 image_error ("Invalid image data `%s'", buffer
, Qnil
);
3478 #ifdef ALLOC_XPM_COLORS
3479 xpm_free_color_cache ();
3484 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3485 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3486 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3487 &xpm_image
, &xpm_mask
,
3490 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3492 &img
->pixmap
, &img
->mask
,
3494 #endif /* HAVE_NTGUI */
3497 if (rc
== XpmSuccess
)
3499 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3500 img
->colors
= colors_in_color_table (&img
->ncolors
);
3501 #else /* not ALLOC_XPM_COLORS */
3505 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3506 plus some duplicate attributes. */
3507 if (xpm_image
&& xpm_image
->bitmap
)
3509 img
->pixmap
= xpm_image
->bitmap
;
3510 /* XImageFree in libXpm frees XImage struct without destroying
3511 the bitmap, which is what we want. */
3512 fn_XImageFree (xpm_image
);
3514 if (xpm_mask
&& xpm_mask
->bitmap
)
3516 /* The mask appears to be inverted compared with what we expect.
3517 TODO: invert our expectations. See other places where we
3518 have to invert bits because our idea of masks is backwards. */
3520 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3522 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3523 SelectObject (hdc
, old_obj
);
3525 img
->mask
= xpm_mask
->bitmap
;
3526 fn_XImageFree (xpm_mask
);
3531 #endif /* HAVE_NTGUI */
3533 /* Remember allocated colors. */
3534 img
->ncolors
= attrs
.nalloc_pixels
;
3535 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
3536 * sizeof *img
->colors
);
3537 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3539 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3540 #ifdef DEBUG_X_COLORS
3541 register_color (img
->colors
[i
]);
3544 #endif /* not ALLOC_XPM_COLORS */
3546 img
->width
= attrs
.width
;
3547 img
->height
= attrs
.height
;
3548 xassert (img
->width
> 0 && img
->height
> 0);
3550 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3552 fn_XpmFreeAttributes (&attrs
);
3554 XpmFreeAttributes (&attrs
);
3555 #endif /* HAVE_NTGUI */
3561 #endif /* HAVE_NTGUI */
3566 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3569 case XpmFileInvalid
:
3570 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3574 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3577 case XpmColorFailed
:
3578 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3582 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3587 #ifdef ALLOC_XPM_COLORS
3588 xpm_free_color_cache ();
3590 return rc
== XpmSuccess
;
3593 #endif /* HAVE_XPM */
3595 #if defined (HAVE_NS) && !defined (HAVE_XPM)
3597 /* XPM support functions for NS where libxpm is not available.
3598 Only XPM version 3 (without any extensions) is supported. */
3600 static void xpm_put_color_table_v (Lisp_Object
, const unsigned char *,
3602 static Lisp_Object
xpm_get_color_table_v (Lisp_Object
,
3603 const unsigned char *, int);
3604 static void xpm_put_color_table_h (Lisp_Object
, const unsigned char *,
3606 static Lisp_Object
xpm_get_color_table_h (Lisp_Object
,
3607 const unsigned char *, int);
3609 /* Tokens returned from xpm_scan. */
3618 /* Scan an XPM data and return a character (< 256) or a token defined
3619 by enum xpm_token above. *S and END are the start (inclusive) and
3620 the end (exclusive) addresses of the data, respectively. Advance
3621 *S while scanning. If token is either XPM_TK_IDENT or
3622 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3623 length of the corresponding token, respectively. */
3626 xpm_scan (const unsigned char **s
,
3627 const unsigned char *end
,
3628 const unsigned char **beg
,
3635 /* Skip white-space. */
3636 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3639 /* gnus-pointer.xpm uses '-' in its identifier.
3640 sb-dir-plus.xpm uses '+' in its identifier. */
3641 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3645 && (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3648 return XPM_TK_IDENT
;
3653 while (*s
< end
&& **s
!= '"')
3658 return XPM_TK_STRING
;
3662 if (*s
< end
&& **s
== '*')
3664 /* C-style comment. */
3668 while (*s
< end
&& *(*s
)++ != '*')
3671 while (*s
< end
&& **s
!= '/');
3685 /* Functions for color table lookup in XPM data. A key is a string
3686 specifying the color of each pixel in XPM data. A value is either
3687 an integer that specifies a pixel color, Qt that specifies
3688 transparency, or Qnil for the unspecified color. If the length of
3689 the key string is one, a vector is used as a table. Otherwise, a
3690 hash table is used. */
3693 xpm_make_color_table_v (void (**put_func
) (Lisp_Object
,
3694 const unsigned char *,
3697 Lisp_Object (**get_func
) (Lisp_Object
,
3698 const unsigned char *,
3701 *put_func
= xpm_put_color_table_v
;
3702 *get_func
= xpm_get_color_table_v
;
3703 return Fmake_vector (make_number (256), Qnil
);
3707 xpm_put_color_table_v (Lisp_Object color_table
,
3708 const unsigned char *chars_start
,
3712 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3716 xpm_get_color_table_v (Lisp_Object color_table
,
3717 const unsigned char *chars_start
,
3720 return XVECTOR (color_table
)->contents
[*chars_start
];
3724 xpm_make_color_table_h (void (**put_func
) (Lisp_Object
,
3725 const unsigned char *,
3728 Lisp_Object (**get_func
) (Lisp_Object
,
3729 const unsigned char *,
3732 *put_func
= xpm_put_color_table_h
;
3733 *get_func
= xpm_get_color_table_h
;
3734 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3735 make_float (DEFAULT_REHASH_SIZE
),
3736 make_float (DEFAULT_REHASH_THRESHOLD
),
3741 xpm_put_color_table_h (Lisp_Object color_table
,
3742 const unsigned char *chars_start
,
3746 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3747 EMACS_UINT hash_code
;
3748 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
3750 hash_lookup (table
, chars
, &hash_code
);
3751 hash_put (table
, chars
, color
, hash_code
);
3755 xpm_get_color_table_h (Lisp_Object color_table
,
3756 const unsigned char *chars_start
,
3759 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3760 int i
= hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
),
3763 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
3766 enum xpm_color_key
{
3774 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
3777 xpm_str_to_color_key (const char *s
)
3782 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
3784 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
3790 xpm_load_image (struct frame
*f
,
3792 const unsigned char *contents
,
3793 const unsigned char *end
)
3795 const unsigned char *s
= contents
, *beg
, *str
;
3796 unsigned char buffer
[BUFSIZ
];
3797 int width
, height
, x
, y
;
3798 int num_colors
, chars_per_pixel
;
3801 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
3802 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
3803 Lisp_Object frame
, color_symbols
, color_table
;
3804 int best_key
, have_mask
= 0;
3805 XImagePtr ximg
= NULL
, mask_img
= NULL
;
3808 LA1 = xpm_scan (&s, end, &beg, &len)
3810 #define expect(TOKEN) \
3811 if (LA1 != (TOKEN)) \
3816 #define expect_ident(IDENT) \
3817 if (LA1 == XPM_TK_IDENT \
3818 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
3823 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
3827 expect_ident ("static");
3828 expect_ident ("char");
3830 expect (XPM_TK_IDENT
);
3835 expect (XPM_TK_STRING
);
3838 memcpy (buffer
, beg
, len
);
3840 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
3841 &num_colors
, &chars_per_pixel
) != 4
3842 || width
<= 0 || height
<= 0
3843 || num_colors
<= 0 || chars_per_pixel
<= 0)
3846 if (!check_image_size (f
, width
, height
))
3848 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
3854 XSETFRAME (frame
, f
);
3855 if (!NILP (Fxw_display_color_p (frame
)))
3856 best_key
= XPM_COLOR_KEY_C
;
3857 else if (!NILP (Fx_display_grayscale_p (frame
)))
3858 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
3859 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
3861 best_key
= XPM_COLOR_KEY_M
;
3863 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3864 if (chars_per_pixel
== 1)
3865 color_table
= xpm_make_color_table_v (&put_color_table
,
3868 color_table
= xpm_make_color_table_h (&put_color_table
,
3871 while (num_colors
-- > 0)
3873 char *color
, *max_color
;
3874 int key
, next_key
, max_key
= 0;
3875 Lisp_Object symbol_color
= Qnil
, color_val
;
3878 expect (XPM_TK_STRING
);
3879 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
3881 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
3882 buffer
[len
- chars_per_pixel
] = '\0';
3884 str
= strtok (buffer
, " \t");
3887 key
= xpm_str_to_color_key (str
);
3892 color
= strtok (NULL
, " \t");
3896 while ((str
= strtok (NULL
, " \t")) != NULL
)
3898 next_key
= xpm_str_to_color_key (str
);
3901 color
[strlen (color
)] = ' ';
3904 if (key
== XPM_COLOR_KEY_S
)
3906 if (NILP (symbol_color
))
3907 symbol_color
= build_string (color
);
3909 else if (max_key
< key
&& key
<= best_key
)
3919 if (!NILP (color_symbols
) && !NILP (symbol_color
))
3921 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
3923 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
3925 if (xstrcasecmp (SSDATA (XCDR (specified_color
)), "None") == 0)
3927 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
3929 color_val
= make_number (cdef
.pixel
);
3932 if (NILP (color_val
) && max_key
> 0)
3934 if (xstrcasecmp (max_color
, "None") == 0)
3936 else if (x_defined_color (f
, max_color
, &cdef
, 0))
3937 color_val
= make_number (cdef
.pixel
);
3939 if (!NILP (color_val
))
3940 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
3945 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
3946 &ximg
, &img
->pixmap
)
3948 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
3949 &mask_img
, &img
->mask
)
3953 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3957 for (y
= 0; y
< height
; y
++)
3959 expect (XPM_TK_STRING
);
3961 if (len
< width
* chars_per_pixel
)
3963 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
3965 Lisp_Object color_val
=
3966 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
3968 XPutPixel (ximg
, x
, y
,
3969 (INTEGERP (color_val
) ? XINT (color_val
)
3970 : FRAME_FOREGROUND_PIXEL (f
)));
3972 XPutPixel (mask_img
, x
, y
,
3973 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
3974 : (have_mask
= 1, PIX_MASK_RETAIN
)));
3976 if (EQ (color_val
, Qt
))
3977 ns_set_alpha (ximg
, x
, y
, 0);
3985 img
->height
= height
;
3987 /* Maybe fill in the background field while we have ximg handy. */
3988 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
3989 IMAGE_BACKGROUND (img
, f
, ximg
);
3991 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
3992 x_destroy_x_image (ximg
);
3996 /* Fill in the background_transparent field while we have the
3998 image_background_transparent (img
, f
, mask_img
);
4000 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4001 x_destroy_x_image (mask_img
);
4005 x_destroy_x_image (mask_img
);
4006 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4007 img
->mask
= NO_PIXMAP
;
4013 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4015 x_destroy_x_image (ximg
);
4016 x_destroy_x_image (mask_img
);
4017 x_clear_image (f
, img
);
4026 xpm_load (struct frame
*f
,
4030 Lisp_Object file_name
;
4032 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4033 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4034 if (STRINGP (file_name
))
4037 unsigned char *contents
;
4040 file
= x_find_image_file (file_name
);
4041 if (!STRINGP (file
))
4043 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4047 contents
= slurp_file (SDATA (file
), &size
);
4048 if (contents
== NULL
)
4050 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4054 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4061 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4062 if (!STRINGP (data
))
4064 image_error ("Invalid image data `%s'", data
, Qnil
);
4067 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4068 SDATA (data
) + SBYTES (data
));
4074 #endif /* HAVE_NS && !HAVE_XPM */
4078 /***********************************************************************
4080 ***********************************************************************/
4082 #ifdef COLOR_TABLE_SUPPORT
4084 /* An entry in the color table mapping an RGB color to a pixel color. */
4089 unsigned long pixel
;
4091 /* Next in color table collision list. */
4092 struct ct_color
*next
;
4095 /* The bucket vector size to use. Must be prime. */
4099 /* Value is a hash of the RGB color given by R, G, and B. */
4101 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4103 /* The color hash table. */
4105 static struct ct_color
**ct_table
;
4107 /* Number of entries in the color table. */
4109 static int ct_colors_allocated
;
4111 /* Initialize the color table. */
4114 init_color_table (void)
4116 int size
= CT_SIZE
* sizeof (*ct_table
);
4117 ct_table
= (struct ct_color
**) xmalloc (size
);
4118 memset (ct_table
, 0, size
);
4119 ct_colors_allocated
= 0;
4123 /* Free memory associated with the color table. */
4126 free_color_table (void)
4129 struct ct_color
*p
, *next
;
4131 for (i
= 0; i
< CT_SIZE
; ++i
)
4132 for (p
= ct_table
[i
]; p
; p
= next
)
4143 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4144 entry for that color already is in the color table, return the
4145 pixel color of that entry. Otherwise, allocate a new color for R,
4146 G, B, and make an entry in the color table. */
4148 static unsigned long
4149 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4151 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4152 int i
= hash
% CT_SIZE
;
4154 Display_Info
*dpyinfo
;
4156 /* Handle TrueColor visuals specially, which improves performance by
4157 two orders of magnitude. Freeing colors on TrueColor visuals is
4158 a nop, and pixel colors specify RGB values directly. See also
4159 the Xlib spec, chapter 3.1. */
4160 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4161 if (dpyinfo
->red_bits
> 0)
4163 unsigned long pr
, pg
, pb
;
4165 /* Apply gamma-correction like normal color allocation does. */
4169 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4170 gamma_correct (f
, &color
);
4171 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4174 /* Scale down RGB values to the visual's bits per RGB, and shift
4175 them to the right position in the pixel color. Note that the
4176 original RGB values are 16-bit values, as usual in X. */
4177 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4178 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4179 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4181 /* Assemble the pixel color. */
4182 return pr
| pg
| pb
;
4185 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4186 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4192 #ifdef HAVE_X_WINDOWS
4201 cmap
= FRAME_X_COLORMAP (f
);
4202 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4205 ++ct_colors_allocated
;
4206 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4210 p
->pixel
= color
.pixel
;
4211 p
->next
= ct_table
[i
];
4215 return FRAME_FOREGROUND_PIXEL (f
);
4220 color
= PALETTERGB (r
, g
, b
);
4222 color
= RGB_TO_ULONG (r
, g
, b
);
4223 #endif /* HAVE_NTGUI */
4224 ++ct_colors_allocated
;
4225 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4230 p
->next
= ct_table
[i
];
4232 #endif /* HAVE_X_WINDOWS */
4240 /* Look up pixel color PIXEL which is used on frame F in the color
4241 table. If not already present, allocate it. Value is PIXEL. */
4243 static unsigned long
4244 lookup_pixel_color (struct frame
*f
, unsigned long pixel
)
4246 int i
= pixel
% CT_SIZE
;
4249 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4250 if (p
->pixel
== pixel
)
4259 #ifdef HAVE_X_WINDOWS
4260 cmap
= FRAME_X_COLORMAP (f
);
4261 color
.pixel
= pixel
;
4262 x_query_color (f
, &color
);
4263 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4266 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4267 color
.pixel
= pixel
;
4268 XQueryColor (NULL
, cmap
, &color
);
4269 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4271 #endif /* HAVE_X_WINDOWS */
4275 ++ct_colors_allocated
;
4277 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4282 p
->next
= ct_table
[i
];
4286 return FRAME_FOREGROUND_PIXEL (f
);
4292 /* Value is a vector of all pixel colors contained in the color table,
4293 allocated via xmalloc. Set *N to the number of colors. */
4295 static unsigned long *
4296 colors_in_color_table (int *n
)
4300 unsigned long *colors
;
4302 if (ct_colors_allocated
== 0)
4309 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4311 *n
= ct_colors_allocated
;
4313 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4314 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4315 colors
[j
++] = p
->pixel
;
4321 #else /* COLOR_TABLE_SUPPORT */
4323 static unsigned long
4324 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4326 unsigned long pixel
;
4329 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4330 #endif /* HAVE_NTGUI */
4333 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4334 #endif /* HAVE_NS */
4339 init_color_table (void)
4342 #endif /* COLOR_TABLE_SUPPORT */
4345 /***********************************************************************
4347 ***********************************************************************/
4349 static XColor
*x_to_xcolors (struct frame
*, struct image
*, int);
4350 static void x_from_xcolors (struct frame
*, struct image
*, XColor
*);
4351 static void x_detect_edges (struct frame
*, struct image
*, int[9], int);
4354 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4355 #endif /* HAVE_NTGUI */
4357 /* Edge detection matrices for different edge-detection
4360 static int emboss_matrix
[9] = {
4362 2, -1, 0, /* y - 1 */
4364 0, 1, -2 /* y + 1 */
4367 static int laplace_matrix
[9] = {
4369 1, 0, 0, /* y - 1 */
4371 0, 0, -1 /* y + 1 */
4374 /* Value is the intensity of the color whose red/green/blue values
4377 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4380 /* On frame F, return an array of XColor structures describing image
4381 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4382 non-zero means also fill the red/green/blue members of the XColor
4383 structures. Value is a pointer to the array of XColors structures,
4384 allocated with xmalloc; it must be freed by the caller. */
4387 x_to_xcolors (struct frame
*f
, struct image
*img
, int rgb_p
)
4391 XImagePtr_or_DC ximg
;
4395 #endif /* HAVE_NTGUI */
4397 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
4400 /* Get the X image IMG->pixmap. */
4401 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4402 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4404 /* Load the image into a memory device context. */
4405 hdc
= get_frame_dc (f
);
4406 ximg
= CreateCompatibleDC (hdc
);
4407 release_frame_dc (f
, hdc
);
4408 prev
= SelectObject (ximg
, img
->pixmap
);
4409 #endif /* HAVE_NTGUI */
4411 /* Fill the `pixel' members of the XColor array. I wished there
4412 were an easy and portable way to circumvent XGetPixel. */
4414 for (y
= 0; y
< img
->height
; ++y
)
4418 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
4419 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4420 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4422 x_query_colors (f
, row
, img
->width
);
4426 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4428 /* W32_TODO: palette support needed here? */
4429 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4432 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4433 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4434 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4437 #endif /* HAVE_X_WINDOWS */
4440 Destroy_Image (ximg
, prev
);
4447 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4448 created with CreateDIBSection, with the pointer to the bit values
4449 stored in ximg->data. */
4452 XPutPixel (XImagePtr ximg
, int x
, int y
, COLORREF color
)
4454 int width
= ximg
->info
.bmiHeader
.biWidth
;
4455 unsigned char * pixel
;
4457 /* True color images. */
4458 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4460 int rowbytes
= width
* 3;
4461 /* Ensure scanlines are aligned on 4 byte boundaries. */
4463 rowbytes
+= 4 - (rowbytes
% 4);
4465 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4466 /* Windows bitmaps are in BGR order. */
4467 *pixel
= GetBValue (color
);
4468 *(pixel
+ 1) = GetGValue (color
);
4469 *(pixel
+ 2) = GetRValue (color
);
4471 /* Monochrome images. */
4472 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4474 int rowbytes
= width
/ 8;
4475 /* Ensure scanlines are aligned on 4 byte boundaries. */
4477 rowbytes
+= 4 - (rowbytes
% 4);
4478 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4479 /* Filter out palette info. */
4480 if (color
& 0x00ffffff)
4481 *pixel
= *pixel
| (1 << x
% 8);
4483 *pixel
= *pixel
& ~(1 << x
% 8);
4486 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4489 #endif /* HAVE_NTGUI */
4491 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4492 RGB members are set. F is the frame on which this all happens.
4493 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4496 x_from_xcolors (struct frame
*f
, struct image
*img
, XColor
*colors
)
4499 XImagePtr oimg
= NULL
;
4503 init_color_table ();
4505 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4508 for (y
= 0; y
< img
->height
; ++y
)
4509 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4511 unsigned long pixel
;
4512 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4513 XPutPixel (oimg
, x
, y
, pixel
);
4517 x_clear_image_1 (f
, img
, 1, 0, 1);
4519 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4520 x_destroy_x_image (oimg
);
4521 img
->pixmap
= pixmap
;
4522 #ifdef COLOR_TABLE_SUPPORT
4523 img
->colors
= colors_in_color_table (&img
->ncolors
);
4524 free_color_table ();
4525 #endif /* COLOR_TABLE_SUPPORT */
4529 /* On frame F, perform edge-detection on image IMG.
4531 MATRIX is a nine-element array specifying the transformation
4532 matrix. See emboss_matrix for an example.
4534 COLOR_ADJUST is a color adjustment added to each pixel of the
4538 x_detect_edges (struct frame
*f
, struct image
*img
, int *matrix
, int color_adjust
)
4540 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4544 for (i
= sum
= 0; i
< 9; ++i
)
4545 sum
+= eabs (matrix
[i
]);
4547 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4549 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
4551 for (y
= 0; y
< img
->height
; ++y
)
4553 p
= COLOR (new, 0, y
);
4554 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4555 p
= COLOR (new, img
->width
- 1, y
);
4556 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4559 for (x
= 1; x
< img
->width
- 1; ++x
)
4561 p
= COLOR (new, x
, 0);
4562 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4563 p
= COLOR (new, x
, img
->height
- 1);
4564 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4567 for (y
= 1; y
< img
->height
- 1; ++y
)
4569 p
= COLOR (new, 1, y
);
4571 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4573 int r
, g
, b
, yy
, xx
;
4576 for (yy
= y
- 1; yy
< y
+ 2; ++yy
)
4577 for (xx
= x
- 1; xx
< x
+ 2; ++xx
, ++i
)
4580 XColor
*t
= COLOR (colors
, xx
, yy
);
4581 r
+= matrix
[i
] * t
->red
;
4582 g
+= matrix
[i
] * t
->green
;
4583 b
+= matrix
[i
] * t
->blue
;
4586 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4587 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4588 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4589 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4594 x_from_xcolors (f
, img
, new);
4600 /* Perform the pre-defined `emboss' edge-detection on image IMG
4604 x_emboss (struct frame
*f
, struct image
*img
)
4606 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4610 /* Transform image IMG which is used on frame F with a Laplace
4611 edge-detection algorithm. The result is an image that can be used
4612 to draw disabled buttons, for example. */
4615 x_laplace (struct frame
*f
, struct image
*img
)
4617 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4621 /* Perform edge-detection on image IMG on frame F, with specified
4622 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4624 MATRIX must be either
4626 - a list of at least 9 numbers in row-major form
4627 - a vector of at least 9 numbers
4629 COLOR_ADJUST nil means use a default; otherwise it must be a
4633 x_edge_detection (struct frame
*f
, struct image
*img
, Lisp_Object matrix
,
4634 Lisp_Object color_adjust
)
4642 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4643 ++i
, matrix
= XCDR (matrix
))
4644 trans
[i
] = XFLOATINT (XCAR (matrix
));
4646 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4648 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4649 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4652 if (NILP (color_adjust
))
4653 color_adjust
= make_number (0xffff / 2);
4655 if (i
== 9 && NUMBERP (color_adjust
))
4656 x_detect_edges (f
, img
, trans
, XFLOATINT (color_adjust
));
4660 /* Transform image IMG on frame F so that it looks disabled. */
4663 x_disable_image (struct frame
*f
, struct image
*img
)
4665 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4667 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4669 int n_planes
= dpyinfo
->n_planes
;
4670 #endif /* HAVE_NTGUI */
4674 /* Color (or grayscale). Convert to gray, and equalize. Just
4675 drawing such images with a stipple can look very odd, so
4676 we're using this method instead. */
4677 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4679 const int h
= 15000;
4680 const int l
= 30000;
4682 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4686 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4687 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4688 p
->red
= p
->green
= p
->blue
= i2
;
4691 x_from_xcolors (f
, img
, colors
);
4694 /* Draw a cross over the disabled image, if we must or if we
4696 if (n_planes
< 2 || cross_disabled_images
)
4699 Display
*dpy
= FRAME_X_DISPLAY (f
);
4702 #ifndef HAVE_NS /* TODO: NS support, however this not needed for toolbars */
4704 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4706 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
4707 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4708 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4709 img
->width
- 1, img
->height
- 1);
4710 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4716 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
4717 XSetForeground (dpy
, gc
, MaskForeground (f
));
4718 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4719 img
->width
- 1, img
->height
- 1);
4720 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4724 #endif /* !HAVE_NS */
4729 hdc
= get_frame_dc (f
);
4730 bmpdc
= CreateCompatibleDC (hdc
);
4731 release_frame_dc (f
, hdc
);
4733 prev
= SelectObject (bmpdc
, img
->pixmap
);
4735 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
4736 MoveToEx (bmpdc
, 0, 0, NULL
);
4737 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4738 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4739 LineTo (bmpdc
, img
->width
- 1, 0);
4743 SelectObject (bmpdc
, img
->mask
);
4744 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
4745 MoveToEx (bmpdc
, 0, 0, NULL
);
4746 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4747 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4748 LineTo (bmpdc
, img
->width
- 1, 0);
4750 SelectObject (bmpdc
, prev
);
4752 #endif /* HAVE_NTGUI */
4757 /* Build a mask for image IMG which is used on frame F. FILE is the
4758 name of an image file, for error messages. HOW determines how to
4759 determine the background color of IMG. If it is a list '(R G B)',
4760 with R, G, and B being integers >= 0, take that as the color of the
4761 background. Otherwise, determine the background color of IMG
4762 heuristically. Value is non-zero if successful. */
4765 x_build_heuristic_mask (struct frame
*f
, struct image
*img
, Lisp_Object how
)
4767 XImagePtr_or_DC ximg
;
4775 #endif /* HAVE_NTGUI */
4776 int x
, y
, rc
, use_img_background
;
4777 unsigned long bg
= 0;
4781 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4782 img
->mask
= NO_PIXMAP
;
4783 img
->background_transparent_valid
= 0;
4788 /* Create an image and pixmap serving as mask. */
4789 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
4790 &mask_img
, &img
->mask
);
4793 #endif /* !HAVE_NS */
4795 /* Get the X image of IMG->pixmap. */
4796 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
4797 img
->width
, img
->height
,
4800 /* Create the bit array serving as mask. */
4801 row_width
= (img
->width
+ 7) / 8;
4802 mask_img
= xmalloc (row_width
* img
->height
);
4803 memset (mask_img
, 0, row_width
* img
->height
);
4805 /* Create a memory device context for IMG->pixmap. */
4806 frame_dc
= get_frame_dc (f
);
4807 ximg
= CreateCompatibleDC (frame_dc
);
4808 release_frame_dc (f
, frame_dc
);
4809 prev
= SelectObject (ximg
, img
->pixmap
);
4810 #endif /* HAVE_NTGUI */
4812 /* Determine the background color of ximg. If HOW is `(R G B)'
4813 take that as color. Otherwise, use the image's background color. */
4814 use_img_background
= 1;
4820 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
4822 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
4826 if (i
== 3 && NILP (how
))
4828 char color_name
[30];
4829 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
4832 0x00ffffff & /* Filter out palette info. */
4833 #endif /* HAVE_NTGUI */
4834 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
4835 use_img_background
= 0;
4839 if (use_img_background
)
4840 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
4842 /* Set all bits in mask_img to 1 whose color in ximg is different
4843 from the background color bg. */
4845 for (y
= 0; y
< img
->height
; ++y
)
4846 for (x
= 0; x
< img
->width
; ++x
)
4848 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
4849 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
4851 if (XGetPixel (ximg
, x
, y
) == bg
)
4852 ns_set_alpha (ximg
, x
, y
, 0);
4853 #endif /* HAVE_NS */
4855 /* Fill in the background_transparent field while we have the mask handy. */
4856 image_background_transparent (img
, f
, mask_img
);
4858 /* Put mask_img into img->mask. */
4859 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
4860 x_destroy_x_image (mask_img
);
4861 #endif /* !HAVE_NS */
4863 for (y
= 0; y
< img
->height
; ++y
)
4864 for (x
= 0; x
< img
->width
; ++x
)
4866 COLORREF p
= GetPixel (ximg
, x
, y
);
4868 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
4871 /* Create the mask image. */
4872 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
4874 /* Fill in the background_transparent field while we have the mask handy. */
4875 SelectObject (ximg
, img
->mask
);
4876 image_background_transparent (img
, f
, ximg
);
4878 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
4880 #endif /* HAVE_NTGUI */
4882 Destroy_Image (ximg
, prev
);
4888 /***********************************************************************
4889 PBM (mono, gray, color)
4890 ***********************************************************************/
4892 static int pbm_image_p (Lisp_Object object
);
4893 static int pbm_load (struct frame
*f
, struct image
*img
);
4894 static int pbm_scan_number (unsigned char **, unsigned char *);
4896 /* The symbol `pbm' identifying images of this type. */
4898 static Lisp_Object Qpbm
;
4900 /* Indices of image specification fields in gs_format, below. */
4902 enum pbm_keyword_index
4918 /* Vector of image_keyword structures describing the format
4919 of valid user-defined image specifications. */
4921 static const struct image_keyword pbm_format
[PBM_LAST
] =
4923 {":type", IMAGE_SYMBOL_VALUE
, 1},
4924 {":file", IMAGE_STRING_VALUE
, 0},
4925 {":data", IMAGE_STRING_VALUE
, 0},
4926 {":ascent", IMAGE_ASCENT_VALUE
, 0},
4927 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
4928 {":relief", IMAGE_INTEGER_VALUE
, 0},
4929 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4930 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4931 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4932 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
4933 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
4936 /* Structure describing the image type `pbm'. */
4938 static struct image_type pbm_type
=
4948 /* Return non-zero if OBJECT is a valid PBM image specification. */
4951 pbm_image_p (Lisp_Object object
)
4953 struct image_keyword fmt
[PBM_LAST
];
4955 memcpy (fmt
, pbm_format
, sizeof fmt
);
4957 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
4960 /* Must specify either :data or :file. */
4961 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
4965 /* Scan a decimal number from *S and return it. Advance *S while
4966 reading the number. END is the end of the string. Value is -1 at
4970 pbm_scan_number (unsigned char **s
, unsigned char *end
)
4972 int c
= 0, val
= -1;
4976 /* Skip white-space. */
4977 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
4982 /* Skip comment to end of line. */
4983 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
4986 else if (isdigit (c
))
4988 /* Read decimal number. */
4990 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
4991 val
= 10 * val
+ c
- '0';
5003 #if 0 /* Unused. ++kfs */
5005 /* Read FILE into memory. Value is a pointer to a buffer allocated
5006 with xmalloc holding FILE's contents. Value is null if an error
5007 occurred. *SIZE is set to the size of the file. */
5010 pbm_read_file (file
, size
)
5018 if (stat (SDATA (file
), &st
) == 0
5019 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5020 && 0 <= st
.st_size
&& st
.st_size
<= min (PTRDIFF_MAX
, SIZE_MAX
)
5021 && (buf
= (char *) xmalloc (st
.st_size
),
5022 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5041 #endif /* HAVE_NTGUI */
5043 /* Load PBM image IMG for use on frame F. */
5046 pbm_load (struct frame
*f
, struct image
*img
)
5049 int width
, height
, max_color_idx
= 0;
5051 Lisp_Object file
, specified_file
;
5052 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5053 unsigned char *contents
= NULL
;
5054 unsigned char *end
, *p
;
5057 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5059 if (STRINGP (specified_file
))
5061 file
= x_find_image_file (specified_file
);
5062 if (!STRINGP (file
))
5064 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5068 contents
= slurp_file (SSDATA (file
), &size
);
5069 if (contents
== NULL
)
5071 image_error ("Error reading `%s'", file
, Qnil
);
5076 end
= contents
+ size
;
5081 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5082 if (!STRINGP (data
))
5084 image_error ("Invalid image data `%s'", data
, Qnil
);
5088 end
= p
+ SBYTES (data
);
5091 /* Check magic number. */
5092 if (end
- p
< 2 || *p
++ != 'P')
5094 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5103 raw_p
= 0, type
= PBM_MONO
;
5107 raw_p
= 0, type
= PBM_GRAY
;
5111 raw_p
= 0, type
= PBM_COLOR
;
5115 raw_p
= 1, type
= PBM_MONO
;
5119 raw_p
= 1, type
= PBM_GRAY
;
5123 raw_p
= 1, type
= PBM_COLOR
;
5127 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5131 /* Read width, height, maximum color-component. Characters
5132 starting with `#' up to the end of a line are ignored. */
5133 width
= pbm_scan_number (&p
, end
);
5134 height
= pbm_scan_number (&p
, end
);
5136 if (type
!= PBM_MONO
)
5138 max_color_idx
= pbm_scan_number (&p
, end
);
5139 if (max_color_idx
> 65535 || max_color_idx
< 0)
5141 image_error ("Unsupported maximum PBM color value", Qnil
, Qnil
);
5146 if (!check_image_size (f
, width
, height
))
5148 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5152 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5153 &ximg
, &img
->pixmap
))
5156 /* Initialize the color hash table. */
5157 init_color_table ();
5159 if (type
== PBM_MONO
)
5162 struct image_keyword fmt
[PBM_LAST
];
5163 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5164 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5166 /* Parse the image specification. */
5167 memcpy (fmt
, pbm_format
, sizeof fmt
);
5168 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5170 /* Get foreground and background colors, maybe allocate colors. */
5171 if (fmt
[PBM_FOREGROUND
].count
5172 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5173 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5174 if (fmt
[PBM_BACKGROUND
].count
5175 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5177 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5178 img
->background
= bg
;
5179 img
->background_valid
= 1;
5182 for (y
= 0; y
< height
; ++y
)
5183 for (x
= 0; x
< width
; ++x
)
5191 x_destroy_x_image (ximg
);
5192 x_clear_image (f
, img
);
5193 image_error ("Invalid image size in image `%s'",
5203 g
= pbm_scan_number (&p
, end
);
5205 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5210 int expected_size
= height
* width
;
5211 if (max_color_idx
> 255)
5213 if (type
== PBM_COLOR
)
5216 if (raw_p
&& p
+ expected_size
> end
)
5218 x_destroy_x_image (ximg
);
5219 x_clear_image (f
, img
);
5220 image_error ("Invalid image size in image `%s'",
5225 for (y
= 0; y
< height
; ++y
)
5226 for (x
= 0; x
< width
; ++x
)
5230 if (type
== PBM_GRAY
&& raw_p
)
5233 if (max_color_idx
> 255)
5234 r
= g
= b
= r
* 256 + *p
++;
5236 else if (type
== PBM_GRAY
)
5237 r
= g
= b
= pbm_scan_number (&p
, end
);
5241 if (max_color_idx
> 255)
5244 if (max_color_idx
> 255)
5247 if (max_color_idx
> 255)
5252 r
= pbm_scan_number (&p
, end
);
5253 g
= pbm_scan_number (&p
, end
);
5254 b
= pbm_scan_number (&p
, end
);
5257 if (r
< 0 || g
< 0 || b
< 0)
5259 x_destroy_x_image (ximg
);
5260 image_error ("Invalid pixel value in image `%s'",
5265 /* RGB values are now in the range 0..max_color_idx.
5266 Scale this to the range 0..0xffff supported by X. */
5267 r
= (double) r
* 65535 / max_color_idx
;
5268 g
= (double) g
* 65535 / max_color_idx
;
5269 b
= (double) b
* 65535 / max_color_idx
;
5270 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5274 #ifdef COLOR_TABLE_SUPPORT
5275 /* Store in IMG->colors the colors allocated for the image, and
5276 free the color table. */
5277 img
->colors
= colors_in_color_table (&img
->ncolors
);
5278 free_color_table ();
5279 #endif /* COLOR_TABLE_SUPPORT */
5282 img
->height
= height
;
5284 /* Maybe fill in the background field while we have ximg handy. */
5286 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5287 /* Casting avoids a GCC warning. */
5288 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5290 /* Put the image into a pixmap. */
5291 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5292 x_destroy_x_image (ximg
);
5294 /* X and W32 versions did it here, MAC version above. ++kfs
5296 img->height = height; */
5303 /***********************************************************************
5305 ***********************************************************************/
5307 #if defined (HAVE_PNG) || defined (HAVE_NS)
5309 /* Function prototypes. */
5311 static int png_image_p (Lisp_Object object
);
5312 static int png_load (struct frame
*f
, struct image
*img
);
5314 /* The symbol `png' identifying images of this type. */
5316 static Lisp_Object Qpng
;
5318 /* Indices of image specification fields in png_format, below. */
5320 enum png_keyword_index
5335 /* Vector of image_keyword structures describing the format
5336 of valid user-defined image specifications. */
5338 static const struct image_keyword png_format
[PNG_LAST
] =
5340 {":type", IMAGE_SYMBOL_VALUE
, 1},
5341 {":data", IMAGE_STRING_VALUE
, 0},
5342 {":file", IMAGE_STRING_VALUE
, 0},
5343 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5344 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5345 {":relief", IMAGE_INTEGER_VALUE
, 0},
5346 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5347 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5348 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5349 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5352 /* Structure describing the image type `png'. */
5354 static struct image_type png_type
=
5363 /* Return non-zero if OBJECT is a valid PNG image specification. */
5366 png_image_p (Lisp_Object object
)
5368 struct image_keyword fmt
[PNG_LAST
];
5369 memcpy (fmt
, png_format
, sizeof fmt
);
5371 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5374 /* Must specify either the :data or :file keyword. */
5375 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5378 #endif /* HAVE_PNG || HAVE_NS */
5384 /* PNG library details. */
5386 DEF_IMGLIB_FN (png_voidp
, png_get_io_ptr
, (png_structp
));
5387 DEF_IMGLIB_FN (int, png_sig_cmp
, (png_bytep
, png_size_t
, png_size_t
));
5388 DEF_IMGLIB_FN (png_structp
, png_create_read_struct
, (png_const_charp
, png_voidp
,
5389 png_error_ptr
, png_error_ptr
));
5390 DEF_IMGLIB_FN (png_infop
, png_create_info_struct
, (png_structp
));
5391 DEF_IMGLIB_FN (void, png_destroy_read_struct
, (png_structpp
, png_infopp
, png_infopp
));
5392 DEF_IMGLIB_FN (void, png_set_read_fn
, (png_structp
, png_voidp
, png_rw_ptr
));
5393 DEF_IMGLIB_FN (void, png_set_sig_bytes
, (png_structp
, int));
5394 DEF_IMGLIB_FN (void, png_read_info
, (png_structp
, png_infop
));
5395 DEF_IMGLIB_FN (png_uint_32
, png_get_IHDR
, (png_structp
, png_infop
,
5396 png_uint_32
*, png_uint_32
*,
5397 int *, int *, int *, int *, int *));
5398 DEF_IMGLIB_FN (png_uint_32
, png_get_valid
, (png_structp
, png_infop
, png_uint_32
));
5399 DEF_IMGLIB_FN (void, png_set_strip_16
, (png_structp
));
5400 DEF_IMGLIB_FN (void, png_set_expand
, (png_structp
));
5401 DEF_IMGLIB_FN (void, png_set_gray_to_rgb
, (png_structp
));
5402 DEF_IMGLIB_FN (void, png_set_background
, (png_structp
, png_color_16p
,
5404 DEF_IMGLIB_FN (png_uint_32
, png_get_bKGD
, (png_structp
, png_infop
, png_color_16p
*));
5405 DEF_IMGLIB_FN (void, png_read_update_info
, (png_structp
, png_infop
));
5406 DEF_IMGLIB_FN (png_byte
, png_get_channels
, (png_structp
, png_infop
));
5407 DEF_IMGLIB_FN (png_size_t
, png_get_rowbytes
, (png_structp
, png_infop
));
5408 DEF_IMGLIB_FN (void, png_read_image
, (png_structp
, png_bytepp
));
5409 DEF_IMGLIB_FN (void, png_read_end
, (png_structp
, png_infop
));
5410 DEF_IMGLIB_FN (void, png_error
, (png_structp
, png_const_charp
));
5412 #if (PNG_LIBPNG_VER >= 10500)
5413 DEF_IMGLIB_FN (void, png_longjmp
, (png_structp
, int));
5414 DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn
, (png_structp
, png_longjmp_ptr
, size_t));
5415 #endif /* libpng version >= 1.5 */
5418 init_png_functions (Lisp_Object libraries
)
5422 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5425 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5426 LOAD_IMGLIB_FN (library
, png_sig_cmp
);
5427 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5428 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5429 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5430 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5431 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5432 LOAD_IMGLIB_FN (library
, png_read_info
);
5433 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5434 LOAD_IMGLIB_FN (library
, png_get_valid
);
5435 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5436 LOAD_IMGLIB_FN (library
, png_set_expand
);
5437 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5438 LOAD_IMGLIB_FN (library
, png_set_background
);
5439 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5440 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5441 LOAD_IMGLIB_FN (library
, png_get_channels
);
5442 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5443 LOAD_IMGLIB_FN (library
, png_read_image
);
5444 LOAD_IMGLIB_FN (library
, png_read_end
);
5445 LOAD_IMGLIB_FN (library
, png_error
);
5447 #if (PNG_LIBPNG_VER >= 10500)
5448 LOAD_IMGLIB_FN (library
, png_longjmp
);
5449 LOAD_IMGLIB_FN (library
, png_set_longjmp_fn
);
5450 #endif /* libpng version >= 1.5 */
5456 #define fn_png_get_io_ptr png_get_io_ptr
5457 #define fn_png_sig_cmp png_sig_cmp
5458 #define fn_png_create_read_struct png_create_read_struct
5459 #define fn_png_create_info_struct png_create_info_struct
5460 #define fn_png_destroy_read_struct png_destroy_read_struct
5461 #define fn_png_set_read_fn png_set_read_fn
5462 #define fn_png_set_sig_bytes png_set_sig_bytes
5463 #define fn_png_read_info png_read_info
5464 #define fn_png_get_IHDR png_get_IHDR
5465 #define fn_png_get_valid png_get_valid
5466 #define fn_png_set_strip_16 png_set_strip_16
5467 #define fn_png_set_expand png_set_expand
5468 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5469 #define fn_png_set_background png_set_background
5470 #define fn_png_get_bKGD png_get_bKGD
5471 #define fn_png_read_update_info png_read_update_info
5472 #define fn_png_get_channels png_get_channels
5473 #define fn_png_get_rowbytes png_get_rowbytes
5474 #define fn_png_read_image png_read_image
5475 #define fn_png_read_end png_read_end
5476 #define fn_png_error png_error
5478 #if (PNG_LIBPNG_VER >= 10500)
5479 #define fn_png_longjmp png_longjmp
5480 #define fn_png_set_longjmp_fn png_set_longjmp_fn
5481 #endif /* libpng version >= 1.5 */
5483 #endif /* HAVE_NTGUI */
5486 #if (PNG_LIBPNG_VER < 10500)
5487 #define PNG_LONGJMP(ptr) (longjmp ((ptr)->jmpbuf, 1))
5488 #define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
5490 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908) */
5491 #define PNG_LONGJMP(ptr) (fn_png_longjmp ((ptr), 1))
5492 #define PNG_JMPBUF(ptr) \
5493 (*fn_png_set_longjmp_fn((ptr), longjmp, sizeof (jmp_buf)))
5496 /* Error and warning handlers installed when the PNG library
5499 static void my_png_error (png_struct
*, const char *) NO_RETURN
;
5501 my_png_error (png_struct
*png_ptr
, const char *msg
)
5503 xassert (png_ptr
!= NULL
);
5504 /* Avoid compiler warning about deprecated direct access to
5505 png_ptr's fields in libpng versions 1.4.x. */
5506 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5507 PNG_LONGJMP (png_ptr
);
5512 my_png_warning (png_struct
*png_ptr
, const char *msg
)
5514 xassert (png_ptr
!= NULL
);
5515 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5518 /* Memory source for PNG decoding. */
5520 struct png_memory_storage
5522 unsigned char *bytes
; /* The data */
5523 size_t len
; /* How big is it? */
5524 int index
; /* Where are we? */
5528 /* Function set as reader function when reading PNG image from memory.
5529 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5530 bytes from the input to DATA. */
5533 png_read_from_memory (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5535 struct png_memory_storage
*tbr
5536 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5538 if (length
> tbr
->len
- tbr
->index
)
5539 fn_png_error (png_ptr
, "Read error");
5541 memcpy (data
, tbr
->bytes
+ tbr
->index
, length
);
5542 tbr
->index
= tbr
->index
+ length
;
5546 /* Function set as reader function when reading PNG image from a file.
5547 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5548 bytes from the input to DATA. */
5551 png_read_from_file (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5553 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
5555 if (fread (data
, 1, length
, fp
) < length
)
5556 fn_png_error (png_ptr
, "Read error");
5560 /* Load PNG image IMG for use on frame F. Value is non-zero if
5564 png_load (struct frame
*f
, struct image
*img
)
5566 Lisp_Object file
, specified_file
;
5567 Lisp_Object specified_data
;
5569 XImagePtr ximg
, mask_img
= NULL
;
5570 png_struct
*png_ptr
= NULL
;
5571 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5572 FILE *volatile fp
= NULL
;
5574 png_byte
* volatile pixels
= NULL
;
5575 png_byte
** volatile rows
= NULL
;
5576 png_uint_32 width
, height
;
5577 int bit_depth
, color_type
, interlace_type
;
5579 png_uint_32 row_bytes
;
5581 struct png_memory_storage tbr
; /* Data to be read */
5583 /* Find out what file to load. */
5584 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5585 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5587 if (NILP (specified_data
))
5589 file
= x_find_image_file (specified_file
);
5590 if (!STRINGP (file
))
5592 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5596 /* Open the image file. */
5597 fp
= fopen (SSDATA (file
), "rb");
5600 image_error ("Cannot open image file `%s'", file
, Qnil
);
5604 /* Check PNG signature. */
5605 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5606 || fn_png_sig_cmp (sig
, 0, sizeof sig
))
5608 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5615 if (!STRINGP (specified_data
))
5617 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
5621 /* Read from memory. */
5622 tbr
.bytes
= SDATA (specified_data
);
5623 tbr
.len
= SBYTES (specified_data
);
5626 /* Check PNG signature. */
5627 if (tbr
.len
< sizeof sig
5628 || fn_png_sig_cmp (tbr
.bytes
, 0, sizeof sig
))
5630 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5634 /* Need to skip past the signature. */
5635 tbr
.bytes
+= sizeof (sig
);
5638 /* Initialize read and info structs for PNG lib. */
5639 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5644 if (fp
) fclose (fp
);
5648 info_ptr
= fn_png_create_info_struct (png_ptr
);
5651 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5652 if (fp
) fclose (fp
);
5656 end_info
= fn_png_create_info_struct (png_ptr
);
5659 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5660 if (fp
) fclose (fp
);
5664 /* Set error jump-back. We come back here when the PNG library
5665 detects an error. */
5666 if (setjmp (PNG_JMPBUF (png_ptr
)))
5670 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5673 if (fp
) fclose (fp
);
5677 /* Read image info. */
5678 if (!NILP (specified_data
))
5679 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5681 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
5683 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5684 fn_png_read_info (png_ptr
, info_ptr
);
5685 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5686 &interlace_type
, NULL
, NULL
);
5688 if (!check_image_size (f
, width
, height
))
5690 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5693 /* If image contains simply transparency data, we prefer to
5694 construct a clipping mask. */
5695 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5700 /* This function is easier to write if we only have to handle
5701 one data format: RGB or RGBA with 8 bits per channel. Let's
5702 transform other formats into that format. */
5704 /* Strip more than 8 bits per channel. */
5705 if (bit_depth
== 16)
5706 fn_png_set_strip_16 (png_ptr
);
5708 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5710 fn_png_set_expand (png_ptr
);
5712 /* Convert grayscale images to RGB. */
5713 if (color_type
== PNG_COLOR_TYPE_GRAY
5714 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5715 fn_png_set_gray_to_rgb (png_ptr
);
5717 /* Handle alpha channel by combining the image with a background
5718 color. Do this only if a real alpha channel is supplied. For
5719 simple transparency, we prefer a clipping mask. */
5722 /* png_color_16 *image_bg; */
5723 Lisp_Object specified_bg
5724 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5725 int shift
= (bit_depth
== 16) ? 0 : 8;
5727 if (STRINGP (specified_bg
))
5728 /* The user specified `:background', use that. */
5731 if (x_defined_color (f
, SSDATA (specified_bg
), &color
, 0))
5733 png_color_16 user_bg
;
5735 memset (&user_bg
, 0, sizeof user_bg
);
5736 user_bg
.red
= color
.red
>> shift
;
5737 user_bg
.green
= color
.green
>> shift
;
5738 user_bg
.blue
= color
.blue
>> shift
;
5740 fn_png_set_background (png_ptr
, &user_bg
,
5741 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5746 /* We use the current frame background, ignoring any default
5747 background color set by the image. */
5748 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
5750 png_color_16 frame_background
;
5752 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5753 x_query_color (f
, &color
);
5755 memset (&frame_background
, 0, sizeof frame_background
);
5756 frame_background
.red
= color
.red
>> shift
;
5757 frame_background
.green
= color
.green
>> shift
;
5758 frame_background
.blue
= color
.blue
>> shift
;
5759 #endif /* HAVE_X_WINDOWS */
5761 fn_png_set_background (png_ptr
, &frame_background
,
5762 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5766 /* Update info structure. */
5767 fn_png_read_update_info (png_ptr
, info_ptr
);
5769 /* Get number of channels. Valid values are 1 for grayscale images
5770 and images with a palette, 2 for grayscale images with transparency
5771 information (alpha channel), 3 for RGB images, and 4 for RGB
5772 images with alpha channel, i.e. RGBA. If conversions above were
5773 sufficient we should only have 3 or 4 channels here. */
5774 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
5775 xassert (channels
== 3 || channels
== 4);
5777 /* Number of bytes needed for one row of the image. */
5778 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
5780 /* Allocate memory for the image. */
5781 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
5782 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
5783 for (i
= 0; i
< height
; ++i
)
5784 rows
[i
] = pixels
+ i
* row_bytes
;
5786 /* Read the entire image. */
5787 fn_png_read_image (png_ptr
, rows
);
5788 fn_png_read_end (png_ptr
, info_ptr
);
5795 /* Create the X image and pixmap. */
5796 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
5800 /* Create an image and pixmap serving as mask if the PNG image
5801 contains an alpha channel. */
5804 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
5805 &mask_img
, &img
->mask
))
5807 x_destroy_x_image (ximg
);
5808 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
5809 img
->pixmap
= NO_PIXMAP
;
5813 /* Fill the X image and mask from PNG data. */
5814 init_color_table ();
5816 for (y
= 0; y
< height
; ++y
)
5818 png_byte
*p
= rows
[y
];
5820 for (x
= 0; x
< width
; ++x
)
5827 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5828 /* An alpha channel, aka mask channel, associates variable
5829 transparency with an image. Where other image formats
5830 support binary transparency---fully transparent or fully
5831 opaque---PNG allows up to 254 levels of partial transparency.
5832 The PNG library implements partial transparency by combining
5833 the image with a specified background color.
5835 I'm not sure how to handle this here nicely: because the
5836 background on which the image is displayed may change, for
5837 real alpha channel support, it would be necessary to create
5838 a new image for each possible background.
5840 What I'm doing now is that a mask is created if we have
5841 boolean transparency information. Otherwise I'm using
5842 the frame's background color to combine the image with. */
5847 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
5853 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5854 /* Set IMG's background color from the PNG image, unless the user
5858 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
5860 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
5861 img
->background_valid
= 1;
5865 #ifdef COLOR_TABLE_SUPPORT
5866 /* Remember colors allocated for this image. */
5867 img
->colors
= colors_in_color_table (&img
->ncolors
);
5868 free_color_table ();
5869 #endif /* COLOR_TABLE_SUPPORT */
5872 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5877 img
->height
= height
;
5879 /* Maybe fill in the background field while we have ximg handy.
5880 Casting avoids a GCC warning. */
5881 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5883 /* Put the image into the pixmap, then free the X image and its buffer. */
5884 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5885 x_destroy_x_image (ximg
);
5887 /* Same for the mask. */
5890 /* Fill in the background_transparent field while we have the
5891 mask handy. Casting avoids a GCC warning. */
5892 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
5894 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5895 x_destroy_x_image (mask_img
);
5901 #else /* HAVE_PNG */
5905 png_load (struct frame
*f
, struct image
*img
)
5907 return ns_load_image(f
, img
,
5908 image_spec_value (img
->spec
, QCfile
, NULL
),
5909 image_spec_value (img
->spec
, QCdata
, NULL
));
5911 #endif /* HAVE_NS */
5914 #endif /* !HAVE_PNG */
5918 /***********************************************************************
5920 ***********************************************************************/
5922 #if defined (HAVE_JPEG) || defined (HAVE_NS)
5924 static int jpeg_image_p (Lisp_Object object
);
5925 static int jpeg_load (struct frame
*f
, struct image
*img
);
5927 /* The symbol `jpeg' identifying images of this type. */
5929 static Lisp_Object Qjpeg
;
5931 /* Indices of image specification fields in gs_format, below. */
5933 enum jpeg_keyword_index
5942 JPEG_HEURISTIC_MASK
,
5948 /* Vector of image_keyword structures describing the format
5949 of valid user-defined image specifications. */
5951 static const struct image_keyword jpeg_format
[JPEG_LAST
] =
5953 {":type", IMAGE_SYMBOL_VALUE
, 1},
5954 {":data", IMAGE_STRING_VALUE
, 0},
5955 {":file", IMAGE_STRING_VALUE
, 0},
5956 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5957 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5958 {":relief", IMAGE_INTEGER_VALUE
, 0},
5959 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5960 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5961 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5962 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5965 /* Structure describing the image type `jpeg'. */
5967 static struct image_type jpeg_type
=
5976 /* Return non-zero if OBJECT is a valid JPEG image specification. */
5979 jpeg_image_p (Lisp_Object object
)
5981 struct image_keyword fmt
[JPEG_LAST
];
5983 memcpy (fmt
, jpeg_format
, sizeof fmt
);
5985 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
5988 /* Must specify either the :data or :file keyword. */
5989 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
5992 #endif /* HAVE_JPEG || HAVE_NS */
5996 /* Work around a warning about HAVE_STDLIB_H being redefined in
5998 #ifdef HAVE_STDLIB_H
5999 #undef HAVE_STDLIB_H
6000 #endif /* HAVE_STLIB_H */
6002 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6003 /* In older releases of the jpeg library, jpeglib.h will define boolean
6004 differently depending on __WIN32__, so make sure it is defined. */
6008 #include <jpeglib.h>
6011 #ifdef HAVE_STLIB_H_1
6012 #define HAVE_STDLIB_H 1
6017 /* JPEG library details. */
6018 DEF_IMGLIB_FN (void, jpeg_CreateDecompress
, (j_decompress_ptr
, int, size_t));
6019 DEF_IMGLIB_FN (boolean
, jpeg_start_decompress
, (j_decompress_ptr
));
6020 DEF_IMGLIB_FN (boolean
, jpeg_finish_decompress
, (j_decompress_ptr
));
6021 DEF_IMGLIB_FN (void, jpeg_destroy_decompress
, (j_decompress_ptr
));
6022 DEF_IMGLIB_FN (int, jpeg_read_header
, (j_decompress_ptr
, boolean
));
6023 DEF_IMGLIB_FN (JDIMENSION
, jpeg_read_scanlines
, (j_decompress_ptr
, JSAMPARRAY
, JDIMENSION
));
6024 DEF_IMGLIB_FN (struct jpeg_error_mgr
*, jpeg_std_error
, (struct jpeg_error_mgr
*));
6025 DEF_IMGLIB_FN (boolean
, jpeg_resync_to_restart
, (j_decompress_ptr
, int));
6028 init_jpeg_functions (Lisp_Object libraries
)
6032 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6035 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6036 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6037 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6038 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6039 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6040 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6041 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6042 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6046 /* Wrapper since we can't directly assign the function pointer
6047 to another function pointer that was declared more completely easily. */
6049 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo
, int desired
)
6051 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6056 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6057 #define fn_jpeg_start_decompress jpeg_start_decompress
6058 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6059 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6060 #define fn_jpeg_read_header jpeg_read_header
6061 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6062 #define fn_jpeg_std_error jpeg_std_error
6063 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6065 #endif /* HAVE_NTGUI */
6067 struct my_jpeg_error_mgr
6069 struct jpeg_error_mgr pub
;
6070 jmp_buf setjmp_buffer
;
6074 static void my_error_exit (j_common_ptr
) NO_RETURN
;
6076 my_error_exit (j_common_ptr cinfo
)
6078 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6079 longjmp (mgr
->setjmp_buffer
, 1);
6083 /* Init source method for JPEG data source manager. Called by
6084 jpeg_read_header() before any data is actually read. See
6085 libjpeg.doc from the JPEG lib distribution. */
6088 our_common_init_source (j_decompress_ptr cinfo
)
6093 /* Method to terminate data source. Called by
6094 jpeg_finish_decompress() after all data has been processed. */
6097 our_common_term_source (j_decompress_ptr cinfo
)
6102 /* Fill input buffer method for JPEG data source manager. Called
6103 whenever more data is needed. We read the whole image in one step,
6104 so this only adds a fake end of input marker at the end. */
6106 static JOCTET our_memory_buffer
[2];
6109 our_memory_fill_input_buffer (j_decompress_ptr cinfo
)
6111 /* Insert a fake EOI marker. */
6112 struct jpeg_source_mgr
*src
= cinfo
->src
;
6114 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6115 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6117 src
->next_input_byte
= our_memory_buffer
;
6118 src
->bytes_in_buffer
= 2;
6123 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6124 is the JPEG data source manager. */
6127 our_memory_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6129 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6133 if (num_bytes
> src
->bytes_in_buffer
)
6134 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6136 src
->bytes_in_buffer
-= num_bytes
;
6137 src
->next_input_byte
+= num_bytes
;
6142 /* Set up the JPEG lib for reading an image from DATA which contains
6143 LEN bytes. CINFO is the decompression info structure created for
6144 reading the image. */
6147 jpeg_memory_src (j_decompress_ptr cinfo
, JOCTET
*data
, unsigned int len
)
6149 struct jpeg_source_mgr
*src
;
6151 if (cinfo
->src
== NULL
)
6153 /* First time for this JPEG object? */
6154 cinfo
->src
= (struct jpeg_source_mgr
*)
6155 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6156 sizeof (struct jpeg_source_mgr
));
6157 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6158 src
->next_input_byte
= data
;
6161 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6162 src
->init_source
= our_common_init_source
;
6163 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6164 src
->skip_input_data
= our_memory_skip_input_data
;
6165 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6166 src
->term_source
= our_common_term_source
;
6167 src
->bytes_in_buffer
= len
;
6168 src
->next_input_byte
= data
;
6172 struct jpeg_stdio_mgr
6174 struct jpeg_source_mgr mgr
;
6181 /* Size of buffer to read JPEG from file.
6182 Not too big, as we want to use alloc_small. */
6183 #define JPEG_STDIO_BUFFER_SIZE 8192
6186 /* Fill input buffer method for JPEG data source manager. Called
6187 whenever more data is needed. The data is read from a FILE *. */
6190 our_stdio_fill_input_buffer (j_decompress_ptr cinfo
)
6192 struct jpeg_stdio_mgr
*src
;
6194 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6199 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6201 src
->mgr
.bytes_in_buffer
= bytes
;
6204 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6206 src
->buffer
[0] = (JOCTET
) 0xFF;
6207 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6208 src
->mgr
.bytes_in_buffer
= 2;
6210 src
->mgr
.next_input_byte
= src
->buffer
;
6217 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6218 is the JPEG data source manager. */
6221 our_stdio_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6223 struct jpeg_stdio_mgr
*src
;
6224 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6226 while (num_bytes
> 0 && !src
->finished
)
6228 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6230 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6231 src
->mgr
.next_input_byte
+= num_bytes
;
6236 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6237 src
->mgr
.bytes_in_buffer
= 0;
6238 src
->mgr
.next_input_byte
= NULL
;
6240 our_stdio_fill_input_buffer (cinfo
);
6246 /* Set up the JPEG lib for reading an image from a FILE *.
6247 CINFO is the decompression info structure created for
6248 reading the image. */
6251 jpeg_file_src (j_decompress_ptr cinfo
, FILE *fp
)
6253 struct jpeg_stdio_mgr
*src
;
6255 if (cinfo
->src
!= NULL
)
6256 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6259 /* First time for this JPEG object? */
6260 cinfo
->src
= (struct jpeg_source_mgr
*)
6261 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6262 sizeof (struct jpeg_stdio_mgr
));
6263 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6264 src
->buffer
= (JOCTET
*)
6265 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6266 JPEG_STDIO_BUFFER_SIZE
);
6271 src
->mgr
.init_source
= our_common_init_source
;
6272 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6273 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6274 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6275 src
->mgr
.term_source
= our_common_term_source
;
6276 src
->mgr
.bytes_in_buffer
= 0;
6277 src
->mgr
.next_input_byte
= NULL
;
6281 /* Load image IMG for use on frame F. Patterned after example.c
6282 from the JPEG lib. */
6285 jpeg_load (struct frame
*f
, struct image
*img
)
6287 struct jpeg_decompress_struct cinfo
;
6288 struct my_jpeg_error_mgr mgr
;
6289 Lisp_Object file
, specified_file
;
6290 Lisp_Object specified_data
;
6291 FILE * volatile fp
= NULL
;
6293 int row_stride
, x
, y
;
6294 XImagePtr ximg
= NULL
;
6296 unsigned long *colors
;
6299 /* Open the JPEG file. */
6300 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6301 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6303 if (NILP (specified_data
))
6305 file
= x_find_image_file (specified_file
);
6306 if (!STRINGP (file
))
6308 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6312 fp
= fopen (SSDATA (file
), "rb");
6315 image_error ("Cannot open `%s'", file
, Qnil
);
6319 else if (!STRINGP (specified_data
))
6321 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6325 /* Customize libjpeg's error handling to call my_error_exit when an
6326 error is detected. This function will perform a longjmp. */
6327 cinfo
.err
= fn_jpeg_std_error (&mgr
.pub
);
6328 mgr
.pub
.error_exit
= my_error_exit
;
6330 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6334 /* Called from my_error_exit. Display a JPEG error. */
6335 char buf
[JMSG_LENGTH_MAX
];
6336 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buf
);
6337 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6338 build_string (buf
));
6341 /* Close the input file and destroy the JPEG object. */
6343 fclose ((FILE *) fp
);
6344 fn_jpeg_destroy_decompress (&cinfo
);
6346 /* If we already have an XImage, free that. */
6347 x_destroy_x_image (ximg
);
6349 /* Free pixmap and colors. */
6350 x_clear_image (f
, img
);
6354 /* Create the JPEG decompression object. Let it read from fp.
6355 Read the JPEG image header. */
6356 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6358 if (NILP (specified_data
))
6359 jpeg_file_src (&cinfo
, (FILE *) fp
);
6361 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6362 SBYTES (specified_data
));
6364 fn_jpeg_read_header (&cinfo
, 1);
6366 /* Customize decompression so that color quantization will be used.
6367 Start decompression. */
6368 cinfo
.quantize_colors
= 1;
6369 fn_jpeg_start_decompress (&cinfo
);
6370 width
= img
->width
= cinfo
.output_width
;
6371 height
= img
->height
= cinfo
.output_height
;
6373 if (!check_image_size (f
, width
, height
))
6375 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6376 longjmp (mgr
.setjmp_buffer
, 2);
6379 /* Create X image and pixmap. */
6380 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6381 longjmp (mgr
.setjmp_buffer
, 2);
6383 /* Allocate colors. When color quantization is used,
6384 cinfo.actual_number_of_colors has been set with the number of
6385 colors generated, and cinfo.colormap is a two-dimensional array
6386 of color indices in the range 0..cinfo.actual_number_of_colors.
6387 No more than 255 colors will be generated. */
6391 if (cinfo
.out_color_components
> 2)
6392 ir
= 0, ig
= 1, ib
= 2;
6393 else if (cinfo
.out_color_components
> 1)
6394 ir
= 0, ig
= 1, ib
= 0;
6396 ir
= 0, ig
= 0, ib
= 0;
6398 /* Use the color table mechanism because it handles colors that
6399 cannot be allocated nicely. Such colors will be replaced with
6400 a default color, and we don't have to care about which colors
6401 can be freed safely, and which can't. */
6402 init_color_table ();
6403 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6406 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6408 /* Multiply RGB values with 255 because X expects RGB values
6409 in the range 0..0xffff. */
6410 int r
= cinfo
.colormap
[ir
][i
] << 8;
6411 int g
= cinfo
.colormap
[ig
][i
] << 8;
6412 int b
= cinfo
.colormap
[ib
][i
] << 8;
6413 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6416 #ifdef COLOR_TABLE_SUPPORT
6417 /* Remember those colors actually allocated. */
6418 img
->colors
= colors_in_color_table (&img
->ncolors
);
6419 free_color_table ();
6420 #endif /* COLOR_TABLE_SUPPORT */
6424 row_stride
= width
* cinfo
.output_components
;
6425 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6427 for (y
= 0; y
< height
; ++y
)
6429 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6430 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6431 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6435 fn_jpeg_finish_decompress (&cinfo
);
6436 fn_jpeg_destroy_decompress (&cinfo
);
6438 fclose ((FILE *) fp
);
6440 /* Maybe fill in the background field while we have ximg handy. */
6441 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6442 /* Casting avoids a GCC warning. */
6443 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6445 /* Put the image into the pixmap. */
6446 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6447 x_destroy_x_image (ximg
);
6451 #else /* HAVE_JPEG */
6455 jpeg_load (struct frame
*f
, struct image
*img
)
6457 return ns_load_image (f
, img
,
6458 image_spec_value (img
->spec
, QCfile
, NULL
),
6459 image_spec_value (img
->spec
, QCdata
, NULL
));
6461 #endif /* HAVE_NS */
6463 #endif /* !HAVE_JPEG */
6467 /***********************************************************************
6469 ***********************************************************************/
6471 #if defined (HAVE_TIFF) || defined (HAVE_NS)
6473 static int tiff_image_p (Lisp_Object object
);
6474 static int tiff_load (struct frame
*f
, struct image
*img
);
6476 /* The symbol `tiff' identifying images of this type. */
6478 static Lisp_Object Qtiff
;
6480 /* Indices of image specification fields in tiff_format, below. */
6482 enum tiff_keyword_index
6491 TIFF_HEURISTIC_MASK
,
6498 /* Vector of image_keyword structures describing the format
6499 of valid user-defined image specifications. */
6501 static const struct image_keyword tiff_format
[TIFF_LAST
] =
6503 {":type", IMAGE_SYMBOL_VALUE
, 1},
6504 {":data", IMAGE_STRING_VALUE
, 0},
6505 {":file", IMAGE_STRING_VALUE
, 0},
6506 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6507 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6508 {":relief", IMAGE_INTEGER_VALUE
, 0},
6509 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6510 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6511 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6512 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
6513 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0}
6516 /* Structure describing the image type `tiff'. */
6518 static struct image_type tiff_type
=
6527 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6530 tiff_image_p (Lisp_Object object
)
6532 struct image_keyword fmt
[TIFF_LAST
];
6533 memcpy (fmt
, tiff_format
, sizeof fmt
);
6535 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6538 /* Must specify either the :data or :file keyword. */
6539 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6542 #endif /* HAVE_TIFF || HAVE_NS */
6550 /* TIFF library details. */
6551 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetErrorHandler
, (TIFFErrorHandler
));
6552 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetWarningHandler
, (TIFFErrorHandler
));
6553 DEF_IMGLIB_FN (TIFF
*, TIFFOpen
, (const char *, const char *));
6554 DEF_IMGLIB_FN (TIFF
*, TIFFClientOpen
, (const char *, const char *, thandle_t
,
6555 TIFFReadWriteProc
, TIFFReadWriteProc
,
6556 TIFFSeekProc
, TIFFCloseProc
, TIFFSizeProc
,
6557 TIFFMapFileProc
, TIFFUnmapFileProc
));
6558 DEF_IMGLIB_FN (int, TIFFGetField
, (TIFF
*, ttag_t
, ...));
6559 DEF_IMGLIB_FN (int, TIFFReadRGBAImage
, (TIFF
*, uint32
, uint32
, uint32
*, int));
6560 DEF_IMGLIB_FN (void, TIFFClose
, (TIFF
*));
6561 DEF_IMGLIB_FN (int, TIFFSetDirectory
, (TIFF
*, tdir_t
));
6564 init_tiff_functions (Lisp_Object libraries
)
6568 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6571 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6572 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6573 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6574 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6575 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6576 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6577 LOAD_IMGLIB_FN (library
, TIFFClose
);
6578 LOAD_IMGLIB_FN (library
, TIFFSetDirectory
);
6584 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6585 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6586 #define fn_TIFFOpen TIFFOpen
6587 #define fn_TIFFClientOpen TIFFClientOpen
6588 #define fn_TIFFGetField TIFFGetField
6589 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6590 #define fn_TIFFClose TIFFClose
6591 #define fn_TIFFSetDirectory TIFFSetDirectory
6592 #endif /* HAVE_NTGUI */
6595 /* Reading from a memory buffer for TIFF images Based on the PNG
6596 memory source, but we have to provide a lot of extra functions.
6599 We really only need to implement read and seek, but I am not
6600 convinced that the TIFF library is smart enough not to destroy
6601 itself if we only hand it the function pointers we need to
6606 unsigned char *bytes
;
6613 tiff_read_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6615 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6617 if (size
> src
->len
- src
->index
)
6619 memcpy (buf
, src
->bytes
+ src
->index
, size
);
6625 tiff_write_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6631 tiff_seek_in_memory (thandle_t data
, toff_t off
, int whence
)
6633 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6638 case SEEK_SET
: /* Go from beginning of source. */
6642 case SEEK_END
: /* Go from end of source. */
6643 idx
= src
->len
+ off
;
6646 case SEEK_CUR
: /* Go from current position. */
6647 idx
= src
->index
+ off
;
6650 default: /* Invalid `whence'. */
6654 if (idx
> src
->len
|| idx
< 0)
6662 tiff_close_memory (thandle_t data
)
6669 tiff_mmap_memory (thandle_t data
, tdata_t
*pbase
, toff_t
*psize
)
6671 /* It is already _IN_ memory. */
6676 tiff_unmap_memory (thandle_t data
, tdata_t base
, toff_t size
)
6678 /* We don't need to do this. */
6682 tiff_size_of_memory (thandle_t data
)
6684 return ((tiff_memory_source
*) data
)->len
;
6688 static void tiff_error_handler (const char *, const char *, va_list)
6689 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6691 tiff_error_handler (const char *title
, const char *format
, va_list ap
)
6696 len
= sprintf (buf
, "TIFF error: %s ", title
);
6697 vsprintf (buf
+ len
, format
, ap
);
6698 add_to_log (buf
, Qnil
, Qnil
);
6702 static void tiff_warning_handler (const char *, const char *, va_list)
6703 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6705 tiff_warning_handler (const char *title
, const char *format
, va_list ap
)
6710 len
= sprintf (buf
, "TIFF warning: %s ", title
);
6711 vsprintf (buf
+ len
, format
, ap
);
6712 add_to_log (buf
, Qnil
, Qnil
);
6716 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6720 tiff_load (struct frame
*f
, struct image
*img
)
6722 Lisp_Object file
, specified_file
;
6723 Lisp_Object specified_data
;
6725 int width
, height
, x
, y
, count
;
6729 tiff_memory_source memsrc
;
6732 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6733 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6735 fn_TIFFSetErrorHandler ((TIFFErrorHandler
) tiff_error_handler
);
6736 fn_TIFFSetWarningHandler ((TIFFErrorHandler
) tiff_warning_handler
);
6738 if (NILP (specified_data
))
6740 /* Read from a file */
6741 file
= x_find_image_file (specified_file
);
6742 if (!STRINGP (file
))
6744 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6748 /* Try to open the image file. */
6749 tiff
= fn_TIFFOpen (SSDATA (file
), "r");
6752 image_error ("Cannot open `%s'", file
, Qnil
);
6758 if (!STRINGP (specified_data
))
6760 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6764 /* Memory source! */
6765 memsrc
.bytes
= SDATA (specified_data
);
6766 memsrc
.len
= SBYTES (specified_data
);
6769 tiff
= fn_TIFFClientOpen ("memory_source", "r", (thandle_t
)&memsrc
,
6770 (TIFFReadWriteProc
) tiff_read_from_memory
,
6771 (TIFFReadWriteProc
) tiff_write_from_memory
,
6772 tiff_seek_in_memory
,
6774 tiff_size_of_memory
,
6780 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6785 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
6786 if (INTEGERP (image
))
6788 int ino
= XFASTINT (image
);
6789 if (!fn_TIFFSetDirectory (tiff
, ino
))
6791 image_error ("Invalid image number `%s' in image `%s'",
6793 fn_TIFFClose (tiff
);
6798 /* Get width and height of the image, and allocate a raster buffer
6799 of width x height 32-bit values. */
6800 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6801 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6803 if (!check_image_size (f
, width
, height
))
6805 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6806 fn_TIFFClose (tiff
);
6810 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
6812 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6814 /* Count the number of images in the file. */
6815 for (count
= 1; fn_TIFFSetDirectory (tiff
, count
); count
++)
6819 img
->lisp_data
= Fcons (Qcount
,
6820 Fcons (make_number (count
),
6823 fn_TIFFClose (tiff
);
6826 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6831 /* Create the X image and pixmap. */
6832 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6838 /* Initialize the color table. */
6839 init_color_table ();
6841 /* Process the pixel raster. Origin is in the lower-left corner. */
6842 for (y
= 0; y
< height
; ++y
)
6844 uint32
*row
= buf
+ y
* width
;
6846 for (x
= 0; x
< width
; ++x
)
6848 uint32 abgr
= row
[x
];
6849 int r
= TIFFGetR (abgr
) << 8;
6850 int g
= TIFFGetG (abgr
) << 8;
6851 int b
= TIFFGetB (abgr
) << 8;
6852 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
6856 #ifdef COLOR_TABLE_SUPPORT
6857 /* Remember the colors allocated for the image. Free the color table. */
6858 img
->colors
= colors_in_color_table (&img
->ncolors
);
6859 free_color_table ();
6860 #endif /* COLOR_TABLE_SUPPORT */
6863 img
->height
= height
;
6865 /* Maybe fill in the background field while we have ximg handy. */
6866 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6867 /* Casting avoids a GCC warning on W32. */
6868 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6870 /* Put the image into the pixmap, then free the X image and its buffer. */
6871 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6872 x_destroy_x_image (ximg
);
6878 #else /* HAVE_TIFF */
6882 tiff_load (struct frame
*f
, struct image
*img
)
6884 return ns_load_image (f
, img
,
6885 image_spec_value (img
->spec
, QCfile
, NULL
),
6886 image_spec_value (img
->spec
, QCdata
, NULL
));
6888 #endif /* HAVE_NS */
6890 #endif /* !HAVE_TIFF */
6894 /***********************************************************************
6896 ***********************************************************************/
6898 #if defined (HAVE_GIF) || defined (HAVE_NS)
6900 static int gif_image_p (Lisp_Object object
);
6901 static int gif_load (struct frame
*f
, struct image
*img
);
6902 static void gif_clear_image (struct frame
*f
, struct image
*img
);
6904 /* The symbol `gif' identifying images of this type. */
6906 static Lisp_Object Qgif
;
6908 /* Indices of image specification fields in gif_format, below. */
6910 enum gif_keyword_index
6926 /* Vector of image_keyword structures describing the format
6927 of valid user-defined image specifications. */
6929 static const struct image_keyword gif_format
[GIF_LAST
] =
6931 {":type", IMAGE_SYMBOL_VALUE
, 1},
6932 {":data", IMAGE_STRING_VALUE
, 0},
6933 {":file", IMAGE_STRING_VALUE
, 0},
6934 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6935 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6936 {":relief", IMAGE_INTEGER_VALUE
, 0},
6937 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6938 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6939 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6940 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
6941 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6944 /* Structure describing the image type `gif'. */
6946 static struct image_type gif_type
=
6955 /* Free X resources of GIF image IMG which is used on frame F. */
6958 gif_clear_image (struct frame
*f
, struct image
*img
)
6960 img
->lisp_data
= Qnil
;
6961 x_clear_image (f
, img
);
6964 /* Return non-zero if OBJECT is a valid GIF image specification. */
6967 gif_image_p (Lisp_Object object
)
6969 struct image_keyword fmt
[GIF_LAST
];
6970 memcpy (fmt
, gif_format
, sizeof fmt
);
6972 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
6975 /* Must specify either the :data or :file keyword. */
6976 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
6979 #endif /* HAVE_GIF */
6983 #if defined (HAVE_NTGUI)
6984 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
6985 Undefine before redefining to avoid a preprocessor warning. */
6989 /* avoid conflict with QuickdrawText.h */
6990 #define DrawText gif_DrawText
6991 #include <gif_lib.h>
6994 #else /* HAVE_NTGUI */
6996 #include <gif_lib.h>
6998 #endif /* HAVE_NTGUI */
7003 /* GIF library details. */
7004 DEF_IMGLIB_FN (int, DGifCloseFile
, (GifFileType
*));
7005 DEF_IMGLIB_FN (int, DGifSlurp
, (GifFileType
*));
7006 DEF_IMGLIB_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
));
7007 DEF_IMGLIB_FN (GifFileType
*, DGifOpenFileName
, (const char *));
7010 init_gif_functions (Lisp_Object libraries
)
7014 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7017 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7018 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7019 LOAD_IMGLIB_FN (library
, DGifOpen
);
7020 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7026 #define fn_DGifCloseFile DGifCloseFile
7027 #define fn_DGifSlurp DGifSlurp
7028 #define fn_DGifOpen DGifOpen
7029 #define fn_DGifOpenFileName DGifOpenFileName
7031 #endif /* HAVE_NTGUI */
7033 /* Reading a GIF image from memory
7034 Based on the PNG memory stuff to a certain extent. */
7038 unsigned char *bytes
;
7044 /* Make the current memory source available to gif_read_from_memory.
7045 It's done this way because not all versions of libungif support
7046 a UserData field in the GifFileType structure. */
7047 static gif_memory_source
*current_gif_memory_src
;
7050 gif_read_from_memory (GifFileType
*file
, GifByteType
*buf
, int len
)
7052 gif_memory_source
*src
= current_gif_memory_src
;
7054 if (len
> src
->len
- src
->index
)
7057 memcpy (buf
, src
->bytes
+ src
->index
, len
);
7063 /* Load GIF image IMG for use on frame F. Value is non-zero if
7066 static const int interlace_start
[] = {0, 4, 2, 1};
7067 static const int interlace_increment
[] = {8, 8, 4, 2};
7069 #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249
7072 gif_load (struct frame
*f
, struct image
*img
)
7075 int rc
, width
, height
, x
, y
, i
, j
;
7077 ColorMapObject
*gif_color_map
;
7078 unsigned long pixel_colors
[256];
7080 int image_height
, image_width
;
7081 gif_memory_source memsrc
;
7082 Lisp_Object specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7083 Lisp_Object specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7084 Lisp_Object specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7085 unsigned long bgcolor
= 0;
7088 if (NILP (specified_data
))
7090 file
= x_find_image_file (specified_file
);
7091 if (!STRINGP (file
))
7093 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7097 /* Open the GIF file. */
7098 gif
= fn_DGifOpenFileName (SSDATA (file
));
7101 image_error ("Cannot open `%s'", file
, Qnil
);
7107 if (!STRINGP (specified_data
))
7109 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
7113 /* Read from memory! */
7114 current_gif_memory_src
= &memsrc
;
7115 memsrc
.bytes
= SDATA (specified_data
);
7116 memsrc
.len
= SBYTES (specified_data
);
7119 gif
= fn_DGifOpen (&memsrc
, gif_read_from_memory
);
7122 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7127 /* Before reading entire contents, check the declared image size. */
7128 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7130 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7131 fn_DGifCloseFile (gif
);
7135 /* Read entire contents. */
7136 rc
= fn_DGifSlurp (gif
);
7137 if (rc
== GIF_ERROR
|| gif
->ImageCount
<= 0)
7139 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7140 fn_DGifCloseFile (gif
);
7144 /* Which sub-image are we to display? */
7146 Lisp_Object image_number
= image_spec_value (img
->spec
, QCindex
, NULL
);
7147 idx
= INTEGERP (image_number
) ? XFASTINT (image_number
) : 0;
7148 if (idx
< 0 || idx
>= gif
->ImageCount
)
7150 image_error ("Invalid image number `%s' in image `%s'",
7151 image_number
, img
->spec
);
7152 fn_DGifCloseFile (gif
);
7157 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Top
;
7158 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Left
;
7159 image_height
= gif
->SavedImages
[idx
].ImageDesc
.Height
;
7160 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7161 image_width
= gif
->SavedImages
[idx
].ImageDesc
.Width
;
7162 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7164 width
= img
->width
= max (gif
->SWidth
,
7165 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7166 img
->corners
[RIGHT_CORNER
]));
7167 height
= img
->height
= max (gif
->SHeight
,
7168 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7169 img
->corners
[BOT_CORNER
]));
7171 if (!check_image_size (f
, width
, height
))
7173 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7174 fn_DGifCloseFile (gif
);
7178 /* Create the X image and pixmap. */
7179 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7181 fn_DGifCloseFile (gif
);
7185 /* Clear the part of the screen image not covered by the image.
7186 Full animated GIF support requires more here (see the gif89 spec,
7187 disposal methods). Let's simply assume that the part not covered
7188 by a sub-image is in the frame's background color. */
7189 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7190 for (x
= 0; x
< width
; ++x
)
7191 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7193 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7194 for (x
= 0; x
< width
; ++x
)
7195 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7197 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7199 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7200 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7201 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7202 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7205 /* Read the GIF image into the X image. */
7207 /* FIXME: With the current implementation, loading an animated gif
7208 is quadratic in the number of animation frames, since each frame
7209 is a separate struct image. We must provide a way for a single
7210 gif_load call to construct and save all animation frames. */
7212 init_color_table ();
7213 if (STRINGP (specified_bg
))
7214 bgcolor
= x_alloc_image_color (f
, img
, specified_bg
,
7215 FRAME_BACKGROUND_PIXEL (f
));
7216 for (j
= 0; j
<= idx
; ++j
)
7218 /* We use a local variable `raster' here because RasterBits is a
7219 char *, which invites problems with bytes >= 0x80. */
7220 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7221 unsigned char *raster
= (unsigned char *) subimage
->RasterBits
;
7222 int transparency_color_index
= -1;
7225 /* Find the Graphic Control Extension block for this sub-image.
7226 Extract the disposal method and transparency color. */
7227 for (i
= 0; i
< subimage
->ExtensionBlockCount
; i
++)
7229 ExtensionBlock
*extblock
= subimage
->ExtensionBlocks
+ i
;
7231 if ((extblock
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
)
7232 && extblock
->ByteCount
== 4
7233 && extblock
->Bytes
[0] & 1)
7235 /* From gif89a spec: 1 = "keep in place", 2 = "restore
7236 to background". Treat any other value like 2. */
7237 disposal
= (extblock
->Bytes
[0] >> 2) & 7;
7238 transparency_color_index
= (unsigned char) extblock
->Bytes
[3];
7243 /* We can't "keep in place" the first subimage. */
7247 /* Allocate subimage colors. */
7248 memset (pixel_colors
, 0, sizeof pixel_colors
);
7249 gif_color_map
= subimage
->ImageDesc
.ColorMap
;
7251 gif_color_map
= gif
->SColorMap
;
7254 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7256 if (transparency_color_index
== i
)
7257 pixel_colors
[i
] = STRINGP (specified_bg
)
7258 ? bgcolor
: FRAME_BACKGROUND_PIXEL (f
);
7261 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7262 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7263 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7264 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7268 /* Apply the pixel values. */
7269 if (gif
->SavedImages
[j
].ImageDesc
.Interlace
)
7273 for (y
= 0, row
= interlace_start
[0], pass
= 0;
7275 y
++, row
+= interlace_increment
[pass
])
7277 if (row
>= image_height
)
7279 row
= interlace_start
[++pass
];
7280 while (row
>= image_height
)
7281 row
= interlace_start
[++pass
];
7284 for (x
= 0; x
< image_width
; x
++)
7286 int c
= raster
[y
* image_width
+ x
];
7287 if (transparency_color_index
!= c
|| disposal
!= 1)
7288 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7289 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7295 for (y
= 0; y
< image_height
; ++y
)
7296 for (x
= 0; x
< image_width
; ++x
)
7298 int c
= raster
[y
* image_width
+ x
];
7299 if (transparency_color_index
!= c
|| disposal
!= 1)
7300 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7301 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7306 #ifdef COLOR_TABLE_SUPPORT
7307 img
->colors
= colors_in_color_table (&img
->ncolors
);
7308 free_color_table ();
7309 #endif /* COLOR_TABLE_SUPPORT */
7311 /* Save GIF image extension data for `image-metadata'.
7312 Format is (count IMAGES extension-data (FUNCTION "BYTES" ...)). */
7313 img
->lisp_data
= Qnil
;
7314 if (gif
->SavedImages
[idx
].ExtensionBlockCount
> 0)
7316 unsigned int delay
= 0;
7317 ExtensionBlock
*ext
= gif
->SavedImages
[idx
].ExtensionBlocks
;
7318 for (i
= 0; i
< gif
->SavedImages
[idx
].ExtensionBlockCount
; i
++, ext
++)
7319 /* Append (... FUNCTION "BYTES") */
7322 = Fcons (make_number (ext
->Function
),
7323 Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7325 if (ext
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
7326 && ext
->ByteCount
== 4)
7328 delay
= ext
->Bytes
[2] << CHAR_BIT
;
7329 delay
|= ext
->Bytes
[1];
7332 img
->lisp_data
= Fcons (Qextension_data
,
7333 Fcons (img
->lisp_data
, Qnil
));
7337 Fcons (make_float (((double) delay
) * 0.01),
7341 if (gif
->ImageCount
> 1)
7342 img
->lisp_data
= Fcons (Qcount
,
7343 Fcons (make_number (gif
->ImageCount
),
7346 fn_DGifCloseFile (gif
);
7348 /* Maybe fill in the background field while we have ximg handy. */
7349 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7350 /* Casting avoids a GCC warning. */
7351 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7353 /* Put the image into the pixmap, then free the X image and its buffer. */
7354 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7355 x_destroy_x_image (ximg
);
7360 #else /* !HAVE_GIF */
7364 gif_load (struct frame
*f
, struct image
*img
)
7366 return ns_load_image (f
, img
,
7367 image_spec_value (img
->spec
, QCfile
, NULL
),
7368 image_spec_value (img
->spec
, QCdata
, NULL
));
7370 #endif /* HAVE_NS */
7372 #endif /* HAVE_GIF */
7375 /***********************************************************************
7377 ***********************************************************************/
7378 #if defined (HAVE_IMAGEMAGICK)
7380 static Lisp_Object Qimagemagick
;
7382 static int imagemagick_image_p (Lisp_Object
);
7383 static int imagemagick_load (struct frame
*, struct image
*);
7384 static void imagemagick_clear_image (struct frame
*, struct image
*);
7386 /* Indices of image specification fields in imagemagick_format. */
7388 enum imagemagick_keyword_index
7396 IMAGEMAGICK_ALGORITHM
,
7397 IMAGEMAGICK_HEURISTIC_MASK
,
7399 IMAGEMAGICK_BACKGROUND
,
7402 IMAGEMAGICK_ROTATION
,
7407 /* Vector of image_keyword structures describing the format
7408 of valid user-defined image specifications. */
7410 static struct image_keyword imagemagick_format
[IMAGEMAGICK_LAST
] =
7412 {":type", IMAGE_SYMBOL_VALUE
, 1},
7413 {":data", IMAGE_STRING_VALUE
, 0},
7414 {":file", IMAGE_STRING_VALUE
, 0},
7415 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7416 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7417 {":relief", IMAGE_INTEGER_VALUE
, 0},
7418 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7419 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7420 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7421 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
7422 {":height", IMAGE_INTEGER_VALUE
, 0},
7423 {":width", IMAGE_INTEGER_VALUE
, 0},
7424 {":rotation", IMAGE_NUMBER_VALUE
, 0},
7425 {":crop", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
7428 /* Structure describing the image type for any image handled via
7431 static struct image_type imagemagick_type
=
7434 imagemagick_image_p
,
7436 imagemagick_clear_image
,
7440 /* Free X resources of imagemagick image IMG which is used on frame F. */
7443 imagemagick_clear_image (struct frame
*f
,
7446 x_clear_image (f
, img
);
7449 /* Return non-zero if OBJECT is a valid IMAGEMAGICK image specification. Do
7450 this by calling parse_image_spec and supplying the keywords that
7451 identify the IMAGEMAGICK format. */
7454 imagemagick_image_p (Lisp_Object object
)
7456 struct image_keyword fmt
[IMAGEMAGICK_LAST
];
7457 memcpy (fmt
, imagemagick_format
, sizeof fmt
);
7459 if (!parse_image_spec (object
, fmt
, IMAGEMAGICK_LAST
, Qimagemagick
))
7462 /* Must specify either the :data or :file keyword. */
7463 return fmt
[IMAGEMAGICK_FILE
].count
+ fmt
[IMAGEMAGICK_DATA
].count
== 1;
7466 /* The GIF library also defines DrawRectangle, but its never used in Emacs.
7467 Therefore rename the function so it doesnt collide with ImageMagick. */
7468 #define DrawRectangle DrawRectangleGif
7469 #include <wand/MagickWand.h>
7471 /* ImageMagick 6.5.3 through 6.6.5 hid PixelGetMagickColor for some reason.
7472 Emacs seems to work fine with the hidden version, so unhide it. */
7473 #include <magick/version.h>
7474 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
7475 extern WandExport
void PixelGetMagickColor (const PixelWand
*,
7476 MagickPixelPacket
*);
7479 /* Helper function for imagemagick_load, which does the actual loading
7480 given contents and size, apart from frame and image structures,
7481 passed from imagemagick_load. Uses librimagemagick to do most of
7482 the image processing.
7484 F is a pointer to the Emacs frame; IMG to the image structure to
7485 prepare; CONTENTS is the string containing the IMAGEMAGICK data to
7486 be parsed; SIZE is the number of bytes of data; and FILENAME is
7487 either the file name or the image data.
7489 Return non-zero if successful. */
7492 imagemagick_load_image (struct frame
*f
, struct image
*img
,
7493 unsigned char *contents
, unsigned int size
,
7499 MagickBooleanType status
;
7505 MagickWand
*image_wand
;
7506 MagickWand
*ping_wand
;
7507 PixelIterator
*iterator
;
7509 MagickPixelPacket pixel
;
7514 int desired_width
, desired_height
;
7516 int imagemagick_rendermethod
;
7518 ImageInfo
*image_info
;
7519 ExceptionInfo
*exception
;
7523 /* Handle image index for image types who can contain more than one image.
7524 Interface :index is same as for GIF. First we "ping" the image to see how
7525 many sub-images it contains. Pinging is faster than loading the image to
7526 find out things about it. */
7528 /* Initialize the imagemagick environment. */
7529 MagickWandGenesis ();
7530 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7531 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7532 ping_wand
= NewMagickWand ();
7533 MagickSetResolution (ping_wand
, 2, 2);
7534 if (filename
!= NULL
)
7536 status
= MagickPingImage (ping_wand
, filename
);
7540 status
= MagickPingImageBlob (ping_wand
, contents
, size
);
7543 if (ino
>= MagickGetNumberImages (ping_wand
))
7545 image_error ("Invalid image number `%s' in image `%s'",
7547 DestroyMagickWand (ping_wand
);
7551 if (MagickGetNumberImages(ping_wand
) > 1)
7554 Fcons (make_number (MagickGetNumberImages (ping_wand
)),
7557 DestroyMagickWand (ping_wand
);
7559 /* Now we know how many images are inside the file. If it's not a
7560 bundle, the number is one. */
7562 if (filename
!= NULL
)
7564 image_info
= CloneImageInfo ((ImageInfo
*) NULL
);
7565 (void) strcpy (image_info
->filename
, filename
);
7566 image_info
->number_scenes
= 1;
7567 image_info
->scene
= ino
;
7568 exception
= AcquireExceptionInfo ();
7570 im_image
= ReadImage (image_info
, exception
);
7571 DestroyExceptionInfo (exception
);
7573 if (im_image
== NULL
)
7574 goto imagemagick_no_wand
;
7575 image_wand
= NewMagickWandFromImage (im_image
);
7576 DestroyImage(im_image
);
7580 image_wand
= NewMagickWand ();
7581 if (MagickReadImageBlob (image_wand
, contents
, size
) == MagickFalse
)
7582 goto imagemagick_error
;
7585 /* If width and/or height is set in the display spec assume we want
7586 to scale to those values. If either h or w is unspecified, the
7587 unspecified should be calculated from the specified to preserve
7590 value
= image_spec_value (img
->spec
, QCwidth
, NULL
);
7591 desired_width
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7592 value
= image_spec_value (img
->spec
, QCheight
, NULL
);
7593 desired_height
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7595 height
= MagickGetImageHeight (image_wand
);
7596 width
= MagickGetImageWidth (image_wand
);
7598 if (desired_width
!= -1 && desired_height
== -1)
7599 /* w known, calculate h. */
7600 desired_height
= (double) desired_width
/ width
* height
;
7601 if (desired_width
== -1 && desired_height
!= -1)
7602 /* h known, calculate w. */
7603 desired_width
= (double) desired_height
/ height
* width
;
7604 if (desired_width
!= -1 && desired_height
!= -1)
7606 status
= MagickScaleImage (image_wand
, desired_width
, desired_height
);
7607 if (status
== MagickFalse
)
7609 image_error ("Imagemagick scale failed", Qnil
, Qnil
);
7610 goto imagemagick_error
;
7614 /* crop behaves similar to image slicing in Emacs but is more memory
7616 crop
= image_spec_value (img
->spec
, QCcrop
, NULL
);
7618 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7620 /* After some testing, it seems MagickCropImage is the fastest crop
7621 function in ImageMagick. This crop function seems to do less copying
7622 than the alternatives, but it still reads the entire image into memory
7623 before croping, which is aparently difficult to avoid when using
7626 w
= XFASTINT (XCAR (crop
));
7628 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7630 h
= XFASTINT (XCAR (crop
));
7632 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7634 x
= XFASTINT (XCAR (crop
));
7636 if (CONSP (crop
) && INTEGERP (XCAR (crop
)))
7638 y
= XFASTINT (XCAR (crop
));
7639 MagickCropImage (image_wand
, w
, h
, x
, y
);
7645 /* Furthermore :rotation. we need background color and angle for
7648 TODO background handling for rotation specified_bg =
7649 image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
7651 value
= image_spec_value (img
->spec
, QCrotation
, NULL
);
7654 PixelWand
* background
= NewPixelWand ();
7655 PixelSetColor (background
, "#ffffff");/*TODO remove hardcode*/
7657 rotation
= extract_float (value
);
7659 status
= MagickRotateImage (image_wand
, background
, rotation
);
7660 DestroyPixelWand (background
);
7661 if (status
== MagickFalse
)
7663 image_error ("Imagemagick image rotate failed", Qnil
, Qnil
);
7664 goto imagemagick_error
;
7668 /* Finally we are done manipulating the image. Figure out the
7669 resulting width/height and transfer ownerwship to Emacs. */
7670 height
= MagickGetImageHeight (image_wand
);
7671 width
= MagickGetImageWidth (image_wand
);
7673 if (! check_image_size (f
, width
, height
))
7675 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7676 goto imagemagick_error
;
7679 /* We can now get a valid pixel buffer from the imagemagick file, if all
7682 init_color_table ();
7683 imagemagick_rendermethod
= (INTEGERP (Vimagemagick_render_type
)
7684 ? XFASTINT (Vimagemagick_render_type
) : 0);
7685 if (imagemagick_rendermethod
== 0)
7687 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7688 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7689 &ximg
, &img
->pixmap
))
7691 #ifdef COLOR_TABLE_SUPPORT
7692 free_color_table ();
7694 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7695 goto imagemagick_error
;
7698 /* Copy imagegmagick image to x with primitive yet robust pixel
7699 pusher loop. This has been tested a lot with many different
7702 /* Copy pixels from the imagemagick image structure to the x image map. */
7703 iterator
= NewPixelIterator (image_wand
);
7704 if (iterator
== (PixelIterator
*) NULL
)
7706 #ifdef COLOR_TABLE_SUPPORT
7707 free_color_table ();
7709 x_destroy_x_image (ximg
);
7710 image_error ("Imagemagick pixel iterator creation failed",
7712 goto imagemagick_error
;
7715 for (y
= 0; y
< (long) MagickGetImageHeight (image_wand
); y
++)
7717 pixels
= PixelGetNextIteratorRow (iterator
, &width
);
7718 if (pixels
== (PixelWand
**) NULL
)
7720 for (x
= 0; x
< (long) width
; x
++)
7722 PixelGetMagickColor (pixels
[x
], &pixel
);
7723 XPutPixel (ximg
, x
, y
,
7724 lookup_rgb_color (f
,
7730 DestroyPixelIterator (iterator
);
7733 if (imagemagick_rendermethod
== 1)
7735 /* Magicexportimage is normaly faster than pixelpushing. This
7736 method is also well tested. Some aspects of this method are
7737 ad-hoc and needs to be more researched. */
7738 int imagedepth
= 24;/*MagickGetImageDepth(image_wand);*/
7739 const char *exportdepth
= imagedepth
<= 8 ? "I" : "BGRP";/*"RGBP";*/
7740 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7741 if (!x_create_x_image_and_pixmap (f
, width
, height
, imagedepth
,
7742 &ximg
, &img
->pixmap
))
7744 #ifdef COLOR_TABLE_SUPPORT
7745 free_color_table ();
7747 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7748 goto imagemagick_error
;
7752 /* Oddly, the below code doesnt seem to work:*/
7753 /* switch(ximg->bitmap_unit){ */
7755 /* pixelwidth=CharPixel; */
7758 /* pixelwidth=ShortPixel; */
7761 /* pixelwidth=LongPixel; */
7765 Here im just guessing the format of the bitmap.
7766 happens to work fine for:
7769 seems about 3 times as fast as pixel pushing(not carefully measured)
7771 pixelwidth
= CharPixel
;/*??? TODO figure out*/
7772 #ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
7773 MagickExportImagePixels (image_wand
,
7778 /*&(img->pixmap));*/
7781 image_error ("You dont have MagickExportImagePixels, upgrade ImageMagick!",
7787 #ifdef COLOR_TABLE_SUPPORT
7788 /* Remember colors allocated for this image. */
7789 img
->colors
= colors_in_color_table (&img
->ncolors
);
7790 free_color_table ();
7791 #endif /* COLOR_TABLE_SUPPORT */
7795 img
->height
= height
;
7797 /* Put the image into the pixmap, then free the X image and its
7799 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7800 x_destroy_x_image (ximg
);
7803 /* Final cleanup. image_wand should be the only resource left. */
7804 DestroyMagickWand (image_wand
);
7805 /* `MagickWandTerminus' terminates the imagemagick environment. */
7806 MagickWandTerminus ();
7811 DestroyMagickWand (image_wand
);
7812 imagemagick_no_wand
:
7813 MagickWandTerminus ();
7814 /* TODO more cleanup. */
7815 image_error ("Error parsing IMAGEMAGICK image `%s'", img
->spec
, Qnil
);
7820 /* Load IMAGEMAGICK image IMG for use on frame F. Value is non-zero if
7821 successful. this function will go into the imagemagick_type structure, and
7822 the prototype thus needs to be compatible with that structure. */
7825 imagemagick_load (struct frame
*f
, struct image
*img
)
7828 Lisp_Object file_name
;
7830 /* If IMG->spec specifies a file name, create a non-file spec from it. */
7831 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
7832 if (STRINGP (file_name
))
7836 file
= x_find_image_file (file_name
);
7837 if (!STRINGP (file
))
7839 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
7842 success_p
= imagemagick_load_image (f
, img
, 0, 0, SSDATA (file
));
7844 /* Else its not a file, its a lisp object. Load the image from a
7845 lisp object rather than a file. */
7850 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7851 if (!STRINGP (data
))
7853 image_error ("Invalid image data `%s'", data
, Qnil
);
7856 success_p
= imagemagick_load_image (f
, img
, SDATA (data
),
7857 SBYTES (data
), NULL
);
7863 DEFUN ("imagemagick-types", Fimagemagick_types
, Simagemagick_types
, 0, 0, 0,
7864 doc
: /* Return a list of image types supported by ImageMagick.
7865 Each entry in this list is a symbol named after an ImageMagick format
7866 tag. See the ImageMagick manual for a list of ImageMagick formats and
7867 their descriptions (http://www.imagemagick.org/script/formats.php).
7869 Note that ImageMagick recognizes many file-types that Emacs does not
7870 recognize as images, such as C. See `imagemagick-types-inhibit'. */)
7873 Lisp_Object typelist
= Qnil
;
7876 char **imtypes
= GetMagickList ("*", &numf
, &ex
);
7878 Lisp_Object Qimagemagicktype
;
7879 for (i
= 0; i
< numf
; i
++)
7881 Qimagemagicktype
= intern (imtypes
[i
]);
7882 typelist
= Fcons (Qimagemagicktype
, typelist
);
7887 #endif /* defined (HAVE_IMAGEMAGICK) */
7891 /***********************************************************************
7893 ***********************************************************************/
7895 #if defined (HAVE_RSVG)
7897 /* Function prototypes. */
7899 static int svg_image_p (Lisp_Object object
);
7900 static int svg_load (struct frame
*f
, struct image
*img
);
7902 static int svg_load_image (struct frame
*, struct image
*,
7903 unsigned char *, ptrdiff_t);
7905 /* The symbol `svg' identifying images of this type. */
7907 static Lisp_Object Qsvg
;
7909 /* Indices of image specification fields in svg_format, below. */
7911 enum svg_keyword_index
7926 /* Vector of image_keyword structures describing the format
7927 of valid user-defined image specifications. */
7929 static const struct image_keyword svg_format
[SVG_LAST
] =
7931 {":type", IMAGE_SYMBOL_VALUE
, 1},
7932 {":data", IMAGE_STRING_VALUE
, 0},
7933 {":file", IMAGE_STRING_VALUE
, 0},
7934 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7935 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7936 {":relief", IMAGE_INTEGER_VALUE
, 0},
7937 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7938 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7939 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7940 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7943 /* Structure describing the image type `svg'. Its the same type of
7944 structure defined for all image formats, handled by emacs image
7945 functions. See struct image_type in dispextern.h. */
7947 static struct image_type svg_type
=
7949 /* An identifier showing that this is an image structure for the SVG format. */
7951 /* Handle to a function that can be used to identify a SVG file. */
7953 /* Handle to function used to load a SVG file. */
7955 /* Handle to function to free sresources for SVG. */
7957 /* An internal field to link to the next image type in a list of
7958 image types, will be filled in when registering the format. */
7963 /* Return non-zero if OBJECT is a valid SVG image specification. Do
7964 this by calling parse_image_spec and supplying the keywords that
7965 identify the SVG format. */
7968 svg_image_p (Lisp_Object object
)
7970 struct image_keyword fmt
[SVG_LAST
];
7971 memcpy (fmt
, svg_format
, sizeof fmt
);
7973 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
7976 /* Must specify either the :data or :file keyword. */
7977 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
7980 #include <librsvg/rsvg.h>
7984 /* SVG library functions. */
7985 DEF_IMGLIB_FN (RsvgHandle
*, rsvg_handle_new
);
7986 DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions
);
7987 DEF_IMGLIB_FN (gboolean
, rsvg_handle_write
);
7988 DEF_IMGLIB_FN (gboolean
, rsvg_handle_close
);
7989 DEF_IMGLIB_FN (GdkPixbuf
*, rsvg_handle_get_pixbuf
);
7991 DEF_IMGLIB_FN (int, gdk_pixbuf_get_width
);
7992 DEF_IMGLIB_FN (int, gdk_pixbuf_get_height
);
7993 DEF_IMGLIB_FN (guchar
*, gdk_pixbuf_get_pixels
);
7994 DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride
);
7995 DEF_IMGLIB_FN (GdkColorspace
, gdk_pixbuf_get_colorspace
);
7996 DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels
);
7997 DEF_IMGLIB_FN (gboolean
, gdk_pixbuf_get_has_alpha
);
7998 DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample
);
8000 DEF_IMGLIB_FN (void, g_type_init
);
8001 DEF_IMGLIB_FN (void, g_object_unref
);
8002 DEF_IMGLIB_FN (void, g_error_free
);
8004 Lisp_Object Qgdk_pixbuf
, Qglib
, Qgobject
;
8007 init_svg_functions (Lisp_Object libraries
)
8009 HMODULE library
, gdklib
, glib
, gobject
;
8011 if (!(glib
= w32_delayed_load (libraries
, Qglib
))
8012 || !(gobject
= w32_delayed_load (libraries
, Qgobject
))
8013 || !(gdklib
= w32_delayed_load (libraries
, Qgdk_pixbuf
))
8014 || !(library
= w32_delayed_load (libraries
, Qsvg
)))
8017 LOAD_IMGLIB_FN (library
, rsvg_handle_new
);
8018 LOAD_IMGLIB_FN (library
, rsvg_handle_get_dimensions
);
8019 LOAD_IMGLIB_FN (library
, rsvg_handle_write
);
8020 LOAD_IMGLIB_FN (library
, rsvg_handle_close
);
8021 LOAD_IMGLIB_FN (library
, rsvg_handle_get_pixbuf
);
8023 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_width
);
8024 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_height
);
8025 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_pixels
);
8026 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8027 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8028 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8029 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8030 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8032 LOAD_IMGLIB_FN (gobject
, g_type_init
);
8033 LOAD_IMGLIB_FN (gobject
, g_object_unref
);
8034 LOAD_IMGLIB_FN (glib
, g_error_free
);
8040 /* The following aliases for library functions allow dynamic loading
8041 to be used on some platforms. */
8042 #define fn_rsvg_handle_new rsvg_handle_new
8043 #define fn_rsvg_handle_get_dimensions rsvg_handle_get_dimensions
8044 #define fn_rsvg_handle_write rsvg_handle_write
8045 #define fn_rsvg_handle_close rsvg_handle_close
8046 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8048 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8049 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8050 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8051 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8052 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8053 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8054 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8055 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8057 #define fn_g_type_init g_type_init
8058 #define fn_g_object_unref g_object_unref
8059 #define fn_g_error_free g_error_free
8060 #endif /* !HAVE_NTGUI */
8062 /* Load SVG image IMG for use on frame F. Value is non-zero if
8063 successful. this function will go into the svg_type structure, and
8064 the prototype thus needs to be compatible with that structure. */
8067 svg_load (struct frame
*f
, struct image
*img
)
8070 Lisp_Object file_name
;
8072 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8073 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8074 if (STRINGP (file_name
))
8077 unsigned char *contents
;
8080 file
= x_find_image_file (file_name
);
8081 if (!STRINGP (file
))
8083 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8087 /* Read the entire file into memory. */
8088 contents
= slurp_file (SSDATA (file
), &size
);
8089 if (contents
== NULL
)
8091 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
8094 /* If the file was slurped into memory properly, parse it. */
8095 success_p
= svg_load_image (f
, img
, contents
, size
);
8098 /* Else its not a file, its a lisp object. Load the image from a
8099 lisp object rather than a file. */
8104 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8105 if (!STRINGP (data
))
8107 image_error ("Invalid image data `%s'", data
, Qnil
);
8110 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
));
8116 /* svg_load_image is a helper function for svg_load, which does the
8117 actual loading given contents and size, apart from frame and image
8118 structures, passed from svg_load.
8120 Uses librsvg to do most of the image processing.
8122 Returns non-zero when successful. */
8124 svg_load_image (struct frame
*f
, /* Pointer to emacs frame structure. */
8125 struct image
*img
, /* Pointer to emacs image structure. */
8126 unsigned char *contents
, /* String containing the SVG XML data to be parsed. */
8127 ptrdiff_t size
) /* Size of data in bytes. */
8129 RsvgHandle
*rsvg_handle
;
8130 RsvgDimensionData dimension_data
;
8135 const guint8
*pixels
;
8138 Lisp_Object specified_bg
;
8143 /* g_type_init is a glib function that must be called prior to using
8144 gnome type library functions. */
8146 /* Make a handle to a new rsvg object. */
8147 rsvg_handle
= fn_rsvg_handle_new ();
8149 /* Parse the contents argument and fill in the rsvg_handle. */
8150 fn_rsvg_handle_write (rsvg_handle
, contents
, size
, &err
);
8151 if (err
) goto rsvg_error
;
8153 /* The parsing is complete, rsvg_handle is ready to used, close it
8154 for further writes. */
8155 fn_rsvg_handle_close (rsvg_handle
, &err
);
8156 if (err
) goto rsvg_error
;
8158 fn_rsvg_handle_get_dimensions (rsvg_handle
, &dimension_data
);
8159 if (! check_image_size (f
, dimension_data
.width
, dimension_data
.height
))
8161 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8165 /* We can now get a valid pixel buffer from the svg file, if all
8167 pixbuf
= fn_rsvg_handle_get_pixbuf (rsvg_handle
);
8168 if (!pixbuf
) goto rsvg_error
;
8169 fn_g_object_unref (rsvg_handle
);
8171 /* Extract some meta data from the svg handle. */
8172 width
= fn_gdk_pixbuf_get_width (pixbuf
);
8173 height
= fn_gdk_pixbuf_get_height (pixbuf
);
8174 pixels
= fn_gdk_pixbuf_get_pixels (pixbuf
);
8175 rowstride
= fn_gdk_pixbuf_get_rowstride (pixbuf
);
8177 /* Validate the svg meta data. */
8178 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
8179 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf
) == 4);
8180 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf
));
8181 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
8183 /* Try to create a x pixmap to hold the svg pixmap. */
8184 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8186 fn_g_object_unref (pixbuf
);
8190 init_color_table ();
8192 /* Handle alpha channel by combining the image with a background
8194 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8195 if (!STRINGP (specified_bg
)
8196 || !x_defined_color (f
, SSDATA (specified_bg
), &background
, 0))
8199 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8200 x_query_color (f
, &background
);
8202 ns_query_color (FRAME_BACKGROUND_COLOR (f
), &background
, 1);
8206 /* SVG pixmaps specify transparency in the last byte, so right
8207 shift 8 bits to get rid of it, since emacs doesn't support
8209 background
.red
>>= 8;
8210 background
.green
>>= 8;
8211 background
.blue
>>= 8;
8213 /* This loop handles opacity values, since Emacs assumes
8214 non-transparent images. Each pixel must be "flattened" by
8215 calculating the resulting color, given the transparency of the
8216 pixel, and the image background color. */
8217 for (y
= 0; y
< height
; ++y
)
8219 for (x
= 0; x
< width
; ++x
)
8229 opacity
= *pixels
++;
8231 red
= ((red
* opacity
)
8232 + (background
.red
* ((1 << 8) - opacity
)));
8233 green
= ((green
* opacity
)
8234 + (background
.green
* ((1 << 8) - opacity
)));
8235 blue
= ((blue
* opacity
)
8236 + (background
.blue
* ((1 << 8) - opacity
)));
8238 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
8241 pixels
+= rowstride
- 4 * width
;
8244 #ifdef COLOR_TABLE_SUPPORT
8245 /* Remember colors allocated for this image. */
8246 img
->colors
= colors_in_color_table (&img
->ncolors
);
8247 free_color_table ();
8248 #endif /* COLOR_TABLE_SUPPORT */
8250 fn_g_object_unref (pixbuf
);
8253 img
->height
= height
;
8255 /* Maybe fill in the background field while we have ximg handy.
8256 Casting avoids a GCC warning. */
8257 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8259 /* Put the image into the pixmap, then free the X image and its
8261 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8262 x_destroy_x_image (ximg
);
8267 fn_g_object_unref (rsvg_handle
);
8268 /* FIXME: Use error->message so the user knows what is the actual
8269 problem with the image. */
8270 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
8271 fn_g_error_free (err
);
8275 #endif /* defined (HAVE_RSVG) */
8280 /***********************************************************************
8282 ***********************************************************************/
8284 #ifdef HAVE_X_WINDOWS
8285 #define HAVE_GHOSTSCRIPT 1
8286 #endif /* HAVE_X_WINDOWS */
8288 #ifdef HAVE_GHOSTSCRIPT
8290 static int gs_image_p (Lisp_Object object
);
8291 static int gs_load (struct frame
*f
, struct image
*img
);
8292 static void gs_clear_image (struct frame
*f
, struct image
*img
);
8294 /* Keyword symbols. */
8296 static Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8298 /* Indices of image specification fields in gs_format, below. */
8300 enum gs_keyword_index
8318 /* Vector of image_keyword structures describing the format
8319 of valid user-defined image specifications. */
8321 static const struct image_keyword gs_format
[GS_LAST
] =
8323 {":type", IMAGE_SYMBOL_VALUE
, 1},
8324 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8325 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8326 {":file", IMAGE_STRING_VALUE
, 1},
8327 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8328 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8329 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8330 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8331 {":relief", IMAGE_INTEGER_VALUE
, 0},
8332 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8333 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8334 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8335 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8338 /* Structure describing the image type `ghostscript'. */
8340 static struct image_type gs_type
=
8350 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8353 gs_clear_image (struct frame
*f
, struct image
*img
)
8355 x_clear_image (f
, img
);
8359 /* Return non-zero if OBJECT is a valid Ghostscript image
8363 gs_image_p (Lisp_Object object
)
8365 struct image_keyword fmt
[GS_LAST
];
8369 memcpy (fmt
, gs_format
, sizeof fmt
);
8371 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8374 /* Bounding box must be a list or vector containing 4 integers. */
8375 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8378 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8379 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8384 else if (VECTORP (tem
))
8386 if (ASIZE (tem
) != 4)
8388 for (i
= 0; i
< 4; ++i
)
8389 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8399 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8403 gs_load (struct frame
*f
, struct image
*img
)
8406 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8408 double in_width
, in_height
;
8409 Lisp_Object pixel_colors
= Qnil
;
8411 /* Compute pixel size of pixmap needed from the given size in the
8412 image specification. Sizes in the specification are in pt. 1 pt
8413 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8415 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8416 in_width
= INTEGERP (pt_width
) ? XFASTINT (pt_width
) / 72.0 : 0;
8417 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
8418 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8419 in_height
= INTEGERP (pt_height
) ? XFASTINT (pt_height
) / 72.0 : 0;
8420 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
8422 if (!check_image_size (f
, img
->width
, img
->height
))
8424 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8428 /* Create the pixmap. */
8429 xassert (img
->pixmap
== NO_PIXMAP
);
8431 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8433 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8434 img
->width
, img
->height
,
8435 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8440 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8444 /* Call the loader to fill the pixmap. It returns a process object
8445 if successful. We do not record_unwind_protect here because
8446 other places in redisplay like calling window scroll functions
8447 don't either. Let the Lisp loader use `unwind-protect' instead. */
8448 sprintf (buffer
, "%lu %lu",
8449 (unsigned long) FRAME_X_WINDOW (f
),
8450 (unsigned long) img
->pixmap
);
8451 window_and_pixmap_id
= build_string (buffer
);
8453 sprintf (buffer
, "%lu %lu",
8454 FRAME_FOREGROUND_PIXEL (f
),
8455 FRAME_BACKGROUND_PIXEL (f
));
8456 pixel_colors
= build_string (buffer
);
8458 XSETFRAME (frame
, f
);
8459 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8461 loader
= intern ("gs-load-image");
8463 img
->lisp_data
= call6 (loader
, frame
, img
->spec
,
8464 make_number (img
->width
),
8465 make_number (img
->height
),
8466 window_and_pixmap_id
,
8468 return PROCESSP (img
->lisp_data
);
8472 /* Kill the Ghostscript process that was started to fill PIXMAP on
8473 frame F. Called from XTread_socket when receiving an event
8474 telling Emacs that Ghostscript has finished drawing. */
8477 x_kill_gs_process (Pixmap pixmap
, struct frame
*f
)
8479 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
8483 /* Find the image containing PIXMAP. */
8484 for (i
= 0; i
< c
->used
; ++i
)
8485 if (c
->images
[i
]->pixmap
== pixmap
)
8488 /* Should someone in between have cleared the image cache, for
8489 instance, give up. */
8493 /* Kill the GS process. We should have found PIXMAP in the image
8494 cache and its image should contain a process object. */
8496 xassert (PROCESSP (img
->lisp_data
));
8497 Fkill_process (img
->lisp_data
, Qnil
);
8498 img
->lisp_data
= Qnil
;
8500 #if defined (HAVE_X_WINDOWS)
8502 /* On displays with a mutable colormap, figure out the colors
8503 allocated for the image by looking at the pixels of an XImage for
8505 class = FRAME_X_VISUAL (f
)->class;
8506 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8512 /* Try to get an XImage for img->pixmep. */
8513 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8514 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8519 /* Initialize the color table. */
8520 init_color_table ();
8522 /* For each pixel of the image, look its color up in the
8523 color table. After having done so, the color table will
8524 contain an entry for each color used by the image. */
8525 for (y
= 0; y
< img
->height
; ++y
)
8526 for (x
= 0; x
< img
->width
; ++x
)
8528 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8529 lookup_pixel_color (f
, pixel
);
8532 /* Record colors in the image. Free color table and XImage. */
8533 #ifdef COLOR_TABLE_SUPPORT
8534 img
->colors
= colors_in_color_table (&img
->ncolors
);
8535 free_color_table ();
8537 XDestroyImage (ximg
);
8539 #if 0 /* This doesn't seem to be the case. If we free the colors
8540 here, we get a BadAccess later in x_clear_image when
8541 freeing the colors. */
8542 /* We have allocated colors once, but Ghostscript has also
8543 allocated colors on behalf of us. So, to get the
8544 reference counts right, free them once. */
8546 x_free_colors (f
, img
->colors
, img
->ncolors
);
8550 image_error ("Cannot get X image of `%s'; colors will not be freed",
8555 #endif /* HAVE_X_WINDOWS */
8557 /* Now that we have the pixmap, compute mask and transform the
8558 image if requested. */
8560 postprocess_image (f
, img
);
8564 #endif /* HAVE_GHOSTSCRIPT */
8567 /***********************************************************************
8569 ***********************************************************************/
8573 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8574 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8577 return valid_image_p (spec
) ? Qt
: Qnil
;
8581 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8586 if (valid_image_p (spec
))
8587 id
= lookup_image (SELECTED_FRAME (), spec
);
8590 return make_number (id
);
8593 #endif /* GLYPH_DEBUG != 0 */
8596 /***********************************************************************
8598 ***********************************************************************/
8601 /* Image types that rely on external libraries are loaded dynamically
8602 if the library is available. */
8603 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8604 define_image_type (image_type, init_lib_fn (libraries))
8606 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8607 define_image_type (image_type, 1)
8608 #endif /* HAVE_NTGUI */
8610 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8611 doc
: /* Initialize image library implementing image type TYPE.
8612 Return non-nil if TYPE is a supported image type.
8614 Image types pbm and xbm are prebuilt; other types are loaded here.
8615 Libraries to load are specified in alist LIBRARIES (usually, the value
8616 of `dynamic-library-alist', which see). */)
8617 (Lisp_Object type
, Lisp_Object libraries
)
8620 /* Don't try to reload the library. */
8621 Lisp_Object tested
= Fassq (type
, Vlibrary_cache
);
8623 return XCDR (tested
);
8626 /* Types pbm and xbm are built-in and always available. */
8627 if (EQ (type
, Qpbm
) || EQ (type
, Qxbm
))
8630 #if defined (HAVE_XPM) || defined (HAVE_NS)
8631 if (EQ (type
, Qxpm
))
8632 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8635 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8636 if (EQ (type
, Qjpeg
))
8637 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8640 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8641 if (EQ (type
, Qtiff
))
8642 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8645 #if defined (HAVE_GIF) || defined (HAVE_NS)
8646 if (EQ (type
, Qgif
))
8647 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8650 #if defined (HAVE_PNG) || defined (HAVE_NS)
8651 if (EQ (type
, Qpng
))
8652 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8655 #if defined (HAVE_RSVG)
8656 if (EQ (type
, Qsvg
))
8657 return CHECK_LIB_AVAILABLE (&svg_type
, init_svg_functions
, libraries
);
8660 #if defined (HAVE_IMAGEMAGICK)
8661 if (EQ (type
, Qimagemagick
))
8662 return CHECK_LIB_AVAILABLE (&imagemagick_type
, init_imagemagick_functions
,
8666 #ifdef HAVE_GHOSTSCRIPT
8667 if (EQ (type
, Qpostscript
))
8668 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8671 /* If the type is not recognized, avoid testing it ever again. */
8672 CACHE_IMAGE_TYPE (type
, Qnil
);
8677 syms_of_image (void)
8679 /* Initialize this only once, since that's what we do with Vimage_types
8680 and they are supposed to be in sync. Initializing here gives correct
8681 operation on GNU/Linux of calling dump-emacs after loading some images. */
8684 /* Must be defined now becase we're going to update it below, while
8685 defining the supported image types. */
8686 DEFVAR_LISP ("image-types", Vimage_types
,
8687 doc
: /* List of potentially supported image types.
8688 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
8689 To check whether it is really supported, use `image-type-available-p'. */);
8690 Vimage_types
= Qnil
;
8692 DEFVAR_LISP ("max-image-size", Vmax_image_size
,
8693 doc
: /* Maximum size of images.
8694 Emacs will not load an image into memory if its pixel width or
8695 pixel height exceeds this limit.
8697 If the value is an integer, it directly specifies the maximum
8698 image height and width, measured in pixels. If it is a floating
8699 point number, it specifies the maximum image height and width
8700 as a ratio to the frame height and width. If the value is
8701 non-numeric, there is no explicit limit on the size of images. */);
8702 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8704 DEFSYM (Qpbm
, "pbm");
8705 ADD_IMAGE_TYPE (Qpbm
);
8707 DEFSYM (Qxbm
, "xbm");
8708 ADD_IMAGE_TYPE (Qxbm
);
8710 define_image_type (&xbm_type
, 1);
8711 define_image_type (&pbm_type
, 1);
8713 DEFSYM (Qcount
, "count");
8714 DEFSYM (Qextension_data
, "extension-data");
8715 DEFSYM (Qdelay
, "delay");
8717 DEFSYM (QCascent
, ":ascent");
8718 DEFSYM (QCmargin
, ":margin");
8719 DEFSYM (QCrelief
, ":relief");
8720 DEFSYM (QCconversion
, ":conversion");
8721 DEFSYM (QCcolor_symbols
, ":color-symbols");
8722 DEFSYM (QCheuristic_mask
, ":heuristic-mask");
8723 DEFSYM (QCindex
, ":index");
8724 DEFSYM (QCgeometry
, ":geometry");
8725 DEFSYM (QCcrop
, ":crop");
8726 DEFSYM (QCrotation
, ":rotation");
8727 DEFSYM (QCmatrix
, ":matrix");
8728 DEFSYM (QCcolor_adjustment
, ":color-adjustment");
8729 DEFSYM (QCmask
, ":mask");
8731 DEFSYM (Qlaplace
, "laplace");
8732 DEFSYM (Qemboss
, "emboss");
8733 DEFSYM (Qedge_detection
, "edge-detection");
8734 DEFSYM (Qheuristic
, "heuristic");
8736 DEFSYM (Qpostscript
, "postscript");
8737 #ifdef HAVE_GHOSTSCRIPT
8738 ADD_IMAGE_TYPE (Qpostscript
);
8739 DEFSYM (QCloader
, ":loader");
8740 DEFSYM (QCbounding_box
, ":bounding-box");
8741 DEFSYM (QCpt_width
, ":pt-width");
8742 DEFSYM (QCpt_height
, ":pt-height");
8743 #endif /* HAVE_GHOSTSCRIPT */
8746 DEFSYM (Qlibpng_version
, "libpng-version");
8747 Fset (Qlibpng_version
,
8749 make_number (PNG_LIBPNG_VER
)
8756 #if defined (HAVE_XPM) || defined (HAVE_NS)
8757 DEFSYM (Qxpm
, "xpm");
8758 ADD_IMAGE_TYPE (Qxpm
);
8761 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8762 DEFSYM (Qjpeg
, "jpeg");
8763 ADD_IMAGE_TYPE (Qjpeg
);
8766 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8767 DEFSYM (Qtiff
, "tiff");
8768 ADD_IMAGE_TYPE (Qtiff
);
8771 #if defined (HAVE_GIF) || defined (HAVE_NS)
8772 DEFSYM (Qgif
, "gif");
8773 ADD_IMAGE_TYPE (Qgif
);
8776 #if defined (HAVE_PNG) || defined (HAVE_NS)
8777 DEFSYM (Qpng
, "png");
8778 ADD_IMAGE_TYPE (Qpng
);
8781 #if defined (HAVE_IMAGEMAGICK)
8782 DEFSYM (Qimagemagick
, "imagemagick");
8783 ADD_IMAGE_TYPE (Qimagemagick
);
8786 #if defined (HAVE_RSVG)
8787 DEFSYM (Qsvg
, "svg");
8788 ADD_IMAGE_TYPE (Qsvg
);
8790 /* Other libraries used directly by svg code. */
8791 DEFSYM (Qgdk_pixbuf
, "gdk-pixbuf");
8792 DEFSYM (Qglib
, "glib");
8793 DEFSYM (Qgobject
, "gobject");
8794 #endif /* HAVE_NTGUI */
8795 #endif /* HAVE_RSVG */
8797 defsubr (&Sinit_image_library
);
8798 #ifdef HAVE_IMAGEMAGICK
8799 defsubr (&Simagemagick_types
);
8801 defsubr (&Sclear_image_cache
);
8802 defsubr (&Simage_flush
);
8803 defsubr (&Simage_size
);
8804 defsubr (&Simage_mask_p
);
8805 defsubr (&Simage_metadata
);
8809 defsubr (&Slookup_image
);
8812 DEFVAR_BOOL ("cross-disabled-images", cross_disabled_images
,
8813 doc
: /* Non-nil means always draw a cross over disabled images.
8814 Disabled images are those having a `:conversion disabled' property.
8815 A cross is always drawn on black & white displays. */);
8816 cross_disabled_images
= 0;
8818 DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path
,
8819 doc
: /* List of directories to search for window system bitmap files. */);
8820 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8822 DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay
,
8823 doc
: /* Maximum time after which images are removed from the cache.
8824 When an image has not been displayed this many seconds, Emacs
8825 automatically removes it from the image cache. If the cache contains
8826 a large number of images, the actual eviction time may be shorter.
8827 The value can also be nil, meaning the cache is never cleared.
8829 The function `clear-image-cache' disregards this variable. */);
8830 Vimage_cache_eviction_delay
= make_number (300);
8831 #ifdef HAVE_IMAGEMAGICK
8832 DEFVAR_LISP ("imagemagick-render-type", Vimagemagick_render_type
,
8833 doc
: /* Choose between ImageMagick render methods. */);