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
);
140 static Lisp_Object
Finit_image_library (Lisp_Object
, Lisp_Object
);
142 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
143 id, which is just an int that this section returns. Bitmaps are
144 reference counted so they can be shared among frames.
146 Bitmap indices are guaranteed to be > 0, so a negative number can
147 be used to indicate no bitmap.
149 If you use x_create_bitmap_from_data, then you must keep track of
150 the bitmaps yourself. That is, creating a bitmap from the same
151 data more than once will not be caught. */
155 XGetImage (Display
*display
, Pixmap pixmap
, int x
, int y
,
156 unsigned int width
, unsigned int height
,
157 unsigned long plane_mask
, int format
)
159 /* TODO: not sure what this function is supposed to do.. */
160 ns_retain_object (pixmap
);
164 /* use with imgs created by ns_image_for_XPM */
166 XGetPixel (XImagePtr ximage
, int x
, int y
)
168 return ns_get_pixel (ximage
, x
, y
);
171 /* use with imgs created by ns_image_for_XPM; alpha set to 1;
172 pixel is assumed to be in form RGB */
174 XPutPixel (XImagePtr ximage
, int x
, int y
, unsigned long pixel
)
176 ns_put_pixel (ximage
, x
, y
, pixel
);
181 /* Functions to access the contents of a bitmap, given an id. */
184 x_bitmap_height (FRAME_PTR f
, ptrdiff_t id
)
186 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
190 x_bitmap_width (FRAME_PTR f
, ptrdiff_t id
)
192 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
195 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
197 x_bitmap_pixmap (FRAME_PTR f
, ptrdiff_t id
)
199 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
203 #ifdef HAVE_X_WINDOWS
205 x_bitmap_mask (FRAME_PTR f
, ptrdiff_t id
)
207 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
211 /* Allocate a new bitmap record. Returns index of new record. */
214 x_allocate_bitmap_record (FRAME_PTR f
)
216 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
219 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
220 return ++dpyinfo
->bitmaps_last
;
222 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
223 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
227 xpalloc (dpyinfo
->bitmaps
, &dpyinfo
->bitmaps_size
,
228 10, -1, sizeof *dpyinfo
->bitmaps
);
229 return ++dpyinfo
->bitmaps_last
;
232 /* Add one reference to the reference count of the bitmap with id ID. */
235 x_reference_bitmap (FRAME_PTR f
, ptrdiff_t id
)
237 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
240 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
243 x_create_bitmap_from_data (struct frame
*f
, char *bits
, unsigned int width
, unsigned int height
)
245 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
248 #ifdef HAVE_X_WINDOWS
250 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
251 bits
, width
, height
);
254 #endif /* HAVE_X_WINDOWS */
258 bitmap
= CreateBitmap (width
, height
,
259 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
260 FRAME_X_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
264 #endif /* HAVE_NTGUI */
267 void *bitmap
= ns_image_from_XBM (bits
, width
, height
);
272 id
= x_allocate_bitmap_record (f
);
275 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
276 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
279 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
280 dpyinfo
->bitmaps
[id
- 1].height
= height
;
281 dpyinfo
->bitmaps
[id
- 1].width
= width
;
282 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
284 #ifdef HAVE_X_WINDOWS
285 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
286 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
287 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
288 #endif /* HAVE_X_WINDOWS */
291 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
292 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
293 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
294 #endif /* HAVE_NTGUI */
299 /* Create bitmap from file FILE for frame F. */
302 x_create_bitmap_from_file (struct frame
*f
, Lisp_Object file
)
304 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
307 return -1; /* W32_TODO : bitmap support */
308 #endif /* HAVE_NTGUI */
312 void *bitmap
= ns_image_from_file (file
);
318 id
= x_allocate_bitmap_record (f
);
319 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
320 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
321 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
322 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
323 dpyinfo
->bitmaps
[id
- 1].height
= ns_image_width (bitmap
);
324 dpyinfo
->bitmaps
[id
- 1].width
= ns_image_height (bitmap
);
325 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
329 #ifdef HAVE_X_WINDOWS
330 unsigned int width
, height
;
332 int xhot
, yhot
, result
;
338 /* Look for an existing bitmap with the same name. */
339 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
341 if (dpyinfo
->bitmaps
[id
].refcount
342 && dpyinfo
->bitmaps
[id
].file
343 && !strcmp (dpyinfo
->bitmaps
[id
].file
, SSDATA (file
)))
345 ++dpyinfo
->bitmaps
[id
].refcount
;
350 /* Search bitmap-file-path for the file, if appropriate. */
351 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
356 filename
= SSDATA (found
);
358 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
359 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
360 if (result
!= BitmapSuccess
)
363 id
= x_allocate_bitmap_record (f
);
364 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
365 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
366 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
367 dpyinfo
->bitmaps
[id
- 1].file
= (char *) xmalloc (SBYTES (file
) + 1);
368 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
369 dpyinfo
->bitmaps
[id
- 1].height
= height
;
370 dpyinfo
->bitmaps
[id
- 1].width
= width
;
371 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SSDATA (file
));
374 #endif /* HAVE_X_WINDOWS */
380 free_bitmap_record (Display_Info
*dpyinfo
, Bitmap_Record
*bm
)
382 #ifdef HAVE_X_WINDOWS
383 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
385 XFreePixmap (dpyinfo
->display
, bm
->mask
);
386 #endif /* HAVE_X_WINDOWS */
389 DeleteObject (bm
->pixmap
);
390 #endif /* HAVE_NTGUI */
393 ns_release_object (bm
->img
);
403 /* Remove reference to bitmap with id number ID. */
406 x_destroy_bitmap (FRAME_PTR f
, ptrdiff_t id
)
408 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
412 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
414 if (--bm
->refcount
== 0)
417 free_bitmap_record (dpyinfo
, bm
);
423 /* Free all the bitmaps for the display specified by DPYINFO. */
426 x_destroy_all_bitmaps (Display_Info
*dpyinfo
)
429 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
431 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
432 if (bm
->refcount
> 0)
433 free_bitmap_record (dpyinfo
, bm
);
435 dpyinfo
->bitmaps_last
= 0;
439 #ifdef HAVE_X_WINDOWS
441 /* Useful functions defined in the section
442 `Image type independent image structures' below. */
444 static unsigned long four_corners_best (XImagePtr ximg
,
447 unsigned long height
);
449 static int x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
,
450 int depth
, XImagePtr
*ximg
,
453 static void x_destroy_x_image (XImagePtr ximg
);
456 /* Create a mask of a bitmap. Note is this not a perfect mask.
457 It's nicer with some borders in this context */
460 x_create_bitmap_mask (struct frame
*f
, ptrdiff_t id
)
463 XImagePtr ximg
, mask_img
;
464 unsigned long width
, height
;
467 unsigned long x
, y
, xp
, xm
, yp
, ym
;
470 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
475 pixmap
= x_bitmap_pixmap (f
, id
);
476 width
= x_bitmap_width (f
, id
);
477 height
= x_bitmap_height (f
, id
);
480 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
489 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
494 XDestroyImage (ximg
);
498 bg
= four_corners_best (ximg
, NULL
, width
, height
);
500 for (y
= 0; y
< ximg
->height
; ++y
)
502 for (x
= 0; x
< ximg
->width
; ++x
)
504 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
505 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
506 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
507 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
508 if (XGetPixel (ximg
, x
, y
) == bg
509 && XGetPixel (ximg
, x
, yp
) == bg
510 && XGetPixel (ximg
, x
, ym
) == bg
511 && XGetPixel (ximg
, xp
, y
) == bg
512 && XGetPixel (ximg
, xp
, yp
) == bg
513 && XGetPixel (ximg
, xp
, ym
) == bg
514 && XGetPixel (ximg
, xm
, y
) == bg
515 && XGetPixel (ximg
, xm
, yp
) == bg
516 && XGetPixel (ximg
, xm
, ym
) == bg
)
517 XPutPixel (mask_img
, x
, y
, 0);
519 XPutPixel (mask_img
, x
, y
, 1);
523 xassert (interrupt_input_blocked
);
524 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
525 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
527 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
529 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
530 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
532 XDestroyImage (ximg
);
533 x_destroy_x_image (mask_img
);
538 #endif /* HAVE_X_WINDOWS */
541 /***********************************************************************
543 ***********************************************************************/
545 /* List of supported image types. Use define_image_type to add new
546 types. Use lookup_image_type to find a type for a given symbol. */
548 static struct image_type
*image_types
;
550 /* The symbol `xbm' which is used as the type symbol for XBM images. */
552 static Lisp_Object Qxbm
;
556 Lisp_Object QCascent
, QCmargin
, QCrelief
;
557 Lisp_Object QCconversion
;
558 static Lisp_Object QCheuristic_mask
;
559 static Lisp_Object QCcolor_symbols
;
560 static Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
, QCgeometry
;
561 static Lisp_Object QCcrop
, QCrotation
;
565 static Lisp_Object Qcount
, Qextension_data
, Qdelay
;
566 static Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
568 /* Function prototypes. */
570 static Lisp_Object
define_image_type (struct image_type
*type
, int loaded
);
571 static struct image_type
*lookup_image_type (Lisp_Object symbol
);
572 static void image_error (const char *format
, Lisp_Object
, Lisp_Object
);
573 static void x_laplace (struct frame
*, struct image
*);
574 static void x_emboss (struct frame
*, struct image
*);
575 static int x_build_heuristic_mask (struct frame
*, struct image
*,
578 #define CACHE_IMAGE_TYPE(type, status) \
579 do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
581 #define CACHE_IMAGE_TYPE(type, status)
584 #define ADD_IMAGE_TYPE(type) \
585 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
587 /* Define a new image type from TYPE. This adds a copy of TYPE to
588 image_types and caches the loading status of TYPE. */
591 define_image_type (struct image_type
*type
, int loaded
)
599 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
600 The initialized data segment is read-only. */
601 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
602 memcpy (p
, type
, sizeof *p
);
603 p
->next
= image_types
;
608 CACHE_IMAGE_TYPE (*type
->type
, success
);
613 /* Look up image type SYMBOL, and return a pointer to its image_type
614 structure. Value is null if SYMBOL is not a known image type. */
616 static inline struct image_type
*
617 lookup_image_type (Lisp_Object symbol
)
619 struct image_type
*type
;
621 /* We must initialize the image-type if it hasn't been already. */
622 if (NILP (Finit_image_library (symbol
, Vdynamic_library_alist
)))
623 return 0; /* unimplemented */
625 for (type
= image_types
; type
; type
= type
->next
)
626 if (EQ (symbol
, *type
->type
))
633 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
634 valid image specification is a list whose car is the symbol
635 `image', and whose rest is a property list. The property list must
636 contain a value for key `:type'. That value must be the name of a
637 supported image type. The rest of the property list depends on the
641 valid_image_p (Lisp_Object object
)
649 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
650 if (EQ (XCAR (tem
), QCtype
))
653 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
655 struct image_type
*type
;
656 type
= lookup_image_type (XCAR (tem
));
658 valid_p
= type
->valid_p (object
);
669 /* Log error message with format string FORMAT and argument ARG.
670 Signaling an error, e.g. when an image cannot be loaded, is not a
671 good idea because this would interrupt redisplay, and the error
672 message display would lead to another redisplay. This function
673 therefore simply displays a message. */
676 image_error (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
678 add_to_log (format
, arg1
, arg2
);
683 /***********************************************************************
685 ***********************************************************************/
687 enum image_value_type
689 IMAGE_DONT_CHECK_VALUE_TYPE
,
691 IMAGE_STRING_OR_NIL_VALUE
,
693 IMAGE_POSITIVE_INTEGER_VALUE
,
694 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
695 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
698 IMAGE_FUNCTION_VALUE
,
703 /* Structure used when parsing image specifications. */
707 /* Name of keyword. */
710 /* The type of value allowed. */
711 enum image_value_type type
;
713 /* Non-zero means key must be present. */
716 /* Used to recognize duplicate keywords in a property list. */
719 /* The value that was found. */
724 static int parse_image_spec (Lisp_Object
, struct image_keyword
*,
726 static Lisp_Object
image_spec_value (Lisp_Object
, Lisp_Object
, int *);
729 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
730 has the format (image KEYWORD VALUE ...). One of the keyword/
731 value pairs must be `:type TYPE'. KEYWORDS is a vector of
732 image_keywords structures of size NKEYWORDS describing other
733 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
736 parse_image_spec (Lisp_Object spec
, struct image_keyword
*keywords
,
737 int nkeywords
, Lisp_Object type
)
746 while (CONSP (plist
))
748 Lisp_Object key
, value
;
750 /* First element of a pair must be a symbol. */
752 plist
= XCDR (plist
);
756 /* There must follow a value. */
759 value
= XCAR (plist
);
760 plist
= XCDR (plist
);
762 /* Find key in KEYWORDS. Error if not found. */
763 for (i
= 0; i
< nkeywords
; ++i
)
764 if (strcmp (keywords
[i
].name
, SSDATA (SYMBOL_NAME (key
))) == 0)
770 /* Record that we recognized the keyword. If a keywords
771 was found more than once, it's an error. */
772 keywords
[i
].value
= value
;
775 if (keywords
[i
].count
> 1)
778 /* Check type of value against allowed type. */
779 switch (keywords
[i
].type
)
781 case IMAGE_STRING_VALUE
:
782 if (!STRINGP (value
))
786 case IMAGE_STRING_OR_NIL_VALUE
:
787 if (!STRINGP (value
) && !NILP (value
))
791 case IMAGE_SYMBOL_VALUE
:
792 if (!SYMBOLP (value
))
796 case IMAGE_POSITIVE_INTEGER_VALUE
:
797 if (! RANGED_INTEGERP (1, value
, INT_MAX
))
801 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
802 if (RANGED_INTEGERP (1, value
, INT_MAX
))
805 && RANGED_INTEGERP (1, XCAR (value
), INT_MAX
)
806 && RANGED_INTEGERP (1, XCDR (value
), INT_MAX
))
810 case IMAGE_ASCENT_VALUE
:
811 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
813 else if (RANGED_INTEGERP (0, value
, 100))
817 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
818 /* Unlike the other integer-related cases, this one does not
819 verify that VALUE fits in 'int'. This is because callers
821 if (!INTEGERP (value
) || XINT (value
) < 0)
825 case IMAGE_DONT_CHECK_VALUE_TYPE
:
828 case IMAGE_FUNCTION_VALUE
:
829 value
= indirect_function (value
);
830 if (!NILP (Ffunctionp (value
)))
834 case IMAGE_NUMBER_VALUE
:
835 if (!INTEGERP (value
) && !FLOATP (value
))
839 case IMAGE_INTEGER_VALUE
:
840 if (! TYPE_RANGED_INTEGERP (int, value
))
844 case IMAGE_BOOL_VALUE
:
845 if (!NILP (value
) && !EQ (value
, Qt
))
854 if (EQ (key
, QCtype
) && !EQ (type
, value
))
858 /* Check that all mandatory fields are present. */
859 for (i
= 0; i
< nkeywords
; ++i
)
860 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
867 /* Return the value of KEY in image specification SPEC. Value is nil
868 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
869 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
872 image_spec_value (Lisp_Object spec
, Lisp_Object key
, int *found
)
876 xassert (valid_image_p (spec
));
878 for (tail
= XCDR (spec
);
879 CONSP (tail
) && CONSP (XCDR (tail
));
880 tail
= XCDR (XCDR (tail
)))
882 if (EQ (XCAR (tail
), key
))
886 return XCAR (XCDR (tail
));
896 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
897 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
898 PIXELS non-nil means return the size in pixels, otherwise return the
899 size in canonical character units.
900 FRAME is the frame on which the image will be displayed. FRAME nil
901 or omitted means use the selected frame. */)
902 (Lisp_Object spec
, Lisp_Object pixels
, Lisp_Object frame
)
907 if (valid_image_p (spec
))
909 struct frame
*f
= check_x_frame (frame
);
910 ptrdiff_t id
= lookup_image (f
, spec
);
911 struct image
*img
= IMAGE_FROM_ID (f
, id
);
912 int width
= img
->width
+ 2 * img
->hmargin
;
913 int height
= img
->height
+ 2 * img
->vmargin
;
916 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
917 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
919 size
= Fcons (make_number (width
), make_number (height
));
922 error ("Invalid image specification");
928 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
929 doc
: /* Return t if image SPEC has a mask bitmap.
930 FRAME is the frame on which the image will be displayed. FRAME nil
931 or omitted means use the selected frame. */)
932 (Lisp_Object spec
, Lisp_Object frame
)
937 if (valid_image_p (spec
))
939 struct frame
*f
= check_x_frame (frame
);
940 ptrdiff_t id
= lookup_image (f
, spec
);
941 struct image
*img
= IMAGE_FROM_ID (f
, id
);
946 error ("Invalid image specification");
951 DEFUN ("image-metadata", Fimage_metadata
, Simage_metadata
, 1, 2, 0,
952 doc
: /* Return metadata for image SPEC.
953 FRAME is the frame on which the image will be displayed. FRAME nil
954 or omitted means use the selected frame. */)
955 (Lisp_Object spec
, Lisp_Object frame
)
960 if (valid_image_p (spec
))
962 struct frame
*f
= check_x_frame (frame
);
963 ptrdiff_t id
= lookup_image (f
, spec
);
964 struct image
*img
= IMAGE_FROM_ID (f
, id
);
965 ext
= img
->lisp_data
;
972 /***********************************************************************
973 Image type independent image structures
974 ***********************************************************************/
976 static void free_image (struct frame
*f
, struct image
*img
);
978 #define MAX_IMAGE_SIZE 6.0
979 /* Allocate and return a new image structure for image specification
980 SPEC. SPEC has a hash value of HASH. */
982 static struct image
*
983 make_image (Lisp_Object spec
, EMACS_UINT hash
)
985 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
986 Lisp_Object file
= image_spec_value (spec
, QCfile
, NULL
);
988 xassert (valid_image_p (spec
));
989 memset (img
, 0, sizeof *img
);
990 img
->dependencies
= NILP (file
) ? Qnil
: list1 (file
);
991 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
992 xassert (img
->type
!= NULL
);
994 img
->lisp_data
= Qnil
;
995 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
997 img
->corners
[BOT_CORNER
] = -1; /* Full image */
1002 /* Free image IMG which was used on frame F, including its resources. */
1005 free_image (struct frame
*f
, struct image
*img
)
1009 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1011 /* Remove IMG from the hash table of its cache. */
1013 img
->prev
->next
= img
->next
;
1015 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
1018 img
->next
->prev
= img
->prev
;
1020 c
->images
[img
->id
] = NULL
;
1022 /* Free resources, then free IMG. */
1023 img
->type
->free (f
, img
);
1028 /* Return 1 if the given widths and heights are valid for display;
1029 otherwise, return 0. */
1032 check_image_size (struct frame
*f
, int width
, int height
)
1036 if (width
<= 0 || height
<= 0)
1039 if (INTEGERP (Vmax_image_size
))
1040 return (width
<= XINT (Vmax_image_size
)
1041 && height
<= XINT (Vmax_image_size
));
1042 else if (FLOATP (Vmax_image_size
))
1046 w
= FRAME_PIXEL_WIDTH (f
);
1047 h
= FRAME_PIXEL_HEIGHT (f
);
1050 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1051 return (width
<= XFLOAT_DATA (Vmax_image_size
) * w
1052 && height
<= XFLOAT_DATA (Vmax_image_size
) * h
);
1058 /* Prepare image IMG for display on frame F. Must be called before
1059 drawing an image. */
1062 prepare_image_for_display (struct frame
*f
, struct image
*img
)
1066 /* We're about to display IMG, so set its timestamp to `now'. */
1068 img
->timestamp
= EMACS_SECS (t
);
1070 /* If IMG doesn't have a pixmap yet, load it now, using the image
1071 type dependent loader function. */
1072 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1073 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1078 /* Value is the number of pixels for the ascent of image IMG when
1079 drawn in face FACE. */
1082 image_ascent (struct image
*img
, struct face
*face
, struct glyph_slice
*slice
)
1087 if (slice
->height
== img
->height
)
1088 height
= img
->height
+ img
->vmargin
;
1089 else if (slice
->y
== 0)
1090 height
= slice
->height
+ img
->vmargin
;
1092 height
= slice
->height
;
1094 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1099 /* W32 specific version. Why?. ++kfs */
1100 ascent
= height
/ 2 - (FONT_DESCENT (face
->font
)
1101 - FONT_BASE (face
->font
)) / 2;
1103 /* This expression is arranged so that if the image can't be
1104 exactly centered, it will be moved slightly up. This is
1105 because a typical font is `top-heavy' (due to the presence
1106 uppercase letters), so the image placement should err towards
1107 being top-heavy too. It also just generally looks better. */
1108 ascent
= (height
+ FONT_BASE(face
->font
)
1109 - FONT_DESCENT(face
->font
) + 1) / 2;
1110 #endif /* HAVE_NTGUI */
1113 ascent
= height
/ 2;
1116 ascent
= height
* (img
->ascent
/ 100.0);
1122 /* Image background colors. */
1124 /* Find the "best" corner color of a bitmap.
1125 On W32, XIMG is assumed to a device context with the bitmap selected. */
1127 static RGB_PIXEL_COLOR
1128 four_corners_best (XImagePtr_or_DC ximg
, int *corners
,
1129 unsigned long width
, unsigned long height
)
1131 RGB_PIXEL_COLOR corner_pixels
[4], best
IF_LINT (= 0);
1134 if (corners
&& corners
[BOT_CORNER
] >= 0)
1136 /* Get the colors at the corner_pixels of ximg. */
1137 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1138 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1139 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1140 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1144 /* Get the colors at the corner_pixels of ximg. */
1145 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1146 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1147 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1148 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1150 /* Choose the most frequently found color as background. */
1151 for (i
= best_count
= 0; i
< 4; ++i
)
1155 for (j
= n
= 0; j
< 4; ++j
)
1156 if (corner_pixels
[i
] == corner_pixels
[j
])
1160 best
= corner_pixels
[i
], best_count
= n
;
1166 /* Portability macros */
1170 #define Destroy_Image(img_dc, prev) \
1171 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1173 #define Free_Pixmap(display, pixmap) \
1174 DeleteObject (pixmap)
1176 #elif defined (HAVE_NS)
1178 #define Destroy_Image(ximg, dummy) \
1179 ns_release_object (ximg)
1181 #define Free_Pixmap(display, pixmap) \
1182 ns_release_object (pixmap)
1186 #define Destroy_Image(ximg, dummy) \
1187 XDestroyImage (ximg)
1189 #define Free_Pixmap(display, pixmap) \
1190 XFreePixmap (display, pixmap)
1192 #endif /* !HAVE_NTGUI && !HAVE_NS */
1195 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1196 it is guessed heuristically. If non-zero, XIMG is an existing
1197 XImage object (or device context with the image selected on W32) to
1198 use for the heuristic. */
1201 image_background (struct image
*img
, struct frame
*f
, XImagePtr_or_DC ximg
)
1203 if (! img
->background_valid
)
1204 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1206 int free_ximg
= !ximg
;
1209 #endif /* HAVE_NTGUI */
1214 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
1215 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1217 HDC frame_dc
= get_frame_dc (f
);
1218 ximg
= CreateCompatibleDC (frame_dc
);
1219 release_frame_dc (f
, frame_dc
);
1220 prev
= SelectObject (ximg
, img
->pixmap
);
1221 #endif /* !HAVE_NTGUI */
1224 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1227 Destroy_Image (ximg
, prev
);
1229 img
->background_valid
= 1;
1232 return img
->background
;
1235 /* Return the `background_transparent' field of IMG. If IMG doesn't
1236 have one yet, it is guessed heuristically. If non-zero, MASK is an
1237 existing XImage object to use for the heuristic. */
1240 image_background_transparent (struct image
*img
, struct frame
*f
, XImagePtr_or_DC mask
)
1242 if (! img
->background_transparent_valid
)
1243 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1247 int free_mask
= !mask
;
1250 #endif /* HAVE_NTGUI */
1255 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
1256 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
1258 HDC frame_dc
= get_frame_dc (f
);
1259 mask
= CreateCompatibleDC (frame_dc
);
1260 release_frame_dc (f
, frame_dc
);
1261 prev
= SelectObject (mask
, img
->mask
);
1262 #endif /* HAVE_NTGUI */
1265 img
->background_transparent
1266 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1269 Destroy_Image (mask
, prev
);
1272 img
->background_transparent
= 0;
1274 img
->background_transparent_valid
= 1;
1277 return img
->background_transparent
;
1281 /***********************************************************************
1282 Helper functions for X image types
1283 ***********************************************************************/
1285 static void x_clear_image_1 (struct frame
*, struct image
*, int,
1287 static void x_clear_image (struct frame
*f
, struct image
*img
);
1288 static unsigned long x_alloc_image_color (struct frame
*f
,
1290 Lisp_Object color_name
,
1291 unsigned long dflt
);
1294 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1295 free the pixmap if any. MASK_P non-zero means clear the mask
1296 pixmap if any. COLORS_P non-zero means free colors allocated for
1297 the image, if any. */
1300 x_clear_image_1 (struct frame
*f
, struct image
*img
, int pixmap_p
, int mask_p
,
1303 if (pixmap_p
&& img
->pixmap
)
1305 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1306 img
->pixmap
= NO_PIXMAP
;
1307 /* NOTE (HAVE_NS): background color is NOT an indexed color! */
1308 img
->background_valid
= 0;
1311 if (mask_p
&& img
->mask
)
1313 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1314 img
->mask
= NO_PIXMAP
;
1315 img
->background_transparent_valid
= 0;
1318 if (colors_p
&& img
->ncolors
)
1320 /* W32_TODO: color table support. */
1321 #ifdef HAVE_X_WINDOWS
1322 x_free_colors (f
, img
->colors
, img
->ncolors
);
1323 #endif /* HAVE_X_WINDOWS */
1324 xfree (img
->colors
);
1331 /* Free X resources of image IMG which is used on frame F. */
1334 x_clear_image (struct frame
*f
, struct image
*img
)
1337 x_clear_image_1 (f
, img
, 1, 1, 1);
1342 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1343 cannot be allocated, use DFLT. Add a newly allocated color to
1344 IMG->colors, so that it can be freed again. Value is the pixel
1347 static unsigned long
1348 x_alloc_image_color (struct frame
*f
, struct image
*img
, Lisp_Object color_name
,
1352 unsigned long result
;
1354 xassert (STRINGP (color_name
));
1356 if (x_defined_color (f
, SSDATA (color_name
), &color
, 1)
1357 && img
->ncolors
< min (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *img
->colors
,
1360 /* This isn't called frequently so we get away with simply
1361 reallocating the color vector to the needed size, here. */
1362 ptrdiff_t ncolors
= img
->ncolors
+ 1;
1364 (unsigned long *) xrealloc (img
->colors
,
1365 ncolors
* sizeof *img
->colors
);
1366 img
->colors
[ncolors
- 1] = color
.pixel
;
1367 img
->ncolors
= ncolors
;
1368 result
= color
.pixel
;
1378 /***********************************************************************
1380 ***********************************************************************/
1382 static void cache_image (struct frame
*f
, struct image
*img
);
1383 static void postprocess_image (struct frame
*, struct image
*);
1385 /* Return a new, initialized image cache that is allocated from the
1386 heap. Call free_image_cache to free an image cache. */
1388 struct image_cache
*
1389 make_image_cache (void)
1391 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
1394 memset (c
, 0, sizeof *c
);
1396 c
->images
= (struct image
**) xmalloc (size
* sizeof *c
->images
);
1398 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
1399 c
->buckets
= (struct image
**) xmalloc (size
);
1400 memset (c
->buckets
, 0, size
);
1405 /* Find an image matching SPEC in the cache, and return it. If no
1406 image is found, return NULL. */
1407 static struct image
*
1408 search_image_cache (struct frame
*f
, Lisp_Object spec
, EMACS_UINT hash
)
1411 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1412 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1414 if (!c
) return NULL
;
1416 /* If the image spec does not specify a background color, the cached
1417 image must have the same background color as the current frame.
1418 The foreground color must also match, for the sake of monochrome
1421 In fact, we could ignore the foreground color matching condition
1422 for color images, or if the image spec specifies :foreground;
1423 similarly we could ignore the background color matching condition
1424 for formats that don't use transparency (such as jpeg), or if the
1425 image spec specifies :background. However, the extra memory
1426 usage is probably negligible in practice, so we don't bother. */
1428 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1429 if (img
->hash
== hash
1430 && !NILP (Fequal (img
->spec
, spec
))
1431 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1432 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1438 /* Search frame F for an image with spec SPEC, and free it. */
1441 uncache_image (struct frame
*f
, Lisp_Object spec
)
1443 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1446 free_image (f
, img
);
1447 /* As display glyphs may still be referring to the image ID, we
1448 must garbage the frame (Bug#6426). */
1449 SET_FRAME_GARBAGED (f
);
1454 /* Free image cache of frame F. Be aware that X frames share images
1458 free_image_cache (struct frame
*f
)
1460 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1465 /* Cache should not be referenced by any frame when freed. */
1466 xassert (c
->refcount
== 0);
1468 for (i
= 0; i
< c
->used
; ++i
)
1469 free_image (f
, c
->images
[i
]);
1473 FRAME_IMAGE_CACHE (f
) = NULL
;
1478 /* Clear image cache of frame F. FILTER=t means free all images.
1479 FILTER=nil means clear only images that haven't been
1480 displayed for some time.
1481 Else, only free the images which have FILTER in their `dependencies'.
1482 Should be called from time to time to reduce the number of loaded images.
1483 If image-cache-eviction-delay is non-nil, this frees images in the cache
1484 which weren't displayed for at least that many seconds. */
1487 clear_image_cache (struct frame
*f
, Lisp_Object filter
)
1489 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1493 ptrdiff_t i
, nfreed
= 0;
1495 /* Block input so that we won't be interrupted by a SIGIO
1496 while being in an inconsistent state. */
1501 /* Filter image cache. */
1502 for (i
= 0; i
< c
->used
; ++i
)
1504 struct image
*img
= c
->images
[i
];
1505 if (img
&& (EQ (Qt
, filter
)
1506 || !NILP (Fmember (filter
, img
->dependencies
))))
1508 free_image (f
, img
);
1513 else if (INTEGERP (Vimage_cache_eviction_delay
))
1515 /* Free cache based on timestamp. */
1518 ptrdiff_t nimages
= 0;
1520 for (i
= 0; i
< c
->used
; ++i
)
1524 /* If the number of cached images has grown unusually large,
1525 decrease the cache eviction delay (Bug#6230). */
1526 delay
= XINT (Vimage_cache_eviction_delay
);
1528 delay
= 1600 * delay
/ nimages
/ nimages
;
1529 delay
= max (delay
, 1);
1532 old
= EMACS_SECS (t
) - delay
;
1534 for (i
= 0; i
< c
->used
; ++i
)
1536 struct image
*img
= c
->images
[i
];
1537 if (img
&& img
->timestamp
< old
)
1539 free_image (f
, img
);
1545 /* We may be clearing the image cache because, for example,
1546 Emacs was iconified for a longer period of time. In that
1547 case, current matrices may still contain references to
1548 images freed above. So, clear these matrices. */
1551 Lisp_Object tail
, frame
;
1553 FOR_EACH_FRAME (tail
, frame
)
1555 struct frame
*fr
= XFRAME (frame
);
1556 if (FRAME_IMAGE_CACHE (fr
) == c
)
1557 clear_current_matrices (fr
);
1560 ++windows_or_buffers_changed
;
1568 clear_image_caches (Lisp_Object filter
)
1570 /* FIXME: We want to do
1571 * struct terminal *t;
1572 * for (t = terminal_list; t; t = t->next_terminal)
1573 * clear_image_cache (t, filter); */
1574 Lisp_Object tail
, frame
;
1575 FOR_EACH_FRAME (tail
, frame
)
1576 if (FRAME_WINDOW_P (XFRAME (frame
)))
1577 clear_image_cache (XFRAME (frame
), filter
);
1580 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1582 doc
: /* Clear the image cache.
1583 FILTER nil or a frame means clear all images in the selected frame.
1584 FILTER t means clear the image caches of all frames.
1585 Anything else, means only clear those images which refer to FILTER,
1586 which is then usually a filename. */)
1587 (Lisp_Object filter
)
1589 if (!(EQ (filter
, Qnil
) || FRAMEP (filter
)))
1590 clear_image_caches (filter
);
1592 clear_image_cache (check_x_frame (filter
), Qt
);
1598 DEFUN ("image-flush", Fimage_flush
, Simage_flush
,
1600 doc
: /* Fush the image with specification SPEC on frame FRAME.
1601 This removes the image from the Emacs image cache. If SPEC specifies
1602 an image file, the next redisplay of this image will read from the
1603 current contents of that file.
1605 FRAME nil or omitted means use the selected frame.
1606 FRAME t means refresh the image on all frames. */)
1607 (Lisp_Object spec
, Lisp_Object frame
)
1609 if (!valid_image_p (spec
))
1610 error ("Invalid image specification");
1615 FOR_EACH_FRAME (tail
, frame
)
1617 struct frame
*f
= XFRAME (frame
);
1618 if (FRAME_WINDOW_P (f
))
1619 uncache_image (f
, spec
);
1623 uncache_image (check_x_frame (frame
), spec
);
1629 /* Compute masks and transform image IMG on frame F, as specified
1630 by the image's specification, */
1633 postprocess_image (struct frame
*f
, struct image
*img
)
1635 /* Manipulation of the image's mask. */
1638 Lisp_Object conversion
, spec
;
1643 /* `:heuristic-mask t'
1645 means build a mask heuristically.
1646 `:heuristic-mask (R G B)'
1647 `:mask (heuristic (R G B))'
1648 means build a mask from color (R G B) in the
1651 means remove a mask, if any. */
1653 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1655 x_build_heuristic_mask (f
, img
, mask
);
1660 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1662 if (EQ (mask
, Qheuristic
))
1663 x_build_heuristic_mask (f
, img
, Qt
);
1664 else if (CONSP (mask
)
1665 && EQ (XCAR (mask
), Qheuristic
))
1667 if (CONSP (XCDR (mask
)))
1668 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1670 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1672 else if (NILP (mask
) && found_p
&& img
->mask
)
1674 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1675 img
->mask
= NO_PIXMAP
;
1680 /* Should we apply an image transformation algorithm? */
1681 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1682 if (EQ (conversion
, Qdisabled
))
1683 x_disable_image (f
, img
);
1684 else if (EQ (conversion
, Qlaplace
))
1686 else if (EQ (conversion
, Qemboss
))
1688 else if (CONSP (conversion
)
1689 && EQ (XCAR (conversion
), Qedge_detection
))
1692 tem
= XCDR (conversion
);
1694 x_edge_detection (f
, img
,
1695 Fplist_get (tem
, QCmatrix
),
1696 Fplist_get (tem
, QCcolor_adjustment
));
1702 /* Return the id of image with Lisp specification SPEC on frame F.
1703 SPEC must be a valid Lisp image specification (see valid_image_p). */
1706 lookup_image (struct frame
*f
, Lisp_Object spec
)
1712 /* F must be a window-system frame, and SPEC must be a valid image
1714 xassert (FRAME_WINDOW_P (f
));
1715 xassert (valid_image_p (spec
));
1717 /* Look up SPEC in the hash table of the image cache. */
1718 hash
= sxhash (spec
, 0);
1719 img
= search_image_cache (f
, spec
, hash
);
1720 if (img
&& img
->load_failed_p
)
1722 free_image (f
, img
);
1726 /* If not found, create a new image and cache it. */
1730 img
= make_image (spec
, hash
);
1731 cache_image (f
, img
);
1732 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
1733 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1734 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1736 /* If we can't load the image, and we don't have a width and
1737 height, use some arbitrary width and height so that we can
1738 draw a rectangle for it. */
1739 if (img
->load_failed_p
)
1743 value
= image_spec_value (spec
, QCwidth
, NULL
);
1744 img
->width
= (INTEGERP (value
)
1745 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1746 value
= image_spec_value (spec
, QCheight
, NULL
);
1747 img
->height
= (INTEGERP (value
)
1748 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1752 /* Handle image type independent image attributes
1753 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1754 `:background COLOR'. */
1755 Lisp_Object ascent
, margin
, relief
, bg
;
1757 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1758 if (INTEGERP (ascent
))
1759 img
->ascent
= XFASTINT (ascent
);
1760 else if (EQ (ascent
, Qcenter
))
1761 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1763 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1764 if (INTEGERP (margin
))
1765 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1766 else if (CONSP (margin
))
1768 img
->hmargin
= XFASTINT (XCAR (margin
));
1769 img
->vmargin
= XFASTINT (XCDR (margin
));
1772 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1773 if (INTEGERP (relief
))
1775 img
->relief
= XINT (relief
);
1776 img
->hmargin
+= eabs (img
->relief
);
1777 img
->vmargin
+= eabs (img
->relief
);
1780 if (! img
->background_valid
)
1782 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1786 = x_alloc_image_color (f
, img
, bg
,
1787 FRAME_BACKGROUND_PIXEL (f
));
1788 img
->background_valid
= 1;
1792 /* Do image transformations and compute masks, unless we
1793 don't have the image yet. */
1794 if (!EQ (*img
->type
->type
, Qpostscript
))
1795 postprocess_image (f
, img
);
1801 /* We're using IMG, so set its timestamp to `now'. */
1802 EMACS_GET_TIME (now
);
1803 img
->timestamp
= EMACS_SECS (now
);
1805 /* Value is the image id. */
1810 /* Cache image IMG in the image cache of frame F. */
1813 cache_image (struct frame
*f
, struct image
*img
)
1815 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1818 /* Find a free slot in c->images. */
1819 for (i
= 0; i
< c
->used
; ++i
)
1820 if (c
->images
[i
] == NULL
)
1823 /* If no free slot found, maybe enlarge c->images. */
1824 if (i
== c
->used
&& c
->used
== c
->size
)
1825 c
->images
= xpalloc (c
->images
, &c
->size
, 1, -1, sizeof *c
->images
);
1827 /* Add IMG to c->images, and assign IMG an id. */
1833 /* Add IMG to the cache's hash table. */
1834 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1835 img
->next
= c
->buckets
[i
];
1837 img
->next
->prev
= img
;
1839 c
->buckets
[i
] = img
;
1843 /* Call FN on every image in the image cache of frame F. Used to mark
1844 Lisp Objects in the image cache. */
1846 /* Mark Lisp objects in image IMG. */
1849 mark_image (struct image
*img
)
1851 mark_object (img
->spec
);
1852 mark_object (img
->dependencies
);
1854 if (!NILP (img
->lisp_data
))
1855 mark_object (img
->lisp_data
);
1860 mark_image_cache (struct image_cache
*c
)
1865 for (i
= 0; i
< c
->used
; ++i
)
1867 mark_image (c
->images
[i
]);
1873 /***********************************************************************
1874 X / NS / W32 support code
1875 ***********************************************************************/
1879 /* Macro for defining functions that will be loaded from image DLLs. */
1880 #define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
1882 /* Macro for loading those image functions from the library. */
1883 #define LOAD_IMGLIB_FN(lib,func) { \
1884 fn_##func = (void *) GetProcAddress (lib, #func); \
1885 if (!fn_##func) return 0; \
1888 #endif /* HAVE_NTGUI */
1890 static int x_create_x_image_and_pixmap (struct frame
*, int, int, int,
1891 XImagePtr
*, Pixmap
*);
1892 static void x_destroy_x_image (XImagePtr
);
1893 static void x_put_x_image (struct frame
*, XImagePtr
, Pixmap
, int, int);
1895 /* Return nonzero if XIMG's size WIDTH x HEIGHT doesn't break the
1897 WIDTH and HEIGHT must both be positive.
1898 If XIMG is null, assume it is a bitmap. */
1900 x_check_image_size (XImagePtr ximg
, int width
, int height
)
1902 #ifdef HAVE_X_WINDOWS
1903 /* Respect Xlib's limits: it cannot deal with images that have more
1904 than INT_MAX (and/or UINT_MAX) bytes. And respect Emacs's limits
1905 of PTRDIFF_MAX (and/or SIZE_MAX) bytes for any object. */
1908 XLIB_BYTES_MAX
= min (INT_MAX
, UINT_MAX
),
1909 X_IMAGE_BYTES_MAX
= min (XLIB_BYTES_MAX
, min (PTRDIFF_MAX
, SIZE_MAX
))
1912 int bitmap_pad
, depth
, bytes_per_line
;
1915 bitmap_pad
= ximg
->bitmap_pad
;
1916 depth
= ximg
->depth
;
1917 bytes_per_line
= ximg
->bytes_per_line
;
1923 bytes_per_line
= (width
>> 3) + ((width
& 7) != 0);
1925 return (width
<= (INT_MAX
- (bitmap_pad
- 1)) / depth
1926 && height
<= X_IMAGE_BYTES_MAX
/ bytes_per_line
);
1928 /* FIXME: Implement this check for the HAVE_NS and HAVE_NTGUI cases.
1929 For now, assume that every image size is allowed on these systems. */
1934 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1935 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1936 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1937 via xmalloc. Print error messages via image_error if an error
1938 occurs. Value is non-zero if successful.
1940 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1941 should indicate the bit depth of the image. */
1944 x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
, int depth
,
1945 XImagePtr
*ximg
, Pixmap
*pixmap
)
1947 #ifdef HAVE_X_WINDOWS
1948 Display
*display
= FRAME_X_DISPLAY (f
);
1949 Window window
= FRAME_X_WINDOW (f
);
1950 Screen
*screen
= FRAME_X_SCREEN (f
);
1952 xassert (interrupt_input_blocked
);
1955 depth
= DefaultDepthOfScreen (screen
);
1956 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1957 depth
, ZPixmap
, 0, NULL
, width
, height
,
1958 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1961 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1965 if (! x_check_image_size (*ximg
, width
, height
))
1967 x_destroy_x_image (*ximg
);
1969 image_error ("Image too large (%dx%d)",
1970 make_number (width
), make_number (height
));
1974 /* Allocate image raster. */
1975 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
1977 /* Allocate a pixmap of the same size. */
1978 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1979 if (*pixmap
== NO_PIXMAP
)
1981 x_destroy_x_image (*ximg
);
1983 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1988 #endif /* HAVE_X_WINDOWS */
1992 BITMAPINFOHEADER
*header
;
1994 int scanline_width_bits
;
1996 int palette_colors
= 0;
2001 if (depth
!= 1 && depth
!= 4 && depth
!= 8
2002 && depth
!= 16 && depth
!= 24 && depth
!= 32)
2004 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
2008 scanline_width_bits
= width
* depth
;
2009 remainder
= scanline_width_bits
% 32;
2012 scanline_width_bits
+= 32 - remainder
;
2014 /* Bitmaps with a depth less than 16 need a palette. */
2015 /* BITMAPINFO structure already contains the first RGBQUAD. */
2017 palette_colors
= 1 << depth
- 1;
2019 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2021 header
= &(*ximg
)->info
.bmiHeader
;
2022 memset (&(*ximg
)->info
, 0, sizeof (BITMAPINFO
));
2023 header
->biSize
= sizeof (*header
);
2024 header
->biWidth
= width
;
2025 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2026 header
->biPlanes
= 1;
2027 header
->biBitCount
= depth
;
2028 header
->biCompression
= BI_RGB
;
2029 header
->biClrUsed
= palette_colors
;
2031 /* TODO: fill in palette. */
2034 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2035 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2036 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2037 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2038 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2039 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2040 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2041 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2044 hdc
= get_frame_dc (f
);
2046 /* Create a DIBSection and raster array for the bitmap,
2047 and store its handle in *pixmap. */
2048 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2049 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2050 /* casting avoids a GCC warning */
2051 (void **)&((*ximg
)->data
), NULL
, 0);
2053 /* Realize display palette and garbage all frames. */
2054 release_frame_dc (f
, hdc
);
2056 if (*pixmap
== NULL
)
2058 DWORD err
= GetLastError ();
2059 Lisp_Object errcode
;
2060 /* All system errors are < 10000, so the following is safe. */
2061 XSETINT (errcode
, err
);
2062 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2063 x_destroy_x_image (*ximg
);
2069 #endif /* HAVE_NTGUI */
2072 *pixmap
= ns_image_for_XPM (width
, height
, depth
);
2076 image_error ("Unable to allocate NSImage for XPM pixmap", Qnil
, Qnil
);
2085 /* Destroy XImage XIMG. Free XIMG->data. */
2088 x_destroy_x_image (XImagePtr ximg
)
2090 xassert (interrupt_input_blocked
);
2093 #ifdef HAVE_X_WINDOWS
2096 XDestroyImage (ximg
);
2097 #endif /* HAVE_X_WINDOWS */
2099 /* Data will be freed by DestroyObject. */
2102 #endif /* HAVE_NTGUI */
2104 ns_release_object (ximg
);
2105 #endif /* HAVE_NS */
2110 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2111 are width and height of both the image and pixmap. */
2114 x_put_x_image (struct frame
*f
, XImagePtr ximg
, Pixmap pixmap
, int width
, int height
)
2116 #ifdef HAVE_X_WINDOWS
2119 xassert (interrupt_input_blocked
);
2120 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2121 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2122 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2123 #endif /* HAVE_X_WINDOWS */
2126 #if 0 /* I don't think this is necessary looking at where it is used. */
2127 HDC hdc
= get_frame_dc (f
);
2128 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2129 release_frame_dc (f
, hdc
);
2131 #endif /* HAVE_NTGUI */
2134 xassert (ximg
== pixmap
);
2135 ns_retain_object (ximg
);
2140 /***********************************************************************
2142 ***********************************************************************/
2144 /* Find image file FILE. Look in data-directory/images, then
2145 x-bitmap-file-path. Value is the encoded full name of the file
2146 found, or nil if not found. */
2149 x_find_image_file (Lisp_Object file
)
2151 Lisp_Object file_found
, search_path
;
2154 /* TODO I think this should use something like image-load-path
2155 instead. Unfortunately, that can contain non-string elements. */
2156 search_path
= Fcons (Fexpand_file_name (build_string ("images"),
2158 Vx_bitmap_file_path
);
2160 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2161 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
2167 file_found
= ENCODE_FILE (file_found
);
2175 /* Read FILE into memory. Value is a pointer to a buffer allocated
2176 with xmalloc holding FILE's contents. Value is null if an error
2177 occurred. *SIZE is set to the size of the file. */
2179 static unsigned char *
2180 slurp_file (char *file
, ptrdiff_t *size
)
2183 unsigned char *buf
= NULL
;
2186 if (stat (file
, &st
) == 0
2187 && (fp
= fopen (file
, "rb")) != NULL
2188 && 0 <= st
.st_size
&& st
.st_size
<= min (PTRDIFF_MAX
, SIZE_MAX
)
2189 && (buf
= (unsigned char *) xmalloc (st
.st_size
),
2190 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
2211 /***********************************************************************
2213 ***********************************************************************/
2215 static int xbm_scan (unsigned char **, unsigned char *, char *, int *);
2216 static int xbm_load (struct frame
*f
, struct image
*img
);
2217 static int xbm_load_image (struct frame
*f
, struct image
*img
,
2218 unsigned char *, unsigned char *);
2219 static int xbm_image_p (Lisp_Object object
);
2220 static int xbm_read_bitmap_data (struct frame
*f
,
2221 unsigned char *, unsigned char *,
2222 int *, int *, char **, int);
2223 static int xbm_file_p (Lisp_Object
);
2226 /* Indices of image specification fields in xbm_format, below. */
2228 enum xbm_keyword_index
2246 /* Vector of image_keyword structures describing the format
2247 of valid XBM image specifications. */
2249 static const struct image_keyword xbm_format
[XBM_LAST
] =
2251 {":type", IMAGE_SYMBOL_VALUE
, 1},
2252 {":file", IMAGE_STRING_VALUE
, 0},
2253 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2254 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2255 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2256 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2257 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2258 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2259 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
2260 {":relief", IMAGE_INTEGER_VALUE
, 0},
2261 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2262 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2263 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2266 /* Structure describing the image type XBM. */
2268 static struct image_type xbm_type
=
2277 /* Tokens returned from xbm_scan. */
2286 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2287 A valid specification is a list starting with the symbol `image'
2288 The rest of the list is a property list which must contain an
2291 If the specification specifies a file to load, it must contain
2292 an entry `:file FILENAME' where FILENAME is a string.
2294 If the specification is for a bitmap loaded from memory it must
2295 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2296 WIDTH and HEIGHT are integers > 0. DATA may be:
2298 1. a string large enough to hold the bitmap data, i.e. it must
2299 have a size >= (WIDTH + 7) / 8 * HEIGHT
2301 2. a bool-vector of size >= WIDTH * HEIGHT
2303 3. a vector of strings or bool-vectors, one for each line of the
2306 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2307 may not be specified in this case because they are defined in the
2310 Both the file and data forms may contain the additional entries
2311 `:background COLOR' and `:foreground COLOR'. If not present,
2312 foreground and background of the frame on which the image is
2313 displayed is used. */
2316 xbm_image_p (Lisp_Object object
)
2318 struct image_keyword kw
[XBM_LAST
];
2320 memcpy (kw
, xbm_format
, sizeof kw
);
2321 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2324 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2326 if (kw
[XBM_FILE
].count
)
2328 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2331 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2333 /* In-memory XBM file. */
2334 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2342 /* Entries for `:width', `:height' and `:data' must be present. */
2343 if (!kw
[XBM_WIDTH
].count
2344 || !kw
[XBM_HEIGHT
].count
2345 || !kw
[XBM_DATA
].count
)
2348 data
= kw
[XBM_DATA
].value
;
2349 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2350 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2352 /* Check type of data, and width and height against contents of
2358 /* Number of elements of the vector must be >= height. */
2359 if (ASIZE (data
) < height
)
2362 /* Each string or bool-vector in data must be large enough
2363 for one line of the image. */
2364 for (i
= 0; i
< height
; ++i
)
2366 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
2371 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2374 else if (BOOL_VECTOR_P (elt
))
2376 if (XBOOL_VECTOR (elt
)->size
< width
)
2383 else if (STRINGP (data
))
2386 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2389 else if (BOOL_VECTOR_P (data
))
2391 if (XBOOL_VECTOR (data
)->size
/ height
< width
)
2402 /* Scan a bitmap file. FP is the stream to read from. Value is
2403 either an enumerator from enum xbm_token, or a character for a
2404 single-character token, or 0 at end of file. If scanning an
2405 identifier, store the lexeme of the identifier in SVAL. If
2406 scanning a number, store its value in *IVAL. */
2409 xbm_scan (unsigned char **s
, unsigned char *end
, char *sval
, int *ival
)
2415 /* Skip white space. */
2416 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
2421 else if (isdigit (c
))
2423 int value
= 0, digit
;
2425 if (c
== '0' && *s
< end
)
2428 if (c
== 'x' || c
== 'X')
2435 else if (c
>= 'a' && c
<= 'f')
2436 digit
= c
- 'a' + 10;
2437 else if (c
>= 'A' && c
<= 'F')
2438 digit
= c
- 'A' + 10;
2441 value
= 16 * value
+ digit
;
2444 else if (isdigit (c
))
2448 && (c
= *(*s
)++, isdigit (c
)))
2449 value
= 8 * value
+ c
- '0';
2456 && (c
= *(*s
)++, isdigit (c
)))
2457 value
= 10 * value
+ c
- '0';
2465 else if (isalpha (c
) || c
== '_')
2469 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
2476 else if (c
== '/' && **s
== '*')
2478 /* C-style comment. */
2480 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2494 /* Create a Windows bitmap from X bitmap data. */
2496 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2498 static unsigned char swap_nibble
[16]
2499 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2500 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2501 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2502 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2504 unsigned char *bits
, *p
;
2507 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2508 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2509 bits
= (unsigned char *) alloca (height
* w2
);
2510 memset (bits
, 0, height
* w2
);
2511 for (i
= 0; i
< height
; i
++)
2514 for (j
= 0; j
< w1
; j
++)
2516 /* Bitswap XBM bytes to match how Windows does things. */
2517 unsigned char c
= *data
++;
2518 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2519 | (swap_nibble
[(c
>>4) & 0xf]));
2522 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2528 convert_mono_to_color_image (struct frame
*f
, struct image
*img
,
2529 COLORREF foreground
, COLORREF background
)
2531 HDC hdc
, old_img_dc
, new_img_dc
;
2532 HGDIOBJ old_prev
, new_prev
;
2535 hdc
= get_frame_dc (f
);
2536 old_img_dc
= CreateCompatibleDC (hdc
);
2537 new_img_dc
= CreateCompatibleDC (hdc
);
2538 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2539 release_frame_dc (f
, hdc
);
2540 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2541 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2542 /* Windows convention for mono bitmaps is black = background,
2543 white = foreground. */
2544 SetTextColor (new_img_dc
, background
);
2545 SetBkColor (new_img_dc
, foreground
);
2547 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2550 SelectObject (old_img_dc
, old_prev
);
2551 SelectObject (new_img_dc
, new_prev
);
2552 DeleteDC (old_img_dc
);
2553 DeleteDC (new_img_dc
);
2554 DeleteObject (img
->pixmap
);
2555 if (new_pixmap
== 0)
2556 fprintf (stderr
, "Failed to convert image to color.\n");
2558 img
->pixmap
= new_pixmap
;
2561 #define XBM_BIT_SHUFFLE(b) (~(b))
2565 #define XBM_BIT_SHUFFLE(b) (b)
2567 #endif /* HAVE_NTGUI */
2571 Create_Pixmap_From_Bitmap_Data (struct frame
*f
, struct image
*img
, char *data
,
2572 RGB_PIXEL_COLOR fg
, RGB_PIXEL_COLOR bg
,
2573 int non_default_colors
)
2577 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2579 /* If colors were specified, transfer the bitmap to a color one. */
2580 if (non_default_colors
)
2581 convert_mono_to_color_image (f
, img
, fg
, bg
);
2583 #elif defined (HAVE_NS)
2584 img
->pixmap
= ns_image_from_XBM (data
, img
->width
, img
->height
);
2588 (x_check_image_size (0, img
->width
, img
->height
)
2589 ? XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2592 img
->width
, img
->height
,
2594 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)))
2596 #endif /* !HAVE_NTGUI && !HAVE_NS */
2601 /* Replacement for XReadBitmapFileData which isn't available under old
2602 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2603 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2604 the image. Return in *DATA the bitmap data allocated with xmalloc.
2605 Value is non-zero if successful. DATA null means just test if
2606 CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR
2607 is non-zero, inhibit the call to image_error when the image size is
2608 invalid (the bitmap remains unread). */
2611 xbm_read_bitmap_data (struct frame
*f
, unsigned char *contents
, unsigned char *end
,
2612 int *width
, int *height
, char **data
,
2613 int inhibit_image_error
)
2615 unsigned char *s
= contents
;
2616 char buffer
[BUFSIZ
];
2619 int bytes_per_line
, i
, nbytes
;
2625 LA1 = xbm_scan (&s, end, buffer, &value)
2627 #define expect(TOKEN) \
2628 if (LA1 != (TOKEN)) \
2633 #define expect_ident(IDENT) \
2634 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2639 *width
= *height
= -1;
2642 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2644 /* Parse defines for width, height and hot-spots. */
2648 expect_ident ("define");
2649 expect (XBM_TK_IDENT
);
2651 if (LA1
== XBM_TK_NUMBER
)
2653 char *q
= strrchr (buffer
, '_');
2654 q
= q
? q
+ 1 : buffer
;
2655 if (strcmp (q
, "width") == 0)
2657 else if (strcmp (q
, "height") == 0)
2660 expect (XBM_TK_NUMBER
);
2663 if (!check_image_size (f
, *width
, *height
))
2665 if (!inhibit_image_error
)
2666 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
2669 else if (data
== NULL
)
2672 /* Parse bits. Must start with `static'. */
2673 expect_ident ("static");
2674 if (LA1
== XBM_TK_IDENT
)
2676 if (strcmp (buffer
, "unsigned") == 0)
2679 expect_ident ("char");
2681 else if (strcmp (buffer
, "short") == 0)
2685 if (*width
% 16 && *width
% 16 < 9)
2688 else if (strcmp (buffer
, "char") == 0)
2696 expect (XBM_TK_IDENT
);
2702 if (! x_check_image_size (0, *width
, *height
))
2704 if (!inhibit_image_error
)
2705 image_error ("Image too large (%dx%d)",
2706 make_number (*width
), make_number (*height
));
2709 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2710 nbytes
= bytes_per_line
* *height
;
2711 p
= *data
= (char *) xmalloc (nbytes
);
2715 for (i
= 0; i
< nbytes
; i
+= 2)
2718 expect (XBM_TK_NUMBER
);
2720 *p
++ = XBM_BIT_SHUFFLE (val
);
2721 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2722 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2724 if (LA1
== ',' || LA1
== '}')
2732 for (i
= 0; i
< nbytes
; ++i
)
2735 expect (XBM_TK_NUMBER
);
2737 *p
++ = XBM_BIT_SHUFFLE (val
);
2739 if (LA1
== ',' || LA1
== '}')
2764 /* Load XBM image IMG which will be displayed on frame F from buffer
2765 CONTENTS. END is the end of the buffer. Value is non-zero if
2769 xbm_load_image (struct frame
*f
, struct image
*img
, unsigned char *contents
,
2776 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
,
2780 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2781 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2782 int non_default_colors
= 0;
2785 xassert (img
->width
> 0 && img
->height
> 0);
2787 /* Get foreground and background colors, maybe allocate colors. */
2788 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
2791 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
2792 non_default_colors
= 1;
2794 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2797 background
= x_alloc_image_color (f
, img
, value
, background
);
2798 img
->background
= background
;
2799 img
->background_valid
= 1;
2800 non_default_colors
= 1;
2803 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
2804 foreground
, background
,
2805 non_default_colors
);
2808 if (img
->pixmap
== NO_PIXMAP
)
2810 x_clear_image (f
, img
);
2811 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
2817 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2823 /* Value is non-zero if DATA looks like an in-memory XBM file. */
2826 xbm_file_p (Lisp_Object data
)
2829 return (STRINGP (data
)
2830 && xbm_read_bitmap_data (NULL
, SDATA (data
),
2831 (SDATA (data
) + SBYTES (data
)),
2836 /* Fill image IMG which is used on frame F with pixmap data. Value is
2837 non-zero if successful. */
2840 xbm_load (struct frame
*f
, struct image
*img
)
2843 Lisp_Object file_name
;
2845 xassert (xbm_image_p (img
->spec
));
2847 /* If IMG->spec specifies a file name, create a non-file spec from it. */
2848 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
2849 if (STRINGP (file_name
))
2852 unsigned char *contents
;
2855 file
= x_find_image_file (file_name
);
2856 if (!STRINGP (file
))
2858 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
2862 contents
= slurp_file (SSDATA (file
), &size
);
2863 if (contents
== NULL
)
2865 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2869 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
2874 struct image_keyword fmt
[XBM_LAST
];
2876 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2877 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2878 int non_default_colors
= 0;
2881 int in_memory_file_p
= 0;
2883 /* See if data looks like an in-memory XBM file. */
2884 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2885 in_memory_file_p
= xbm_file_p (data
);
2887 /* Parse the image specification. */
2888 memcpy (fmt
, xbm_format
, sizeof fmt
);
2889 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
2893 /* Get specified width, and height. */
2894 if (!in_memory_file_p
)
2896 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
2897 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
2898 xassert (img
->width
> 0 && img
->height
> 0);
2899 if (!check_image_size (f
, img
->width
, img
->height
))
2901 image_error ("Invalid image size (see `max-image-size')",
2907 /* Get foreground and background colors, maybe allocate colors. */
2908 if (fmt
[XBM_FOREGROUND
].count
2909 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
2911 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
2913 non_default_colors
= 1;
2916 if (fmt
[XBM_BACKGROUND
].count
2917 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
2919 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
2921 non_default_colors
= 1;
2924 if (in_memory_file_p
)
2925 success_p
= xbm_load_image (f
, img
, SDATA (data
),
2934 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
2936 p
= bits
= (char *) alloca (nbytes
* img
->height
);
2937 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
2939 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
2941 memcpy (p
, SDATA (line
), nbytes
);
2943 memcpy (p
, XBOOL_VECTOR (line
)->data
, nbytes
);
2946 else if (STRINGP (data
))
2947 bits
= SSDATA (data
);
2949 bits
= (char *) XBOOL_VECTOR (data
)->data
;
2955 /* Windows mono bitmaps are reversed compared with X. */
2956 invertedBits
= bits
;
2957 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
2959 bits
= (char *) alloca (nbytes
);
2960 for (i
= 0; i
< nbytes
; i
++)
2961 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
2964 /* Create the pixmap. */
2966 if (x_check_image_size (0, img
->width
, img
->height
))
2967 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
2968 foreground
, background
,
2969 non_default_colors
);
2971 img
->pixmap
= NO_PIXMAP
;
2977 image_error ("Unable to create pixmap for XBM image `%s'",
2979 x_clear_image (f
, img
);
2989 /***********************************************************************
2991 ***********************************************************************/
2993 #if defined (HAVE_XPM) || defined (HAVE_NS)
2995 static int xpm_image_p (Lisp_Object object
);
2996 static int xpm_load (struct frame
*f
, struct image
*img
);
2997 static int xpm_valid_color_symbols_p (Lisp_Object
);
2999 #endif /* HAVE_XPM || HAVE_NS */
3003 /* Indicate to xpm.h that we don't have Xlib. */
3005 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3006 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3007 #define XColor xpm_XColor
3008 #define XImage xpm_XImage
3009 #define Display xpm_Display
3010 #define PIXEL_ALREADY_TYPEDEFED
3011 #include "X11/xpm.h"
3016 #undef PIXEL_ALREADY_TYPEDEFED
3018 #include "X11/xpm.h"
3019 #endif /* HAVE_NTGUI */
3020 #endif /* HAVE_XPM */
3022 #if defined (HAVE_XPM) || defined (HAVE_NS)
3023 /* The symbol `xpm' identifying XPM-format images. */
3025 static Lisp_Object Qxpm
;
3027 /* Indices of image specification fields in xpm_format, below. */
3029 enum xpm_keyword_index
3045 /* Vector of image_keyword structures describing the format
3046 of valid XPM image specifications. */
3048 static const struct image_keyword xpm_format
[XPM_LAST
] =
3050 {":type", IMAGE_SYMBOL_VALUE
, 1},
3051 {":file", IMAGE_STRING_VALUE
, 0},
3052 {":data", IMAGE_STRING_VALUE
, 0},
3053 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3054 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
3055 {":relief", IMAGE_INTEGER_VALUE
, 0},
3056 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3057 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3058 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3059 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3060 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3063 /* Structure describing the image type XPM. */
3065 static struct image_type xpm_type
=
3074 #ifdef HAVE_X_WINDOWS
3076 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3077 functions for allocating image colors. Our own functions handle
3078 color allocation failures more gracefully than the ones on the XPM
3081 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3082 #define ALLOC_XPM_COLORS
3084 #endif /* HAVE_X_WINDOWS */
3086 #ifdef ALLOC_XPM_COLORS
3088 static void xpm_init_color_cache (struct frame
*, XpmAttributes
*);
3089 static void xpm_free_color_cache (void);
3090 static int xpm_lookup_color (struct frame
*, char *, XColor
*);
3091 static int xpm_color_bucket (char *);
3092 static struct xpm_cached_color
*xpm_cache_color (struct frame
*, char *,
3095 /* An entry in a hash table used to cache color definitions of named
3096 colors. This cache is necessary to speed up XPM image loading in
3097 case we do color allocations ourselves. Without it, we would need
3098 a call to XParseColor per pixel in the image. */
3100 struct xpm_cached_color
3102 /* Next in collision chain. */
3103 struct xpm_cached_color
*next
;
3105 /* Color definition (RGB and pixel color). */
3112 /* The hash table used for the color cache, and its bucket vector
3115 #define XPM_COLOR_CACHE_BUCKETS 1001
3116 static struct xpm_cached_color
**xpm_color_cache
;
3118 /* Initialize the color cache. */
3121 xpm_init_color_cache (struct frame
*f
, XpmAttributes
*attrs
)
3123 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3124 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
3125 memset (xpm_color_cache
, 0, nbytes
);
3126 init_color_table ();
3128 if (attrs
->valuemask
& XpmColorSymbols
)
3133 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3134 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3135 attrs
->colorsymbols
[i
].value
, &color
))
3137 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3139 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3144 /* Free the color cache. */
3147 xpm_free_color_cache (void)
3149 struct xpm_cached_color
*p
, *next
;
3152 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3153 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3159 xfree (xpm_color_cache
);
3160 xpm_color_cache
= NULL
;
3161 free_color_table ();
3164 /* Return the bucket index for color named COLOR_NAME in the color
3168 xpm_color_bucket (char *color_name
)
3170 EMACS_UINT hash
= hash_string (color_name
, strlen (color_name
));
3171 return hash
% XPM_COLOR_CACHE_BUCKETS
;
3175 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3176 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3179 static struct xpm_cached_color
*
3180 xpm_cache_color (struct frame
*f
, char *color_name
, XColor
*color
, int bucket
)
3183 struct xpm_cached_color
*p
;
3186 bucket
= xpm_color_bucket (color_name
);
3188 nbytes
= offsetof (struct xpm_cached_color
, name
) + strlen (color_name
) + 1;
3189 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
3190 strcpy (p
->name
, color_name
);
3192 p
->next
= xpm_color_cache
[bucket
];
3193 xpm_color_cache
[bucket
] = p
;
3197 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3198 return the cached definition in *COLOR. Otherwise, make a new
3199 entry in the cache and allocate the color. Value is zero if color
3200 allocation failed. */
3203 xpm_lookup_color (struct frame
*f
, char *color_name
, XColor
*color
)
3205 struct xpm_cached_color
*p
;
3206 int h
= xpm_color_bucket (color_name
);
3208 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3209 if (strcmp (p
->name
, color_name
) == 0)
3214 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3217 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3219 p
= xpm_cache_color (f
, color_name
, color
, h
);
3221 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3222 with transparency, and it's useful. */
3223 else if (strcmp ("opaque", color_name
) == 0)
3225 memset (color
, 0, sizeof (XColor
)); /* Is this necessary/correct? */
3226 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3227 p
= xpm_cache_color (f
, color_name
, color
, h
);
3234 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3235 CLOSURE is a pointer to the frame on which we allocate the
3236 color. Return in *COLOR the allocated color. Value is non-zero
3240 xpm_alloc_color (Display
*dpy
, Colormap cmap
, char *color_name
, XColor
*color
,
3243 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
3247 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3248 is a pointer to the frame on which we allocate the color. Value is
3249 non-zero if successful. */
3252 xpm_free_colors (Display
*dpy
, Colormap cmap
, Pixel
*pixels
, int npixels
, void *closure
)
3257 #endif /* ALLOC_XPM_COLORS */
3262 /* XPM library details. */
3264 DEF_IMGLIB_FN (void, XpmFreeAttributes
, (XpmAttributes
*));
3265 DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer
, (Display
*, char *, xpm_XImage
**,
3266 xpm_XImage
**, XpmAttributes
*));
3267 DEF_IMGLIB_FN (int, XpmReadFileToImage
, (Display
*, char *, xpm_XImage
**,
3268 xpm_XImage
**, XpmAttributes
*));
3269 DEF_IMGLIB_FN (void, XImageFree
, (xpm_XImage
*));
3272 init_xpm_functions (Lisp_Object libraries
)
3276 if (!(library
= w32_delayed_load (libraries
, Qxpm
)))
3279 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3280 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3281 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3282 LOAD_IMGLIB_FN (library
, XImageFree
);
3286 #endif /* HAVE_NTGUI */
3289 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3290 for XPM images. Such a list must consist of conses whose car and
3294 xpm_valid_color_symbols_p (Lisp_Object color_symbols
)
3296 while (CONSP (color_symbols
))
3298 Lisp_Object sym
= XCAR (color_symbols
);
3300 || !STRINGP (XCAR (sym
))
3301 || !STRINGP (XCDR (sym
)))
3303 color_symbols
= XCDR (color_symbols
);
3306 return NILP (color_symbols
);
3310 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3313 xpm_image_p (Lisp_Object object
)
3315 struct image_keyword fmt
[XPM_LAST
];
3316 memcpy (fmt
, xpm_format
, sizeof fmt
);
3317 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3318 /* Either `:file' or `:data' must be present. */
3319 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3320 /* Either no `:color-symbols' or it's a list of conses
3321 whose car and cdr are strings. */
3322 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3323 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3326 #endif /* HAVE_XPM || HAVE_NS */
3328 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3330 x_create_bitmap_from_xpm_data (struct frame
*f
, const char **bits
)
3332 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3335 XpmAttributes attrs
;
3336 Pixmap bitmap
, mask
;
3338 memset (&attrs
, 0, sizeof attrs
);
3340 attrs
.visual
= FRAME_X_VISUAL (f
);
3341 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3342 attrs
.valuemask
|= XpmVisual
;
3343 attrs
.valuemask
|= XpmColormap
;
3345 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3346 (char **) bits
, &bitmap
, &mask
, &attrs
);
3347 if (rc
!= XpmSuccess
)
3349 XpmFreeAttributes (&attrs
);
3353 id
= x_allocate_bitmap_record (f
);
3354 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3355 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
3356 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3357 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3358 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3359 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3360 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3361 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3363 XpmFreeAttributes (&attrs
);
3366 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3368 /* Load image IMG which will be displayed on frame F. Value is
3369 non-zero if successful. */
3374 xpm_load (struct frame
*f
, struct image
*img
)
3377 XpmAttributes attrs
;
3378 Lisp_Object specified_file
, color_symbols
;
3381 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3382 #endif /* HAVE_NTGUI */
3384 /* Configure the XPM lib. Use the visual of frame F. Allocate
3385 close colors. Return colors allocated. */
3386 memset (&attrs
, 0, sizeof attrs
);
3389 attrs
.visual
= FRAME_X_VISUAL (f
);
3390 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3391 attrs
.valuemask
|= XpmVisual
;
3392 attrs
.valuemask
|= XpmColormap
;
3393 #endif /* HAVE_NTGUI */
3395 #ifdef ALLOC_XPM_COLORS
3396 /* Allocate colors with our own functions which handle
3397 failing color allocation more gracefully. */
3398 attrs
.color_closure
= f
;
3399 attrs
.alloc_color
= xpm_alloc_color
;
3400 attrs
.free_colors
= xpm_free_colors
;
3401 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3402 #else /* not ALLOC_XPM_COLORS */
3403 /* Let the XPM lib allocate colors. */
3404 attrs
.valuemask
|= XpmReturnAllocPixels
;
3405 #ifdef XpmAllocCloseColors
3406 attrs
.alloc_close_colors
= 1;
3407 attrs
.valuemask
|= XpmAllocCloseColors
;
3408 #else /* not XpmAllocCloseColors */
3409 attrs
.closeness
= 600;
3410 attrs
.valuemask
|= XpmCloseness
;
3411 #endif /* not XpmAllocCloseColors */
3412 #endif /* ALLOC_XPM_COLORS */
3414 /* If image specification contains symbolic color definitions, add
3415 these to `attrs'. */
3416 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3417 if (CONSP (color_symbols
))
3420 XpmColorSymbol
*xpm_syms
;
3423 attrs
.valuemask
|= XpmColorSymbols
;
3425 /* Count number of symbols. */
3426 attrs
.numsymbols
= 0;
3427 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3430 /* Allocate an XpmColorSymbol array. */
3431 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3432 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
3433 memset (xpm_syms
, 0, size
);
3434 attrs
.colorsymbols
= xpm_syms
;
3436 /* Fill the color symbol array. */
3437 for (tail
= color_symbols
, i
= 0;
3439 ++i
, tail
= XCDR (tail
))
3443 char *empty_string
= (char *) "";
3445 if (!CONSP (XCAR (tail
)))
3447 xpm_syms
[i
].name
= empty_string
;
3448 xpm_syms
[i
].value
= empty_string
;
3451 name
= XCAR (XCAR (tail
));
3452 color
= XCDR (XCAR (tail
));
3455 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
3456 strcpy (xpm_syms
[i
].name
, SSDATA (name
));
3459 xpm_syms
[i
].name
= empty_string
;
3460 if (STRINGP (color
))
3462 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
3463 strcpy (xpm_syms
[i
].value
, SSDATA (color
));
3466 xpm_syms
[i
].value
= empty_string
;
3470 /* Create a pixmap for the image, either from a file, or from a
3471 string buffer containing data in the same format as an XPM file. */
3472 #ifdef ALLOC_XPM_COLORS
3473 xpm_init_color_cache (f
, &attrs
);
3476 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3480 HDC frame_dc
= get_frame_dc (f
);
3481 hdc
= CreateCompatibleDC (frame_dc
);
3482 release_frame_dc (f
, frame_dc
);
3484 #endif /* HAVE_NTGUI */
3486 if (STRINGP (specified_file
))
3488 Lisp_Object file
= x_find_image_file (specified_file
);
3489 if (!STRINGP (file
))
3491 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3492 #ifdef ALLOC_XPM_COLORS
3493 xpm_free_color_cache ();
3499 /* XpmReadFileToPixmap is not available in the Windows port of
3500 libxpm. But XpmReadFileToImage almost does what we want. */
3501 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3502 &xpm_image
, &xpm_mask
,
3505 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3506 SSDATA (file
), &img
->pixmap
, &img
->mask
,
3508 #endif /* HAVE_NTGUI */
3512 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3513 if (!STRINGP (buffer
))
3515 image_error ("Invalid image data `%s'", buffer
, Qnil
);
3516 #ifdef ALLOC_XPM_COLORS
3517 xpm_free_color_cache ();
3522 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3523 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3524 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3525 &xpm_image
, &xpm_mask
,
3528 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3530 &img
->pixmap
, &img
->mask
,
3532 #endif /* HAVE_NTGUI */
3535 if (rc
== XpmSuccess
)
3537 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3538 img
->colors
= colors_in_color_table (&img
->ncolors
);
3539 #else /* not ALLOC_XPM_COLORS */
3543 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3544 plus some duplicate attributes. */
3545 if (xpm_image
&& xpm_image
->bitmap
)
3547 img
->pixmap
= xpm_image
->bitmap
;
3548 /* XImageFree in libXpm frees XImage struct without destroying
3549 the bitmap, which is what we want. */
3550 fn_XImageFree (xpm_image
);
3552 if (xpm_mask
&& xpm_mask
->bitmap
)
3554 /* The mask appears to be inverted compared with what we expect.
3555 TODO: invert our expectations. See other places where we
3556 have to invert bits because our idea of masks is backwards. */
3558 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3560 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3561 SelectObject (hdc
, old_obj
);
3563 img
->mask
= xpm_mask
->bitmap
;
3564 fn_XImageFree (xpm_mask
);
3569 #endif /* HAVE_NTGUI */
3571 /* Remember allocated colors. */
3572 img
->colors
= xnmalloc (attrs
.nalloc_pixels
, sizeof *img
->colors
);
3573 img
->ncolors
= attrs
.nalloc_pixels
;
3574 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3576 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3577 #ifdef DEBUG_X_COLORS
3578 register_color (img
->colors
[i
]);
3581 #endif /* not ALLOC_XPM_COLORS */
3583 img
->width
= attrs
.width
;
3584 img
->height
= attrs
.height
;
3585 xassert (img
->width
> 0 && img
->height
> 0);
3587 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3589 fn_XpmFreeAttributes (&attrs
);
3591 XpmFreeAttributes (&attrs
);
3592 #endif /* HAVE_NTGUI */
3598 #endif /* HAVE_NTGUI */
3603 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3606 case XpmFileInvalid
:
3607 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3611 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3614 case XpmColorFailed
:
3615 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3619 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3624 #ifdef ALLOC_XPM_COLORS
3625 xpm_free_color_cache ();
3627 return rc
== XpmSuccess
;
3630 #endif /* HAVE_XPM */
3632 #if defined (HAVE_NS) && !defined (HAVE_XPM)
3634 /* XPM support functions for NS where libxpm is not available.
3635 Only XPM version 3 (without any extensions) is supported. */
3637 static void xpm_put_color_table_v (Lisp_Object
, const unsigned char *,
3639 static Lisp_Object
xpm_get_color_table_v (Lisp_Object
,
3640 const unsigned char *, int);
3641 static void xpm_put_color_table_h (Lisp_Object
, const unsigned char *,
3643 static Lisp_Object
xpm_get_color_table_h (Lisp_Object
,
3644 const unsigned char *, int);
3646 /* Tokens returned from xpm_scan. */
3655 /* Scan an XPM data and return a character (< 256) or a token defined
3656 by enum xpm_token above. *S and END are the start (inclusive) and
3657 the end (exclusive) addresses of the data, respectively. Advance
3658 *S while scanning. If token is either XPM_TK_IDENT or
3659 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3660 length of the corresponding token, respectively. */
3663 xpm_scan (const unsigned char **s
,
3664 const unsigned char *end
,
3665 const unsigned char **beg
,
3672 /* Skip white-space. */
3673 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
3676 /* gnus-pointer.xpm uses '-' in its identifier.
3677 sb-dir-plus.xpm uses '+' in its identifier. */
3678 if (isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3682 && (c
= **s
, isalnum (c
) || c
== '_' || c
== '-' || c
== '+'))
3685 return XPM_TK_IDENT
;
3690 while (*s
< end
&& **s
!= '"')
3695 return XPM_TK_STRING
;
3699 if (*s
< end
&& **s
== '*')
3701 /* C-style comment. */
3705 while (*s
< end
&& *(*s
)++ != '*')
3708 while (*s
< end
&& **s
!= '/');
3722 /* Functions for color table lookup in XPM data. A key is a string
3723 specifying the color of each pixel in XPM data. A value is either
3724 an integer that specifies a pixel color, Qt that specifies
3725 transparency, or Qnil for the unspecified color. If the length of
3726 the key string is one, a vector is used as a table. Otherwise, a
3727 hash table is used. */
3730 xpm_make_color_table_v (void (**put_func
) (Lisp_Object
,
3731 const unsigned char *,
3734 Lisp_Object (**get_func
) (Lisp_Object
,
3735 const unsigned char *,
3738 *put_func
= xpm_put_color_table_v
;
3739 *get_func
= xpm_get_color_table_v
;
3740 return Fmake_vector (make_number (256), Qnil
);
3744 xpm_put_color_table_v (Lisp_Object color_table
,
3745 const unsigned char *chars_start
,
3749 XVECTOR (color_table
)->contents
[*chars_start
] = color
;
3753 xpm_get_color_table_v (Lisp_Object color_table
,
3754 const unsigned char *chars_start
,
3757 return XVECTOR (color_table
)->contents
[*chars_start
];
3761 xpm_make_color_table_h (void (**put_func
) (Lisp_Object
,
3762 const unsigned char *,
3765 Lisp_Object (**get_func
) (Lisp_Object
,
3766 const unsigned char *,
3769 *put_func
= xpm_put_color_table_h
;
3770 *get_func
= xpm_get_color_table_h
;
3771 return make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
3772 make_float (DEFAULT_REHASH_SIZE
),
3773 make_float (DEFAULT_REHASH_THRESHOLD
),
3778 xpm_put_color_table_h (Lisp_Object color_table
,
3779 const unsigned char *chars_start
,
3783 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3784 EMACS_UINT hash_code
;
3785 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
3787 hash_lookup (table
, chars
, &hash_code
);
3788 hash_put (table
, chars
, color
, hash_code
);
3792 xpm_get_color_table_h (Lisp_Object color_table
,
3793 const unsigned char *chars_start
,
3796 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3798 hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
), NULL
);
3800 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
3803 enum xpm_color_key
{
3811 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
3814 xpm_str_to_color_key (const char *s
)
3819 i
< sizeof xpm_color_key_strings
/ sizeof xpm_color_key_strings
[0];
3821 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
3827 xpm_load_image (struct frame
*f
,
3829 const unsigned char *contents
,
3830 const unsigned char *end
)
3832 const unsigned char *s
= contents
, *beg
, *str
;
3833 unsigned char buffer
[BUFSIZ
];
3834 int width
, height
, x
, y
;
3835 int num_colors
, chars_per_pixel
;
3838 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
3839 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
3840 Lisp_Object frame
, color_symbols
, color_table
;
3841 int best_key
, have_mask
= 0;
3842 XImagePtr ximg
= NULL
, mask_img
= NULL
;
3845 LA1 = xpm_scan (&s, end, &beg, &len)
3847 #define expect(TOKEN) \
3848 if (LA1 != (TOKEN)) \
3853 #define expect_ident(IDENT) \
3854 if (LA1 == XPM_TK_IDENT \
3855 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
3860 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
3864 expect_ident ("static");
3865 expect_ident ("char");
3867 expect (XPM_TK_IDENT
);
3872 expect (XPM_TK_STRING
);
3875 memcpy (buffer
, beg
, len
);
3877 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
3878 &num_colors
, &chars_per_pixel
) != 4
3879 || width
<= 0 || height
<= 0
3880 || num_colors
<= 0 || chars_per_pixel
<= 0)
3883 if (!check_image_size (f
, width
, height
))
3885 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
3889 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
3890 &ximg
, &img
->pixmap
)
3892 || !x_create_x_image_and_pixmap (f
, width
, height
, 1,
3893 &mask_img
, &img
->mask
)
3897 image_error ("Image too large", Qnil
, Qnil
);
3903 XSETFRAME (frame
, f
);
3904 if (!NILP (Fxw_display_color_p (frame
)))
3905 best_key
= XPM_COLOR_KEY_C
;
3906 else if (!NILP (Fx_display_grayscale_p (frame
)))
3907 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
3908 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
3910 best_key
= XPM_COLOR_KEY_M
;
3912 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3913 if (chars_per_pixel
== 1)
3914 color_table
= xpm_make_color_table_v (&put_color_table
,
3917 color_table
= xpm_make_color_table_h (&put_color_table
,
3920 while (num_colors
-- > 0)
3922 char *color
, *max_color
;
3923 int key
, next_key
, max_key
= 0;
3924 Lisp_Object symbol_color
= Qnil
, color_val
;
3927 expect (XPM_TK_STRING
);
3928 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
3930 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
3931 buffer
[len
- chars_per_pixel
] = '\0';
3933 str
= strtok (buffer
, " \t");
3936 key
= xpm_str_to_color_key (str
);
3941 color
= strtok (NULL
, " \t");
3945 while ((str
= strtok (NULL
, " \t")) != NULL
)
3947 next_key
= xpm_str_to_color_key (str
);
3950 color
[strlen (color
)] = ' ';
3953 if (key
== XPM_COLOR_KEY_S
)
3955 if (NILP (symbol_color
))
3956 symbol_color
= build_string (color
);
3958 else if (max_key
< key
&& key
<= best_key
)
3968 if (!NILP (color_symbols
) && !NILP (symbol_color
))
3970 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
3972 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
3974 if (xstrcasecmp (SSDATA (XCDR (specified_color
)), "None") == 0)
3976 else if (x_defined_color (f
, SDATA (XCDR (specified_color
)),
3978 color_val
= make_number (cdef
.pixel
);
3981 if (NILP (color_val
) && max_key
> 0)
3983 if (xstrcasecmp (max_color
, "None") == 0)
3985 else if (x_defined_color (f
, max_color
, &cdef
, 0))
3986 color_val
= make_number (cdef
.pixel
);
3988 if (!NILP (color_val
))
3989 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
3994 for (y
= 0; y
< height
; y
++)
3996 expect (XPM_TK_STRING
);
3998 if (len
< width
* chars_per_pixel
)
4000 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4002 Lisp_Object color_val
=
4003 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4005 XPutPixel (ximg
, x
, y
,
4006 (INTEGERP (color_val
) ? XINT (color_val
)
4007 : FRAME_FOREGROUND_PIXEL (f
)));
4009 XPutPixel (mask_img
, x
, y
,
4010 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4011 : (have_mask
= 1, PIX_MASK_RETAIN
)));
4013 if (EQ (color_val
, Qt
))
4014 ns_set_alpha (ximg
, x
, y
, 0);
4022 img
->height
= height
;
4024 /* Maybe fill in the background field while we have ximg handy. */
4025 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4026 IMAGE_BACKGROUND (img
, f
, ximg
);
4028 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
4029 x_destroy_x_image (ximg
);
4033 /* Fill in the background_transparent field while we have the
4035 image_background_transparent (img
, f
, mask_img
);
4037 x_put_x_image (f
, mask_img
, img
->mask
, width
, height
);
4038 x_destroy_x_image (mask_img
);
4042 x_destroy_x_image (mask_img
);
4043 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4044 img
->mask
= NO_PIXMAP
;
4050 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4052 x_destroy_x_image (ximg
);
4053 x_destroy_x_image (mask_img
);
4054 x_clear_image (f
, img
);
4063 xpm_load (struct frame
*f
,
4067 Lisp_Object file_name
;
4069 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4070 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4071 if (STRINGP (file_name
))
4074 unsigned char *contents
;
4077 file
= x_find_image_file (file_name
);
4078 if (!STRINGP (file
))
4080 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4084 contents
= slurp_file (SDATA (file
), &size
);
4085 if (contents
== NULL
)
4087 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4091 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4098 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4099 if (!STRINGP (data
))
4101 image_error ("Invalid image data `%s'", data
, Qnil
);
4104 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4105 SDATA (data
) + SBYTES (data
));
4111 #endif /* HAVE_NS && !HAVE_XPM */
4115 /***********************************************************************
4117 ***********************************************************************/
4119 #ifdef COLOR_TABLE_SUPPORT
4121 /* An entry in the color table mapping an RGB color to a pixel color. */
4126 unsigned long pixel
;
4128 /* Next in color table collision list. */
4129 struct ct_color
*next
;
4132 /* The bucket vector size to use. Must be prime. */
4136 /* Value is a hash of the RGB color given by R, G, and B. */
4138 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4140 /* The color hash table. */
4142 static struct ct_color
**ct_table
;
4144 /* Number of entries in the color table. */
4146 static int ct_colors_allocated
;
4149 ct_colors_allocated_max
=
4151 min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (unsigned long))
4154 /* Initialize the color table. */
4157 init_color_table (void)
4159 int size
= CT_SIZE
* sizeof (*ct_table
);
4160 ct_table
= (struct ct_color
**) xmalloc (size
);
4161 memset (ct_table
, 0, size
);
4162 ct_colors_allocated
= 0;
4166 /* Free memory associated with the color table. */
4169 free_color_table (void)
4172 struct ct_color
*p
, *next
;
4174 for (i
= 0; i
< CT_SIZE
; ++i
)
4175 for (p
= ct_table
[i
]; p
; p
= next
)
4186 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4187 entry for that color already is in the color table, return the
4188 pixel color of that entry. Otherwise, allocate a new color for R,
4189 G, B, and make an entry in the color table. */
4191 static unsigned long
4192 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4194 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4195 int i
= hash
% CT_SIZE
;
4197 Display_Info
*dpyinfo
;
4199 /* Handle TrueColor visuals specially, which improves performance by
4200 two orders of magnitude. Freeing colors on TrueColor visuals is
4201 a nop, and pixel colors specify RGB values directly. See also
4202 the Xlib spec, chapter 3.1. */
4203 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4204 if (dpyinfo
->red_bits
> 0)
4206 unsigned long pr
, pg
, pb
;
4208 /* Apply gamma-correction like normal color allocation does. */
4212 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4213 gamma_correct (f
, &color
);
4214 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4217 /* Scale down RGB values to the visual's bits per RGB, and shift
4218 them to the right position in the pixel color. Note that the
4219 original RGB values are 16-bit values, as usual in X. */
4220 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4221 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4222 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4224 /* Assemble the pixel color. */
4225 return pr
| pg
| pb
;
4228 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4229 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4235 #ifdef HAVE_X_WINDOWS
4243 if (ct_colors_allocated_max
<= ct_colors_allocated
)
4244 return FRAME_FOREGROUND_PIXEL (f
);
4246 #ifdef HAVE_X_WINDOWS
4251 cmap
= FRAME_X_COLORMAP (f
);
4252 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4255 ++ct_colors_allocated
;
4256 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4260 p
->pixel
= color
.pixel
;
4261 p
->next
= ct_table
[i
];
4265 return FRAME_FOREGROUND_PIXEL (f
);
4269 color
= PALETTERGB (r
, g
, b
);
4271 color
= RGB_TO_ULONG (r
, g
, b
);
4272 #endif /* HAVE_NTGUI */
4273 ++ct_colors_allocated
;
4274 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4279 p
->next
= ct_table
[i
];
4281 #endif /* HAVE_X_WINDOWS */
4289 /* Look up pixel color PIXEL which is used on frame F in the color
4290 table. If not already present, allocate it. Value is PIXEL. */
4292 static unsigned long
4293 lookup_pixel_color (struct frame
*f
, unsigned long pixel
)
4295 int i
= pixel
% CT_SIZE
;
4298 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4299 if (p
->pixel
== pixel
)
4308 if (ct_colors_allocated_max
<= ct_colors_allocated
)
4309 return FRAME_FOREGROUND_PIXEL (f
);
4311 #ifdef HAVE_X_WINDOWS
4312 cmap
= FRAME_X_COLORMAP (f
);
4313 color
.pixel
= pixel
;
4314 x_query_color (f
, &color
);
4315 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4318 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4319 color
.pixel
= pixel
;
4320 XQueryColor (NULL
, cmap
, &color
);
4321 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4323 #endif /* HAVE_X_WINDOWS */
4327 ++ct_colors_allocated
;
4329 p
= (struct ct_color
*) xmalloc (sizeof *p
);
4334 p
->next
= ct_table
[i
];
4338 return FRAME_FOREGROUND_PIXEL (f
);
4344 /* Value is a vector of all pixel colors contained in the color table,
4345 allocated via xmalloc. Set *N to the number of colors. */
4347 static unsigned long *
4348 colors_in_color_table (int *n
)
4352 unsigned long *colors
;
4354 if (ct_colors_allocated
== 0)
4361 colors
= (unsigned long *) xmalloc (ct_colors_allocated
4363 *n
= ct_colors_allocated
;
4365 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4366 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4367 colors
[j
++] = p
->pixel
;
4373 #else /* COLOR_TABLE_SUPPORT */
4375 static unsigned long
4376 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4378 unsigned long pixel
;
4381 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4382 #endif /* HAVE_NTGUI */
4385 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4386 #endif /* HAVE_NS */
4391 init_color_table (void)
4394 #endif /* COLOR_TABLE_SUPPORT */
4397 /***********************************************************************
4399 ***********************************************************************/
4401 static XColor
*x_to_xcolors (struct frame
*, struct image
*, int);
4402 static void x_from_xcolors (struct frame
*, struct image
*, XColor
*);
4403 static void x_detect_edges (struct frame
*, struct image
*, int[9], int);
4406 static void XPutPixel (XImagePtr
, int, int, COLORREF
);
4407 #endif /* HAVE_NTGUI */
4409 /* Edge detection matrices for different edge-detection
4412 static int emboss_matrix
[9] = {
4414 2, -1, 0, /* y - 1 */
4416 0, 1, -2 /* y + 1 */
4419 static int laplace_matrix
[9] = {
4421 1, 0, 0, /* y - 1 */
4423 0, 0, -1 /* y + 1 */
4426 /* Value is the intensity of the color whose red/green/blue values
4429 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4432 /* On frame F, return an array of XColor structures describing image
4433 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4434 non-zero means also fill the red/green/blue members of the XColor
4435 structures. Value is a pointer to the array of XColors structures,
4436 allocated with xmalloc; it must be freed by the caller. */
4439 x_to_xcolors (struct frame
*f
, struct image
*img
, int rgb_p
)
4443 XImagePtr_or_DC ximg
;
4447 #endif /* HAVE_NTGUI */
4449 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *colors
/ img
->width
< img
->height
)
4450 memory_full (SIZE_MAX
);
4451 colors
= (XColor
*) xmalloc (sizeof *colors
* img
->width
* img
->height
);
4454 /* Get the X image IMG->pixmap. */
4455 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4456 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4458 /* Load the image into a memory device context. */
4459 hdc
= get_frame_dc (f
);
4460 ximg
= CreateCompatibleDC (hdc
);
4461 release_frame_dc (f
, hdc
);
4462 prev
= SelectObject (ximg
, img
->pixmap
);
4463 #endif /* HAVE_NTGUI */
4465 /* Fill the `pixel' members of the XColor array. I wished there
4466 were an easy and portable way to circumvent XGetPixel. */
4468 for (y
= 0; y
< img
->height
; ++y
)
4472 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
4473 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4474 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4476 x_query_colors (f
, row
, img
->width
);
4480 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4482 /* W32_TODO: palette support needed here? */
4483 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4486 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4487 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4488 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4491 #endif /* HAVE_X_WINDOWS */
4494 Destroy_Image (ximg
, prev
);
4501 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4502 created with CreateDIBSection, with the pointer to the bit values
4503 stored in ximg->data. */
4506 XPutPixel (XImagePtr ximg
, int x
, int y
, COLORREF color
)
4508 int width
= ximg
->info
.bmiHeader
.biWidth
;
4509 unsigned char * pixel
;
4511 /* True color images. */
4512 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4514 int rowbytes
= width
* 3;
4515 /* Ensure scanlines are aligned on 4 byte boundaries. */
4517 rowbytes
+= 4 - (rowbytes
% 4);
4519 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4520 /* Windows bitmaps are in BGR order. */
4521 *pixel
= GetBValue (color
);
4522 *(pixel
+ 1) = GetGValue (color
);
4523 *(pixel
+ 2) = GetRValue (color
);
4525 /* Monochrome images. */
4526 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4528 int rowbytes
= width
/ 8;
4529 /* Ensure scanlines are aligned on 4 byte boundaries. */
4531 rowbytes
+= 4 - (rowbytes
% 4);
4532 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4533 /* Filter out palette info. */
4534 if (color
& 0x00ffffff)
4535 *pixel
= *pixel
| (1 << x
% 8);
4537 *pixel
= *pixel
& ~(1 << x
% 8);
4540 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4543 #endif /* HAVE_NTGUI */
4545 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4546 RGB members are set. F is the frame on which this all happens.
4547 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4550 x_from_xcolors (struct frame
*f
, struct image
*img
, XColor
*colors
)
4553 XImagePtr oimg
= NULL
;
4557 init_color_table ();
4559 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
4562 for (y
= 0; y
< img
->height
; ++y
)
4563 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4565 unsigned long pixel
;
4566 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4567 XPutPixel (oimg
, x
, y
, pixel
);
4571 x_clear_image_1 (f
, img
, 1, 0, 1);
4573 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
4574 x_destroy_x_image (oimg
);
4575 img
->pixmap
= pixmap
;
4576 #ifdef COLOR_TABLE_SUPPORT
4577 img
->colors
= colors_in_color_table (&img
->ncolors
);
4578 free_color_table ();
4579 #endif /* COLOR_TABLE_SUPPORT */
4583 /* On frame F, perform edge-detection on image IMG.
4585 MATRIX is a nine-element array specifying the transformation
4586 matrix. See emboss_matrix for an example.
4588 COLOR_ADJUST is a color adjustment added to each pixel of the
4592 x_detect_edges (struct frame
*f
, struct image
*img
, int *matrix
, int color_adjust
)
4594 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4598 for (i
= sum
= 0; i
< 9; ++i
)
4599 sum
+= eabs (matrix
[i
]);
4601 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4603 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *new / img
->width
< img
->height
)
4604 memory_full (SIZE_MAX
);
4605 new = (XColor
*) xmalloc (sizeof *new * img
->width
* img
->height
);
4607 for (y
= 0; y
< img
->height
; ++y
)
4609 p
= COLOR (new, 0, y
);
4610 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4611 p
= COLOR (new, img
->width
- 1, y
);
4612 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4615 for (x
= 1; x
< img
->width
- 1; ++x
)
4617 p
= COLOR (new, x
, 0);
4618 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4619 p
= COLOR (new, x
, img
->height
- 1);
4620 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4623 for (y
= 1; y
< img
->height
- 1; ++y
)
4625 p
= COLOR (new, 1, y
);
4627 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4629 int r
, g
, b
, yy
, xx
;
4632 for (yy
= y
- 1; yy
< y
+ 2; ++yy
)
4633 for (xx
= x
- 1; xx
< x
+ 2; ++xx
, ++i
)
4636 XColor
*t
= COLOR (colors
, xx
, yy
);
4637 r
+= matrix
[i
] * t
->red
;
4638 g
+= matrix
[i
] * t
->green
;
4639 b
+= matrix
[i
] * t
->blue
;
4642 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4643 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4644 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4645 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4650 x_from_xcolors (f
, img
, new);
4656 /* Perform the pre-defined `emboss' edge-detection on image IMG
4660 x_emboss (struct frame
*f
, struct image
*img
)
4662 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4666 /* Transform image IMG which is used on frame F with a Laplace
4667 edge-detection algorithm. The result is an image that can be used
4668 to draw disabled buttons, for example. */
4671 x_laplace (struct frame
*f
, struct image
*img
)
4673 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4677 /* Perform edge-detection on image IMG on frame F, with specified
4678 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4680 MATRIX must be either
4682 - a list of at least 9 numbers in row-major form
4683 - a vector of at least 9 numbers
4685 COLOR_ADJUST nil means use a default; otherwise it must be a
4689 x_edge_detection (struct frame
*f
, struct image
*img
, Lisp_Object matrix
,
4690 Lisp_Object color_adjust
)
4698 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4699 ++i
, matrix
= XCDR (matrix
))
4700 trans
[i
] = XFLOATINT (XCAR (matrix
));
4702 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4704 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4705 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4708 if (NILP (color_adjust
))
4709 color_adjust
= make_number (0xffff / 2);
4711 if (i
== 9 && NUMBERP (color_adjust
))
4712 x_detect_edges (f
, img
, trans
, XFLOATINT (color_adjust
));
4716 /* Transform image IMG on frame F so that it looks disabled. */
4719 x_disable_image (struct frame
*f
, struct image
*img
)
4721 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4723 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4725 int n_planes
= dpyinfo
->n_planes
;
4726 #endif /* HAVE_NTGUI */
4730 /* Color (or grayscale). Convert to gray, and equalize. Just
4731 drawing such images with a stipple can look very odd, so
4732 we're using this method instead. */
4733 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4735 const int h
= 15000;
4736 const int l
= 30000;
4738 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4742 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4743 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4744 p
->red
= p
->green
= p
->blue
= i2
;
4747 x_from_xcolors (f
, img
, colors
);
4750 /* Draw a cross over the disabled image, if we must or if we
4752 if (n_planes
< 2 || cross_disabled_images
)
4755 Display
*dpy
= FRAME_X_DISPLAY (f
);
4758 #ifndef HAVE_NS /* TODO: NS support, however this not needed for toolbars */
4760 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4762 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
4763 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4764 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4765 img
->width
- 1, img
->height
- 1);
4766 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4772 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
4773 XSetForeground (dpy
, gc
, MaskForeground (f
));
4774 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4775 img
->width
- 1, img
->height
- 1);
4776 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4780 #endif /* !HAVE_NS */
4785 hdc
= get_frame_dc (f
);
4786 bmpdc
= CreateCompatibleDC (hdc
);
4787 release_frame_dc (f
, hdc
);
4789 prev
= SelectObject (bmpdc
, img
->pixmap
);
4791 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
4792 MoveToEx (bmpdc
, 0, 0, NULL
);
4793 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4794 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4795 LineTo (bmpdc
, img
->width
- 1, 0);
4799 SelectObject (bmpdc
, img
->mask
);
4800 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
4801 MoveToEx (bmpdc
, 0, 0, NULL
);
4802 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4803 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4804 LineTo (bmpdc
, img
->width
- 1, 0);
4806 SelectObject (bmpdc
, prev
);
4808 #endif /* HAVE_NTGUI */
4813 /* Build a mask for image IMG which is used on frame F. FILE is the
4814 name of an image file, for error messages. HOW determines how to
4815 determine the background color of IMG. If it is a list '(R G B)',
4816 with R, G, and B being integers >= 0, take that as the color of the
4817 background. Otherwise, determine the background color of IMG
4818 heuristically. Value is non-zero if successful. */
4821 x_build_heuristic_mask (struct frame
*f
, struct image
*img
, Lisp_Object how
)
4823 XImagePtr_or_DC ximg
;
4831 #endif /* HAVE_NTGUI */
4832 int x
, y
, rc
, use_img_background
;
4833 unsigned long bg
= 0;
4837 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4838 img
->mask
= NO_PIXMAP
;
4839 img
->background_transparent_valid
= 0;
4844 /* Create an image and pixmap serving as mask. */
4845 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
4846 &mask_img
, &img
->mask
);
4849 #endif /* !HAVE_NS */
4851 /* Get the X image of IMG->pixmap. */
4852 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
, 0, 0,
4853 img
->width
, img
->height
,
4856 /* Create the bit array serving as mask. */
4857 row_width
= (img
->width
+ 7) / 8;
4858 mask_img
= xmalloc (row_width
* img
->height
);
4859 memset (mask_img
, 0, row_width
* img
->height
);
4861 /* Create a memory device context for IMG->pixmap. */
4862 frame_dc
= get_frame_dc (f
);
4863 ximg
= CreateCompatibleDC (frame_dc
);
4864 release_frame_dc (f
, frame_dc
);
4865 prev
= SelectObject (ximg
, img
->pixmap
);
4866 #endif /* HAVE_NTGUI */
4868 /* Determine the background color of ximg. If HOW is `(R G B)'
4869 take that as color. Otherwise, use the image's background color. */
4870 use_img_background
= 1;
4876 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
4878 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
4882 if (i
== 3 && NILP (how
))
4884 char color_name
[30];
4885 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
4888 0x00ffffff & /* Filter out palette info. */
4889 #endif /* HAVE_NTGUI */
4890 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
4891 use_img_background
= 0;
4895 if (use_img_background
)
4896 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
4898 /* Set all bits in mask_img to 1 whose color in ximg is different
4899 from the background color bg. */
4901 for (y
= 0; y
< img
->height
; ++y
)
4902 for (x
= 0; x
< img
->width
; ++x
)
4904 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
4905 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
4907 if (XGetPixel (ximg
, x
, y
) == bg
)
4908 ns_set_alpha (ximg
, x
, y
, 0);
4909 #endif /* HAVE_NS */
4911 /* Fill in the background_transparent field while we have the mask handy. */
4912 image_background_transparent (img
, f
, mask_img
);
4914 /* Put mask_img into img->mask. */
4915 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
4916 x_destroy_x_image (mask_img
);
4917 #endif /* !HAVE_NS */
4919 for (y
= 0; y
< img
->height
; ++y
)
4920 for (x
= 0; x
< img
->width
; ++x
)
4922 COLORREF p
= GetPixel (ximg
, x
, y
);
4924 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
4927 /* Create the mask image. */
4928 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
4930 /* Fill in the background_transparent field while we have the mask handy. */
4931 SelectObject (ximg
, img
->mask
);
4932 image_background_transparent (img
, f
, ximg
);
4934 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
4936 #endif /* HAVE_NTGUI */
4938 Destroy_Image (ximg
, prev
);
4944 /***********************************************************************
4945 PBM (mono, gray, color)
4946 ***********************************************************************/
4948 static int pbm_image_p (Lisp_Object object
);
4949 static int pbm_load (struct frame
*f
, struct image
*img
);
4950 static int pbm_scan_number (unsigned char **, unsigned char *);
4952 /* The symbol `pbm' identifying images of this type. */
4954 static Lisp_Object Qpbm
;
4956 /* Indices of image specification fields in gs_format, below. */
4958 enum pbm_keyword_index
4974 /* Vector of image_keyword structures describing the format
4975 of valid user-defined image specifications. */
4977 static const struct image_keyword pbm_format
[PBM_LAST
] =
4979 {":type", IMAGE_SYMBOL_VALUE
, 1},
4980 {":file", IMAGE_STRING_VALUE
, 0},
4981 {":data", IMAGE_STRING_VALUE
, 0},
4982 {":ascent", IMAGE_ASCENT_VALUE
, 0},
4983 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
4984 {":relief", IMAGE_INTEGER_VALUE
, 0},
4985 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4986 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4987 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
4988 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
4989 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
4992 /* Structure describing the image type `pbm'. */
4994 static struct image_type pbm_type
=
5004 /* Return non-zero if OBJECT is a valid PBM image specification. */
5007 pbm_image_p (Lisp_Object object
)
5009 struct image_keyword fmt
[PBM_LAST
];
5011 memcpy (fmt
, pbm_format
, sizeof fmt
);
5013 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5016 /* Must specify either :data or :file. */
5017 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5021 /* Scan a decimal number from *S and return it. Advance *S while
5022 reading the number. END is the end of the string. Value is -1 at
5026 pbm_scan_number (unsigned char **s
, unsigned char *end
)
5028 int c
= 0, val
= -1;
5032 /* Skip white-space. */
5033 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5038 /* Skip comment to end of line. */
5039 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
5042 else if (isdigit (c
))
5044 /* Read decimal number. */
5046 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
5047 val
= 10 * val
+ c
- '0';
5059 #if 0 /* Unused. ++kfs */
5061 /* Read FILE into memory. Value is a pointer to a buffer allocated
5062 with xmalloc holding FILE's contents. Value is null if an error
5063 occurred. *SIZE is set to the size of the file. */
5066 pbm_read_file (Lisp_Object file
, int *size
)
5072 if (stat (SDATA (file
), &st
) == 0
5073 && (fp
= fopen (SDATA (file
), "rb")) != NULL
5074 && 0 <= st
.st_size
&& st
.st_size
<= min (PTRDIFF_MAX
, SIZE_MAX
)
5075 && (buf
= (char *) xmalloc (st
.st_size
),
5076 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5095 #endif /* HAVE_NTGUI */
5097 /* Load PBM image IMG for use on frame F. */
5100 pbm_load (struct frame
*f
, struct image
*img
)
5103 int width
, height
, max_color_idx
= 0;
5105 Lisp_Object file
, specified_file
;
5106 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5107 unsigned char *contents
= NULL
;
5108 unsigned char *end
, *p
;
5111 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5113 if (STRINGP (specified_file
))
5115 file
= x_find_image_file (specified_file
);
5116 if (!STRINGP (file
))
5118 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5122 contents
= slurp_file (SSDATA (file
), &size
);
5123 if (contents
== NULL
)
5125 image_error ("Error reading `%s'", file
, Qnil
);
5130 end
= contents
+ size
;
5135 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5136 if (!STRINGP (data
))
5138 image_error ("Invalid image data `%s'", data
, Qnil
);
5142 end
= p
+ SBYTES (data
);
5145 /* Check magic number. */
5146 if (end
- p
< 2 || *p
++ != 'P')
5148 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5157 raw_p
= 0, type
= PBM_MONO
;
5161 raw_p
= 0, type
= PBM_GRAY
;
5165 raw_p
= 0, type
= PBM_COLOR
;
5169 raw_p
= 1, type
= PBM_MONO
;
5173 raw_p
= 1, type
= PBM_GRAY
;
5177 raw_p
= 1, type
= PBM_COLOR
;
5181 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5185 /* Read width, height, maximum color-component. Characters
5186 starting with `#' up to the end of a line are ignored. */
5187 width
= pbm_scan_number (&p
, end
);
5188 height
= pbm_scan_number (&p
, end
);
5190 if (type
!= PBM_MONO
)
5192 max_color_idx
= pbm_scan_number (&p
, end
);
5193 if (max_color_idx
> 65535 || max_color_idx
< 0)
5195 image_error ("Unsupported maximum PBM color value", Qnil
, Qnil
);
5200 if (!check_image_size (f
, width
, height
))
5202 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5206 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
5207 &ximg
, &img
->pixmap
))
5210 /* Initialize the color hash table. */
5211 init_color_table ();
5213 if (type
== PBM_MONO
)
5216 struct image_keyword fmt
[PBM_LAST
];
5217 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5218 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5220 /* Parse the image specification. */
5221 memcpy (fmt
, pbm_format
, sizeof fmt
);
5222 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5224 /* Get foreground and background colors, maybe allocate colors. */
5225 if (fmt
[PBM_FOREGROUND
].count
5226 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5227 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5228 if (fmt
[PBM_BACKGROUND
].count
5229 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5231 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5232 img
->background
= bg
;
5233 img
->background_valid
= 1;
5236 for (y
= 0; y
< height
; ++y
)
5237 for (x
= 0; x
< width
; ++x
)
5245 x_destroy_x_image (ximg
);
5246 x_clear_image (f
, img
);
5247 image_error ("Invalid image size in image `%s'",
5257 g
= pbm_scan_number (&p
, end
);
5259 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5264 int expected_size
= height
* width
;
5265 if (max_color_idx
> 255)
5267 if (type
== PBM_COLOR
)
5270 if (raw_p
&& p
+ expected_size
> end
)
5272 x_destroy_x_image (ximg
);
5273 x_clear_image (f
, img
);
5274 image_error ("Invalid image size in image `%s'",
5279 for (y
= 0; y
< height
; ++y
)
5280 for (x
= 0; x
< width
; ++x
)
5284 if (type
== PBM_GRAY
&& raw_p
)
5287 if (max_color_idx
> 255)
5288 r
= g
= b
= r
* 256 + *p
++;
5290 else if (type
== PBM_GRAY
)
5291 r
= g
= b
= pbm_scan_number (&p
, end
);
5295 if (max_color_idx
> 255)
5298 if (max_color_idx
> 255)
5301 if (max_color_idx
> 255)
5306 r
= pbm_scan_number (&p
, end
);
5307 g
= pbm_scan_number (&p
, end
);
5308 b
= pbm_scan_number (&p
, end
);
5311 if (r
< 0 || g
< 0 || b
< 0)
5313 x_destroy_x_image (ximg
);
5314 image_error ("Invalid pixel value in image `%s'",
5319 /* RGB values are now in the range 0..max_color_idx.
5320 Scale this to the range 0..0xffff supported by X. */
5321 r
= (double) r
* 65535 / max_color_idx
;
5322 g
= (double) g
* 65535 / max_color_idx
;
5323 b
= (double) b
* 65535 / max_color_idx
;
5324 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5328 #ifdef COLOR_TABLE_SUPPORT
5329 /* Store in IMG->colors the colors allocated for the image, and
5330 free the color table. */
5331 img
->colors
= colors_in_color_table (&img
->ncolors
);
5332 free_color_table ();
5333 #endif /* COLOR_TABLE_SUPPORT */
5336 img
->height
= height
;
5338 /* Maybe fill in the background field while we have ximg handy. */
5340 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5341 /* Casting avoids a GCC warning. */
5342 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5344 /* Put the image into a pixmap. */
5345 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5346 x_destroy_x_image (ximg
);
5348 /* X and W32 versions did it here, MAC version above. ++kfs
5350 img->height = height; */
5357 /***********************************************************************
5359 ***********************************************************************/
5361 #if defined (HAVE_PNG) || defined (HAVE_NS)
5363 /* Function prototypes. */
5365 static int png_image_p (Lisp_Object object
);
5366 static int png_load (struct frame
*f
, struct image
*img
);
5368 /* The symbol `png' identifying images of this type. */
5370 static Lisp_Object Qpng
;
5372 /* Indices of image specification fields in png_format, below. */
5374 enum png_keyword_index
5389 /* Vector of image_keyword structures describing the format
5390 of valid user-defined image specifications. */
5392 static const struct image_keyword png_format
[PNG_LAST
] =
5394 {":type", IMAGE_SYMBOL_VALUE
, 1},
5395 {":data", IMAGE_STRING_VALUE
, 0},
5396 {":file", IMAGE_STRING_VALUE
, 0},
5397 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5398 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5399 {":relief", IMAGE_INTEGER_VALUE
, 0},
5400 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5401 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5402 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5403 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5406 /* Structure describing the image type `png'. */
5408 static struct image_type png_type
=
5417 /* Return non-zero if OBJECT is a valid PNG image specification. */
5420 png_image_p (Lisp_Object object
)
5422 struct image_keyword fmt
[PNG_LAST
];
5423 memcpy (fmt
, png_format
, sizeof fmt
);
5425 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5428 /* Must specify either the :data or :file keyword. */
5429 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5432 #endif /* HAVE_PNG || HAVE_NS */
5438 /* PNG library details. */
5440 DEF_IMGLIB_FN (png_voidp
, png_get_io_ptr
, (png_structp
));
5441 DEF_IMGLIB_FN (int, png_sig_cmp
, (png_bytep
, png_size_t
, png_size_t
));
5442 DEF_IMGLIB_FN (png_structp
, png_create_read_struct
, (png_const_charp
, png_voidp
,
5443 png_error_ptr
, png_error_ptr
));
5444 DEF_IMGLIB_FN (png_infop
, png_create_info_struct
, (png_structp
));
5445 DEF_IMGLIB_FN (void, png_destroy_read_struct
, (png_structpp
, png_infopp
, png_infopp
));
5446 DEF_IMGLIB_FN (void, png_set_read_fn
, (png_structp
, png_voidp
, png_rw_ptr
));
5447 DEF_IMGLIB_FN (void, png_set_sig_bytes
, (png_structp
, int));
5448 DEF_IMGLIB_FN (void, png_read_info
, (png_structp
, png_infop
));
5449 DEF_IMGLIB_FN (png_uint_32
, png_get_IHDR
, (png_structp
, png_infop
,
5450 png_uint_32
*, png_uint_32
*,
5451 int *, int *, int *, int *, int *));
5452 DEF_IMGLIB_FN (png_uint_32
, png_get_valid
, (png_structp
, png_infop
, png_uint_32
));
5453 DEF_IMGLIB_FN (void, png_set_strip_16
, (png_structp
));
5454 DEF_IMGLIB_FN (void, png_set_expand
, (png_structp
));
5455 DEF_IMGLIB_FN (void, png_set_gray_to_rgb
, (png_structp
));
5456 DEF_IMGLIB_FN (void, png_set_background
, (png_structp
, png_color_16p
,
5458 DEF_IMGLIB_FN (png_uint_32
, png_get_bKGD
, (png_structp
, png_infop
, png_color_16p
*));
5459 DEF_IMGLIB_FN (void, png_read_update_info
, (png_structp
, png_infop
));
5460 DEF_IMGLIB_FN (png_byte
, png_get_channels
, (png_structp
, png_infop
));
5461 DEF_IMGLIB_FN (png_size_t
, png_get_rowbytes
, (png_structp
, png_infop
));
5462 DEF_IMGLIB_FN (void, png_read_image
, (png_structp
, png_bytepp
));
5463 DEF_IMGLIB_FN (void, png_read_end
, (png_structp
, png_infop
));
5464 DEF_IMGLIB_FN (void, png_error
, (png_structp
, png_const_charp
));
5466 #if (PNG_LIBPNG_VER >= 10500)
5467 DEF_IMGLIB_FN (void, png_longjmp
, (png_structp
, int));
5468 DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn
, (png_structp
, png_longjmp_ptr
, size_t));
5469 #endif /* libpng version >= 1.5 */
5472 init_png_functions (Lisp_Object libraries
)
5476 if (!(library
= w32_delayed_load (libraries
, Qpng
)))
5479 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5480 LOAD_IMGLIB_FN (library
, png_sig_cmp
);
5481 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5482 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5483 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5484 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5485 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5486 LOAD_IMGLIB_FN (library
, png_read_info
);
5487 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5488 LOAD_IMGLIB_FN (library
, png_get_valid
);
5489 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5490 LOAD_IMGLIB_FN (library
, png_set_expand
);
5491 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5492 LOAD_IMGLIB_FN (library
, png_set_background
);
5493 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5494 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5495 LOAD_IMGLIB_FN (library
, png_get_channels
);
5496 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5497 LOAD_IMGLIB_FN (library
, png_read_image
);
5498 LOAD_IMGLIB_FN (library
, png_read_end
);
5499 LOAD_IMGLIB_FN (library
, png_error
);
5501 #if (PNG_LIBPNG_VER >= 10500)
5502 LOAD_IMGLIB_FN (library
, png_longjmp
);
5503 LOAD_IMGLIB_FN (library
, png_set_longjmp_fn
);
5504 #endif /* libpng version >= 1.5 */
5510 #define fn_png_get_io_ptr png_get_io_ptr
5511 #define fn_png_sig_cmp png_sig_cmp
5512 #define fn_png_create_read_struct png_create_read_struct
5513 #define fn_png_create_info_struct png_create_info_struct
5514 #define fn_png_destroy_read_struct png_destroy_read_struct
5515 #define fn_png_set_read_fn png_set_read_fn
5516 #define fn_png_set_sig_bytes png_set_sig_bytes
5517 #define fn_png_read_info png_read_info
5518 #define fn_png_get_IHDR png_get_IHDR
5519 #define fn_png_get_valid png_get_valid
5520 #define fn_png_set_strip_16 png_set_strip_16
5521 #define fn_png_set_expand png_set_expand
5522 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5523 #define fn_png_set_background png_set_background
5524 #define fn_png_get_bKGD png_get_bKGD
5525 #define fn_png_read_update_info png_read_update_info
5526 #define fn_png_get_channels png_get_channels
5527 #define fn_png_get_rowbytes png_get_rowbytes
5528 #define fn_png_read_image png_read_image
5529 #define fn_png_read_end png_read_end
5530 #define fn_png_error png_error
5532 #if (PNG_LIBPNG_VER >= 10500)
5533 #define fn_png_longjmp png_longjmp
5534 #define fn_png_set_longjmp_fn png_set_longjmp_fn
5535 #endif /* libpng version >= 1.5 */
5537 #endif /* HAVE_NTGUI */
5540 #if (PNG_LIBPNG_VER < 10500)
5541 #define PNG_LONGJMP(ptr) (longjmp ((ptr)->jmpbuf, 1))
5542 #define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
5544 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908) */
5545 #define PNG_LONGJMP(ptr) (fn_png_longjmp ((ptr), 1))
5546 #define PNG_JMPBUF(ptr) \
5547 (*fn_png_set_longjmp_fn((ptr), longjmp, sizeof (jmp_buf)))
5550 /* Error and warning handlers installed when the PNG library
5553 static void my_png_error (png_struct
*, const char *) NO_RETURN
;
5555 my_png_error (png_struct
*png_ptr
, const char *msg
)
5557 xassert (png_ptr
!= NULL
);
5558 /* Avoid compiler warning about deprecated direct access to
5559 png_ptr's fields in libpng versions 1.4.x. */
5560 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5561 PNG_LONGJMP (png_ptr
);
5566 my_png_warning (png_struct
*png_ptr
, const char *msg
)
5568 xassert (png_ptr
!= NULL
);
5569 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5572 /* Memory source for PNG decoding. */
5574 struct png_memory_storage
5576 unsigned char *bytes
; /* The data */
5577 ptrdiff_t len
; /* How big is it? */
5578 ptrdiff_t index
; /* Where are we? */
5582 /* Function set as reader function when reading PNG image from memory.
5583 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5584 bytes from the input to DATA. */
5587 png_read_from_memory (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5589 struct png_memory_storage
*tbr
5590 = (struct png_memory_storage
*) fn_png_get_io_ptr (png_ptr
);
5592 if (length
> tbr
->len
- tbr
->index
)
5593 fn_png_error (png_ptr
, "Read error");
5595 memcpy (data
, tbr
->bytes
+ tbr
->index
, length
);
5596 tbr
->index
= tbr
->index
+ length
;
5600 /* Function set as reader function when reading PNG image from a file.
5601 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5602 bytes from the input to DATA. */
5605 png_read_from_file (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5607 FILE *fp
= (FILE *) fn_png_get_io_ptr (png_ptr
);
5609 if (fread (data
, 1, length
, fp
) < length
)
5610 fn_png_error (png_ptr
, "Read error");
5614 /* Load PNG image IMG for use on frame F. Value is non-zero if
5618 png_load (struct frame
*f
, struct image
*img
)
5620 Lisp_Object file
, specified_file
;
5621 Lisp_Object specified_data
;
5624 XImagePtr ximg
, mask_img
= NULL
;
5625 png_struct
*png_ptr
= NULL
;
5626 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5627 FILE *volatile fp
= NULL
;
5629 png_byte
* volatile pixels
= NULL
;
5630 png_byte
** volatile rows
= NULL
;
5631 png_uint_32 width
, height
;
5632 int bit_depth
, color_type
, interlace_type
;
5634 png_uint_32 row_bytes
;
5636 struct png_memory_storage tbr
; /* Data to be read */
5638 /* Find out what file to load. */
5639 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5640 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5642 if (NILP (specified_data
))
5644 file
= x_find_image_file (specified_file
);
5645 if (!STRINGP (file
))
5647 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5651 /* Open the image file. */
5652 fp
= fopen (SSDATA (file
), "rb");
5655 image_error ("Cannot open image file `%s'", file
, Qnil
);
5659 /* Check PNG signature. */
5660 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5661 || fn_png_sig_cmp (sig
, 0, sizeof sig
))
5663 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5670 if (!STRINGP (specified_data
))
5672 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
5676 /* Read from memory. */
5677 tbr
.bytes
= SDATA (specified_data
);
5678 tbr
.len
= SBYTES (specified_data
);
5681 /* Check PNG signature. */
5682 if (tbr
.len
< sizeof sig
5683 || fn_png_sig_cmp (tbr
.bytes
, 0, sizeof sig
))
5685 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5689 /* Need to skip past the signature. */
5690 tbr
.bytes
+= sizeof (sig
);
5693 /* Initialize read and info structs for PNG lib. */
5694 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5699 if (fp
) fclose (fp
);
5703 info_ptr
= fn_png_create_info_struct (png_ptr
);
5706 fn_png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
5707 if (fp
) fclose (fp
);
5711 end_info
= fn_png_create_info_struct (png_ptr
);
5714 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
5715 if (fp
) fclose (fp
);
5719 /* Set error jump-back. We come back here when the PNG library
5720 detects an error. */
5721 if (setjmp (PNG_JMPBUF (png_ptr
)))
5725 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5728 if (fp
) fclose (fp
);
5732 /* Read image info. */
5733 if (!NILP (specified_data
))
5734 fn_png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
5736 fn_png_set_read_fn (png_ptr
, (void *) fp
, png_read_from_file
);
5738 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5739 fn_png_read_info (png_ptr
, info_ptr
);
5740 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5741 &interlace_type
, NULL
, NULL
);
5743 if (! (width
<= INT_MAX
&& height
<= INT_MAX
5744 && check_image_size (f
, width
, height
)))
5746 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5750 /* Create the X image and pixmap now, so that the work below can be
5751 omitted if the image is too large for X. */
5752 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
5756 /* If image contains simply transparency data, we prefer to
5757 construct a clipping mask. */
5758 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5763 /* This function is easier to write if we only have to handle
5764 one data format: RGB or RGBA with 8 bits per channel. Let's
5765 transform other formats into that format. */
5767 /* Strip more than 8 bits per channel. */
5768 if (bit_depth
== 16)
5769 fn_png_set_strip_16 (png_ptr
);
5771 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5773 fn_png_set_expand (png_ptr
);
5775 /* Convert grayscale images to RGB. */
5776 if (color_type
== PNG_COLOR_TYPE_GRAY
5777 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5778 fn_png_set_gray_to_rgb (png_ptr
);
5780 /* Handle alpha channel by combining the image with a background
5781 color. Do this only if a real alpha channel is supplied. For
5782 simple transparency, we prefer a clipping mask. */
5785 /* png_color_16 *image_bg; */
5786 Lisp_Object specified_bg
5787 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5788 int shift
= (bit_depth
== 16) ? 0 : 8;
5790 if (STRINGP (specified_bg
))
5791 /* The user specified `:background', use that. */
5794 if (x_defined_color (f
, SSDATA (specified_bg
), &color
, 0))
5796 png_color_16 user_bg
;
5798 memset (&user_bg
, 0, sizeof user_bg
);
5799 user_bg
.red
= color
.red
>> shift
;
5800 user_bg
.green
= color
.green
>> shift
;
5801 user_bg
.blue
= color
.blue
>> shift
;
5803 fn_png_set_background (png_ptr
, &user_bg
,
5804 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5809 /* We use the current frame background, ignoring any default
5810 background color set by the image. */
5811 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
5813 png_color_16 frame_background
;
5815 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
5816 x_query_color (f
, &color
);
5818 memset (&frame_background
, 0, sizeof frame_background
);
5819 frame_background
.red
= color
.red
>> shift
;
5820 frame_background
.green
= color
.green
>> shift
;
5821 frame_background
.blue
= color
.blue
>> shift
;
5822 #endif /* HAVE_X_WINDOWS */
5824 fn_png_set_background (png_ptr
, &frame_background
,
5825 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5829 /* Update info structure. */
5830 fn_png_read_update_info (png_ptr
, info_ptr
);
5832 /* Get number of channels. Valid values are 1 for grayscale images
5833 and images with a palette, 2 for grayscale images with transparency
5834 information (alpha channel), 3 for RGB images, and 4 for RGB
5835 images with alpha channel, i.e. RGBA. If conversions above were
5836 sufficient we should only have 3 or 4 channels here. */
5837 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
5838 xassert (channels
== 3 || channels
== 4);
5840 /* Number of bytes needed for one row of the image. */
5841 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
5843 /* Allocate memory for the image. */
5844 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *rows
< height
5845 || min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *pixels
/ height
< row_bytes
)
5846 memory_full (SIZE_MAX
);
5847 pixels
= (png_byte
*) xmalloc (sizeof *pixels
* row_bytes
* height
);
5848 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
5849 for (i
= 0; i
< height
; ++i
)
5850 rows
[i
] = pixels
+ i
* row_bytes
;
5852 /* Read the entire image. */
5853 fn_png_read_image (png_ptr
, rows
);
5854 fn_png_read_end (png_ptr
, info_ptr
);
5861 /* Create an image and pixmap serving as mask if the PNG image
5862 contains an alpha channel. */
5865 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
5866 &mask_img
, &img
->mask
))
5868 x_destroy_x_image (ximg
);
5869 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
5870 img
->pixmap
= NO_PIXMAP
;
5874 /* Fill the X image and mask from PNG data. */
5875 init_color_table ();
5877 for (y
= 0; y
< height
; ++y
)
5879 png_byte
*p
= rows
[y
];
5881 for (x
= 0; x
< width
; ++x
)
5888 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5889 /* An alpha channel, aka mask channel, associates variable
5890 transparency with an image. Where other image formats
5891 support binary transparency---fully transparent or fully
5892 opaque---PNG allows up to 254 levels of partial transparency.
5893 The PNG library implements partial transparency by combining
5894 the image with a specified background color.
5896 I'm not sure how to handle this here nicely: because the
5897 background on which the image is displayed may change, for
5898 real alpha channel support, it would be necessary to create
5899 a new image for each possible background.
5901 What I'm doing now is that a mask is created if we have
5902 boolean transparency information. Otherwise I'm using
5903 the frame's background color to combine the image with. */
5908 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
5914 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5915 /* Set IMG's background color from the PNG image, unless the user
5919 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
5921 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
5922 img
->background_valid
= 1;
5926 #ifdef COLOR_TABLE_SUPPORT
5927 /* Remember colors allocated for this image. */
5928 img
->colors
= colors_in_color_table (&img
->ncolors
);
5929 free_color_table ();
5930 #endif /* COLOR_TABLE_SUPPORT */
5933 fn_png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
5938 img
->height
= height
;
5940 /* Maybe fill in the background field while we have ximg handy.
5941 Casting avoids a GCC warning. */
5942 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5944 /* Put the image into the pixmap, then free the X image and its buffer. */
5945 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
5946 x_destroy_x_image (ximg
);
5948 /* Same for the mask. */
5951 /* Fill in the background_transparent field while we have the
5952 mask handy. Casting avoids a GCC warning. */
5953 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
5955 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
5956 x_destroy_x_image (mask_img
);
5962 #else /* HAVE_PNG */
5966 png_load (struct frame
*f
, struct image
*img
)
5968 return ns_load_image(f
, img
,
5969 image_spec_value (img
->spec
, QCfile
, NULL
),
5970 image_spec_value (img
->spec
, QCdata
, NULL
));
5972 #endif /* HAVE_NS */
5975 #endif /* !HAVE_PNG */
5979 /***********************************************************************
5981 ***********************************************************************/
5983 #if defined (HAVE_JPEG) || defined (HAVE_NS)
5985 static int jpeg_image_p (Lisp_Object object
);
5986 static int jpeg_load (struct frame
*f
, struct image
*img
);
5988 /* The symbol `jpeg' identifying images of this type. */
5990 static Lisp_Object Qjpeg
;
5992 /* Indices of image specification fields in gs_format, below. */
5994 enum jpeg_keyword_index
6003 JPEG_HEURISTIC_MASK
,
6009 /* Vector of image_keyword structures describing the format
6010 of valid user-defined image specifications. */
6012 static const struct image_keyword jpeg_format
[JPEG_LAST
] =
6014 {":type", IMAGE_SYMBOL_VALUE
, 1},
6015 {":data", IMAGE_STRING_VALUE
, 0},
6016 {":file", IMAGE_STRING_VALUE
, 0},
6017 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6018 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6019 {":relief", IMAGE_INTEGER_VALUE
, 0},
6020 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6021 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6022 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6023 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6026 /* Structure describing the image type `jpeg'. */
6028 static struct image_type jpeg_type
=
6037 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6040 jpeg_image_p (Lisp_Object object
)
6042 struct image_keyword fmt
[JPEG_LAST
];
6044 memcpy (fmt
, jpeg_format
, sizeof fmt
);
6046 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6049 /* Must specify either the :data or :file keyword. */
6050 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6053 #endif /* HAVE_JPEG || HAVE_NS */
6057 /* Work around a warning about HAVE_STDLIB_H being redefined in
6059 #ifdef HAVE_STDLIB_H
6060 #undef HAVE_STDLIB_H
6061 #endif /* HAVE_STLIB_H */
6063 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6064 /* In older releases of the jpeg library, jpeglib.h will define boolean
6065 differently depending on __WIN32__, so make sure it is defined. */
6069 #include <jpeglib.h>
6072 #ifdef HAVE_STLIB_H_1
6073 #define HAVE_STDLIB_H 1
6078 /* JPEG library details. */
6079 DEF_IMGLIB_FN (void, jpeg_CreateDecompress
, (j_decompress_ptr
, int, size_t));
6080 DEF_IMGLIB_FN (boolean
, jpeg_start_decompress
, (j_decompress_ptr
));
6081 DEF_IMGLIB_FN (boolean
, jpeg_finish_decompress
, (j_decompress_ptr
));
6082 DEF_IMGLIB_FN (void, jpeg_destroy_decompress
, (j_decompress_ptr
));
6083 DEF_IMGLIB_FN (int, jpeg_read_header
, (j_decompress_ptr
, boolean
));
6084 DEF_IMGLIB_FN (JDIMENSION
, jpeg_read_scanlines
, (j_decompress_ptr
, JSAMPARRAY
, JDIMENSION
));
6085 DEF_IMGLIB_FN (struct jpeg_error_mgr
*, jpeg_std_error
, (struct jpeg_error_mgr
*));
6086 DEF_IMGLIB_FN (boolean
, jpeg_resync_to_restart
, (j_decompress_ptr
, int));
6089 init_jpeg_functions (Lisp_Object libraries
)
6093 if (!(library
= w32_delayed_load (libraries
, Qjpeg
)))
6096 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6097 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6098 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6099 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6100 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6101 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6102 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6103 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6107 /* Wrapper since we can't directly assign the function pointer
6108 to another function pointer that was declared more completely easily. */
6110 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo
, int desired
)
6112 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6117 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6118 #define fn_jpeg_start_decompress jpeg_start_decompress
6119 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6120 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6121 #define fn_jpeg_read_header jpeg_read_header
6122 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6123 #define fn_jpeg_std_error jpeg_std_error
6124 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6126 #endif /* HAVE_NTGUI */
6128 struct my_jpeg_error_mgr
6130 struct jpeg_error_mgr pub
;
6131 jmp_buf setjmp_buffer
;
6135 static void my_error_exit (j_common_ptr
) NO_RETURN
;
6137 my_error_exit (j_common_ptr cinfo
)
6139 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6140 longjmp (mgr
->setjmp_buffer
, 1);
6144 /* Init source method for JPEG data source manager. Called by
6145 jpeg_read_header() before any data is actually read. See
6146 libjpeg.doc from the JPEG lib distribution. */
6149 our_common_init_source (j_decompress_ptr cinfo
)
6154 /* Method to terminate data source. Called by
6155 jpeg_finish_decompress() after all data has been processed. */
6158 our_common_term_source (j_decompress_ptr cinfo
)
6163 /* Fill input buffer method for JPEG data source manager. Called
6164 whenever more data is needed. We read the whole image in one step,
6165 so this only adds a fake end of input marker at the end. */
6167 static JOCTET our_memory_buffer
[2];
6170 our_memory_fill_input_buffer (j_decompress_ptr cinfo
)
6172 /* Insert a fake EOI marker. */
6173 struct jpeg_source_mgr
*src
= cinfo
->src
;
6175 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6176 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6178 src
->next_input_byte
= our_memory_buffer
;
6179 src
->bytes_in_buffer
= 2;
6184 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6185 is the JPEG data source manager. */
6188 our_memory_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6190 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6194 if (num_bytes
> src
->bytes_in_buffer
)
6195 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6197 src
->bytes_in_buffer
-= num_bytes
;
6198 src
->next_input_byte
+= num_bytes
;
6203 /* Set up the JPEG lib for reading an image from DATA which contains
6204 LEN bytes. CINFO is the decompression info structure created for
6205 reading the image. */
6208 jpeg_memory_src (j_decompress_ptr cinfo
, JOCTET
*data
, unsigned int len
)
6210 struct jpeg_source_mgr
*src
;
6212 if (cinfo
->src
== NULL
)
6214 /* First time for this JPEG object? */
6215 cinfo
->src
= (struct jpeg_source_mgr
*)
6216 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6217 sizeof (struct jpeg_source_mgr
));
6218 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6219 src
->next_input_byte
= data
;
6222 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
6223 src
->init_source
= our_common_init_source
;
6224 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6225 src
->skip_input_data
= our_memory_skip_input_data
;
6226 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6227 src
->term_source
= our_common_term_source
;
6228 src
->bytes_in_buffer
= len
;
6229 src
->next_input_byte
= data
;
6233 struct jpeg_stdio_mgr
6235 struct jpeg_source_mgr mgr
;
6242 /* Size of buffer to read JPEG from file.
6243 Not too big, as we want to use alloc_small. */
6244 #define JPEG_STDIO_BUFFER_SIZE 8192
6247 /* Fill input buffer method for JPEG data source manager. Called
6248 whenever more data is needed. The data is read from a FILE *. */
6251 our_stdio_fill_input_buffer (j_decompress_ptr cinfo
)
6253 struct jpeg_stdio_mgr
*src
;
6255 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6260 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6262 src
->mgr
.bytes_in_buffer
= bytes
;
6265 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6267 src
->buffer
[0] = (JOCTET
) 0xFF;
6268 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6269 src
->mgr
.bytes_in_buffer
= 2;
6271 src
->mgr
.next_input_byte
= src
->buffer
;
6278 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6279 is the JPEG data source manager. */
6282 our_stdio_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6284 struct jpeg_stdio_mgr
*src
;
6285 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6287 while (num_bytes
> 0 && !src
->finished
)
6289 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6291 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6292 src
->mgr
.next_input_byte
+= num_bytes
;
6297 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6298 src
->mgr
.bytes_in_buffer
= 0;
6299 src
->mgr
.next_input_byte
= NULL
;
6301 our_stdio_fill_input_buffer (cinfo
);
6307 /* Set up the JPEG lib for reading an image from a FILE *.
6308 CINFO is the decompression info structure created for
6309 reading the image. */
6312 jpeg_file_src (j_decompress_ptr cinfo
, FILE *fp
)
6314 struct jpeg_stdio_mgr
*src
;
6316 if (cinfo
->src
!= NULL
)
6317 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6320 /* First time for this JPEG object? */
6321 cinfo
->src
= (struct jpeg_source_mgr
*)
6322 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6323 sizeof (struct jpeg_stdio_mgr
));
6324 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6325 src
->buffer
= (JOCTET
*)
6326 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
6327 JPEG_STDIO_BUFFER_SIZE
);
6332 src
->mgr
.init_source
= our_common_init_source
;
6333 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6334 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6335 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6336 src
->mgr
.term_source
= our_common_term_source
;
6337 src
->mgr
.bytes_in_buffer
= 0;
6338 src
->mgr
.next_input_byte
= NULL
;
6342 /* Load image IMG for use on frame F. Patterned after example.c
6343 from the JPEG lib. */
6346 jpeg_load (struct frame
*f
, struct image
*img
)
6348 struct jpeg_decompress_struct cinfo
;
6349 struct my_jpeg_error_mgr mgr
;
6350 Lisp_Object file
, specified_file
;
6351 Lisp_Object specified_data
;
6352 FILE * volatile fp
= NULL
;
6354 int row_stride
, x
, y
;
6355 XImagePtr ximg
= NULL
;
6357 unsigned long *colors
;
6360 /* Open the JPEG file. */
6361 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6362 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6364 if (NILP (specified_data
))
6366 file
= x_find_image_file (specified_file
);
6367 if (!STRINGP (file
))
6369 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6373 fp
= fopen (SSDATA (file
), "rb");
6376 image_error ("Cannot open `%s'", file
, Qnil
);
6380 else if (!STRINGP (specified_data
))
6382 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6386 /* Customize libjpeg's error handling to call my_error_exit when an
6387 error is detected. This function will perform a longjmp. */
6388 cinfo
.err
= fn_jpeg_std_error (&mgr
.pub
);
6389 mgr
.pub
.error_exit
= my_error_exit
;
6391 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
6395 /* Called from my_error_exit. Display a JPEG error. */
6396 char buf
[JMSG_LENGTH_MAX
];
6397 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buf
);
6398 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6399 build_string (buf
));
6402 /* Close the input file and destroy the JPEG object. */
6404 fclose ((FILE *) fp
);
6405 fn_jpeg_destroy_decompress (&cinfo
);
6407 /* If we already have an XImage, free that. */
6408 x_destroy_x_image (ximg
);
6410 /* Free pixmap and colors. */
6411 x_clear_image (f
, img
);
6415 /* Create the JPEG decompression object. Let it read from fp.
6416 Read the JPEG image header. */
6417 fn_jpeg_CreateDecompress (&cinfo
, JPEG_LIB_VERSION
, sizeof (cinfo
));
6419 if (NILP (specified_data
))
6420 jpeg_file_src (&cinfo
, (FILE *) fp
);
6422 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
6423 SBYTES (specified_data
));
6425 fn_jpeg_read_header (&cinfo
, 1);
6427 /* Customize decompression so that color quantization will be used.
6428 Start decompression. */
6429 cinfo
.quantize_colors
= 1;
6430 fn_jpeg_start_decompress (&cinfo
);
6431 width
= img
->width
= cinfo
.output_width
;
6432 height
= img
->height
= cinfo
.output_height
;
6434 if (!check_image_size (f
, width
, height
))
6436 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6437 longjmp (mgr
.setjmp_buffer
, 2);
6440 /* Create X image and pixmap. */
6441 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
6442 longjmp (mgr
.setjmp_buffer
, 2);
6444 /* Allocate colors. When color quantization is used,
6445 cinfo.actual_number_of_colors has been set with the number of
6446 colors generated, and cinfo.colormap is a two-dimensional array
6447 of color indices in the range 0..cinfo.actual_number_of_colors.
6448 No more than 255 colors will be generated. */
6452 if (cinfo
.out_color_components
> 2)
6453 ir
= 0, ig
= 1, ib
= 2;
6454 else if (cinfo
.out_color_components
> 1)
6455 ir
= 0, ig
= 1, ib
= 0;
6457 ir
= 0, ig
= 0, ib
= 0;
6459 /* Use the color table mechanism because it handles colors that
6460 cannot be allocated nicely. Such colors will be replaced with
6461 a default color, and we don't have to care about which colors
6462 can be freed safely, and which can't. */
6463 init_color_table ();
6464 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
6467 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
6469 /* Multiply RGB values with 255 because X expects RGB values
6470 in the range 0..0xffff. */
6471 int r
= cinfo
.colormap
[ir
][i
] << 8;
6472 int g
= cinfo
.colormap
[ig
][i
] << 8;
6473 int b
= cinfo
.colormap
[ib
][i
] << 8;
6474 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6477 #ifdef COLOR_TABLE_SUPPORT
6478 /* Remember those colors actually allocated. */
6479 img
->colors
= colors_in_color_table (&img
->ncolors
);
6480 free_color_table ();
6481 #endif /* COLOR_TABLE_SUPPORT */
6485 row_stride
= width
* cinfo
.output_components
;
6486 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
6488 for (y
= 0; y
< height
; ++y
)
6490 fn_jpeg_read_scanlines (&cinfo
, buffer
, 1);
6491 for (x
= 0; x
< cinfo
.output_width
; ++x
)
6492 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6496 fn_jpeg_finish_decompress (&cinfo
);
6497 fn_jpeg_destroy_decompress (&cinfo
);
6499 fclose ((FILE *) fp
);
6501 /* Maybe fill in the background field while we have ximg handy. */
6502 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6503 /* Casting avoids a GCC warning. */
6504 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6506 /* Put the image into the pixmap. */
6507 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6508 x_destroy_x_image (ximg
);
6512 #else /* HAVE_JPEG */
6516 jpeg_load (struct frame
*f
, struct image
*img
)
6518 return ns_load_image (f
, img
,
6519 image_spec_value (img
->spec
, QCfile
, NULL
),
6520 image_spec_value (img
->spec
, QCdata
, NULL
));
6522 #endif /* HAVE_NS */
6524 #endif /* !HAVE_JPEG */
6528 /***********************************************************************
6530 ***********************************************************************/
6532 #if defined (HAVE_TIFF) || defined (HAVE_NS)
6534 static int tiff_image_p (Lisp_Object object
);
6535 static int tiff_load (struct frame
*f
, struct image
*img
);
6537 /* The symbol `tiff' identifying images of this type. */
6539 static Lisp_Object Qtiff
;
6541 /* Indices of image specification fields in tiff_format, below. */
6543 enum tiff_keyword_index
6552 TIFF_HEURISTIC_MASK
,
6559 /* Vector of image_keyword structures describing the format
6560 of valid user-defined image specifications. */
6562 static const struct image_keyword tiff_format
[TIFF_LAST
] =
6564 {":type", IMAGE_SYMBOL_VALUE
, 1},
6565 {":data", IMAGE_STRING_VALUE
, 0},
6566 {":file", IMAGE_STRING_VALUE
, 0},
6567 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6568 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6569 {":relief", IMAGE_INTEGER_VALUE
, 0},
6570 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6571 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6572 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6573 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
6574 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0}
6577 /* Structure describing the image type `tiff'. */
6579 static struct image_type tiff_type
=
6588 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6591 tiff_image_p (Lisp_Object object
)
6593 struct image_keyword fmt
[TIFF_LAST
];
6594 memcpy (fmt
, tiff_format
, sizeof fmt
);
6596 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6599 /* Must specify either the :data or :file keyword. */
6600 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6603 #endif /* HAVE_TIFF || HAVE_NS */
6611 /* TIFF library details. */
6612 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetErrorHandler
, (TIFFErrorHandler
));
6613 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetWarningHandler
, (TIFFErrorHandler
));
6614 DEF_IMGLIB_FN (TIFF
*, TIFFOpen
, (const char *, const char *));
6615 DEF_IMGLIB_FN (TIFF
*, TIFFClientOpen
, (const char *, const char *, thandle_t
,
6616 TIFFReadWriteProc
, TIFFReadWriteProc
,
6617 TIFFSeekProc
, TIFFCloseProc
, TIFFSizeProc
,
6618 TIFFMapFileProc
, TIFFUnmapFileProc
));
6619 DEF_IMGLIB_FN (int, TIFFGetField
, (TIFF
*, ttag_t
, ...));
6620 DEF_IMGLIB_FN (int, TIFFReadRGBAImage
, (TIFF
*, uint32
, uint32
, uint32
*, int));
6621 DEF_IMGLIB_FN (void, TIFFClose
, (TIFF
*));
6622 DEF_IMGLIB_FN (int, TIFFSetDirectory
, (TIFF
*, tdir_t
));
6625 init_tiff_functions (Lisp_Object libraries
)
6629 if (!(library
= w32_delayed_load (libraries
, Qtiff
)))
6632 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6633 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6634 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6635 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6636 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6637 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6638 LOAD_IMGLIB_FN (library
, TIFFClose
);
6639 LOAD_IMGLIB_FN (library
, TIFFSetDirectory
);
6645 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6646 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6647 #define fn_TIFFOpen TIFFOpen
6648 #define fn_TIFFClientOpen TIFFClientOpen
6649 #define fn_TIFFGetField TIFFGetField
6650 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6651 #define fn_TIFFClose TIFFClose
6652 #define fn_TIFFSetDirectory TIFFSetDirectory
6653 #endif /* HAVE_NTGUI */
6656 /* Reading from a memory buffer for TIFF images Based on the PNG
6657 memory source, but we have to provide a lot of extra functions.
6660 We really only need to implement read and seek, but I am not
6661 convinced that the TIFF library is smart enough not to destroy
6662 itself if we only hand it the function pointers we need to
6667 unsigned char *bytes
;
6674 tiff_read_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6676 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6678 size
= min (size
, src
->len
- src
->index
);
6679 memcpy (buf
, src
->bytes
+ src
->index
, size
);
6685 tiff_write_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6691 tiff_seek_in_memory (thandle_t data
, toff_t off
, int whence
)
6693 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6698 case SEEK_SET
: /* Go from beginning of source. */
6702 case SEEK_END
: /* Go from end of source. */
6703 idx
= src
->len
+ off
;
6706 case SEEK_CUR
: /* Go from current position. */
6707 idx
= src
->index
+ off
;
6710 default: /* Invalid `whence'. */
6714 if (idx
> src
->len
|| idx
< 0)
6722 tiff_close_memory (thandle_t data
)
6729 tiff_mmap_memory (thandle_t data
, tdata_t
*pbase
, toff_t
*psize
)
6731 /* It is already _IN_ memory. */
6736 tiff_unmap_memory (thandle_t data
, tdata_t base
, toff_t size
)
6738 /* We don't need to do this. */
6742 tiff_size_of_memory (thandle_t data
)
6744 return ((tiff_memory_source
*) data
)->len
;
6748 static void tiff_handler (const char *, const char *, const char *, va_list)
6749 ATTRIBUTE_FORMAT_PRINTF (3, 0);
6751 tiff_handler (const char *log_format
, const char *title
,
6752 const char *format
, va_list ap
)
6754 /* doprnt is not suitable here, as TIFF handlers are called from
6755 libtiff and are passed arbitrary printf directives. Instead, use
6756 vsnprintf, taking care to be portable to nonstandard environments
6757 where vsnprintf returns -1 on buffer overflow. Since it's just a
6758 log entry, it's OK to truncate it. */
6760 int len
= vsnprintf (buf
, sizeof buf
, format
, ap
);
6761 add_to_log (log_format
, build_string (title
),
6762 make_string (buf
, max (0, min (len
, sizeof buf
- 1))));
6765 static void tiff_error_handler (const char *, const char *, va_list)
6766 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6768 tiff_error_handler (const char *title
, const char *format
, va_list ap
)
6770 tiff_handler ("TIFF error: %s %s", title
, format
, ap
);
6774 static void tiff_warning_handler (const char *, const char *, va_list)
6775 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6777 tiff_warning_handler (const char *title
, const char *format
, va_list ap
)
6779 tiff_handler ("TIFF warning: %s %s", title
, format
, ap
);
6783 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6787 tiff_load (struct frame
*f
, struct image
*img
)
6789 Lisp_Object file
, specified_file
;
6790 Lisp_Object specified_data
;
6792 int width
, height
, x
, y
, count
;
6796 tiff_memory_source memsrc
;
6799 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6800 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6802 fn_TIFFSetErrorHandler ((TIFFErrorHandler
) tiff_error_handler
);
6803 fn_TIFFSetWarningHandler ((TIFFErrorHandler
) tiff_warning_handler
);
6805 if (NILP (specified_data
))
6807 /* Read from a file */
6808 file
= x_find_image_file (specified_file
);
6809 if (!STRINGP (file
))
6811 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6815 /* Try to open the image file. */
6816 tiff
= fn_TIFFOpen (SSDATA (file
), "r");
6819 image_error ("Cannot open `%s'", file
, Qnil
);
6825 if (!STRINGP (specified_data
))
6827 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6831 /* Memory source! */
6832 memsrc
.bytes
= SDATA (specified_data
);
6833 memsrc
.len
= SBYTES (specified_data
);
6836 tiff
= fn_TIFFClientOpen ("memory_source", "r", (thandle_t
)&memsrc
,
6837 tiff_read_from_memory
,
6838 tiff_write_from_memory
,
6839 tiff_seek_in_memory
,
6841 tiff_size_of_memory
,
6847 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
6852 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
6853 if (INTEGERP (image
))
6855 EMACS_INT ino
= XFASTINT (image
);
6856 if (! (TYPE_MINIMUM (tdir_t
) <= ino
&& ino
<= TYPE_MAXIMUM (tdir_t
)
6857 && fn_TIFFSetDirectory (tiff
, ino
)))
6859 image_error ("Invalid image number `%s' in image `%s'",
6861 fn_TIFFClose (tiff
);
6866 /* Get width and height of the image, and allocate a raster buffer
6867 of width x height 32-bit values. */
6868 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
6869 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
6871 if (!check_image_size (f
, width
, height
))
6873 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6874 fn_TIFFClose (tiff
);
6878 /* Create the X image and pixmap. */
6879 if (! (height
<= min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *buf
/ width
6880 && x_create_x_image_and_pixmap (f
, width
, height
, 0,
6881 &ximg
, &img
->pixmap
)))
6883 fn_TIFFClose (tiff
);
6887 buf
= (uint32
*) xmalloc (sizeof *buf
* width
* height
);
6889 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
6891 /* Count the number of images in the file. */
6892 for (count
= 1; fn_TIFFSetDirectory (tiff
, count
); count
++)
6896 img
->lisp_data
= Fcons (Qcount
,
6897 Fcons (make_number (count
),
6900 fn_TIFFClose (tiff
);
6903 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
6908 /* Initialize the color table. */
6909 init_color_table ();
6911 /* Process the pixel raster. Origin is in the lower-left corner. */
6912 for (y
= 0; y
< height
; ++y
)
6914 uint32
*row
= buf
+ y
* width
;
6916 for (x
= 0; x
< width
; ++x
)
6918 uint32 abgr
= row
[x
];
6919 int r
= TIFFGetR (abgr
) << 8;
6920 int g
= TIFFGetG (abgr
) << 8;
6921 int b
= TIFFGetB (abgr
) << 8;
6922 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
6926 #ifdef COLOR_TABLE_SUPPORT
6927 /* Remember the colors allocated for the image. Free the color table. */
6928 img
->colors
= colors_in_color_table (&img
->ncolors
);
6929 free_color_table ();
6930 #endif /* COLOR_TABLE_SUPPORT */
6933 img
->height
= height
;
6935 /* Maybe fill in the background field while we have ximg handy. */
6936 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6937 /* Casting avoids a GCC warning on W32. */
6938 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6940 /* Put the image into the pixmap, then free the X image and its buffer. */
6941 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
6942 x_destroy_x_image (ximg
);
6948 #else /* HAVE_TIFF */
6952 tiff_load (struct frame
*f
, struct image
*img
)
6954 return ns_load_image (f
, img
,
6955 image_spec_value (img
->spec
, QCfile
, NULL
),
6956 image_spec_value (img
->spec
, QCdata
, NULL
));
6958 #endif /* HAVE_NS */
6960 #endif /* !HAVE_TIFF */
6964 /***********************************************************************
6966 ***********************************************************************/
6968 #if defined (HAVE_GIF) || defined (HAVE_NS)
6970 static int gif_image_p (Lisp_Object object
);
6971 static int gif_load (struct frame
*f
, struct image
*img
);
6972 static void gif_clear_image (struct frame
*f
, struct image
*img
);
6974 /* The symbol `gif' identifying images of this type. */
6976 static Lisp_Object Qgif
;
6978 /* Indices of image specification fields in gif_format, below. */
6980 enum gif_keyword_index
6996 /* Vector of image_keyword structures describing the format
6997 of valid user-defined image specifications. */
6999 static const struct image_keyword gif_format
[GIF_LAST
] =
7001 {":type", IMAGE_SYMBOL_VALUE
, 1},
7002 {":data", IMAGE_STRING_VALUE
, 0},
7003 {":file", IMAGE_STRING_VALUE
, 0},
7004 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7005 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7006 {":relief", IMAGE_INTEGER_VALUE
, 0},
7007 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7008 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7009 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7010 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7011 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7014 /* Structure describing the image type `gif'. */
7016 static struct image_type gif_type
=
7025 /* Free X resources of GIF image IMG which is used on frame F. */
7028 gif_clear_image (struct frame
*f
, struct image
*img
)
7030 img
->lisp_data
= Qnil
;
7031 x_clear_image (f
, img
);
7034 /* Return non-zero if OBJECT is a valid GIF image specification. */
7037 gif_image_p (Lisp_Object object
)
7039 struct image_keyword fmt
[GIF_LAST
];
7040 memcpy (fmt
, gif_format
, sizeof fmt
);
7042 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7045 /* Must specify either the :data or :file keyword. */
7046 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7049 #endif /* HAVE_GIF */
7053 #if defined (HAVE_NTGUI)
7054 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7055 Undefine before redefining to avoid a preprocessor warning. */
7059 /* avoid conflict with QuickdrawText.h */
7060 #define DrawText gif_DrawText
7061 #include <gif_lib.h>
7064 #else /* HAVE_NTGUI */
7066 #include <gif_lib.h>
7068 #endif /* HAVE_NTGUI */
7073 /* GIF library details. */
7074 DEF_IMGLIB_FN (int, DGifCloseFile
, (GifFileType
*));
7075 DEF_IMGLIB_FN (int, DGifSlurp
, (GifFileType
*));
7076 DEF_IMGLIB_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
));
7077 DEF_IMGLIB_FN (GifFileType
*, DGifOpenFileName
, (const char *));
7080 init_gif_functions (Lisp_Object libraries
)
7084 if (!(library
= w32_delayed_load (libraries
, Qgif
)))
7087 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7088 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7089 LOAD_IMGLIB_FN (library
, DGifOpen
);
7090 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7096 #define fn_DGifCloseFile DGifCloseFile
7097 #define fn_DGifSlurp DGifSlurp
7098 #define fn_DGifOpen DGifOpen
7099 #define fn_DGifOpenFileName DGifOpenFileName
7101 #endif /* HAVE_NTGUI */
7103 /* Reading a GIF image from memory
7104 Based on the PNG memory stuff to a certain extent. */
7108 unsigned char *bytes
;
7114 /* Make the current memory source available to gif_read_from_memory.
7115 It's done this way because not all versions of libungif support
7116 a UserData field in the GifFileType structure. */
7117 static gif_memory_source
*current_gif_memory_src
;
7120 gif_read_from_memory (GifFileType
*file
, GifByteType
*buf
, int len
)
7122 gif_memory_source
*src
= current_gif_memory_src
;
7124 if (len
> src
->len
- src
->index
)
7127 memcpy (buf
, src
->bytes
+ src
->index
, len
);
7133 /* Load GIF image IMG for use on frame F. Value is non-zero if
7136 static const int interlace_start
[] = {0, 4, 2, 1};
7137 static const int interlace_increment
[] = {8, 8, 4, 2};
7139 #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249
7142 gif_load (struct frame
*f
, struct image
*img
)
7145 int rc
, width
, height
, x
, y
, i
, j
;
7147 ColorMapObject
*gif_color_map
;
7148 unsigned long pixel_colors
[256];
7150 int image_height
, image_width
;
7151 gif_memory_source memsrc
;
7152 Lisp_Object specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7153 Lisp_Object specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7154 Lisp_Object specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7155 unsigned long bgcolor
= 0;
7158 if (NILP (specified_data
))
7160 file
= x_find_image_file (specified_file
);
7161 if (!STRINGP (file
))
7163 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7167 /* Open the GIF file. */
7168 gif
= fn_DGifOpenFileName (SSDATA (file
));
7171 image_error ("Cannot open `%s'", file
, Qnil
);
7177 if (!STRINGP (specified_data
))
7179 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
7183 /* Read from memory! */
7184 current_gif_memory_src
= &memsrc
;
7185 memsrc
.bytes
= SDATA (specified_data
);
7186 memsrc
.len
= SBYTES (specified_data
);
7189 gif
= fn_DGifOpen (&memsrc
, gif_read_from_memory
);
7192 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7197 /* Before reading entire contents, check the declared image size. */
7198 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7200 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7201 fn_DGifCloseFile (gif
);
7205 /* Read entire contents. */
7206 rc
= fn_DGifSlurp (gif
);
7207 if (rc
== GIF_ERROR
|| gif
->ImageCount
<= 0)
7209 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7210 fn_DGifCloseFile (gif
);
7214 /* Which sub-image are we to display? */
7216 Lisp_Object image_number
= image_spec_value (img
->spec
, QCindex
, NULL
);
7217 idx
= INTEGERP (image_number
) ? XFASTINT (image_number
) : 0;
7218 if (idx
< 0 || idx
>= gif
->ImageCount
)
7220 image_error ("Invalid image number `%s' in image `%s'",
7221 image_number
, img
->spec
);
7222 fn_DGifCloseFile (gif
);
7227 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Top
;
7228 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[idx
].ImageDesc
.Left
;
7229 image_height
= gif
->SavedImages
[idx
].ImageDesc
.Height
;
7230 img
->corners
[BOT_CORNER
] = img
->corners
[TOP_CORNER
] + image_height
;
7231 image_width
= gif
->SavedImages
[idx
].ImageDesc
.Width
;
7232 img
->corners
[RIGHT_CORNER
] = img
->corners
[LEFT_CORNER
] + image_width
;
7234 width
= img
->width
= max (gif
->SWidth
,
7235 max (gif
->Image
.Left
+ gif
->Image
.Width
,
7236 img
->corners
[RIGHT_CORNER
]));
7237 height
= img
->height
= max (gif
->SHeight
,
7238 max (gif
->Image
.Top
+ gif
->Image
.Height
,
7239 img
->corners
[BOT_CORNER
]));
7241 if (!check_image_size (f
, width
, height
))
7243 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7244 fn_DGifCloseFile (gif
);
7248 /* Create the X image and pixmap. */
7249 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
7251 fn_DGifCloseFile (gif
);
7255 /* Clear the part of the screen image not covered by the image.
7256 Full animated GIF support requires more here (see the gif89 spec,
7257 disposal methods). Let's simply assume that the part not covered
7258 by a sub-image is in the frame's background color. */
7259 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7260 for (x
= 0; x
< width
; ++x
)
7261 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7263 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7264 for (x
= 0; x
< width
; ++x
)
7265 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7267 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7269 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7270 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7271 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7272 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7275 /* Read the GIF image into the X image. */
7277 /* FIXME: With the current implementation, loading an animated gif
7278 is quadratic in the number of animation frames, since each frame
7279 is a separate struct image. We must provide a way for a single
7280 gif_load call to construct and save all animation frames. */
7282 init_color_table ();
7283 if (STRINGP (specified_bg
))
7284 bgcolor
= x_alloc_image_color (f
, img
, specified_bg
,
7285 FRAME_BACKGROUND_PIXEL (f
));
7286 for (j
= 0; j
<= idx
; ++j
)
7288 /* We use a local variable `raster' here because RasterBits is a
7289 char *, which invites problems with bytes >= 0x80. */
7290 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7291 unsigned char *raster
= (unsigned char *) subimage
->RasterBits
;
7292 int transparency_color_index
= -1;
7295 /* Find the Graphic Control Extension block for this sub-image.
7296 Extract the disposal method and transparency color. */
7297 for (i
= 0; i
< subimage
->ExtensionBlockCount
; i
++)
7299 ExtensionBlock
*extblock
= subimage
->ExtensionBlocks
+ i
;
7301 if ((extblock
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
)
7302 && extblock
->ByteCount
== 4
7303 && extblock
->Bytes
[0] & 1)
7305 /* From gif89a spec: 1 = "keep in place", 2 = "restore
7306 to background". Treat any other value like 2. */
7307 disposal
= (extblock
->Bytes
[0] >> 2) & 7;
7308 transparency_color_index
= (unsigned char) extblock
->Bytes
[3];
7313 /* We can't "keep in place" the first subimage. */
7317 /* Allocate subimage colors. */
7318 memset (pixel_colors
, 0, sizeof pixel_colors
);
7319 gif_color_map
= subimage
->ImageDesc
.ColorMap
;
7321 gif_color_map
= gif
->SColorMap
;
7324 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7326 if (transparency_color_index
== i
)
7327 pixel_colors
[i
] = STRINGP (specified_bg
)
7328 ? bgcolor
: FRAME_BACKGROUND_PIXEL (f
);
7331 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7332 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7333 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7334 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7338 /* Apply the pixel values. */
7339 if (gif
->SavedImages
[j
].ImageDesc
.Interlace
)
7343 for (y
= 0, row
= interlace_start
[0], pass
= 0;
7345 y
++, row
+= interlace_increment
[pass
])
7347 if (row
>= image_height
)
7349 row
= interlace_start
[++pass
];
7350 while (row
>= image_height
)
7351 row
= interlace_start
[++pass
];
7354 for (x
= 0; x
< image_width
; x
++)
7356 int c
= raster
[y
* image_width
+ x
];
7357 if (transparency_color_index
!= c
|| disposal
!= 1)
7358 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7359 row
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7365 for (y
= 0; y
< image_height
; ++y
)
7366 for (x
= 0; x
< image_width
; ++x
)
7368 int c
= raster
[y
* image_width
+ x
];
7369 if (transparency_color_index
!= c
|| disposal
!= 1)
7370 XPutPixel (ximg
, x
+ img
->corners
[LEFT_CORNER
],
7371 y
+ img
->corners
[TOP_CORNER
], pixel_colors
[c
]);
7376 #ifdef COLOR_TABLE_SUPPORT
7377 img
->colors
= colors_in_color_table (&img
->ncolors
);
7378 free_color_table ();
7379 #endif /* COLOR_TABLE_SUPPORT */
7381 /* Save GIF image extension data for `image-metadata'.
7382 Format is (count IMAGES extension-data (FUNCTION "BYTES" ...)). */
7383 img
->lisp_data
= Qnil
;
7384 if (gif
->SavedImages
[idx
].ExtensionBlockCount
> 0)
7387 ExtensionBlock
*ext
= gif
->SavedImages
[idx
].ExtensionBlocks
;
7388 for (i
= 0; i
< gif
->SavedImages
[idx
].ExtensionBlockCount
; i
++, ext
++)
7389 /* Append (... FUNCTION "BYTES") */
7392 = Fcons (make_number (ext
->Function
),
7393 Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7395 if (ext
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
7396 && ext
->ByteCount
== 4)
7398 delay
= ext
->Bytes
[2] << CHAR_BIT
;
7399 delay
|= ext
->Bytes
[1];
7402 img
->lisp_data
= Fcons (Qextension_data
,
7403 Fcons (img
->lisp_data
, Qnil
));
7407 Fcons (make_float (delay
/ 100.0),
7411 if (gif
->ImageCount
> 1)
7412 img
->lisp_data
= Fcons (Qcount
,
7413 Fcons (make_number (gif
->ImageCount
),
7416 fn_DGifCloseFile (gif
);
7418 /* Maybe fill in the background field while we have ximg handy. */
7419 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7420 /* Casting avoids a GCC warning. */
7421 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7423 /* Put the image into the pixmap, then free the X image and its buffer. */
7424 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7425 x_destroy_x_image (ximg
);
7430 #else /* !HAVE_GIF */
7434 gif_load (struct frame
*f
, struct image
*img
)
7436 return ns_load_image (f
, img
,
7437 image_spec_value (img
->spec
, QCfile
, NULL
),
7438 image_spec_value (img
->spec
, QCdata
, NULL
));
7440 #endif /* HAVE_NS */
7442 #endif /* HAVE_GIF */
7445 /***********************************************************************
7447 ***********************************************************************/
7448 #if defined (HAVE_IMAGEMAGICK)
7450 static Lisp_Object Qimagemagick
;
7452 static int imagemagick_image_p (Lisp_Object
);
7453 static int imagemagick_load (struct frame
*, struct image
*);
7454 static void imagemagick_clear_image (struct frame
*, struct image
*);
7456 /* Indices of image specification fields in imagemagick_format. */
7458 enum imagemagick_keyword_index
7466 IMAGEMAGICK_ALGORITHM
,
7467 IMAGEMAGICK_HEURISTIC_MASK
,
7469 IMAGEMAGICK_BACKGROUND
,
7472 IMAGEMAGICK_ROTATION
,
7477 /* Vector of image_keyword structures describing the format
7478 of valid user-defined image specifications. */
7480 static struct image_keyword imagemagick_format
[IMAGEMAGICK_LAST
] =
7482 {":type", IMAGE_SYMBOL_VALUE
, 1},
7483 {":data", IMAGE_STRING_VALUE
, 0},
7484 {":file", IMAGE_STRING_VALUE
, 0},
7485 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7486 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7487 {":relief", IMAGE_INTEGER_VALUE
, 0},
7488 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7489 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7490 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7491 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
7492 {":height", IMAGE_INTEGER_VALUE
, 0},
7493 {":width", IMAGE_INTEGER_VALUE
, 0},
7494 {":rotation", IMAGE_NUMBER_VALUE
, 0},
7495 {":crop", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
7498 /* Structure describing the image type for any image handled via
7501 static struct image_type imagemagick_type
=
7504 imagemagick_image_p
,
7506 imagemagick_clear_image
,
7510 /* Free X resources of imagemagick image IMG which is used on frame F. */
7513 imagemagick_clear_image (struct frame
*f
,
7516 x_clear_image (f
, img
);
7519 /* Return non-zero if OBJECT is a valid IMAGEMAGICK image specification. Do
7520 this by calling parse_image_spec and supplying the keywords that
7521 identify the IMAGEMAGICK format. */
7524 imagemagick_image_p (Lisp_Object object
)
7526 struct image_keyword fmt
[IMAGEMAGICK_LAST
];
7527 memcpy (fmt
, imagemagick_format
, sizeof fmt
);
7529 if (!parse_image_spec (object
, fmt
, IMAGEMAGICK_LAST
, Qimagemagick
))
7532 /* Must specify either the :data or :file keyword. */
7533 return fmt
[IMAGEMAGICK_FILE
].count
+ fmt
[IMAGEMAGICK_DATA
].count
== 1;
7536 /* The GIF library also defines DrawRectangle, but its never used in Emacs.
7537 Therefore rename the function so it doesnt collide with ImageMagick. */
7538 #define DrawRectangle DrawRectangleGif
7539 #include <wand/MagickWand.h>
7541 /* ImageMagick 6.5.3 through 6.6.5 hid PixelGetMagickColor for some reason.
7542 Emacs seems to work fine with the hidden version, so unhide it. */
7543 #include <magick/version.h>
7544 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
7545 extern WandExport
void PixelGetMagickColor (const PixelWand
*,
7546 MagickPixelPacket
*);
7549 /* Helper function for imagemagick_load, which does the actual loading
7550 given contents and size, apart from frame and image structures,
7551 passed from imagemagick_load. Uses librimagemagick to do most of
7552 the image processing.
7554 F is a pointer to the Emacs frame; IMG to the image structure to
7555 prepare; CONTENTS is the string containing the IMAGEMAGICK data to
7556 be parsed; SIZE is the number of bytes of data; and FILENAME is
7557 either the file name or the image data.
7559 Return non-zero if successful. */
7562 imagemagick_load_image (struct frame
*f
, struct image
*img
,
7563 unsigned char *contents
, unsigned int size
,
7569 MagickBooleanType status
;
7575 MagickWand
*image_wand
;
7576 MagickWand
*ping_wand
;
7577 PixelIterator
*iterator
;
7579 MagickPixelPacket pixel
;
7584 int desired_width
, desired_height
;
7586 EMACS_INT imagemagick_rendermethod
;
7588 ImageInfo
*image_info
;
7589 ExceptionInfo
*exception
;
7593 /* Handle image index for image types who can contain more than one image.
7594 Interface :index is same as for GIF. First we "ping" the image to see how
7595 many sub-images it contains. Pinging is faster than loading the image to
7596 find out things about it. */
7598 /* Initialize the imagemagick environment. */
7599 MagickWandGenesis ();
7600 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7601 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
7602 ping_wand
= NewMagickWand ();
7603 MagickSetResolution (ping_wand
, 2, 2);
7604 if (filename
!= NULL
)
7606 status
= MagickPingImage (ping_wand
, filename
);
7610 status
= MagickPingImageBlob (ping_wand
, contents
, size
);
7613 if (! (0 <= ino
&& ino
< MagickGetNumberImages (ping_wand
)))
7615 image_error ("Invalid image number `%s' in image `%s'",
7617 DestroyMagickWand (ping_wand
);
7621 if (MagickGetNumberImages(ping_wand
) > 1)
7624 Fcons (make_number (MagickGetNumberImages (ping_wand
)),
7627 DestroyMagickWand (ping_wand
);
7629 /* Now we know how many images are inside the file. If it's not a
7630 bundle, the number is one. */
7632 if (filename
!= NULL
)
7634 image_info
= CloneImageInfo ((ImageInfo
*) NULL
);
7635 (void) strcpy (image_info
->filename
, filename
);
7636 image_info
->number_scenes
= 1;
7637 image_info
->scene
= ino
;
7638 exception
= AcquireExceptionInfo ();
7640 im_image
= ReadImage (image_info
, exception
);
7641 DestroyExceptionInfo (exception
);
7643 if (im_image
== NULL
)
7644 goto imagemagick_no_wand
;
7645 image_wand
= NewMagickWandFromImage (im_image
);
7646 DestroyImage(im_image
);
7650 image_wand
= NewMagickWand ();
7651 if (MagickReadImageBlob (image_wand
, contents
, size
) == MagickFalse
)
7652 goto imagemagick_error
;
7655 /* If width and/or height is set in the display spec assume we want
7656 to scale to those values. If either h or w is unspecified, the
7657 unspecified should be calculated from the specified to preserve
7660 value
= image_spec_value (img
->spec
, QCwidth
, NULL
);
7661 desired_width
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7662 value
= image_spec_value (img
->spec
, QCheight
, NULL
);
7663 desired_height
= (INTEGERP (value
) ? XFASTINT (value
) : -1);
7665 height
= MagickGetImageHeight (image_wand
);
7666 width
= MagickGetImageWidth (image_wand
);
7668 if (desired_width
!= -1 && desired_height
== -1)
7669 /* w known, calculate h. */
7670 desired_height
= (double) desired_width
/ width
* height
;
7671 if (desired_width
== -1 && desired_height
!= -1)
7672 /* h known, calculate w. */
7673 desired_width
= (double) desired_height
/ height
* width
;
7674 if (desired_width
!= -1 && desired_height
!= -1)
7676 status
= MagickScaleImage (image_wand
, desired_width
, desired_height
);
7677 if (status
== MagickFalse
)
7679 image_error ("Imagemagick scale failed", Qnil
, Qnil
);
7680 goto imagemagick_error
;
7684 /* crop behaves similar to image slicing in Emacs but is more memory
7686 crop
= image_spec_value (img
->spec
, QCcrop
, NULL
);
7688 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop
)))
7690 /* After some testing, it seems MagickCropImage is the fastest crop
7691 function in ImageMagick. This crop function seems to do less copying
7692 than the alternatives, but it still reads the entire image into memory
7693 before cropping, which is apparently difficult to avoid when using
7695 size_t crop_width
= XINT (XCAR (crop
));
7697 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop
)))
7699 size_t crop_height
= XINT (XCAR (crop
));
7701 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (ssize_t
, XCAR (crop
)))
7703 ssize_t crop_x
= XINT (XCAR (crop
));
7705 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (ssize_t
, XCAR (crop
)))
7707 ssize_t crop_y
= XINT (XCAR (crop
));
7708 MagickCropImage (image_wand
, crop_width
, crop_height
,
7715 /* Furthermore :rotation. we need background color and angle for
7718 TODO background handling for rotation specified_bg =
7719 image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
7721 value
= image_spec_value (img
->spec
, QCrotation
, NULL
);
7724 PixelWand
* background
= NewPixelWand ();
7725 PixelSetColor (background
, "#ffffff");/*TODO remove hardcode*/
7727 rotation
= extract_float (value
);
7729 status
= MagickRotateImage (image_wand
, background
, rotation
);
7730 DestroyPixelWand (background
);
7731 if (status
== MagickFalse
)
7733 image_error ("Imagemagick image rotate failed", Qnil
, Qnil
);
7734 goto imagemagick_error
;
7738 /* Finally we are done manipulating the image. Figure out the
7739 resulting width/height and transfer ownerwship to Emacs. */
7740 height
= MagickGetImageHeight (image_wand
);
7741 width
= MagickGetImageWidth (image_wand
);
7743 if (! (width
<= INT_MAX
&& height
<= INT_MAX
7744 && check_image_size (f
, width
, height
)))
7746 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7747 goto imagemagick_error
;
7750 /* We can now get a valid pixel buffer from the imagemagick file, if all
7753 init_color_table ();
7754 imagemagick_rendermethod
= (INTEGERP (Vimagemagick_render_type
)
7755 ? XINT (Vimagemagick_render_type
) : 0);
7756 if (imagemagick_rendermethod
== 0)
7758 size_t image_height
;
7760 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7761 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7762 &ximg
, &img
->pixmap
))
7764 #ifdef COLOR_TABLE_SUPPORT
7765 free_color_table ();
7767 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7768 goto imagemagick_error
;
7771 /* Copy imagegmagick image to x with primitive yet robust pixel
7772 pusher loop. This has been tested a lot with many different
7775 /* Copy pixels from the imagemagick image structure to the x image map. */
7776 iterator
= NewPixelIterator (image_wand
);
7777 if (iterator
== (PixelIterator
*) NULL
)
7779 #ifdef COLOR_TABLE_SUPPORT
7780 free_color_table ();
7782 x_destroy_x_image (ximg
);
7783 image_error ("Imagemagick pixel iterator creation failed",
7785 goto imagemagick_error
;
7788 image_height
= MagickGetImageHeight (image_wand
);
7789 for (y
= 0; y
< image_height
; y
++)
7791 pixels
= PixelGetNextIteratorRow (iterator
, &width
);
7792 if (pixels
== (PixelWand
**) NULL
)
7794 for (x
= 0; x
< (long) width
; x
++)
7796 PixelGetMagickColor (pixels
[x
], &pixel
);
7797 XPutPixel (ximg
, x
, y
,
7798 lookup_rgb_color (f
,
7804 DestroyPixelIterator (iterator
);
7807 if (imagemagick_rendermethod
== 1)
7809 /* Magicexportimage is normaly faster than pixelpushing. This
7810 method is also well tested. Some aspects of this method are
7811 ad-hoc and needs to be more researched. */
7812 int imagedepth
= 24;/*MagickGetImageDepth(image_wand);*/
7813 const char *exportdepth
= imagedepth
<= 8 ? "I" : "BGRP";/*"RGBP";*/
7814 /* Try to create a x pixmap to hold the imagemagick pixmap. */
7815 if (!x_create_x_image_and_pixmap (f
, width
, height
, imagedepth
,
7816 &ximg
, &img
->pixmap
))
7818 #ifdef COLOR_TABLE_SUPPORT
7819 free_color_table ();
7821 image_error("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
7822 goto imagemagick_error
;
7826 /* Oddly, the below code doesnt seem to work:*/
7827 /* switch(ximg->bitmap_unit){ */
7829 /* pixelwidth=CharPixel; */
7832 /* pixelwidth=ShortPixel; */
7835 /* pixelwidth=LongPixel; */
7839 Here im just guessing the format of the bitmap.
7840 happens to work fine for:
7843 seems about 3 times as fast as pixel pushing(not carefully measured)
7845 pixelwidth
= CharPixel
;/*??? TODO figure out*/
7846 #ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
7847 MagickExportImagePixels (image_wand
,
7852 /*&(img->pixmap));*/
7855 image_error ("You dont have MagickExportImagePixels, upgrade ImageMagick!",
7861 #ifdef COLOR_TABLE_SUPPORT
7862 /* Remember colors allocated for this image. */
7863 img
->colors
= colors_in_color_table (&img
->ncolors
);
7864 free_color_table ();
7865 #endif /* COLOR_TABLE_SUPPORT */
7869 img
->height
= height
;
7871 /* Put the image into the pixmap, then free the X image and its
7873 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7874 x_destroy_x_image (ximg
);
7877 /* Final cleanup. image_wand should be the only resource left. */
7878 DestroyMagickWand (image_wand
);
7879 /* `MagickWandTerminus' terminates the imagemagick environment. */
7880 MagickWandTerminus ();
7885 DestroyMagickWand (image_wand
);
7886 imagemagick_no_wand
:
7887 MagickWandTerminus ();
7888 /* TODO more cleanup. */
7889 image_error ("Error parsing IMAGEMAGICK image `%s'", img
->spec
, Qnil
);
7894 /* Load IMAGEMAGICK image IMG for use on frame F. Value is non-zero if
7895 successful. this function will go into the imagemagick_type structure, and
7896 the prototype thus needs to be compatible with that structure. */
7899 imagemagick_load (struct frame
*f
, struct image
*img
)
7902 Lisp_Object file_name
;
7904 /* If IMG->spec specifies a file name, create a non-file spec from it. */
7905 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
7906 if (STRINGP (file_name
))
7910 file
= x_find_image_file (file_name
);
7911 if (!STRINGP (file
))
7913 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
7916 success_p
= imagemagick_load_image (f
, img
, 0, 0, SSDATA (file
));
7918 /* Else its not a file, its a lisp object. Load the image from a
7919 lisp object rather than a file. */
7924 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7925 if (!STRINGP (data
))
7927 image_error ("Invalid image data `%s'", data
, Qnil
);
7930 success_p
= imagemagick_load_image (f
, img
, SDATA (data
),
7931 SBYTES (data
), NULL
);
7937 DEFUN ("imagemagick-types", Fimagemagick_types
, Simagemagick_types
, 0, 0, 0,
7938 doc
: /* Return a list of image types supported by ImageMagick.
7939 Each entry in this list is a symbol named after an ImageMagick format
7940 tag. See the ImageMagick manual for a list of ImageMagick formats and
7941 their descriptions (http://www.imagemagick.org/script/formats.php).
7943 Note that ImageMagick recognizes many file-types that Emacs does not
7944 recognize as images, such as C. See `imagemagick-types-inhibit'. */)
7947 Lisp_Object typelist
= Qnil
;
7950 char **imtypes
= GetMagickList ("*", &numf
, &ex
);
7952 Lisp_Object Qimagemagicktype
;
7953 for (i
= 0; i
< numf
; i
++)
7955 Qimagemagicktype
= intern (imtypes
[i
]);
7956 typelist
= Fcons (Qimagemagicktype
, typelist
);
7961 #endif /* defined (HAVE_IMAGEMAGICK) */
7965 /***********************************************************************
7967 ***********************************************************************/
7969 #if defined (HAVE_RSVG)
7971 /* Function prototypes. */
7973 static int svg_image_p (Lisp_Object object
);
7974 static int svg_load (struct frame
*f
, struct image
*img
);
7976 static int svg_load_image (struct frame
*, struct image
*,
7977 unsigned char *, ptrdiff_t);
7979 /* The symbol `svg' identifying images of this type. */
7981 static Lisp_Object Qsvg
;
7983 /* Indices of image specification fields in svg_format, below. */
7985 enum svg_keyword_index
8000 /* Vector of image_keyword structures describing the format
8001 of valid user-defined image specifications. */
8003 static const struct image_keyword svg_format
[SVG_LAST
] =
8005 {":type", IMAGE_SYMBOL_VALUE
, 1},
8006 {":data", IMAGE_STRING_VALUE
, 0},
8007 {":file", IMAGE_STRING_VALUE
, 0},
8008 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8009 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8010 {":relief", IMAGE_INTEGER_VALUE
, 0},
8011 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8012 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8013 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8014 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8017 /* Structure describing the image type `svg'. Its the same type of
8018 structure defined for all image formats, handled by emacs image
8019 functions. See struct image_type in dispextern.h. */
8021 static struct image_type svg_type
=
8023 /* An identifier showing that this is an image structure for the SVG format. */
8025 /* Handle to a function that can be used to identify a SVG file. */
8027 /* Handle to function used to load a SVG file. */
8029 /* Handle to function to free sresources for SVG. */
8031 /* An internal field to link to the next image type in a list of
8032 image types, will be filled in when registering the format. */
8037 /* Return non-zero if OBJECT is a valid SVG image specification. Do
8038 this by calling parse_image_spec and supplying the keywords that
8039 identify the SVG format. */
8042 svg_image_p (Lisp_Object object
)
8044 struct image_keyword fmt
[SVG_LAST
];
8045 memcpy (fmt
, svg_format
, sizeof fmt
);
8047 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
8050 /* Must specify either the :data or :file keyword. */
8051 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
8054 #include <librsvg/rsvg.h>
8058 /* SVG library functions. */
8059 DEF_IMGLIB_FN (RsvgHandle
*, rsvg_handle_new
);
8060 DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions
);
8061 DEF_IMGLIB_FN (gboolean
, rsvg_handle_write
);
8062 DEF_IMGLIB_FN (gboolean
, rsvg_handle_close
);
8063 DEF_IMGLIB_FN (GdkPixbuf
*, rsvg_handle_get_pixbuf
);
8065 DEF_IMGLIB_FN (int, gdk_pixbuf_get_width
);
8066 DEF_IMGLIB_FN (int, gdk_pixbuf_get_height
);
8067 DEF_IMGLIB_FN (guchar
*, gdk_pixbuf_get_pixels
);
8068 DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride
);
8069 DEF_IMGLIB_FN (GdkColorspace
, gdk_pixbuf_get_colorspace
);
8070 DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels
);
8071 DEF_IMGLIB_FN (gboolean
, gdk_pixbuf_get_has_alpha
);
8072 DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample
);
8074 DEF_IMGLIB_FN (void, g_type_init
);
8075 DEF_IMGLIB_FN (void, g_object_unref
);
8076 DEF_IMGLIB_FN (void, g_error_free
);
8078 Lisp_Object Qgdk_pixbuf
, Qglib
, Qgobject
;
8081 init_svg_functions (Lisp_Object libraries
)
8083 HMODULE library
, gdklib
, glib
, gobject
;
8085 if (!(glib
= w32_delayed_load (libraries
, Qglib
))
8086 || !(gobject
= w32_delayed_load (libraries
, Qgobject
))
8087 || !(gdklib
= w32_delayed_load (libraries
, Qgdk_pixbuf
))
8088 || !(library
= w32_delayed_load (libraries
, Qsvg
)))
8091 LOAD_IMGLIB_FN (library
, rsvg_handle_new
);
8092 LOAD_IMGLIB_FN (library
, rsvg_handle_get_dimensions
);
8093 LOAD_IMGLIB_FN (library
, rsvg_handle_write
);
8094 LOAD_IMGLIB_FN (library
, rsvg_handle_close
);
8095 LOAD_IMGLIB_FN (library
, rsvg_handle_get_pixbuf
);
8097 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_width
);
8098 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_height
);
8099 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_pixels
);
8100 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8101 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8102 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8103 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8104 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8106 LOAD_IMGLIB_FN (gobject
, g_type_init
);
8107 LOAD_IMGLIB_FN (gobject
, g_object_unref
);
8108 LOAD_IMGLIB_FN (glib
, g_error_free
);
8114 /* The following aliases for library functions allow dynamic loading
8115 to be used on some platforms. */
8116 #define fn_rsvg_handle_new rsvg_handle_new
8117 #define fn_rsvg_handle_get_dimensions rsvg_handle_get_dimensions
8118 #define fn_rsvg_handle_write rsvg_handle_write
8119 #define fn_rsvg_handle_close rsvg_handle_close
8120 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8122 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8123 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8124 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8125 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8126 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8127 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8128 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8129 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8131 #define fn_g_type_init g_type_init
8132 #define fn_g_object_unref g_object_unref
8133 #define fn_g_error_free g_error_free
8134 #endif /* !HAVE_NTGUI */
8136 /* Load SVG image IMG for use on frame F. Value is non-zero if
8137 successful. this function will go into the svg_type structure, and
8138 the prototype thus needs to be compatible with that structure. */
8141 svg_load (struct frame
*f
, struct image
*img
)
8144 Lisp_Object file_name
;
8146 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8147 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8148 if (STRINGP (file_name
))
8151 unsigned char *contents
;
8154 file
= x_find_image_file (file_name
);
8155 if (!STRINGP (file
))
8157 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8161 /* Read the entire file into memory. */
8162 contents
= slurp_file (SSDATA (file
), &size
);
8163 if (contents
== NULL
)
8165 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
8168 /* If the file was slurped into memory properly, parse it. */
8169 success_p
= svg_load_image (f
, img
, contents
, size
);
8172 /* Else its not a file, its a lisp object. Load the image from a
8173 lisp object rather than a file. */
8178 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8179 if (!STRINGP (data
))
8181 image_error ("Invalid image data `%s'", data
, Qnil
);
8184 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
));
8190 /* svg_load_image is a helper function for svg_load, which does the
8191 actual loading given contents and size, apart from frame and image
8192 structures, passed from svg_load.
8194 Uses librsvg to do most of the image processing.
8196 Returns non-zero when successful. */
8198 svg_load_image (struct frame
*f
, /* Pointer to emacs frame structure. */
8199 struct image
*img
, /* Pointer to emacs image structure. */
8200 unsigned char *contents
, /* String containing the SVG XML data to be parsed. */
8201 ptrdiff_t size
) /* Size of data in bytes. */
8203 RsvgHandle
*rsvg_handle
;
8204 RsvgDimensionData dimension_data
;
8209 const guint8
*pixels
;
8212 Lisp_Object specified_bg
;
8217 /* g_type_init is a glib function that must be called prior to using
8218 gnome type library functions. */
8220 /* Make a handle to a new rsvg object. */
8221 rsvg_handle
= fn_rsvg_handle_new ();
8223 /* Parse the contents argument and fill in the rsvg_handle. */
8224 fn_rsvg_handle_write (rsvg_handle
, contents
, size
, &err
);
8225 if (err
) goto rsvg_error
;
8227 /* The parsing is complete, rsvg_handle is ready to used, close it
8228 for further writes. */
8229 fn_rsvg_handle_close (rsvg_handle
, &err
);
8230 if (err
) goto rsvg_error
;
8232 fn_rsvg_handle_get_dimensions (rsvg_handle
, &dimension_data
);
8233 if (! check_image_size (f
, dimension_data
.width
, dimension_data
.height
))
8235 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8239 /* We can now get a valid pixel buffer from the svg file, if all
8241 pixbuf
= fn_rsvg_handle_get_pixbuf (rsvg_handle
);
8242 if (!pixbuf
) goto rsvg_error
;
8243 fn_g_object_unref (rsvg_handle
);
8245 /* Extract some meta data from the svg handle. */
8246 width
= fn_gdk_pixbuf_get_width (pixbuf
);
8247 height
= fn_gdk_pixbuf_get_height (pixbuf
);
8248 pixels
= fn_gdk_pixbuf_get_pixels (pixbuf
);
8249 rowstride
= fn_gdk_pixbuf_get_rowstride (pixbuf
);
8251 /* Validate the svg meta data. */
8252 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
8253 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf
) == 4);
8254 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf
));
8255 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
8257 /* Try to create a x pixmap to hold the svg pixmap. */
8258 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8260 fn_g_object_unref (pixbuf
);
8264 init_color_table ();
8266 /* Handle alpha channel by combining the image with a background
8268 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8269 if (!STRINGP (specified_bg
)
8270 || !x_defined_color (f
, SSDATA (specified_bg
), &background
, 0))
8273 background
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8274 x_query_color (f
, &background
);
8276 ns_query_color (FRAME_BACKGROUND_COLOR (f
), &background
, 1);
8280 /* SVG pixmaps specify transparency in the last byte, so right
8281 shift 8 bits to get rid of it, since emacs doesn't support
8283 background
.red
>>= 8;
8284 background
.green
>>= 8;
8285 background
.blue
>>= 8;
8287 /* This loop handles opacity values, since Emacs assumes
8288 non-transparent images. Each pixel must be "flattened" by
8289 calculating the resulting color, given the transparency of the
8290 pixel, and the image background color. */
8291 for (y
= 0; y
< height
; ++y
)
8293 for (x
= 0; x
< width
; ++x
)
8303 opacity
= *pixels
++;
8305 red
= ((red
* opacity
)
8306 + (background
.red
* ((1 << 8) - opacity
)));
8307 green
= ((green
* opacity
)
8308 + (background
.green
* ((1 << 8) - opacity
)));
8309 blue
= ((blue
* opacity
)
8310 + (background
.blue
* ((1 << 8) - opacity
)));
8312 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
8315 pixels
+= rowstride
- 4 * width
;
8318 #ifdef COLOR_TABLE_SUPPORT
8319 /* Remember colors allocated for this image. */
8320 img
->colors
= colors_in_color_table (&img
->ncolors
);
8321 free_color_table ();
8322 #endif /* COLOR_TABLE_SUPPORT */
8324 fn_g_object_unref (pixbuf
);
8327 img
->height
= height
;
8329 /* Maybe fill in the background field while we have ximg handy.
8330 Casting avoids a GCC warning. */
8331 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8333 /* Put the image into the pixmap, then free the X image and its
8335 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8336 x_destroy_x_image (ximg
);
8341 fn_g_object_unref (rsvg_handle
);
8342 /* FIXME: Use error->message so the user knows what is the actual
8343 problem with the image. */
8344 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
8345 fn_g_error_free (err
);
8349 #endif /* defined (HAVE_RSVG) */
8354 /***********************************************************************
8356 ***********************************************************************/
8358 #ifdef HAVE_X_WINDOWS
8359 #define HAVE_GHOSTSCRIPT 1
8360 #endif /* HAVE_X_WINDOWS */
8362 #ifdef HAVE_GHOSTSCRIPT
8364 static int gs_image_p (Lisp_Object object
);
8365 static int gs_load (struct frame
*f
, struct image
*img
);
8366 static void gs_clear_image (struct frame
*f
, struct image
*img
);
8368 /* Keyword symbols. */
8370 static Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8372 /* Indices of image specification fields in gs_format, below. */
8374 enum gs_keyword_index
8392 /* Vector of image_keyword structures describing the format
8393 of valid user-defined image specifications. */
8395 static const struct image_keyword gs_format
[GS_LAST
] =
8397 {":type", IMAGE_SYMBOL_VALUE
, 1},
8398 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8399 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8400 {":file", IMAGE_STRING_VALUE
, 1},
8401 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8402 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8403 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8404 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8405 {":relief", IMAGE_INTEGER_VALUE
, 0},
8406 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8407 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8408 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8409 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8412 /* Structure describing the image type `ghostscript'. */
8414 static struct image_type gs_type
=
8424 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8427 gs_clear_image (struct frame
*f
, struct image
*img
)
8429 x_clear_image (f
, img
);
8433 /* Return non-zero if OBJECT is a valid Ghostscript image
8437 gs_image_p (Lisp_Object object
)
8439 struct image_keyword fmt
[GS_LAST
];
8443 memcpy (fmt
, gs_format
, sizeof fmt
);
8445 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
8448 /* Bounding box must be a list or vector containing 4 integers. */
8449 tem
= fmt
[GS_BOUNDING_BOX
].value
;
8452 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
8453 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
8458 else if (VECTORP (tem
))
8460 if (ASIZE (tem
) != 4)
8462 for (i
= 0; i
< 4; ++i
)
8463 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
8473 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8477 gs_load (struct frame
*f
, struct image
*img
)
8479 uprintmax_t printnum1
, printnum2
;
8480 char buffer
[sizeof " " + INT_STRLEN_BOUND (printmax_t
)];
8481 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
8483 double in_width
, in_height
;
8484 Lisp_Object pixel_colors
= Qnil
;
8486 /* Compute pixel size of pixmap needed from the given size in the
8487 image specification. Sizes in the specification are in pt. 1 pt
8488 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8490 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
8491 in_width
= INTEGERP (pt_width
) ? XFASTINT (pt_width
) / 72.0 : 0;
8492 in_width
*= FRAME_X_DISPLAY_INFO (f
)->resx
;
8493 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
8494 in_height
= INTEGERP (pt_height
) ? XFASTINT (pt_height
) / 72.0 : 0;
8495 in_height
*= FRAME_X_DISPLAY_INFO (f
)->resy
;
8497 if (! (in_width
<= INT_MAX
&& in_height
<= INT_MAX
8498 && check_image_size (f
, in_width
, in_height
)))
8500 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8503 img
->width
= in_width
;
8504 img
->height
= in_height
;
8506 /* Create the pixmap. */
8507 xassert (img
->pixmap
== NO_PIXMAP
);
8509 if (x_check_image_size (0, img
->width
, img
->height
))
8511 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8513 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8514 img
->width
, img
->height
,
8515 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
8521 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
8525 /* Call the loader to fill the pixmap. It returns a process object
8526 if successful. We do not record_unwind_protect here because
8527 other places in redisplay like calling window scroll functions
8528 don't either. Let the Lisp loader use `unwind-protect' instead. */
8529 printnum1
= FRAME_X_WINDOW (f
);
8530 printnum2
= img
->pixmap
;
8531 sprintf (buffer
, "%"pMu
" %"pMu
, printnum1
, printnum2
);
8532 window_and_pixmap_id
= build_string (buffer
);
8534 printnum1
= FRAME_FOREGROUND_PIXEL (f
);
8535 printnum2
= FRAME_BACKGROUND_PIXEL (f
);
8536 sprintf (buffer
, "%"pMu
" %"pMu
, printnum1
, printnum2
);
8537 pixel_colors
= build_string (buffer
);
8539 XSETFRAME (frame
, f
);
8540 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
8542 loader
= intern ("gs-load-image");
8544 img
->lisp_data
= call6 (loader
, frame
, img
->spec
,
8545 make_number (img
->width
),
8546 make_number (img
->height
),
8547 window_and_pixmap_id
,
8549 return PROCESSP (img
->lisp_data
);
8553 /* Kill the Ghostscript process that was started to fill PIXMAP on
8554 frame F. Called from XTread_socket when receiving an event
8555 telling Emacs that Ghostscript has finished drawing. */
8558 x_kill_gs_process (Pixmap pixmap
, struct frame
*f
)
8560 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
8565 /* Find the image containing PIXMAP. */
8566 for (i
= 0; i
< c
->used
; ++i
)
8567 if (c
->images
[i
]->pixmap
== pixmap
)
8570 /* Should someone in between have cleared the image cache, for
8571 instance, give up. */
8575 /* Kill the GS process. We should have found PIXMAP in the image
8576 cache and its image should contain a process object. */
8578 xassert (PROCESSP (img
->lisp_data
));
8579 Fkill_process (img
->lisp_data
, Qnil
);
8580 img
->lisp_data
= Qnil
;
8582 #if defined (HAVE_X_WINDOWS)
8584 /* On displays with a mutable colormap, figure out the colors
8585 allocated for the image by looking at the pixels of an XImage for
8587 class = FRAME_X_VISUAL (f
)->class;
8588 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
8594 /* Try to get an XImage for img->pixmep. */
8595 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
8596 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
8601 /* Initialize the color table. */
8602 init_color_table ();
8604 /* For each pixel of the image, look its color up in the
8605 color table. After having done so, the color table will
8606 contain an entry for each color used by the image. */
8607 for (y
= 0; y
< img
->height
; ++y
)
8608 for (x
= 0; x
< img
->width
; ++x
)
8610 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
8611 lookup_pixel_color (f
, pixel
);
8614 /* Record colors in the image. Free color table and XImage. */
8615 #ifdef COLOR_TABLE_SUPPORT
8616 img
->colors
= colors_in_color_table (&img
->ncolors
);
8617 free_color_table ();
8619 XDestroyImage (ximg
);
8621 #if 0 /* This doesn't seem to be the case. If we free the colors
8622 here, we get a BadAccess later in x_clear_image when
8623 freeing the colors. */
8624 /* We have allocated colors once, but Ghostscript has also
8625 allocated colors on behalf of us. So, to get the
8626 reference counts right, free them once. */
8628 x_free_colors (f
, img
->colors
, img
->ncolors
);
8632 image_error ("Cannot get X image of `%s'; colors will not be freed",
8637 #endif /* HAVE_X_WINDOWS */
8639 /* Now that we have the pixmap, compute mask and transform the
8640 image if requested. */
8642 postprocess_image (f
, img
);
8646 #endif /* HAVE_GHOSTSCRIPT */
8649 /***********************************************************************
8651 ***********************************************************************/
8655 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
8656 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
8659 return valid_image_p (spec
) ? Qt
: Qnil
;
8663 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
8668 if (valid_image_p (spec
))
8669 id
= lookup_image (SELECTED_FRAME (), spec
);
8672 return make_number (id
);
8675 #endif /* GLYPH_DEBUG != 0 */
8678 /***********************************************************************
8680 ***********************************************************************/
8683 /* Image types that rely on external libraries are loaded dynamically
8684 if the library is available. */
8685 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8686 define_image_type (image_type, init_lib_fn (libraries))
8688 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8689 define_image_type (image_type, 1)
8690 #endif /* HAVE_NTGUI */
8692 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 2, 2, 0,
8693 doc
: /* Initialize image library implementing image type TYPE.
8694 Return non-nil if TYPE is a supported image type.
8696 Image types pbm and xbm are prebuilt; other types are loaded here.
8697 Libraries to load are specified in alist LIBRARIES (usually, the value
8698 of `dynamic-library-alist', which see). */)
8699 (Lisp_Object type
, Lisp_Object libraries
)
8702 /* Don't try to reload the library. */
8703 Lisp_Object tested
= Fassq (type
, Vlibrary_cache
);
8705 return XCDR (tested
);
8708 /* Types pbm and xbm are built-in and always available. */
8709 if (EQ (type
, Qpbm
) || EQ (type
, Qxbm
))
8712 #if defined (HAVE_XPM) || defined (HAVE_NS)
8713 if (EQ (type
, Qxpm
))
8714 return CHECK_LIB_AVAILABLE (&xpm_type
, init_xpm_functions
, libraries
);
8717 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8718 if (EQ (type
, Qjpeg
))
8719 return CHECK_LIB_AVAILABLE (&jpeg_type
, init_jpeg_functions
, libraries
);
8722 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8723 if (EQ (type
, Qtiff
))
8724 return CHECK_LIB_AVAILABLE (&tiff_type
, init_tiff_functions
, libraries
);
8727 #if defined (HAVE_GIF) || defined (HAVE_NS)
8728 if (EQ (type
, Qgif
))
8729 return CHECK_LIB_AVAILABLE (&gif_type
, init_gif_functions
, libraries
);
8732 #if defined (HAVE_PNG) || defined (HAVE_NS)
8733 if (EQ (type
, Qpng
))
8734 return CHECK_LIB_AVAILABLE (&png_type
, init_png_functions
, libraries
);
8737 #if defined (HAVE_RSVG)
8738 if (EQ (type
, Qsvg
))
8739 return CHECK_LIB_AVAILABLE (&svg_type
, init_svg_functions
, libraries
);
8742 #if defined (HAVE_IMAGEMAGICK)
8743 if (EQ (type
, Qimagemagick
))
8744 return CHECK_LIB_AVAILABLE (&imagemagick_type
, init_imagemagick_functions
,
8748 #ifdef HAVE_GHOSTSCRIPT
8749 if (EQ (type
, Qpostscript
))
8750 return CHECK_LIB_AVAILABLE (&gs_type
, init_gs_functions
, libraries
);
8753 /* If the type is not recognized, avoid testing it ever again. */
8754 CACHE_IMAGE_TYPE (type
, Qnil
);
8759 syms_of_image (void)
8761 /* Initialize this only once, since that's what we do with Vimage_types
8762 and they are supposed to be in sync. Initializing here gives correct
8763 operation on GNU/Linux of calling dump-emacs after loading some images. */
8766 /* Must be defined now becase we're going to update it below, while
8767 defining the supported image types. */
8768 DEFVAR_LISP ("image-types", Vimage_types
,
8769 doc
: /* List of potentially supported image types.
8770 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
8771 To check whether it is really supported, use `image-type-available-p'. */);
8772 Vimage_types
= Qnil
;
8774 DEFVAR_LISP ("max-image-size", Vmax_image_size
,
8775 doc
: /* Maximum size of images.
8776 Emacs will not load an image into memory if its pixel width or
8777 pixel height exceeds this limit.
8779 If the value is an integer, it directly specifies the maximum
8780 image height and width, measured in pixels. If it is a floating
8781 point number, it specifies the maximum image height and width
8782 as a ratio to the frame height and width. If the value is
8783 non-numeric, there is no explicit limit on the size of images. */);
8784 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
8786 DEFSYM (Qpbm
, "pbm");
8787 ADD_IMAGE_TYPE (Qpbm
);
8789 DEFSYM (Qxbm
, "xbm");
8790 ADD_IMAGE_TYPE (Qxbm
);
8792 define_image_type (&xbm_type
, 1);
8793 define_image_type (&pbm_type
, 1);
8795 DEFSYM (Qcount
, "count");
8796 DEFSYM (Qextension_data
, "extension-data");
8797 DEFSYM (Qdelay
, "delay");
8799 DEFSYM (QCascent
, ":ascent");
8800 DEFSYM (QCmargin
, ":margin");
8801 DEFSYM (QCrelief
, ":relief");
8802 DEFSYM (QCconversion
, ":conversion");
8803 DEFSYM (QCcolor_symbols
, ":color-symbols");
8804 DEFSYM (QCheuristic_mask
, ":heuristic-mask");
8805 DEFSYM (QCindex
, ":index");
8806 DEFSYM (QCgeometry
, ":geometry");
8807 DEFSYM (QCcrop
, ":crop");
8808 DEFSYM (QCrotation
, ":rotation");
8809 DEFSYM (QCmatrix
, ":matrix");
8810 DEFSYM (QCcolor_adjustment
, ":color-adjustment");
8811 DEFSYM (QCmask
, ":mask");
8813 DEFSYM (Qlaplace
, "laplace");
8814 DEFSYM (Qemboss
, "emboss");
8815 DEFSYM (Qedge_detection
, "edge-detection");
8816 DEFSYM (Qheuristic
, "heuristic");
8818 DEFSYM (Qpostscript
, "postscript");
8819 #ifdef HAVE_GHOSTSCRIPT
8820 ADD_IMAGE_TYPE (Qpostscript
);
8821 DEFSYM (QCloader
, ":loader");
8822 DEFSYM (QCbounding_box
, ":bounding-box");
8823 DEFSYM (QCpt_width
, ":pt-width");
8824 DEFSYM (QCpt_height
, ":pt-height");
8825 #endif /* HAVE_GHOSTSCRIPT */
8828 DEFSYM (Qlibpng_version
, "libpng-version");
8829 Fset (Qlibpng_version
,
8831 make_number (PNG_LIBPNG_VER
)
8838 #if defined (HAVE_XPM) || defined (HAVE_NS)
8839 DEFSYM (Qxpm
, "xpm");
8840 ADD_IMAGE_TYPE (Qxpm
);
8843 #if defined (HAVE_JPEG) || defined (HAVE_NS)
8844 DEFSYM (Qjpeg
, "jpeg");
8845 ADD_IMAGE_TYPE (Qjpeg
);
8848 #if defined (HAVE_TIFF) || defined (HAVE_NS)
8849 DEFSYM (Qtiff
, "tiff");
8850 ADD_IMAGE_TYPE (Qtiff
);
8853 #if defined (HAVE_GIF) || defined (HAVE_NS)
8854 DEFSYM (Qgif
, "gif");
8855 ADD_IMAGE_TYPE (Qgif
);
8858 #if defined (HAVE_PNG) || defined (HAVE_NS)
8859 DEFSYM (Qpng
, "png");
8860 ADD_IMAGE_TYPE (Qpng
);
8863 #if defined (HAVE_IMAGEMAGICK)
8864 DEFSYM (Qimagemagick
, "imagemagick");
8865 ADD_IMAGE_TYPE (Qimagemagick
);
8868 #if defined (HAVE_RSVG)
8869 DEFSYM (Qsvg
, "svg");
8870 ADD_IMAGE_TYPE (Qsvg
);
8872 /* Other libraries used directly by svg code. */
8873 DEFSYM (Qgdk_pixbuf
, "gdk-pixbuf");
8874 DEFSYM (Qglib
, "glib");
8875 DEFSYM (Qgobject
, "gobject");
8876 #endif /* HAVE_NTGUI */
8877 #endif /* HAVE_RSVG */
8879 defsubr (&Sinit_image_library
);
8880 #ifdef HAVE_IMAGEMAGICK
8881 defsubr (&Simagemagick_types
);
8883 defsubr (&Sclear_image_cache
);
8884 defsubr (&Simage_flush
);
8885 defsubr (&Simage_size
);
8886 defsubr (&Simage_mask_p
);
8887 defsubr (&Simage_metadata
);
8891 defsubr (&Slookup_image
);
8894 DEFVAR_BOOL ("cross-disabled-images", cross_disabled_images
,
8895 doc
: /* Non-nil means always draw a cross over disabled images.
8896 Disabled images are those having a `:conversion disabled' property.
8897 A cross is always drawn on black & white displays. */);
8898 cross_disabled_images
= 0;
8900 DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path
,
8901 doc
: /* List of directories to search for window system bitmap files. */);
8902 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
8904 DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay
,
8905 doc
: /* Maximum time after which images are removed from the cache.
8906 When an image has not been displayed this many seconds, Emacs
8907 automatically removes it from the image cache. If the cache contains
8908 a large number of images, the actual eviction time may be shorter.
8909 The value can also be nil, meaning the cache is never cleared.
8911 The function `clear-image-cache' disregards this variable. */);
8912 Vimage_cache_eviction_delay
= make_number (300);
8913 #ifdef HAVE_IMAGEMAGICK
8914 DEFVAR_LISP ("imagemagick-render-type", Vimagemagick_render_type
,
8915 doc
: /* Choose between ImageMagick render methods. */);