1 /* Functions for image support on window system.
3 Copyright (C) 1989, 1992-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 /* Include this before including <setjmp.h> to work around bugs with
25 older libpng; see Bug#17429. */
26 #if defined HAVE_PNG && !defined HAVE_NS
37 #include "dispextern.h"
38 #include "blockinput.h"
41 #include "character.h"
43 #include "termhooks.h"
46 #ifdef HAVE_SYS_STAT_H
48 #endif /* HAVE_SYS_STAT_H */
50 #ifdef HAVE_SYS_TYPES_H
51 #include <sys/types.h>
52 #endif /* HAVE_SYS_TYPES_H */
54 #ifdef HAVE_WINDOW_SYSTEM
56 #endif /* HAVE_WINDOW_SYSTEM */
59 #define COLOR_TABLE_SUPPORT 1
61 typedef struct x_bitmap_record Bitmap_Record
;
62 #define GET_PIXEL(ximg, x, y) XGetPixel (ximg, x, y)
63 #define NO_PIXMAP None
65 #define PIX_MASK_RETAIN 0
66 #define PIX_MASK_DRAW 1
67 #endif /* HAVE_X_WINDOWS */
71 /* We need (or want) w32.h only when we're _not_ compiling for Cygwin. */
76 /* W32_TODO : Color tables on W32. */
77 #undef COLOR_TABLE_SUPPORT
79 typedef struct w32_bitmap_record Bitmap_Record
;
80 #define GET_PIXEL(ximg, x, y) GetPixel (ximg, x, y)
83 #define PIX_MASK_RETAIN 0
84 #define PIX_MASK_DRAW 1
86 #define x_defined_color w32_defined_color
87 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
89 #endif /* HAVE_NTGUI */
92 #undef COLOR_TABLE_SUPPORT
96 #undef COLOR_TABLE_SUPPORT
98 typedef struct ns_bitmap_record Bitmap_Record
;
100 #define GET_PIXEL(ximg, x, y) XGetPixel (ximg, x, y)
103 #define PIX_MASK_RETAIN 0
104 #define PIX_MASK_DRAW 1
106 #define x_defined_color(f, name, color_def, alloc) \
107 ns_defined_color (f, name, color_def, alloc, 0)
108 #define DefaultDepthOfScreen(screen) x_display_list->n_planes
111 static void x_disable_image (struct frame
*, struct image
*);
112 static void x_edge_detection (struct frame
*, struct image
*, Lisp_Object
,
115 static void init_color_table (void);
116 static unsigned long lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
);
117 #ifdef COLOR_TABLE_SUPPORT
118 static void free_color_table (void);
119 static unsigned long *colors_in_color_table (int *n
);
122 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
123 id, which is just an int that this section returns. Bitmaps are
124 reference counted so they can be shared among frames.
126 Bitmap indices are guaranteed to be > 0, so a negative number can
127 be used to indicate no bitmap.
129 If you use x_create_bitmap_from_data, then you must keep track of
130 the bitmaps yourself. That is, creating a bitmap from the same
131 data more than once will not be caught. */
134 /* Use with images created by ns_image_for_XPM. */
136 XGetPixel (XImagePtr ximage
, int x
, int y
)
138 return ns_get_pixel (ximage
, x
, y
);
141 /* Use with images created by ns_image_for_XPM; alpha set to 1;
142 pixel is assumed to be in RGB form. */
144 XPutPixel (XImagePtr ximage
, int x
, int y
, unsigned long pixel
)
146 ns_put_pixel (ximage
, x
, y
, pixel
);
151 /* Functions to access the contents of a bitmap, given an id. */
153 #ifdef HAVE_X_WINDOWS
155 x_bitmap_height (struct frame
*f
, ptrdiff_t id
)
157 return FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
161 x_bitmap_width (struct frame
*f
, ptrdiff_t id
)
163 return FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
167 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
169 x_bitmap_pixmap (struct frame
*f
, ptrdiff_t id
)
171 /* HAVE_NTGUI needs the explicit cast here. */
172 return (ptrdiff_t) FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
176 #ifdef HAVE_X_WINDOWS
178 x_bitmap_mask (struct frame
*f
, ptrdiff_t id
)
180 return FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
184 /* Allocate a new bitmap record. Returns index of new record. */
187 x_allocate_bitmap_record (struct frame
*f
)
189 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
192 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
193 return ++dpyinfo
->bitmaps_last
;
195 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
196 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
200 xpalloc (dpyinfo
->bitmaps
, &dpyinfo
->bitmaps_size
,
201 10, -1, sizeof *dpyinfo
->bitmaps
);
202 return ++dpyinfo
->bitmaps_last
;
205 /* Add one reference to the reference count of the bitmap with id ID. */
208 x_reference_bitmap (struct frame
*f
, ptrdiff_t id
)
210 ++FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
213 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
216 x_create_bitmap_from_data (struct frame
*f
, char *bits
, unsigned int width
, unsigned int height
)
218 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
221 #ifdef HAVE_X_WINDOWS
223 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
224 bits
, width
, height
);
227 #endif /* HAVE_X_WINDOWS */
231 bitmap
= CreateBitmap (width
, height
,
232 FRAME_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
233 FRAME_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
237 #endif /* HAVE_NTGUI */
240 void *bitmap
= ns_image_from_XBM (bits
, width
, height
);
245 id
= x_allocate_bitmap_record (f
);
248 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
249 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
252 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
253 dpyinfo
->bitmaps
[id
- 1].height
= height
;
254 dpyinfo
->bitmaps
[id
- 1].width
= width
;
255 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
257 #ifdef HAVE_X_WINDOWS
258 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
259 dpyinfo
->bitmaps
[id
- 1].have_mask
= false;
260 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
261 #endif /* HAVE_X_WINDOWS */
264 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
265 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
266 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
267 #endif /* HAVE_NTGUI */
272 /* Create bitmap from file FILE for frame F. */
275 x_create_bitmap_from_file (struct frame
*f
, Lisp_Object file
)
277 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
280 return -1; /* W32_TODO : bitmap support */
281 #endif /* HAVE_NTGUI */
285 void *bitmap
= ns_image_from_file (file
);
291 id
= x_allocate_bitmap_record (f
);
292 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
293 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
294 dpyinfo
->bitmaps
[id
- 1].file
= xlispstrdup (file
);
295 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
296 dpyinfo
->bitmaps
[id
- 1].height
= ns_image_width (bitmap
);
297 dpyinfo
->bitmaps
[id
- 1].width
= ns_image_height (bitmap
);
301 #ifdef HAVE_X_WINDOWS
302 unsigned int width
, height
;
304 int xhot
, yhot
, result
;
309 /* Look for an existing bitmap with the same name. */
310 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
312 if (dpyinfo
->bitmaps
[id
].refcount
313 && dpyinfo
->bitmaps
[id
].file
314 && !strcmp (dpyinfo
->bitmaps
[id
].file
, SSDATA (file
)))
316 ++dpyinfo
->bitmaps
[id
].refcount
;
321 /* Search bitmap-file-path for the file, if appropriate. */
322 if (openp (Vx_bitmap_file_path
, file
, Qnil
, &found
,
323 make_number (R_OK
), false)
327 filename
= SSDATA (found
);
329 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
330 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
331 if (result
!= BitmapSuccess
)
334 id
= x_allocate_bitmap_record (f
);
335 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
336 dpyinfo
->bitmaps
[id
- 1].have_mask
= false;
337 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
338 dpyinfo
->bitmaps
[id
- 1].file
= xlispstrdup (file
);
339 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
340 dpyinfo
->bitmaps
[id
- 1].height
= height
;
341 dpyinfo
->bitmaps
[id
- 1].width
= width
;
344 #endif /* HAVE_X_WINDOWS */
350 free_bitmap_record (Display_Info
*dpyinfo
, Bitmap_Record
*bm
)
352 #ifdef HAVE_X_WINDOWS
353 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
355 XFreePixmap (dpyinfo
->display
, bm
->mask
);
356 #endif /* HAVE_X_WINDOWS */
359 DeleteObject (bm
->pixmap
);
360 #endif /* HAVE_NTGUI */
363 ns_release_object (bm
->img
);
373 /* Remove reference to bitmap with id number ID. */
376 x_destroy_bitmap (struct frame
*f
, ptrdiff_t id
)
378 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
382 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
384 if (--bm
->refcount
== 0)
387 free_bitmap_record (dpyinfo
, bm
);
393 /* Free all the bitmaps for the display specified by DPYINFO. */
396 x_destroy_all_bitmaps (Display_Info
*dpyinfo
)
399 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
401 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
402 if (bm
->refcount
> 0)
403 free_bitmap_record (dpyinfo
, bm
);
405 dpyinfo
->bitmaps_last
= 0;
408 static bool x_create_x_image_and_pixmap (struct frame
*, int, int, int,
409 XImagePtr
*, Pixmap
*);
410 static void x_destroy_x_image (XImagePtr ximg
);
413 static XImagePtr_or_DC
image_get_x_image_or_dc (struct frame
*, struct image
*,
415 static void image_unget_x_image_or_dc (struct image
*, bool, XImagePtr_or_DC
,
418 static XImagePtr
image_get_x_image (struct frame
*, struct image
*, bool);
419 static void image_unget_x_image (struct image
*, bool, XImagePtr
);
420 #define image_get_x_image_or_dc(f, img, mask_p, dummy) \
421 image_get_x_image (f, img, mask_p)
422 #define image_unget_x_image_or_dc(img, mask_p, ximg, dummy) \
423 image_unget_x_image (img, mask_p, ximg)
426 #ifdef HAVE_X_WINDOWS
428 static void image_sync_to_pixmaps (struct frame
*, struct image
*);
430 /* Useful functions defined in the section
431 `Image type independent image structures' below. */
433 static unsigned long four_corners_best (XImagePtr ximg
,
436 unsigned long height
);
439 /* Create a mask of a bitmap. Note is this not a perfect mask.
440 It's nicer with some borders in this context */
443 x_create_bitmap_mask (struct frame
*f
, ptrdiff_t id
)
446 XImagePtr ximg
, mask_img
;
447 unsigned long width
, height
;
450 unsigned long x
, y
, xp
, xm
, yp
, ym
;
453 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
458 pixmap
= x_bitmap_pixmap (f
, id
);
459 width
= x_bitmap_width (f
, id
);
460 height
= x_bitmap_height (f
, id
);
463 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
472 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
477 XDestroyImage (ximg
);
481 bg
= four_corners_best (ximg
, NULL
, width
, height
);
483 for (y
= 0; y
< ximg
->height
; ++y
)
485 for (x
= 0; x
< ximg
->width
; ++x
)
487 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
488 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
489 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
490 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
491 if (XGetPixel (ximg
, x
, y
) == bg
492 && XGetPixel (ximg
, x
, yp
) == bg
493 && XGetPixel (ximg
, x
, ym
) == bg
494 && XGetPixel (ximg
, xp
, y
) == bg
495 && XGetPixel (ximg
, xp
, yp
) == bg
496 && XGetPixel (ximg
, xp
, ym
) == bg
497 && XGetPixel (ximg
, xm
, y
) == bg
498 && XGetPixel (ximg
, xm
, yp
) == bg
499 && XGetPixel (ximg
, xm
, ym
) == bg
)
500 XPutPixel (mask_img
, x
, y
, 0);
502 XPutPixel (mask_img
, x
, y
, 1);
506 eassert (input_blocked_p ());
507 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
508 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
510 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
512 dpyinfo
->bitmaps
[id
- 1].have_mask
= true;
513 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
515 XDestroyImage (ximg
);
516 x_destroy_x_image (mask_img
);
519 #endif /* HAVE_X_WINDOWS */
521 /***********************************************************************
523 ***********************************************************************/
525 /* List of supported image types. Use define_image_type to add new
526 types. Use lookup_image_type to find a type for a given symbol. */
528 static struct image_type
*image_types
;
530 /* Forward function prototypes. */
532 static struct image_type
*lookup_image_type (Lisp_Object
);
533 static void x_laplace (struct frame
*, struct image
*);
534 static void x_emboss (struct frame
*, struct image
*);
535 static void x_build_heuristic_mask (struct frame
*, struct image
*,
538 #define CACHE_IMAGE_TYPE(type, status) \
539 do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
541 #define CACHE_IMAGE_TYPE(type, status)
544 #define ADD_IMAGE_TYPE(type) \
545 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
547 /* Define a new image type from TYPE. This adds a copy of TYPE to
548 image_types and caches the loading status of TYPE. */
550 static struct image_type
*
551 define_image_type (struct image_type
*type
)
553 struct image_type
*p
= NULL
;
554 int new_type
= type
->type
;
555 bool type_valid
= true;
559 for (p
= image_types
; p
; p
= p
->next
)
560 if (p
->type
== new_type
)
565 #if defined HAVE_NTGUI && defined WINDOWSNT
566 /* If we failed to load the library before, don't try again. */
567 Lisp_Object tested
= Fassq (builtin_lisp_symbol (new_type
),
569 if (CONSP (tested
) && NILP (XCDR (tested
)))
574 type_valid
= type
->init ();
575 CACHE_IMAGE_TYPE (builtin_lisp_symbol (new_type
),
576 type_valid
? Qt
: Qnil
);
582 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
583 The initialized data segment is read-only. */
584 p
= xmalloc (sizeof *p
);
586 p
->next
= image_types
;
596 /* Value is true if OBJECT is a valid Lisp image specification. A
597 valid image specification is a list whose car is the symbol
598 `image', and whose rest is a property list. The property list must
599 contain a value for key `:type'. That value must be the name of a
600 supported image type. The rest of the property list depends on the
604 valid_image_p (Lisp_Object object
)
612 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
613 if (EQ (XCAR (tem
), QCtype
))
616 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
618 struct image_type
*type
;
619 type
= lookup_image_type (XCAR (tem
));
621 valid_p
= type
->valid_p (object
);
632 /* Log error message with format string FORMAT and argument ARG.
633 Signaling an error, e.g. when an image cannot be loaded, is not a
634 good idea because this would interrupt redisplay, and the error
635 message display would lead to another redisplay. This function
636 therefore simply displays a message. */
639 image_error (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
641 add_to_log (format
, arg1
, arg2
);
646 /***********************************************************************
648 ***********************************************************************/
650 enum image_value_type
652 IMAGE_DONT_CHECK_VALUE_TYPE
,
654 IMAGE_STRING_OR_NIL_VALUE
,
656 IMAGE_POSITIVE_INTEGER_VALUE
,
657 IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
,
658 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
661 IMAGE_FUNCTION_VALUE
,
666 /* Structure used when parsing image specifications. */
670 /* Name of keyword. */
673 /* The type of value allowed. */
674 enum image_value_type type
;
676 /* True means key must be present. */
679 /* Used to recognize duplicate keywords in a property list. */
682 /* The value that was found. */
687 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
688 has the format (image KEYWORD VALUE ...). One of the keyword/
689 value pairs must be `:type TYPE'. KEYWORDS is a vector of
690 image_keywords structures of size NKEYWORDS describing other
691 allowed keyword/value pairs. Value is true if SPEC is valid. */
694 parse_image_spec (Lisp_Object spec
, struct image_keyword
*keywords
,
695 int nkeywords
, Lisp_Object type
)
704 while (CONSP (plist
))
706 Lisp_Object key
, value
;
708 /* First element of a pair must be a symbol. */
710 plist
= XCDR (plist
);
714 /* There must follow a value. */
717 value
= XCAR (plist
);
718 plist
= XCDR (plist
);
720 /* Find key in KEYWORDS. Error if not found. */
721 for (i
= 0; i
< nkeywords
; ++i
)
722 if (strcmp (keywords
[i
].name
, SSDATA (SYMBOL_NAME (key
))) == 0)
728 /* Record that we recognized the keyword. If a keywords
729 was found more than once, it's an error. */
730 keywords
[i
].value
= value
;
731 if (keywords
[i
].count
> 1)
735 /* Check type of value against allowed type. */
736 switch (keywords
[i
].type
)
738 case IMAGE_STRING_VALUE
:
739 if (!STRINGP (value
))
743 case IMAGE_STRING_OR_NIL_VALUE
:
744 if (!STRINGP (value
) && !NILP (value
))
748 case IMAGE_SYMBOL_VALUE
:
749 if (!SYMBOLP (value
))
753 case IMAGE_POSITIVE_INTEGER_VALUE
:
754 if (! RANGED_INTEGERP (1, value
, INT_MAX
))
758 case IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
:
759 if (RANGED_INTEGERP (0, value
, INT_MAX
))
762 && RANGED_INTEGERP (0, XCAR (value
), INT_MAX
)
763 && RANGED_INTEGERP (0, XCDR (value
), INT_MAX
))
767 case IMAGE_ASCENT_VALUE
:
768 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
770 else if (RANGED_INTEGERP (0, value
, 100))
774 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
775 /* Unlike the other integer-related cases, this one does not
776 verify that VALUE fits in 'int'. This is because callers
778 if (!INTEGERP (value
) || XINT (value
) < 0)
782 case IMAGE_DONT_CHECK_VALUE_TYPE
:
785 case IMAGE_FUNCTION_VALUE
:
786 value
= indirect_function (value
);
787 if (!NILP (Ffunctionp (value
)))
791 case IMAGE_NUMBER_VALUE
:
792 if (!INTEGERP (value
) && !FLOATP (value
))
796 case IMAGE_INTEGER_VALUE
:
797 if (! TYPE_RANGED_INTEGERP (int, value
))
801 case IMAGE_BOOL_VALUE
:
802 if (!NILP (value
) && !EQ (value
, Qt
))
811 if (EQ (key
, QCtype
) && !EQ (type
, value
))
815 /* Check that all mandatory fields are present. */
816 for (i
= 0; i
< nkeywords
; ++i
)
817 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
824 /* Return the value of KEY in image specification SPEC. Value is nil
825 if KEY is not present in SPEC. Set *FOUND depending on whether KEY
826 was found in SPEC. */
829 image_spec_value (Lisp_Object spec
, Lisp_Object key
, bool *found
)
833 eassert (valid_image_p (spec
));
835 for (tail
= XCDR (spec
);
836 CONSP (tail
) && CONSP (XCDR (tail
));
837 tail
= XCDR (XCDR (tail
)))
839 if (EQ (XCAR (tail
), key
))
843 return XCAR (XCDR (tail
));
853 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
854 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
855 PIXELS non-nil means return the size in pixels, otherwise return the
856 size in canonical character units.
857 FRAME is the frame on which the image will be displayed. FRAME nil
858 or omitted means use the selected frame. */)
859 (Lisp_Object spec
, Lisp_Object pixels
, Lisp_Object frame
)
864 if (valid_image_p (spec
))
866 struct frame
*f
= decode_window_system_frame (frame
);
867 ptrdiff_t id
= lookup_image (f
, spec
);
868 struct image
*img
= IMAGE_FROM_ID (f
, id
);
869 int width
= img
->width
+ 2 * img
->hmargin
;
870 int height
= img
->height
+ 2 * img
->vmargin
;
873 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
874 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
876 size
= Fcons (make_number (width
), make_number (height
));
879 error ("Invalid image specification");
885 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
886 doc
: /* Return t if image SPEC has a mask bitmap.
887 FRAME is the frame on which the image will be displayed. FRAME nil
888 or omitted means use the selected frame. */)
889 (Lisp_Object spec
, Lisp_Object frame
)
894 if (valid_image_p (spec
))
896 struct frame
*f
= decode_window_system_frame (frame
);
897 ptrdiff_t id
= lookup_image (f
, spec
);
898 struct image
*img
= IMAGE_FROM_ID (f
, id
);
903 error ("Invalid image specification");
908 DEFUN ("image-metadata", Fimage_metadata
, Simage_metadata
, 1, 2, 0,
909 doc
: /* Return metadata for image SPEC.
910 FRAME is the frame on which the image will be displayed. FRAME nil
911 or omitted means use the selected frame. */)
912 (Lisp_Object spec
, Lisp_Object frame
)
917 if (valid_image_p (spec
))
919 struct frame
*f
= decode_window_system_frame (frame
);
920 ptrdiff_t id
= lookup_image (f
, spec
);
921 struct image
*img
= IMAGE_FROM_ID (f
, id
);
922 ext
= img
->lisp_data
;
929 /***********************************************************************
930 Image type independent image structures
931 ***********************************************************************/
933 #define MAX_IMAGE_SIZE 10.0
934 /* Allocate and return a new image structure for image specification
935 SPEC. SPEC has a hash value of HASH. */
937 static struct image
*
938 make_image (Lisp_Object spec
, EMACS_UINT hash
)
940 struct image
*img
= xzalloc (sizeof *img
);
941 Lisp_Object file
= image_spec_value (spec
, QCfile
, NULL
);
943 eassert (valid_image_p (spec
));
944 img
->dependencies
= NILP (file
) ? Qnil
: list1 (file
);
945 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
946 eassert (img
->type
!= NULL
);
948 img
->lisp_data
= Qnil
;
949 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
951 img
->corners
[BOT_CORNER
] = -1; /* Full image */
956 /* Free image IMG which was used on frame F, including its resources. */
959 free_image (struct frame
*f
, struct image
*img
)
963 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
965 /* Remove IMG from the hash table of its cache. */
967 img
->prev
->next
= img
->next
;
969 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
972 img
->next
->prev
= img
->prev
;
974 c
->images
[img
->id
] = NULL
;
976 /* Windows NT redefines 'free', but in this file, we need to
977 avoid the redefinition. */
981 /* Free resources, then free IMG. */
982 img
->type
->free (f
, img
);
987 /* Return true if the given widths and heights are valid for display. */
990 check_image_size (struct frame
*f
, int width
, int height
)
994 if (width
<= 0 || height
<= 0)
997 if (INTEGERP (Vmax_image_size
))
998 return (width
<= XINT (Vmax_image_size
)
999 && height
<= XINT (Vmax_image_size
));
1000 else if (FLOATP (Vmax_image_size
))
1004 w
= FRAME_PIXEL_WIDTH (f
);
1005 h
= FRAME_PIXEL_HEIGHT (f
);
1008 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1009 return (width
<= XFLOAT_DATA (Vmax_image_size
) * w
1010 && height
<= XFLOAT_DATA (Vmax_image_size
) * h
);
1016 /* Prepare image IMG for display on frame F. Must be called before
1017 drawing an image. */
1020 prepare_image_for_display (struct frame
*f
, struct image
*img
)
1022 /* We're about to display IMG, so set its timestamp to `now'. */
1023 img
->timestamp
= current_timespec ();
1026 /* If IMG doesn't have a pixmap yet, load it now, using the image
1027 type dependent loader function. */
1028 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1029 img
->load_failed_p
= ! img
->type
->load (f
, img
);
1031 #ifdef HAVE_X_WINDOWS
1032 if (!img
->load_failed_p
)
1035 image_sync_to_pixmaps (f
, img
);
1043 /* Value is the number of pixels for the ascent of image IMG when
1044 drawn in face FACE. */
1047 image_ascent (struct image
*img
, struct face
*face
, struct glyph_slice
*slice
)
1052 if (slice
->height
== img
->height
)
1053 height
= img
->height
+ img
->vmargin
;
1054 else if (slice
->y
== 0)
1055 height
= slice
->height
+ img
->vmargin
;
1057 height
= slice
->height
;
1059 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1064 /* W32 specific version. Why?. ++kfs */
1065 ascent
= height
/ 2 - (FONT_DESCENT (face
->font
)
1066 - FONT_BASE (face
->font
)) / 2;
1068 /* This expression is arranged so that if the image can't be
1069 exactly centered, it will be moved slightly up. This is
1070 because a typical font is `top-heavy' (due to the presence
1071 uppercase letters), so the image placement should err towards
1072 being top-heavy too. It also just generally looks better. */
1073 ascent
= (height
+ FONT_BASE (face
->font
)
1074 - FONT_DESCENT (face
->font
) + 1) / 2;
1075 #endif /* HAVE_NTGUI */
1078 ascent
= height
/ 2;
1081 ascent
= height
* (img
->ascent
/ 100.0);
1088 get_spec_bg_or_alpha_as_argb (struct image
*img
,
1091 uint32_t bgcolor
= 0;
1093 Lisp_Object bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1095 if (STRINGP (bg
) && XParseColor (FRAME_X_DISPLAY (f
),
1096 FRAME_X_COLORMAP (f
),
1099 bgcolor
= (0xff << 24) | ((xbgcolor
.red
/ 256) << 16)
1100 | ((xbgcolor
.green
/ 256) << 8) | (xbgcolor
.blue
/ 256);
1105 create_cairo_image_surface (struct image
*img
,
1106 unsigned char *data
,
1110 cairo_surface_t
*surface
;
1111 cairo_format_t format
= CAIRO_FORMAT_ARGB32
;
1112 int stride
= cairo_format_stride_for_width (format
, width
);
1113 surface
= cairo_image_surface_create_for_data (data
,
1119 img
->height
= height
;
1120 img
->cr_data
= surface
;
1121 img
->cr_data2
= data
;
1128 /* Image background colors. */
1130 /* Find the "best" corner color of a bitmap.
1131 On W32, XIMG is assumed to a device context with the bitmap selected. */
1133 static RGB_PIXEL_COLOR
1134 four_corners_best (XImagePtr_or_DC ximg
, int *corners
,
1135 unsigned long width
, unsigned long height
)
1137 RGB_PIXEL_COLOR corner_pixels
[4], best
IF_LINT (= 0);
1140 if (corners
&& corners
[BOT_CORNER
] >= 0)
1142 /* Get the colors at the corner_pixels of ximg. */
1143 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1144 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1145 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1146 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1150 /* Get the colors at the corner_pixels of ximg. */
1151 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1152 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1153 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1154 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1156 /* Choose the most frequently found color as background. */
1157 for (i
= best_count
= 0; i
< 4; ++i
)
1161 for (j
= n
= 0; j
< 4; ++j
)
1162 if (corner_pixels
[i
] == corner_pixels
[j
])
1166 best
= corner_pixels
[i
], best_count
= n
;
1172 /* Portability macros */
1176 #define Free_Pixmap(display, pixmap) \
1177 DeleteObject (pixmap)
1179 #elif defined (HAVE_NS)
1181 #define Free_Pixmap(display, pixmap) \
1182 ns_release_object (pixmap)
1186 #define Free_Pixmap(display, pixmap) \
1187 XFreePixmap (display, pixmap)
1189 #endif /* !HAVE_NTGUI && !HAVE_NS */
1192 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1193 it is guessed heuristically. If non-zero, XIMG is an existing
1194 XImage object (or device context with the image selected on W32) to
1195 use for the heuristic. */
1198 image_background (struct image
*img
, struct frame
*f
, XImagePtr_or_DC ximg
)
1200 if (! img
->background_valid
)
1201 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1203 bool free_ximg
= !ximg
;
1206 #endif /* HAVE_NTGUI */
1209 ximg
= image_get_x_image_or_dc (f
, img
, 0, &prev
);
1211 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1214 image_unget_x_image_or_dc (img
, 0, ximg
, prev
);
1216 img
->background_valid
= 1;
1219 return img
->background
;
1222 /* Return the `background_transparent' field of IMG. If IMG doesn't
1223 have one yet, it is guessed heuristically. If non-zero, MASK is an
1224 existing XImage object to use for the heuristic. */
1227 image_background_transparent (struct image
*img
, struct frame
*f
, XImagePtr_or_DC mask
)
1229 if (! img
->background_transparent_valid
)
1230 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1234 bool free_mask
= !mask
;
1237 #endif /* HAVE_NTGUI */
1240 mask
= image_get_x_image_or_dc (f
, img
, 1, &prev
);
1242 img
->background_transparent
1243 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1246 image_unget_x_image_or_dc (img
, 1, mask
, prev
);
1249 img
->background_transparent
= 0;
1251 img
->background_transparent_valid
= 1;
1254 return img
->background_transparent
;
1257 #if defined (HAVE_PNG) || defined (HAVE_NS) \
1258 || defined (HAVE_IMAGEMAGICK) || defined (HAVE_RSVG)
1260 /* Store F's background color into *BGCOLOR. */
1262 x_query_frame_background_color (struct frame
*f
, XColor
*bgcolor
)
1265 bgcolor
->pixel
= FRAME_BACKGROUND_PIXEL (f
);
1266 x_query_color (f
, bgcolor
);
1268 ns_query_color (FRAME_BACKGROUND_COLOR (f
), bgcolor
, 1);
1272 #endif /* HAVE_PNG || HAVE_NS || HAVE_IMAGEMAGICK || HAVE_RSVG */
1274 /***********************************************************************
1275 Helper functions for X image types
1276 ***********************************************************************/
1278 /* Clear X resources of image IMG on frame F according to FLAGS.
1279 FLAGS is bitwise-or of the following masks:
1280 CLEAR_IMAGE_PIXMAP free the pixmap if any.
1281 CLEAR_IMAGE_MASK means clear the mask pixmap if any.
1282 CLEAR_IMAGE_COLORS means free colors allocated for the image, if
1285 #define CLEAR_IMAGE_PIXMAP (1 << 0)
1286 #define CLEAR_IMAGE_MASK (1 << 1)
1287 #define CLEAR_IMAGE_COLORS (1 << 2)
1290 x_clear_image_1 (struct frame
*f
, struct image
*img
, int flags
)
1292 if (flags
& CLEAR_IMAGE_PIXMAP
)
1296 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1297 img
->pixmap
= NO_PIXMAP
;
1298 /* NOTE (HAVE_NS): background color is NOT an indexed color! */
1299 img
->background_valid
= 0;
1301 #ifdef HAVE_X_WINDOWS
1304 x_destroy_x_image (img
->ximg
);
1306 img
->background_valid
= 0;
1311 if (flags
& CLEAR_IMAGE_MASK
)
1315 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1316 img
->mask
= NO_PIXMAP
;
1317 img
->background_transparent_valid
= 0;
1319 #ifdef HAVE_X_WINDOWS
1322 x_destroy_x_image (img
->mask_img
);
1323 img
->mask_img
= NULL
;
1324 img
->background_transparent_valid
= 0;
1329 if ((flags
& CLEAR_IMAGE_COLORS
) && img
->ncolors
)
1331 /* W32_TODO: color table support. */
1332 #ifdef HAVE_X_WINDOWS
1333 x_free_colors (f
, img
->colors
, img
->ncolors
);
1334 #endif /* HAVE_X_WINDOWS */
1335 xfree (img
->colors
);
1342 /* Free X resources of image IMG which is used on frame F. */
1345 x_clear_image (struct frame
*f
, struct image
*img
)
1350 cairo_surface_destroy ((cairo_surface_t
*)img
->cr_data
);
1351 if (img
->cr_data2
) xfree (img
->cr_data2
);
1353 x_clear_image_1 (f
, img
,
1354 CLEAR_IMAGE_PIXMAP
| CLEAR_IMAGE_MASK
| CLEAR_IMAGE_COLORS
);
1359 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1360 cannot be allocated, use DFLT. Add a newly allocated color to
1361 IMG->colors, so that it can be freed again. Value is the pixel
1364 static unsigned long
1365 x_alloc_image_color (struct frame
*f
, struct image
*img
, Lisp_Object color_name
,
1369 unsigned long result
;
1371 eassert (STRINGP (color_name
));
1373 if (x_defined_color (f
, SSDATA (color_name
), &color
, 1)
1374 && img
->ncolors
< min (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *img
->colors
,
1377 /* This isn't called frequently so we get away with simply
1378 reallocating the color vector to the needed size, here. */
1379 ptrdiff_t ncolors
= img
->ncolors
+ 1;
1380 img
->colors
= xrealloc (img
->colors
, ncolors
* sizeof *img
->colors
);
1381 img
->colors
[ncolors
- 1] = color
.pixel
;
1382 img
->ncolors
= ncolors
;
1383 result
= color
.pixel
;
1393 /***********************************************************************
1395 ***********************************************************************/
1397 static void cache_image (struct frame
*f
, struct image
*img
);
1399 /* Return a new, initialized image cache that is allocated from the
1400 heap. Call free_image_cache to free an image cache. */
1402 struct image_cache
*
1403 make_image_cache (void)
1405 struct image_cache
*c
= xmalloc (sizeof *c
);
1408 c
->used
= c
->refcount
= 0;
1409 c
->images
= xmalloc (c
->size
* sizeof *c
->images
);
1410 c
->buckets
= xzalloc (IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
);
1415 /* Find an image matching SPEC in the cache, and return it. If no
1416 image is found, return NULL. */
1417 static struct image
*
1418 search_image_cache (struct frame
*f
, Lisp_Object spec
, EMACS_UINT hash
)
1421 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1422 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1424 if (!c
) return NULL
;
1426 /* If the image spec does not specify a background color, the cached
1427 image must have the same background color as the current frame.
1428 The foreground color must also match, for the sake of monochrome
1431 In fact, we could ignore the foreground color matching condition
1432 for color images, or if the image spec specifies :foreground;
1433 similarly we could ignore the background color matching condition
1434 for formats that don't use transparency (such as jpeg), or if the
1435 image spec specifies :background. However, the extra memory
1436 usage is probably negligible in practice, so we don't bother. */
1438 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1439 if (img
->hash
== hash
1440 && !NILP (Fequal (img
->spec
, spec
))
1441 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1442 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1448 /* Search frame F for an image with spec SPEC, and free it. */
1451 uncache_image (struct frame
*f
, Lisp_Object spec
)
1453 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1456 free_image (f
, img
);
1457 /* As display glyphs may still be referring to the image ID, we
1458 must garbage the frame (Bug#6426). */
1459 SET_FRAME_GARBAGED (f
);
1464 /* Free image cache of frame F. Be aware that X frames share images
1468 free_image_cache (struct frame
*f
)
1470 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1475 /* Cache should not be referenced by any frame when freed. */
1476 eassert (c
->refcount
== 0);
1478 for (i
= 0; i
< c
->used
; ++i
)
1479 free_image (f
, c
->images
[i
]);
1483 FRAME_IMAGE_CACHE (f
) = NULL
;
1488 /* Clear image cache of frame F. FILTER=t means free all images.
1489 FILTER=nil means clear only images that haven't been
1490 displayed for some time.
1491 Else, only free the images which have FILTER in their `dependencies'.
1492 Should be called from time to time to reduce the number of loaded images.
1493 If image-cache-eviction-delay is non-nil, this frees images in the cache
1494 which weren't displayed for at least that many seconds. */
1497 clear_image_cache (struct frame
*f
, Lisp_Object filter
)
1499 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1503 ptrdiff_t i
, nfreed
= 0;
1505 /* Block input so that we won't be interrupted by a SIGIO
1506 while being in an inconsistent state. */
1511 /* Filter image cache. */
1512 for (i
= 0; i
< c
->used
; ++i
)
1514 struct image
*img
= c
->images
[i
];
1515 if (img
&& (EQ (Qt
, filter
)
1516 || !NILP (Fmember (filter
, img
->dependencies
))))
1518 free_image (f
, img
);
1523 else if (INTEGERP (Vimage_cache_eviction_delay
))
1525 /* Free cache based on timestamp. */
1526 struct timespec old
, t
;
1528 ptrdiff_t nimages
= 0;
1530 for (i
= 0; i
< c
->used
; ++i
)
1534 /* If the number of cached images has grown unusually large,
1535 decrease the cache eviction delay (Bug#6230). */
1536 delay
= XINT (Vimage_cache_eviction_delay
);
1538 delay
= 1600 * delay
/ nimages
/ nimages
;
1539 delay
= max (delay
, 1);
1541 t
= current_timespec ();
1542 old
= timespec_sub (t
, dtotimespec (delay
));
1544 for (i
= 0; i
< c
->used
; ++i
)
1546 struct image
*img
= c
->images
[i
];
1547 if (img
&& timespec_cmp (img
->timestamp
, old
) < 0)
1549 free_image (f
, img
);
1555 /* We may be clearing the image cache because, for example,
1556 Emacs was iconified for a longer period of time. In that
1557 case, current matrices may still contain references to
1558 images freed above. So, clear these matrices. */
1561 Lisp_Object tail
, frame
;
1563 FOR_EACH_FRAME (tail
, frame
)
1565 struct frame
*fr
= XFRAME (frame
);
1566 if (FRAME_IMAGE_CACHE (fr
) == c
)
1567 clear_current_matrices (fr
);
1570 windows_or_buffers_changed
= 19;
1578 clear_image_caches (Lisp_Object filter
)
1580 /* FIXME: We want to do
1581 * struct terminal *t;
1582 * for (t = terminal_list; t; t = t->next_terminal)
1583 * clear_image_cache (t, filter); */
1584 Lisp_Object tail
, frame
;
1585 FOR_EACH_FRAME (tail
, frame
)
1586 if (FRAME_WINDOW_P (XFRAME (frame
)))
1587 clear_image_cache (XFRAME (frame
), filter
);
1590 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1592 doc
: /* Clear the image cache.
1593 FILTER nil or a frame means clear all images in the selected frame.
1594 FILTER t means clear the image caches of all frames.
1595 Anything else, means only clear those images which refer to FILTER,
1596 which is then usually a filename. */)
1597 (Lisp_Object filter
)
1599 if (!(EQ (filter
, Qnil
) || FRAMEP (filter
)))
1600 clear_image_caches (filter
);
1602 clear_image_cache (decode_window_system_frame (filter
), Qt
);
1608 DEFUN ("image-flush", Fimage_flush
, Simage_flush
,
1610 doc
: /* Flush the image with specification SPEC on frame FRAME.
1611 This removes the image from the Emacs image cache. If SPEC specifies
1612 an image file, the next redisplay of this image will read from the
1613 current contents of that file.
1615 FRAME nil or omitted means use the selected frame.
1616 FRAME t means refresh the image on all frames. */)
1617 (Lisp_Object spec
, Lisp_Object frame
)
1619 if (!valid_image_p (spec
))
1620 error ("Invalid image specification");
1625 FOR_EACH_FRAME (tail
, frame
)
1627 struct frame
*f
= XFRAME (frame
);
1628 if (FRAME_WINDOW_P (f
))
1629 uncache_image (f
, spec
);
1633 uncache_image (decode_window_system_frame (frame
), spec
);
1639 /* Compute masks and transform image IMG on frame F, as specified
1640 by the image's specification, */
1643 postprocess_image (struct frame
*f
, struct image
*img
)
1645 /* Manipulation of the image's mask. */
1648 Lisp_Object conversion
, spec
;
1653 /* `:heuristic-mask t'
1655 means build a mask heuristically.
1656 `:heuristic-mask (R G B)'
1657 `:mask (heuristic (R G B))'
1658 means build a mask from color (R G B) in the
1661 means remove a mask, if any. */
1663 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1665 x_build_heuristic_mask (f
, img
, mask
);
1670 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1672 if (EQ (mask
, Qheuristic
))
1673 x_build_heuristic_mask (f
, img
, Qt
);
1674 else if (CONSP (mask
)
1675 && EQ (XCAR (mask
), Qheuristic
))
1677 if (CONSP (XCDR (mask
)))
1678 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1680 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1682 else if (NILP (mask
) && found_p
&& img
->mask
)
1683 x_clear_image_1 (f
, img
, CLEAR_IMAGE_MASK
);
1687 /* Should we apply an image transformation algorithm? */
1688 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1689 if (EQ (conversion
, Qdisabled
))
1690 x_disable_image (f
, img
);
1691 else if (EQ (conversion
, Qlaplace
))
1693 else if (EQ (conversion
, Qemboss
))
1695 else if (CONSP (conversion
)
1696 && EQ (XCAR (conversion
), Qedge_detection
))
1699 tem
= XCDR (conversion
);
1701 x_edge_detection (f
, img
,
1702 Fplist_get (tem
, QCmatrix
),
1703 Fplist_get (tem
, QCcolor_adjustment
));
1709 /* Return the id of image with Lisp specification SPEC on frame F.
1710 SPEC must be a valid Lisp image specification (see valid_image_p). */
1713 lookup_image (struct frame
*f
, Lisp_Object spec
)
1718 /* F must be a window-system frame, and SPEC must be a valid image
1720 eassert (FRAME_WINDOW_P (f
));
1721 eassert (valid_image_p (spec
));
1723 /* Look up SPEC in the hash table of the image cache. */
1724 hash
= sxhash (spec
, 0);
1725 img
= search_image_cache (f
, spec
, hash
);
1726 if (img
&& img
->load_failed_p
)
1728 free_image (f
, img
);
1732 /* If not found, create a new image and cache it. */
1736 img
= make_image (spec
, hash
);
1737 cache_image (f
, img
);
1738 img
->load_failed_p
= ! img
->type
->load (f
, img
);
1739 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1740 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1742 /* If we can't load the image, and we don't have a width and
1743 height, use some arbitrary width and height so that we can
1744 draw a rectangle for it. */
1745 if (img
->load_failed_p
)
1749 value
= image_spec_value (spec
, QCwidth
, NULL
);
1750 img
->width
= (INTEGERP (value
)
1751 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1752 value
= image_spec_value (spec
, QCheight
, NULL
);
1753 img
->height
= (INTEGERP (value
)
1754 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1758 /* Handle image type independent image attributes
1759 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1760 `:background COLOR'. */
1761 Lisp_Object ascent
, margin
, relief
, bg
;
1764 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1765 if (INTEGERP (ascent
))
1766 img
->ascent
= XFASTINT (ascent
);
1767 else if (EQ (ascent
, Qcenter
))
1768 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1770 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1771 if (INTEGERP (margin
))
1772 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1773 else if (CONSP (margin
))
1775 img
->hmargin
= XFASTINT (XCAR (margin
));
1776 img
->vmargin
= XFASTINT (XCDR (margin
));
1779 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1780 relief_bound
= INT_MAX
- max (img
->hmargin
, img
->vmargin
);
1781 if (RANGED_INTEGERP (- relief_bound
, relief
, relief_bound
))
1783 img
->relief
= XINT (relief
);
1784 img
->hmargin
+= eabs (img
->relief
);
1785 img
->vmargin
+= eabs (img
->relief
);
1788 if (! img
->background_valid
)
1790 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1794 = x_alloc_image_color (f
, img
, bg
,
1795 FRAME_BACKGROUND_PIXEL (f
));
1796 img
->background_valid
= 1;
1800 /* Do image transformations and compute masks, unless we
1801 don't have the image yet. */
1802 if (!EQ (builtin_lisp_symbol (img
->type
->type
), Qpostscript
))
1803 postprocess_image (f
, img
);
1809 /* We're using IMG, so set its timestamp to `now'. */
1810 img
->timestamp
= current_timespec ();
1812 /* Value is the image id. */
1817 /* Cache image IMG in the image cache of frame F. */
1820 cache_image (struct frame
*f
, struct image
*img
)
1822 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1825 /* Find a free slot in c->images. */
1826 for (i
= 0; i
< c
->used
; ++i
)
1827 if (c
->images
[i
] == NULL
)
1830 /* If no free slot found, maybe enlarge c->images. */
1831 if (i
== c
->used
&& c
->used
== c
->size
)
1832 c
->images
= xpalloc (c
->images
, &c
->size
, 1, -1, sizeof *c
->images
);
1834 /* Add IMG to c->images, and assign IMG an id. */
1840 /* Add IMG to the cache's hash table. */
1841 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1842 img
->next
= c
->buckets
[i
];
1844 img
->next
->prev
= img
;
1846 c
->buckets
[i
] = img
;
1850 /* Call FN on every image in the image cache of frame F. Used to mark
1851 Lisp Objects in the image cache. */
1853 /* Mark Lisp objects in image IMG. */
1856 mark_image (struct image
*img
)
1858 mark_object (img
->spec
);
1859 mark_object (img
->dependencies
);
1861 if (!NILP (img
->lisp_data
))
1862 mark_object (img
->lisp_data
);
1867 mark_image_cache (struct image_cache
*c
)
1872 for (i
= 0; i
< c
->used
; ++i
)
1874 mark_image (c
->images
[i
]);
1880 /***********************************************************************
1881 X / NS / W32 support code
1882 ***********************************************************************/
1884 /* Return true if XIMG's size WIDTH x HEIGHT doesn't break the
1886 WIDTH and HEIGHT must both be positive.
1887 If XIMG is null, assume it is a bitmap. */
1889 x_check_image_size (XImagePtr ximg
, int width
, int height
)
1891 #ifdef HAVE_X_WINDOWS
1892 /* Respect Xlib's limits: it cannot deal with images that have more
1893 than INT_MAX (and/or UINT_MAX) bytes. And respect Emacs's limits
1894 of PTRDIFF_MAX (and/or SIZE_MAX) bytes for any object. */
1897 XLIB_BYTES_MAX
= min (INT_MAX
, UINT_MAX
),
1898 X_IMAGE_BYTES_MAX
= min (XLIB_BYTES_MAX
, min (PTRDIFF_MAX
, SIZE_MAX
))
1901 int bitmap_pad
, depth
, bytes_per_line
;
1904 bitmap_pad
= ximg
->bitmap_pad
;
1905 depth
= ximg
->depth
;
1906 bytes_per_line
= ximg
->bytes_per_line
;
1912 bytes_per_line
= (width
>> 3) + ((width
& 7) != 0);
1914 return (width
<= (INT_MAX
- (bitmap_pad
- 1)) / depth
1915 && height
<= X_IMAGE_BYTES_MAX
/ bytes_per_line
);
1917 /* FIXME: Implement this check for the HAVE_NS and HAVE_NTGUI cases.
1918 For now, assume that every image size is allowed on these systems. */
1923 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1924 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1925 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1926 via xmalloc. Print error messages via image_error if an error
1927 occurs. Value is true if successful.
1929 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1930 should indicate the bit depth of the image. */
1933 x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
, int depth
,
1934 XImagePtr
*ximg
, Pixmap
*pixmap
)
1936 #ifdef HAVE_X_WINDOWS
1937 Display
*display
= FRAME_X_DISPLAY (f
);
1938 Window window
= FRAME_X_WINDOW (f
);
1939 Screen
*screen
= FRAME_X_SCREEN (f
);
1941 eassert (input_blocked_p ());
1944 depth
= DefaultDepthOfScreen (screen
);
1945 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1946 depth
, ZPixmap
, 0, NULL
, width
, height
,
1947 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1950 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1954 if (! x_check_image_size (*ximg
, width
, height
))
1956 x_destroy_x_image (*ximg
);
1958 image_error ("Image too large (%dx%d)",
1959 make_number (width
), make_number (height
));
1963 /* Allocate image raster. */
1964 (*ximg
)->data
= xmalloc ((*ximg
)->bytes_per_line
* height
);
1966 /* Allocate a pixmap of the same size. */
1967 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1968 if (*pixmap
== NO_PIXMAP
)
1970 x_destroy_x_image (*ximg
);
1972 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1977 #endif /* HAVE_X_WINDOWS */
1981 BITMAPINFOHEADER
*header
;
1983 int scanline_width_bits
;
1985 int palette_colors
= 0;
1990 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1991 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1993 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1997 scanline_width_bits
= width
* depth
;
1998 remainder
= scanline_width_bits
% 32;
2001 scanline_width_bits
+= 32 - remainder
;
2003 /* Bitmaps with a depth less than 16 need a palette. */
2004 /* BITMAPINFO structure already contains the first RGBQUAD. */
2006 palette_colors
= 1 << (depth
- 1);
2008 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
2010 header
= &(*ximg
)->info
.bmiHeader
;
2011 memset (&(*ximg
)->info
, 0, sizeof (BITMAPINFO
));
2012 header
->biSize
= sizeof (*header
);
2013 header
->biWidth
= width
;
2014 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
2015 header
->biPlanes
= 1;
2016 header
->biBitCount
= depth
;
2017 header
->biCompression
= BI_RGB
;
2018 header
->biClrUsed
= palette_colors
;
2020 /* TODO: fill in palette. */
2023 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2024 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2025 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2026 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2027 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2028 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2029 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2030 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2033 hdc
= get_frame_dc (f
);
2035 /* Create a DIBSection and raster array for the bitmap,
2036 and store its handle in *pixmap. */
2037 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2038 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2039 /* casting avoids a GCC warning */
2040 (void **)&((*ximg
)->data
), NULL
, 0);
2042 /* Realize display palette and garbage all frames. */
2043 release_frame_dc (f
, hdc
);
2045 if (*pixmap
== NULL
)
2047 DWORD err
= GetLastError ();
2048 Lisp_Object errcode
;
2049 /* All system errors are < 10000, so the following is safe. */
2050 XSETINT (errcode
, err
);
2051 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2052 x_destroy_x_image (*ximg
);
2059 #endif /* HAVE_NTGUI */
2062 *pixmap
= ns_image_for_XPM (width
, height
, depth
);
2066 image_error ("Unable to allocate NSImage for XPM pixmap", Qnil
, Qnil
);
2075 /* Destroy XImage XIMG. Free XIMG->data. */
2078 x_destroy_x_image (XImagePtr ximg
)
2080 eassert (input_blocked_p ());
2083 #ifdef HAVE_X_WINDOWS
2086 XDestroyImage (ximg
);
2087 #endif /* HAVE_X_WINDOWS */
2089 /* Data will be freed by DestroyObject. */
2092 #endif /* HAVE_NTGUI */
2094 ns_release_object (ximg
);
2095 #endif /* HAVE_NS */
2100 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2101 are width and height of both the image and pixmap. */
2104 x_put_x_image (struct frame
*f
, XImagePtr ximg
, Pixmap pixmap
, int width
, int height
)
2106 #ifdef HAVE_X_WINDOWS
2109 eassert (input_blocked_p ());
2110 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2111 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2112 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2113 #endif /* HAVE_X_WINDOWS */
2116 #if 0 /* I don't think this is necessary looking at where it is used. */
2117 HDC hdc
= get_frame_dc (f
);
2118 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2119 release_frame_dc (f
, hdc
);
2121 #endif /* HAVE_NTGUI */
2124 eassert (ximg
== pixmap
);
2125 ns_retain_object (ximg
);
2129 /* Thin wrapper for x_create_x_image_and_pixmap, so that it matches
2130 with image_put_x_image. */
2133 image_create_x_image_and_pixmap (struct frame
*f
, struct image
*img
,
2134 int width
, int height
, int depth
,
2135 XImagePtr
*ximg
, bool mask_p
)
2137 eassert ((!mask_p
? img
->pixmap
: img
->mask
) == NO_PIXMAP
);
2139 return x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
,
2140 !mask_p
? &img
->pixmap
: &img
->mask
);
2143 /* Put X image XIMG into image IMG on frame F, as a mask if and only
2144 if MASK_P. On X, this simply records XIMG on a member of IMG, so
2145 it can be put into the pixmap afterwards via image_sync_to_pixmaps.
2146 On the other platforms, it puts XIMG into the pixmap, then frees
2147 the X image and its buffer. */
2150 image_put_x_image (struct frame
*f
, struct image
*img
, XImagePtr ximg
,
2153 #ifdef HAVE_X_WINDOWS
2156 eassert (img
->ximg
== NULL
);
2161 eassert (img
->mask_img
== NULL
);
2162 img
->mask_img
= ximg
;
2165 x_put_x_image (f
, ximg
, !mask_p
? img
->pixmap
: img
->mask
,
2166 img
->width
, img
->height
);
2167 x_destroy_x_image (ximg
);
2171 #ifdef HAVE_X_WINDOWS
2172 /* Put the X images recorded in IMG on frame F into pixmaps, then free
2173 the X images and their buffers. */
2176 image_sync_to_pixmaps (struct frame
*f
, struct image
*img
)
2180 x_put_x_image (f
, img
->ximg
, img
->pixmap
, img
->width
, img
->height
);
2181 x_destroy_x_image (img
->ximg
);
2186 x_put_x_image (f
, img
->mask_img
, img
->mask
, img
->width
, img
->height
);
2187 x_destroy_x_image (img
->mask_img
);
2188 img
->mask_img
= NULL
;
2194 /* Create a memory device context for IMG on frame F. It stores the
2195 currently selected GDI object into *PREV for future restoration by
2196 image_unget_x_image_or_dc. */
2198 static XImagePtr_or_DC
2199 image_get_x_image_or_dc (struct frame
*f
, struct image
*img
, bool mask_p
,
2202 HDC frame_dc
= get_frame_dc (f
);
2203 XImagePtr_or_DC ximg
= CreateCompatibleDC (frame_dc
);
2205 release_frame_dc (f
, frame_dc
);
2206 *prev
= SelectObject (ximg
, !mask_p
? img
->pixmap
: img
->mask
);
2212 image_unget_x_image_or_dc (struct image
*img
, bool mask_p
,
2213 XImagePtr_or_DC ximg
, HGDIOBJ prev
)
2215 SelectObject (ximg
, prev
);
2218 #else /* !HAVE_NTGUI */
2219 /* Get the X image for IMG on frame F. The resulting X image data
2220 should be treated as read-only at least on X. */
2223 image_get_x_image (struct frame
*f
, struct image
*img
, bool mask_p
)
2225 #ifdef HAVE_X_WINDOWS
2226 XImagePtr ximg_in_img
= !mask_p
? img
->ximg
: img
->mask_img
;
2231 return XGetImage (FRAME_X_DISPLAY (f
), !mask_p
? img
->pixmap
: img
->mask
,
2232 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
2233 #elif defined (HAVE_NS)
2234 XImagePtr pixmap
= !mask_p
? img
->pixmap
: img
->mask
;
2236 ns_retain_object (pixmap
);
2242 image_unget_x_image (struct image
*img
, bool mask_p
, XImagePtr ximg
)
2244 #ifdef HAVE_X_WINDOWS
2245 XImagePtr ximg_in_img
= !mask_p
? img
->ximg
: img
->mask_img
;
2248 eassert (ximg
== ximg_in_img
);
2250 XDestroyImage (ximg
);
2251 #elif defined (HAVE_NS)
2252 ns_release_object (ximg
);
2255 #endif /* !HAVE_NTGUI */
2258 /***********************************************************************
2260 ***********************************************************************/
2262 /* Find image file FILE. Look in data-directory/images, then
2263 x-bitmap-file-path. Value is the encoded full name of the file
2264 found, or nil if not found. */
2267 x_find_image_file (Lisp_Object file
)
2269 Lisp_Object file_found
, search_path
;
2272 /* TODO I think this should use something like image-load-path
2273 instead. Unfortunately, that can contain non-string elements. */
2274 search_path
= Fcons (Fexpand_file_name (build_string ("images"),
2276 Vx_bitmap_file_path
);
2278 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2279 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
, false);
2285 file_found
= ENCODE_FILE (file_found
);
2294 /* Read FILE into memory. Value is a pointer to a buffer allocated
2295 with xmalloc holding FILE's contents. Value is null if an error
2296 occurred. *SIZE is set to the size of the file. */
2298 static unsigned char *
2299 slurp_file (char *file
, ptrdiff_t *size
)
2301 FILE *fp
= emacs_fopen (file
, "rb");
2302 unsigned char *buf
= NULL
;
2307 ptrdiff_t count
= SPECPDL_INDEX ();
2308 record_unwind_protect_ptr (fclose_unwind
, fp
);
2310 if (fstat (fileno (fp
), &st
) == 0
2311 && 0 <= st
.st_size
&& st
.st_size
< min (PTRDIFF_MAX
, SIZE_MAX
))
2313 /* Report an error if we read past the purported EOF.
2314 This can happen if the file grows as we read it. */
2315 ptrdiff_t buflen
= st
.st_size
;
2316 buf
= xmalloc (buflen
+ 1);
2317 if (fread (buf
, 1, buflen
+ 1, fp
) == buflen
)
2326 unbind_to (count
, Qnil
);
2334 /***********************************************************************
2336 ***********************************************************************/
2338 static bool xbm_load (struct frame
*f
, struct image
*img
);
2339 static bool xbm_image_p (Lisp_Object object
);
2340 static bool xbm_file_p (Lisp_Object
);
2343 /* Indices of image specification fields in xbm_format, below. */
2345 enum xbm_keyword_index
2363 /* Vector of image_keyword structures describing the format
2364 of valid XBM image specifications. */
2366 static const struct image_keyword xbm_format
[XBM_LAST
] =
2368 {":type", IMAGE_SYMBOL_VALUE
, 1},
2369 {":file", IMAGE_STRING_VALUE
, 0},
2370 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2371 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2372 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2373 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2374 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2375 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2376 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
2377 {":relief", IMAGE_INTEGER_VALUE
, 0},
2378 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2379 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2380 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2383 /* Structure describing the image type XBM. */
2385 static struct image_type xbm_type
=
2387 SYMBOL_INDEX (Qxbm
),
2395 /* Tokens returned from xbm_scan. */
2404 /* Return true if OBJECT is a valid XBM-type image specification.
2405 A valid specification is a list starting with the symbol `image'
2406 The rest of the list is a property list which must contain an
2409 If the specification specifies a file to load, it must contain
2410 an entry `:file FILENAME' where FILENAME is a string.
2412 If the specification is for a bitmap loaded from memory it must
2413 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2414 WIDTH and HEIGHT are integers > 0. DATA may be:
2416 1. a string large enough to hold the bitmap data, i.e. it must
2417 have a size >= (WIDTH + 7) / 8 * HEIGHT
2419 2. a bool-vector of size >= WIDTH * HEIGHT
2421 3. a vector of strings or bool-vectors, one for each line of the
2424 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2425 may not be specified in this case because they are defined in the
2428 Both the file and data forms may contain the additional entries
2429 `:background COLOR' and `:foreground COLOR'. If not present,
2430 foreground and background of the frame on which the image is
2431 displayed is used. */
2434 xbm_image_p (Lisp_Object object
)
2436 struct image_keyword kw
[XBM_LAST
];
2438 memcpy (kw
, xbm_format
, sizeof kw
);
2439 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2442 eassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2444 if (kw
[XBM_FILE
].count
)
2446 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2449 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2451 /* In-memory XBM file. */
2452 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2460 /* Entries for `:width', `:height' and `:data' must be present. */
2461 if (!kw
[XBM_WIDTH
].count
2462 || !kw
[XBM_HEIGHT
].count
2463 || !kw
[XBM_DATA
].count
)
2466 data
= kw
[XBM_DATA
].value
;
2467 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2468 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2470 /* Check type of data, and width and height against contents of
2476 /* Number of elements of the vector must be >= height. */
2477 if (ASIZE (data
) < height
)
2480 /* Each string or bool-vector in data must be large enough
2481 for one line of the image. */
2482 for (i
= 0; i
< height
; ++i
)
2484 Lisp_Object elt
= AREF (data
, i
);
2489 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2492 else if (BOOL_VECTOR_P (elt
))
2494 if (bool_vector_size (elt
) < width
)
2501 else if (STRINGP (data
))
2504 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2507 else if (BOOL_VECTOR_P (data
))
2509 if (bool_vector_size (data
) / height
< width
)
2520 /* Scan a bitmap file. FP is the stream to read from. Value is
2521 either an enumerator from enum xbm_token, or a character for a
2522 single-character token, or 0 at end of file. If scanning an
2523 identifier, store the lexeme of the identifier in SVAL. If
2524 scanning a number, store its value in *IVAL. */
2527 xbm_scan (unsigned char **s
, unsigned char *end
, char *sval
, int *ival
)
2533 /* Skip white space. */
2534 while (*s
< end
&& (c
= *(*s
)++, c_isspace (c
)))
2539 else if (c_isdigit (c
))
2541 int value
= 0, digit
;
2543 if (c
== '0' && *s
< end
)
2546 if (c
== 'x' || c
== 'X')
2553 else if (c
>= 'a' && c
<= 'f')
2554 digit
= c
- 'a' + 10;
2555 else if (c
>= 'A' && c
<= 'F')
2556 digit
= c
- 'A' + 10;
2559 value
= 16 * value
+ digit
;
2562 else if (c_isdigit (c
))
2566 && (c
= *(*s
)++, c_isdigit (c
)))
2567 value
= 8 * value
+ c
- '0';
2574 && (c
= *(*s
)++, c_isdigit (c
)))
2575 value
= 10 * value
+ c
- '0';
2583 else if (c_isalpha (c
) || c
== '_')
2587 && (c
= *(*s
)++, (c_isalnum (c
) || c
== '_')))
2594 else if (c
== '/' && **s
== '*')
2596 /* C-style comment. */
2598 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2612 /* Create a Windows bitmap from X bitmap data. */
2614 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2616 static unsigned char swap_nibble
[16]
2617 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2618 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2619 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2620 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2622 unsigned char *bits
, *p
;
2625 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2626 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2627 bits
= alloca (height
* w2
);
2628 memset (bits
, 0, height
* w2
);
2629 for (i
= 0; i
< height
; i
++)
2632 for (j
= 0; j
< w1
; j
++)
2634 /* Bitswap XBM bytes to match how Windows does things. */
2635 unsigned char c
= *data
++;
2636 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2637 | (swap_nibble
[(c
>>4) & 0xf]));
2640 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2646 convert_mono_to_color_image (struct frame
*f
, struct image
*img
,
2647 COLORREF foreground
, COLORREF background
)
2649 HDC hdc
, old_img_dc
, new_img_dc
;
2650 HGDIOBJ old_prev
, new_prev
;
2653 hdc
= get_frame_dc (f
);
2654 old_img_dc
= CreateCompatibleDC (hdc
);
2655 new_img_dc
= CreateCompatibleDC (hdc
);
2656 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2657 release_frame_dc (f
, hdc
);
2658 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2659 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2660 /* Windows convention for mono bitmaps is black = background,
2661 white = foreground. */
2662 SetTextColor (new_img_dc
, background
);
2663 SetBkColor (new_img_dc
, foreground
);
2665 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2668 SelectObject (old_img_dc
, old_prev
);
2669 SelectObject (new_img_dc
, new_prev
);
2670 DeleteDC (old_img_dc
);
2671 DeleteDC (new_img_dc
);
2672 DeleteObject (img
->pixmap
);
2673 if (new_pixmap
== 0)
2674 fprintf (stderr
, "Failed to convert image to color.\n");
2676 img
->pixmap
= new_pixmap
;
2679 #define XBM_BIT_SHUFFLE(b) (~(b))
2683 #define XBM_BIT_SHUFFLE(b) (b)
2685 #endif /* HAVE_NTGUI */
2689 Create_Pixmap_From_Bitmap_Data (struct frame
*f
, struct image
*img
, char *data
,
2690 RGB_PIXEL_COLOR fg
, RGB_PIXEL_COLOR bg
,
2691 bool non_default_colors
)
2695 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2697 /* If colors were specified, transfer the bitmap to a color one. */
2698 if (non_default_colors
)
2699 convert_mono_to_color_image (f
, img
, fg
, bg
);
2701 #elif defined (HAVE_NS)
2702 img
->pixmap
= ns_image_from_XBM (data
, img
->width
, img
->height
);
2706 (x_check_image_size (0, img
->width
, img
->height
)
2707 ? XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2710 img
->width
, img
->height
,
2712 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)))
2714 #endif /* !HAVE_NTGUI && !HAVE_NS */
2719 /* Replacement for XReadBitmapFileData which isn't available under old
2720 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2721 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2722 the image. Return in *DATA the bitmap data allocated with xmalloc.
2723 Value is true if successful. DATA null means just test if
2724 CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR,
2725 inhibit the call to image_error when the image size is invalid (the
2726 bitmap remains unread). */
2729 xbm_read_bitmap_data (struct frame
*f
, unsigned char *contents
, unsigned char *end
,
2730 int *width
, int *height
, char **data
,
2731 bool inhibit_image_error
)
2733 unsigned char *s
= contents
;
2734 char buffer
[BUFSIZ
];
2737 int bytes_per_line
, i
, nbytes
;
2743 LA1 = xbm_scan (&s, end, buffer, &value)
2745 #define expect(TOKEN) \
2748 if (LA1 != (TOKEN)) \
2754 #define expect_ident(IDENT) \
2755 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2760 *width
= *height
= -1;
2763 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2765 /* Parse defines for width, height and hot-spots. */
2769 expect_ident ("define");
2770 expect (XBM_TK_IDENT
);
2772 if (LA1
== XBM_TK_NUMBER
)
2774 char *q
= strrchr (buffer
, '_');
2775 q
= q
? q
+ 1 : buffer
;
2776 if (strcmp (q
, "width") == 0)
2778 else if (strcmp (q
, "height") == 0)
2781 expect (XBM_TK_NUMBER
);
2784 if (!check_image_size (f
, *width
, *height
))
2786 if (!inhibit_image_error
)
2787 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
2790 else if (data
== NULL
)
2793 /* Parse bits. Must start with `static'. */
2794 expect_ident ("static");
2795 if (LA1
== XBM_TK_IDENT
)
2797 if (strcmp (buffer
, "unsigned") == 0)
2800 expect_ident ("char");
2802 else if (strcmp (buffer
, "short") == 0)
2806 if (*width
% 16 && *width
% 16 < 9)
2809 else if (strcmp (buffer
, "char") == 0)
2817 expect (XBM_TK_IDENT
);
2823 if (! x_check_image_size (0, *width
, *height
))
2825 if (!inhibit_image_error
)
2826 image_error ("Image too large (%dx%d)",
2827 make_number (*width
), make_number (*height
));
2830 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2831 nbytes
= bytes_per_line
* *height
;
2832 p
= *data
= xmalloc (nbytes
);
2836 for (i
= 0; i
< nbytes
; i
+= 2)
2839 expect (XBM_TK_NUMBER
);
2841 *p
++ = XBM_BIT_SHUFFLE (val
);
2842 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2843 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2845 if (LA1
== ',' || LA1
== '}')
2853 for (i
= 0; i
< nbytes
; ++i
)
2856 expect (XBM_TK_NUMBER
);
2858 *p
++ = XBM_BIT_SHUFFLE (val
);
2860 if (LA1
== ',' || LA1
== '}')
2885 /* Load XBM image IMG which will be displayed on frame F from buffer
2886 CONTENTS. END is the end of the buffer. Value is true if
2890 xbm_load_image (struct frame
*f
, struct image
*img
, unsigned char *contents
,
2897 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
,
2901 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2902 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2903 bool non_default_colors
= 0;
2906 eassert (img
->width
> 0 && img
->height
> 0);
2908 /* Get foreground and background colors, maybe allocate colors. */
2909 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
2912 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
2913 non_default_colors
= 1;
2915 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2918 background
= x_alloc_image_color (f
, img
, value
, background
);
2919 img
->background
= background
;
2920 img
->background_valid
= 1;
2921 non_default_colors
= 1;
2924 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
2925 foreground
, background
,
2926 non_default_colors
);
2929 if (img
->pixmap
== NO_PIXMAP
)
2931 x_clear_image (f
, img
);
2932 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
2938 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2944 /* Value is true if DATA looks like an in-memory XBM file. */
2947 xbm_file_p (Lisp_Object data
)
2950 return (STRINGP (data
)
2951 && xbm_read_bitmap_data (NULL
, SDATA (data
),
2952 (SDATA (data
) + SBYTES (data
)),
2957 /* Fill image IMG which is used on frame F with pixmap data. Value is
2958 true if successful. */
2961 xbm_load (struct frame
*f
, struct image
*img
)
2964 Lisp_Object file_name
;
2966 eassert (xbm_image_p (img
->spec
));
2968 /* If IMG->spec specifies a file name, create a non-file spec from it. */
2969 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
2970 if (STRINGP (file_name
))
2973 unsigned char *contents
;
2976 file
= x_find_image_file (file_name
);
2977 if (!STRINGP (file
))
2979 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
2983 contents
= slurp_file (SSDATA (file
), &size
);
2984 if (contents
== NULL
)
2986 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2990 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
2995 struct image_keyword fmt
[XBM_LAST
];
2997 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2998 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2999 bool non_default_colors
= 0;
3002 bool in_memory_file_p
= 0;
3004 /* See if data looks like an in-memory XBM file. */
3005 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
3006 in_memory_file_p
= xbm_file_p (data
);
3008 /* Parse the image specification. */
3009 memcpy (fmt
, xbm_format
, sizeof fmt
);
3010 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
3013 /* Get specified width, and height. */
3014 if (!in_memory_file_p
)
3016 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
3017 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
3018 eassert (img
->width
> 0 && img
->height
> 0);
3019 if (!check_image_size (f
, img
->width
, img
->height
))
3021 image_error ("Invalid image size (see `max-image-size')",
3027 /* Get foreground and background colors, maybe allocate colors. */
3028 if (fmt
[XBM_FOREGROUND
].count
3029 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3031 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3033 non_default_colors
= 1;
3036 if (fmt
[XBM_BACKGROUND
].count
3037 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3039 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3041 non_default_colors
= 1;
3044 if (in_memory_file_p
)
3045 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3056 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3058 SAFE_NALLOCA (bits
, nbytes
, img
->height
);
3060 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3062 Lisp_Object line
= AREF (data
, i
);
3064 memcpy (p
, SDATA (line
), nbytes
);
3066 memcpy (p
, bool_vector_data (line
), nbytes
);
3069 else if (STRINGP (data
))
3070 bits
= SSDATA (data
);
3072 bits
= (char *) bool_vector_data (data
);
3078 /* Windows mono bitmaps are reversed compared with X. */
3079 invertedBits
= bits
;
3080 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3081 SAFE_NALLOCA (bits
, nbytes
, img
->height
);
3082 for (i
= 0; i
< nbytes
; i
++)
3083 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
3086 /* Create the pixmap. */
3088 if (x_check_image_size (0, img
->width
, img
->height
))
3089 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3090 foreground
, background
,
3091 non_default_colors
);
3093 img
->pixmap
= NO_PIXMAP
;
3099 image_error ("Unable to create pixmap for XBM image `%s'",
3101 x_clear_image (f
, img
);
3113 /***********************************************************************
3115 ***********************************************************************/
3117 #if defined (HAVE_XPM) || defined (HAVE_NS)
3119 static bool xpm_image_p (Lisp_Object object
);
3120 static bool xpm_load (struct frame
*f
, struct image
*img
);
3122 #endif /* HAVE_XPM || HAVE_NS */
3126 /* Indicate to xpm.h that we don't have Xlib. */
3128 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3129 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3130 #define XColor xpm_XColor
3131 #define XImage xpm_XImage
3132 #define Display xpm_Display
3133 #define PIXEL_ALREADY_TYPEDEFED
3134 #include "X11/xpm.h"
3139 #undef PIXEL_ALREADY_TYPEDEFED
3141 #include "X11/xpm.h"
3142 #endif /* HAVE_NTGUI */
3143 #endif /* HAVE_XPM */
3145 #if defined (HAVE_XPM) || defined (HAVE_NS)
3147 /* Indices of image specification fields in xpm_format, below. */
3149 enum xpm_keyword_index
3165 /* Vector of image_keyword structures describing the format
3166 of valid XPM image specifications. */
3168 static const struct image_keyword xpm_format
[XPM_LAST
] =
3170 {":type", IMAGE_SYMBOL_VALUE
, 1},
3171 {":file", IMAGE_STRING_VALUE
, 0},
3172 {":data", IMAGE_STRING_VALUE
, 0},
3173 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3174 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
3175 {":relief", IMAGE_INTEGER_VALUE
, 0},
3176 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3177 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3178 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3179 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3180 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3183 #if defined HAVE_NTGUI && defined WINDOWSNT
3184 static bool init_xpm_functions (void);
3186 #define init_xpm_functions NULL
3189 /* Structure describing the image type XPM. */
3191 static struct image_type xpm_type
=
3193 SYMBOL_INDEX (Qxpm
),
3201 #ifdef HAVE_X_WINDOWS
3203 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3204 functions for allocating image colors. Our own functions handle
3205 color allocation failures more gracefully than the ones on the XPM
3209 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3210 #define ALLOC_XPM_COLORS
3212 #endif /* USE_CAIRO */
3213 #endif /* HAVE_X_WINDOWS */
3215 #ifdef ALLOC_XPM_COLORS
3217 static struct xpm_cached_color
*xpm_cache_color (struct frame
*, char *,
3220 /* An entry in a hash table used to cache color definitions of named
3221 colors. This cache is necessary to speed up XPM image loading in
3222 case we do color allocations ourselves. Without it, we would need
3223 a call to XParseColor per pixel in the image. */
3225 struct xpm_cached_color
3227 /* Next in collision chain. */
3228 struct xpm_cached_color
*next
;
3230 /* Color definition (RGB and pixel color). */
3234 char name
[FLEXIBLE_ARRAY_MEMBER
];
3237 /* The hash table used for the color cache, and its bucket vector
3240 #define XPM_COLOR_CACHE_BUCKETS 1001
3241 static struct xpm_cached_color
**xpm_color_cache
;
3243 /* Initialize the color cache. */
3246 xpm_init_color_cache (struct frame
*f
, XpmAttributes
*attrs
)
3248 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3249 xpm_color_cache
= xzalloc (nbytes
);
3250 init_color_table ();
3252 if (attrs
->valuemask
& XpmColorSymbols
)
3257 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3258 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3259 attrs
->colorsymbols
[i
].value
, &color
))
3261 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3263 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3268 /* Free the color cache. */
3271 xpm_free_color_cache (void)
3273 struct xpm_cached_color
*p
, *next
;
3276 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3277 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3283 xfree (xpm_color_cache
);
3284 xpm_color_cache
= NULL
;
3285 free_color_table ();
3288 /* Return the bucket index for color named COLOR_NAME in the color
3292 xpm_color_bucket (char *color_name
)
3294 EMACS_UINT hash
= hash_string (color_name
, strlen (color_name
));
3295 return hash
% XPM_COLOR_CACHE_BUCKETS
;
3299 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3300 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3303 static struct xpm_cached_color
*
3304 xpm_cache_color (struct frame
*f
, char *color_name
, XColor
*color
, int bucket
)
3307 struct xpm_cached_color
*p
;
3310 bucket
= xpm_color_bucket (color_name
);
3312 nbytes
= offsetof (struct xpm_cached_color
, name
) + strlen (color_name
) + 1;
3313 p
= xmalloc (nbytes
);
3314 strcpy (p
->name
, color_name
);
3316 p
->next
= xpm_color_cache
[bucket
];
3317 xpm_color_cache
[bucket
] = p
;
3321 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3322 return the cached definition in *COLOR. Otherwise, make a new
3323 entry in the cache and allocate the color. Value is false if color
3324 allocation failed. */
3327 xpm_lookup_color (struct frame
*f
, char *color_name
, XColor
*color
)
3329 struct xpm_cached_color
*p
;
3330 int h
= xpm_color_bucket (color_name
);
3332 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3333 if (strcmp (p
->name
, color_name
) == 0)
3338 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3341 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3343 p
= xpm_cache_color (f
, color_name
, color
, h
);
3345 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3346 with transparency, and it's useful. */
3347 else if (strcmp ("opaque", color_name
) == 0)
3349 memset (color
, 0, sizeof (XColor
)); /* Is this necessary/correct? */
3350 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3351 p
= xpm_cache_color (f
, color_name
, color
, h
);
3358 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3359 CLOSURE is a pointer to the frame on which we allocate the
3360 color. Return in *COLOR the allocated color. Value is non-zero
3364 xpm_alloc_color (Display
*dpy
, Colormap cmap
, char *color_name
, XColor
*color
,
3367 return xpm_lookup_color (closure
, color_name
, color
);
3371 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3372 is a pointer to the frame on which we allocate the color. Value is
3373 non-zero if successful. */
3376 xpm_free_colors (Display
*dpy
, Colormap cmap
, Pixel
*pixels
, int npixels
, void *closure
)
3381 #endif /* ALLOC_XPM_COLORS */
3386 /* XPM library details. */
3388 DEF_DLL_FN (void, XpmFreeAttributes
, (XpmAttributes
*));
3389 DEF_DLL_FN (int, XpmCreateImageFromBuffer
,
3390 (Display
*, char *, xpm_XImage
**,
3391 xpm_XImage
**, XpmAttributes
*));
3392 DEF_DLL_FN (int, XpmReadFileToImage
,
3393 (Display
*, char *, xpm_XImage
**,
3394 xpm_XImage
**, XpmAttributes
*));
3395 DEF_DLL_FN (void, XImageFree
, (xpm_XImage
*));
3398 init_xpm_functions (void)
3402 if (!(library
= w32_delayed_load (Qxpm
)))
3405 LOAD_DLL_FN (library
, XpmFreeAttributes
);
3406 LOAD_DLL_FN (library
, XpmCreateImageFromBuffer
);
3407 LOAD_DLL_FN (library
, XpmReadFileToImage
);
3408 LOAD_DLL_FN (library
, XImageFree
);
3413 # undef XpmCreateImageFromBuffer
3414 # undef XpmFreeAttributes
3415 # undef XpmReadFileToImage
3417 # define XImageFree fn_XImageFree
3418 # define XpmCreateImageFromBuffer fn_XpmCreateImageFromBuffer
3419 # define XpmFreeAttributes fn_XpmFreeAttributes
3420 # define XpmReadFileToImage fn_XpmReadFileToImage
3422 #endif /* WINDOWSNT */
3424 /* Value is true if COLOR_SYMBOLS is a valid color symbols list
3425 for XPM images. Such a list must consist of conses whose car and
3429 xpm_valid_color_symbols_p (Lisp_Object color_symbols
)
3431 while (CONSP (color_symbols
))
3433 Lisp_Object sym
= XCAR (color_symbols
);
3435 || !STRINGP (XCAR (sym
))
3436 || !STRINGP (XCDR (sym
)))
3438 color_symbols
= XCDR (color_symbols
);
3441 return NILP (color_symbols
);
3445 /* Value is true if OBJECT is a valid XPM image specification. */
3448 xpm_image_p (Lisp_Object object
)
3450 struct image_keyword fmt
[XPM_LAST
];
3451 memcpy (fmt
, xpm_format
, sizeof fmt
);
3452 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3453 /* Either `:file' or `:data' must be present. */
3454 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3455 /* Either no `:color-symbols' or it's a list of conses
3456 whose car and cdr are strings. */
3457 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3458 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3461 #endif /* HAVE_XPM || HAVE_NS */
3463 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3465 x_create_bitmap_from_xpm_data (struct frame
*f
, const char **bits
)
3467 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
3470 XpmAttributes attrs
;
3471 Pixmap bitmap
, mask
;
3473 memset (&attrs
, 0, sizeof attrs
);
3475 attrs
.visual
= FRAME_X_VISUAL (f
);
3476 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3477 attrs
.valuemask
|= XpmVisual
;
3478 attrs
.valuemask
|= XpmColormap
;
3480 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3481 (char **) bits
, &bitmap
, &mask
, &attrs
);
3482 if (rc
!= XpmSuccess
)
3484 XpmFreeAttributes (&attrs
);
3488 id
= x_allocate_bitmap_record (f
);
3489 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3490 dpyinfo
->bitmaps
[id
- 1].have_mask
= true;
3491 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3492 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3493 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3494 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3495 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3496 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3498 XpmFreeAttributes (&attrs
);
3501 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3503 /* Load image IMG which will be displayed on frame F. Value is
3504 true if successful. */
3509 xpm_load (struct frame
*f
, struct image
*img
)
3512 XpmAttributes attrs
;
3513 Lisp_Object specified_file
, color_symbols
;
3518 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3519 #endif /* HAVE_NTGUI */
3521 /* Configure the XPM lib. Use the visual of frame F. Allocate
3522 close colors. Return colors allocated. */
3523 memset (&attrs
, 0, sizeof attrs
);
3526 attrs
.visual
= FRAME_X_VISUAL (f
);
3527 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3528 attrs
.valuemask
|= XpmVisual
;
3529 attrs
.valuemask
|= XpmColormap
;
3530 #endif /* HAVE_NTGUI */
3532 #ifdef ALLOC_XPM_COLORS
3533 /* Allocate colors with our own functions which handle
3534 failing color allocation more gracefully. */
3535 attrs
.color_closure
= f
;
3536 attrs
.alloc_color
= xpm_alloc_color
;
3537 attrs
.free_colors
= xpm_free_colors
;
3538 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3539 #else /* not ALLOC_XPM_COLORS */
3540 /* Let the XPM lib allocate colors. */
3541 attrs
.valuemask
|= XpmReturnAllocPixels
;
3542 #ifdef XpmAllocCloseColors
3543 attrs
.alloc_close_colors
= 1;
3544 attrs
.valuemask
|= XpmAllocCloseColors
;
3545 #else /* not XpmAllocCloseColors */
3546 attrs
.closeness
= 600;
3547 attrs
.valuemask
|= XpmCloseness
;
3548 #endif /* not XpmAllocCloseColors */
3549 #endif /* ALLOC_XPM_COLORS */
3551 /* If image specification contains symbolic color definitions, add
3552 these to `attrs'. */
3553 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3554 if (CONSP (color_symbols
))
3557 XpmColorSymbol
*xpm_syms
;
3560 attrs
.valuemask
|= XpmColorSymbols
;
3562 /* Count number of symbols. */
3563 attrs
.numsymbols
= 0;
3564 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3567 /* Allocate an XpmColorSymbol array. */
3568 SAFE_NALLOCA (xpm_syms
, 1, attrs
.numsymbols
);
3569 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3570 memset (xpm_syms
, 0, size
);
3571 attrs
.colorsymbols
= xpm_syms
;
3573 /* Fill the color symbol array. */
3574 for (tail
= color_symbols
, i
= 0;
3576 ++i
, tail
= XCDR (tail
))
3580 char *empty_string
= (char *) "";
3582 if (!CONSP (XCAR (tail
)))
3584 xpm_syms
[i
].name
= empty_string
;
3585 xpm_syms
[i
].value
= empty_string
;
3588 name
= XCAR (XCAR (tail
));
3589 color
= XCDR (XCAR (tail
));
3591 SAFE_ALLOCA_STRING (xpm_syms
[i
].name
, name
);
3593 xpm_syms
[i
].name
= empty_string
;
3594 if (STRINGP (color
))
3595 SAFE_ALLOCA_STRING (xpm_syms
[i
].value
, color
);
3597 xpm_syms
[i
].value
= empty_string
;
3601 /* Create a pixmap for the image, either from a file, or from a
3602 string buffer containing data in the same format as an XPM file. */
3603 #ifdef ALLOC_XPM_COLORS
3604 xpm_init_color_cache (f
, &attrs
);
3607 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3611 HDC frame_dc
= get_frame_dc (f
);
3612 hdc
= CreateCompatibleDC (frame_dc
);
3613 release_frame_dc (f
, frame_dc
);
3615 #endif /* HAVE_NTGUI */
3617 if (STRINGP (specified_file
))
3619 Lisp_Object file
= x_find_image_file (specified_file
);
3620 if (!STRINGP (file
))
3622 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3623 #ifdef ALLOC_XPM_COLORS
3624 xpm_free_color_cache ();
3632 /* FILE is encoded in UTF-8, but image libraries on Windows
3633 support neither UTF-8 nor UTF-16 encoded file names. So we
3634 need to re-encode it in ANSI. */
3635 file
= ansi_encode_filename (file
);
3637 /* XpmReadFileToPixmap is not available in the Windows port of
3638 libxpm. But XpmReadFileToImage almost does what we want. */
3639 rc
= XpmReadFileToImage (&hdc
, SDATA (file
),
3640 &xpm_image
, &xpm_mask
,
3643 rc
= XpmReadFileToImage (FRAME_X_DISPLAY (f
), SSDATA (file
),
3644 &img
->ximg
, &img
->mask_img
,
3646 #endif /* HAVE_NTGUI */
3650 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3651 if (!STRINGP (buffer
))
3653 image_error ("Invalid image data `%s'", buffer
, Qnil
);
3654 #ifdef ALLOC_XPM_COLORS
3655 xpm_free_color_cache ();
3661 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3662 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3663 rc
= XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3664 &xpm_image
, &xpm_mask
,
3667 rc
= XpmCreateImageFromBuffer (FRAME_X_DISPLAY (f
), SSDATA (buffer
),
3668 &img
->ximg
, &img
->mask_img
,
3670 #endif /* HAVE_NTGUI */
3674 // Load very specific Xpm:s.
3675 if (rc
== XpmSuccess
3676 && img
->ximg
->format
== ZPixmap
3677 && img
->ximg
->bits_per_pixel
== 32
3678 && (! img
->mask_img
|| img
->mask_img
->bits_per_pixel
== 1))
3680 int width
= img
->ximg
->width
;
3681 int height
= img
->ximg
->height
;
3682 unsigned char *data
= (unsigned char *) xmalloc (width
*height
*4);
3684 uint32_t *od
= (uint32_t *)data
;
3685 uint32_t *id
= (uint32_t *)img
->ximg
->data
;
3686 unsigned char *mid
= img
->mask_img
? img
->mask_img
->data
: 0;
3687 uint32_t bgcolor
= get_spec_bg_or_alpha_as_argb (img
, f
);
3689 for (i
= 0; i
< height
; ++i
)
3692 for (k
= 0; k
< width
; ++k
)
3694 int idx
= i
* img
->ximg
->bytes_per_line
/4 + k
;
3695 int maskidx
= mid
? i
* img
->mask_img
->bytes_per_line
+ k
/8 : 0;
3696 int mask
= mid
? mid
[maskidx
] & (1 << (k
% 8)) : 1;
3698 if (mask
) od
[idx
] = id
[idx
] + 0xff000000; // ff => full alpha
3699 else od
[idx
] = bgcolor
;
3703 create_cairo_image_surface (img
, data
, width
, height
);
3707 rc
= XpmFileInvalid
;
3708 x_clear_image (f
, img
);
3711 #ifdef HAVE_X_WINDOWS
3712 if (rc
== XpmSuccess
)
3714 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3715 img
->ximg
->width
, img
->ximg
->height
,
3717 if (img
->pixmap
== NO_PIXMAP
)
3719 x_clear_image (f
, img
);
3722 else if (img
->mask_img
)
3724 img
->mask
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3725 img
->mask_img
->width
,
3726 img
->mask_img
->height
,
3727 img
->mask_img
->depth
);
3728 if (img
->mask
== NO_PIXMAP
)
3730 x_clear_image (f
, img
);
3736 #endif /* ! USE_CAIRO */
3738 if (rc
== XpmSuccess
)
3740 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3741 img
->colors
= colors_in_color_table (&img
->ncolors
);
3742 #else /* not ALLOC_XPM_COLORS */
3746 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3747 plus some duplicate attributes. */
3748 if (xpm_image
&& xpm_image
->bitmap
)
3750 img
->pixmap
= xpm_image
->bitmap
;
3751 /* XImageFree in libXpm frees XImage struct without destroying
3752 the bitmap, which is what we want. */
3753 XImageFree (xpm_image
);
3755 if (xpm_mask
&& xpm_mask
->bitmap
)
3757 /* The mask appears to be inverted compared with what we expect.
3758 TODO: invert our expectations. See other places where we
3759 have to invert bits because our idea of masks is backwards. */
3761 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3763 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3764 SelectObject (hdc
, old_obj
);
3766 img
->mask
= xpm_mask
->bitmap
;
3767 XImageFree (xpm_mask
);
3772 #endif /* HAVE_NTGUI */
3774 /* Remember allocated colors. */
3775 img
->colors
= xnmalloc (attrs
.nalloc_pixels
, sizeof *img
->colors
);
3776 img
->ncolors
= attrs
.nalloc_pixels
;
3777 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3779 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3780 #ifdef DEBUG_X_COLORS
3781 register_color (img
->colors
[i
]);
3784 #endif /* not ALLOC_XPM_COLORS */
3786 img
->width
= attrs
.width
;
3787 img
->height
= attrs
.height
;
3788 eassert (img
->width
> 0 && img
->height
> 0);
3790 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3791 XpmFreeAttributes (&attrs
);
3793 #ifdef HAVE_X_WINDOWS
3794 /* Maybe fill in the background field while we have ximg handy. */
3795 IMAGE_BACKGROUND (img
, f
, img
->ximg
);
3797 /* Fill in the background_transparent field while we have the
3799 image_background_transparent (img
, f
, img
->mask_img
);
3806 #endif /* HAVE_NTGUI */
3811 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3814 case XpmFileInvalid
:
3815 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3819 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3822 case XpmColorFailed
:
3823 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3827 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3832 #ifdef ALLOC_XPM_COLORS
3833 xpm_free_color_cache ();
3836 return rc
== XpmSuccess
;
3839 #endif /* HAVE_XPM */
3841 #if defined (HAVE_NS) && !defined (HAVE_XPM)
3843 /* XPM support functions for NS where libxpm is not available.
3844 Only XPM version 3 (without any extensions) is supported. */
3846 static void xpm_put_color_table_v (Lisp_Object
, const unsigned char *,
3848 static Lisp_Object
xpm_get_color_table_v (Lisp_Object
,
3849 const unsigned char *, int);
3850 static void xpm_put_color_table_h (Lisp_Object
, const unsigned char *,
3852 static Lisp_Object
xpm_get_color_table_h (Lisp_Object
,
3853 const unsigned char *, int);
3855 /* Tokens returned from xpm_scan. */
3864 /* Scan an XPM data and return a character (< 256) or a token defined
3865 by enum xpm_token above. *S and END are the start (inclusive) and
3866 the end (exclusive) addresses of the data, respectively. Advance
3867 *S while scanning. If token is either XPM_TK_IDENT or
3868 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3869 length of the corresponding token, respectively. */
3872 xpm_scan (const unsigned char **s
,
3873 const unsigned char *end
,
3874 const unsigned char **beg
,
3881 /* Skip white-space. */
3882 while (*s
< end
&& (c
= *(*s
)++, c_isspace (c
)))
3885 /* gnus-pointer.xpm uses '-' in its identifier.
3886 sb-dir-plus.xpm uses '+' in its identifier. */
3887 if (c_isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3891 && (c
= **s
, c_isalnum (c
)
3892 || c
== '_' || c
== '-' || c
== '+'))
3895 return XPM_TK_IDENT
;
3900 while (*s
< end
&& **s
!= '"')
3905 return XPM_TK_STRING
;
3909 if (*s
< end
&& **s
== '*')
3911 /* C-style comment. */
3915 while (*s
< end
&& *(*s
)++ != '*')
3918 while (*s
< end
&& **s
!= '/');
3932 /* Functions for color table lookup in XPM data. A key is a string
3933 specifying the color of each pixel in XPM data. A value is either
3934 an integer that specifies a pixel color, Qt that specifies
3935 transparency, or Qnil for the unspecified color. If the length of
3936 the key string is one, a vector is used as a table. Otherwise, a
3937 hash table is used. */
3940 xpm_make_color_table_v (void (**put_func
) (Lisp_Object
,
3941 const unsigned char *,
3944 Lisp_Object (**get_func
) (Lisp_Object
,
3945 const unsigned char *,
3948 *put_func
= xpm_put_color_table_v
;
3949 *get_func
= xpm_get_color_table_v
;
3950 return Fmake_vector (make_number (256), Qnil
);
3954 xpm_put_color_table_v (Lisp_Object color_table
,
3955 const unsigned char *chars_start
,
3959 ASET (color_table
, *chars_start
, color
);
3963 xpm_get_color_table_v (Lisp_Object color_table
,
3964 const unsigned char *chars_start
,
3967 return AREF (color_table
, *chars_start
);
3971 xpm_make_color_table_h (void (**put_func
) (Lisp_Object
,
3972 const unsigned char *,
3975 Lisp_Object (**get_func
) (Lisp_Object
,
3976 const unsigned char *,
3979 *put_func
= xpm_put_color_table_h
;
3980 *get_func
= xpm_get_color_table_h
;
3981 return make_hash_table (hashtest_equal
, make_number (DEFAULT_HASH_SIZE
),
3982 make_float (DEFAULT_REHASH_SIZE
),
3983 make_float (DEFAULT_REHASH_THRESHOLD
),
3988 xpm_put_color_table_h (Lisp_Object color_table
,
3989 const unsigned char *chars_start
,
3993 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3994 EMACS_UINT hash_code
;
3995 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
3997 hash_lookup (table
, chars
, &hash_code
);
3998 hash_put (table
, chars
, color
, hash_code
);
4002 xpm_get_color_table_h (Lisp_Object color_table
,
4003 const unsigned char *chars_start
,
4006 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
4008 hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
), NULL
);
4010 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
4013 enum xpm_color_key
{
4021 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
4024 xpm_str_to_color_key (const char *s
)
4028 for (i
= 0; i
< ARRAYELTS (xpm_color_key_strings
); i
++)
4029 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
4035 xpm_load_image (struct frame
*f
,
4037 const unsigned char *contents
,
4038 const unsigned char *end
)
4040 const unsigned char *s
= contents
, *beg
, *str
;
4041 unsigned char buffer
[BUFSIZ
];
4042 int width
, height
, x
, y
;
4043 int num_colors
, chars_per_pixel
;
4046 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
4047 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
4048 Lisp_Object frame
, color_symbols
, color_table
;
4050 bool have_mask
= false;
4051 XImagePtr ximg
= NULL
, mask_img
= NULL
;
4054 LA1 = xpm_scan (&s, end, &beg, &len)
4056 #define expect(TOKEN) \
4059 if (LA1 != (TOKEN)) \
4065 #define expect_ident(IDENT) \
4066 if (LA1 == XPM_TK_IDENT \
4067 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4072 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4076 expect_ident ("static");
4077 expect_ident ("char");
4079 expect (XPM_TK_IDENT
);
4084 expect (XPM_TK_STRING
);
4087 memcpy (buffer
, beg
, len
);
4089 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4090 &num_colors
, &chars_per_pixel
) != 4
4091 || width
<= 0 || height
<= 0
4092 || num_colors
<= 0 || chars_per_pixel
<= 0)
4095 if (!check_image_size (f
, width
, height
))
4097 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
4101 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0)
4103 || !image_create_x_image_and_pixmap (f
, img
, width
, height
, 1,
4108 image_error ("Image too large", Qnil
, Qnil
);
4114 XSETFRAME (frame
, f
);
4115 if (!NILP (Fxw_display_color_p (frame
)))
4116 best_key
= XPM_COLOR_KEY_C
;
4117 else if (!NILP (Fx_display_grayscale_p (frame
)))
4118 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4119 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4121 best_key
= XPM_COLOR_KEY_M
;
4123 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4124 if (chars_per_pixel
== 1)
4125 color_table
= xpm_make_color_table_v (&put_color_table
,
4128 color_table
= xpm_make_color_table_h (&put_color_table
,
4131 while (num_colors
-- > 0)
4133 char *color
, *max_color
;
4134 int key
, next_key
, max_key
= 0;
4135 Lisp_Object symbol_color
= Qnil
, color_val
;
4138 expect (XPM_TK_STRING
);
4139 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4141 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4142 buffer
[len
- chars_per_pixel
] = '\0';
4144 str
= strtok (buffer
, " \t");
4147 key
= xpm_str_to_color_key (str
);
4152 color
= strtok (NULL
, " \t");
4156 while ((str
= strtok (NULL
, " \t")) != NULL
)
4158 next_key
= xpm_str_to_color_key (str
);
4161 color
[strlen (color
)] = ' ';
4164 if (key
== XPM_COLOR_KEY_S
)
4166 if (NILP (symbol_color
))
4167 symbol_color
= build_string (color
);
4169 else if (max_key
< key
&& key
<= best_key
)
4179 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4181 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4183 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4185 if (xstrcasecmp (SSDATA (XCDR (specified_color
)), "None") == 0)
4187 else if (x_defined_color (f
, SSDATA (XCDR (specified_color
)),
4189 color_val
= make_number (cdef
.pixel
);
4192 if (NILP (color_val
) && max_key
> 0)
4194 if (xstrcasecmp (max_color
, "None") == 0)
4196 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4197 color_val
= make_number (cdef
.pixel
);
4199 if (!NILP (color_val
))
4200 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4205 for (y
= 0; y
< height
; y
++)
4207 expect (XPM_TK_STRING
);
4209 if (len
< width
* chars_per_pixel
)
4211 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4213 Lisp_Object color_val
=
4214 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4216 XPutPixel (ximg
, x
, y
,
4217 (INTEGERP (color_val
) ? XINT (color_val
)
4218 : FRAME_FOREGROUND_PIXEL (f
)));
4220 XPutPixel (mask_img
, x
, y
,
4221 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4222 : (have_mask
= true, PIX_MASK_RETAIN
)));
4224 if (EQ (color_val
, Qt
))
4225 ns_set_alpha (ximg
, x
, y
, 0);
4233 img
->height
= height
;
4235 /* Maybe fill in the background field while we have ximg handy. */
4236 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4237 IMAGE_BACKGROUND (img
, f
, ximg
);
4239 image_put_x_image (f
, img
, ximg
, 0);
4243 /* Fill in the background_transparent field while we have the
4245 image_background_transparent (img
, f
, mask_img
);
4247 image_put_x_image (f
, img
, mask_img
, 1);
4251 x_destroy_x_image (mask_img
);
4252 x_clear_image_1 (f
, img
, CLEAR_IMAGE_MASK
);
4258 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4259 x_destroy_x_image (ximg
);
4260 x_destroy_x_image (mask_img
);
4261 x_clear_image (f
, img
);
4270 xpm_load (struct frame
*f
,
4274 Lisp_Object file_name
;
4276 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4277 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4278 if (STRINGP (file_name
))
4281 unsigned char *contents
;
4284 file
= x_find_image_file (file_name
);
4285 if (!STRINGP (file
))
4287 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4291 contents
= slurp_file (SSDATA (file
), &size
);
4292 if (contents
== NULL
)
4294 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4298 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4305 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4306 if (!STRINGP (data
))
4308 image_error ("Invalid image data `%s'", data
, Qnil
);
4311 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4312 SDATA (data
) + SBYTES (data
));
4318 #endif /* HAVE_NS && !HAVE_XPM */
4322 /***********************************************************************
4324 ***********************************************************************/
4326 #ifdef COLOR_TABLE_SUPPORT
4328 /* An entry in the color table mapping an RGB color to a pixel color. */
4333 unsigned long pixel
;
4335 /* Next in color table collision list. */
4336 struct ct_color
*next
;
4339 /* The bucket vector size to use. Must be prime. */
4343 /* Value is a hash of the RGB color given by R, G, and B. */
4346 ct_hash_rgb (unsigned r
, unsigned g
, unsigned b
)
4348 return (r
<< 16) ^ (g
<< 8) ^ b
;
4351 /* The color hash table. */
4353 static struct ct_color
**ct_table
;
4355 /* Number of entries in the color table. */
4357 static int ct_colors_allocated
;
4360 ct_colors_allocated_max
=
4362 min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (unsigned long))
4365 /* Initialize the color table. */
4368 init_color_table (void)
4370 int size
= CT_SIZE
* sizeof (*ct_table
);
4371 ct_table
= xzalloc (size
);
4372 ct_colors_allocated
= 0;
4376 /* Free memory associated with the color table. */
4379 free_color_table (void)
4382 struct ct_color
*p
, *next
;
4384 for (i
= 0; i
< CT_SIZE
; ++i
)
4385 for (p
= ct_table
[i
]; p
; p
= next
)
4396 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4397 entry for that color already is in the color table, return the
4398 pixel color of that entry. Otherwise, allocate a new color for R,
4399 G, B, and make an entry in the color table. */
4401 static unsigned long
4402 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4404 unsigned hash
= ct_hash_rgb (r
, g
, b
);
4405 int i
= hash
% CT_SIZE
;
4407 Display_Info
*dpyinfo
;
4409 /* Handle TrueColor visuals specially, which improves performance by
4410 two orders of magnitude. Freeing colors on TrueColor visuals is
4411 a nop, and pixel colors specify RGB values directly. See also
4412 the Xlib spec, chapter 3.1. */
4413 dpyinfo
= FRAME_DISPLAY_INFO (f
);
4414 if (dpyinfo
->red_bits
> 0)
4416 unsigned long pr
, pg
, pb
;
4418 /* Apply gamma-correction like normal color allocation does. */
4422 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4423 gamma_correct (f
, &color
);
4424 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4427 /* Scale down RGB values to the visual's bits per RGB, and shift
4428 them to the right position in the pixel color. Note that the
4429 original RGB values are 16-bit values, as usual in X. */
4430 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4431 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4432 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4434 /* Assemble the pixel color. */
4435 return pr
| pg
| pb
;
4438 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4439 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4445 #ifdef HAVE_X_WINDOWS
4453 if (ct_colors_allocated_max
<= ct_colors_allocated
)
4454 return FRAME_FOREGROUND_PIXEL (f
);
4456 #ifdef HAVE_X_WINDOWS
4461 cmap
= FRAME_X_COLORMAP (f
);
4462 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4465 ++ct_colors_allocated
;
4466 p
= xmalloc (sizeof *p
);
4470 p
->pixel
= color
.pixel
;
4471 p
->next
= ct_table
[i
];
4475 return FRAME_FOREGROUND_PIXEL (f
);
4479 color
= PALETTERGB (r
, g
, b
);
4481 color
= RGB_TO_ULONG (r
, g
, b
);
4482 #endif /* HAVE_NTGUI */
4483 ++ct_colors_allocated
;
4484 p
= xmalloc (sizeof *p
);
4489 p
->next
= ct_table
[i
];
4491 #endif /* HAVE_X_WINDOWS */
4499 /* Look up pixel color PIXEL which is used on frame F in the color
4500 table. If not already present, allocate it. Value is PIXEL. */
4502 static unsigned long
4503 lookup_pixel_color (struct frame
*f
, unsigned long pixel
)
4505 int i
= pixel
% CT_SIZE
;
4508 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4509 if (p
->pixel
== pixel
)
4518 if (ct_colors_allocated
>= ct_colors_allocated_max
)
4519 return FRAME_FOREGROUND_PIXEL (f
);
4521 #ifdef HAVE_X_WINDOWS
4522 cmap
= FRAME_X_COLORMAP (f
);
4523 color
.pixel
= pixel
;
4524 x_query_color (f
, &color
);
4525 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4528 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4529 color
.pixel
= pixel
;
4530 XQueryColor (NULL
, cmap
, &color
);
4531 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4533 #endif /* HAVE_X_WINDOWS */
4537 ++ct_colors_allocated
;
4539 p
= xmalloc (sizeof *p
);
4544 p
->next
= ct_table
[i
];
4548 return FRAME_FOREGROUND_PIXEL (f
);
4554 /* Value is a vector of all pixel colors contained in the color table,
4555 allocated via xmalloc. Set *N to the number of colors. */
4557 static unsigned long *
4558 colors_in_color_table (int *n
)
4562 unsigned long *colors
;
4564 if (ct_colors_allocated
== 0)
4571 colors
= xmalloc (ct_colors_allocated
* sizeof *colors
);
4572 *n
= ct_colors_allocated
;
4574 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4575 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4576 colors
[j
++] = p
->pixel
;
4582 #else /* COLOR_TABLE_SUPPORT */
4584 static unsigned long
4585 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4587 unsigned long pixel
;
4590 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4591 #endif /* HAVE_NTGUI */
4594 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4595 #endif /* HAVE_NS */
4600 init_color_table (void)
4603 #endif /* COLOR_TABLE_SUPPORT */
4606 /***********************************************************************
4608 ***********************************************************************/
4610 /* Edge detection matrices for different edge-detection
4613 static int emboss_matrix
[9] = {
4615 2, -1, 0, /* y - 1 */
4617 0, 1, -2 /* y + 1 */
4620 static int laplace_matrix
[9] = {
4622 1, 0, 0, /* y - 1 */
4624 0, 0, -1 /* y + 1 */
4627 /* Value is the intensity of the color whose red/green/blue values
4630 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4633 /* On frame F, return an array of XColor structures describing image
4634 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4635 means also fill the red/green/blue members of the XColor
4636 structures. Value is a pointer to the array of XColors structures,
4637 allocated with xmalloc; it must be freed by the caller. */
4640 x_to_xcolors (struct frame
*f
, struct image
*img
, bool rgb_p
)
4644 XImagePtr_or_DC ximg
;
4647 #endif /* HAVE_NTGUI */
4649 if (img
->height
> min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *colors
/ img
->width
)
4650 memory_full (SIZE_MAX
);
4651 colors
= xmalloc (sizeof *colors
* img
->width
* img
->height
);
4653 /* Get the X image or create a memory device context for IMG. */
4654 ximg
= image_get_x_image_or_dc (f
, img
, 0, &prev
);
4656 /* Fill the `pixel' members of the XColor array. I wished there
4657 were an easy and portable way to circumvent XGetPixel. */
4659 for (y
= 0; y
< img
->height
; ++y
)
4661 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
4663 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4664 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4666 x_query_colors (f
, row
, img
->width
);
4670 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4672 /* W32_TODO: palette support needed here? */
4673 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4676 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4677 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4678 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4681 #endif /* HAVE_X_WINDOWS */
4684 image_unget_x_image_or_dc (img
, 0, ximg
, prev
);
4691 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4692 created with CreateDIBSection, with the pointer to the bit values
4693 stored in ximg->data. */
4696 XPutPixel (XImagePtr ximg
, int x
, int y
, COLORREF color
)
4698 int width
= ximg
->info
.bmiHeader
.biWidth
;
4699 unsigned char * pixel
;
4701 /* True color images. */
4702 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4704 int rowbytes
= width
* 3;
4705 /* Ensure scanlines are aligned on 4 byte boundaries. */
4707 rowbytes
+= 4 - (rowbytes
% 4);
4709 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4710 /* Windows bitmaps are in BGR order. */
4711 *pixel
= GetBValue (color
);
4712 *(pixel
+ 1) = GetGValue (color
);
4713 *(pixel
+ 2) = GetRValue (color
);
4715 /* Monochrome images. */
4716 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4718 int rowbytes
= width
/ 8;
4719 /* Ensure scanlines are aligned on 4 byte boundaries. */
4721 rowbytes
+= 4 - (rowbytes
% 4);
4722 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4723 /* Filter out palette info. */
4724 if (color
& 0x00ffffff)
4725 *pixel
= *pixel
| (1 << x
% 8);
4727 *pixel
= *pixel
& ~(1 << x
% 8);
4730 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4733 #endif /* HAVE_NTGUI */
4735 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4736 RGB members are set. F is the frame on which this all happens.
4737 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4740 x_from_xcolors (struct frame
*f
, struct image
*img
, XColor
*colors
)
4743 XImagePtr oimg
= NULL
;
4746 init_color_table ();
4748 x_clear_image_1 (f
, img
, CLEAR_IMAGE_PIXMAP
| CLEAR_IMAGE_COLORS
);
4749 image_create_x_image_and_pixmap (f
, img
, img
->width
, img
->height
, 0,
4752 for (y
= 0; y
< img
->height
; ++y
)
4753 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4755 unsigned long pixel
;
4756 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4757 XPutPixel (oimg
, x
, y
, pixel
);
4762 image_put_x_image (f
, img
, oimg
, 0);
4763 #ifdef COLOR_TABLE_SUPPORT
4764 img
->colors
= colors_in_color_table (&img
->ncolors
);
4765 free_color_table ();
4766 #endif /* COLOR_TABLE_SUPPORT */
4770 /* On frame F, perform edge-detection on image IMG.
4772 MATRIX is a nine-element array specifying the transformation
4773 matrix. See emboss_matrix for an example.
4775 COLOR_ADJUST is a color adjustment added to each pixel of the
4779 x_detect_edges (struct frame
*f
, struct image
*img
, int *matrix
, int color_adjust
)
4781 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4785 for (i
= sum
= 0; i
< 9; ++i
)
4786 sum
+= eabs (matrix
[i
]);
4788 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4790 if (img
->height
> min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *new / img
->width
)
4791 memory_full (SIZE_MAX
);
4792 new = xmalloc (sizeof *new * img
->width
* img
->height
);
4794 for (y
= 0; y
< img
->height
; ++y
)
4796 p
= COLOR (new, 0, y
);
4797 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4798 p
= COLOR (new, img
->width
- 1, y
);
4799 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4802 for (x
= 1; x
< img
->width
- 1; ++x
)
4804 p
= COLOR (new, x
, 0);
4805 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4806 p
= COLOR (new, x
, img
->height
- 1);
4807 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4810 for (y
= 1; y
< img
->height
- 1; ++y
)
4812 p
= COLOR (new, 1, y
);
4814 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4816 int r
, g
, b
, yy
, xx
;
4819 for (yy
= y
- 1; yy
< y
+ 2; ++yy
)
4820 for (xx
= x
- 1; xx
< x
+ 2; ++xx
, ++i
)
4823 XColor
*t
= COLOR (colors
, xx
, yy
);
4824 r
+= matrix
[i
] * t
->red
;
4825 g
+= matrix
[i
] * t
->green
;
4826 b
+= matrix
[i
] * t
->blue
;
4829 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4830 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4831 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4832 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4837 x_from_xcolors (f
, img
, new);
4843 /* Perform the pre-defined `emboss' edge-detection on image IMG
4847 x_emboss (struct frame
*f
, struct image
*img
)
4849 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4853 /* Transform image IMG which is used on frame F with a Laplace
4854 edge-detection algorithm. The result is an image that can be used
4855 to draw disabled buttons, for example. */
4858 x_laplace (struct frame
*f
, struct image
*img
)
4860 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4864 /* Perform edge-detection on image IMG on frame F, with specified
4865 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4867 MATRIX must be either
4869 - a list of at least 9 numbers in row-major form
4870 - a vector of at least 9 numbers
4872 COLOR_ADJUST nil means use a default; otherwise it must be a
4876 x_edge_detection (struct frame
*f
, struct image
*img
, Lisp_Object matrix
,
4877 Lisp_Object color_adjust
)
4885 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4886 ++i
, matrix
= XCDR (matrix
))
4887 trans
[i
] = XFLOATINT (XCAR (matrix
));
4889 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4891 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4892 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4895 if (NILP (color_adjust
))
4896 color_adjust
= make_number (0xffff / 2);
4898 if (i
== 9 && NUMBERP (color_adjust
))
4899 x_detect_edges (f
, img
, trans
, XFLOATINT (color_adjust
));
4903 /* Transform image IMG on frame F so that it looks disabled. */
4906 x_disable_image (struct frame
*f
, struct image
*img
)
4908 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
4910 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4912 int n_planes
= dpyinfo
->n_planes
;
4913 #endif /* HAVE_NTGUI */
4917 /* Color (or grayscale). Convert to gray, and equalize. Just
4918 drawing such images with a stipple can look very odd, so
4919 we're using this method instead. */
4920 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4922 const int h
= 15000;
4923 const int l
= 30000;
4925 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4929 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4930 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4931 p
->red
= p
->green
= p
->blue
= i2
;
4934 x_from_xcolors (f
, img
, colors
);
4937 /* Draw a cross over the disabled image, if we must or if we
4939 if (n_planes
< 2 || cross_disabled_images
)
4942 #ifndef HAVE_NS /* TODO: NS support, however this not needed for toolbars */
4944 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4946 Display
*dpy
= FRAME_X_DISPLAY (f
);
4949 image_sync_to_pixmaps (f
, img
);
4950 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
4951 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4952 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4953 img
->width
- 1, img
->height
- 1);
4954 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4960 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
4961 XSetForeground (dpy
, gc
, MaskForeground (f
));
4962 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4963 img
->width
- 1, img
->height
- 1);
4964 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4968 #endif /* !HAVE_NS */
4973 hdc
= get_frame_dc (f
);
4974 bmpdc
= CreateCompatibleDC (hdc
);
4975 release_frame_dc (f
, hdc
);
4977 prev
= SelectObject (bmpdc
, img
->pixmap
);
4979 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
4980 MoveToEx (bmpdc
, 0, 0, NULL
);
4981 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4982 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4983 LineTo (bmpdc
, img
->width
- 1, 0);
4987 SelectObject (bmpdc
, img
->mask
);
4988 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
4989 MoveToEx (bmpdc
, 0, 0, NULL
);
4990 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4991 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4992 LineTo (bmpdc
, img
->width
- 1, 0);
4994 SelectObject (bmpdc
, prev
);
4996 #endif /* HAVE_NTGUI */
5001 /* Build a mask for image IMG which is used on frame F. FILE is the
5002 name of an image file, for error messages. HOW determines how to
5003 determine the background color of IMG. If it is a list '(R G B)',
5004 with R, G, and B being integers >= 0, take that as the color of the
5005 background. Otherwise, determine the background color of IMG
5009 x_build_heuristic_mask (struct frame
*f
, struct image
*img
, Lisp_Object how
)
5011 XImagePtr_or_DC ximg
;
5018 #endif /* HAVE_NTGUI */
5020 bool use_img_background
;
5021 unsigned long bg
= 0;
5024 x_clear_image_1 (f
, img
, CLEAR_IMAGE_MASK
);
5028 /* Create an image and pixmap serving as mask. */
5029 if (! image_create_x_image_and_pixmap (f
, img
, img
->width
, img
->height
, 1,
5032 #endif /* !HAVE_NS */
5034 /* Create the bit array serving as mask. */
5035 row_width
= (img
->width
+ 7) / 8;
5036 mask_img
= xzalloc (row_width
* img
->height
);
5037 #endif /* HAVE_NTGUI */
5039 /* Get the X image or create a memory device context for IMG. */
5040 ximg
= image_get_x_image_or_dc (f
, img
, 0, &prev
);
5042 /* Determine the background color of ximg. If HOW is `(R G B)'
5043 take that as color. Otherwise, use the image's background color. */
5044 use_img_background
= 1;
5050 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
5052 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
5056 if (i
== 3 && NILP (how
))
5058 char color_name
[30];
5059 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
5062 0x00ffffff & /* Filter out palette info. */
5063 #endif /* HAVE_NTGUI */
5064 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5065 use_img_background
= 0;
5069 if (use_img_background
)
5070 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5072 /* Set all bits in mask_img to 1 whose color in ximg is different
5073 from the background color bg. */
5075 for (y
= 0; y
< img
->height
; ++y
)
5076 for (x
= 0; x
< img
->width
; ++x
)
5078 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5079 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5081 if (XGetPixel (ximg
, x
, y
) == bg
)
5082 ns_set_alpha (ximg
, x
, y
, 0);
5083 #endif /* HAVE_NS */
5085 /* Fill in the background_transparent field while we have the mask handy. */
5086 image_background_transparent (img
, f
, mask_img
);
5088 /* Put mask_img into the image. */
5089 image_put_x_image (f
, img
, mask_img
, 1);
5090 #endif /* !HAVE_NS */
5092 for (y
= 0; y
< img
->height
; ++y
)
5093 for (x
= 0; x
< img
->width
; ++x
)
5095 COLORREF p
= GetPixel (ximg
, x
, y
);
5097 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5100 /* Create the mask image. */
5101 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5103 /* Fill in the background_transparent field while we have the mask handy. */
5104 SelectObject (ximg
, img
->mask
);
5105 image_background_transparent (img
, f
, ximg
);
5107 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5109 #endif /* HAVE_NTGUI */
5111 image_unget_x_image_or_dc (img
, 0, ximg
, prev
);
5115 /***********************************************************************
5116 PBM (mono, gray, color)
5117 ***********************************************************************/
5119 static bool pbm_image_p (Lisp_Object object
);
5120 static bool pbm_load (struct frame
*f
, struct image
*img
);
5122 /* Indices of image specification fields in gs_format, below. */
5124 enum pbm_keyword_index
5140 /* Vector of image_keyword structures describing the format
5141 of valid user-defined image specifications. */
5143 static const struct image_keyword pbm_format
[PBM_LAST
] =
5145 {":type", IMAGE_SYMBOL_VALUE
, 1},
5146 {":file", IMAGE_STRING_VALUE
, 0},
5147 {":data", IMAGE_STRING_VALUE
, 0},
5148 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5149 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
5150 {":relief", IMAGE_INTEGER_VALUE
, 0},
5151 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5152 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5153 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5154 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5155 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5158 /* Structure describing the image type `pbm'. */
5160 static struct image_type pbm_type
=
5162 SYMBOL_INDEX (Qpbm
),
5171 /* Return true if OBJECT is a valid PBM image specification. */
5174 pbm_image_p (Lisp_Object object
)
5176 struct image_keyword fmt
[PBM_LAST
];
5178 memcpy (fmt
, pbm_format
, sizeof fmt
);
5180 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5183 /* Must specify either :data or :file. */
5184 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5188 /* Get next char skipping comments in Netpbm header. Returns -1 at
5192 pbm_next_char (unsigned char **s
, unsigned char *end
)
5196 while (*s
< end
&& (c
= *(*s
)++, c
== '#'))
5198 /* Skip to the next line break. */
5199 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n' && c
!= '\r'))
5209 /* Scan a decimal number from *S and return it. Advance *S while
5210 reading the number. END is the end of the string. Value is -1 at
5214 pbm_scan_number (unsigned char **s
, unsigned char *end
)
5216 int c
= 0, val
= -1;
5218 /* Skip white-space. */
5219 while ((c
= pbm_next_char (s
, end
)) != -1 && c_isspace (c
))
5224 /* Read decimal number. */
5226 while ((c
= pbm_next_char (s
, end
)) != -1 && c_isdigit (c
))
5227 val
= 10 * val
+ c
- '0';
5234 /* Load PBM image IMG for use on frame F. */
5237 pbm_load (struct frame
*f
, struct image
*img
)
5241 int width
, height
, max_color_idx
= 0;
5243 Lisp_Object file
, specified_file
;
5244 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5245 unsigned char *contents
= NULL
;
5246 unsigned char *end
, *p
;
5249 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5251 if (STRINGP (specified_file
))
5253 file
= x_find_image_file (specified_file
);
5254 if (!STRINGP (file
))
5256 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5260 contents
= slurp_file (SSDATA (file
), &size
);
5261 if (contents
== NULL
)
5263 image_error ("Error reading `%s'", file
, Qnil
);
5268 end
= contents
+ size
;
5273 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5274 if (!STRINGP (data
))
5276 image_error ("Invalid image data `%s'", data
, Qnil
);
5280 end
= p
+ SBYTES (data
);
5283 /* Check magic number. */
5284 if (end
- p
< 2 || *p
++ != 'P')
5286 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5289 img
->pixmap
= NO_PIXMAP
;
5296 raw_p
= 0, type
= PBM_MONO
;
5300 raw_p
= 0, type
= PBM_GRAY
;
5304 raw_p
= 0, type
= PBM_COLOR
;
5308 raw_p
= 1, type
= PBM_MONO
;
5312 raw_p
= 1, type
= PBM_GRAY
;
5316 raw_p
= 1, type
= PBM_COLOR
;
5320 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5324 /* Read width, height, maximum color-component. Characters
5325 starting with `#' up to the end of a line are ignored. */
5326 width
= pbm_scan_number (&p
, end
);
5327 height
= pbm_scan_number (&p
, end
);
5329 if (type
!= PBM_MONO
)
5331 max_color_idx
= pbm_scan_number (&p
, end
);
5332 if (max_color_idx
> 65535 || max_color_idx
< 0)
5334 image_error ("Unsupported maximum PBM color value", Qnil
, Qnil
);
5339 if (!check_image_size (f
, width
, height
))
5341 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5345 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
5348 /* Initialize the color hash table. */
5349 init_color_table ();
5351 if (type
== PBM_MONO
)
5354 struct image_keyword fmt
[PBM_LAST
];
5355 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5356 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5358 /* Parse the image specification. */
5359 memcpy (fmt
, pbm_format
, sizeof fmt
);
5360 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5362 /* Get foreground and background colors, maybe allocate colors. */
5363 if (fmt
[PBM_FOREGROUND
].count
5364 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5365 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5366 if (fmt
[PBM_BACKGROUND
].count
5367 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5369 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5370 img
->background
= bg
;
5371 img
->background_valid
= 1;
5374 for (y
= 0; y
< height
; ++y
)
5375 for (x
= 0; x
< width
; ++x
)
5383 x_destroy_x_image (ximg
);
5384 x_clear_image (f
, img
);
5385 image_error ("Invalid image size in image `%s'",
5395 g
= pbm_scan_number (&p
, end
);
5397 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5402 int expected_size
= height
* width
;
5403 if (max_color_idx
> 255)
5405 if (type
== PBM_COLOR
)
5408 if (raw_p
&& p
+ expected_size
> end
)
5410 x_destroy_x_image (ximg
);
5411 x_clear_image (f
, img
);
5412 image_error ("Invalid image size in image `%s'",
5417 for (y
= 0; y
< height
; ++y
)
5418 for (x
= 0; x
< width
; ++x
)
5422 if (type
== PBM_GRAY
&& raw_p
)
5425 if (max_color_idx
> 255)
5426 r
= g
= b
= r
* 256 + *p
++;
5428 else if (type
== PBM_GRAY
)
5429 r
= g
= b
= pbm_scan_number (&p
, end
);
5433 if (max_color_idx
> 255)
5436 if (max_color_idx
> 255)
5439 if (max_color_idx
> 255)
5444 r
= pbm_scan_number (&p
, end
);
5445 g
= pbm_scan_number (&p
, end
);
5446 b
= pbm_scan_number (&p
, end
);
5449 if (r
< 0 || g
< 0 || b
< 0)
5451 x_destroy_x_image (ximg
);
5452 image_error ("Invalid pixel value in image `%s'",
5457 /* RGB values are now in the range 0..max_color_idx.
5458 Scale this to the range 0..0xffff supported by X. */
5459 r
= (double) r
* 65535 / max_color_idx
;
5460 g
= (double) g
* 65535 / max_color_idx
;
5461 b
= (double) b
* 65535 / max_color_idx
;
5462 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5466 #ifdef COLOR_TABLE_SUPPORT
5467 /* Store in IMG->colors the colors allocated for the image, and
5468 free the color table. */
5469 img
->colors
= colors_in_color_table (&img
->ncolors
);
5470 free_color_table ();
5471 #endif /* COLOR_TABLE_SUPPORT */
5474 img
->height
= height
;
5476 /* Maybe fill in the background field while we have ximg handy. */
5478 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5479 /* Casting avoids a GCC warning. */
5480 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5482 /* Put ximg into the image. */
5483 image_put_x_image (f
, img
, ximg
, 0);
5485 /* X and W32 versions did it here, MAC version above. ++kfs
5487 img->height = height; */
5494 /***********************************************************************
5496 ***********************************************************************/
5498 #if defined (HAVE_PNG) || defined (HAVE_NS) || defined (USE_CAIRO)
5500 /* Function prototypes. */
5502 static bool png_image_p (Lisp_Object object
);
5503 static bool png_load (struct frame
*f
, struct image
*img
);
5505 /* Indices of image specification fields in png_format, below. */
5507 enum png_keyword_index
5522 /* Vector of image_keyword structures describing the format
5523 of valid user-defined image specifications. */
5525 static const struct image_keyword png_format
[PNG_LAST
] =
5527 {":type", IMAGE_SYMBOL_VALUE
, 1},
5528 {":data", IMAGE_STRING_VALUE
, 0},
5529 {":file", IMAGE_STRING_VALUE
, 0},
5530 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5531 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
5532 {":relief", IMAGE_INTEGER_VALUE
, 0},
5533 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5534 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5535 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5536 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5539 #if defined HAVE_NTGUI && defined WINDOWSNT
5540 static bool init_png_functions (void);
5542 #define init_png_functions NULL
5545 /* Structure describing the image type `png'. */
5547 static struct image_type png_type
=
5549 SYMBOL_INDEX (Qpng
),
5557 /* Return true if OBJECT is a valid PNG image specification. */
5560 png_image_p (Lisp_Object object
)
5562 struct image_keyword fmt
[PNG_LAST
];
5563 memcpy (fmt
, png_format
, sizeof fmt
);
5565 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5568 /* Must specify either the :data or :file keyword. */
5569 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5572 #endif /* HAVE_PNG || HAVE_NS || USE_CAIRO */
5575 #if defined HAVE_PNG && !defined HAVE_NS
5578 /* PNG library details. */
5580 DEF_DLL_FN (png_voidp
, png_get_io_ptr
, (png_structp
));
5581 DEF_DLL_FN (int, png_sig_cmp
, (png_bytep
, png_size_t
, png_size_t
));
5582 DEF_DLL_FN (png_structp
, png_create_read_struct
,
5583 (png_const_charp
, png_voidp
, png_error_ptr
, png_error_ptr
));
5584 DEF_DLL_FN (png_infop
, png_create_info_struct
, (png_structp
));
5585 DEF_DLL_FN (void, png_destroy_read_struct
,
5586 (png_structpp
, png_infopp
, png_infopp
));
5587 DEF_DLL_FN (void, png_set_read_fn
, (png_structp
, png_voidp
, png_rw_ptr
));
5588 DEF_DLL_FN (void, png_set_sig_bytes
, (png_structp
, int));
5589 DEF_DLL_FN (void, png_read_info
, (png_structp
, png_infop
));
5590 DEF_DLL_FN (png_uint_32
, png_get_IHDR
,
5591 (png_structp
, png_infop
, png_uint_32
*, png_uint_32
*,
5592 int *, int *, int *, int *, int *));
5593 DEF_DLL_FN (png_uint_32
, png_get_valid
, (png_structp
, png_infop
, png_uint_32
));
5594 DEF_DLL_FN (void, png_set_strip_16
, (png_structp
));
5595 DEF_DLL_FN (void, png_set_expand
, (png_structp
));
5596 DEF_DLL_FN (void, png_set_gray_to_rgb
, (png_structp
));
5597 DEF_DLL_FN (void, png_set_background
,
5598 (png_structp
, png_color_16p
, int, int, double));
5599 DEF_DLL_FN (png_uint_32
, png_get_bKGD
,
5600 (png_structp
, png_infop
, png_color_16p
*));
5601 DEF_DLL_FN (void, png_read_update_info
, (png_structp
, png_infop
));
5602 DEF_DLL_FN (png_byte
, png_get_channels
, (png_structp
, png_infop
));
5603 DEF_DLL_FN (png_size_t
, png_get_rowbytes
, (png_structp
, png_infop
));
5604 DEF_DLL_FN (void, png_read_image
, (png_structp
, png_bytepp
));
5605 DEF_DLL_FN (void, png_read_end
, (png_structp
, png_infop
));
5606 DEF_DLL_FN (void, png_error
, (png_structp
, png_const_charp
));
5608 # if (PNG_LIBPNG_VER >= 10500)
5609 DEF_DLL_FN (void, png_longjmp
, (png_structp
, int)) PNG_NORETURN
;
5610 DEF_DLL_FN (jmp_buf *, png_set_longjmp_fn
,
5611 (png_structp
, png_longjmp_ptr
, size_t));
5612 # endif /* libpng version >= 1.5 */
5615 init_png_functions (void)
5619 if (!(library
= w32_delayed_load (Qpng
)))
5622 LOAD_DLL_FN (library
, png_get_io_ptr
);
5623 LOAD_DLL_FN (library
, png_sig_cmp
);
5624 LOAD_DLL_FN (library
, png_create_read_struct
);
5625 LOAD_DLL_FN (library
, png_create_info_struct
);
5626 LOAD_DLL_FN (library
, png_destroy_read_struct
);
5627 LOAD_DLL_FN (library
, png_set_read_fn
);
5628 LOAD_DLL_FN (library
, png_set_sig_bytes
);
5629 LOAD_DLL_FN (library
, png_read_info
);
5630 LOAD_DLL_FN (library
, png_get_IHDR
);
5631 LOAD_DLL_FN (library
, png_get_valid
);
5632 LOAD_DLL_FN (library
, png_set_strip_16
);
5633 LOAD_DLL_FN (library
, png_set_expand
);
5634 LOAD_DLL_FN (library
, png_set_gray_to_rgb
);
5635 LOAD_DLL_FN (library
, png_set_background
);
5636 LOAD_DLL_FN (library
, png_get_bKGD
);
5637 LOAD_DLL_FN (library
, png_read_update_info
);
5638 LOAD_DLL_FN (library
, png_get_channels
);
5639 LOAD_DLL_FN (library
, png_get_rowbytes
);
5640 LOAD_DLL_FN (library
, png_read_image
);
5641 LOAD_DLL_FN (library
, png_read_end
);
5642 LOAD_DLL_FN (library
, png_error
);
5644 # if (PNG_LIBPNG_VER >= 10500)
5645 LOAD_DLL_FN (library
, png_longjmp
);
5646 LOAD_DLL_FN (library
, png_set_longjmp_fn
);
5647 # endif /* libpng version >= 1.5 */
5652 # undef png_create_info_struct
5653 # undef png_create_read_struct
5654 # undef png_destroy_read_struct
5656 # undef png_get_bKGD
5657 # undef png_get_channels
5658 # undef png_get_IHDR
5659 # undef png_get_io_ptr
5660 # undef png_get_rowbytes
5661 # undef png_get_valid
5663 # undef png_read_end
5664 # undef png_read_image
5665 # undef png_read_info
5666 # undef png_read_update_info
5667 # undef png_set_background
5668 # undef png_set_expand
5669 # undef png_set_gray_to_rgb
5670 # undef png_set_longjmp_fn
5671 # undef png_set_read_fn
5672 # undef png_set_sig_bytes
5673 # undef png_set_strip_16
5676 # define png_create_info_struct fn_png_create_info_struct
5677 # define png_create_read_struct fn_png_create_read_struct
5678 # define png_destroy_read_struct fn_png_destroy_read_struct
5679 # define png_error fn_png_error
5680 # define png_get_bKGD fn_png_get_bKGD
5681 # define png_get_channels fn_png_get_channels
5682 # define png_get_IHDR fn_png_get_IHDR
5683 # define png_get_io_ptr fn_png_get_io_ptr
5684 # define png_get_rowbytes fn_png_get_rowbytes
5685 # define png_get_valid fn_png_get_valid
5686 # define png_longjmp fn_png_longjmp
5687 # define png_read_end fn_png_read_end
5688 # define png_read_image fn_png_read_image
5689 # define png_read_info fn_png_read_info
5690 # define png_read_update_info fn_png_read_update_info
5691 # define png_set_background fn_png_set_background
5692 # define png_set_expand fn_png_set_expand
5693 # define png_set_gray_to_rgb fn_png_set_gray_to_rgb
5694 # define png_set_longjmp_fn fn_png_set_longjmp_fn
5695 # define png_set_read_fn fn_png_set_read_fn
5696 # define png_set_sig_bytes fn_png_set_sig_bytes
5697 # define png_set_strip_16 fn_png_set_strip_16
5698 # define png_sig_cmp fn_png_sig_cmp
5700 # endif /* WINDOWSNT */
5702 /* Fast implementations of setjmp and longjmp. Although setjmp and longjmp
5703 will do, POSIX _setjmp and _longjmp (if available) are often faster.
5704 Do not use sys_setjmp, as PNG supports only jmp_buf.
5705 It's OK if the longjmp substitute restores the signal mask. */
5706 # ifdef HAVE__SETJMP
5707 # define FAST_SETJMP(j) _setjmp (j)
5708 # define FAST_LONGJMP _longjmp
5710 # define FAST_SETJMP(j) setjmp (j)
5711 # define FAST_LONGJMP longjmp
5714 # if PNG_LIBPNG_VER < 10500
5715 # define PNG_LONGJMP(ptr) FAST_LONGJMP ((ptr)->jmpbuf, 1)
5716 # define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
5718 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908) */
5719 # define PNG_LONGJMP(ptr) png_longjmp (ptr, 1)
5720 # define PNG_JMPBUF(ptr) \
5721 (*png_set_longjmp_fn (ptr, FAST_LONGJMP, sizeof (jmp_buf)))
5724 /* Error and warning handlers installed when the PNG library
5727 static _Noreturn
void
5728 my_png_error (png_struct
*png_ptr
, const char *msg
)
5730 eassert (png_ptr
!= NULL
);
5731 /* Avoid compiler warning about deprecated direct access to
5732 png_ptr's fields in libpng versions 1.4.x. */
5733 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5734 PNG_LONGJMP (png_ptr
);
5739 my_png_warning (png_struct
*png_ptr
, const char *msg
)
5741 eassert (png_ptr
!= NULL
);
5742 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5745 /* Memory source for PNG decoding. */
5747 struct png_memory_storage
5749 unsigned char *bytes
; /* The data */
5750 ptrdiff_t len
; /* How big is it? */
5751 ptrdiff_t index
; /* Where are we? */
5755 /* Function set as reader function when reading PNG image from memory.
5756 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5757 bytes from the input to DATA. */
5760 png_read_from_memory (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5762 struct png_memory_storage
*tbr
= png_get_io_ptr (png_ptr
);
5764 if (length
> tbr
->len
- tbr
->index
)
5765 png_error (png_ptr
, "Read error");
5767 memcpy (data
, tbr
->bytes
+ tbr
->index
, length
);
5768 tbr
->index
= tbr
->index
+ length
;
5772 /* Function set as reader function when reading PNG image from a file.
5773 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5774 bytes from the input to DATA. */
5777 png_read_from_file (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5779 FILE *fp
= png_get_io_ptr (png_ptr
);
5781 if (fread (data
, 1, length
, fp
) < length
)
5782 png_error (png_ptr
, "Read error");
5786 /* Load PNG image IMG for use on frame F. Value is true if
5789 struct png_load_context
5791 /* These are members so that longjmp doesn't munge local variables. */
5792 png_struct
*png_ptr
;
5801 png_load_body (struct frame
*f
, struct image
*img
, struct png_load_context
*c
)
5803 Lisp_Object file
, specified_file
;
5804 Lisp_Object specified_data
;
5807 XImagePtr ximg
, mask_img
= NULL
;
5808 png_struct
*png_ptr
;
5809 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5812 png_byte
*pixels
= NULL
;
5813 png_byte
**rows
= NULL
;
5814 png_uint_32 width
, height
;
5815 int bit_depth
, color_type
, interlace_type
;
5817 png_uint_32 row_bytes
;
5819 struct png_memory_storage tbr
; /* Data to be read */
5822 unsigned char *data
= 0;
5826 /* Find out what file to load. */
5827 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5828 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5830 if (NILP (specified_data
))
5832 file
= x_find_image_file (specified_file
);
5833 if (!STRINGP (file
))
5835 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5839 /* Open the image file. */
5840 fp
= emacs_fopen (SSDATA (file
), "rb");
5843 image_error ("Cannot open image file `%s'", file
, Qnil
);
5847 /* Check PNG signature. */
5848 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5849 || png_sig_cmp (sig
, 0, sizeof sig
))
5852 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5858 if (!STRINGP (specified_data
))
5860 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
5864 /* Read from memory. */
5865 tbr
.bytes
= SDATA (specified_data
);
5866 tbr
.len
= SBYTES (specified_data
);
5869 /* Check PNG signature. */
5870 if (tbr
.len
< sizeof sig
5871 || png_sig_cmp (tbr
.bytes
, 0, sizeof sig
))
5873 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5877 /* Need to skip past the signature. */
5878 tbr
.bytes
+= sizeof (sig
);
5881 /* Initialize read and info structs for PNG lib. */
5882 png_ptr
= png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5887 info_ptr
= png_create_info_struct (png_ptr
);
5888 end_info
= png_create_info_struct (png_ptr
);
5891 c
->png_ptr
= png_ptr
;
5892 c
->info_ptr
= info_ptr
;
5893 c
->end_info
= end_info
;
5898 if (! (info_ptr
&& end_info
))
5900 png_destroy_read_struct (&c
->png_ptr
, &c
->info_ptr
, &c
->end_info
);
5905 if (fp
) fclose (fp
);
5909 /* Set error jump-back. We come back here when the PNG library
5910 detects an error. */
5911 if (FAST_SETJMP (PNG_JMPBUF (png_ptr
)))
5915 png_destroy_read_struct (&c
->png_ptr
, &c
->info_ptr
, &c
->end_info
);
5923 /* Silence a bogus diagnostic; see GCC bug 54561. */
5924 IF_LINT (fp
= c
->fp
);
5926 /* Read image info. */
5927 if (!NILP (specified_data
))
5928 png_set_read_fn (png_ptr
, &tbr
, png_read_from_memory
);
5930 png_set_read_fn (png_ptr
, fp
, png_read_from_file
);
5932 png_set_sig_bytes (png_ptr
, sizeof sig
);
5933 png_read_info (png_ptr
, info_ptr
);
5934 png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5935 &interlace_type
, NULL
, NULL
);
5937 if (! (width
<= INT_MAX
&& height
<= INT_MAX
5938 && check_image_size (f
, width
, height
)))
5940 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5945 /* Create the X image and pixmap now, so that the work below can be
5946 omitted if the image is too large for X. */
5947 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
5951 /* If image contains simply transparency data, we prefer to
5952 construct a clipping mask. */
5953 if (png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5958 /* This function is easier to write if we only have to handle
5959 one data format: RGB or RGBA with 8 bits per channel. Let's
5960 transform other formats into that format. */
5962 /* Strip more than 8 bits per channel. */
5963 if (bit_depth
== 16)
5964 png_set_strip_16 (png_ptr
);
5966 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5968 png_set_expand (png_ptr
);
5970 /* Convert grayscale images to RGB. */
5971 if (color_type
== PNG_COLOR_TYPE_GRAY
5972 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5973 png_set_gray_to_rgb (png_ptr
);
5975 /* Handle alpha channel by combining the image with a background
5976 color. Do this only if a real alpha channel is supplied. For
5977 simple transparency, we prefer a clipping mask. */
5980 /* png_color_16 *image_bg; */
5981 Lisp_Object specified_bg
5982 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5985 /* If the user specified a color, try to use it; if not, use the
5986 current frame background, ignoring any default background
5987 color set by the image. */
5988 if (STRINGP (specified_bg
)
5989 ? x_defined_color (f
, SSDATA (specified_bg
), &color
, false)
5990 : (x_query_frame_background_color (f
, &color
), true))
5991 /* The user specified `:background', use that. */
5993 int shift
= bit_depth
== 16 ? 0 : 8;
5994 png_color_16 bg
= { 0 };
5995 bg
.red
= color
.red
>> shift
;
5996 bg
.green
= color
.green
>> shift
;
5997 bg
.blue
= color
.blue
>> shift
;
5999 png_set_background (png_ptr
, &bg
,
6000 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
6004 /* Update info structure. */
6005 png_read_update_info (png_ptr
, info_ptr
);
6007 /* Get number of channels. Valid values are 1 for grayscale images
6008 and images with a palette, 2 for grayscale images with transparency
6009 information (alpha channel), 3 for RGB images, and 4 for RGB
6010 images with alpha channel, i.e. RGBA. If conversions above were
6011 sufficient we should only have 3 or 4 channels here. */
6012 channels
= png_get_channels (png_ptr
, info_ptr
);
6013 eassert (channels
== 3 || channels
== 4);
6015 /* Number of bytes needed for one row of the image. */
6016 row_bytes
= png_get_rowbytes (png_ptr
, info_ptr
);
6018 /* Allocate memory for the image. */
6019 if (height
> min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *rows
6020 || row_bytes
> min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *pixels
/ height
)
6021 memory_full (SIZE_MAX
);
6022 c
->pixels
= pixels
= xmalloc (sizeof *pixels
* row_bytes
* height
);
6023 c
->rows
= rows
= xmalloc (height
* sizeof *rows
);
6024 for (i
= 0; i
< height
; ++i
)
6025 rows
[i
] = pixels
+ i
* row_bytes
;
6027 /* Read the entire image. */
6028 png_read_image (png_ptr
, rows
);
6029 png_read_end (png_ptr
, info_ptr
);
6037 data
= (unsigned char *) xmalloc (width
* height
* 4);
6038 dataptr
= (uint32_t *) data
;
6040 /* Create an image and pixmap serving as mask if the PNG image
6041 contains an alpha channel. */
6044 && !image_create_x_image_and_pixmap (f
, img
, width
, height
, 1,
6047 x_destroy_x_image (ximg
);
6048 x_clear_image_1 (f
, img
, CLEAR_IMAGE_PIXMAP
);
6053 /* Fill the X image and mask from PNG data. */
6054 init_color_table ();
6056 for (y
= 0; y
< height
; ++y
)
6058 png_byte
*p
= rows
[y
];
6060 for (x
= 0; x
< width
; ++x
)
6069 if (channels
== 4) a
= *p
++;
6070 *dataptr
++ = (a
<< 24) | (r
<< 16) | (g
<< 8) | b
;
6075 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
6076 /* An alpha channel, aka mask channel, associates variable
6077 transparency with an image. Where other image formats
6078 support binary transparency---fully transparent or fully
6079 opaque---PNG allows up to 254 levels of partial transparency.
6080 The PNG library implements partial transparency by combining
6081 the image with a specified background color.
6083 I'm not sure how to handle this here nicely: because the
6084 background on which the image is displayed may change, for
6085 real alpha channel support, it would be necessary to create
6086 a new image for each possible background.
6088 What I'm doing now is that a mask is created if we have
6089 boolean transparency information. Otherwise I'm using
6090 the frame's background color to combine the image with. */
6095 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6102 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6103 /* Set IMG's background color from the PNG image, unless the user
6107 if (png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6109 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6110 img
->background_valid
= 1;
6114 # ifdef COLOR_TABLE_SUPPORT
6115 /* Remember colors allocated for this image. */
6116 img
->colors
= colors_in_color_table (&img
->ncolors
);
6117 free_color_table ();
6118 # endif /* COLOR_TABLE_SUPPORT */
6121 png_destroy_read_struct (&c
->png_ptr
, &c
->info_ptr
, &c
->end_info
);
6126 img
->height
= height
;
6129 create_cairo_image_surface (img
, data
, width
, height
);
6131 /* Maybe fill in the background field while we have ximg handy.
6132 Casting avoids a GCC warning. */
6133 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6135 /* Put ximg into the image. */
6136 image_put_x_image (f
, img
, ximg
, 0);
6138 /* Same for the mask. */
6141 /* Fill in the background_transparent field while we have the
6142 mask handy. Casting avoids a GCC warning. */
6143 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6145 image_put_x_image (f
, img
, mask_img
, 1);
6153 png_load (struct frame
*f
, struct image
*img
)
6155 struct png_load_context c
;
6156 return png_load_body (f
, img
, &c
);
6159 #elif defined HAVE_NS
6162 png_load (struct frame
*f
, struct image
*img
)
6164 return ns_load_image (f
, img
,
6165 image_spec_value (img
->spec
, QCfile
, NULL
),
6166 image_spec_value (img
->spec
, QCdata
, NULL
));
6170 #endif /* HAVE_NS */
6174 /***********************************************************************
6176 ***********************************************************************/
6178 #if defined (HAVE_JPEG) || defined (HAVE_NS)
6180 static bool jpeg_image_p (Lisp_Object object
);
6181 static bool jpeg_load (struct frame
*f
, struct image
*img
);
6183 /* Indices of image specification fields in gs_format, below. */
6185 enum jpeg_keyword_index
6194 JPEG_HEURISTIC_MASK
,
6200 /* Vector of image_keyword structures describing the format
6201 of valid user-defined image specifications. */
6203 static const struct image_keyword jpeg_format
[JPEG_LAST
] =
6205 {":type", IMAGE_SYMBOL_VALUE
, 1},
6206 {":data", IMAGE_STRING_VALUE
, 0},
6207 {":file", IMAGE_STRING_VALUE
, 0},
6208 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6209 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
6210 {":relief", IMAGE_INTEGER_VALUE
, 0},
6211 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6212 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6213 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6214 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6217 #if defined HAVE_NTGUI && defined WINDOWSNT
6218 static bool init_jpeg_functions (void);
6220 #define init_jpeg_functions NULL
6223 /* Structure describing the image type `jpeg'. */
6225 static struct image_type jpeg_type
=
6227 SYMBOL_INDEX (Qjpeg
),
6231 init_jpeg_functions
,
6235 /* Return true if OBJECT is a valid JPEG image specification. */
6238 jpeg_image_p (Lisp_Object object
)
6240 struct image_keyword fmt
[JPEG_LAST
];
6242 memcpy (fmt
, jpeg_format
, sizeof fmt
);
6244 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6247 /* Must specify either the :data or :file keyword. */
6248 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6251 #endif /* HAVE_JPEG || HAVE_NS */
6255 /* Work around a warning about HAVE_STDLIB_H being redefined in
6257 # ifdef HAVE_STDLIB_H
6258 # undef HAVE_STDLIB_H
6261 # if defined (HAVE_NTGUI) && !defined (__WIN32__)
6262 /* In older releases of the jpeg library, jpeglib.h will define boolean
6263 differently depending on __WIN32__, so make sure it is defined. */
6264 # define __WIN32__ 1
6267 /* rpcndr.h (via windows.h) and jpeglib.h both define boolean types.
6268 Some versions of jpeglib try to detect whether rpcndr.h is loaded,
6269 using the Windows boolean type instead of the jpeglib boolean type
6270 if so. Cygwin jpeglib, however, doesn't try to detect whether its
6271 headers are included along with windows.h, so under Cygwin, jpeglib
6272 attempts to define a conflicting boolean type. Worse, forcing
6273 Cygwin jpeglib headers to use the Windows boolean type doesn't work
6274 because it created an ABI incompatibility between the
6275 already-compiled jpeg library and the header interface definition.
6277 The best we can do is to define jpeglib's boolean type to a
6278 different name. This name, jpeg_boolean, remains in effect through
6279 the rest of image.c.
6281 # if defined CYGWIN && defined HAVE_NTGUI
6282 # define boolean jpeg_boolean
6284 # include <jpeglib.h>
6285 # include <jerror.h>
6289 /* JPEG library details. */
6290 DEF_DLL_FN (void, jpeg_CreateDecompress
, (j_decompress_ptr
, int, size_t));
6291 DEF_DLL_FN (boolean
, jpeg_start_decompress
, (j_decompress_ptr
));
6292 DEF_DLL_FN (boolean
, jpeg_finish_decompress
, (j_decompress_ptr
));
6293 DEF_DLL_FN (void, jpeg_destroy_decompress
, (j_decompress_ptr
));
6294 DEF_DLL_FN (int, jpeg_read_header
, (j_decompress_ptr
, boolean
));
6295 DEF_DLL_FN (JDIMENSION
, jpeg_read_scanlines
,
6296 (j_decompress_ptr
, JSAMPARRAY
, JDIMENSION
));
6297 DEF_DLL_FN (struct jpeg_error_mgr
*, jpeg_std_error
,
6298 (struct jpeg_error_mgr
*));
6299 DEF_DLL_FN (boolean
, jpeg_resync_to_restart
, (j_decompress_ptr
, int));
6302 init_jpeg_functions (void)
6306 if (!(library
= w32_delayed_load (Qjpeg
)))
6309 LOAD_DLL_FN (library
, jpeg_finish_decompress
);
6310 LOAD_DLL_FN (library
, jpeg_read_scanlines
);
6311 LOAD_DLL_FN (library
, jpeg_start_decompress
);
6312 LOAD_DLL_FN (library
, jpeg_read_header
);
6313 LOAD_DLL_FN (library
, jpeg_CreateDecompress
);
6314 LOAD_DLL_FN (library
, jpeg_destroy_decompress
);
6315 LOAD_DLL_FN (library
, jpeg_std_error
);
6316 LOAD_DLL_FN (library
, jpeg_resync_to_restart
);
6320 # undef jpeg_CreateDecompress
6321 # undef jpeg_destroy_decompress
6322 # undef jpeg_finish_decompress
6323 # undef jpeg_read_header
6324 # undef jpeg_read_scanlines
6325 # undef jpeg_resync_to_restart
6326 # undef jpeg_start_decompress
6327 # undef jpeg_std_error
6329 # define jpeg_CreateDecompress fn_jpeg_CreateDecompress
6330 # define jpeg_destroy_decompress fn_jpeg_destroy_decompress
6331 # define jpeg_finish_decompress fn_jpeg_finish_decompress
6332 # define jpeg_read_header fn_jpeg_read_header
6333 # define jpeg_read_scanlines fn_jpeg_read_scanlines
6334 # define jpeg_resync_to_restart fn_jpeg_resync_to_restart
6335 # define jpeg_start_decompress fn_jpeg_start_decompress
6336 # define jpeg_std_error fn_jpeg_std_error
6338 /* Wrapper since we can't directly assign the function pointer
6339 to another function pointer that was declared more completely easily. */
6341 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo
, int desired
)
6343 return jpeg_resync_to_restart (cinfo
, desired
);
6345 # undef jpeg_resync_to_restart
6346 # define jpeg_resync_to_restart jpeg_resync_to_restart_wrapper
6348 # endif /* WINDOWSNT */
6350 struct my_jpeg_error_mgr
6352 struct jpeg_error_mgr pub
;
6353 sys_jmp_buf setjmp_buffer
;
6355 /* The remaining members are so that longjmp doesn't munge local
6357 struct jpeg_decompress_struct cinfo
;
6361 MY_JPEG_INVALID_IMAGE_SIZE
,
6362 MY_JPEG_CANNOT_CREATE_X
6367 static _Noreturn
void
6368 my_error_exit (j_common_ptr cinfo
)
6370 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6371 mgr
->failure_code
= MY_JPEG_ERROR_EXIT
;
6372 sys_longjmp (mgr
->setjmp_buffer
, 1);
6376 /* Init source method for JPEG data source manager. Called by
6377 jpeg_read_header() before any data is actually read. See
6378 libjpeg.doc from the JPEG lib distribution. */
6381 our_common_init_source (j_decompress_ptr cinfo
)
6386 /* Method to terminate data source. Called by
6387 jpeg_finish_decompress() after all data has been processed. */
6390 our_common_term_source (j_decompress_ptr cinfo
)
6395 /* Fill input buffer method for JPEG data source manager. Called
6396 whenever more data is needed. We read the whole image in one step,
6397 so this only adds a fake end of input marker at the end. */
6399 static JOCTET our_memory_buffer
[2];
6402 our_memory_fill_input_buffer (j_decompress_ptr cinfo
)
6404 /* Insert a fake EOI marker. */
6405 struct jpeg_source_mgr
*src
= cinfo
->src
;
6407 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6408 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6410 src
->next_input_byte
= our_memory_buffer
;
6411 src
->bytes_in_buffer
= 2;
6416 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6417 is the JPEG data source manager. */
6420 our_memory_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6422 struct jpeg_source_mgr
*src
= cinfo
->src
;
6426 if (num_bytes
> src
->bytes_in_buffer
)
6427 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6429 src
->bytes_in_buffer
-= num_bytes
;
6430 src
->next_input_byte
+= num_bytes
;
6435 /* Set up the JPEG lib for reading an image from DATA which contains
6436 LEN bytes. CINFO is the decompression info structure created for
6437 reading the image. */
6440 jpeg_memory_src (j_decompress_ptr cinfo
, JOCTET
*data
, ptrdiff_t len
)
6442 struct jpeg_source_mgr
*src
= cinfo
->src
;
6446 /* First time for this JPEG object? */
6447 src
= cinfo
->mem
->alloc_small ((j_common_ptr
) cinfo
,
6448 JPOOL_PERMANENT
, sizeof *src
);
6450 src
->next_input_byte
= data
;
6453 src
->init_source
= our_common_init_source
;
6454 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6455 src
->skip_input_data
= our_memory_skip_input_data
;
6456 src
->resync_to_restart
= jpeg_resync_to_restart
; /* Use default method. */
6457 src
->term_source
= our_common_term_source
;
6458 src
->bytes_in_buffer
= len
;
6459 src
->next_input_byte
= data
;
6463 struct jpeg_stdio_mgr
6465 struct jpeg_source_mgr mgr
;
6472 /* Size of buffer to read JPEG from file.
6473 Not too big, as we want to use alloc_small. */
6474 #define JPEG_STDIO_BUFFER_SIZE 8192
6477 /* Fill input buffer method for JPEG data source manager. Called
6478 whenever more data is needed. The data is read from a FILE *. */
6481 our_stdio_fill_input_buffer (j_decompress_ptr cinfo
)
6483 struct jpeg_stdio_mgr
*src
;
6485 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6490 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6492 src
->mgr
.bytes_in_buffer
= bytes
;
6495 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6497 src
->buffer
[0] = (JOCTET
) 0xFF;
6498 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6499 src
->mgr
.bytes_in_buffer
= 2;
6501 src
->mgr
.next_input_byte
= src
->buffer
;
6508 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6509 is the JPEG data source manager. */
6512 our_stdio_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6514 struct jpeg_stdio_mgr
*src
;
6515 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6517 while (num_bytes
> 0 && !src
->finished
)
6519 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6521 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6522 src
->mgr
.next_input_byte
+= num_bytes
;
6527 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6528 src
->mgr
.bytes_in_buffer
= 0;
6529 src
->mgr
.next_input_byte
= NULL
;
6531 our_stdio_fill_input_buffer (cinfo
);
6537 /* Set up the JPEG lib for reading an image from a FILE *.
6538 CINFO is the decompression info structure created for
6539 reading the image. */
6542 jpeg_file_src (j_decompress_ptr cinfo
, FILE *fp
)
6544 struct jpeg_stdio_mgr
*src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6548 /* First time for this JPEG object? */
6549 src
= cinfo
->mem
->alloc_small ((j_common_ptr
) cinfo
,
6550 JPOOL_PERMANENT
, sizeof *src
);
6551 cinfo
->src
= (struct jpeg_source_mgr
*) src
;
6552 src
->buffer
= cinfo
->mem
->alloc_small ((j_common_ptr
) cinfo
,
6554 JPEG_STDIO_BUFFER_SIZE
);
6559 src
->mgr
.init_source
= our_common_init_source
;
6560 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6561 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6562 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart
; /* Use default. */
6563 src
->mgr
.term_source
= our_common_term_source
;
6564 src
->mgr
.bytes_in_buffer
= 0;
6565 src
->mgr
.next_input_byte
= NULL
;
6568 /* Load image IMG for use on frame F. Patterned after example.c
6569 from the JPEG lib. */
6572 jpeg_load_body (struct frame
*f
, struct image
*img
,
6573 struct my_jpeg_error_mgr
*mgr
)
6575 Lisp_Object file
, specified_file
;
6576 Lisp_Object specified_data
;
6577 /* The 'volatile' silences a bogus diagnostic; see GCC bug 54561. */
6578 FILE * IF_LINT (volatile) fp
= NULL
;
6580 int row_stride
, x
, y
;
6581 XImagePtr ximg
= NULL
;
6582 unsigned long *colors
;
6586 /* Open the JPEG file. */
6587 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6588 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6590 if (NILP (specified_data
))
6592 file
= x_find_image_file (specified_file
);
6593 if (!STRINGP (file
))
6595 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6599 fp
= emacs_fopen (SSDATA (file
), "rb");
6602 image_error ("Cannot open `%s'", file
, Qnil
);
6606 else if (!STRINGP (specified_data
))
6608 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6612 /* Customize libjpeg's error handling to call my_error_exit when an
6613 error is detected. This function will perform a longjmp. */
6614 mgr
->cinfo
.err
= jpeg_std_error (&mgr
->pub
);
6615 mgr
->pub
.error_exit
= my_error_exit
;
6616 if (sys_setjmp (mgr
->setjmp_buffer
))
6618 switch (mgr
->failure_code
)
6620 case MY_JPEG_ERROR_EXIT
:
6622 char buf
[JMSG_LENGTH_MAX
];
6623 mgr
->cinfo
.err
->format_message ((j_common_ptr
) &mgr
->cinfo
, buf
);
6624 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6625 build_string (buf
));
6629 case MY_JPEG_INVALID_IMAGE_SIZE
:
6630 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6633 case MY_JPEG_CANNOT_CREATE_X
:
6637 /* Close the input file and destroy the JPEG object. */
6640 jpeg_destroy_decompress (&mgr
->cinfo
);
6642 /* If we already have an XImage, free that. */
6643 x_destroy_x_image (ximg
);
6645 /* Free pixmap and colors. */
6646 x_clear_image (f
, img
);
6650 /* Create the JPEG decompression object. Let it read from fp.
6651 Read the JPEG image header. */
6652 jpeg_CreateDecompress (&mgr
->cinfo
, JPEG_LIB_VERSION
, sizeof *&mgr
->cinfo
);
6654 if (NILP (specified_data
))
6655 jpeg_file_src (&mgr
->cinfo
, fp
);
6657 jpeg_memory_src (&mgr
->cinfo
, SDATA (specified_data
),
6658 SBYTES (specified_data
));
6660 jpeg_read_header (&mgr
->cinfo
, 1);
6662 /* Customize decompression so that color quantization will be used.
6663 Start decompression. */
6664 mgr
->cinfo
.quantize_colors
= 1;
6665 jpeg_start_decompress (&mgr
->cinfo
);
6666 width
= img
->width
= mgr
->cinfo
.output_width
;
6667 height
= img
->height
= mgr
->cinfo
.output_height
;
6669 if (!check_image_size (f
, width
, height
))
6671 mgr
->failure_code
= MY_JPEG_INVALID_IMAGE_SIZE
;
6672 sys_longjmp (mgr
->setjmp_buffer
, 1);
6675 /* Create X image and pixmap. */
6676 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
6678 mgr
->failure_code
= MY_JPEG_CANNOT_CREATE_X
;
6679 sys_longjmp (mgr
->setjmp_buffer
, 1);
6682 /* Allocate colors. When color quantization is used,
6683 mgr->cinfo.actual_number_of_colors has been set with the number of
6684 colors generated, and mgr->cinfo.colormap is a two-dimensional array
6685 of color indices in the range 0..mgr->cinfo.actual_number_of_colors.
6686 No more than 255 colors will be generated. */
6689 if (mgr
->cinfo
.out_color_components
> 2)
6690 ir
= 0, ig
= 1, ib
= 2;
6691 else if (mgr
->cinfo
.out_color_components
> 1)
6692 ir
= 0, ig
= 1, ib
= 0;
6694 ir
= 0, ig
= 0, ib
= 0;
6697 /* Use the color table mechanism because it handles colors that
6698 cannot be allocated nicely. Such colors will be replaced with
6699 a default color, and we don't have to care about which colors
6700 can be freed safely, and which can't. */
6701 init_color_table ();
6702 SAFE_NALLOCA (colors
, 1, mgr
->cinfo
.actual_number_of_colors
);
6704 for (i
= 0; i
< mgr
->cinfo
.actual_number_of_colors
; ++i
)
6706 /* Multiply RGB values with 255 because X expects RGB values
6707 in the range 0..0xffff. */
6708 int r
= mgr
->cinfo
.colormap
[ir
][i
] << 8;
6709 int g
= mgr
->cinfo
.colormap
[ig
][i
] << 8;
6710 int b
= mgr
->cinfo
.colormap
[ib
][i
] << 8;
6711 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6715 #ifdef COLOR_TABLE_SUPPORT
6716 /* Remember those colors actually allocated. */
6717 img
->colors
= colors_in_color_table (&img
->ncolors
);
6718 free_color_table ();
6719 #endif /* COLOR_TABLE_SUPPORT */
6723 row_stride
= width
* mgr
->cinfo
.output_components
;
6724 buffer
= mgr
->cinfo
.mem
->alloc_sarray ((j_common_ptr
) &mgr
->cinfo
,
6725 JPOOL_IMAGE
, row_stride
, 1);
6728 unsigned char *data
= (unsigned char *) xmalloc (width
*height
*4);
6729 uint32_t *dataptr
= (uint32_t *) data
;
6732 for (y
= 0; y
< height
; ++y
)
6734 jpeg_read_scanlines (&mgr
->cinfo
, buffer
, 1);
6736 for (x
= 0; x
< width
; ++x
)
6739 r
= mgr
->cinfo
.colormap
[ir
][i
];
6740 g
= mgr
->cinfo
.colormap
[ig
][i
];
6741 b
= mgr
->cinfo
.colormap
[ib
][i
];
6742 *dataptr
++ = (0xff << 24) | (r
<< 16) | (g
<< 8) | b
;
6746 create_cairo_image_surface (img
, data
, width
, height
);
6749 for (y
= 0; y
< height
; ++y
)
6751 jpeg_read_scanlines (&mgr
->cinfo
, buffer
, 1);
6752 for (x
= 0; x
< mgr
->cinfo
.output_width
; ++x
)
6753 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6758 jpeg_finish_decompress (&mgr
->cinfo
);
6759 jpeg_destroy_decompress (&mgr
->cinfo
);
6764 /* Maybe fill in the background field while we have ximg handy. */
6765 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6766 /* Casting avoids a GCC warning. */
6767 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6769 /* Put ximg into the image. */
6770 image_put_x_image (f
, img
, ximg
, 0);
6777 jpeg_load (struct frame
*f
, struct image
*img
)
6779 struct my_jpeg_error_mgr mgr
;
6780 return jpeg_load_body (f
, img
, &mgr
);
6783 #else /* HAVE_JPEG */
6787 jpeg_load (struct frame
*f
, struct image
*img
)
6789 return ns_load_image (f
, img
,
6790 image_spec_value (img
->spec
, QCfile
, NULL
),
6791 image_spec_value (img
->spec
, QCdata
, NULL
));
6793 #endif /* HAVE_NS */
6795 #endif /* !HAVE_JPEG */
6799 /***********************************************************************
6801 ***********************************************************************/
6803 #if defined (HAVE_TIFF) || defined (HAVE_NS)
6805 static bool tiff_image_p (Lisp_Object object
);
6806 static bool tiff_load (struct frame
*f
, struct image
*img
);
6808 /* Indices of image specification fields in tiff_format, below. */
6810 enum tiff_keyword_index
6819 TIFF_HEURISTIC_MASK
,
6826 /* Vector of image_keyword structures describing the format
6827 of valid user-defined image specifications. */
6829 static const struct image_keyword tiff_format
[TIFF_LAST
] =
6831 {":type", IMAGE_SYMBOL_VALUE
, 1},
6832 {":data", IMAGE_STRING_VALUE
, 0},
6833 {":file", IMAGE_STRING_VALUE
, 0},
6834 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6835 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
6836 {":relief", IMAGE_INTEGER_VALUE
, 0},
6837 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6838 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6839 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6840 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
6841 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0}
6844 #if defined HAVE_NTGUI && defined WINDOWSNT
6845 static bool init_tiff_functions (void);
6847 #define init_tiff_functions NULL
6850 /* Structure describing the image type `tiff'. */
6852 static struct image_type tiff_type
=
6854 SYMBOL_INDEX (Qtiff
),
6858 init_tiff_functions
,
6862 /* Return true if OBJECT is a valid TIFF image specification. */
6865 tiff_image_p (Lisp_Object object
)
6867 struct image_keyword fmt
[TIFF_LAST
];
6868 memcpy (fmt
, tiff_format
, sizeof fmt
);
6870 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6873 /* Must specify either the :data or :file keyword. */
6874 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6877 #endif /* HAVE_TIFF || HAVE_NS */
6881 # include <tiffio.h>
6885 /* TIFF library details. */
6886 DEF_DLL_FN (TIFFErrorHandler
, TIFFSetErrorHandler
, (TIFFErrorHandler
));
6887 DEF_DLL_FN (TIFFErrorHandler
, TIFFSetWarningHandler
, (TIFFErrorHandler
));
6888 DEF_DLL_FN (TIFF
*, TIFFOpen
, (const char *, const char *));
6889 DEF_DLL_FN (TIFF
*, TIFFClientOpen
,
6890 (const char *, const char *, thandle_t
, TIFFReadWriteProc
,
6891 TIFFReadWriteProc
, TIFFSeekProc
, TIFFCloseProc
, TIFFSizeProc
,
6892 TIFFMapFileProc
, TIFFUnmapFileProc
));
6893 DEF_DLL_FN (int, TIFFGetField
, (TIFF
*, ttag_t
, ...));
6894 DEF_DLL_FN (int, TIFFReadRGBAImage
, (TIFF
*, uint32
, uint32
, uint32
*, int));
6895 DEF_DLL_FN (void, TIFFClose
, (TIFF
*));
6896 DEF_DLL_FN (int, TIFFSetDirectory
, (TIFF
*, tdir_t
));
6899 init_tiff_functions (void)
6903 if (!(library
= w32_delayed_load (Qtiff
)))
6906 LOAD_DLL_FN (library
, TIFFSetErrorHandler
);
6907 LOAD_DLL_FN (library
, TIFFSetWarningHandler
);
6908 LOAD_DLL_FN (library
, TIFFOpen
);
6909 LOAD_DLL_FN (library
, TIFFClientOpen
);
6910 LOAD_DLL_FN (library
, TIFFGetField
);
6911 LOAD_DLL_FN (library
, TIFFReadRGBAImage
);
6912 LOAD_DLL_FN (library
, TIFFClose
);
6913 LOAD_DLL_FN (library
, TIFFSetDirectory
);
6917 # undef TIFFClientOpen
6919 # undef TIFFGetField
6921 # undef TIFFReadRGBAImage
6922 # undef TIFFSetDirectory
6923 # undef TIFFSetErrorHandler
6924 # undef TIFFSetWarningHandler
6926 # define TIFFClientOpen fn_TIFFClientOpen
6927 # define TIFFClose fn_TIFFClose
6928 # define TIFFGetField fn_TIFFGetField
6929 # define TIFFOpen fn_TIFFOpen
6930 # define TIFFReadRGBAImage fn_TIFFReadRGBAImage
6931 # define TIFFSetDirectory fn_TIFFSetDirectory
6932 # define TIFFSetErrorHandler fn_TIFFSetErrorHandler
6933 # define TIFFSetWarningHandler fn_TIFFSetWarningHandler
6935 # endif /* WINDOWSNT */
6938 /* Reading from a memory buffer for TIFF images Based on the PNG
6939 memory source, but we have to provide a lot of extra functions.
6942 We really only need to implement read and seek, but I am not
6943 convinced that the TIFF library is smart enough not to destroy
6944 itself if we only hand it the function pointers we need to
6949 unsigned char *bytes
;
6956 tiff_read_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6958 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6960 size
= min (size
, src
->len
- src
->index
);
6961 memcpy (buf
, src
->bytes
+ src
->index
, size
);
6967 tiff_write_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6973 tiff_seek_in_memory (thandle_t data
, toff_t off
, int whence
)
6975 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6980 case SEEK_SET
: /* Go from beginning of source. */
6984 case SEEK_END
: /* Go from end of source. */
6985 idx
= src
->len
+ off
;
6988 case SEEK_CUR
: /* Go from current position. */
6989 idx
= src
->index
+ off
;
6992 default: /* Invalid `whence'. */
6996 if (idx
> src
->len
|| idx
< 0)
7004 tiff_close_memory (thandle_t data
)
7011 tiff_mmap_memory (thandle_t data
, tdata_t
*pbase
, toff_t
*psize
)
7013 /* It is already _IN_ memory. */
7018 tiff_unmap_memory (thandle_t data
, tdata_t base
, toff_t size
)
7020 /* We don't need to do this. */
7024 tiff_size_of_memory (thandle_t data
)
7026 return ((tiff_memory_source
*) data
)->len
;
7029 /* GCC 3.x on x86 Windows targets has a bug that triggers an internal
7030 compiler error compiling tiff_handler, see Bugzilla bug #17406
7031 (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=17406). Declaring
7032 this function as external works around that problem. */
7033 # if defined (__MINGW32__) && __GNUC__ == 3
7034 # define MINGW_STATIC
7036 # define MINGW_STATIC static
7040 tiff_handler (const char *, const char *, const char *, va_list)
7041 ATTRIBUTE_FORMAT_PRINTF (3, 0);
7043 tiff_handler (const char *log_format
, const char *title
,
7044 const char *format
, va_list ap
)
7046 /* doprnt is not suitable here, as TIFF handlers are called from
7047 libtiff and are passed arbitrary printf directives. Instead, use
7048 vsnprintf, taking care to be portable to nonstandard environments
7049 where vsnprintf returns -1 on buffer overflow. Since it's just a
7050 log entry, it's OK to truncate it. */
7052 int len
= vsnprintf (buf
, sizeof buf
, format
, ap
);
7053 add_to_log (log_format
, build_string (title
),
7054 make_string (buf
, max (0, min (len
, sizeof buf
- 1))));
7056 # undef MINGW_STATIC
7058 static void tiff_error_handler (const char *, const char *, va_list)
7059 ATTRIBUTE_FORMAT_PRINTF (2, 0);
7061 tiff_error_handler (const char *title
, const char *format
, va_list ap
)
7063 tiff_handler ("TIFF error: %s %s", title
, format
, ap
);
7067 static void tiff_warning_handler (const char *, const char *, va_list)
7068 ATTRIBUTE_FORMAT_PRINTF (2, 0);
7070 tiff_warning_handler (const char *title
, const char *format
, va_list ap
)
7072 tiff_handler ("TIFF warning: %s %s", title
, format
, ap
);
7076 /* Load TIFF image IMG for use on frame F. Value is true if
7080 tiff_load (struct frame
*f
, struct image
*img
)
7082 Lisp_Object file
, specified_file
;
7083 Lisp_Object specified_data
;
7085 int width
, height
, x
, y
, count
;
7089 tiff_memory_source memsrc
;
7092 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7093 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7095 TIFFSetErrorHandler ((TIFFErrorHandler
) tiff_error_handler
);
7096 TIFFSetWarningHandler ((TIFFErrorHandler
) tiff_warning_handler
);
7098 if (NILP (specified_data
))
7100 /* Read from a file */
7101 file
= x_find_image_file (specified_file
);
7102 if (!STRINGP (file
))
7104 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7108 file
= ansi_encode_filename (file
);
7111 /* Try to open the image file. */
7112 tiff
= TIFFOpen (SSDATA (file
), "r");
7115 image_error ("Cannot open `%s'", file
, Qnil
);
7121 if (!STRINGP (specified_data
))
7123 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
7127 /* Memory source! */
7128 memsrc
.bytes
= SDATA (specified_data
);
7129 memsrc
.len
= SBYTES (specified_data
);
7132 tiff
= TIFFClientOpen ("memory_source", "r", (thandle_t
)&memsrc
,
7133 tiff_read_from_memory
,
7134 tiff_write_from_memory
,
7135 tiff_seek_in_memory
,
7137 tiff_size_of_memory
,
7143 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7148 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7149 if (INTEGERP (image
))
7151 EMACS_INT ino
= XFASTINT (image
);
7152 if (! (TYPE_MINIMUM (tdir_t
) <= ino
&& ino
<= TYPE_MAXIMUM (tdir_t
)
7153 && TIFFSetDirectory (tiff
, ino
)))
7155 image_error ("Invalid image number `%s' in image `%s'",
7162 /* Get width and height of the image, and allocate a raster buffer
7163 of width x height 32-bit values. */
7164 TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7165 TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7167 if (!check_image_size (f
, width
, height
))
7169 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7174 /* Create the X image and pixmap. */
7175 if (! (height
<= min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *buf
/ width
7176 && image_create_x_image_and_pixmap (f
, img
, width
, height
, 0,
7183 buf
= xmalloc (sizeof *buf
* width
* height
);
7185 rc
= TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7187 /* Count the number of images in the file. */
7188 for (count
= 1; TIFFSetDirectory (tiff
, count
); count
++)
7192 img
->lisp_data
= Fcons (Qcount
,
7193 Fcons (make_number (count
),
7199 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7206 unsigned char *data
= (unsigned char *) xmalloc (width
*height
*4);
7207 uint32_t *dataptr
= (uint32_t *) data
;
7210 for (y
= 0; y
< height
; ++y
)
7212 uint32
*row
= buf
+ (height
- 1 - y
) * width
;
7213 for (x
= 0; x
< width
; ++x
)
7215 uint32 abgr
= row
[x
];
7216 int r
= TIFFGetR (abgr
);
7217 int g
= TIFFGetG (abgr
);
7218 int b
= TIFFGetB (abgr
);
7219 int a
= TIFFGetA (abgr
);
7220 *dataptr
++ = (a
<< 24) | (r
<< 16) | (g
<< 8) | b
;
7224 create_cairo_image_surface (img
, data
, width
, height
);
7227 /* Initialize the color table. */
7228 init_color_table ();
7230 /* Process the pixel raster. Origin is in the lower-left corner. */
7231 for (y
= 0; y
< height
; ++y
)
7233 uint32
*row
= buf
+ y
* width
;
7235 for (x
= 0; x
< width
; ++x
)
7237 uint32 abgr
= row
[x
];
7238 int r
= TIFFGetR (abgr
) << 8;
7239 int g
= TIFFGetG (abgr
) << 8;
7240 int b
= TIFFGetB (abgr
) << 8;
7241 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7245 # ifdef COLOR_TABLE_SUPPORT
7246 /* Remember the colors allocated for the image. Free the color table. */
7247 img
->colors
= colors_in_color_table (&img
->ncolors
);
7248 free_color_table ();
7249 # endif /* COLOR_TABLE_SUPPORT */
7252 img
->height
= height
;
7254 /* Maybe fill in the background field while we have ximg handy. */
7255 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7256 /* Casting avoids a GCC warning on W32. */
7257 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7259 /* Put ximg into the image. */
7260 image_put_x_image (f
, img
, ximg
, 0);
7262 #endif /* ! USE_CAIRO */
7268 #elif defined HAVE_NS
7271 tiff_load (struct frame
*f
, struct image
*img
)
7273 return ns_load_image (f
, img
,
7274 image_spec_value (img
->spec
, QCfile
, NULL
),
7275 image_spec_value (img
->spec
, QCdata
, NULL
));
7282 /***********************************************************************
7284 ***********************************************************************/
7286 #if defined (HAVE_GIF) || defined (HAVE_NS)
7288 static bool gif_image_p (Lisp_Object object
);
7289 static bool gif_load (struct frame
*f
, struct image
*img
);
7290 static void gif_clear_image (struct frame
*f
, struct image
*img
);
7292 /* Indices of image specification fields in gif_format, below. */
7294 enum gif_keyword_index
7310 /* Vector of image_keyword structures describing the format
7311 of valid user-defined image specifications. */
7313 static const struct image_keyword gif_format
[GIF_LAST
] =
7315 {":type", IMAGE_SYMBOL_VALUE
, 1},
7316 {":data", IMAGE_STRING_VALUE
, 0},
7317 {":file", IMAGE_STRING_VALUE
, 0},
7318 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7319 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
7320 {":relief", IMAGE_INTEGER_VALUE
, 0},
7321 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7322 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7323 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7324 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7325 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7328 #if defined HAVE_NTGUI && defined WINDOWSNT
7329 static bool init_gif_functions (void);
7331 #define init_gif_functions NULL
7334 /* Structure describing the image type `gif'. */
7336 static struct image_type gif_type
=
7338 SYMBOL_INDEX (Qgif
),
7346 /* Free X resources of GIF image IMG which is used on frame F. */
7349 gif_clear_image (struct frame
*f
, struct image
*img
)
7351 img
->lisp_data
= Qnil
;
7352 x_clear_image (f
, img
);
7355 /* Return true if OBJECT is a valid GIF image specification. */
7358 gif_image_p (Lisp_Object object
)
7360 struct image_keyword fmt
[GIF_LAST
];
7361 memcpy (fmt
, gif_format
, sizeof fmt
);
7363 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7366 /* Must specify either the :data or :file keyword. */
7367 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7370 #endif /* HAVE_GIF */
7376 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7377 Undefine before redefining to avoid a preprocessor warning. */
7381 /* avoid conflict with QuickdrawText.h */
7382 # define DrawText gif_DrawText
7383 # include <gif_lib.h>
7386 /* Giflib before 5.0 didn't define these macros (used only if HAVE_NTGUI). */
7387 # ifndef GIFLIB_MINOR
7388 # define GIFLIB_MINOR 0
7390 # ifndef GIFLIB_RELEASE
7391 # define GIFLIB_RELEASE 0
7394 # else /* HAVE_NTGUI */
7396 # include <gif_lib.h>
7398 # endif /* HAVE_NTGUI */
7400 /* Giflib before 5.0 didn't define these macros. */
7401 # ifndef GIFLIB_MAJOR
7402 # define GIFLIB_MAJOR 4
7407 /* GIF library details. */
7408 # if GIFLIB_MAJOR + (GIFLIB_MINOR >= 1) > 5
7409 DEF_DLL_FN (int, DGifCloseFile
, (GifFileType
*, int *));
7411 DEF_DLL_FN (int, DGifCloseFile
, (GifFileType
*));
7413 DEF_DLL_FN (int, DGifSlurp
, (GifFileType
*));
7414 # if GIFLIB_MAJOR < 5
7415 DEF_DLL_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
));
7416 DEF_DLL_FN (GifFileType
*, DGifOpenFileName
, (const char *));
7418 DEF_DLL_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
, int *));
7419 DEF_DLL_FN (GifFileType
*, DGifOpenFileName
, (const char *, int *));
7420 DEF_DLL_FN (char *, GifErrorString
, (int));
7424 init_gif_functions (void)
7428 if (!(library
= w32_delayed_load (Qgif
)))
7431 LOAD_DLL_FN (library
, DGifCloseFile
);
7432 LOAD_DLL_FN (library
, DGifSlurp
);
7433 LOAD_DLL_FN (library
, DGifOpen
);
7434 LOAD_DLL_FN (library
, DGifOpenFileName
);
7435 # if GIFLIB_MAJOR >= 5
7436 LOAD_DLL_FN (library
, GifErrorString
);
7441 # undef DGifCloseFile
7443 # undef DGifOpenFileName
7445 # undef GifErrorString
7447 # define DGifCloseFile fn_DGifCloseFile
7448 # define DGifOpen fn_DGifOpen
7449 # define DGifOpenFileName fn_DGifOpenFileName
7450 # define DGifSlurp fn_DGifSlurp
7451 # define GifErrorString fn_GifErrorString
7453 # endif /* WINDOWSNT */
7455 /* Reading a GIF image from memory
7456 Based on the PNG memory stuff to a certain extent. */
7460 unsigned char *bytes
;
7466 /* Make the current memory source available to gif_read_from_memory.
7467 It's done this way because not all versions of libungif support
7468 a UserData field in the GifFileType structure. */
7469 static gif_memory_source
*current_gif_memory_src
;
7472 gif_read_from_memory (GifFileType
*file
, GifByteType
*buf
, int len
)
7474 gif_memory_source
*src
= current_gif_memory_src
;
7476 if (len
> src
->len
- src
->index
)
7479 memcpy (buf
, src
->bytes
+ src
->index
, len
);
7485 gif_close (GifFileType
*gif
, int *err
)
7489 #if GIFLIB_MAJOR + (GIFLIB_MINOR >= 1) > 5
7490 retval
= DGifCloseFile (gif
, err
);
7492 retval
= DGifCloseFile (gif
);
7493 #if GIFLIB_MAJOR >= 5
7501 /* Load GIF image IMG for use on frame F. Value is true if
7504 static const int interlace_start
[] = {0, 4, 2, 1};
7505 static const int interlace_increment
[] = {8, 8, 4, 2};
7507 #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249
7510 gif_load (struct frame
*f
, struct image
*img
)
7513 int rc
, width
, height
, x
, y
, i
, j
;
7515 ColorMapObject
*gif_color_map
;
7516 unsigned long pixel_colors
[256];
7518 gif_memory_source memsrc
;
7519 Lisp_Object specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7520 Lisp_Object specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7521 Lisp_Object specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7522 unsigned long bgcolor
= 0;
7527 unsigned char *data
= 0;
7530 if (NILP (specified_data
))
7532 file
= x_find_image_file (specified_file
);
7533 if (!STRINGP (file
))
7535 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7539 file
= ansi_encode_filename (file
);
7542 /* Open the GIF file. */
7543 #if GIFLIB_MAJOR < 5
7544 gif
= DGifOpenFileName (SSDATA (file
));
7547 image_error ("Cannot open `%s'", file
, Qnil
);
7551 gif
= DGifOpenFileName (SSDATA (file
), &gif_err
);
7554 image_error ("Cannot open `%s': %s",
7555 file
, build_string (GifErrorString (gif_err
)));
7562 if (!STRINGP (specified_data
))
7564 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
7568 /* Read from memory! */
7569 current_gif_memory_src
= &memsrc
;
7570 memsrc
.bytes
= SDATA (specified_data
);
7571 memsrc
.len
= SBYTES (specified_data
);
7574 #if GIFLIB_MAJOR < 5
7575 gif
= DGifOpen (&memsrc
, gif_read_from_memory
);
7578 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7582 gif
= DGifOpen (&memsrc
, gif_read_from_memory
, &gif_err
);
7585 image_error ("Cannot open memory source `%s': %s",
7586 img
->spec
, build_string (GifErrorString (gif_err
)));
7592 /* Before reading entire contents, check the declared image size. */
7593 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7595 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7596 gif_close (gif
, NULL
);
7600 /* Read entire contents. */
7601 rc
= DGifSlurp (gif
);
7602 if (rc
== GIF_ERROR
|| gif
->ImageCount
<= 0)
7604 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7605 gif_close (gif
, NULL
);
7609 /* Which sub-image are we to display? */
7611 Lisp_Object image_number
= image_spec_value (img
->spec
, QCindex
, NULL
);
7612 idx
= INTEGERP (image_number
) ? XFASTINT (image_number
) : 0;
7613 if (idx
< 0 || idx
>= gif
->ImageCount
)
7615 image_error ("Invalid image number `%s' in image `%s'",
7616 image_number
, img
->spec
);
7617 gif_close (gif
, NULL
);
7622 width
= img
->width
= gif
->SWidth
;
7623 height
= img
->height
= gif
->SHeight
;
7625 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[0].ImageDesc
.Top
;
7626 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[0].ImageDesc
.Left
;
7627 img
->corners
[BOT_CORNER
]
7628 = img
->corners
[TOP_CORNER
] + gif
->SavedImages
[0].ImageDesc
.Height
;
7629 img
->corners
[RIGHT_CORNER
]
7630 = img
->corners
[LEFT_CORNER
] + gif
->SavedImages
[0].ImageDesc
.Width
;
7632 if (!check_image_size (f
, width
, height
))
7634 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7635 gif_close (gif
, NULL
);
7639 /* Check that the selected subimages fit. It's not clear whether
7640 the GIF spec requires this, but Emacs can crash if they don't fit. */
7641 for (j
= 0; j
<= idx
; ++j
)
7643 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7644 int subimg_width
= subimage
->ImageDesc
.Width
;
7645 int subimg_height
= subimage
->ImageDesc
.Height
;
7646 int subimg_top
= subimage
->ImageDesc
.Top
;
7647 int subimg_left
= subimage
->ImageDesc
.Left
;
7648 if (! (subimg_width
>= 0 && subimg_height
>= 0
7649 && 0 <= subimg_top
&& subimg_top
<= height
- subimg_height
7650 && 0 <= subimg_left
&& subimg_left
<= width
- subimg_width
))
7652 image_error ("Subimage does not fit in image", Qnil
, Qnil
);
7653 gif_close (gif
, NULL
);
7659 /* xzalloc so data is zero => transparent */
7660 data
= (unsigned char *) xzalloc (width
* height
* 4);
7661 if (STRINGP (specified_bg
))
7664 if (x_defined_color (f
, SSDATA (specified_bg
), &color
, 0))
7666 uint32_t *dataptr
= (uint32_t *)data
;
7667 int r
= color
.red
/256;
7668 int g
= color
.green
/256;
7669 int b
= color
.blue
/256;
7671 for (y
= 0; y
< height
; ++y
)
7672 for (x
= 0; x
< width
; ++x
)
7673 *dataptr
++ = (0xff << 24) | (r
<< 16) | (g
<< 8) | b
;
7677 /* Create the X image and pixmap. */
7678 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
7680 gif_close (gif
, NULL
);
7684 /* Clear the part of the screen image not covered by the image.
7685 Full animated GIF support requires more here (see the gif89 spec,
7686 disposal methods). Let's simply assume that the part not covered
7687 by a sub-image is in the frame's background color. */
7688 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7689 for (x
= 0; x
< width
; ++x
)
7690 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7692 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7693 for (x
= 0; x
< width
; ++x
)
7694 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7696 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7698 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7699 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7700 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7701 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7705 /* Read the GIF image into the X image. */
7707 /* FIXME: With the current implementation, loading an animated gif
7708 is quadratic in the number of animation frames, since each frame
7709 is a separate struct image. We must provide a way for a single
7710 gif_load call to construct and save all animation frames. */
7712 init_color_table ();
7713 if (STRINGP (specified_bg
))
7714 bgcolor
= x_alloc_image_color (f
, img
, specified_bg
,
7715 FRAME_BACKGROUND_PIXEL (f
));
7716 for (j
= 0; j
<= idx
; ++j
)
7718 /* We use a local variable `raster' here because RasterBits is a
7719 char *, which invites problems with bytes >= 0x80. */
7720 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7721 unsigned char *raster
= (unsigned char *) subimage
->RasterBits
;
7722 int transparency_color_index
= -1;
7724 int subimg_width
= subimage
->ImageDesc
.Width
;
7725 int subimg_height
= subimage
->ImageDesc
.Height
;
7726 int subimg_top
= subimage
->ImageDesc
.Top
;
7727 int subimg_left
= subimage
->ImageDesc
.Left
;
7729 /* Find the Graphic Control Extension block for this sub-image.
7730 Extract the disposal method and transparency color. */
7731 for (i
= 0; i
< subimage
->ExtensionBlockCount
; i
++)
7733 ExtensionBlock
*extblock
= subimage
->ExtensionBlocks
+ i
;
7735 if ((extblock
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
)
7736 && extblock
->ByteCount
== 4
7737 && extblock
->Bytes
[0] & 1)
7739 /* From gif89a spec: 1 = "keep in place", 2 = "restore
7740 to background". Treat any other value like 2. */
7741 disposal
= (extblock
->Bytes
[0] >> 2) & 7;
7742 transparency_color_index
= (unsigned char) extblock
->Bytes
[3];
7747 /* We can't "keep in place" the first subimage. */
7751 /* For disposal == 0, the spec says "No disposal specified. The
7752 decoder is not required to take any action." In practice, it
7753 seems we need to treat this like "keep in place", see e.g.
7754 http://upload.wikimedia.org/wikipedia/commons/3/37/Clock.gif */
7758 gif_color_map
= subimage
->ImageDesc
.ColorMap
;
7760 gif_color_map
= gif
->SColorMap
;
7763 /* Allocate subimage colors. */
7764 memset (pixel_colors
, 0, sizeof pixel_colors
);
7767 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7769 if (transparency_color_index
== i
)
7770 pixel_colors
[i
] = STRINGP (specified_bg
)
7771 ? bgcolor
: FRAME_BACKGROUND_PIXEL (f
);
7774 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7775 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7776 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7777 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7782 /* Apply the pixel values. */
7783 if (GIFLIB_MAJOR
< 5 && gif
->SavedImages
[j
].ImageDesc
.Interlace
)
7787 for (y
= 0, row
= interlace_start
[0], pass
= 0;
7789 y
++, row
+= interlace_increment
[pass
])
7791 while (subimg_height
<= row
)
7792 row
= interlace_start
[++pass
];
7794 for (x
= 0; x
< subimg_width
; x
++)
7796 int c
= raster
[y
* subimg_width
+ x
];
7797 if (transparency_color_index
!= c
|| disposal
!= 1)
7801 ((uint32_t*)data
+ ((row
+ subimg_top
) * subimg_width
7802 + x
+ subimg_left
));
7803 int r
= gif_color_map
->Colors
[c
].Red
;
7804 int g
= gif_color_map
->Colors
[c
].Green
;
7805 int b
= gif_color_map
->Colors
[c
].Blue
;
7807 if (transparency_color_index
!= c
)
7808 *dataptr
= (0xff << 24) | (r
<< 16) | (g
<< 8) | b
;
7810 XPutPixel (ximg
, x
+ subimg_left
, row
+ subimg_top
,
7819 for (y
= 0; y
< subimg_height
; ++y
)
7820 for (x
= 0; x
< subimg_width
; ++x
)
7822 int c
= raster
[y
* subimg_width
+ x
];
7823 if (transparency_color_index
!= c
|| disposal
!= 1)
7827 ((uint32_t*)data
+ ((y
+ subimg_top
) * subimg_width
7828 + x
+ subimg_left
));
7829 int r
= gif_color_map
->Colors
[c
].Red
;
7830 int g
= gif_color_map
->Colors
[c
].Green
;
7831 int b
= gif_color_map
->Colors
[c
].Blue
;
7832 if (transparency_color_index
!= c
)
7833 *dataptr
= (0xff << 24) | (r
<< 16) | (g
<< 8) | b
;
7835 XPutPixel (ximg
, x
+ subimg_left
, y
+ subimg_top
,
7843 #ifdef COLOR_TABLE_SUPPORT
7844 img
->colors
= colors_in_color_table (&img
->ncolors
);
7845 free_color_table ();
7846 #endif /* COLOR_TABLE_SUPPORT */
7848 /* Save GIF image extension data for `image-metadata'.
7849 Format is (count IMAGES extension-data (FUNCTION "BYTES" ...)). */
7850 img
->lisp_data
= Qnil
;
7851 if (gif
->SavedImages
[idx
].ExtensionBlockCount
> 0)
7854 ExtensionBlock
*ext
= gif
->SavedImages
[idx
].ExtensionBlocks
;
7855 for (i
= 0; i
< gif
->SavedImages
[idx
].ExtensionBlockCount
; i
++, ext
++)
7856 /* Append (... FUNCTION "BYTES") */
7859 = Fcons (make_number (ext
->Function
),
7860 Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7862 if (ext
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
7863 && ext
->ByteCount
== 4)
7865 delay
= ext
->Bytes
[2] << CHAR_BIT
;
7866 delay
|= ext
->Bytes
[1];
7869 img
->lisp_data
= list2 (Qextension_data
, img
->lisp_data
);
7873 Fcons (make_float (delay
/ 100.0),
7877 if (gif
->ImageCount
> 1)
7878 img
->lisp_data
= Fcons (Qcount
,
7879 Fcons (make_number (gif
->ImageCount
),
7882 if (gif_close (gif
, &gif_err
) == GIF_ERROR
)
7884 #if 5 <= GIFLIB_MAJOR
7885 char *error_text
= GifErrorString (gif_err
);
7888 image_error ("Error closing `%s': %s",
7889 img
->spec
, build_string (error_text
));
7891 image_error ("Error closing `%s'", img
->spec
, Qnil
);
7896 create_cairo_image_surface (img
, data
, width
, height
);
7898 /* Maybe fill in the background field while we have ximg handy. */
7899 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7900 /* Casting avoids a GCC warning. */
7901 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7903 /* Put ximg into the image. */
7904 image_put_x_image (f
, img
, ximg
, 0);
7910 #else /* !HAVE_GIF */
7914 gif_load (struct frame
*f
, struct image
*img
)
7916 return ns_load_image (f
, img
,
7917 image_spec_value (img
->spec
, QCfile
, NULL
),
7918 image_spec_value (img
->spec
, QCdata
, NULL
));
7920 #endif /* HAVE_NS */
7922 #endif /* HAVE_GIF */
7925 #ifdef HAVE_IMAGEMAGICK
7927 /***********************************************************************
7929 ***********************************************************************/
7931 /* Scale an image size by returning SIZE / DIVISOR * MULTIPLIER,
7932 safely rounded and clipped to int range. */
7935 scale_image_size (int size
, size_t divisor
, size_t multiplier
)
7940 double scaled
= s
* multiplier
/ divisor
+ 0.5;
7941 if (scaled
< INT_MAX
)
7947 /* Compute the desired size of an image with native size WIDTH x HEIGHT.
7948 Use SPEC to deduce the size. Store the desired size into
7949 *D_WIDTH x *D_HEIGHT. Store -1 x -1 if the native size is OK. */
7951 compute_image_size (size_t width
, size_t height
,
7953 int *d_width
, int *d_height
)
7956 int desired_width
, desired_height
;
7958 /* If width and/or height is set in the display spec assume we want
7959 to scale to those values. If either h or w is unspecified, the
7960 unspecified should be calculated from the specified to preserve
7962 value
= image_spec_value (spec
, QCwidth
, NULL
);
7963 desired_width
= NATNUMP (value
) ? min (XFASTINT (value
), INT_MAX
) : -1;
7964 value
= image_spec_value (spec
, QCheight
, NULL
);
7965 desired_height
= NATNUMP (value
) ? min (XFASTINT (value
), INT_MAX
) : -1;
7967 if (desired_width
== -1)
7969 value
= image_spec_value (spec
, QCmax_width
, NULL
);
7970 if (NATNUMP (value
))
7972 int max_width
= min (XFASTINT (value
), INT_MAX
);
7973 if (max_width
< width
)
7975 /* The image is wider than :max-width. */
7976 desired_width
= max_width
;
7977 if (desired_height
== -1)
7979 desired_height
= scale_image_size (desired_width
,
7981 value
= image_spec_value (spec
, QCmax_height
, NULL
);
7982 if (NATNUMP (value
))
7984 int max_height
= min (XFASTINT (value
), INT_MAX
);
7985 if (max_height
< desired_height
)
7987 desired_height
= max_height
;
7988 desired_width
= scale_image_size (desired_height
,
7997 if (desired_height
== -1)
7999 value
= image_spec_value (spec
, QCmax_height
, NULL
);
8000 if (NATNUMP (value
))
8002 int max_height
= min (XFASTINT (value
), INT_MAX
);
8003 if (max_height
< height
)
8004 desired_height
= max_height
;
8008 if (desired_width
!= -1 && desired_height
== -1)
8009 /* w known, calculate h. */
8010 desired_height
= scale_image_size (desired_width
, width
, height
);
8012 if (desired_width
== -1 && desired_height
!= -1)
8013 /* h known, calculate w. */
8014 desired_width
= scale_image_size (desired_height
, height
, width
);
8016 *d_width
= desired_width
;
8017 *d_height
= desired_height
;
8020 static bool imagemagick_image_p (Lisp_Object
);
8021 static bool imagemagick_load (struct frame
*, struct image
*);
8022 static void imagemagick_clear_image (struct frame
*, struct image
*);
8024 /* Indices of image specification fields in imagemagick_format. */
8026 enum imagemagick_keyword_index
8034 IMAGEMAGICK_ALGORITHM
,
8035 IMAGEMAGICK_HEURISTIC_MASK
,
8037 IMAGEMAGICK_BACKGROUND
,
8040 IMAGEMAGICK_MAX_HEIGHT
,
8041 IMAGEMAGICK_MAX_WIDTH
,
8043 IMAGEMAGICK_ROTATION
,
8048 /* Vector of image_keyword structures describing the format
8049 of valid user-defined image specifications. */
8051 static struct image_keyword imagemagick_format
[IMAGEMAGICK_LAST
] =
8053 {":type", IMAGE_SYMBOL_VALUE
, 1},
8054 {":data", IMAGE_STRING_VALUE
, 0},
8055 {":file", IMAGE_STRING_VALUE
, 0},
8056 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8057 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
8058 {":relief", IMAGE_INTEGER_VALUE
, 0},
8059 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8060 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8061 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8062 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
8063 {":height", IMAGE_INTEGER_VALUE
, 0},
8064 {":width", IMAGE_INTEGER_VALUE
, 0},
8065 {":max-height", IMAGE_INTEGER_VALUE
, 0},
8066 {":max-width", IMAGE_INTEGER_VALUE
, 0},
8067 {":format", IMAGE_SYMBOL_VALUE
, 0},
8068 {":rotation", IMAGE_NUMBER_VALUE
, 0},
8069 {":crop", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
8072 #if defined HAVE_NTGUI && defined WINDOWSNT
8073 static bool init_imagemagick_functions (void);
8075 #define init_imagemagick_functions NULL
8078 /* Structure describing the image type for any image handled via
8081 static struct image_type imagemagick_type
=
8083 SYMBOL_INDEX (Qimagemagick
),
8084 imagemagick_image_p
,
8086 imagemagick_clear_image
,
8087 init_imagemagick_functions
,
8091 /* Free X resources of imagemagick image IMG which is used on frame F. */
8094 imagemagick_clear_image (struct frame
*f
,
8097 x_clear_image (f
, img
);
8100 /* Return true if OBJECT is a valid IMAGEMAGICK image specification. Do
8101 this by calling parse_image_spec and supplying the keywords that
8102 identify the IMAGEMAGICK format. */
8105 imagemagick_image_p (Lisp_Object object
)
8107 struct image_keyword fmt
[IMAGEMAGICK_LAST
];
8108 memcpy (fmt
, imagemagick_format
, sizeof fmt
);
8110 if (!parse_image_spec (object
, fmt
, IMAGEMAGICK_LAST
, Qimagemagick
))
8113 /* Must specify either the :data or :file keyword. */
8114 return fmt
[IMAGEMAGICK_FILE
].count
+ fmt
[IMAGEMAGICK_DATA
].count
== 1;
8117 /* The GIF library also defines DrawRectangle, but its never used in Emacs.
8118 Therefore rename the function so it doesn't collide with ImageMagick. */
8119 #define DrawRectangle DrawRectangleGif
8120 #include <wand/MagickWand.h>
8122 /* ImageMagick 6.5.3 through 6.6.5 hid PixelGetMagickColor for some reason.
8123 Emacs seems to work fine with the hidden version, so unhide it. */
8124 #include <magick/version.h>
8125 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
8126 extern WandExport
void PixelGetMagickColor (const PixelWand
*,
8127 MagickPixelPacket
*);
8130 /* Log ImageMagick error message.
8131 Useful when a ImageMagick function returns the status `MagickFalse'. */
8134 imagemagick_error (MagickWand
*wand
)
8137 ExceptionType severity
;
8139 description
= MagickGetException (wand
, &severity
);
8140 image_error ("ImageMagick error: %s",
8141 build_string (description
),
8143 MagickRelinquishMemory (description
);
8146 /* Possibly give ImageMagick some extra help to determine the image
8147 type by supplying a "dummy" filename based on the Content-Type. */
8150 imagemagick_filename_hint (Lisp_Object spec
, char hint_buffer
[MaxTextExtent
])
8152 Lisp_Object symbol
= intern ("image-format-suffixes");
8153 Lisp_Object val
= find_symbol_value (symbol
);
8159 format
= image_spec_value (spec
, intern (":format"), NULL
);
8160 val
= Fcar_safe (Fcdr_safe (Fassq (format
, val
)));
8161 if (! STRINGP (val
))
8164 /* It's OK to truncate the hint if it has MaxTextExtent or more bytes,
8165 as ImageMagick would ignore the extra bytes anyway. */
8166 snprintf (hint_buffer
, MaxTextExtent
, "/tmp/foo.%s", SSDATA (val
));
8170 /* Animated images (e.g., GIF89a) are composed from one "master image"
8171 (which is the first one, and then there's a number of images that
8172 follow. If following images have non-transparent colors, these are
8173 composed "on top" of the master image. So, in general, one has to
8174 compute ann the preceding images to be able to display a particular
8177 Computing all the preceding images is too slow, so we maintain a
8178 cache of previously computed images. We have to maintain a cache
8179 separate from the image cache, because the images may be scaled
8182 struct animation_cache
8186 struct timespec update_time
;
8187 struct animation_cache
*next
;
8188 char signature
[FLEXIBLE_ARRAY_MEMBER
];
8191 static struct animation_cache
*animation_cache
= NULL
;
8193 static struct animation_cache
*
8194 imagemagick_create_cache (char *signature
)
8196 struct animation_cache
*cache
8197 = xmalloc (offsetof (struct animation_cache
, signature
)
8198 + strlen (signature
) + 1);
8202 strcpy (cache
->signature
, signature
);
8206 /* Discard cached images that haven't been used for a minute. */
8208 imagemagick_prune_animation_cache (void)
8210 struct animation_cache
**pcache
= &animation_cache
;
8211 struct timespec old
= timespec_sub (current_timespec (),
8212 make_timespec (60, 0));
8216 struct animation_cache
*cache
= *pcache
;
8217 if (timespec_cmp (old
, cache
->update_time
) <= 0)
8218 pcache
= &cache
->next
;
8222 DestroyMagickWand (cache
->wand
);
8223 *pcache
= cache
->next
;
8229 static struct animation_cache
*
8230 imagemagick_get_animation_cache (MagickWand
*wand
)
8232 char *signature
= MagickGetImageSignature (wand
);
8233 struct animation_cache
*cache
;
8234 struct animation_cache
**pcache
= &animation_cache
;
8236 imagemagick_prune_animation_cache ();
8243 *pcache
= cache
= imagemagick_create_cache (signature
);
8246 if (strcmp (signature
, cache
->signature
) == 0)
8248 pcache
= &cache
->next
;
8251 DestroyString (signature
);
8252 cache
->update_time
= current_timespec ();
8257 imagemagick_compute_animated_image (MagickWand
*super_wand
, int ino
)
8260 MagickWand
*composite_wand
;
8261 size_t dest_width
, dest_height
;
8262 struct animation_cache
*cache
= imagemagick_get_animation_cache (super_wand
);
8264 MagickSetIteratorIndex (super_wand
, 0);
8266 if (ino
== 0 || cache
->wand
== NULL
|| cache
->index
> ino
)
8268 composite_wand
= MagickGetImage (super_wand
);
8270 DestroyMagickWand (cache
->wand
);
8273 composite_wand
= cache
->wand
;
8275 dest_height
= MagickGetImageHeight (composite_wand
);
8277 for (i
= max (1, cache
->index
+ 1); i
<= ino
; i
++)
8279 MagickWand
*sub_wand
;
8280 PixelIterator
*source_iterator
, *dest_iterator
;
8281 PixelWand
**source
, **dest
;
8282 size_t source_width
, source_height
;
8283 ssize_t source_left
, source_top
;
8284 MagickPixelPacket pixel
;
8285 DisposeType dispose
;
8286 ptrdiff_t lines
= 0;
8288 MagickSetIteratorIndex (super_wand
, i
);
8289 sub_wand
= MagickGetImage (super_wand
);
8291 MagickGetImagePage (sub_wand
, &source_width
, &source_height
,
8292 &source_left
, &source_top
);
8294 /* This flag says how to handle transparent pixels. */
8295 dispose
= MagickGetImageDispose (sub_wand
);
8297 source_iterator
= NewPixelIterator (sub_wand
);
8298 if (! source_iterator
)
8300 DestroyMagickWand (composite_wand
);
8301 DestroyMagickWand (sub_wand
);
8303 image_error ("Imagemagick pixel iterator creation failed",
8308 dest_iterator
= NewPixelIterator (composite_wand
);
8309 if (! dest_iterator
)
8311 DestroyMagickWand (composite_wand
);
8312 DestroyMagickWand (sub_wand
);
8313 DestroyPixelIterator (source_iterator
);
8315 image_error ("Imagemagick pixel iterator creation failed",
8320 /* The sub-image may not start at origin, so move the destination
8321 iterator to where the sub-image should start. */
8324 PixelSetIteratorRow (dest_iterator
, source_top
);
8328 while ((source
= PixelGetNextIteratorRow (source_iterator
, &source_width
))
8333 /* Sanity check. This shouldn't happen, but apparently
8334 does in some pictures. */
8335 if (++lines
>= dest_height
)
8338 dest
= PixelGetNextIteratorRow (dest_iterator
, &dest_width
);
8339 for (x
= 0; x
< source_width
; x
++)
8341 /* Sanity check. This shouldn't happen, but apparently
8342 also does in some pictures. */
8343 if (x
+ source_left
>= dest_width
)
8345 /* Normally we only copy over non-transparent pixels,
8346 but if the disposal method is "Background", then we
8347 copy over all pixels. */
8348 if (dispose
== BackgroundDispose
|| PixelGetAlpha (source
[x
]))
8350 PixelGetMagickColor (source
[x
], &pixel
);
8351 PixelSetMagickColor (dest
[x
+ source_left
], &pixel
);
8354 PixelSyncIterator (dest_iterator
);
8357 DestroyPixelIterator (source_iterator
);
8358 DestroyPixelIterator (dest_iterator
);
8359 DestroyMagickWand (sub_wand
);
8362 /* Cache a copy for the next iteration. The current wand will be
8363 destroyed by the caller. */
8364 cache
->wand
= CloneMagickWand (composite_wand
);
8367 return composite_wand
;
8371 /* Helper function for imagemagick_load, which does the actual loading
8372 given contents and size, apart from frame and image structures,
8373 passed from imagemagick_load. Uses librimagemagick to do most of
8374 the image processing.
8376 F is a pointer to the Emacs frame; IMG to the image structure to
8377 prepare; CONTENTS is the string containing the IMAGEMAGICK data to
8378 be parsed; SIZE is the number of bytes of data; and FILENAME is
8379 either the file name or the image data.
8381 Return true if successful. */
8384 imagemagick_load_image (struct frame
*f
, struct image
*img
,
8385 unsigned char *contents
, unsigned int size
,
8389 size_t image_width
, image_height
;
8390 MagickBooleanType status
;
8393 MagickWand
*image_wand
;
8394 PixelIterator
*iterator
;
8395 PixelWand
**pixels
, *bg_wand
= NULL
;
8396 MagickPixelPacket pixel
;
8401 int desired_width
, desired_height
;
8404 char hint_buffer
[MaxTextExtent
];
8405 char *filename_hint
= NULL
;
8407 /* Handle image index for image types who can contain more than one image.
8408 Interface :index is same as for GIF. First we "ping" the image to see how
8409 many sub-images it contains. Pinging is faster than loading the image to
8410 find out things about it. */
8412 /* Initialize the imagemagick environment. */
8413 MagickWandGenesis ();
8414 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8415 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8416 image_wand
= NewMagickWand ();
8419 status
= MagickReadImage (image_wand
, filename
);
8422 filename_hint
= imagemagick_filename_hint (img
->spec
, hint_buffer
);
8423 MagickSetFilename (image_wand
, filename_hint
);
8424 status
= MagickReadImageBlob (image_wand
, contents
, size
);
8427 if (status
== MagickFalse
)
8429 imagemagick_error (image_wand
);
8430 DestroyMagickWand (image_wand
);
8434 if (ino
< 0 || ino
>= MagickGetNumberImages (image_wand
))
8436 image_error ("Invalid image number `%s' in image `%s'",
8438 DestroyMagickWand (image_wand
);
8442 if (MagickGetImageDelay (image_wand
) > 0)
8445 Fcons (make_float (MagickGetImageDelay (image_wand
) / 100.0),
8448 if (MagickGetNumberImages (image_wand
) > 1)
8451 Fcons (make_number (MagickGetNumberImages (image_wand
)),
8454 /* If we have an animated image, get the new wand based on the
8456 if (MagickGetNumberImages (image_wand
) > 1)
8458 MagickWand
*super_wand
= image_wand
;
8459 image_wand
= imagemagick_compute_animated_image (super_wand
, ino
);
8461 image_wand
= super_wand
;
8463 DestroyMagickWand (super_wand
);
8466 /* Retrieve the frame's background color, for use later. */
8469 Lisp_Object specified_bg
;
8471 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8472 if (!STRINGP (specified_bg
)
8473 || !x_defined_color (f
, SSDATA (specified_bg
), &bgcolor
, 0))
8474 x_query_frame_background_color (f
, &bgcolor
);
8476 bg_wand
= NewPixelWand ();
8477 PixelSetRed (bg_wand
, (double) bgcolor
.red
/ 65535);
8478 PixelSetGreen (bg_wand
, (double) bgcolor
.green
/ 65535);
8479 PixelSetBlue (bg_wand
, (double) bgcolor
.blue
/ 65535);
8482 compute_image_size (MagickGetImageWidth (image_wand
),
8483 MagickGetImageHeight (image_wand
),
8484 img
->spec
, &desired_width
, &desired_height
);
8486 if (desired_width
!= -1 && desired_height
!= -1)
8488 status
= MagickScaleImage (image_wand
, desired_width
, desired_height
);
8489 if (status
== MagickFalse
)
8491 image_error ("Imagemagick scale failed", Qnil
, Qnil
);
8492 imagemagick_error (image_wand
);
8493 goto imagemagick_error
;
8497 /* crop behaves similar to image slicing in Emacs but is more memory
8499 crop
= image_spec_value (img
->spec
, QCcrop
, NULL
);
8501 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop
)))
8503 /* After some testing, it seems MagickCropImage is the fastest crop
8504 function in ImageMagick. This crop function seems to do less copying
8505 than the alternatives, but it still reads the entire image into memory
8506 before cropping, which is apparently difficult to avoid when using
8508 size_t crop_width
= XINT (XCAR (crop
));
8510 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop
)))
8512 size_t crop_height
= XINT (XCAR (crop
));
8514 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (ssize_t
, XCAR (crop
)))
8516 ssize_t crop_x
= XINT (XCAR (crop
));
8518 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (ssize_t
, XCAR (crop
)))
8520 ssize_t crop_y
= XINT (XCAR (crop
));
8521 MagickCropImage (image_wand
, crop_width
, crop_height
,
8528 /* Furthermore :rotation. we need background color and angle for
8531 TODO background handling for rotation specified_bg =
8532 image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
8534 value
= image_spec_value (img
->spec
, QCrotation
, NULL
);
8537 rotation
= extract_float (value
);
8538 status
= MagickRotateImage (image_wand
, bg_wand
, rotation
);
8539 if (status
== MagickFalse
)
8541 image_error ("Imagemagick image rotate failed", Qnil
, Qnil
);
8542 imagemagick_error (image_wand
);
8543 goto imagemagick_error
;
8547 /* Set the canvas background color to the frame or specified
8548 background, and flatten the image. Note: as of ImageMagick
8549 6.6.0, SVG image transparency is not handled properly
8550 (e.g. etc/images/splash.svg shows a white background always). */
8552 MagickWand
*new_wand
;
8553 MagickSetImageBackgroundColor (image_wand
, bg_wand
);
8554 #ifdef HAVE_MAGICKMERGEIMAGELAYERS
8555 new_wand
= MagickMergeImageLayers (image_wand
, MergeLayer
);
8557 new_wand
= MagickFlattenImages (image_wand
);
8559 DestroyMagickWand (image_wand
);
8560 image_wand
= new_wand
;
8563 /* Finally we are done manipulating the image. Figure out the
8564 resulting width/height and transfer ownership to Emacs. */
8565 image_height
= MagickGetImageHeight (image_wand
);
8566 image_width
= MagickGetImageWidth (image_wand
);
8568 if (! (image_width
<= INT_MAX
&& image_height
<= INT_MAX
8569 && check_image_size (f
, image_width
, image_height
)))
8571 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8572 goto imagemagick_error
;
8575 width
= image_width
;
8576 height
= image_height
;
8578 /* We can now get a valid pixel buffer from the imagemagick file, if all
8581 init_color_table ();
8583 #if defined (HAVE_MAGICKEXPORTIMAGEPIXELS) && ! defined (HAVE_NS)
8584 if (imagemagick_render_type
!= 0)
8586 /* Magicexportimage is normally faster than pixelpushing. This
8587 method is also well tested. Some aspects of this method are
8588 ad-hoc and needs to be more researched. */
8589 int imagedepth
= 24; /*MagickGetImageDepth(image_wand);*/
8590 const char *exportdepth
= imagedepth
<= 8 ? "I" : "BGRP"; /*"RGBP";*/
8591 /* Try to create a x pixmap to hold the imagemagick pixmap. */
8592 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, imagedepth
,
8595 #ifdef COLOR_TABLE_SUPPORT
8596 free_color_table ();
8598 image_error ("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
8599 goto imagemagick_error
;
8602 /* Oddly, the below code doesn't seem to work:*/
8603 /* switch(ximg->bitmap_unit){ */
8605 /* pixelwidth=CharPixel; */
8608 /* pixelwidth=ShortPixel; */
8611 /* pixelwidth=LongPixel; */
8615 Here im just guessing the format of the bitmap.
8616 happens to work fine for:
8619 seems about 3 times as fast as pixel pushing(not carefully measured)
8621 pixelwidth
= CharPixel
; /*??? TODO figure out*/
8622 MagickExportImagePixels (image_wand
, 0, 0, width
, height
,
8623 exportdepth
, pixelwidth
, ximg
->data
);
8626 #endif /* HAVE_MAGICKEXPORTIMAGEPIXELS */
8628 size_t image_height
;
8629 MagickRealType color_scale
= 65535.0 / QuantumRange
;
8631 /* Try to create a x pixmap to hold the imagemagick pixmap. */
8632 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0,
8635 #ifdef COLOR_TABLE_SUPPORT
8636 free_color_table ();
8638 image_error ("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
8639 goto imagemagick_error
;
8642 /* Copy imagemagick image to x with primitive yet robust pixel
8643 pusher loop. This has been tested a lot with many different
8646 /* Copy pixels from the imagemagick image structure to the x image map. */
8647 iterator
= NewPixelIterator (image_wand
);
8650 #ifdef COLOR_TABLE_SUPPORT
8651 free_color_table ();
8653 x_destroy_x_image (ximg
);
8654 image_error ("Imagemagick pixel iterator creation failed",
8656 goto imagemagick_error
;
8659 image_height
= MagickGetImageHeight (image_wand
);
8660 for (y
= 0; y
< image_height
; y
++)
8663 pixels
= PixelGetNextIteratorRow (iterator
, &row_width
);
8666 int xlim
= min (row_width
, width
);
8667 for (x
= 0; x
< xlim
; x
++)
8669 PixelGetMagickColor (pixels
[x
], &pixel
);
8670 XPutPixel (ximg
, x
, y
,
8671 lookup_rgb_color (f
,
8672 color_scale
* pixel
.red
,
8673 color_scale
* pixel
.green
,
8674 color_scale
* pixel
.blue
));
8677 DestroyPixelIterator (iterator
);
8680 #ifdef COLOR_TABLE_SUPPORT
8681 /* Remember colors allocated for this image. */
8682 img
->colors
= colors_in_color_table (&img
->ncolors
);
8683 free_color_table ();
8684 #endif /* COLOR_TABLE_SUPPORT */
8687 img
->height
= height
;
8689 /* Put ximg into the image. */
8690 image_put_x_image (f
, img
, ximg
, 0);
8692 /* Final cleanup. image_wand should be the only resource left. */
8693 DestroyMagickWand (image_wand
);
8694 if (bg_wand
) DestroyPixelWand (bg_wand
);
8696 /* `MagickWandTerminus' terminates the imagemagick environment. */
8697 MagickWandTerminus ();
8702 DestroyMagickWand (image_wand
);
8703 if (bg_wand
) DestroyPixelWand (bg_wand
);
8705 MagickWandTerminus ();
8706 /* TODO more cleanup. */
8707 image_error ("Error parsing IMAGEMAGICK image `%s'", img
->spec
, Qnil
);
8712 /* Load IMAGEMAGICK image IMG for use on frame F. Value is true if
8713 successful. this function will go into the imagemagick_type structure, and
8714 the prototype thus needs to be compatible with that structure. */
8717 imagemagick_load (struct frame
*f
, struct image
*img
)
8720 Lisp_Object file_name
;
8722 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8723 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8724 if (STRINGP (file_name
))
8728 file
= x_find_image_file (file_name
);
8729 if (!STRINGP (file
))
8731 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8735 file
= ansi_encode_filename (file
);
8737 success_p
= imagemagick_load_image (f
, img
, 0, 0, SSDATA (file
));
8739 /* Else its not a file, its a lisp object. Load the image from a
8740 lisp object rather than a file. */
8745 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8746 if (!STRINGP (data
))
8748 image_error ("Invalid image data `%s'", data
, Qnil
);
8751 success_p
= imagemagick_load_image (f
, img
, SDATA (data
),
8752 SBYTES (data
), NULL
);
8758 DEFUN ("imagemagick-types", Fimagemagick_types
, Simagemagick_types
, 0, 0, 0,
8759 doc
: /* Return a list of image types supported by ImageMagick.
8760 Each entry in this list is a symbol named after an ImageMagick format
8761 tag. See the ImageMagick manual for a list of ImageMagick formats and
8762 their descriptions (http://www.imagemagick.org/script/formats.php).
8763 You can also try the shell command: `identify -list format'.
8765 Note that ImageMagick recognizes many file-types that Emacs does not
8766 recognize as images, such as C. See `imagemagick-types-enable'
8767 and `imagemagick-types-inhibit'. */)
8770 Lisp_Object typelist
= Qnil
;
8776 GetExceptionInfo(&ex
);
8777 imtypes
= GetMagickList ("*", &numf
, &ex
);
8778 DestroyExceptionInfo(&ex
);
8780 for (i
= 0; i
< numf
; i
++)
8782 Lisp_Object imagemagicktype
= intern (imtypes
[i
]);
8783 typelist
= Fcons (imagemagicktype
, typelist
);
8784 imtypes
[i
] = MagickRelinquishMemory (imtypes
[i
]);
8787 MagickRelinquishMemory (imtypes
);
8788 return Fnreverse (typelist
);
8791 #endif /* defined (HAVE_IMAGEMAGICK) */
8795 /***********************************************************************
8797 ***********************************************************************/
8801 /* Function prototypes. */
8803 static bool svg_image_p (Lisp_Object object
);
8804 static bool svg_load (struct frame
*f
, struct image
*img
);
8806 static bool svg_load_image (struct frame
*, struct image
*,
8807 unsigned char *, ptrdiff_t, char *);
8809 /* Indices of image specification fields in svg_format, below. */
8811 enum svg_keyword_index
8826 /* Vector of image_keyword structures describing the format
8827 of valid user-defined image specifications. */
8829 static const struct image_keyword svg_format
[SVG_LAST
] =
8831 {":type", IMAGE_SYMBOL_VALUE
, 1},
8832 {":data", IMAGE_STRING_VALUE
, 0},
8833 {":file", IMAGE_STRING_VALUE
, 0},
8834 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8835 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
8836 {":relief", IMAGE_INTEGER_VALUE
, 0},
8837 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8838 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8839 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8840 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8843 # if defined HAVE_NTGUI && defined WINDOWSNT
8844 static bool init_svg_functions (void);
8846 #define init_svg_functions NULL
8849 /* Structure describing the image type `svg'. Its the same type of
8850 structure defined for all image formats, handled by emacs image
8851 functions. See struct image_type in dispextern.h. */
8853 static struct image_type svg_type
=
8855 SYMBOL_INDEX (Qsvg
),
8864 /* Return true if OBJECT is a valid SVG image specification. Do
8865 this by calling parse_image_spec and supplying the keywords that
8866 identify the SVG format. */
8869 svg_image_p (Lisp_Object object
)
8871 struct image_keyword fmt
[SVG_LAST
];
8872 memcpy (fmt
, svg_format
, sizeof fmt
);
8874 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
8877 /* Must specify either the :data or :file keyword. */
8878 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
8881 # include <librsvg/rsvg.h>
8885 /* SVG library functions. */
8886 DEF_DLL_FN (RsvgHandle
*, rsvg_handle_new
, (void));
8887 DEF_DLL_FN (void, rsvg_handle_get_dimensions
,
8888 (RsvgHandle
*, RsvgDimensionData
*));
8889 DEF_DLL_FN (gboolean
, rsvg_handle_write
,
8890 (RsvgHandle
*, const guchar
*, gsize
, GError
**));
8891 DEF_DLL_FN (gboolean
, rsvg_handle_close
, (RsvgHandle
*, GError
**));
8892 DEF_DLL_FN (GdkPixbuf
*, rsvg_handle_get_pixbuf
, (RsvgHandle
*));
8893 DEF_DLL_FN (void, rsvg_handle_set_base_uri
, (RsvgHandle
*, const char *));
8895 DEF_DLL_FN (int, gdk_pixbuf_get_width
, (const GdkPixbuf
*));
8896 DEF_DLL_FN (int, gdk_pixbuf_get_height
, (const GdkPixbuf
*));
8897 DEF_DLL_FN (guchar
*, gdk_pixbuf_get_pixels
, (const GdkPixbuf
*));
8898 DEF_DLL_FN (int, gdk_pixbuf_get_rowstride
, (const GdkPixbuf
*));
8899 DEF_DLL_FN (GdkColorspace
, gdk_pixbuf_get_colorspace
, (const GdkPixbuf
*));
8900 DEF_DLL_FN (int, gdk_pixbuf_get_n_channels
, (const GdkPixbuf
*));
8901 DEF_DLL_FN (gboolean
, gdk_pixbuf_get_has_alpha
, (const GdkPixbuf
*));
8902 DEF_DLL_FN (int, gdk_pixbuf_get_bits_per_sample
, (const GdkPixbuf
*));
8904 # if ! GLIB_CHECK_VERSION (2, 36, 0)
8905 DEF_DLL_FN (void, g_type_init
, (void));
8907 DEF_DLL_FN (void, g_object_unref
, (gpointer
));
8908 DEF_DLL_FN (void, g_error_free
, (GError
*));
8911 init_svg_functions (void)
8913 HMODULE library
, gdklib
= NULL
, glib
= NULL
, gobject
= NULL
;
8915 if (!(glib
= w32_delayed_load (Qglib
))
8916 || !(gobject
= w32_delayed_load (Qgobject
))
8917 || !(gdklib
= w32_delayed_load (Qgdk_pixbuf
))
8918 || !(library
= w32_delayed_load (Qsvg
)))
8920 if (gdklib
) FreeLibrary (gdklib
);
8921 if (gobject
) FreeLibrary (gobject
);
8922 if (glib
) FreeLibrary (glib
);
8926 LOAD_DLL_FN (library
, rsvg_handle_new
);
8927 LOAD_DLL_FN (library
, rsvg_handle_get_dimensions
);
8928 LOAD_DLL_FN (library
, rsvg_handle_write
);
8929 LOAD_DLL_FN (library
, rsvg_handle_close
);
8930 LOAD_DLL_FN (library
, rsvg_handle_get_pixbuf
);
8931 LOAD_DLL_FN (library
, rsvg_handle_set_base_uri
);
8933 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_width
);
8934 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_height
);
8935 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_pixels
);
8936 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8937 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8938 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8939 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8940 LOAD_DLL_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8942 # if ! GLIB_CHECK_VERSION (2, 36, 0)
8943 LOAD_DLL_FN (gobject
, g_type_init
);
8945 LOAD_DLL_FN (gobject
, g_object_unref
);
8946 LOAD_DLL_FN (glib
, g_error_free
);
8951 /* The following aliases for library functions allow dynamic loading
8952 to be used on some platforms. */
8954 # undef gdk_pixbuf_get_bits_per_sample
8955 # undef gdk_pixbuf_get_colorspace
8956 # undef gdk_pixbuf_get_has_alpha
8957 # undef gdk_pixbuf_get_height
8958 # undef gdk_pixbuf_get_n_channels
8959 # undef gdk_pixbuf_get_pixels
8960 # undef gdk_pixbuf_get_rowstride
8961 # undef gdk_pixbuf_get_width
8962 # undef g_error_free
8963 # undef g_object_unref
8965 # undef rsvg_handle_close
8966 # undef rsvg_handle_get_dimensions
8967 # undef rsvg_handle_get_pixbuf
8968 # undef rsvg_handle_new
8969 # undef rsvg_handle_set_base_uri
8970 # undef rsvg_handle_write
8972 # define gdk_pixbuf_get_bits_per_sample fn_gdk_pixbuf_get_bits_per_sample
8973 # define gdk_pixbuf_get_colorspace fn_gdk_pixbuf_get_colorspace
8974 # define gdk_pixbuf_get_has_alpha fn_gdk_pixbuf_get_has_alpha
8975 # define gdk_pixbuf_get_height fn_gdk_pixbuf_get_height
8976 # define gdk_pixbuf_get_n_channels fn_gdk_pixbuf_get_n_channels
8977 # define gdk_pixbuf_get_pixels fn_gdk_pixbuf_get_pixels
8978 # define gdk_pixbuf_get_rowstride fn_gdk_pixbuf_get_rowstride
8979 # define gdk_pixbuf_get_width fn_gdk_pixbuf_get_width
8980 # define g_error_free fn_g_error_free
8981 # define g_object_unref fn_g_object_unref
8982 # define g_type_init fn_g_type_init
8983 # define rsvg_handle_close fn_rsvg_handle_close
8984 # define rsvg_handle_get_dimensions fn_rsvg_handle_get_dimensions
8985 # define rsvg_handle_get_pixbuf fn_rsvg_handle_get_pixbuf
8986 # define rsvg_handle_new fn_rsvg_handle_new
8987 # define rsvg_handle_set_base_uri fn_rsvg_handle_set_base_uri
8988 # define rsvg_handle_write fn_rsvg_handle_write
8990 # endif /* !WINDOWSNT */
8992 /* Load SVG image IMG for use on frame F. Value is true if
8996 svg_load (struct frame
*f
, struct image
*img
)
8999 Lisp_Object file_name
;
9001 /* If IMG->spec specifies a file name, create a non-file spec from it. */
9002 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
9003 if (STRINGP (file_name
))
9006 unsigned char *contents
;
9009 file
= x_find_image_file (file_name
);
9010 if (!STRINGP (file
))
9012 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
9016 /* Read the entire file into memory. */
9017 contents
= slurp_file (SSDATA (file
), &size
);
9018 if (contents
== NULL
)
9020 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
9023 /* If the file was slurped into memory properly, parse it. */
9024 success_p
= svg_load_image (f
, img
, contents
, size
, SSDATA (file
));
9027 /* Else its not a file, its a lisp object. Load the image from a
9028 lisp object rather than a file. */
9031 Lisp_Object data
, original_filename
;
9033 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
9034 if (!STRINGP (data
))
9036 image_error ("Invalid image data `%s'", data
, Qnil
);
9039 original_filename
= BVAR (current_buffer
, filename
);
9040 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
),
9041 (NILP (original_filename
) ? NULL
9042 : SSDATA (original_filename
)));
9048 /* svg_load_image is a helper function for svg_load, which does the
9049 actual loading given contents and size, apart from frame and image
9050 structures, passed from svg_load.
9052 Uses librsvg to do most of the image processing.
9054 Returns true when successful. */
9056 svg_load_image (struct frame
*f
, /* Pointer to emacs frame structure. */
9057 struct image
*img
, /* Pointer to emacs image structure. */
9058 unsigned char *contents
, /* String containing the SVG XML data to be parsed. */
9059 ptrdiff_t size
, /* Size of data in bytes. */
9060 char *filename
) /* Name of SVG file being loaded. */
9062 RsvgHandle
*rsvg_handle
;
9063 RsvgDimensionData dimension_data
;
9068 const guint8
*pixels
;
9071 Lisp_Object specified_bg
;
9076 #if ! GLIB_CHECK_VERSION (2, 36, 0)
9077 /* g_type_init is a glib function that must be called prior to
9078 using gnome type library functions (obsolete since 2.36.0). */
9082 /* Make a handle to a new rsvg object. */
9083 rsvg_handle
= rsvg_handle_new ();
9085 /* Set base_uri for properly handling referenced images (via 'href').
9086 See rsvg bug 596114 - "image refs are relative to curdir, not .svg file"
9087 (https://bugzilla.gnome.org/show_bug.cgi?id=596114). */
9089 rsvg_handle_set_base_uri(rsvg_handle
, filename
);
9091 /* Parse the contents argument and fill in the rsvg_handle. */
9092 rsvg_handle_write (rsvg_handle
, contents
, size
, &err
);
9093 if (err
) goto rsvg_error
;
9095 /* The parsing is complete, rsvg_handle is ready to used, close it
9096 for further writes. */
9097 rsvg_handle_close (rsvg_handle
, &err
);
9098 if (err
) goto rsvg_error
;
9100 rsvg_handle_get_dimensions (rsvg_handle
, &dimension_data
);
9101 if (! check_image_size (f
, dimension_data
.width
, dimension_data
.height
))
9103 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
9107 /* We can now get a valid pixel buffer from the svg file, if all
9109 pixbuf
= rsvg_handle_get_pixbuf (rsvg_handle
);
9110 if (!pixbuf
) goto rsvg_error
;
9111 g_object_unref (rsvg_handle
);
9113 /* Extract some meta data from the svg handle. */
9114 width
= gdk_pixbuf_get_width (pixbuf
);
9115 height
= gdk_pixbuf_get_height (pixbuf
);
9116 pixels
= gdk_pixbuf_get_pixels (pixbuf
);
9117 rowstride
= gdk_pixbuf_get_rowstride (pixbuf
);
9119 /* Validate the svg meta data. */
9120 eassert (gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
9121 eassert (gdk_pixbuf_get_n_channels (pixbuf
) == 4);
9122 eassert (gdk_pixbuf_get_has_alpha (pixbuf
));
9123 eassert (gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
9127 unsigned char *data
= (unsigned char *) xmalloc (width
*height
*4);
9129 uint32_t bgcolor
= get_spec_bg_or_alpha_as_argb (img
, f
);
9131 for (y
= 0; y
< height
; ++y
)
9133 const guchar
*iconptr
= pixels
+ y
* rowstride
;
9134 uint32_t *dataptr
= (uint32_t *) (data
+ y
* rowstride
);
9137 for (x
= 0; x
< width
; ++x
)
9139 if (iconptr
[3] == 0)
9142 *dataptr
= (iconptr
[0] << 16)
9145 | (iconptr
[3] << 24);
9152 create_cairo_image_surface (img
, data
, width
, height
);
9153 g_object_unref (pixbuf
);
9156 /* Try to create a x pixmap to hold the svg pixmap. */
9157 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
9159 g_object_unref (pixbuf
);
9163 init_color_table ();
9165 /* Handle alpha channel by combining the image with a background
9167 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
9168 if (!STRINGP (specified_bg
)
9169 || !x_defined_color (f
, SSDATA (specified_bg
), &background
, 0))
9170 x_query_frame_background_color (f
, &background
);
9172 /* SVG pixmaps specify transparency in the last byte, so right
9173 shift 8 bits to get rid of it, since emacs doesn't support
9175 background
.red
>>= 8;
9176 background
.green
>>= 8;
9177 background
.blue
>>= 8;
9179 /* This loop handles opacity values, since Emacs assumes
9180 non-transparent images. Each pixel must be "flattened" by
9181 calculating the resulting color, given the transparency of the
9182 pixel, and the image background color. */
9183 for (y
= 0; y
< height
; ++y
)
9185 for (x
= 0; x
< width
; ++x
)
9195 opacity
= *pixels
++;
9197 red
= ((red
* opacity
)
9198 + (background
.red
* ((1 << 8) - opacity
)));
9199 green
= ((green
* opacity
)
9200 + (background
.green
* ((1 << 8) - opacity
)));
9201 blue
= ((blue
* opacity
)
9202 + (background
.blue
* ((1 << 8) - opacity
)));
9204 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
9207 pixels
+= rowstride
- 4 * width
;
9210 #ifdef COLOR_TABLE_SUPPORT
9211 /* Remember colors allocated for this image. */
9212 img
->colors
= colors_in_color_table (&img
->ncolors
);
9213 free_color_table ();
9214 #endif /* COLOR_TABLE_SUPPORT */
9216 g_object_unref (pixbuf
);
9219 img
->height
= height
;
9221 /* Maybe fill in the background field while we have ximg handy.
9222 Casting avoids a GCC warning. */
9223 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
9225 /* Put ximg into the image. */
9226 image_put_x_image (f
, img
, ximg
, 0);
9227 #endif /* ! USE_CAIRO */
9232 g_object_unref (rsvg_handle
);
9233 /* FIXME: Use error->message so the user knows what is the actual
9234 problem with the image. */
9235 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
9240 #endif /* defined (HAVE_RSVG) */
9245 /***********************************************************************
9247 ***********************************************************************/
9249 #ifdef HAVE_X_WINDOWS
9250 #define HAVE_GHOSTSCRIPT 1
9251 #endif /* HAVE_X_WINDOWS */
9253 #ifdef HAVE_GHOSTSCRIPT
9255 static bool gs_image_p (Lisp_Object object
);
9256 static bool gs_load (struct frame
*f
, struct image
*img
);
9257 static void gs_clear_image (struct frame
*f
, struct image
*img
);
9259 /* Indices of image specification fields in gs_format, below. */
9261 enum gs_keyword_index
9279 /* Vector of image_keyword structures describing the format
9280 of valid user-defined image specifications. */
9282 static const struct image_keyword gs_format
[GS_LAST
] =
9284 {":type", IMAGE_SYMBOL_VALUE
, 1},
9285 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9286 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9287 {":file", IMAGE_STRING_VALUE
, 1},
9288 {":loader", IMAGE_FUNCTION_VALUE
, 0},
9289 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
9290 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9291 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
9292 {":relief", IMAGE_INTEGER_VALUE
, 0},
9293 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9294 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9295 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9296 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9299 /* Structure describing the image type `ghostscript'. */
9301 static struct image_type gs_type
=
9303 SYMBOL_INDEX (Qpostscript
),
9312 /* Free X resources of Ghostscript image IMG which is used on frame F. */
9315 gs_clear_image (struct frame
*f
, struct image
*img
)
9317 x_clear_image (f
, img
);
9321 /* Return true if OBJECT is a valid Ghostscript image
9325 gs_image_p (Lisp_Object object
)
9327 struct image_keyword fmt
[GS_LAST
];
9331 memcpy (fmt
, gs_format
, sizeof fmt
);
9333 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
9336 /* Bounding box must be a list or vector containing 4 integers. */
9337 tem
= fmt
[GS_BOUNDING_BOX
].value
;
9340 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
9341 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
9346 else if (VECTORP (tem
))
9348 if (ASIZE (tem
) != 4)
9350 for (i
= 0; i
< 4; ++i
)
9351 if (!INTEGERP (AREF (tem
, i
)))
9361 /* Load Ghostscript image IMG for use on frame F. Value is true
9365 gs_load (struct frame
*f
, struct image
*img
)
9367 uprintmax_t printnum1
, printnum2
;
9368 char buffer
[sizeof " " + INT_STRLEN_BOUND (printmax_t
)];
9369 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
9371 double in_width
, in_height
;
9372 Lisp_Object pixel_colors
= Qnil
;
9374 /* Compute pixel size of pixmap needed from the given size in the
9375 image specification. Sizes in the specification are in pt. 1 pt
9376 = 1/72 in, xdpi and ydpi are stored in the frame's X display
9378 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
9379 in_width
= INTEGERP (pt_width
) ? XFASTINT (pt_width
) / 72.0 : 0;
9380 in_width
*= FRAME_RES_X (f
);
9381 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
9382 in_height
= INTEGERP (pt_height
) ? XFASTINT (pt_height
) / 72.0 : 0;
9383 in_height
*= FRAME_RES_Y (f
);
9385 if (! (in_width
<= INT_MAX
&& in_height
<= INT_MAX
9386 && check_image_size (f
, in_width
, in_height
)))
9388 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
9391 img
->width
= in_width
;
9392 img
->height
= in_height
;
9394 /* Create the pixmap. */
9395 eassert (img
->pixmap
== NO_PIXMAP
);
9397 if (x_check_image_size (0, img
->width
, img
->height
))
9399 /* Only W32 version did BLOCK_INPUT here. ++kfs */
9401 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9402 img
->width
, img
->height
,
9403 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
9409 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
9413 /* Call the loader to fill the pixmap. It returns a process object
9414 if successful. We do not record_unwind_protect here because
9415 other places in redisplay like calling window scroll functions
9416 don't either. Let the Lisp loader use `unwind-protect' instead. */
9417 printnum1
= FRAME_X_WINDOW (f
);
9418 printnum2
= img
->pixmap
;
9419 window_and_pixmap_id
9420 = make_formatted_string (buffer
, "%"pMu
" %"pMu
, printnum1
, printnum2
);
9422 printnum1
= FRAME_FOREGROUND_PIXEL (f
);
9423 printnum2
= FRAME_BACKGROUND_PIXEL (f
);
9425 = make_formatted_string (buffer
, "%"pMu
" %"pMu
, printnum1
, printnum2
);
9427 XSETFRAME (frame
, f
);
9428 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
9430 loader
= intern ("gs-load-image");
9432 img
->lisp_data
= call6 (loader
, frame
, img
->spec
,
9433 make_number (img
->width
),
9434 make_number (img
->height
),
9435 window_and_pixmap_id
,
9437 return PROCESSP (img
->lisp_data
);
9441 /* Kill the Ghostscript process that was started to fill PIXMAP on
9442 frame F. Called from XTread_socket when receiving an event
9443 telling Emacs that Ghostscript has finished drawing. */
9446 x_kill_gs_process (Pixmap pixmap
, struct frame
*f
)
9448 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
9453 /* Find the image containing PIXMAP. */
9454 for (i
= 0; i
< c
->used
; ++i
)
9455 if (c
->images
[i
]->pixmap
== pixmap
)
9458 /* Should someone in between have cleared the image cache, for
9459 instance, give up. */
9463 /* Kill the GS process. We should have found PIXMAP in the image
9464 cache and its image should contain a process object. */
9466 eassert (PROCESSP (img
->lisp_data
));
9467 Fkill_process (img
->lisp_data
, Qnil
);
9468 img
->lisp_data
= Qnil
;
9470 #if defined (HAVE_X_WINDOWS)
9472 /* On displays with a mutable colormap, figure out the colors
9473 allocated for the image by looking at the pixels of an XImage for
9475 class = FRAME_X_VISUAL (f
)->class;
9476 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
9482 /* Try to get an XImage for img->pixmep. */
9483 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
9484 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
9489 /* Initialize the color table. */
9490 init_color_table ();
9492 /* For each pixel of the image, look its color up in the
9493 color table. After having done so, the color table will
9494 contain an entry for each color used by the image. */
9495 #ifdef COLOR_TABLE_SUPPORT
9496 for (y
= 0; y
< img
->height
; ++y
)
9497 for (x
= 0; x
< img
->width
; ++x
)
9499 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
9501 lookup_pixel_color (f
, pixel
);
9504 /* Record colors in the image. Free color table and XImage. */
9505 img
->colors
= colors_in_color_table (&img
->ncolors
);
9506 free_color_table ();
9508 XDestroyImage (ximg
);
9510 #if 0 /* This doesn't seem to be the case. If we free the colors
9511 here, we get a BadAccess later in x_clear_image when
9512 freeing the colors. */
9513 /* We have allocated colors once, but Ghostscript has also
9514 allocated colors on behalf of us. So, to get the
9515 reference counts right, free them once. */
9517 x_free_colors (f
, img
->colors
, img
->ncolors
);
9521 image_error ("Cannot get X image of `%s'; colors will not be freed",
9526 #endif /* HAVE_X_WINDOWS */
9528 /* Now that we have the pixmap, compute mask and transform the
9529 image if requested. */
9531 postprocess_image (f
, img
);
9535 #endif /* HAVE_GHOSTSCRIPT */
9538 /***********************************************************************
9540 ***********************************************************************/
9544 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
9545 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
9548 return valid_image_p (spec
) ? Qt
: Qnil
;
9552 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0,
9558 if (valid_image_p (spec
))
9559 id
= lookup_image (SELECTED_FRAME (), spec
);
9562 return make_number (id
);
9565 #endif /* GLYPH_DEBUG */
9568 /***********************************************************************
9570 ***********************************************************************/
9572 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 1, 1, 0,
9573 doc
: /* Initialize image library implementing image type TYPE.
9574 Return non-nil if TYPE is a supported image type.
9576 If image libraries are loaded dynamically (currently only the case on
9577 MS-Windows), load the library for TYPE if it is not yet loaded, using
9578 the library file(s) specified by `dynamic-library-alist'. */)
9581 return lookup_image_type (type
) ? Qt
: Qnil
;
9584 /* Look up image type TYPE, and return a pointer to its image_type
9585 structure. Return 0 if TYPE is not a known image type. */
9587 static struct image_type
*
9588 lookup_image_type (Lisp_Object type
)
9590 /* Types pbm and xbm are built-in and always available. */
9591 if (EQ (type
, Qpbm
))
9592 return define_image_type (&pbm_type
);
9594 if (EQ (type
, Qxbm
))
9595 return define_image_type (&xbm_type
);
9597 #if defined (HAVE_XPM) || defined (HAVE_NS)
9598 if (EQ (type
, Qxpm
))
9599 return define_image_type (&xpm_type
);
9602 #if defined (HAVE_JPEG) || defined (HAVE_NS)
9603 if (EQ (type
, Qjpeg
))
9604 return define_image_type (&jpeg_type
);
9607 #if defined (HAVE_TIFF) || defined (HAVE_NS)
9608 if (EQ (type
, Qtiff
))
9609 return define_image_type (&tiff_type
);
9612 #if defined (HAVE_GIF) || defined (HAVE_NS)
9613 if (EQ (type
, Qgif
))
9614 return define_image_type (&gif_type
);
9617 #if defined (HAVE_PNG) || defined (HAVE_NS) || defined (USE_CAIRO)
9618 if (EQ (type
, Qpng
))
9619 return define_image_type (&png_type
);
9622 #if defined (HAVE_RSVG)
9623 if (EQ (type
, Qsvg
))
9624 return define_image_type (&svg_type
);
9627 #if defined (HAVE_IMAGEMAGICK)
9628 if (EQ (type
, Qimagemagick
))
9629 return define_image_type (&imagemagick_type
);
9632 #ifdef HAVE_GHOSTSCRIPT
9633 if (EQ (type
, Qpostscript
))
9634 return define_image_type (&gs_type
);
9640 /* Reset image_types before dumping.
9641 Called from Fdump_emacs. */
9644 reset_image_types (void)
9648 struct image_type
*next
= image_types
->next
;
9649 xfree (image_types
);
9655 syms_of_image (void)
9657 /* Initialize this only once; it will be reset before dumping. */
9660 /* Must be defined now because we're going to update it below, while
9661 defining the supported image types. */
9662 DEFVAR_LISP ("image-types", Vimage_types
,
9663 doc
: /* List of potentially supported image types.
9664 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
9665 To check whether it is really supported, use `image-type-available-p'. */);
9666 Vimage_types
= Qnil
;
9668 DEFVAR_LISP ("max-image-size", Vmax_image_size
,
9669 doc
: /* Maximum size of images.
9670 Emacs will not load an image into memory if its pixel width or
9671 pixel height exceeds this limit.
9673 If the value is an integer, it directly specifies the maximum
9674 image height and width, measured in pixels. If it is a floating
9675 point number, it specifies the maximum image height and width
9676 as a ratio to the frame height and width. If the value is
9677 non-numeric, there is no explicit limit on the size of images. */);
9678 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
9680 /* Other symbols. */
9681 DEFSYM (Qcount
, "count");
9682 DEFSYM (Qextension_data
, "extension-data");
9683 DEFSYM (Qdelay
, "delay");
9686 DEFSYM (QCascent
, ":ascent");
9687 DEFSYM (QCmargin
, ":margin");
9688 DEFSYM (QCrelief
, ":relief");
9689 DEFSYM (QCconversion
, ":conversion");
9690 DEFSYM (QCcolor_symbols
, ":color-symbols");
9691 DEFSYM (QCheuristic_mask
, ":heuristic-mask");
9692 DEFSYM (QCindex
, ":index");
9693 DEFSYM (QCgeometry
, ":geometry");
9694 DEFSYM (QCcrop
, ":crop");
9695 DEFSYM (QCrotation
, ":rotation");
9696 DEFSYM (QCmatrix
, ":matrix");
9697 DEFSYM (QCcolor_adjustment
, ":color-adjustment");
9698 DEFSYM (QCmask
, ":mask");
9700 /* Other symbols. */
9701 DEFSYM (Qlaplace
, "laplace");
9702 DEFSYM (Qemboss
, "emboss");
9703 DEFSYM (Qedge_detection
, "edge-detection");
9704 DEFSYM (Qheuristic
, "heuristic");
9706 DEFSYM (Qpostscript
, "postscript");
9707 DEFSYM (QCmax_width
, ":max-width");
9708 DEFSYM (QCmax_height
, ":max-height");
9709 #ifdef HAVE_GHOSTSCRIPT
9710 ADD_IMAGE_TYPE (Qpostscript
);
9711 DEFSYM (QCloader
, ":loader");
9712 DEFSYM (QCbounding_box
, ":bounding-box");
9713 DEFSYM (QCpt_width
, ":pt-width");
9714 DEFSYM (QCpt_height
, ":pt-height");
9715 #endif /* HAVE_GHOSTSCRIPT */
9718 /* Versions of libpng, libgif, and libjpeg that we were compiled with,
9719 or -1 if no PNG/GIF support was compiled in. This is tested by
9720 w32-win.el to correctly set up the alist used to search for the
9721 respective image libraries. */
9722 DEFSYM (Qlibpng_version
, "libpng-version");
9723 Fset (Qlibpng_version
,
9725 make_number (PNG_LIBPNG_VER
)
9730 DEFSYM (Qlibgif_version
, "libgif-version");
9731 Fset (Qlibgif_version
,
9733 make_number (GIFLIB_MAJOR
* 10000
9734 + GIFLIB_MINOR
* 100
9740 DEFSYM (Qlibjpeg_version
, "libjpeg-version");
9741 Fset (Qlibjpeg_version
,
9743 make_number (JPEG_LIB_VERSION
)
9750 DEFSYM (Qpbm
, "pbm");
9751 ADD_IMAGE_TYPE (Qpbm
);
9753 DEFSYM (Qxbm
, "xbm");
9754 ADD_IMAGE_TYPE (Qxbm
);
9756 #if defined (HAVE_XPM) || defined (HAVE_NS)
9757 DEFSYM (Qxpm
, "xpm");
9758 ADD_IMAGE_TYPE (Qxpm
);
9761 #if defined (HAVE_JPEG) || defined (HAVE_NS)
9762 DEFSYM (Qjpeg
, "jpeg");
9763 ADD_IMAGE_TYPE (Qjpeg
);
9766 #if defined (HAVE_TIFF) || defined (HAVE_NS)
9767 DEFSYM (Qtiff
, "tiff");
9768 ADD_IMAGE_TYPE (Qtiff
);
9771 #if defined (HAVE_GIF) || defined (HAVE_NS)
9772 DEFSYM (Qgif
, "gif");
9773 ADD_IMAGE_TYPE (Qgif
);
9776 #if defined (HAVE_PNG) || defined (HAVE_NS)
9777 DEFSYM (Qpng
, "png");
9778 ADD_IMAGE_TYPE (Qpng
);
9781 #if defined (HAVE_IMAGEMAGICK)
9782 DEFSYM (Qimagemagick
, "imagemagick");
9783 ADD_IMAGE_TYPE (Qimagemagick
);
9786 #if defined (HAVE_RSVG)
9787 DEFSYM (Qsvg
, "svg");
9788 ADD_IMAGE_TYPE (Qsvg
);
9790 /* Other libraries used directly by svg code. */
9791 DEFSYM (Qgdk_pixbuf
, "gdk-pixbuf");
9792 DEFSYM (Qglib
, "glib");
9793 DEFSYM (Qgobject
, "gobject");
9794 #endif /* HAVE_NTGUI */
9795 #endif /* HAVE_RSVG */
9797 defsubr (&Sinit_image_library
);
9798 #ifdef HAVE_IMAGEMAGICK
9799 defsubr (&Simagemagick_types
);
9801 defsubr (&Sclear_image_cache
);
9802 defsubr (&Simage_flush
);
9803 defsubr (&Simage_size
);
9804 defsubr (&Simage_mask_p
);
9805 defsubr (&Simage_metadata
);
9809 defsubr (&Slookup_image
);
9812 DEFVAR_BOOL ("cross-disabled-images", cross_disabled_images
,
9813 doc
: /* Non-nil means always draw a cross over disabled images.
9814 Disabled images are those having a `:conversion disabled' property.
9815 A cross is always drawn on black & white displays. */);
9816 cross_disabled_images
= 0;
9818 DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path
,
9819 doc
: /* List of directories to search for window system bitmap files. */);
9820 Vx_bitmap_file_path
= decode_env_path (0, PATH_BITMAPS
, 0);
9822 DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay
,
9823 doc
: /* Maximum time after which images are removed from the cache.
9824 When an image has not been displayed this many seconds, Emacs
9825 automatically removes it from the image cache. If the cache contains
9826 a large number of images, the actual eviction time may be shorter.
9827 The value can also be nil, meaning the cache is never cleared.
9829 The function `clear-image-cache' disregards this variable. */);
9830 Vimage_cache_eviction_delay
= make_number (300);
9831 #ifdef HAVE_IMAGEMAGICK
9832 DEFVAR_INT ("imagemagick-render-type", imagemagick_render_type
,
9833 doc
: /* Integer indicating which ImageMagick rendering method to use.
9835 0 -- the default method (pixel pushing)
9836 1 -- a newer method ("MagickExportImagePixels") that may perform
9837 better (speed etc) in some cases, but has not been as thoroughly
9838 tested with Emacs as the default method. This method requires
9839 ImageMagick version 6.4.6 (approximately) or later.
9841 /* MagickExportImagePixels is in 6.4.6-9, but not 6.4.4-10. */
9842 imagemagick_render_type
= 0;