1 /* Functions for image support on window system.
3 Copyright (C) 1989, 1992-2014 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
36 #include "dispextern.h"
37 #include "blockinput.h"
40 #include "character.h"
42 #include "termhooks.h"
45 #ifdef HAVE_SYS_STAT_H
47 #endif /* HAVE_SYS_STAT_H */
49 #ifdef HAVE_SYS_TYPES_H
50 #include <sys/types.h>
51 #endif /* HAVE_SYS_TYPES_H */
53 #ifdef HAVE_WINDOW_SYSTEM
55 #endif /* HAVE_WINDOW_SYSTEM */
58 #define COLOR_TABLE_SUPPORT 1
60 typedef struct x_bitmap_record Bitmap_Record
;
61 #define GET_PIXEL(ximg, x, y) XGetPixel (ximg, x, y)
62 #define NO_PIXMAP None
64 #define PIX_MASK_RETAIN 0
65 #define PIX_MASK_DRAW 1
66 #endif /* HAVE_X_WINDOWS */
70 /* We need (or want) w32.h only when we're _not_ compiling for Cygwin. */
75 /* W32_TODO : Color tables on W32. */
76 #undef COLOR_TABLE_SUPPORT
78 typedef struct w32_bitmap_record Bitmap_Record
;
79 #define GET_PIXEL(ximg, x, y) GetPixel (ximg, x, y)
82 #define PIX_MASK_RETAIN 0
83 #define PIX_MASK_DRAW 1
85 #define x_defined_color w32_defined_color
86 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
88 /* Versions of libpng, libgif, and libjpeg that we were compiled with,
89 or -1 if no PNG/GIF support was compiled in. This is tested by
90 w32-win.el to correctly set up the alist used to search for the
91 respective image libraries. */
92 Lisp_Object Qlibpng_version
, Qlibgif_version
, Qlibjpeg_version
;
94 #endif /* HAVE_NTGUI */
97 #undef COLOR_TABLE_SUPPORT
99 typedef struct ns_bitmap_record Bitmap_Record
;
101 #define GET_PIXEL(ximg, x, y) XGetPixel (ximg, x, y)
104 #define PIX_MASK_RETAIN 0
105 #define PIX_MASK_DRAW 1
107 #define x_defined_color(f, name, color_def, alloc) \
108 ns_defined_color (f, name, color_def, alloc, 0)
109 #define DefaultDepthOfScreen(screen) x_display_list->n_planes
113 /* The symbol `postscript' identifying images of this type. */
115 static Lisp_Object Qpostscript
;
117 static void x_disable_image (struct frame
*, struct image
*);
118 static void x_edge_detection (struct frame
*, struct image
*, Lisp_Object
,
121 static void init_color_table (void);
122 static unsigned long lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
);
123 #ifdef COLOR_TABLE_SUPPORT
124 static void free_color_table (void);
125 static unsigned long *colors_in_color_table (int *n
);
128 static Lisp_Object QCmax_width
, QCmax_height
;
130 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
131 id, which is just an int that this section returns. Bitmaps are
132 reference counted so they can be shared among frames.
134 Bitmap indices are guaranteed to be > 0, so a negative number can
135 be used to indicate no bitmap.
137 If you use x_create_bitmap_from_data, then you must keep track of
138 the bitmaps yourself. That is, creating a bitmap from the same
139 data more than once will not be caught. */
142 /* Use with images created by ns_image_for_XPM. */
144 XGetPixel (XImagePtr ximage
, int x
, int y
)
146 return ns_get_pixel (ximage
, x
, y
);
149 /* Use with images created by ns_image_for_XPM; alpha set to 1;
150 pixel is assumed to be in RGB form. */
152 XPutPixel (XImagePtr ximage
, int x
, int y
, unsigned long pixel
)
154 ns_put_pixel (ximage
, x
, y
, pixel
);
159 /* Functions to access the contents of a bitmap, given an id. */
161 #ifdef HAVE_X_WINDOWS
163 x_bitmap_height (struct frame
*f
, ptrdiff_t id
)
165 return FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
169 x_bitmap_width (struct frame
*f
, ptrdiff_t id
)
171 return FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
175 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
177 x_bitmap_pixmap (struct frame
*f
, ptrdiff_t id
)
179 /* HAVE_NTGUI needs the explicit cast here. */
180 return (ptrdiff_t) FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
184 #ifdef HAVE_X_WINDOWS
186 x_bitmap_mask (struct frame
*f
, ptrdiff_t id
)
188 return FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
192 /* Allocate a new bitmap record. Returns index of new record. */
195 x_allocate_bitmap_record (struct frame
*f
)
197 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
200 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
201 return ++dpyinfo
->bitmaps_last
;
203 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
204 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
208 xpalloc (dpyinfo
->bitmaps
, &dpyinfo
->bitmaps_size
,
209 10, -1, sizeof *dpyinfo
->bitmaps
);
210 return ++dpyinfo
->bitmaps_last
;
213 /* Add one reference to the reference count of the bitmap with id ID. */
216 x_reference_bitmap (struct frame
*f
, ptrdiff_t id
)
218 ++FRAME_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
221 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
224 x_create_bitmap_from_data (struct frame
*f
, char *bits
, unsigned int width
, unsigned int height
)
226 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
229 #ifdef HAVE_X_WINDOWS
231 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
232 bits
, width
, height
);
235 #endif /* HAVE_X_WINDOWS */
239 bitmap
= CreateBitmap (width
, height
,
240 FRAME_DISPLAY_INFO (XFRAME (frame
))->n_planes
,
241 FRAME_DISPLAY_INFO (XFRAME (frame
))->n_cbits
,
245 #endif /* HAVE_NTGUI */
248 void *bitmap
= ns_image_from_XBM (bits
, width
, height
);
253 id
= x_allocate_bitmap_record (f
);
256 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
257 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
260 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
261 dpyinfo
->bitmaps
[id
- 1].height
= height
;
262 dpyinfo
->bitmaps
[id
- 1].width
= width
;
263 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
265 #ifdef HAVE_X_WINDOWS
266 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
267 dpyinfo
->bitmaps
[id
- 1].have_mask
= false;
268 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
269 #endif /* HAVE_X_WINDOWS */
272 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
273 dpyinfo
->bitmaps
[id
- 1].hinst
= NULL
;
274 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
275 #endif /* HAVE_NTGUI */
280 /* Create bitmap from file FILE for frame F. */
283 x_create_bitmap_from_file (struct frame
*f
, Lisp_Object file
)
285 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
288 return -1; /* W32_TODO : bitmap support */
289 #endif /* HAVE_NTGUI */
293 void *bitmap
= ns_image_from_file (file
);
299 id
= x_allocate_bitmap_record (f
);
300 dpyinfo
->bitmaps
[id
- 1].img
= bitmap
;
301 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
302 dpyinfo
->bitmaps
[id
- 1].file
= xlispstrdup (file
);
303 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
304 dpyinfo
->bitmaps
[id
- 1].height
= ns_image_width (bitmap
);
305 dpyinfo
->bitmaps
[id
- 1].width
= ns_image_height (bitmap
);
309 #ifdef HAVE_X_WINDOWS
310 unsigned int width
, height
;
312 int xhot
, yhot
, result
;
317 /* Look for an existing bitmap with the same name. */
318 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
320 if (dpyinfo
->bitmaps
[id
].refcount
321 && dpyinfo
->bitmaps
[id
].file
322 && !strcmp (dpyinfo
->bitmaps
[id
].file
, SSDATA (file
)))
324 ++dpyinfo
->bitmaps
[id
].refcount
;
329 /* Search bitmap-file-path for the file, if appropriate. */
330 if (openp (Vx_bitmap_file_path
, file
, Qnil
, &found
,
331 make_number (R_OK
), false)
335 filename
= SSDATA (found
);
337 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
338 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
339 if (result
!= BitmapSuccess
)
342 id
= x_allocate_bitmap_record (f
);
343 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
344 dpyinfo
->bitmaps
[id
- 1].have_mask
= false;
345 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
346 dpyinfo
->bitmaps
[id
- 1].file
= xlispstrdup (file
);
347 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
348 dpyinfo
->bitmaps
[id
- 1].height
= height
;
349 dpyinfo
->bitmaps
[id
- 1].width
= width
;
352 #endif /* HAVE_X_WINDOWS */
358 free_bitmap_record (Display_Info
*dpyinfo
, Bitmap_Record
*bm
)
360 #ifdef HAVE_X_WINDOWS
361 XFreePixmap (dpyinfo
->display
, bm
->pixmap
);
363 XFreePixmap (dpyinfo
->display
, bm
->mask
);
364 #endif /* HAVE_X_WINDOWS */
367 DeleteObject (bm
->pixmap
);
368 #endif /* HAVE_NTGUI */
371 ns_release_object (bm
->img
);
381 /* Remove reference to bitmap with id number ID. */
384 x_destroy_bitmap (struct frame
*f
, ptrdiff_t id
)
386 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
390 Bitmap_Record
*bm
= &dpyinfo
->bitmaps
[id
- 1];
392 if (--bm
->refcount
== 0)
395 free_bitmap_record (dpyinfo
, bm
);
401 /* Free all the bitmaps for the display specified by DPYINFO. */
404 x_destroy_all_bitmaps (Display_Info
*dpyinfo
)
407 Bitmap_Record
*bm
= dpyinfo
->bitmaps
;
409 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++, bm
++)
410 if (bm
->refcount
> 0)
411 free_bitmap_record (dpyinfo
, bm
);
413 dpyinfo
->bitmaps_last
= 0;
416 static bool x_create_x_image_and_pixmap (struct frame
*, int, int, int,
417 XImagePtr
*, Pixmap
*);
418 static void x_destroy_x_image (XImagePtr ximg
);
421 static XImagePtr_or_DC
image_get_x_image_or_dc (struct frame
*, struct image
*,
423 static void image_unget_x_image_or_dc (struct image
*, bool, XImagePtr_or_DC
,
426 static XImagePtr
image_get_x_image (struct frame
*, struct image
*, bool);
427 static void image_unget_x_image (struct image
*, bool, XImagePtr
);
428 #define image_get_x_image_or_dc(f, img, mask_p, dummy) \
429 image_get_x_image (f, img, mask_p)
430 #define image_unget_x_image_or_dc(img, mask_p, ximg, dummy) \
431 image_unget_x_image (img, mask_p, ximg)
434 #ifdef HAVE_X_WINDOWS
436 static void image_sync_to_pixmaps (struct frame
*, struct image
*);
438 /* Useful functions defined in the section
439 `Image type independent image structures' below. */
441 static unsigned long four_corners_best (XImagePtr ximg
,
444 unsigned long height
);
447 /* Create a mask of a bitmap. Note is this not a perfect mask.
448 It's nicer with some borders in this context */
451 x_create_bitmap_mask (struct frame
*f
, ptrdiff_t id
)
454 XImagePtr ximg
, mask_img
;
455 unsigned long width
, height
;
458 unsigned long x
, y
, xp
, xm
, yp
, ym
;
461 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
466 pixmap
= x_bitmap_pixmap (f
, id
);
467 width
= x_bitmap_width (f
, id
);
468 height
= x_bitmap_height (f
, id
);
471 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
480 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
485 XDestroyImage (ximg
);
489 bg
= four_corners_best (ximg
, NULL
, width
, height
);
491 for (y
= 0; y
< ximg
->height
; ++y
)
493 for (x
= 0; x
< ximg
->width
; ++x
)
495 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
496 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
497 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
498 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
499 if (XGetPixel (ximg
, x
, y
) == bg
500 && XGetPixel (ximg
, x
, yp
) == bg
501 && XGetPixel (ximg
, x
, ym
) == bg
502 && XGetPixel (ximg
, xp
, y
) == bg
503 && XGetPixel (ximg
, xp
, yp
) == bg
504 && XGetPixel (ximg
, xp
, ym
) == bg
505 && XGetPixel (ximg
, xm
, y
) == bg
506 && XGetPixel (ximg
, xm
, yp
) == bg
507 && XGetPixel (ximg
, xm
, ym
) == bg
)
508 XPutPixel (mask_img
, x
, y
, 0);
510 XPutPixel (mask_img
, x
, y
, 1);
514 eassert (input_blocked_p ());
515 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
516 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
518 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
520 dpyinfo
->bitmaps
[id
- 1].have_mask
= true;
521 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
523 XDestroyImage (ximg
);
524 x_destroy_x_image (mask_img
);
527 #endif /* HAVE_X_WINDOWS */
530 /***********************************************************************
532 ***********************************************************************/
534 /* List of supported image types. Use define_image_type to add new
535 types. Use lookup_image_type to find a type for a given symbol. */
537 static struct image_type
*image_types
;
539 /* The symbol `xbm' which is used as the type symbol for XBM images. */
541 static Lisp_Object Qxbm
;
545 Lisp_Object QCascent
, QCmargin
, QCrelief
;
546 Lisp_Object QCconversion
;
547 static Lisp_Object QCheuristic_mask
;
548 static Lisp_Object QCcolor_symbols
;
549 static Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
, QCgeometry
;
550 static Lisp_Object QCcrop
, QCrotation
;
554 static Lisp_Object Qcount
, Qextension_data
, Qdelay
;
555 static Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
557 /* Forward function prototypes. */
559 static struct image_type
*lookup_image_type (Lisp_Object
);
560 static void x_laplace (struct frame
*, struct image
*);
561 static void x_emboss (struct frame
*, struct image
*);
562 static void x_build_heuristic_mask (struct frame
*, struct image
*,
565 #define CACHE_IMAGE_TYPE(type, status) \
566 do { Vlibrary_cache = Fcons (Fcons (type, status), Vlibrary_cache); } while (0)
568 #define CACHE_IMAGE_TYPE(type, status)
571 #define ADD_IMAGE_TYPE(type) \
572 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
574 /* Define a new image type from TYPE. This adds a copy of TYPE to
575 image_types and caches the loading status of TYPE. */
577 static struct image_type
*
578 define_image_type (struct image_type
*type
)
580 struct image_type
*p
= NULL
;
581 Lisp_Object target_type
= *type
->type
;
586 for (p
= image_types
; p
; p
= p
->next
)
587 if (EQ (*p
->type
, target_type
))
592 #if defined HAVE_NTGUI && defined WINDOWSNT
593 /* If we failed to load the library before, don't try again. */
594 Lisp_Object tested
= Fassq (target_type
, Vlibrary_cache
);
595 if (CONSP (tested
) && NILP (XCDR (tested
)))
600 type_valid
= type
->init ();
601 CACHE_IMAGE_TYPE (target_type
, type_valid
? Qt
: Qnil
);
607 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
608 The initialized data segment is read-only. */
609 p
= xmalloc (sizeof *p
);
611 p
->next
= image_types
;
621 /* Value is true if OBJECT is a valid Lisp image specification. A
622 valid image specification is a list whose car is the symbol
623 `image', and whose rest is a property list. The property list must
624 contain a value for key `:type'. That value must be the name of a
625 supported image type. The rest of the property list depends on the
629 valid_image_p (Lisp_Object object
)
637 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
638 if (EQ (XCAR (tem
), QCtype
))
641 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
643 struct image_type
*type
;
644 type
= lookup_image_type (XCAR (tem
));
646 valid_p
= type
->valid_p (object
);
657 /* Log error message with format string FORMAT and argument ARG.
658 Signaling an error, e.g. when an image cannot be loaded, is not a
659 good idea because this would interrupt redisplay, and the error
660 message display would lead to another redisplay. This function
661 therefore simply displays a message. */
664 image_error (const char *format
, Lisp_Object arg1
, Lisp_Object arg2
)
666 add_to_log (format
, arg1
, arg2
);
671 /***********************************************************************
673 ***********************************************************************/
675 enum image_value_type
677 IMAGE_DONT_CHECK_VALUE_TYPE
,
679 IMAGE_STRING_OR_NIL_VALUE
,
681 IMAGE_POSITIVE_INTEGER_VALUE
,
682 IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
,
683 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
686 IMAGE_FUNCTION_VALUE
,
691 /* Structure used when parsing image specifications. */
695 /* Name of keyword. */
698 /* The type of value allowed. */
699 enum image_value_type type
;
701 /* True means key must be present. */
704 /* Used to recognize duplicate keywords in a property list. */
707 /* The value that was found. */
712 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
713 has the format (image KEYWORD VALUE ...). One of the keyword/
714 value pairs must be `:type TYPE'. KEYWORDS is a vector of
715 image_keywords structures of size NKEYWORDS describing other
716 allowed keyword/value pairs. Value is true if SPEC is valid. */
719 parse_image_spec (Lisp_Object spec
, struct image_keyword
*keywords
,
720 int nkeywords
, Lisp_Object type
)
729 while (CONSP (plist
))
731 Lisp_Object key
, value
;
733 /* First element of a pair must be a symbol. */
735 plist
= XCDR (plist
);
739 /* There must follow a value. */
742 value
= XCAR (plist
);
743 plist
= XCDR (plist
);
745 /* Find key in KEYWORDS. Error if not found. */
746 for (i
= 0; i
< nkeywords
; ++i
)
747 if (strcmp (keywords
[i
].name
, SSDATA (SYMBOL_NAME (key
))) == 0)
753 /* Record that we recognized the keyword. If a keywords
754 was found more than once, it's an error. */
755 keywords
[i
].value
= value
;
756 if (keywords
[i
].count
> 1)
760 /* Check type of value against allowed type. */
761 switch (keywords
[i
].type
)
763 case IMAGE_STRING_VALUE
:
764 if (!STRINGP (value
))
768 case IMAGE_STRING_OR_NIL_VALUE
:
769 if (!STRINGP (value
) && !NILP (value
))
773 case IMAGE_SYMBOL_VALUE
:
774 if (!SYMBOLP (value
))
778 case IMAGE_POSITIVE_INTEGER_VALUE
:
779 if (! RANGED_INTEGERP (1, value
, INT_MAX
))
783 case IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
:
784 if (RANGED_INTEGERP (0, value
, INT_MAX
))
787 && RANGED_INTEGERP (0, XCAR (value
), INT_MAX
)
788 && RANGED_INTEGERP (0, XCDR (value
), INT_MAX
))
792 case IMAGE_ASCENT_VALUE
:
793 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
795 else if (RANGED_INTEGERP (0, value
, 100))
799 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
800 /* Unlike the other integer-related cases, this one does not
801 verify that VALUE fits in 'int'. This is because callers
803 if (!INTEGERP (value
) || XINT (value
) < 0)
807 case IMAGE_DONT_CHECK_VALUE_TYPE
:
810 case IMAGE_FUNCTION_VALUE
:
811 value
= indirect_function (value
);
812 if (!NILP (Ffunctionp (value
)))
816 case IMAGE_NUMBER_VALUE
:
817 if (!INTEGERP (value
) && !FLOATP (value
))
821 case IMAGE_INTEGER_VALUE
:
822 if (! TYPE_RANGED_INTEGERP (int, value
))
826 case IMAGE_BOOL_VALUE
:
827 if (!NILP (value
) && !EQ (value
, Qt
))
836 if (EQ (key
, QCtype
) && !EQ (type
, value
))
840 /* Check that all mandatory fields are present. */
841 for (i
= 0; i
< nkeywords
; ++i
)
842 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
849 /* Return the value of KEY in image specification SPEC. Value is nil
850 if KEY is not present in SPEC. Set *FOUND depending on whether KEY
851 was found in SPEC. */
854 image_spec_value (Lisp_Object spec
, Lisp_Object key
, bool *found
)
858 eassert (valid_image_p (spec
));
860 for (tail
= XCDR (spec
);
861 CONSP (tail
) && CONSP (XCDR (tail
));
862 tail
= XCDR (XCDR (tail
)))
864 if (EQ (XCAR (tail
), key
))
868 return XCAR (XCDR (tail
));
878 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
879 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
880 PIXELS non-nil means return the size in pixels, otherwise return the
881 size in canonical character units.
882 FRAME is the frame on which the image will be displayed. FRAME nil
883 or omitted means use the selected frame. */)
884 (Lisp_Object spec
, Lisp_Object pixels
, Lisp_Object frame
)
889 if (valid_image_p (spec
))
891 struct frame
*f
= decode_window_system_frame (frame
);
892 ptrdiff_t id
= lookup_image (f
, spec
);
893 struct image
*img
= IMAGE_FROM_ID (f
, id
);
894 int width
= img
->width
+ 2 * img
->hmargin
;
895 int height
= img
->height
+ 2 * img
->vmargin
;
898 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
899 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
901 size
= Fcons (make_number (width
), make_number (height
));
904 error ("Invalid image specification");
910 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
911 doc
: /* Return t if image SPEC has a mask bitmap.
912 FRAME is the frame on which the image will be displayed. FRAME nil
913 or omitted means use the selected frame. */)
914 (Lisp_Object spec
, Lisp_Object frame
)
919 if (valid_image_p (spec
))
921 struct frame
*f
= decode_window_system_frame (frame
);
922 ptrdiff_t id
= lookup_image (f
, spec
);
923 struct image
*img
= IMAGE_FROM_ID (f
, id
);
928 error ("Invalid image specification");
933 DEFUN ("image-metadata", Fimage_metadata
, Simage_metadata
, 1, 2, 0,
934 doc
: /* Return metadata for image SPEC.
935 FRAME is the frame on which the image will be displayed. FRAME nil
936 or omitted means use the selected frame. */)
937 (Lisp_Object spec
, Lisp_Object frame
)
942 if (valid_image_p (spec
))
944 struct frame
*f
= decode_window_system_frame (frame
);
945 ptrdiff_t id
= lookup_image (f
, spec
);
946 struct image
*img
= IMAGE_FROM_ID (f
, id
);
947 ext
= img
->lisp_data
;
954 /***********************************************************************
955 Image type independent image structures
956 ***********************************************************************/
958 #define MAX_IMAGE_SIZE 10.0
959 /* Allocate and return a new image structure for image specification
960 SPEC. SPEC has a hash value of HASH. */
962 static struct image
*
963 make_image (Lisp_Object spec
, EMACS_UINT hash
)
965 struct image
*img
= xzalloc (sizeof *img
);
966 Lisp_Object file
= image_spec_value (spec
, QCfile
, NULL
);
968 eassert (valid_image_p (spec
));
969 img
->dependencies
= NILP (file
) ? Qnil
: list1 (file
);
970 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
971 eassert (img
->type
!= NULL
);
973 img
->lisp_data
= Qnil
;
974 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
976 img
->corners
[BOT_CORNER
] = -1; /* Full image */
981 /* Free image IMG which was used on frame F, including its resources. */
984 free_image (struct frame
*f
, struct image
*img
)
988 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
990 /* Remove IMG from the hash table of its cache. */
992 img
->prev
->next
= img
->next
;
994 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
997 img
->next
->prev
= img
->prev
;
999 c
->images
[img
->id
] = NULL
;
1001 /* Free resources, then free IMG. */
1002 img
->type
->free (f
, img
);
1007 /* Return true if the given widths and heights are valid for display. */
1010 check_image_size (struct frame
*f
, int width
, int height
)
1014 if (width
<= 0 || height
<= 0)
1017 if (INTEGERP (Vmax_image_size
))
1018 return (width
<= XINT (Vmax_image_size
)
1019 && height
<= XINT (Vmax_image_size
));
1020 else if (FLOATP (Vmax_image_size
))
1024 w
= FRAME_PIXEL_WIDTH (f
);
1025 h
= FRAME_PIXEL_HEIGHT (f
);
1028 w
= h
= 1024; /* Arbitrary size for unknown frame. */
1029 return (width
<= XFLOAT_DATA (Vmax_image_size
) * w
1030 && height
<= XFLOAT_DATA (Vmax_image_size
) * h
);
1036 /* Prepare image IMG for display on frame F. Must be called before
1037 drawing an image. */
1040 prepare_image_for_display (struct frame
*f
, struct image
*img
)
1042 /* We're about to display IMG, so set its timestamp to `now'. */
1043 img
->timestamp
= current_timespec ();
1045 /* If IMG doesn't have a pixmap yet, load it now, using the image
1046 type dependent loader function. */
1047 if (img
->pixmap
== NO_PIXMAP
&& !img
->load_failed_p
)
1048 img
->load_failed_p
= ! img
->type
->load (f
, img
);
1050 #ifdef HAVE_X_WINDOWS
1051 if (!img
->load_failed_p
)
1054 image_sync_to_pixmaps (f
, img
);
1061 /* Value is the number of pixels for the ascent of image IMG when
1062 drawn in face FACE. */
1065 image_ascent (struct image
*img
, struct face
*face
, struct glyph_slice
*slice
)
1070 if (slice
->height
== img
->height
)
1071 height
= img
->height
+ img
->vmargin
;
1072 else if (slice
->y
== 0)
1073 height
= slice
->height
+ img
->vmargin
;
1075 height
= slice
->height
;
1077 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
1082 /* W32 specific version. Why?. ++kfs */
1083 ascent
= height
/ 2 - (FONT_DESCENT (face
->font
)
1084 - FONT_BASE (face
->font
)) / 2;
1086 /* This expression is arranged so that if the image can't be
1087 exactly centered, it will be moved slightly up. This is
1088 because a typical font is `top-heavy' (due to the presence
1089 uppercase letters), so the image placement should err towards
1090 being top-heavy too. It also just generally looks better. */
1091 ascent
= (height
+ FONT_BASE (face
->font
)
1092 - FONT_DESCENT (face
->font
) + 1) / 2;
1093 #endif /* HAVE_NTGUI */
1096 ascent
= height
/ 2;
1099 ascent
= height
* (img
->ascent
/ 100.0);
1105 /* Image background colors. */
1107 /* Find the "best" corner color of a bitmap.
1108 On W32, XIMG is assumed to a device context with the bitmap selected. */
1110 static RGB_PIXEL_COLOR
1111 four_corners_best (XImagePtr_or_DC ximg
, int *corners
,
1112 unsigned long width
, unsigned long height
)
1114 RGB_PIXEL_COLOR corner_pixels
[4], best
IF_LINT (= 0);
1117 if (corners
&& corners
[BOT_CORNER
] >= 0)
1119 /* Get the colors at the corner_pixels of ximg. */
1120 corner_pixels
[0] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[TOP_CORNER
]);
1121 corner_pixels
[1] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[TOP_CORNER
]);
1122 corner_pixels
[2] = GET_PIXEL (ximg
, corners
[RIGHT_CORNER
] - 1, corners
[BOT_CORNER
] - 1);
1123 corner_pixels
[3] = GET_PIXEL (ximg
, corners
[LEFT_CORNER
], corners
[BOT_CORNER
] - 1);
1127 /* Get the colors at the corner_pixels of ximg. */
1128 corner_pixels
[0] = GET_PIXEL (ximg
, 0, 0);
1129 corner_pixels
[1] = GET_PIXEL (ximg
, width
- 1, 0);
1130 corner_pixels
[2] = GET_PIXEL (ximg
, width
- 1, height
- 1);
1131 corner_pixels
[3] = GET_PIXEL (ximg
, 0, height
- 1);
1133 /* Choose the most frequently found color as background. */
1134 for (i
= best_count
= 0; i
< 4; ++i
)
1138 for (j
= n
= 0; j
< 4; ++j
)
1139 if (corner_pixels
[i
] == corner_pixels
[j
])
1143 best
= corner_pixels
[i
], best_count
= n
;
1149 /* Portability macros */
1153 #define Free_Pixmap(display, pixmap) \
1154 DeleteObject (pixmap)
1156 #elif defined (HAVE_NS)
1158 #define Free_Pixmap(display, pixmap) \
1159 ns_release_object (pixmap)
1163 #define Free_Pixmap(display, pixmap) \
1164 XFreePixmap (display, pixmap)
1166 #endif /* !HAVE_NTGUI && !HAVE_NS */
1169 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1170 it is guessed heuristically. If non-zero, XIMG is an existing
1171 XImage object (or device context with the image selected on W32) to
1172 use for the heuristic. */
1175 image_background (struct image
*img
, struct frame
*f
, XImagePtr_or_DC ximg
)
1177 if (! img
->background_valid
)
1178 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1180 bool free_ximg
= !ximg
;
1183 #endif /* HAVE_NTGUI */
1186 ximg
= image_get_x_image_or_dc (f
, img
, 0, &prev
);
1188 img
->background
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
1191 image_unget_x_image_or_dc (img
, 0, ximg
, prev
);
1193 img
->background_valid
= 1;
1196 return img
->background
;
1199 /* Return the `background_transparent' field of IMG. If IMG doesn't
1200 have one yet, it is guessed heuristically. If non-zero, MASK is an
1201 existing XImage object to use for the heuristic. */
1204 image_background_transparent (struct image
*img
, struct frame
*f
, XImagePtr_or_DC mask
)
1206 if (! img
->background_transparent_valid
)
1207 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1211 bool free_mask
= !mask
;
1214 #endif /* HAVE_NTGUI */
1217 mask
= image_get_x_image_or_dc (f
, img
, 1, &prev
);
1219 img
->background_transparent
1220 = (four_corners_best (mask
, img
->corners
, img
->width
, img
->height
) == PIX_MASK_RETAIN
);
1223 image_unget_x_image_or_dc (img
, 1, mask
, prev
);
1226 img
->background_transparent
= 0;
1228 img
->background_transparent_valid
= 1;
1231 return img
->background_transparent
;
1234 /* Store F's background color into *BGCOLOR. */
1236 x_query_frame_background_color (struct frame
*f
, XColor
*bgcolor
)
1239 bgcolor
->pixel
= FRAME_BACKGROUND_PIXEL (f
);
1240 x_query_color (f
, bgcolor
);
1242 ns_query_color (FRAME_BACKGROUND_COLOR (f
), bgcolor
, 1);
1247 /***********************************************************************
1248 Helper functions for X image types
1249 ***********************************************************************/
1251 /* Clear X resources of image IMG on frame F according to FLAGS.
1252 FLAGS is bitwise-or of the following masks:
1253 CLEAR_IMAGE_PIXMAP free the pixmap if any.
1254 CLEAR_IMAGE_MASK means clear the mask pixmap if any.
1255 CLEAR_IMAGE_COLORS means free colors allocated for the image, if
1258 #define CLEAR_IMAGE_PIXMAP (1 << 0)
1259 #define CLEAR_IMAGE_MASK (1 << 1)
1260 #define CLEAR_IMAGE_COLORS (1 << 2)
1263 x_clear_image_1 (struct frame
*f
, struct image
*img
, int flags
)
1265 if (flags
& CLEAR_IMAGE_PIXMAP
)
1269 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
1270 img
->pixmap
= NO_PIXMAP
;
1271 /* NOTE (HAVE_NS): background color is NOT an indexed color! */
1272 img
->background_valid
= 0;
1274 #ifdef HAVE_X_WINDOWS
1277 x_destroy_x_image (img
->ximg
);
1279 img
->background_valid
= 0;
1284 if (flags
& CLEAR_IMAGE_MASK
)
1288 Free_Pixmap (FRAME_X_DISPLAY (f
), img
->mask
);
1289 img
->mask
= NO_PIXMAP
;
1290 img
->background_transparent_valid
= 0;
1292 #ifdef HAVE_X_WINDOWS
1295 x_destroy_x_image (img
->mask_img
);
1296 img
->mask_img
= NULL
;
1297 img
->background_transparent_valid
= 0;
1302 if ((flags
& CLEAR_IMAGE_COLORS
) && img
->ncolors
)
1304 /* W32_TODO: color table support. */
1305 #ifdef HAVE_X_WINDOWS
1306 x_free_colors (f
, img
->colors
, img
->ncolors
);
1307 #endif /* HAVE_X_WINDOWS */
1308 xfree (img
->colors
);
1315 /* Free X resources of image IMG which is used on frame F. */
1318 x_clear_image (struct frame
*f
, struct image
*img
)
1321 x_clear_image_1 (f
, img
,
1322 CLEAR_IMAGE_PIXMAP
| CLEAR_IMAGE_MASK
| CLEAR_IMAGE_COLORS
);
1327 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1328 cannot be allocated, use DFLT. Add a newly allocated color to
1329 IMG->colors, so that it can be freed again. Value is the pixel
1332 static unsigned long
1333 x_alloc_image_color (struct frame
*f
, struct image
*img
, Lisp_Object color_name
,
1337 unsigned long result
;
1339 eassert (STRINGP (color_name
));
1341 if (x_defined_color (f
, SSDATA (color_name
), &color
, 1)
1342 && img
->ncolors
< min (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *img
->colors
,
1345 /* This isn't called frequently so we get away with simply
1346 reallocating the color vector to the needed size, here. */
1347 ptrdiff_t ncolors
= img
->ncolors
+ 1;
1348 img
->colors
= xrealloc (img
->colors
, ncolors
* sizeof *img
->colors
);
1349 img
->colors
[ncolors
- 1] = color
.pixel
;
1350 img
->ncolors
= ncolors
;
1351 result
= color
.pixel
;
1361 /***********************************************************************
1363 ***********************************************************************/
1365 static void cache_image (struct frame
*f
, struct image
*img
);
1367 /* Return a new, initialized image cache that is allocated from the
1368 heap. Call free_image_cache to free an image cache. */
1370 struct image_cache
*
1371 make_image_cache (void)
1373 struct image_cache
*c
= xmalloc (sizeof *c
);
1376 c
->used
= c
->refcount
= 0;
1377 c
->images
= xmalloc (c
->size
* sizeof *c
->images
);
1378 c
->buckets
= xzalloc (IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
);
1383 /* Find an image matching SPEC in the cache, and return it. If no
1384 image is found, return NULL. */
1385 static struct image
*
1386 search_image_cache (struct frame
*f
, Lisp_Object spec
, EMACS_UINT hash
)
1389 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1390 int i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1392 if (!c
) return NULL
;
1394 /* If the image spec does not specify a background color, the cached
1395 image must have the same background color as the current frame.
1396 The foreground color must also match, for the sake of monochrome
1399 In fact, we could ignore the foreground color matching condition
1400 for color images, or if the image spec specifies :foreground;
1401 similarly we could ignore the background color matching condition
1402 for formats that don't use transparency (such as jpeg), or if the
1403 image spec specifies :background. However, the extra memory
1404 usage is probably negligible in practice, so we don't bother. */
1406 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
1407 if (img
->hash
== hash
1408 && !NILP (Fequal (img
->spec
, spec
))
1409 && img
->frame_foreground
== FRAME_FOREGROUND_PIXEL (f
)
1410 && img
->frame_background
== FRAME_BACKGROUND_PIXEL (f
))
1416 /* Search frame F for an image with spec SPEC, and free it. */
1419 uncache_image (struct frame
*f
, Lisp_Object spec
)
1421 struct image
*img
= search_image_cache (f
, spec
, sxhash (spec
, 0));
1424 free_image (f
, img
);
1425 /* As display glyphs may still be referring to the image ID, we
1426 must garbage the frame (Bug#6426). */
1427 SET_FRAME_GARBAGED (f
);
1432 /* Free image cache of frame F. Be aware that X frames share images
1436 free_image_cache (struct frame
*f
)
1438 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1443 /* Cache should not be referenced by any frame when freed. */
1444 eassert (c
->refcount
== 0);
1446 for (i
= 0; i
< c
->used
; ++i
)
1447 free_image (f
, c
->images
[i
]);
1451 FRAME_IMAGE_CACHE (f
) = NULL
;
1456 /* Clear image cache of frame F. FILTER=t means free all images.
1457 FILTER=nil means clear only images that haven't been
1458 displayed for some time.
1459 Else, only free the images which have FILTER in their `dependencies'.
1460 Should be called from time to time to reduce the number of loaded images.
1461 If image-cache-eviction-delay is non-nil, this frees images in the cache
1462 which weren't displayed for at least that many seconds. */
1465 clear_image_cache (struct frame
*f
, Lisp_Object filter
)
1467 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1471 ptrdiff_t i
, nfreed
= 0;
1473 /* Block input so that we won't be interrupted by a SIGIO
1474 while being in an inconsistent state. */
1479 /* Filter image cache. */
1480 for (i
= 0; i
< c
->used
; ++i
)
1482 struct image
*img
= c
->images
[i
];
1483 if (img
&& (EQ (Qt
, filter
)
1484 || !NILP (Fmember (filter
, img
->dependencies
))))
1486 free_image (f
, img
);
1491 else if (INTEGERP (Vimage_cache_eviction_delay
))
1493 /* Free cache based on timestamp. */
1494 struct timespec old
, t
;
1496 ptrdiff_t nimages
= 0;
1498 for (i
= 0; i
< c
->used
; ++i
)
1502 /* If the number of cached images has grown unusually large,
1503 decrease the cache eviction delay (Bug#6230). */
1504 delay
= XINT (Vimage_cache_eviction_delay
);
1506 delay
= 1600 * delay
/ nimages
/ nimages
;
1507 delay
= max (delay
, 1);
1509 t
= current_timespec ();
1510 old
= timespec_sub (t
, dtotimespec (delay
));
1512 for (i
= 0; i
< c
->used
; ++i
)
1514 struct image
*img
= c
->images
[i
];
1515 if (img
&& timespec_cmp (img
->timestamp
, old
) < 0)
1517 free_image (f
, img
);
1523 /* We may be clearing the image cache because, for example,
1524 Emacs was iconified for a longer period of time. In that
1525 case, current matrices may still contain references to
1526 images freed above. So, clear these matrices. */
1529 Lisp_Object tail
, frame
;
1531 FOR_EACH_FRAME (tail
, frame
)
1533 struct frame
*fr
= XFRAME (frame
);
1534 if (FRAME_IMAGE_CACHE (fr
) == c
)
1535 clear_current_matrices (fr
);
1538 windows_or_buffers_changed
= 19;
1546 clear_image_caches (Lisp_Object filter
)
1548 /* FIXME: We want to do
1549 * struct terminal *t;
1550 * for (t = terminal_list; t; t = t->next_terminal)
1551 * clear_image_cache (t, filter); */
1552 Lisp_Object tail
, frame
;
1553 FOR_EACH_FRAME (tail
, frame
)
1554 if (FRAME_WINDOW_P (XFRAME (frame
)))
1555 clear_image_cache (XFRAME (frame
), filter
);
1558 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
1560 doc
: /* Clear the image cache.
1561 FILTER nil or a frame means clear all images in the selected frame.
1562 FILTER t means clear the image caches of all frames.
1563 Anything else, means only clear those images which refer to FILTER,
1564 which is then usually a filename. */)
1565 (Lisp_Object filter
)
1567 if (!(EQ (filter
, Qnil
) || FRAMEP (filter
)))
1568 clear_image_caches (filter
);
1570 clear_image_cache (decode_window_system_frame (filter
), Qt
);
1576 DEFUN ("image-flush", Fimage_flush
, Simage_flush
,
1578 doc
: /* Flush the image with specification SPEC on frame FRAME.
1579 This removes the image from the Emacs image cache. If SPEC specifies
1580 an image file, the next redisplay of this image will read from the
1581 current contents of that file.
1583 FRAME nil or omitted means use the selected frame.
1584 FRAME t means refresh the image on all frames. */)
1585 (Lisp_Object spec
, Lisp_Object frame
)
1587 if (!valid_image_p (spec
))
1588 error ("Invalid image specification");
1593 FOR_EACH_FRAME (tail
, frame
)
1595 struct frame
*f
= XFRAME (frame
);
1596 if (FRAME_WINDOW_P (f
))
1597 uncache_image (f
, spec
);
1601 uncache_image (decode_window_system_frame (frame
), spec
);
1607 /* Compute masks and transform image IMG on frame F, as specified
1608 by the image's specification, */
1611 postprocess_image (struct frame
*f
, struct image
*img
)
1613 /* Manipulation of the image's mask. */
1616 Lisp_Object conversion
, spec
;
1621 /* `:heuristic-mask t'
1623 means build a mask heuristically.
1624 `:heuristic-mask (R G B)'
1625 `:mask (heuristic (R G B))'
1626 means build a mask from color (R G B) in the
1629 means remove a mask, if any. */
1631 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
1633 x_build_heuristic_mask (f
, img
, mask
);
1638 mask
= image_spec_value (spec
, QCmask
, &found_p
);
1640 if (EQ (mask
, Qheuristic
))
1641 x_build_heuristic_mask (f
, img
, Qt
);
1642 else if (CONSP (mask
)
1643 && EQ (XCAR (mask
), Qheuristic
))
1645 if (CONSP (XCDR (mask
)))
1646 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
1648 x_build_heuristic_mask (f
, img
, XCDR (mask
));
1650 else if (NILP (mask
) && found_p
&& img
->mask
)
1651 x_clear_image_1 (f
, img
, CLEAR_IMAGE_MASK
);
1655 /* Should we apply an image transformation algorithm? */
1656 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
1657 if (EQ (conversion
, Qdisabled
))
1658 x_disable_image (f
, img
);
1659 else if (EQ (conversion
, Qlaplace
))
1661 else if (EQ (conversion
, Qemboss
))
1663 else if (CONSP (conversion
)
1664 && EQ (XCAR (conversion
), Qedge_detection
))
1667 tem
= XCDR (conversion
);
1669 x_edge_detection (f
, img
,
1670 Fplist_get (tem
, QCmatrix
),
1671 Fplist_get (tem
, QCcolor_adjustment
));
1677 /* Return the id of image with Lisp specification SPEC on frame F.
1678 SPEC must be a valid Lisp image specification (see valid_image_p). */
1681 lookup_image (struct frame
*f
, Lisp_Object spec
)
1686 /* F must be a window-system frame, and SPEC must be a valid image
1688 eassert (FRAME_WINDOW_P (f
));
1689 eassert (valid_image_p (spec
));
1691 /* Look up SPEC in the hash table of the image cache. */
1692 hash
= sxhash (spec
, 0);
1693 img
= search_image_cache (f
, spec
, hash
);
1694 if (img
&& img
->load_failed_p
)
1696 free_image (f
, img
);
1700 /* If not found, create a new image and cache it. */
1704 img
= make_image (spec
, hash
);
1705 cache_image (f
, img
);
1706 img
->load_failed_p
= ! img
->type
->load (f
, img
);
1707 img
->frame_foreground
= FRAME_FOREGROUND_PIXEL (f
);
1708 img
->frame_background
= FRAME_BACKGROUND_PIXEL (f
);
1710 /* If we can't load the image, and we don't have a width and
1711 height, use some arbitrary width and height so that we can
1712 draw a rectangle for it. */
1713 if (img
->load_failed_p
)
1717 value
= image_spec_value (spec
, QCwidth
, NULL
);
1718 img
->width
= (INTEGERP (value
)
1719 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
1720 value
= image_spec_value (spec
, QCheight
, NULL
);
1721 img
->height
= (INTEGERP (value
)
1722 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
1726 /* Handle image type independent image attributes
1727 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1728 `:background COLOR'. */
1729 Lisp_Object ascent
, margin
, relief
, bg
;
1732 ascent
= image_spec_value (spec
, QCascent
, NULL
);
1733 if (INTEGERP (ascent
))
1734 img
->ascent
= XFASTINT (ascent
);
1735 else if (EQ (ascent
, Qcenter
))
1736 img
->ascent
= CENTERED_IMAGE_ASCENT
;
1738 margin
= image_spec_value (spec
, QCmargin
, NULL
);
1739 if (INTEGERP (margin
))
1740 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
1741 else if (CONSP (margin
))
1743 img
->hmargin
= XFASTINT (XCAR (margin
));
1744 img
->vmargin
= XFASTINT (XCDR (margin
));
1747 relief
= image_spec_value (spec
, QCrelief
, NULL
);
1748 relief_bound
= INT_MAX
- max (img
->hmargin
, img
->vmargin
);
1749 if (RANGED_INTEGERP (- relief_bound
, relief
, relief_bound
))
1751 img
->relief
= XINT (relief
);
1752 img
->hmargin
+= eabs (img
->relief
);
1753 img
->vmargin
+= eabs (img
->relief
);
1756 if (! img
->background_valid
)
1758 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
1762 = x_alloc_image_color (f
, img
, bg
,
1763 FRAME_BACKGROUND_PIXEL (f
));
1764 img
->background_valid
= 1;
1768 /* Do image transformations and compute masks, unless we
1769 don't have the image yet. */
1770 if (!EQ (*img
->type
->type
, Qpostscript
))
1771 postprocess_image (f
, img
);
1777 /* We're using IMG, so set its timestamp to `now'. */
1778 img
->timestamp
= current_timespec ();
1780 /* Value is the image id. */
1785 /* Cache image IMG in the image cache of frame F. */
1788 cache_image (struct frame
*f
, struct image
*img
)
1790 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
1793 /* Find a free slot in c->images. */
1794 for (i
= 0; i
< c
->used
; ++i
)
1795 if (c
->images
[i
] == NULL
)
1798 /* If no free slot found, maybe enlarge c->images. */
1799 if (i
== c
->used
&& c
->used
== c
->size
)
1800 c
->images
= xpalloc (c
->images
, &c
->size
, 1, -1, sizeof *c
->images
);
1802 /* Add IMG to c->images, and assign IMG an id. */
1808 /* Add IMG to the cache's hash table. */
1809 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
1810 img
->next
= c
->buckets
[i
];
1812 img
->next
->prev
= img
;
1814 c
->buckets
[i
] = img
;
1818 /* Call FN on every image in the image cache of frame F. Used to mark
1819 Lisp Objects in the image cache. */
1821 /* Mark Lisp objects in image IMG. */
1824 mark_image (struct image
*img
)
1826 mark_object (img
->spec
);
1827 mark_object (img
->dependencies
);
1829 if (!NILP (img
->lisp_data
))
1830 mark_object (img
->lisp_data
);
1835 mark_image_cache (struct image_cache
*c
)
1840 for (i
= 0; i
< c
->used
; ++i
)
1842 mark_image (c
->images
[i
]);
1848 /***********************************************************************
1849 X / NS / W32 support code
1850 ***********************************************************************/
1854 /* Macro for defining functions that will be loaded from image DLLs. */
1855 #define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
1857 /* Macro for loading those image functions from the library. */
1858 #define LOAD_IMGLIB_FN(lib,func) { \
1859 fn_##func = (void *) GetProcAddress (lib, #func); \
1860 if (!fn_##func) return 0; \
1863 #endif /* WINDOWSNT */
1865 /* Return true if XIMG's size WIDTH x HEIGHT doesn't break the
1867 WIDTH and HEIGHT must both be positive.
1868 If XIMG is null, assume it is a bitmap. */
1870 x_check_image_size (XImagePtr ximg
, int width
, int height
)
1872 #ifdef HAVE_X_WINDOWS
1873 /* Respect Xlib's limits: it cannot deal with images that have more
1874 than INT_MAX (and/or UINT_MAX) bytes. And respect Emacs's limits
1875 of PTRDIFF_MAX (and/or SIZE_MAX) bytes for any object. */
1878 XLIB_BYTES_MAX
= min (INT_MAX
, UINT_MAX
),
1879 X_IMAGE_BYTES_MAX
= min (XLIB_BYTES_MAX
, min (PTRDIFF_MAX
, SIZE_MAX
))
1882 int bitmap_pad
, depth
, bytes_per_line
;
1885 bitmap_pad
= ximg
->bitmap_pad
;
1886 depth
= ximg
->depth
;
1887 bytes_per_line
= ximg
->bytes_per_line
;
1893 bytes_per_line
= (width
>> 3) + ((width
& 7) != 0);
1895 return (width
<= (INT_MAX
- (bitmap_pad
- 1)) / depth
1896 && height
<= X_IMAGE_BYTES_MAX
/ bytes_per_line
);
1898 /* FIXME: Implement this check for the HAVE_NS and HAVE_NTGUI cases.
1899 For now, assume that every image size is allowed on these systems. */
1904 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1905 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1906 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1907 via xmalloc. Print error messages via image_error if an error
1908 occurs. Value is true if successful.
1910 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1911 should indicate the bit depth of the image. */
1914 x_create_x_image_and_pixmap (struct frame
*f
, int width
, int height
, int depth
,
1915 XImagePtr
*ximg
, Pixmap
*pixmap
)
1917 #ifdef HAVE_X_WINDOWS
1918 Display
*display
= FRAME_X_DISPLAY (f
);
1919 Window window
= FRAME_X_WINDOW (f
);
1920 Screen
*screen
= FRAME_X_SCREEN (f
);
1922 eassert (input_blocked_p ());
1925 depth
= DefaultDepthOfScreen (screen
);
1926 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
1927 depth
, ZPixmap
, 0, NULL
, width
, height
,
1928 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
1931 image_error ("Unable to allocate X image", Qnil
, Qnil
);
1935 if (! x_check_image_size (*ximg
, width
, height
))
1937 x_destroy_x_image (*ximg
);
1939 image_error ("Image too large (%dx%d)",
1940 make_number (width
), make_number (height
));
1944 /* Allocate image raster. */
1945 (*ximg
)->data
= xmalloc ((*ximg
)->bytes_per_line
* height
);
1947 /* Allocate a pixmap of the same size. */
1948 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
1949 if (*pixmap
== NO_PIXMAP
)
1951 x_destroy_x_image (*ximg
);
1953 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
1958 #endif /* HAVE_X_WINDOWS */
1962 BITMAPINFOHEADER
*header
;
1964 int scanline_width_bits
;
1966 int palette_colors
= 0;
1971 if (depth
!= 1 && depth
!= 4 && depth
!= 8
1972 && depth
!= 16 && depth
!= 24 && depth
!= 32)
1974 image_error ("Invalid image bit depth specified", Qnil
, Qnil
);
1978 scanline_width_bits
= width
* depth
;
1979 remainder
= scanline_width_bits
% 32;
1982 scanline_width_bits
+= 32 - remainder
;
1984 /* Bitmaps with a depth less than 16 need a palette. */
1985 /* BITMAPINFO structure already contains the first RGBQUAD. */
1987 palette_colors
= 1 << (depth
- 1);
1989 *ximg
= xmalloc (sizeof (XImage
) + palette_colors
* sizeof (RGBQUAD
));
1991 header
= &(*ximg
)->info
.bmiHeader
;
1992 memset (&(*ximg
)->info
, 0, sizeof (BITMAPINFO
));
1993 header
->biSize
= sizeof (*header
);
1994 header
->biWidth
= width
;
1995 header
->biHeight
= -height
; /* negative indicates a top-down bitmap. */
1996 header
->biPlanes
= 1;
1997 header
->biBitCount
= depth
;
1998 header
->biCompression
= BI_RGB
;
1999 header
->biClrUsed
= palette_colors
;
2001 /* TODO: fill in palette. */
2004 (*ximg
)->info
.bmiColors
[0].rgbBlue
= 0;
2005 (*ximg
)->info
.bmiColors
[0].rgbGreen
= 0;
2006 (*ximg
)->info
.bmiColors
[0].rgbRed
= 0;
2007 (*ximg
)->info
.bmiColors
[0].rgbReserved
= 0;
2008 (*ximg
)->info
.bmiColors
[1].rgbBlue
= 255;
2009 (*ximg
)->info
.bmiColors
[1].rgbGreen
= 255;
2010 (*ximg
)->info
.bmiColors
[1].rgbRed
= 255;
2011 (*ximg
)->info
.bmiColors
[1].rgbReserved
= 0;
2014 hdc
= get_frame_dc (f
);
2016 /* Create a DIBSection and raster array for the bitmap,
2017 and store its handle in *pixmap. */
2018 *pixmap
= CreateDIBSection (hdc
, &((*ximg
)->info
),
2019 (depth
< 16) ? DIB_PAL_COLORS
: DIB_RGB_COLORS
,
2020 /* casting avoids a GCC warning */
2021 (void **)&((*ximg
)->data
), NULL
, 0);
2023 /* Realize display palette and garbage all frames. */
2024 release_frame_dc (f
, hdc
);
2026 if (*pixmap
== NULL
)
2028 DWORD err
= GetLastError ();
2029 Lisp_Object errcode
;
2030 /* All system errors are < 10000, so the following is safe. */
2031 XSETINT (errcode
, err
);
2032 image_error ("Unable to create bitmap, error code %d", errcode
, Qnil
);
2033 x_destroy_x_image (*ximg
);
2040 #endif /* HAVE_NTGUI */
2043 *pixmap
= ns_image_for_XPM (width
, height
, depth
);
2047 image_error ("Unable to allocate NSImage for XPM pixmap", Qnil
, Qnil
);
2056 /* Destroy XImage XIMG. Free XIMG->data. */
2059 x_destroy_x_image (XImagePtr ximg
)
2061 eassert (input_blocked_p ());
2064 #ifdef HAVE_X_WINDOWS
2067 XDestroyImage (ximg
);
2068 #endif /* HAVE_X_WINDOWS */
2070 /* Data will be freed by DestroyObject. */
2073 #endif /* HAVE_NTGUI */
2075 ns_release_object (ximg
);
2076 #endif /* HAVE_NS */
2081 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2082 are width and height of both the image and pixmap. */
2085 x_put_x_image (struct frame
*f
, XImagePtr ximg
, Pixmap pixmap
, int width
, int height
)
2087 #ifdef HAVE_X_WINDOWS
2090 eassert (input_blocked_p ());
2091 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
2092 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
2093 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
2094 #endif /* HAVE_X_WINDOWS */
2097 #if 0 /* I don't think this is necessary looking at where it is used. */
2098 HDC hdc
= get_frame_dc (f
);
2099 SetDIBits (hdc
, pixmap
, 0, height
, ximg
->data
, &(ximg
->info
), DIB_RGB_COLORS
);
2100 release_frame_dc (f
, hdc
);
2102 #endif /* HAVE_NTGUI */
2105 eassert (ximg
== pixmap
);
2106 ns_retain_object (ximg
);
2110 /* Thin wrapper for x_create_x_image_and_pixmap, so that it matches
2111 with image_put_x_image. */
2114 image_create_x_image_and_pixmap (struct frame
*f
, struct image
*img
,
2115 int width
, int height
, int depth
,
2116 XImagePtr
*ximg
, bool mask_p
)
2118 eassert ((!mask_p
? img
->pixmap
: img
->mask
) == NO_PIXMAP
);
2120 return x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
,
2121 !mask_p
? &img
->pixmap
: &img
->mask
);
2124 /* Put X image XIMG into image IMG on frame F, as a mask if and only
2125 if MASK_P. On X, this simply records XIMG on a member of IMG, so
2126 it can be put into the pixmap afterwards via image_sync_to_pixmaps.
2127 On the other platforms, it puts XIMG into the pixmap, then frees
2128 the X image and its buffer. */
2131 image_put_x_image (struct frame
*f
, struct image
*img
, XImagePtr ximg
,
2134 #ifdef HAVE_X_WINDOWS
2137 eassert (img
->ximg
== NULL
);
2142 eassert (img
->mask_img
== NULL
);
2143 img
->mask_img
= ximg
;
2146 x_put_x_image (f
, ximg
, !mask_p
? img
->pixmap
: img
->mask
,
2147 img
->width
, img
->height
);
2148 x_destroy_x_image (ximg
);
2152 #ifdef HAVE_X_WINDOWS
2153 /* Put the X images recorded in IMG on frame F into pixmaps, then free
2154 the X images and their buffers. */
2157 image_sync_to_pixmaps (struct frame
*f
, struct image
*img
)
2161 x_put_x_image (f
, img
->ximg
, img
->pixmap
, img
->width
, img
->height
);
2162 x_destroy_x_image (img
->ximg
);
2167 x_put_x_image (f
, img
->mask_img
, img
->mask
, img
->width
, img
->height
);
2168 x_destroy_x_image (img
->mask_img
);
2169 img
->mask_img
= NULL
;
2175 /* Create a memory device context for IMG on frame F. It stores the
2176 currently selected GDI object into *PREV for future restoration by
2177 image_unget_x_image_or_dc. */
2179 static XImagePtr_or_DC
2180 image_get_x_image_or_dc (struct frame
*f
, struct image
*img
, bool mask_p
,
2183 HDC frame_dc
= get_frame_dc (f
);
2184 XImagePtr_or_DC ximg
= CreateCompatibleDC (frame_dc
);
2186 release_frame_dc (f
, frame_dc
);
2187 *prev
= SelectObject (ximg
, !mask_p
? img
->pixmap
: img
->mask
);
2193 image_unget_x_image_or_dc (struct image
*img
, bool mask_p
,
2194 XImagePtr_or_DC ximg
, HGDIOBJ prev
)
2196 SelectObject (ximg
, prev
);
2199 #else /* !HAVE_NTGUI */
2200 /* Get the X image for IMG on frame F. The resulting X image data
2201 should be treated as read-only at least on X. */
2204 image_get_x_image (struct frame
*f
, struct image
*img
, bool mask_p
)
2206 #ifdef HAVE_X_WINDOWS
2207 XImagePtr ximg_in_img
= !mask_p
? img
->ximg
: img
->mask_img
;
2212 return XGetImage (FRAME_X_DISPLAY (f
), !mask_p
? img
->pixmap
: img
->mask
,
2213 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
2214 #elif defined (HAVE_NS)
2215 XImagePtr pixmap
= !mask_p
? img
->pixmap
: img
->mask
;
2217 ns_retain_object (pixmap
);
2223 image_unget_x_image (struct image
*img
, bool mask_p
, XImagePtr ximg
)
2225 #ifdef HAVE_X_WINDOWS
2226 XImagePtr ximg_in_img
= !mask_p
? img
->ximg
: img
->mask_img
;
2229 eassert (ximg
== ximg_in_img
);
2231 XDestroyImage (ximg
);
2232 #elif defined (HAVE_NS)
2233 ns_release_object (ximg
);
2236 #endif /* !HAVE_NTGUI */
2239 /***********************************************************************
2241 ***********************************************************************/
2243 /* Find image file FILE. Look in data-directory/images, then
2244 x-bitmap-file-path. Value is the encoded full name of the file
2245 found, or nil if not found. */
2248 x_find_image_file (Lisp_Object file
)
2250 Lisp_Object file_found
, search_path
;
2253 /* TODO I think this should use something like image-load-path
2254 instead. Unfortunately, that can contain non-string elements. */
2255 search_path
= Fcons (Fexpand_file_name (build_string ("images"),
2257 Vx_bitmap_file_path
);
2259 /* Try to find FILE in data-directory/images, then x-bitmap-file-path. */
2260 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
, false);
2266 file_found
= ENCODE_FILE (file_found
);
2275 /* Read FILE into memory. Value is a pointer to a buffer allocated
2276 with xmalloc holding FILE's contents. Value is null if an error
2277 occurred. *SIZE is set to the size of the file. */
2279 static unsigned char *
2280 slurp_file (char *file
, ptrdiff_t *size
)
2282 FILE *fp
= emacs_fopen (file
, "rb");
2283 unsigned char *buf
= NULL
;
2288 ptrdiff_t count
= SPECPDL_INDEX ();
2289 record_unwind_protect_ptr (fclose_unwind
, fp
);
2291 if (fstat (fileno (fp
), &st
) == 0
2292 && 0 <= st
.st_size
&& st
.st_size
< min (PTRDIFF_MAX
, SIZE_MAX
))
2294 /* Report an error if we read past the purported EOF.
2295 This can happen if the file grows as we read it. */
2296 ptrdiff_t buflen
= st
.st_size
;
2297 buf
= xmalloc (buflen
+ 1);
2298 if (fread (buf
, 1, buflen
+ 1, fp
) == buflen
)
2307 unbind_to (count
, Qnil
);
2315 /***********************************************************************
2317 ***********************************************************************/
2319 static bool xbm_load (struct frame
*f
, struct image
*img
);
2320 static bool xbm_image_p (Lisp_Object object
);
2321 static bool xbm_file_p (Lisp_Object
);
2324 /* Indices of image specification fields in xbm_format, below. */
2326 enum xbm_keyword_index
2344 /* Vector of image_keyword structures describing the format
2345 of valid XBM image specifications. */
2347 static const struct image_keyword xbm_format
[XBM_LAST
] =
2349 {":type", IMAGE_SYMBOL_VALUE
, 1},
2350 {":file", IMAGE_STRING_VALUE
, 0},
2351 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2352 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
2353 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2354 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
2355 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
2356 {":ascent", IMAGE_ASCENT_VALUE
, 0},
2357 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
2358 {":relief", IMAGE_INTEGER_VALUE
, 0},
2359 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2360 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
2361 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
2364 /* Structure describing the image type XBM. */
2366 static struct image_type xbm_type
=
2376 /* Tokens returned from xbm_scan. */
2385 /* Return true if OBJECT is a valid XBM-type image specification.
2386 A valid specification is a list starting with the symbol `image'
2387 The rest of the list is a property list which must contain an
2390 If the specification specifies a file to load, it must contain
2391 an entry `:file FILENAME' where FILENAME is a string.
2393 If the specification is for a bitmap loaded from memory it must
2394 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2395 WIDTH and HEIGHT are integers > 0. DATA may be:
2397 1. a string large enough to hold the bitmap data, i.e. it must
2398 have a size >= (WIDTH + 7) / 8 * HEIGHT
2400 2. a bool-vector of size >= WIDTH * HEIGHT
2402 3. a vector of strings or bool-vectors, one for each line of the
2405 4. a string containing an in-memory XBM file. WIDTH and HEIGHT
2406 may not be specified in this case because they are defined in the
2409 Both the file and data forms may contain the additional entries
2410 `:background COLOR' and `:foreground COLOR'. If not present,
2411 foreground and background of the frame on which the image is
2412 displayed is used. */
2415 xbm_image_p (Lisp_Object object
)
2417 struct image_keyword kw
[XBM_LAST
];
2419 memcpy (kw
, xbm_format
, sizeof kw
);
2420 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
2423 eassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
2425 if (kw
[XBM_FILE
].count
)
2427 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
2430 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
2432 /* In-memory XBM file. */
2433 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
2441 /* Entries for `:width', `:height' and `:data' must be present. */
2442 if (!kw
[XBM_WIDTH
].count
2443 || !kw
[XBM_HEIGHT
].count
2444 || !kw
[XBM_DATA
].count
)
2447 data
= kw
[XBM_DATA
].value
;
2448 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
2449 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
2451 /* Check type of data, and width and height against contents of
2457 /* Number of elements of the vector must be >= height. */
2458 if (ASIZE (data
) < height
)
2461 /* Each string or bool-vector in data must be large enough
2462 for one line of the image. */
2463 for (i
= 0; i
< height
; ++i
)
2465 Lisp_Object elt
= AREF (data
, i
);
2470 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
2473 else if (BOOL_VECTOR_P (elt
))
2475 if (bool_vector_size (elt
) < width
)
2482 else if (STRINGP (data
))
2485 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
2488 else if (BOOL_VECTOR_P (data
))
2490 if (bool_vector_size (data
) / height
< width
)
2501 /* Scan a bitmap file. FP is the stream to read from. Value is
2502 either an enumerator from enum xbm_token, or a character for a
2503 single-character token, or 0 at end of file. If scanning an
2504 identifier, store the lexeme of the identifier in SVAL. If
2505 scanning a number, store its value in *IVAL. */
2508 xbm_scan (unsigned char **s
, unsigned char *end
, char *sval
, int *ival
)
2514 /* Skip white space. */
2515 while (*s
< end
&& (c
= *(*s
)++, c_isspace (c
)))
2520 else if (c_isdigit (c
))
2522 int value
= 0, digit
;
2524 if (c
== '0' && *s
< end
)
2527 if (c
== 'x' || c
== 'X')
2534 else if (c
>= 'a' && c
<= 'f')
2535 digit
= c
- 'a' + 10;
2536 else if (c
>= 'A' && c
<= 'F')
2537 digit
= c
- 'A' + 10;
2540 value
= 16 * value
+ digit
;
2543 else if (c_isdigit (c
))
2547 && (c
= *(*s
)++, c_isdigit (c
)))
2548 value
= 8 * value
+ c
- '0';
2555 && (c
= *(*s
)++, c_isdigit (c
)))
2556 value
= 10 * value
+ c
- '0';
2564 else if (c_isalpha (c
) || c
== '_')
2568 && (c
= *(*s
)++, (c_isalnum (c
) || c
== '_')))
2575 else if (c
== '/' && **s
== '*')
2577 /* C-style comment. */
2579 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
2593 /* Create a Windows bitmap from X bitmap data. */
2595 w32_create_pixmap_from_bitmap_data (int width
, int height
, char *data
)
2597 static unsigned char swap_nibble
[16]
2598 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2599 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2600 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2601 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2603 unsigned char *bits
, *p
;
2606 w1
= (width
+ 7) / 8; /* nb of 8bits elt in X bitmap */
2607 w2
= ((width
+ 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2608 bits
= alloca (height
* w2
);
2609 memset (bits
, 0, height
* w2
);
2610 for (i
= 0; i
< height
; i
++)
2613 for (j
= 0; j
< w1
; j
++)
2615 /* Bitswap XBM bytes to match how Windows does things. */
2616 unsigned char c
= *data
++;
2617 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
2618 | (swap_nibble
[(c
>>4) & 0xf]));
2621 bmp
= CreateBitmap (width
, height
, 1, 1, (char *) bits
);
2627 convert_mono_to_color_image (struct frame
*f
, struct image
*img
,
2628 COLORREF foreground
, COLORREF background
)
2630 HDC hdc
, old_img_dc
, new_img_dc
;
2631 HGDIOBJ old_prev
, new_prev
;
2634 hdc
= get_frame_dc (f
);
2635 old_img_dc
= CreateCompatibleDC (hdc
);
2636 new_img_dc
= CreateCompatibleDC (hdc
);
2637 new_pixmap
= CreateCompatibleBitmap (hdc
, img
->width
, img
->height
);
2638 release_frame_dc (f
, hdc
);
2639 old_prev
= SelectObject (old_img_dc
, img
->pixmap
);
2640 new_prev
= SelectObject (new_img_dc
, new_pixmap
);
2641 /* Windows convention for mono bitmaps is black = background,
2642 white = foreground. */
2643 SetTextColor (new_img_dc
, background
);
2644 SetBkColor (new_img_dc
, foreground
);
2646 BitBlt (new_img_dc
, 0, 0, img
->width
, img
->height
, old_img_dc
,
2649 SelectObject (old_img_dc
, old_prev
);
2650 SelectObject (new_img_dc
, new_prev
);
2651 DeleteDC (old_img_dc
);
2652 DeleteDC (new_img_dc
);
2653 DeleteObject (img
->pixmap
);
2654 if (new_pixmap
== 0)
2655 fprintf (stderr
, "Failed to convert image to color.\n");
2657 img
->pixmap
= new_pixmap
;
2660 #define XBM_BIT_SHUFFLE(b) (~(b))
2664 #define XBM_BIT_SHUFFLE(b) (b)
2666 #endif /* HAVE_NTGUI */
2670 Create_Pixmap_From_Bitmap_Data (struct frame
*f
, struct image
*img
, char *data
,
2671 RGB_PIXEL_COLOR fg
, RGB_PIXEL_COLOR bg
,
2672 bool non_default_colors
)
2676 = w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
, data
);
2678 /* If colors were specified, transfer the bitmap to a color one. */
2679 if (non_default_colors
)
2680 convert_mono_to_color_image (f
, img
, fg
, bg
);
2682 #elif defined (HAVE_NS)
2683 img
->pixmap
= ns_image_from_XBM (data
, img
->width
, img
->height
);
2687 (x_check_image_size (0, img
->width
, img
->height
)
2688 ? XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
2691 img
->width
, img
->height
,
2693 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)))
2695 #endif /* !HAVE_NTGUI && !HAVE_NS */
2700 /* Replacement for XReadBitmapFileData which isn't available under old
2701 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2702 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2703 the image. Return in *DATA the bitmap data allocated with xmalloc.
2704 Value is true if successful. DATA null means just test if
2705 CONTENTS looks like an in-memory XBM file. If INHIBIT_IMAGE_ERROR,
2706 inhibit the call to image_error when the image size is invalid (the
2707 bitmap remains unread). */
2710 xbm_read_bitmap_data (struct frame
*f
, unsigned char *contents
, unsigned char *end
,
2711 int *width
, int *height
, char **data
,
2712 bool inhibit_image_error
)
2714 unsigned char *s
= contents
;
2715 char buffer
[BUFSIZ
];
2718 int bytes_per_line
, i
, nbytes
;
2724 LA1 = xbm_scan (&s, end, buffer, &value)
2726 #define expect(TOKEN) \
2729 if (LA1 != (TOKEN)) \
2735 #define expect_ident(IDENT) \
2736 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2741 *width
= *height
= -1;
2744 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
2746 /* Parse defines for width, height and hot-spots. */
2750 expect_ident ("define");
2751 expect (XBM_TK_IDENT
);
2753 if (LA1
== XBM_TK_NUMBER
)
2755 char *q
= strrchr (buffer
, '_');
2756 q
= q
? q
+ 1 : buffer
;
2757 if (strcmp (q
, "width") == 0)
2759 else if (strcmp (q
, "height") == 0)
2762 expect (XBM_TK_NUMBER
);
2765 if (!check_image_size (f
, *width
, *height
))
2767 if (!inhibit_image_error
)
2768 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
2771 else if (data
== NULL
)
2774 /* Parse bits. Must start with `static'. */
2775 expect_ident ("static");
2776 if (LA1
== XBM_TK_IDENT
)
2778 if (strcmp (buffer
, "unsigned") == 0)
2781 expect_ident ("char");
2783 else if (strcmp (buffer
, "short") == 0)
2787 if (*width
% 16 && *width
% 16 < 9)
2790 else if (strcmp (buffer
, "char") == 0)
2798 expect (XBM_TK_IDENT
);
2804 if (! x_check_image_size (0, *width
, *height
))
2806 if (!inhibit_image_error
)
2807 image_error ("Image too large (%dx%d)",
2808 make_number (*width
), make_number (*height
));
2811 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
2812 nbytes
= bytes_per_line
* *height
;
2813 p
= *data
= xmalloc (nbytes
);
2817 for (i
= 0; i
< nbytes
; i
+= 2)
2820 expect (XBM_TK_NUMBER
);
2822 *p
++ = XBM_BIT_SHUFFLE (val
);
2823 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
2824 *p
++ = XBM_BIT_SHUFFLE (value
>> 8);
2826 if (LA1
== ',' || LA1
== '}')
2834 for (i
= 0; i
< nbytes
; ++i
)
2837 expect (XBM_TK_NUMBER
);
2839 *p
++ = XBM_BIT_SHUFFLE (val
);
2841 if (LA1
== ',' || LA1
== '}')
2866 /* Load XBM image IMG which will be displayed on frame F from buffer
2867 CONTENTS. END is the end of the buffer. Value is true if
2871 xbm_load_image (struct frame
*f
, struct image
*img
, unsigned char *contents
,
2878 rc
= xbm_read_bitmap_data (f
, contents
, end
, &img
->width
, &img
->height
,
2882 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2883 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2884 bool non_default_colors
= 0;
2887 eassert (img
->width
> 0 && img
->height
> 0);
2889 /* Get foreground and background colors, maybe allocate colors. */
2890 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
2893 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
2894 non_default_colors
= 1;
2896 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
2899 background
= x_alloc_image_color (f
, img
, value
, background
);
2900 img
->background
= background
;
2901 img
->background_valid
= 1;
2902 non_default_colors
= 1;
2905 Create_Pixmap_From_Bitmap_Data (f
, img
, data
,
2906 foreground
, background
,
2907 non_default_colors
);
2910 if (img
->pixmap
== NO_PIXMAP
)
2912 x_clear_image (f
, img
);
2913 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
2919 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2925 /* Value is true if DATA looks like an in-memory XBM file. */
2928 xbm_file_p (Lisp_Object data
)
2931 return (STRINGP (data
)
2932 && xbm_read_bitmap_data (NULL
, SDATA (data
),
2933 (SDATA (data
) + SBYTES (data
)),
2938 /* Fill image IMG which is used on frame F with pixmap data. Value is
2939 true if successful. */
2942 xbm_load (struct frame
*f
, struct image
*img
)
2945 Lisp_Object file_name
;
2947 eassert (xbm_image_p (img
->spec
));
2949 /* If IMG->spec specifies a file name, create a non-file spec from it. */
2950 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
2951 if (STRINGP (file_name
))
2954 unsigned char *contents
;
2957 file
= x_find_image_file (file_name
);
2958 if (!STRINGP (file
))
2960 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
2964 contents
= slurp_file (SSDATA (file
), &size
);
2965 if (contents
== NULL
)
2967 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
2971 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
2976 struct image_keyword fmt
[XBM_LAST
];
2978 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
2979 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
2980 bool non_default_colors
= 0;
2983 bool in_memory_file_p
= 0;
2985 /* See if data looks like an in-memory XBM file. */
2986 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
2987 in_memory_file_p
= xbm_file_p (data
);
2989 /* Parse the image specification. */
2990 memcpy (fmt
, xbm_format
, sizeof fmt
);
2991 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
2994 /* Get specified width, and height. */
2995 if (!in_memory_file_p
)
2997 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
2998 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
2999 eassert (img
->width
> 0 && img
->height
> 0);
3000 if (!check_image_size (f
, img
->width
, img
->height
))
3002 image_error ("Invalid image size (see `max-image-size')",
3008 /* Get foreground and background colors, maybe allocate colors. */
3009 if (fmt
[XBM_FOREGROUND
].count
3010 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
3012 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
3014 non_default_colors
= 1;
3017 if (fmt
[XBM_BACKGROUND
].count
3018 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
3020 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
3022 non_default_colors
= 1;
3025 if (in_memory_file_p
)
3026 success_p
= xbm_load_image (f
, img
, SDATA (data
),
3035 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
3037 p
= bits
= alloca (nbytes
* img
->height
);
3038 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
3040 Lisp_Object line
= AREF (data
, i
);
3042 memcpy (p
, SDATA (line
), nbytes
);
3044 memcpy (p
, bool_vector_data (line
), nbytes
);
3047 else if (STRINGP (data
))
3048 bits
= SSDATA (data
);
3050 bits
= (char *) bool_vector_data (data
);
3056 /* Windows mono bitmaps are reversed compared with X. */
3057 invertedBits
= bits
;
3058 nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
3060 bits
= alloca (nbytes
);
3061 for (i
= 0; i
< nbytes
; i
++)
3062 bits
[i
] = XBM_BIT_SHUFFLE (invertedBits
[i
]);
3065 /* Create the pixmap. */
3067 if (x_check_image_size (0, img
->width
, img
->height
))
3068 Create_Pixmap_From_Bitmap_Data (f
, img
, bits
,
3069 foreground
, background
,
3070 non_default_colors
);
3072 img
->pixmap
= NO_PIXMAP
;
3078 image_error ("Unable to create pixmap for XBM image `%s'",
3080 x_clear_image (f
, img
);
3090 /***********************************************************************
3092 ***********************************************************************/
3094 #if defined (HAVE_XPM) || defined (HAVE_NS)
3096 static bool xpm_image_p (Lisp_Object object
);
3097 static bool xpm_load (struct frame
*f
, struct image
*img
);
3099 #endif /* HAVE_XPM || HAVE_NS */
3103 /* Indicate to xpm.h that we don't have Xlib. */
3105 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3106 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3107 #define XColor xpm_XColor
3108 #define XImage xpm_XImage
3109 #define Display xpm_Display
3110 #define PIXEL_ALREADY_TYPEDEFED
3111 #include "X11/xpm.h"
3116 #undef PIXEL_ALREADY_TYPEDEFED
3118 #include "X11/xpm.h"
3119 #endif /* HAVE_NTGUI */
3120 #endif /* HAVE_XPM */
3122 #if defined (HAVE_XPM) || defined (HAVE_NS)
3123 /* The symbol `xpm' identifying XPM-format images. */
3125 static Lisp_Object Qxpm
;
3127 /* Indices of image specification fields in xpm_format, below. */
3129 enum xpm_keyword_index
3145 /* Vector of image_keyword structures describing the format
3146 of valid XPM image specifications. */
3148 static const struct image_keyword xpm_format
[XPM_LAST
] =
3150 {":type", IMAGE_SYMBOL_VALUE
, 1},
3151 {":file", IMAGE_STRING_VALUE
, 0},
3152 {":data", IMAGE_STRING_VALUE
, 0},
3153 {":ascent", IMAGE_ASCENT_VALUE
, 0},
3154 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
3155 {":relief", IMAGE_INTEGER_VALUE
, 0},
3156 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3157 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3158 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3159 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
3160 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
3163 #if defined HAVE_NTGUI && defined WINDOWSNT
3164 static bool init_xpm_functions (void);
3166 #define init_xpm_functions NULL
3169 /* Structure describing the image type XPM. */
3171 static struct image_type xpm_type
=
3181 #ifdef HAVE_X_WINDOWS
3183 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3184 functions for allocating image colors. Our own functions handle
3185 color allocation failures more gracefully than the ones on the XPM
3188 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3189 #define ALLOC_XPM_COLORS
3191 #endif /* HAVE_X_WINDOWS */
3193 #ifdef ALLOC_XPM_COLORS
3195 static struct xpm_cached_color
*xpm_cache_color (struct frame
*, char *,
3198 /* An entry in a hash table used to cache color definitions of named
3199 colors. This cache is necessary to speed up XPM image loading in
3200 case we do color allocations ourselves. Without it, we would need
3201 a call to XParseColor per pixel in the image. */
3203 struct xpm_cached_color
3205 /* Next in collision chain. */
3206 struct xpm_cached_color
*next
;
3208 /* Color definition (RGB and pixel color). */
3212 char name
[FLEXIBLE_ARRAY_MEMBER
];
3215 /* The hash table used for the color cache, and its bucket vector
3218 #define XPM_COLOR_CACHE_BUCKETS 1001
3219 static struct xpm_cached_color
**xpm_color_cache
;
3221 /* Initialize the color cache. */
3224 xpm_init_color_cache (struct frame
*f
, XpmAttributes
*attrs
)
3226 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
3227 xpm_color_cache
= xzalloc (nbytes
);
3228 init_color_table ();
3230 if (attrs
->valuemask
& XpmColorSymbols
)
3235 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
3236 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3237 attrs
->colorsymbols
[i
].value
, &color
))
3239 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
3241 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
3246 /* Free the color cache. */
3249 xpm_free_color_cache (void)
3251 struct xpm_cached_color
*p
, *next
;
3254 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
3255 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
3261 xfree (xpm_color_cache
);
3262 xpm_color_cache
= NULL
;
3263 free_color_table ();
3266 /* Return the bucket index for color named COLOR_NAME in the color
3270 xpm_color_bucket (char *color_name
)
3272 EMACS_UINT hash
= hash_string (color_name
, strlen (color_name
));
3273 return hash
% XPM_COLOR_CACHE_BUCKETS
;
3277 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3278 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3281 static struct xpm_cached_color
*
3282 xpm_cache_color (struct frame
*f
, char *color_name
, XColor
*color
, int bucket
)
3285 struct xpm_cached_color
*p
;
3288 bucket
= xpm_color_bucket (color_name
);
3290 nbytes
= offsetof (struct xpm_cached_color
, name
) + strlen (color_name
) + 1;
3291 p
= xmalloc (nbytes
);
3292 strcpy (p
->name
, color_name
);
3294 p
->next
= xpm_color_cache
[bucket
];
3295 xpm_color_cache
[bucket
] = p
;
3299 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3300 return the cached definition in *COLOR. Otherwise, make a new
3301 entry in the cache and allocate the color. Value is false if color
3302 allocation failed. */
3305 xpm_lookup_color (struct frame
*f
, char *color_name
, XColor
*color
)
3307 struct xpm_cached_color
*p
;
3308 int h
= xpm_color_bucket (color_name
);
3310 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
3311 if (strcmp (p
->name
, color_name
) == 0)
3316 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
3319 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
3321 p
= xpm_cache_color (f
, color_name
, color
, h
);
3323 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3324 with transparency, and it's useful. */
3325 else if (strcmp ("opaque", color_name
) == 0)
3327 memset (color
, 0, sizeof (XColor
)); /* Is this necessary/correct? */
3328 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
3329 p
= xpm_cache_color (f
, color_name
, color
, h
);
3336 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3337 CLOSURE is a pointer to the frame on which we allocate the
3338 color. Return in *COLOR the allocated color. Value is non-zero
3342 xpm_alloc_color (Display
*dpy
, Colormap cmap
, char *color_name
, XColor
*color
,
3345 return xpm_lookup_color (closure
, color_name
, color
);
3349 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3350 is a pointer to the frame on which we allocate the color. Value is
3351 non-zero if successful. */
3354 xpm_free_colors (Display
*dpy
, Colormap cmap
, Pixel
*pixels
, int npixels
, void *closure
)
3359 #endif /* ALLOC_XPM_COLORS */
3364 /* XPM library details. */
3366 DEF_IMGLIB_FN (void, XpmFreeAttributes
, (XpmAttributes
*));
3367 DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer
, (Display
*, char *, xpm_XImage
**,
3368 xpm_XImage
**, XpmAttributes
*));
3369 DEF_IMGLIB_FN (int, XpmReadFileToImage
, (Display
*, char *, xpm_XImage
**,
3370 xpm_XImage
**, XpmAttributes
*));
3371 DEF_IMGLIB_FN (void, XImageFree
, (xpm_XImage
*));
3374 init_xpm_functions (void)
3378 if (!(library
= w32_delayed_load (Qxpm
)))
3381 LOAD_IMGLIB_FN (library
, XpmFreeAttributes
);
3382 LOAD_IMGLIB_FN (library
, XpmCreateImageFromBuffer
);
3383 LOAD_IMGLIB_FN (library
, XpmReadFileToImage
);
3384 LOAD_IMGLIB_FN (library
, XImageFree
);
3388 #endif /* WINDOWSNT */
3390 #if defined HAVE_NTGUI && !defined WINDOWSNT
3391 /* Glue for code below */
3392 #define fn_XpmReadFileToImage XpmReadFileToImage
3393 #define fn_XpmCreateImageFromBuffer XpmCreateImageFromBuffer
3394 #define fn_XImageFree XImageFree
3395 #define fn_XpmFreeAttributes XpmFreeAttributes
3396 #endif /* HAVE_NTGUI && !WINDOWSNT */
3398 /* Value is true if COLOR_SYMBOLS is a valid color symbols list
3399 for XPM images. Such a list must consist of conses whose car and
3403 xpm_valid_color_symbols_p (Lisp_Object color_symbols
)
3405 while (CONSP (color_symbols
))
3407 Lisp_Object sym
= XCAR (color_symbols
);
3409 || !STRINGP (XCAR (sym
))
3410 || !STRINGP (XCDR (sym
)))
3412 color_symbols
= XCDR (color_symbols
);
3415 return NILP (color_symbols
);
3419 /* Value is true if OBJECT is a valid XPM image specification. */
3422 xpm_image_p (Lisp_Object object
)
3424 struct image_keyword fmt
[XPM_LAST
];
3425 memcpy (fmt
, xpm_format
, sizeof fmt
);
3426 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
3427 /* Either `:file' or `:data' must be present. */
3428 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
3429 /* Either no `:color-symbols' or it's a list of conses
3430 whose car and cdr are strings. */
3431 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
3432 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
3435 #endif /* HAVE_XPM || HAVE_NS */
3437 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3439 x_create_bitmap_from_xpm_data (struct frame
*f
, const char **bits
)
3441 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
3444 XpmAttributes attrs
;
3445 Pixmap bitmap
, mask
;
3447 memset (&attrs
, 0, sizeof attrs
);
3449 attrs
.visual
= FRAME_X_VISUAL (f
);
3450 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3451 attrs
.valuemask
|= XpmVisual
;
3452 attrs
.valuemask
|= XpmColormap
;
3454 rc
= XpmCreatePixmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3455 (char **) bits
, &bitmap
, &mask
, &attrs
);
3456 if (rc
!= XpmSuccess
)
3458 XpmFreeAttributes (&attrs
);
3462 id
= x_allocate_bitmap_record (f
);
3463 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
3464 dpyinfo
->bitmaps
[id
- 1].have_mask
= true;
3465 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
3466 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
3467 dpyinfo
->bitmaps
[id
- 1].height
= attrs
.height
;
3468 dpyinfo
->bitmaps
[id
- 1].width
= attrs
.width
;
3469 dpyinfo
->bitmaps
[id
- 1].depth
= attrs
.depth
;
3470 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
3472 XpmFreeAttributes (&attrs
);
3475 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3477 /* Load image IMG which will be displayed on frame F. Value is
3478 true if successful. */
3483 xpm_load (struct frame
*f
, struct image
*img
)
3486 XpmAttributes attrs
;
3487 Lisp_Object specified_file
, color_symbols
;
3490 xpm_XImage
* xpm_image
= NULL
, * xpm_mask
= NULL
;
3491 #endif /* HAVE_NTGUI */
3493 /* Configure the XPM lib. Use the visual of frame F. Allocate
3494 close colors. Return colors allocated. */
3495 memset (&attrs
, 0, sizeof attrs
);
3498 attrs
.visual
= FRAME_X_VISUAL (f
);
3499 attrs
.colormap
= FRAME_X_COLORMAP (f
);
3500 attrs
.valuemask
|= XpmVisual
;
3501 attrs
.valuemask
|= XpmColormap
;
3502 #endif /* HAVE_NTGUI */
3504 #ifdef ALLOC_XPM_COLORS
3505 /* Allocate colors with our own functions which handle
3506 failing color allocation more gracefully. */
3507 attrs
.color_closure
= f
;
3508 attrs
.alloc_color
= xpm_alloc_color
;
3509 attrs
.free_colors
= xpm_free_colors
;
3510 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
3511 #else /* not ALLOC_XPM_COLORS */
3512 /* Let the XPM lib allocate colors. */
3513 attrs
.valuemask
|= XpmReturnAllocPixels
;
3514 #ifdef XpmAllocCloseColors
3515 attrs
.alloc_close_colors
= 1;
3516 attrs
.valuemask
|= XpmAllocCloseColors
;
3517 #else /* not XpmAllocCloseColors */
3518 attrs
.closeness
= 600;
3519 attrs
.valuemask
|= XpmCloseness
;
3520 #endif /* not XpmAllocCloseColors */
3521 #endif /* ALLOC_XPM_COLORS */
3523 /* If image specification contains symbolic color definitions, add
3524 these to `attrs'. */
3525 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
3526 if (CONSP (color_symbols
))
3529 XpmColorSymbol
*xpm_syms
;
3532 attrs
.valuemask
|= XpmColorSymbols
;
3534 /* Count number of symbols. */
3535 attrs
.numsymbols
= 0;
3536 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
3539 /* Allocate an XpmColorSymbol array. */
3540 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
3541 xpm_syms
= alloca (size
);
3542 memset (xpm_syms
, 0, size
);
3543 attrs
.colorsymbols
= xpm_syms
;
3545 /* Fill the color symbol array. */
3546 for (tail
= color_symbols
, i
= 0;
3548 ++i
, tail
= XCDR (tail
))
3552 char *empty_string
= (char *) "";
3554 if (!CONSP (XCAR (tail
)))
3556 xpm_syms
[i
].name
= empty_string
;
3557 xpm_syms
[i
].value
= empty_string
;
3560 name
= XCAR (XCAR (tail
));
3561 color
= XCDR (XCAR (tail
));
3564 xpm_syms
[i
].name
= alloca (SCHARS (name
) + 1);
3565 strcpy (xpm_syms
[i
].name
, SSDATA (name
));
3568 xpm_syms
[i
].name
= empty_string
;
3569 if (STRINGP (color
))
3571 xpm_syms
[i
].value
= alloca (SCHARS (color
) + 1);
3572 strcpy (xpm_syms
[i
].value
, SSDATA (color
));
3575 xpm_syms
[i
].value
= empty_string
;
3579 /* Create a pixmap for the image, either from a file, or from a
3580 string buffer containing data in the same format as an XPM file. */
3581 #ifdef ALLOC_XPM_COLORS
3582 xpm_init_color_cache (f
, &attrs
);
3585 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
3589 HDC frame_dc
= get_frame_dc (f
);
3590 hdc
= CreateCompatibleDC (frame_dc
);
3591 release_frame_dc (f
, frame_dc
);
3593 #endif /* HAVE_NTGUI */
3595 if (STRINGP (specified_file
))
3597 Lisp_Object file
= x_find_image_file (specified_file
);
3598 if (!STRINGP (file
))
3600 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
3601 #ifdef ALLOC_XPM_COLORS
3602 xpm_free_color_cache ();
3609 /* FILE is encoded in UTF-8, but image libraries on Windows
3610 support neither UTF-8 nor UTF-16 encoded file names. So we
3611 need to re-encode it in ANSI. */
3612 file
= ansi_encode_filename (file
);
3614 /* XpmReadFileToPixmap is not available in the Windows port of
3615 libxpm. But XpmReadFileToImage almost does what we want. */
3616 rc
= fn_XpmReadFileToImage (&hdc
, SDATA (file
),
3617 &xpm_image
, &xpm_mask
,
3620 rc
= XpmReadFileToImage (FRAME_X_DISPLAY (f
), SSDATA (file
),
3621 &img
->ximg
, &img
->mask_img
,
3623 #endif /* HAVE_NTGUI */
3627 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
3628 if (!STRINGP (buffer
))
3630 image_error ("Invalid image data `%s'", buffer
, Qnil
);
3631 #ifdef ALLOC_XPM_COLORS
3632 xpm_free_color_cache ();
3637 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3638 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3639 rc
= fn_XpmCreateImageFromBuffer (&hdc
, SDATA (buffer
),
3640 &xpm_image
, &xpm_mask
,
3643 rc
= XpmCreateImageFromBuffer (FRAME_X_DISPLAY (f
), SSDATA (buffer
),
3644 &img
->ximg
, &img
->mask_img
,
3646 #endif /* HAVE_NTGUI */
3649 #ifdef HAVE_X_WINDOWS
3650 if (rc
== XpmSuccess
)
3652 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3653 img
->ximg
->width
, img
->ximg
->height
,
3655 if (img
->pixmap
== NO_PIXMAP
)
3657 x_clear_image (f
, img
);
3660 else if (img
->mask_img
)
3662 img
->mask
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3663 img
->mask_img
->width
,
3664 img
->mask_img
->height
,
3665 img
->mask_img
->depth
);
3666 if (img
->mask
== NO_PIXMAP
)
3668 x_clear_image (f
, img
);
3675 if (rc
== XpmSuccess
)
3677 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3678 img
->colors
= colors_in_color_table (&img
->ncolors
);
3679 #else /* not ALLOC_XPM_COLORS */
3683 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3684 plus some duplicate attributes. */
3685 if (xpm_image
&& xpm_image
->bitmap
)
3687 img
->pixmap
= xpm_image
->bitmap
;
3688 /* XImageFree in libXpm frees XImage struct without destroying
3689 the bitmap, which is what we want. */
3690 fn_XImageFree (xpm_image
);
3692 if (xpm_mask
&& xpm_mask
->bitmap
)
3694 /* The mask appears to be inverted compared with what we expect.
3695 TODO: invert our expectations. See other places where we
3696 have to invert bits because our idea of masks is backwards. */
3698 old_obj
= SelectObject (hdc
, xpm_mask
->bitmap
);
3700 PatBlt (hdc
, 0, 0, xpm_mask
->width
, xpm_mask
->height
, DSTINVERT
);
3701 SelectObject (hdc
, old_obj
);
3703 img
->mask
= xpm_mask
->bitmap
;
3704 fn_XImageFree (xpm_mask
);
3709 #endif /* HAVE_NTGUI */
3711 /* Remember allocated colors. */
3712 img
->colors
= xnmalloc (attrs
.nalloc_pixels
, sizeof *img
->colors
);
3713 img
->ncolors
= attrs
.nalloc_pixels
;
3714 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
3716 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
3717 #ifdef DEBUG_X_COLORS
3718 register_color (img
->colors
[i
]);
3721 #endif /* not ALLOC_XPM_COLORS */
3723 img
->width
= attrs
.width
;
3724 img
->height
= attrs
.height
;
3725 eassert (img
->width
> 0 && img
->height
> 0);
3727 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3729 fn_XpmFreeAttributes (&attrs
);
3731 XpmFreeAttributes (&attrs
);
3732 #endif /* HAVE_NTGUI */
3734 #ifdef HAVE_X_WINDOWS
3735 /* Maybe fill in the background field while we have ximg handy. */
3736 IMAGE_BACKGROUND (img
, f
, img
->ximg
);
3738 /* Fill in the background_transparent field while we have the
3740 image_background_transparent (img
, f
, img
->mask_img
);
3747 #endif /* HAVE_NTGUI */
3752 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
3755 case XpmFileInvalid
:
3756 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
3760 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
3763 case XpmColorFailed
:
3764 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
3768 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
3773 #ifdef ALLOC_XPM_COLORS
3774 xpm_free_color_cache ();
3776 return rc
== XpmSuccess
;
3779 #endif /* HAVE_XPM */
3781 #if defined (HAVE_NS) && !defined (HAVE_XPM)
3783 /* XPM support functions for NS where libxpm is not available.
3784 Only XPM version 3 (without any extensions) is supported. */
3786 static void xpm_put_color_table_v (Lisp_Object
, const unsigned char *,
3788 static Lisp_Object
xpm_get_color_table_v (Lisp_Object
,
3789 const unsigned char *, int);
3790 static void xpm_put_color_table_h (Lisp_Object
, const unsigned char *,
3792 static Lisp_Object
xpm_get_color_table_h (Lisp_Object
,
3793 const unsigned char *, int);
3795 /* Tokens returned from xpm_scan. */
3804 /* Scan an XPM data and return a character (< 256) or a token defined
3805 by enum xpm_token above. *S and END are the start (inclusive) and
3806 the end (exclusive) addresses of the data, respectively. Advance
3807 *S while scanning. If token is either XPM_TK_IDENT or
3808 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3809 length of the corresponding token, respectively. */
3812 xpm_scan (const unsigned char **s
,
3813 const unsigned char *end
,
3814 const unsigned char **beg
,
3821 /* Skip white-space. */
3822 while (*s
< end
&& (c
= *(*s
)++, c_isspace (c
)))
3825 /* gnus-pointer.xpm uses '-' in its identifier.
3826 sb-dir-plus.xpm uses '+' in its identifier. */
3827 if (c_isalpha (c
) || c
== '_' || c
== '-' || c
== '+')
3831 && (c
= **s
, c_isalnum (c
)
3832 || c
== '_' || c
== '-' || c
== '+'))
3835 return XPM_TK_IDENT
;
3840 while (*s
< end
&& **s
!= '"')
3845 return XPM_TK_STRING
;
3849 if (*s
< end
&& **s
== '*')
3851 /* C-style comment. */
3855 while (*s
< end
&& *(*s
)++ != '*')
3858 while (*s
< end
&& **s
!= '/');
3872 /* Functions for color table lookup in XPM data. A key is a string
3873 specifying the color of each pixel in XPM data. A value is either
3874 an integer that specifies a pixel color, Qt that specifies
3875 transparency, or Qnil for the unspecified color. If the length of
3876 the key string is one, a vector is used as a table. Otherwise, a
3877 hash table is used. */
3880 xpm_make_color_table_v (void (**put_func
) (Lisp_Object
,
3881 const unsigned char *,
3884 Lisp_Object (**get_func
) (Lisp_Object
,
3885 const unsigned char *,
3888 *put_func
= xpm_put_color_table_v
;
3889 *get_func
= xpm_get_color_table_v
;
3890 return Fmake_vector (make_number (256), Qnil
);
3894 xpm_put_color_table_v (Lisp_Object color_table
,
3895 const unsigned char *chars_start
,
3899 ASET (color_table
, *chars_start
, color
);
3903 xpm_get_color_table_v (Lisp_Object color_table
,
3904 const unsigned char *chars_start
,
3907 return AREF (color_table
, *chars_start
);
3911 xpm_make_color_table_h (void (**put_func
) (Lisp_Object
,
3912 const unsigned char *,
3915 Lisp_Object (**get_func
) (Lisp_Object
,
3916 const unsigned char *,
3919 *put_func
= xpm_put_color_table_h
;
3920 *get_func
= xpm_get_color_table_h
;
3921 return make_hash_table (hashtest_equal
, make_number (DEFAULT_HASH_SIZE
),
3922 make_float (DEFAULT_REHASH_SIZE
),
3923 make_float (DEFAULT_REHASH_THRESHOLD
),
3928 xpm_put_color_table_h (Lisp_Object color_table
,
3929 const unsigned char *chars_start
,
3933 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3934 EMACS_UINT hash_code
;
3935 Lisp_Object chars
= make_unibyte_string (chars_start
, chars_len
);
3937 hash_lookup (table
, chars
, &hash_code
);
3938 hash_put (table
, chars
, color
, hash_code
);
3942 xpm_get_color_table_h (Lisp_Object color_table
,
3943 const unsigned char *chars_start
,
3946 struct Lisp_Hash_Table
*table
= XHASH_TABLE (color_table
);
3948 hash_lookup (table
, make_unibyte_string (chars_start
, chars_len
), NULL
);
3950 return i
>= 0 ? HASH_VALUE (table
, i
) : Qnil
;
3953 enum xpm_color_key
{
3961 static const char xpm_color_key_strings
[][4] = {"s", "m", "g4", "g", "c"};
3964 xpm_str_to_color_key (const char *s
)
3968 for (i
= 0; i
< ARRAYELTS (xpm_color_key_strings
); i
++)
3969 if (strcmp (xpm_color_key_strings
[i
], s
) == 0)
3975 xpm_load_image (struct frame
*f
,
3977 const unsigned char *contents
,
3978 const unsigned char *end
)
3980 const unsigned char *s
= contents
, *beg
, *str
;
3981 unsigned char buffer
[BUFSIZ
];
3982 int width
, height
, x
, y
;
3983 int num_colors
, chars_per_pixel
;
3986 void (*put_color_table
) (Lisp_Object
, const unsigned char *, int, Lisp_Object
);
3987 Lisp_Object (*get_color_table
) (Lisp_Object
, const unsigned char *, int);
3988 Lisp_Object frame
, color_symbols
, color_table
;
3990 bool have_mask
= false;
3991 XImagePtr ximg
= NULL
, mask_img
= NULL
;
3994 LA1 = xpm_scan (&s, end, &beg, &len)
3996 #define expect(TOKEN) \
3999 if (LA1 != (TOKEN)) \
4005 #define expect_ident(IDENT) \
4006 if (LA1 == XPM_TK_IDENT \
4007 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4012 if (!(end
- s
>= 9 && memcmp (s
, "/* XPM */", 9) == 0))
4016 expect_ident ("static");
4017 expect_ident ("char");
4019 expect (XPM_TK_IDENT
);
4024 expect (XPM_TK_STRING
);
4027 memcpy (buffer
, beg
, len
);
4029 if (sscanf (buffer
, "%d %d %d %d", &width
, &height
,
4030 &num_colors
, &chars_per_pixel
) != 4
4031 || width
<= 0 || height
<= 0
4032 || num_colors
<= 0 || chars_per_pixel
<= 0)
4035 if (!check_image_size (f
, width
, height
))
4037 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
4041 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0)
4043 || !image_create_x_image_and_pixmap (f
, img
, width
, height
, 1,
4048 image_error ("Image too large", Qnil
, Qnil
);
4054 XSETFRAME (frame
, f
);
4055 if (!NILP (Fxw_display_color_p (frame
)))
4056 best_key
= XPM_COLOR_KEY_C
;
4057 else if (!NILP (Fx_display_grayscale_p (frame
)))
4058 best_key
= (XFASTINT (Fx_display_planes (frame
)) > 2
4059 ? XPM_COLOR_KEY_G
: XPM_COLOR_KEY_G4
);
4061 best_key
= XPM_COLOR_KEY_M
;
4063 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
4064 if (chars_per_pixel
== 1)
4065 color_table
= xpm_make_color_table_v (&put_color_table
,
4068 color_table
= xpm_make_color_table_h (&put_color_table
,
4071 while (num_colors
-- > 0)
4073 char *color
, *max_color
;
4074 int key
, next_key
, max_key
= 0;
4075 Lisp_Object symbol_color
= Qnil
, color_val
;
4078 expect (XPM_TK_STRING
);
4079 if (len
<= chars_per_pixel
|| len
>= BUFSIZ
+ chars_per_pixel
)
4081 memcpy (buffer
, beg
+ chars_per_pixel
, len
- chars_per_pixel
);
4082 buffer
[len
- chars_per_pixel
] = '\0';
4084 str
= strtok (buffer
, " \t");
4087 key
= xpm_str_to_color_key (str
);
4092 color
= strtok (NULL
, " \t");
4096 while ((str
= strtok (NULL
, " \t")) != NULL
)
4098 next_key
= xpm_str_to_color_key (str
);
4101 color
[strlen (color
)] = ' ';
4104 if (key
== XPM_COLOR_KEY_S
)
4106 if (NILP (symbol_color
))
4107 symbol_color
= build_string (color
);
4109 else if (max_key
< key
&& key
<= best_key
)
4119 if (!NILP (color_symbols
) && !NILP (symbol_color
))
4121 Lisp_Object specified_color
= Fassoc (symbol_color
, color_symbols
);
4123 if (CONSP (specified_color
) && STRINGP (XCDR (specified_color
)))
4125 if (xstrcasecmp (SSDATA (XCDR (specified_color
)), "None") == 0)
4127 else if (x_defined_color (f
, SSDATA (XCDR (specified_color
)),
4129 color_val
= make_number (cdef
.pixel
);
4132 if (NILP (color_val
) && max_key
> 0)
4134 if (xstrcasecmp (max_color
, "None") == 0)
4136 else if (x_defined_color (f
, max_color
, &cdef
, 0))
4137 color_val
= make_number (cdef
.pixel
);
4139 if (!NILP (color_val
))
4140 (*put_color_table
) (color_table
, beg
, chars_per_pixel
, color_val
);
4145 for (y
= 0; y
< height
; y
++)
4147 expect (XPM_TK_STRING
);
4149 if (len
< width
* chars_per_pixel
)
4151 for (x
= 0; x
< width
; x
++, str
+= chars_per_pixel
)
4153 Lisp_Object color_val
=
4154 (*get_color_table
) (color_table
, str
, chars_per_pixel
);
4156 XPutPixel (ximg
, x
, y
,
4157 (INTEGERP (color_val
) ? XINT (color_val
)
4158 : FRAME_FOREGROUND_PIXEL (f
)));
4160 XPutPixel (mask_img
, x
, y
,
4161 (!EQ (color_val
, Qt
) ? PIX_MASK_DRAW
4162 : (have_mask
= true, PIX_MASK_RETAIN
)));
4164 if (EQ (color_val
, Qt
))
4165 ns_set_alpha (ximg
, x
, y
, 0);
4173 img
->height
= height
;
4175 /* Maybe fill in the background field while we have ximg handy. */
4176 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
4177 IMAGE_BACKGROUND (img
, f
, ximg
);
4179 image_put_x_image (f
, img
, ximg
, 0);
4183 /* Fill in the background_transparent field while we have the
4185 image_background_transparent (img
, f
, mask_img
);
4187 image_put_x_image (f
, img
, mask_img
, 1);
4191 x_destroy_x_image (mask_img
);
4192 x_clear_image_1 (f
, img
, CLEAR_IMAGE_MASK
);
4198 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
4199 x_destroy_x_image (ximg
);
4200 x_destroy_x_image (mask_img
);
4201 x_clear_image (f
, img
);
4210 xpm_load (struct frame
*f
,
4214 Lisp_Object file_name
;
4216 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4217 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
4218 if (STRINGP (file_name
))
4221 unsigned char *contents
;
4224 file
= x_find_image_file (file_name
);
4225 if (!STRINGP (file
))
4227 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
4231 contents
= slurp_file (SSDATA (file
), &size
);
4232 if (contents
== NULL
)
4234 image_error ("Error loading XPM image `%s'", img
->spec
, Qnil
);
4238 success_p
= xpm_load_image (f
, img
, contents
, contents
+ size
);
4245 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
4246 if (!STRINGP (data
))
4248 image_error ("Invalid image data `%s'", data
, Qnil
);
4251 success_p
= xpm_load_image (f
, img
, SDATA (data
),
4252 SDATA (data
) + SBYTES (data
));
4258 #endif /* HAVE_NS && !HAVE_XPM */
4262 /***********************************************************************
4264 ***********************************************************************/
4266 #ifdef COLOR_TABLE_SUPPORT
4268 /* An entry in the color table mapping an RGB color to a pixel color. */
4273 unsigned long pixel
;
4275 /* Next in color table collision list. */
4276 struct ct_color
*next
;
4279 /* The bucket vector size to use. Must be prime. */
4283 /* Value is a hash of the RGB color given by R, G, and B. */
4285 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4287 /* The color hash table. */
4289 static struct ct_color
**ct_table
;
4291 /* Number of entries in the color table. */
4293 static int ct_colors_allocated
;
4296 ct_colors_allocated_max
=
4298 min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (unsigned long))
4301 /* Initialize the color table. */
4304 init_color_table (void)
4306 int size
= CT_SIZE
* sizeof (*ct_table
);
4307 ct_table
= xzalloc (size
);
4308 ct_colors_allocated
= 0;
4312 /* Free memory associated with the color table. */
4315 free_color_table (void)
4318 struct ct_color
*p
, *next
;
4320 for (i
= 0; i
< CT_SIZE
; ++i
)
4321 for (p
= ct_table
[i
]; p
; p
= next
)
4332 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4333 entry for that color already is in the color table, return the
4334 pixel color of that entry. Otherwise, allocate a new color for R,
4335 G, B, and make an entry in the color table. */
4337 static unsigned long
4338 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4340 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
4341 int i
= hash
% CT_SIZE
;
4343 Display_Info
*dpyinfo
;
4345 /* Handle TrueColor visuals specially, which improves performance by
4346 two orders of magnitude. Freeing colors on TrueColor visuals is
4347 a nop, and pixel colors specify RGB values directly. See also
4348 the Xlib spec, chapter 3.1. */
4349 dpyinfo
= FRAME_DISPLAY_INFO (f
);
4350 if (dpyinfo
->red_bits
> 0)
4352 unsigned long pr
, pg
, pb
;
4354 /* Apply gamma-correction like normal color allocation does. */
4358 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
4359 gamma_correct (f
, &color
);
4360 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
4363 /* Scale down RGB values to the visual's bits per RGB, and shift
4364 them to the right position in the pixel color. Note that the
4365 original RGB values are 16-bit values, as usual in X. */
4366 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
4367 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
4368 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
4370 /* Assemble the pixel color. */
4371 return pr
| pg
| pb
;
4374 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4375 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
4381 #ifdef HAVE_X_WINDOWS
4389 if (ct_colors_allocated_max
<= ct_colors_allocated
)
4390 return FRAME_FOREGROUND_PIXEL (f
);
4392 #ifdef HAVE_X_WINDOWS
4397 cmap
= FRAME_X_COLORMAP (f
);
4398 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4401 ++ct_colors_allocated
;
4402 p
= xmalloc (sizeof *p
);
4406 p
->pixel
= color
.pixel
;
4407 p
->next
= ct_table
[i
];
4411 return FRAME_FOREGROUND_PIXEL (f
);
4415 color
= PALETTERGB (r
, g
, b
);
4417 color
= RGB_TO_ULONG (r
, g
, b
);
4418 #endif /* HAVE_NTGUI */
4419 ++ct_colors_allocated
;
4420 p
= xmalloc (sizeof *p
);
4425 p
->next
= ct_table
[i
];
4427 #endif /* HAVE_X_WINDOWS */
4435 /* Look up pixel color PIXEL which is used on frame F in the color
4436 table. If not already present, allocate it. Value is PIXEL. */
4438 static unsigned long
4439 lookup_pixel_color (struct frame
*f
, unsigned long pixel
)
4441 int i
= pixel
% CT_SIZE
;
4444 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4445 if (p
->pixel
== pixel
)
4454 if (ct_colors_allocated_max
<= ct_colors_allocated
)
4455 return FRAME_FOREGROUND_PIXEL (f
);
4457 #ifdef HAVE_X_WINDOWS
4458 cmap
= FRAME_X_COLORMAP (f
);
4459 color
.pixel
= pixel
;
4460 x_query_color (f
, &color
);
4461 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4464 cmap
= DefaultColormapOfScreen (FRAME_X_SCREEN (f
));
4465 color
.pixel
= pixel
;
4466 XQueryColor (NULL
, cmap
, &color
);
4467 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
4469 #endif /* HAVE_X_WINDOWS */
4473 ++ct_colors_allocated
;
4475 p
= xmalloc (sizeof *p
);
4480 p
->next
= ct_table
[i
];
4484 return FRAME_FOREGROUND_PIXEL (f
);
4490 /* Value is a vector of all pixel colors contained in the color table,
4491 allocated via xmalloc. Set *N to the number of colors. */
4493 static unsigned long *
4494 colors_in_color_table (int *n
)
4498 unsigned long *colors
;
4500 if (ct_colors_allocated
== 0)
4507 colors
= xmalloc (ct_colors_allocated
* sizeof *colors
);
4508 *n
= ct_colors_allocated
;
4510 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
4511 for (p
= ct_table
[i
]; p
; p
= p
->next
)
4512 colors
[j
++] = p
->pixel
;
4518 #else /* COLOR_TABLE_SUPPORT */
4520 static unsigned long
4521 lookup_rgb_color (struct frame
*f
, int r
, int g
, int b
)
4523 unsigned long pixel
;
4526 pixel
= PALETTERGB (r
>> 8, g
>> 8, b
>> 8);
4527 #endif /* HAVE_NTGUI */
4530 pixel
= RGB_TO_ULONG (r
>> 8, g
>> 8, b
>> 8);
4531 #endif /* HAVE_NS */
4536 init_color_table (void)
4539 #endif /* COLOR_TABLE_SUPPORT */
4542 /***********************************************************************
4544 ***********************************************************************/
4546 /* Edge detection matrices for different edge-detection
4549 static int emboss_matrix
[9] = {
4551 2, -1, 0, /* y - 1 */
4553 0, 1, -2 /* y + 1 */
4556 static int laplace_matrix
[9] = {
4558 1, 0, 0, /* y - 1 */
4560 0, 0, -1 /* y + 1 */
4563 /* Value is the intensity of the color whose red/green/blue values
4566 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4569 /* On frame F, return an array of XColor structures describing image
4570 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4571 means also fill the red/green/blue members of the XColor
4572 structures. Value is a pointer to the array of XColors structures,
4573 allocated with xmalloc; it must be freed by the caller. */
4576 x_to_xcolors (struct frame
*f
, struct image
*img
, bool rgb_p
)
4580 XImagePtr_or_DC ximg
;
4583 #endif /* HAVE_NTGUI */
4585 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *colors
/ img
->width
< img
->height
)
4586 memory_full (SIZE_MAX
);
4587 colors
= xmalloc (sizeof *colors
* img
->width
* img
->height
);
4589 /* Get the X image or create a memory device context for IMG. */
4590 ximg
= image_get_x_image_or_dc (f
, img
, 0, &prev
);
4592 /* Fill the `pixel' members of the XColor array. I wished there
4593 were an easy and portable way to circumvent XGetPixel. */
4595 for (y
= 0; y
< img
->height
; ++y
)
4597 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
4599 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4600 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4602 x_query_colors (f
, row
, img
->width
);
4606 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4608 /* W32_TODO: palette support needed here? */
4609 p
->pixel
= GET_PIXEL (ximg
, x
, y
);
4612 p
->red
= RED16_FROM_ULONG (p
->pixel
);
4613 p
->green
= GREEN16_FROM_ULONG (p
->pixel
);
4614 p
->blue
= BLUE16_FROM_ULONG (p
->pixel
);
4617 #endif /* HAVE_X_WINDOWS */
4620 image_unget_x_image_or_dc (img
, 0, ximg
, prev
);
4627 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4628 created with CreateDIBSection, with the pointer to the bit values
4629 stored in ximg->data. */
4632 XPutPixel (XImagePtr ximg
, int x
, int y
, COLORREF color
)
4634 int width
= ximg
->info
.bmiHeader
.biWidth
;
4635 unsigned char * pixel
;
4637 /* True color images. */
4638 if (ximg
->info
.bmiHeader
.biBitCount
== 24)
4640 int rowbytes
= width
* 3;
4641 /* Ensure scanlines are aligned on 4 byte boundaries. */
4643 rowbytes
+= 4 - (rowbytes
% 4);
4645 pixel
= ximg
->data
+ y
* rowbytes
+ x
* 3;
4646 /* Windows bitmaps are in BGR order. */
4647 *pixel
= GetBValue (color
);
4648 *(pixel
+ 1) = GetGValue (color
);
4649 *(pixel
+ 2) = GetRValue (color
);
4651 /* Monochrome images. */
4652 else if (ximg
->info
.bmiHeader
.biBitCount
== 1)
4654 int rowbytes
= width
/ 8;
4655 /* Ensure scanlines are aligned on 4 byte boundaries. */
4657 rowbytes
+= 4 - (rowbytes
% 4);
4658 pixel
= ximg
->data
+ y
* rowbytes
+ x
/ 8;
4659 /* Filter out palette info. */
4660 if (color
& 0x00ffffff)
4661 *pixel
= *pixel
| (1 << x
% 8);
4663 *pixel
= *pixel
& ~(1 << x
% 8);
4666 image_error ("XPutPixel: palette image not supported", Qnil
, Qnil
);
4669 #endif /* HAVE_NTGUI */
4671 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4672 RGB members are set. F is the frame on which this all happens.
4673 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4676 x_from_xcolors (struct frame
*f
, struct image
*img
, XColor
*colors
)
4679 XImagePtr oimg
= NULL
;
4682 init_color_table ();
4684 x_clear_image_1 (f
, img
, CLEAR_IMAGE_PIXMAP
| CLEAR_IMAGE_COLORS
);
4685 image_create_x_image_and_pixmap (f
, img
, img
->width
, img
->height
, 0,
4688 for (y
= 0; y
< img
->height
; ++y
)
4689 for (x
= 0; x
< img
->width
; ++x
, ++p
)
4691 unsigned long pixel
;
4692 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
4693 XPutPixel (oimg
, x
, y
, pixel
);
4698 image_put_x_image (f
, img
, oimg
, 0);
4699 #ifdef COLOR_TABLE_SUPPORT
4700 img
->colors
= colors_in_color_table (&img
->ncolors
);
4701 free_color_table ();
4702 #endif /* COLOR_TABLE_SUPPORT */
4706 /* On frame F, perform edge-detection on image IMG.
4708 MATRIX is a nine-element array specifying the transformation
4709 matrix. See emboss_matrix for an example.
4711 COLOR_ADJUST is a color adjustment added to each pixel of the
4715 x_detect_edges (struct frame
*f
, struct image
*img
, int *matrix
, int color_adjust
)
4717 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4721 for (i
= sum
= 0; i
< 9; ++i
)
4722 sum
+= eabs (matrix
[i
]);
4724 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4726 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *new / img
->width
< img
->height
)
4727 memory_full (SIZE_MAX
);
4728 new = xmalloc (sizeof *new * img
->width
* img
->height
);
4730 for (y
= 0; y
< img
->height
; ++y
)
4732 p
= COLOR (new, 0, y
);
4733 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4734 p
= COLOR (new, img
->width
- 1, y
);
4735 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4738 for (x
= 1; x
< img
->width
- 1; ++x
)
4740 p
= COLOR (new, x
, 0);
4741 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4742 p
= COLOR (new, x
, img
->height
- 1);
4743 p
->red
= p
->green
= p
->blue
= 0xffff/2;
4746 for (y
= 1; y
< img
->height
- 1; ++y
)
4748 p
= COLOR (new, 1, y
);
4750 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
4752 int r
, g
, b
, yy
, xx
;
4755 for (yy
= y
- 1; yy
< y
+ 2; ++yy
)
4756 for (xx
= x
- 1; xx
< x
+ 2; ++xx
, ++i
)
4759 XColor
*t
= COLOR (colors
, xx
, yy
);
4760 r
+= matrix
[i
] * t
->red
;
4761 g
+= matrix
[i
] * t
->green
;
4762 b
+= matrix
[i
] * t
->blue
;
4765 r
= (r
/ sum
+ color_adjust
) & 0xffff;
4766 g
= (g
/ sum
+ color_adjust
) & 0xffff;
4767 b
= (b
/ sum
+ color_adjust
) & 0xffff;
4768 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
4773 x_from_xcolors (f
, img
, new);
4779 /* Perform the pre-defined `emboss' edge-detection on image IMG
4783 x_emboss (struct frame
*f
, struct image
*img
)
4785 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
4789 /* Transform image IMG which is used on frame F with a Laplace
4790 edge-detection algorithm. The result is an image that can be used
4791 to draw disabled buttons, for example. */
4794 x_laplace (struct frame
*f
, struct image
*img
)
4796 x_detect_edges (f
, img
, laplace_matrix
, 45000);
4800 /* Perform edge-detection on image IMG on frame F, with specified
4801 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4803 MATRIX must be either
4805 - a list of at least 9 numbers in row-major form
4806 - a vector of at least 9 numbers
4808 COLOR_ADJUST nil means use a default; otherwise it must be a
4812 x_edge_detection (struct frame
*f
, struct image
*img
, Lisp_Object matrix
,
4813 Lisp_Object color_adjust
)
4821 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
4822 ++i
, matrix
= XCDR (matrix
))
4823 trans
[i
] = XFLOATINT (XCAR (matrix
));
4825 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
4827 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
4828 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
4831 if (NILP (color_adjust
))
4832 color_adjust
= make_number (0xffff / 2);
4834 if (i
== 9 && NUMBERP (color_adjust
))
4835 x_detect_edges (f
, img
, trans
, XFLOATINT (color_adjust
));
4839 /* Transform image IMG on frame F so that it looks disabled. */
4842 x_disable_image (struct frame
*f
, struct image
*img
)
4844 Display_Info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
4846 int n_planes
= dpyinfo
->n_planes
* dpyinfo
->n_cbits
;
4848 int n_planes
= dpyinfo
->n_planes
;
4849 #endif /* HAVE_NTGUI */
4853 /* Color (or grayscale). Convert to gray, and equalize. Just
4854 drawing such images with a stipple can look very odd, so
4855 we're using this method instead. */
4856 XColor
*colors
= x_to_xcolors (f
, img
, 1);
4858 const int h
= 15000;
4859 const int l
= 30000;
4861 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
4865 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
4866 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
4867 p
->red
= p
->green
= p
->blue
= i2
;
4870 x_from_xcolors (f
, img
, colors
);
4873 /* Draw a cross over the disabled image, if we must or if we
4875 if (n_planes
< 2 || cross_disabled_images
)
4878 #ifndef HAVE_NS /* TODO: NS support, however this not needed for toolbars */
4880 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4882 Display
*dpy
= FRAME_X_DISPLAY (f
);
4885 image_sync_to_pixmaps (f
, img
);
4886 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
4887 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
4888 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
4889 img
->width
- 1, img
->height
- 1);
4890 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
4896 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
4897 XSetForeground (dpy
, gc
, MaskForeground (f
));
4898 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
4899 img
->width
- 1, img
->height
- 1);
4900 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
4904 #endif /* !HAVE_NS */
4909 hdc
= get_frame_dc (f
);
4910 bmpdc
= CreateCompatibleDC (hdc
);
4911 release_frame_dc (f
, hdc
);
4913 prev
= SelectObject (bmpdc
, img
->pixmap
);
4915 SetTextColor (bmpdc
, BLACK_PIX_DEFAULT (f
));
4916 MoveToEx (bmpdc
, 0, 0, NULL
);
4917 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4918 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4919 LineTo (bmpdc
, img
->width
- 1, 0);
4923 SelectObject (bmpdc
, img
->mask
);
4924 SetTextColor (bmpdc
, WHITE_PIX_DEFAULT (f
));
4925 MoveToEx (bmpdc
, 0, 0, NULL
);
4926 LineTo (bmpdc
, img
->width
- 1, img
->height
- 1);
4927 MoveToEx (bmpdc
, 0, img
->height
- 1, NULL
);
4928 LineTo (bmpdc
, img
->width
- 1, 0);
4930 SelectObject (bmpdc
, prev
);
4932 #endif /* HAVE_NTGUI */
4937 /* Build a mask for image IMG which is used on frame F. FILE is the
4938 name of an image file, for error messages. HOW determines how to
4939 determine the background color of IMG. If it is a list '(R G B)',
4940 with R, G, and B being integers >= 0, take that as the color of the
4941 background. Otherwise, determine the background color of IMG
4945 x_build_heuristic_mask (struct frame
*f
, struct image
*img
, Lisp_Object how
)
4947 XImagePtr_or_DC ximg
;
4954 #endif /* HAVE_NTGUI */
4956 bool use_img_background
;
4957 unsigned long bg
= 0;
4960 x_clear_image_1 (f
, img
, CLEAR_IMAGE_MASK
);
4964 /* Create an image and pixmap serving as mask. */
4965 if (! image_create_x_image_and_pixmap (f
, img
, img
->width
, img
->height
, 1,
4968 #endif /* !HAVE_NS */
4970 /* Create the bit array serving as mask. */
4971 row_width
= (img
->width
+ 7) / 8;
4972 mask_img
= xzalloc (row_width
* img
->height
);
4973 #endif /* HAVE_NTGUI */
4975 /* Get the X image or create a memory device context for IMG. */
4976 ximg
= image_get_x_image_or_dc (f
, img
, 0, &prev
);
4978 /* Determine the background color of ximg. If HOW is `(R G B)'
4979 take that as color. Otherwise, use the image's background color. */
4980 use_img_background
= 1;
4986 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
4988 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
4992 if (i
== 3 && NILP (how
))
4994 char color_name
[30];
4995 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
4998 0x00ffffff & /* Filter out palette info. */
4999 #endif /* HAVE_NTGUI */
5000 x_alloc_image_color (f
, img
, build_string (color_name
), 0));
5001 use_img_background
= 0;
5005 if (use_img_background
)
5006 bg
= four_corners_best (ximg
, img
->corners
, img
->width
, img
->height
);
5008 /* Set all bits in mask_img to 1 whose color in ximg is different
5009 from the background color bg. */
5011 for (y
= 0; y
< img
->height
; ++y
)
5012 for (x
= 0; x
< img
->width
; ++x
)
5014 XPutPixel (mask_img
, x
, y
, (XGetPixel (ximg
, x
, y
) != bg
5015 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
));
5017 if (XGetPixel (ximg
, x
, y
) == bg
)
5018 ns_set_alpha (ximg
, x
, y
, 0);
5019 #endif /* HAVE_NS */
5021 /* Fill in the background_transparent field while we have the mask handy. */
5022 image_background_transparent (img
, f
, mask_img
);
5024 /* Put mask_img into the image. */
5025 image_put_x_image (f
, img
, mask_img
, 1);
5026 #endif /* !HAVE_NS */
5028 for (y
= 0; y
< img
->height
; ++y
)
5029 for (x
= 0; x
< img
->width
; ++x
)
5031 COLORREF p
= GetPixel (ximg
, x
, y
);
5033 mask_img
[y
* row_width
+ x
/ 8] |= 1 << (x
% 8);
5036 /* Create the mask image. */
5037 img
->mask
= w32_create_pixmap_from_bitmap_data (img
->width
, img
->height
,
5039 /* Fill in the background_transparent field while we have the mask handy. */
5040 SelectObject (ximg
, img
->mask
);
5041 image_background_transparent (img
, f
, ximg
);
5043 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5045 #endif /* HAVE_NTGUI */
5047 image_unget_x_image_or_dc (img
, 0, ximg
, prev
);
5051 /***********************************************************************
5052 PBM (mono, gray, color)
5053 ***********************************************************************/
5055 static bool pbm_image_p (Lisp_Object object
);
5056 static bool pbm_load (struct frame
*f
, struct image
*img
);
5058 /* The symbol `pbm' identifying images of this type. */
5060 static Lisp_Object Qpbm
;
5062 /* Indices of image specification fields in gs_format, below. */
5064 enum pbm_keyword_index
5080 /* Vector of image_keyword structures describing the format
5081 of valid user-defined image specifications. */
5083 static const struct image_keyword pbm_format
[PBM_LAST
] =
5085 {":type", IMAGE_SYMBOL_VALUE
, 1},
5086 {":file", IMAGE_STRING_VALUE
, 0},
5087 {":data", IMAGE_STRING_VALUE
, 0},
5088 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5089 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
5090 {":relief", IMAGE_INTEGER_VALUE
, 0},
5091 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5092 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5093 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5094 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5095 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5098 /* Structure describing the image type `pbm'. */
5100 static struct image_type pbm_type
=
5111 /* Return true if OBJECT is a valid PBM image specification. */
5114 pbm_image_p (Lisp_Object object
)
5116 struct image_keyword fmt
[PBM_LAST
];
5118 memcpy (fmt
, pbm_format
, sizeof fmt
);
5120 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
5123 /* Must specify either :data or :file. */
5124 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
5128 /* Get next char skipping comments in Netpbm header. Returns -1 at
5132 pbm_next_char (unsigned char **s
, unsigned char *end
)
5136 while (*s
< end
&& (c
= *(*s
)++, c
== '#'))
5138 /* Skip to the next line break. */
5139 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n' && c
!= '\r'))
5149 /* Scan a decimal number from *S and return it. Advance *S while
5150 reading the number. END is the end of the string. Value is -1 at
5154 pbm_scan_number (unsigned char **s
, unsigned char *end
)
5156 int c
= 0, val
= -1;
5158 /* Skip white-space. */
5159 while ((c
= pbm_next_char (s
, end
)) != -1 && c_isspace (c
))
5164 /* Read decimal number. */
5166 while ((c
= pbm_next_char (s
, end
)) != -1 && c_isdigit (c
))
5167 val
= 10 * val
+ c
- '0';
5174 /* Load PBM image IMG for use on frame F. */
5177 pbm_load (struct frame
*f
, struct image
*img
)
5181 int width
, height
, max_color_idx
= 0;
5183 Lisp_Object file
, specified_file
;
5184 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
5185 unsigned char *contents
= NULL
;
5186 unsigned char *end
, *p
;
5189 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5191 if (STRINGP (specified_file
))
5193 file
= x_find_image_file (specified_file
);
5194 if (!STRINGP (file
))
5196 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5200 contents
= slurp_file (SSDATA (file
), &size
);
5201 if (contents
== NULL
)
5203 image_error ("Error reading `%s'", file
, Qnil
);
5208 end
= contents
+ size
;
5213 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5214 if (!STRINGP (data
))
5216 image_error ("Invalid image data `%s'", data
, Qnil
);
5220 end
= p
+ SBYTES (data
);
5223 /* Check magic number. */
5224 if (end
- p
< 2 || *p
++ != 'P')
5226 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5229 img
->pixmap
= NO_PIXMAP
;
5236 raw_p
= 0, type
= PBM_MONO
;
5240 raw_p
= 0, type
= PBM_GRAY
;
5244 raw_p
= 0, type
= PBM_COLOR
;
5248 raw_p
= 1, type
= PBM_MONO
;
5252 raw_p
= 1, type
= PBM_GRAY
;
5256 raw_p
= 1, type
= PBM_COLOR
;
5260 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
5264 /* Read width, height, maximum color-component. Characters
5265 starting with `#' up to the end of a line are ignored. */
5266 width
= pbm_scan_number (&p
, end
);
5267 height
= pbm_scan_number (&p
, end
);
5269 if (type
!= PBM_MONO
)
5271 max_color_idx
= pbm_scan_number (&p
, end
);
5272 if (max_color_idx
> 65535 || max_color_idx
< 0)
5274 image_error ("Unsupported maximum PBM color value", Qnil
, Qnil
);
5279 if (!check_image_size (f
, width
, height
))
5281 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5285 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
5288 /* Initialize the color hash table. */
5289 init_color_table ();
5291 if (type
== PBM_MONO
)
5294 struct image_keyword fmt
[PBM_LAST
];
5295 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
5296 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
5298 /* Parse the image specification. */
5299 memcpy (fmt
, pbm_format
, sizeof fmt
);
5300 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
5302 /* Get foreground and background colors, maybe allocate colors. */
5303 if (fmt
[PBM_FOREGROUND
].count
5304 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
5305 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
5306 if (fmt
[PBM_BACKGROUND
].count
5307 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
5309 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
5310 img
->background
= bg
;
5311 img
->background_valid
= 1;
5314 for (y
= 0; y
< height
; ++y
)
5315 for (x
= 0; x
< width
; ++x
)
5323 x_destroy_x_image (ximg
);
5324 x_clear_image (f
, img
);
5325 image_error ("Invalid image size in image `%s'",
5335 g
= pbm_scan_number (&p
, end
);
5337 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
5342 int expected_size
= height
* width
;
5343 if (max_color_idx
> 255)
5345 if (type
== PBM_COLOR
)
5348 if (raw_p
&& p
+ expected_size
> end
)
5350 x_destroy_x_image (ximg
);
5351 x_clear_image (f
, img
);
5352 image_error ("Invalid image size in image `%s'",
5357 for (y
= 0; y
< height
; ++y
)
5358 for (x
= 0; x
< width
; ++x
)
5362 if (type
== PBM_GRAY
&& raw_p
)
5365 if (max_color_idx
> 255)
5366 r
= g
= b
= r
* 256 + *p
++;
5368 else if (type
== PBM_GRAY
)
5369 r
= g
= b
= pbm_scan_number (&p
, end
);
5373 if (max_color_idx
> 255)
5376 if (max_color_idx
> 255)
5379 if (max_color_idx
> 255)
5384 r
= pbm_scan_number (&p
, end
);
5385 g
= pbm_scan_number (&p
, end
);
5386 b
= pbm_scan_number (&p
, end
);
5389 if (r
< 0 || g
< 0 || b
< 0)
5391 x_destroy_x_image (ximg
);
5392 image_error ("Invalid pixel value in image `%s'",
5397 /* RGB values are now in the range 0..max_color_idx.
5398 Scale this to the range 0..0xffff supported by X. */
5399 r
= (double) r
* 65535 / max_color_idx
;
5400 g
= (double) g
* 65535 / max_color_idx
;
5401 b
= (double) b
* 65535 / max_color_idx
;
5402 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5406 #ifdef COLOR_TABLE_SUPPORT
5407 /* Store in IMG->colors the colors allocated for the image, and
5408 free the color table. */
5409 img
->colors
= colors_in_color_table (&img
->ncolors
);
5410 free_color_table ();
5411 #endif /* COLOR_TABLE_SUPPORT */
5414 img
->height
= height
;
5416 /* Maybe fill in the background field while we have ximg handy. */
5418 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
5419 /* Casting avoids a GCC warning. */
5420 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
5422 /* Put ximg into the image. */
5423 image_put_x_image (f
, img
, ximg
, 0);
5425 /* X and W32 versions did it here, MAC version above. ++kfs
5427 img->height = height; */
5434 /***********************************************************************
5436 ***********************************************************************/
5438 #if defined (HAVE_PNG) || defined (HAVE_NS)
5440 /* Function prototypes. */
5442 static bool png_image_p (Lisp_Object object
);
5443 static bool png_load (struct frame
*f
, struct image
*img
);
5445 /* The symbol `png' identifying images of this type. */
5447 static Lisp_Object Qpng
;
5449 /* Indices of image specification fields in png_format, below. */
5451 enum png_keyword_index
5466 /* Vector of image_keyword structures describing the format
5467 of valid user-defined image specifications. */
5469 static const struct image_keyword png_format
[PNG_LAST
] =
5471 {":type", IMAGE_SYMBOL_VALUE
, 1},
5472 {":data", IMAGE_STRING_VALUE
, 0},
5473 {":file", IMAGE_STRING_VALUE
, 0},
5474 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5475 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
5476 {":relief", IMAGE_INTEGER_VALUE
, 0},
5477 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5478 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5479 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5480 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
5483 #if defined HAVE_NTGUI && defined WINDOWSNT
5484 static bool init_png_functions (void);
5486 #define init_png_functions NULL
5489 /* Structure describing the image type `png'. */
5491 static struct image_type png_type
=
5501 /* Return true if OBJECT is a valid PNG image specification. */
5504 png_image_p (Lisp_Object object
)
5506 struct image_keyword fmt
[PNG_LAST
];
5507 memcpy (fmt
, png_format
, sizeof fmt
);
5509 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
5512 /* Must specify either the :data or :file keyword. */
5513 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
5516 #endif /* HAVE_PNG || HAVE_NS */
5519 #if defined HAVE_PNG && !defined HAVE_NS
5522 /* PNG library details. */
5524 DEF_IMGLIB_FN (png_voidp
, png_get_io_ptr
, (png_structp
));
5525 DEF_IMGLIB_FN (int, png_sig_cmp
, (png_bytep
, png_size_t
, png_size_t
));
5526 DEF_IMGLIB_FN (png_structp
, png_create_read_struct
, (png_const_charp
, png_voidp
,
5527 png_error_ptr
, png_error_ptr
));
5528 DEF_IMGLIB_FN (png_infop
, png_create_info_struct
, (png_structp
));
5529 DEF_IMGLIB_FN (void, png_destroy_read_struct
, (png_structpp
, png_infopp
, png_infopp
));
5530 DEF_IMGLIB_FN (void, png_set_read_fn
, (png_structp
, png_voidp
, png_rw_ptr
));
5531 DEF_IMGLIB_FN (void, png_set_sig_bytes
, (png_structp
, int));
5532 DEF_IMGLIB_FN (void, png_read_info
, (png_structp
, png_infop
));
5533 DEF_IMGLIB_FN (png_uint_32
, png_get_IHDR
, (png_structp
, png_infop
,
5534 png_uint_32
*, png_uint_32
*,
5535 int *, int *, int *, int *, int *));
5536 DEF_IMGLIB_FN (png_uint_32
, png_get_valid
, (png_structp
, png_infop
, png_uint_32
));
5537 DEF_IMGLIB_FN (void, png_set_strip_16
, (png_structp
));
5538 DEF_IMGLIB_FN (void, png_set_expand
, (png_structp
));
5539 DEF_IMGLIB_FN (void, png_set_gray_to_rgb
, (png_structp
));
5540 DEF_IMGLIB_FN (void, png_set_background
, (png_structp
, png_color_16p
,
5542 DEF_IMGLIB_FN (png_uint_32
, png_get_bKGD
, (png_structp
, png_infop
, png_color_16p
*));
5543 DEF_IMGLIB_FN (void, png_read_update_info
, (png_structp
, png_infop
));
5544 DEF_IMGLIB_FN (png_byte
, png_get_channels
, (png_structp
, png_infop
));
5545 DEF_IMGLIB_FN (png_size_t
, png_get_rowbytes
, (png_structp
, png_infop
));
5546 DEF_IMGLIB_FN (void, png_read_image
, (png_structp
, png_bytepp
));
5547 DEF_IMGLIB_FN (void, png_read_end
, (png_structp
, png_infop
));
5548 DEF_IMGLIB_FN (void, png_error
, (png_structp
, png_const_charp
));
5550 #if (PNG_LIBPNG_VER >= 10500)
5551 DEF_IMGLIB_FN (void, png_longjmp
, (png_structp
, int)) PNG_NORETURN
;
5552 DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn
, (png_structp
, png_longjmp_ptr
, size_t));
5553 #endif /* libpng version >= 1.5 */
5556 init_png_functions (void)
5560 if (!(library
= w32_delayed_load (Qpng
)))
5563 LOAD_IMGLIB_FN (library
, png_get_io_ptr
);
5564 LOAD_IMGLIB_FN (library
, png_sig_cmp
);
5565 LOAD_IMGLIB_FN (library
, png_create_read_struct
);
5566 LOAD_IMGLIB_FN (library
, png_create_info_struct
);
5567 LOAD_IMGLIB_FN (library
, png_destroy_read_struct
);
5568 LOAD_IMGLIB_FN (library
, png_set_read_fn
);
5569 LOAD_IMGLIB_FN (library
, png_set_sig_bytes
);
5570 LOAD_IMGLIB_FN (library
, png_read_info
);
5571 LOAD_IMGLIB_FN (library
, png_get_IHDR
);
5572 LOAD_IMGLIB_FN (library
, png_get_valid
);
5573 LOAD_IMGLIB_FN (library
, png_set_strip_16
);
5574 LOAD_IMGLIB_FN (library
, png_set_expand
);
5575 LOAD_IMGLIB_FN (library
, png_set_gray_to_rgb
);
5576 LOAD_IMGLIB_FN (library
, png_set_background
);
5577 LOAD_IMGLIB_FN (library
, png_get_bKGD
);
5578 LOAD_IMGLIB_FN (library
, png_read_update_info
);
5579 LOAD_IMGLIB_FN (library
, png_get_channels
);
5580 LOAD_IMGLIB_FN (library
, png_get_rowbytes
);
5581 LOAD_IMGLIB_FN (library
, png_read_image
);
5582 LOAD_IMGLIB_FN (library
, png_read_end
);
5583 LOAD_IMGLIB_FN (library
, png_error
);
5585 #if (PNG_LIBPNG_VER >= 10500)
5586 LOAD_IMGLIB_FN (library
, png_longjmp
);
5587 LOAD_IMGLIB_FN (library
, png_set_longjmp_fn
);
5588 #endif /* libpng version >= 1.5 */
5594 #define fn_png_get_io_ptr png_get_io_ptr
5595 #define fn_png_sig_cmp png_sig_cmp
5596 #define fn_png_create_read_struct png_create_read_struct
5597 #define fn_png_create_info_struct png_create_info_struct
5598 #define fn_png_destroy_read_struct png_destroy_read_struct
5599 #define fn_png_set_read_fn png_set_read_fn
5600 #define fn_png_set_sig_bytes png_set_sig_bytes
5601 #define fn_png_read_info png_read_info
5602 #define fn_png_get_IHDR png_get_IHDR
5603 #define fn_png_get_valid png_get_valid
5604 #define fn_png_set_strip_16 png_set_strip_16
5605 #define fn_png_set_expand png_set_expand
5606 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5607 #define fn_png_set_background png_set_background
5608 #define fn_png_get_bKGD png_get_bKGD
5609 #define fn_png_read_update_info png_read_update_info
5610 #define fn_png_get_channels png_get_channels
5611 #define fn_png_get_rowbytes png_get_rowbytes
5612 #define fn_png_read_image png_read_image
5613 #define fn_png_read_end png_read_end
5614 #define fn_png_error png_error
5616 #if (PNG_LIBPNG_VER >= 10500)
5617 #define fn_png_longjmp png_longjmp
5618 #define fn_png_set_longjmp_fn png_set_longjmp_fn
5619 #endif /* libpng version >= 1.5 */
5621 #endif /* WINDOWSNT */
5623 /* Fast implementations of setjmp and longjmp. Although setjmp and longjmp
5624 will do, POSIX _setjmp and _longjmp (if available) are often faster.
5625 Do not use sys_setjmp, as PNG supports only jmp_buf.
5626 It's OK if the longjmp substitute restores the signal mask. */
5628 # define FAST_SETJMP(j) _setjmp (j)
5629 # define FAST_LONGJMP _longjmp
5631 # define FAST_SETJMP(j) setjmp (j)
5632 # define FAST_LONGJMP longjmp
5635 #if PNG_LIBPNG_VER < 10500
5636 #define PNG_LONGJMP(ptr) FAST_LONGJMP ((ptr)->jmpbuf, 1)
5637 #define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
5639 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908) */
5640 #define PNG_LONGJMP(ptr) fn_png_longjmp (ptr, 1)
5641 #define PNG_JMPBUF(ptr) \
5642 (*fn_png_set_longjmp_fn (ptr, FAST_LONGJMP, sizeof (jmp_buf)))
5645 /* Error and warning handlers installed when the PNG library
5648 static _Noreturn
void
5649 my_png_error (png_struct
*png_ptr
, const char *msg
)
5651 eassert (png_ptr
!= NULL
);
5652 /* Avoid compiler warning about deprecated direct access to
5653 png_ptr's fields in libpng versions 1.4.x. */
5654 image_error ("PNG error: %s", build_string (msg
), Qnil
);
5655 PNG_LONGJMP (png_ptr
);
5660 my_png_warning (png_struct
*png_ptr
, const char *msg
)
5662 eassert (png_ptr
!= NULL
);
5663 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
5666 /* Memory source for PNG decoding. */
5668 struct png_memory_storage
5670 unsigned char *bytes
; /* The data */
5671 ptrdiff_t len
; /* How big is it? */
5672 ptrdiff_t index
; /* Where are we? */
5676 /* Function set as reader function when reading PNG image from memory.
5677 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5678 bytes from the input to DATA. */
5681 png_read_from_memory (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5683 struct png_memory_storage
*tbr
= fn_png_get_io_ptr (png_ptr
);
5685 if (length
> tbr
->len
- tbr
->index
)
5686 fn_png_error (png_ptr
, "Read error");
5688 memcpy (data
, tbr
->bytes
+ tbr
->index
, length
);
5689 tbr
->index
= tbr
->index
+ length
;
5693 /* Function set as reader function when reading PNG image from a file.
5694 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5695 bytes from the input to DATA. */
5698 png_read_from_file (png_structp png_ptr
, png_bytep data
, png_size_t length
)
5700 FILE *fp
= fn_png_get_io_ptr (png_ptr
);
5702 if (fread (data
, 1, length
, fp
) < length
)
5703 fn_png_error (png_ptr
, "Read error");
5707 /* Load PNG image IMG for use on frame F. Value is true if
5710 struct png_load_context
5712 /* These are members so that longjmp doesn't munge local variables. */
5713 png_struct
*png_ptr
;
5722 png_load_body (struct frame
*f
, struct image
*img
, struct png_load_context
*c
)
5724 Lisp_Object file
, specified_file
;
5725 Lisp_Object specified_data
;
5728 XImagePtr ximg
, mask_img
= NULL
;
5729 png_struct
*png_ptr
;
5730 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
5733 png_byte
*pixels
= NULL
;
5734 png_byte
**rows
= NULL
;
5735 png_uint_32 width
, height
;
5736 int bit_depth
, color_type
, interlace_type
;
5738 png_uint_32 row_bytes
;
5740 struct png_memory_storage tbr
; /* Data to be read */
5742 /* Find out what file to load. */
5743 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
5744 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5746 if (NILP (specified_data
))
5748 file
= x_find_image_file (specified_file
);
5749 if (!STRINGP (file
))
5751 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
5755 /* Open the image file. */
5756 fp
= emacs_fopen (SSDATA (file
), "rb");
5759 image_error ("Cannot open image file `%s'", file
, Qnil
);
5763 /* Check PNG signature. */
5764 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
5765 || fn_png_sig_cmp (sig
, 0, sizeof sig
))
5768 image_error ("Not a PNG file: `%s'", file
, Qnil
);
5774 if (!STRINGP (specified_data
))
5776 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
5780 /* Read from memory. */
5781 tbr
.bytes
= SDATA (specified_data
);
5782 tbr
.len
= SBYTES (specified_data
);
5785 /* Check PNG signature. */
5786 if (tbr
.len
< sizeof sig
5787 || fn_png_sig_cmp (tbr
.bytes
, 0, sizeof sig
))
5789 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
5793 /* Need to skip past the signature. */
5794 tbr
.bytes
+= sizeof (sig
);
5797 /* Initialize read and info structs for PNG lib. */
5798 png_ptr
= fn_png_create_read_struct (PNG_LIBPNG_VER_STRING
,
5803 info_ptr
= fn_png_create_info_struct (png_ptr
);
5804 end_info
= fn_png_create_info_struct (png_ptr
);
5807 c
->png_ptr
= png_ptr
;
5808 c
->info_ptr
= info_ptr
;
5809 c
->end_info
= end_info
;
5814 if (! (info_ptr
&& end_info
))
5816 fn_png_destroy_read_struct (&c
->png_ptr
, &c
->info_ptr
, &c
->end_info
);
5821 if (fp
) fclose (fp
);
5825 /* Set error jump-back. We come back here when the PNG library
5826 detects an error. */
5827 if (FAST_SETJMP (PNG_JMPBUF (png_ptr
)))
5831 fn_png_destroy_read_struct (&c
->png_ptr
, &c
->info_ptr
, &c
->end_info
);
5839 /* Silence a bogus diagnostic; see GCC bug 54561. */
5840 IF_LINT (fp
= c
->fp
);
5842 /* Read image info. */
5843 if (!NILP (specified_data
))
5844 fn_png_set_read_fn (png_ptr
, &tbr
, png_read_from_memory
);
5846 fn_png_set_read_fn (png_ptr
, fp
, png_read_from_file
);
5848 fn_png_set_sig_bytes (png_ptr
, sizeof sig
);
5849 fn_png_read_info (png_ptr
, info_ptr
);
5850 fn_png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
5851 &interlace_type
, NULL
, NULL
);
5853 if (! (width
<= INT_MAX
&& height
<= INT_MAX
5854 && check_image_size (f
, width
, height
)))
5856 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
5860 /* Create the X image and pixmap now, so that the work below can be
5861 omitted if the image is too large for X. */
5862 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
5865 /* If image contains simply transparency data, we prefer to
5866 construct a clipping mask. */
5867 if (fn_png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
5872 /* This function is easier to write if we only have to handle
5873 one data format: RGB or RGBA with 8 bits per channel. Let's
5874 transform other formats into that format. */
5876 /* Strip more than 8 bits per channel. */
5877 if (bit_depth
== 16)
5878 fn_png_set_strip_16 (png_ptr
);
5880 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5882 fn_png_set_expand (png_ptr
);
5884 /* Convert grayscale images to RGB. */
5885 if (color_type
== PNG_COLOR_TYPE_GRAY
5886 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
5887 fn_png_set_gray_to_rgb (png_ptr
);
5889 /* Handle alpha channel by combining the image with a background
5890 color. Do this only if a real alpha channel is supplied. For
5891 simple transparency, we prefer a clipping mask. */
5894 /* png_color_16 *image_bg; */
5895 Lisp_Object specified_bg
5896 = image_spec_value (img
->spec
, QCbackground
, NULL
);
5899 /* If the user specified a color, try to use it; if not, use the
5900 current frame background, ignoring any default background
5901 color set by the image. */
5902 if (STRINGP (specified_bg
)
5903 ? x_defined_color (f
, SSDATA (specified_bg
), &color
, false)
5904 : (x_query_frame_background_color (f
, &color
), true))
5905 /* The user specified `:background', use that. */
5907 int shift
= bit_depth
== 16 ? 0 : 8;
5908 png_color_16 bg
= { 0 };
5909 bg
.red
= color
.red
>> shift
;
5910 bg
.green
= color
.green
>> shift
;
5911 bg
.blue
= color
.blue
>> shift
;
5913 fn_png_set_background (png_ptr
, &bg
,
5914 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
5918 /* Update info structure. */
5919 fn_png_read_update_info (png_ptr
, info_ptr
);
5921 /* Get number of channels. Valid values are 1 for grayscale images
5922 and images with a palette, 2 for grayscale images with transparency
5923 information (alpha channel), 3 for RGB images, and 4 for RGB
5924 images with alpha channel, i.e. RGBA. If conversions above were
5925 sufficient we should only have 3 or 4 channels here. */
5926 channels
= fn_png_get_channels (png_ptr
, info_ptr
);
5927 eassert (channels
== 3 || channels
== 4);
5929 /* Number of bytes needed for one row of the image. */
5930 row_bytes
= fn_png_get_rowbytes (png_ptr
, info_ptr
);
5932 /* Allocate memory for the image. */
5933 if (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *rows
< height
5934 || min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *pixels
/ height
< row_bytes
)
5935 memory_full (SIZE_MAX
);
5936 c
->pixels
= pixels
= xmalloc (sizeof *pixels
* row_bytes
* height
);
5937 c
->rows
= rows
= xmalloc (height
* sizeof *rows
);
5938 for (i
= 0; i
< height
; ++i
)
5939 rows
[i
] = pixels
+ i
* row_bytes
;
5941 /* Read the entire image. */
5942 fn_png_read_image (png_ptr
, rows
);
5943 fn_png_read_end (png_ptr
, info_ptr
);
5950 /* Create an image and pixmap serving as mask if the PNG image
5951 contains an alpha channel. */
5954 && !image_create_x_image_and_pixmap (f
, img
, width
, height
, 1,
5957 x_destroy_x_image (ximg
);
5958 x_clear_image_1 (f
, img
, CLEAR_IMAGE_PIXMAP
);
5962 /* Fill the X image and mask from PNG data. */
5963 init_color_table ();
5965 for (y
= 0; y
< height
; ++y
)
5967 png_byte
*p
= rows
[y
];
5969 for (x
= 0; x
< width
; ++x
)
5976 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
5977 /* An alpha channel, aka mask channel, associates variable
5978 transparency with an image. Where other image formats
5979 support binary transparency---fully transparent or fully
5980 opaque---PNG allows up to 254 levels of partial transparency.
5981 The PNG library implements partial transparency by combining
5982 the image with a specified background color.
5984 I'm not sure how to handle this here nicely: because the
5985 background on which the image is displayed may change, for
5986 real alpha channel support, it would be necessary to create
5987 a new image for each possible background.
5989 What I'm doing now is that a mask is created if we have
5990 boolean transparency information. Otherwise I'm using
5991 the frame's background color to combine the image with. */
5996 XPutPixel (mask_img
, x
, y
, *p
> 0 ? PIX_MASK_DRAW
: PIX_MASK_RETAIN
);
6002 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6003 /* Set IMG's background color from the PNG image, unless the user
6007 if (fn_png_get_bKGD (png_ptr
, info_ptr
, &bg
))
6009 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
6010 img
->background_valid
= 1;
6014 #ifdef COLOR_TABLE_SUPPORT
6015 /* Remember colors allocated for this image. */
6016 img
->colors
= colors_in_color_table (&img
->ncolors
);
6017 free_color_table ();
6018 #endif /* COLOR_TABLE_SUPPORT */
6021 fn_png_destroy_read_struct (&c
->png_ptr
, &c
->info_ptr
, &c
->end_info
);
6026 img
->height
= height
;
6028 /* Maybe fill in the background field while we have ximg handy.
6029 Casting avoids a GCC warning. */
6030 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6032 /* Put ximg into the image. */
6033 image_put_x_image (f
, img
, ximg
, 0);
6035 /* Same for the mask. */
6038 /* Fill in the background_transparent field while we have the
6039 mask handy. Casting avoids a GCC warning. */
6040 image_background_transparent (img
, f
, (XImagePtr_or_DC
)mask_img
);
6042 image_put_x_image (f
, img
, mask_img
, 1);
6049 png_load (struct frame
*f
, struct image
*img
)
6051 struct png_load_context c
;
6052 return png_load_body (f
, img
, &c
);
6055 #elif defined HAVE_NS
6058 png_load (struct frame
*f
, struct image
*img
)
6060 return ns_load_image (f
, img
,
6061 image_spec_value (img
->spec
, QCfile
, NULL
),
6062 image_spec_value (img
->spec
, QCdata
, NULL
));
6065 #endif /* HAVE_NS */
6069 /***********************************************************************
6071 ***********************************************************************/
6073 #if defined (HAVE_JPEG) || defined (HAVE_NS)
6075 static bool jpeg_image_p (Lisp_Object object
);
6076 static bool jpeg_load (struct frame
*f
, struct image
*img
);
6078 /* The symbol `jpeg' identifying images of this type. */
6080 static Lisp_Object Qjpeg
;
6082 /* Indices of image specification fields in gs_format, below. */
6084 enum jpeg_keyword_index
6093 JPEG_HEURISTIC_MASK
,
6099 /* Vector of image_keyword structures describing the format
6100 of valid user-defined image specifications. */
6102 static const struct image_keyword jpeg_format
[JPEG_LAST
] =
6104 {":type", IMAGE_SYMBOL_VALUE
, 1},
6105 {":data", IMAGE_STRING_VALUE
, 0},
6106 {":file", IMAGE_STRING_VALUE
, 0},
6107 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6108 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
6109 {":relief", IMAGE_INTEGER_VALUE
, 0},
6110 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6111 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6112 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6113 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6116 #if defined HAVE_NTGUI && defined WINDOWSNT
6117 static bool init_jpeg_functions (void);
6119 #define init_jpeg_functions NULL
6122 /* Structure describing the image type `jpeg'. */
6124 static struct image_type jpeg_type
=
6130 init_jpeg_functions
,
6134 /* Return true if OBJECT is a valid JPEG image specification. */
6137 jpeg_image_p (Lisp_Object object
)
6139 struct image_keyword fmt
[JPEG_LAST
];
6141 memcpy (fmt
, jpeg_format
, sizeof fmt
);
6143 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
6146 /* Must specify either the :data or :file keyword. */
6147 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
6150 #endif /* HAVE_JPEG || HAVE_NS */
6154 /* Work around a warning about HAVE_STDLIB_H being redefined in
6156 #ifdef HAVE_STDLIB_H
6157 #undef HAVE_STDLIB_H
6158 #endif /* HAVE_STLIB_H */
6160 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6161 /* In older releases of the jpeg library, jpeglib.h will define boolean
6162 differently depending on __WIN32__, so make sure it is defined. */
6166 /* rpcndr.h (via windows.h) and jpeglib.h both define boolean types.
6167 Some versions of jpeglib try to detect whether rpcndr.h is loaded,
6168 using the Windows boolean type instead of the jpeglib boolean type
6169 if so. Cygwin jpeglib, however, doesn't try to detect whether its
6170 headers are included along with windows.h, so under Cygwin, jpeglib
6171 attempts to define a conflicting boolean type. Worse, forcing
6172 Cygwin jpeglib headers to use the Windows boolean type doesn't work
6173 because it created an ABI incompatibility between the
6174 already-compiled jpeg library and the header interface definition.
6176 The best we can do is to define jpeglib's boolean type to a
6177 different name. This name, jpeg_boolean, remains in effect through
6178 the rest of image.c.
6180 #if defined CYGWIN && defined HAVE_NTGUI
6181 #define boolean jpeg_boolean
6183 #include <jpeglib.h>
6188 /* JPEG library details. */
6189 DEF_IMGLIB_FN (void, jpeg_CreateDecompress
, (j_decompress_ptr
, int, size_t));
6190 DEF_IMGLIB_FN (boolean
, jpeg_start_decompress
, (j_decompress_ptr
));
6191 DEF_IMGLIB_FN (boolean
, jpeg_finish_decompress
, (j_decompress_ptr
));
6192 DEF_IMGLIB_FN (void, jpeg_destroy_decompress
, (j_decompress_ptr
));
6193 DEF_IMGLIB_FN (int, jpeg_read_header
, (j_decompress_ptr
, boolean
));
6194 DEF_IMGLIB_FN (JDIMENSION
, jpeg_read_scanlines
, (j_decompress_ptr
, JSAMPARRAY
, JDIMENSION
));
6195 DEF_IMGLIB_FN (struct jpeg_error_mgr
*, jpeg_std_error
, (struct jpeg_error_mgr
*));
6196 DEF_IMGLIB_FN (boolean
, jpeg_resync_to_restart
, (j_decompress_ptr
, int));
6199 init_jpeg_functions (void)
6203 if (!(library
= w32_delayed_load (Qjpeg
)))
6206 LOAD_IMGLIB_FN (library
, jpeg_finish_decompress
);
6207 LOAD_IMGLIB_FN (library
, jpeg_read_scanlines
);
6208 LOAD_IMGLIB_FN (library
, jpeg_start_decompress
);
6209 LOAD_IMGLIB_FN (library
, jpeg_read_header
);
6210 LOAD_IMGLIB_FN (library
, jpeg_CreateDecompress
);
6211 LOAD_IMGLIB_FN (library
, jpeg_destroy_decompress
);
6212 LOAD_IMGLIB_FN (library
, jpeg_std_error
);
6213 LOAD_IMGLIB_FN (library
, jpeg_resync_to_restart
);
6217 /* Wrapper since we can't directly assign the function pointer
6218 to another function pointer that was declared more completely easily. */
6220 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo
, int desired
)
6222 return fn_jpeg_resync_to_restart (cinfo
, desired
);
6227 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress (a)
6228 #define fn_jpeg_start_decompress jpeg_start_decompress
6229 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6230 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6231 #define fn_jpeg_read_header jpeg_read_header
6232 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6233 #define fn_jpeg_std_error jpeg_std_error
6234 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6236 #endif /* WINDOWSNT */
6238 struct my_jpeg_error_mgr
6240 struct jpeg_error_mgr pub
;
6241 sys_jmp_buf setjmp_buffer
;
6243 /* The remaining members are so that longjmp doesn't munge local
6245 struct jpeg_decompress_struct cinfo
;
6249 MY_JPEG_INVALID_IMAGE_SIZE
,
6250 MY_JPEG_CANNOT_CREATE_X
6255 static _Noreturn
void
6256 my_error_exit (j_common_ptr cinfo
)
6258 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
6259 mgr
->failure_code
= MY_JPEG_ERROR_EXIT
;
6260 sys_longjmp (mgr
->setjmp_buffer
, 1);
6264 /* Init source method for JPEG data source manager. Called by
6265 jpeg_read_header() before any data is actually read. See
6266 libjpeg.doc from the JPEG lib distribution. */
6269 our_common_init_source (j_decompress_ptr cinfo
)
6274 /* Method to terminate data source. Called by
6275 jpeg_finish_decompress() after all data has been processed. */
6278 our_common_term_source (j_decompress_ptr cinfo
)
6283 /* Fill input buffer method for JPEG data source manager. Called
6284 whenever more data is needed. We read the whole image in one step,
6285 so this only adds a fake end of input marker at the end. */
6287 static JOCTET our_memory_buffer
[2];
6290 our_memory_fill_input_buffer (j_decompress_ptr cinfo
)
6292 /* Insert a fake EOI marker. */
6293 struct jpeg_source_mgr
*src
= cinfo
->src
;
6295 our_memory_buffer
[0] = (JOCTET
) 0xFF;
6296 our_memory_buffer
[1] = (JOCTET
) JPEG_EOI
;
6298 src
->next_input_byte
= our_memory_buffer
;
6299 src
->bytes_in_buffer
= 2;
6304 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6305 is the JPEG data source manager. */
6308 our_memory_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6310 struct jpeg_source_mgr
*src
= cinfo
->src
;
6314 if (num_bytes
> src
->bytes_in_buffer
)
6315 ERREXIT (cinfo
, JERR_INPUT_EOF
);
6317 src
->bytes_in_buffer
-= num_bytes
;
6318 src
->next_input_byte
+= num_bytes
;
6323 /* Set up the JPEG lib for reading an image from DATA which contains
6324 LEN bytes. CINFO is the decompression info structure created for
6325 reading the image. */
6328 jpeg_memory_src (j_decompress_ptr cinfo
, JOCTET
*data
, ptrdiff_t len
)
6330 struct jpeg_source_mgr
*src
= cinfo
->src
;
6334 /* First time for this JPEG object? */
6335 src
= cinfo
->mem
->alloc_small ((j_common_ptr
) cinfo
,
6336 JPOOL_PERMANENT
, sizeof *src
);
6338 src
->next_input_byte
= data
;
6341 src
->init_source
= our_common_init_source
;
6342 src
->fill_input_buffer
= our_memory_fill_input_buffer
;
6343 src
->skip_input_data
= our_memory_skip_input_data
;
6344 src
->resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6345 src
->term_source
= our_common_term_source
;
6346 src
->bytes_in_buffer
= len
;
6347 src
->next_input_byte
= data
;
6351 struct jpeg_stdio_mgr
6353 struct jpeg_source_mgr mgr
;
6360 /* Size of buffer to read JPEG from file.
6361 Not too big, as we want to use alloc_small. */
6362 #define JPEG_STDIO_BUFFER_SIZE 8192
6365 /* Fill input buffer method for JPEG data source manager. Called
6366 whenever more data is needed. The data is read from a FILE *. */
6369 our_stdio_fill_input_buffer (j_decompress_ptr cinfo
)
6371 struct jpeg_stdio_mgr
*src
;
6373 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6378 bytes
= fread (src
->buffer
, 1, JPEG_STDIO_BUFFER_SIZE
, src
->file
);
6380 src
->mgr
.bytes_in_buffer
= bytes
;
6383 WARNMS (cinfo
, JWRN_JPEG_EOF
);
6385 src
->buffer
[0] = (JOCTET
) 0xFF;
6386 src
->buffer
[1] = (JOCTET
) JPEG_EOI
;
6387 src
->mgr
.bytes_in_buffer
= 2;
6389 src
->mgr
.next_input_byte
= src
->buffer
;
6396 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6397 is the JPEG data source manager. */
6400 our_stdio_skip_input_data (j_decompress_ptr cinfo
, long int num_bytes
)
6402 struct jpeg_stdio_mgr
*src
;
6403 src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6405 while (num_bytes
> 0 && !src
->finished
)
6407 if (num_bytes
<= src
->mgr
.bytes_in_buffer
)
6409 src
->mgr
.bytes_in_buffer
-= num_bytes
;
6410 src
->mgr
.next_input_byte
+= num_bytes
;
6415 num_bytes
-= src
->mgr
.bytes_in_buffer
;
6416 src
->mgr
.bytes_in_buffer
= 0;
6417 src
->mgr
.next_input_byte
= NULL
;
6419 our_stdio_fill_input_buffer (cinfo
);
6425 /* Set up the JPEG lib for reading an image from a FILE *.
6426 CINFO is the decompression info structure created for
6427 reading the image. */
6430 jpeg_file_src (j_decompress_ptr cinfo
, FILE *fp
)
6432 struct jpeg_stdio_mgr
*src
= (struct jpeg_stdio_mgr
*) cinfo
->src
;
6436 /* First time for this JPEG object? */
6437 src
= cinfo
->mem
->alloc_small ((j_common_ptr
) cinfo
,
6438 JPOOL_PERMANENT
, sizeof *src
);
6439 cinfo
->src
= (struct jpeg_source_mgr
*) src
;
6440 src
->buffer
= cinfo
->mem
->alloc_small ((j_common_ptr
) cinfo
,
6442 JPEG_STDIO_BUFFER_SIZE
);
6447 src
->mgr
.init_source
= our_common_init_source
;
6448 src
->mgr
.fill_input_buffer
= our_stdio_fill_input_buffer
;
6449 src
->mgr
.skip_input_data
= our_stdio_skip_input_data
;
6450 src
->mgr
.resync_to_restart
= jpeg_resync_to_restart_wrapper
; /* Use default method. */
6451 src
->mgr
.term_source
= our_common_term_source
;
6452 src
->mgr
.bytes_in_buffer
= 0;
6453 src
->mgr
.next_input_byte
= NULL
;
6457 /* Load image IMG for use on frame F. Patterned after example.c
6458 from the JPEG lib. */
6461 jpeg_load_body (struct frame
*f
, struct image
*img
,
6462 struct my_jpeg_error_mgr
*mgr
)
6464 Lisp_Object file
, specified_file
;
6465 Lisp_Object specified_data
;
6466 /* The 'volatile' silences a bogus diagnostic; see GCC bug 54561. */
6467 FILE * IF_LINT (volatile) fp
= NULL
;
6469 int row_stride
, x
, y
;
6470 XImagePtr ximg
= NULL
;
6471 unsigned long *colors
;
6474 /* Open the JPEG file. */
6475 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6476 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6478 if (NILP (specified_data
))
6480 file
= x_find_image_file (specified_file
);
6481 if (!STRINGP (file
))
6483 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6487 fp
= emacs_fopen (SSDATA (file
), "rb");
6490 image_error ("Cannot open `%s'", file
, Qnil
);
6494 else if (!STRINGP (specified_data
))
6496 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6500 /* Customize libjpeg's error handling to call my_error_exit when an
6501 error is detected. This function will perform a longjmp. */
6502 mgr
->cinfo
.err
= fn_jpeg_std_error (&mgr
->pub
);
6503 mgr
->pub
.error_exit
= my_error_exit
;
6504 if (sys_setjmp (mgr
->setjmp_buffer
))
6506 switch (mgr
->failure_code
)
6508 case MY_JPEG_ERROR_EXIT
:
6510 char buf
[JMSG_LENGTH_MAX
];
6511 mgr
->cinfo
.err
->format_message ((j_common_ptr
) &mgr
->cinfo
, buf
);
6512 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
6513 build_string (buf
));
6517 case MY_JPEG_INVALID_IMAGE_SIZE
:
6518 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
6521 case MY_JPEG_CANNOT_CREATE_X
:
6525 /* Close the input file and destroy the JPEG object. */
6528 fn_jpeg_destroy_decompress (&mgr
->cinfo
);
6530 /* If we already have an XImage, free that. */
6531 x_destroy_x_image (ximg
);
6533 /* Free pixmap and colors. */
6534 x_clear_image (f
, img
);
6538 /* Create the JPEG decompression object. Let it read from fp.
6539 Read the JPEG image header. */
6540 fn_jpeg_CreateDecompress (&mgr
->cinfo
, JPEG_LIB_VERSION
, sizeof *&mgr
->cinfo
);
6542 if (NILP (specified_data
))
6543 jpeg_file_src (&mgr
->cinfo
, fp
);
6545 jpeg_memory_src (&mgr
->cinfo
, SDATA (specified_data
),
6546 SBYTES (specified_data
));
6548 fn_jpeg_read_header (&mgr
->cinfo
, 1);
6550 /* Customize decompression so that color quantization will be used.
6551 Start decompression. */
6552 mgr
->cinfo
.quantize_colors
= 1;
6553 fn_jpeg_start_decompress (&mgr
->cinfo
);
6554 width
= img
->width
= mgr
->cinfo
.output_width
;
6555 height
= img
->height
= mgr
->cinfo
.output_height
;
6557 if (!check_image_size (f
, width
, height
))
6559 mgr
->failure_code
= MY_JPEG_INVALID_IMAGE_SIZE
;
6560 sys_longjmp (mgr
->setjmp_buffer
, 1);
6563 /* Create X image and pixmap. */
6564 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
6566 mgr
->failure_code
= MY_JPEG_CANNOT_CREATE_X
;
6567 sys_longjmp (mgr
->setjmp_buffer
, 1);
6570 /* Allocate colors. When color quantization is used,
6571 mgr->cinfo.actual_number_of_colors has been set with the number of
6572 colors generated, and mgr->cinfo.colormap is a two-dimensional array
6573 of color indices in the range 0..mgr->cinfo.actual_number_of_colors.
6574 No more than 255 colors will be generated. */
6578 if (mgr
->cinfo
.out_color_components
> 2)
6579 ir
= 0, ig
= 1, ib
= 2;
6580 else if (mgr
->cinfo
.out_color_components
> 1)
6581 ir
= 0, ig
= 1, ib
= 0;
6583 ir
= 0, ig
= 0, ib
= 0;
6585 /* Use the color table mechanism because it handles colors that
6586 cannot be allocated nicely. Such colors will be replaced with
6587 a default color, and we don't have to care about which colors
6588 can be freed safely, and which can't. */
6589 init_color_table ();
6590 colors
= alloca (mgr
->cinfo
.actual_number_of_colors
* sizeof *colors
);
6592 for (i
= 0; i
< mgr
->cinfo
.actual_number_of_colors
; ++i
)
6594 /* Multiply RGB values with 255 because X expects RGB values
6595 in the range 0..0xffff. */
6596 int r
= mgr
->cinfo
.colormap
[ir
][i
] << 8;
6597 int g
= mgr
->cinfo
.colormap
[ig
][i
] << 8;
6598 int b
= mgr
->cinfo
.colormap
[ib
][i
] << 8;
6599 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
6602 #ifdef COLOR_TABLE_SUPPORT
6603 /* Remember those colors actually allocated. */
6604 img
->colors
= colors_in_color_table (&img
->ncolors
);
6605 free_color_table ();
6606 #endif /* COLOR_TABLE_SUPPORT */
6610 row_stride
= width
* mgr
->cinfo
.output_components
;
6611 buffer
= mgr
->cinfo
.mem
->alloc_sarray ((j_common_ptr
) &mgr
->cinfo
,
6612 JPOOL_IMAGE
, row_stride
, 1);
6613 for (y
= 0; y
< height
; ++y
)
6615 fn_jpeg_read_scanlines (&mgr
->cinfo
, buffer
, 1);
6616 for (x
= 0; x
< mgr
->cinfo
.output_width
; ++x
)
6617 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
6621 fn_jpeg_finish_decompress (&mgr
->cinfo
);
6622 fn_jpeg_destroy_decompress (&mgr
->cinfo
);
6626 /* Maybe fill in the background field while we have ximg handy. */
6627 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
6628 /* Casting avoids a GCC warning. */
6629 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
6631 /* Put ximg into the image. */
6632 image_put_x_image (f
, img
, ximg
, 0);
6637 jpeg_load (struct frame
*f
, struct image
*img
)
6639 struct my_jpeg_error_mgr mgr
;
6640 return jpeg_load_body (f
, img
, &mgr
);
6643 #else /* HAVE_JPEG */
6647 jpeg_load (struct frame
*f
, struct image
*img
)
6649 return ns_load_image (f
, img
,
6650 image_spec_value (img
->spec
, QCfile
, NULL
),
6651 image_spec_value (img
->spec
, QCdata
, NULL
));
6653 #endif /* HAVE_NS */
6655 #endif /* !HAVE_JPEG */
6659 /***********************************************************************
6661 ***********************************************************************/
6663 #if defined (HAVE_TIFF) || defined (HAVE_NS)
6665 static bool tiff_image_p (Lisp_Object object
);
6666 static bool tiff_load (struct frame
*f
, struct image
*img
);
6668 /* The symbol `tiff' identifying images of this type. */
6670 static Lisp_Object Qtiff
;
6672 /* Indices of image specification fields in tiff_format, below. */
6674 enum tiff_keyword_index
6683 TIFF_HEURISTIC_MASK
,
6690 /* Vector of image_keyword structures describing the format
6691 of valid user-defined image specifications. */
6693 static const struct image_keyword tiff_format
[TIFF_LAST
] =
6695 {":type", IMAGE_SYMBOL_VALUE
, 1},
6696 {":data", IMAGE_STRING_VALUE
, 0},
6697 {":file", IMAGE_STRING_VALUE
, 0},
6698 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6699 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
6700 {":relief", IMAGE_INTEGER_VALUE
, 0},
6701 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6702 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6703 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6704 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
6705 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0}
6708 #if defined HAVE_NTGUI && defined WINDOWSNT
6709 static bool init_tiff_functions (void);
6711 #define init_tiff_functions NULL
6714 /* Structure describing the image type `tiff'. */
6716 static struct image_type tiff_type
=
6722 init_tiff_functions
,
6726 /* Return true if OBJECT is a valid TIFF image specification. */
6729 tiff_image_p (Lisp_Object object
)
6731 struct image_keyword fmt
[TIFF_LAST
];
6732 memcpy (fmt
, tiff_format
, sizeof fmt
);
6734 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
6737 /* Must specify either the :data or :file keyword. */
6738 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
6741 #endif /* HAVE_TIFF || HAVE_NS */
6749 /* TIFF library details. */
6750 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetErrorHandler
, (TIFFErrorHandler
));
6751 DEF_IMGLIB_FN (TIFFErrorHandler
, TIFFSetWarningHandler
, (TIFFErrorHandler
));
6752 DEF_IMGLIB_FN (TIFF
*, TIFFOpen
, (const char *, const char *));
6753 DEF_IMGLIB_FN (TIFF
*, TIFFClientOpen
, (const char *, const char *, thandle_t
,
6754 TIFFReadWriteProc
, TIFFReadWriteProc
,
6755 TIFFSeekProc
, TIFFCloseProc
, TIFFSizeProc
,
6756 TIFFMapFileProc
, TIFFUnmapFileProc
));
6757 DEF_IMGLIB_FN (int, TIFFGetField
, (TIFF
*, ttag_t
, ...));
6758 DEF_IMGLIB_FN (int, TIFFReadRGBAImage
, (TIFF
*, uint32
, uint32
, uint32
*, int));
6759 DEF_IMGLIB_FN (void, TIFFClose
, (TIFF
*));
6760 DEF_IMGLIB_FN (int, TIFFSetDirectory
, (TIFF
*, tdir_t
));
6763 init_tiff_functions (void)
6767 if (!(library
= w32_delayed_load (Qtiff
)))
6770 LOAD_IMGLIB_FN (library
, TIFFSetErrorHandler
);
6771 LOAD_IMGLIB_FN (library
, TIFFSetWarningHandler
);
6772 LOAD_IMGLIB_FN (library
, TIFFOpen
);
6773 LOAD_IMGLIB_FN (library
, TIFFClientOpen
);
6774 LOAD_IMGLIB_FN (library
, TIFFGetField
);
6775 LOAD_IMGLIB_FN (library
, TIFFReadRGBAImage
);
6776 LOAD_IMGLIB_FN (library
, TIFFClose
);
6777 LOAD_IMGLIB_FN (library
, TIFFSetDirectory
);
6783 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6784 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6785 #define fn_TIFFOpen TIFFOpen
6786 #define fn_TIFFClientOpen TIFFClientOpen
6787 #define fn_TIFFGetField TIFFGetField
6788 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6789 #define fn_TIFFClose TIFFClose
6790 #define fn_TIFFSetDirectory TIFFSetDirectory
6791 #endif /* WINDOWSNT */
6794 /* Reading from a memory buffer for TIFF images Based on the PNG
6795 memory source, but we have to provide a lot of extra functions.
6798 We really only need to implement read and seek, but I am not
6799 convinced that the TIFF library is smart enough not to destroy
6800 itself if we only hand it the function pointers we need to
6805 unsigned char *bytes
;
6812 tiff_read_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6814 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6816 size
= min (size
, src
->len
- src
->index
);
6817 memcpy (buf
, src
->bytes
+ src
->index
, size
);
6823 tiff_write_from_memory (thandle_t data
, tdata_t buf
, tsize_t size
)
6829 tiff_seek_in_memory (thandle_t data
, toff_t off
, int whence
)
6831 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
6836 case SEEK_SET
: /* Go from beginning of source. */
6840 case SEEK_END
: /* Go from end of source. */
6841 idx
= src
->len
+ off
;
6844 case SEEK_CUR
: /* Go from current position. */
6845 idx
= src
->index
+ off
;
6848 default: /* Invalid `whence'. */
6852 if (idx
> src
->len
|| idx
< 0)
6860 tiff_close_memory (thandle_t data
)
6867 tiff_mmap_memory (thandle_t data
, tdata_t
*pbase
, toff_t
*psize
)
6869 /* It is already _IN_ memory. */
6874 tiff_unmap_memory (thandle_t data
, tdata_t base
, toff_t size
)
6876 /* We don't need to do this. */
6880 tiff_size_of_memory (thandle_t data
)
6882 return ((tiff_memory_source
*) data
)->len
;
6885 /* GCC 3.x on x86 Windows targets has a bug that triggers an internal
6886 compiler error compiling tiff_handler, see Bugzilla bug #17406
6887 (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=17406). Declaring
6888 this function as external works around that problem. */
6889 #if defined (__MINGW32__) && __GNUC__ == 3
6890 # define MINGW_STATIC
6892 # define MINGW_STATIC static
6896 tiff_handler (const char *, const char *, const char *, va_list)
6897 ATTRIBUTE_FORMAT_PRINTF (3, 0);
6899 tiff_handler (const char *log_format
, const char *title
,
6900 const char *format
, va_list ap
)
6902 /* doprnt is not suitable here, as TIFF handlers are called from
6903 libtiff and are passed arbitrary printf directives. Instead, use
6904 vsnprintf, taking care to be portable to nonstandard environments
6905 where vsnprintf returns -1 on buffer overflow. Since it's just a
6906 log entry, it's OK to truncate it. */
6908 int len
= vsnprintf (buf
, sizeof buf
, format
, ap
);
6909 add_to_log (log_format
, build_string (title
),
6910 make_string (buf
, max (0, min (len
, sizeof buf
- 1))));
6914 static void tiff_error_handler (const char *, const char *, va_list)
6915 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6917 tiff_error_handler (const char *title
, const char *format
, va_list ap
)
6919 tiff_handler ("TIFF error: %s %s", title
, format
, ap
);
6923 static void tiff_warning_handler (const char *, const char *, va_list)
6924 ATTRIBUTE_FORMAT_PRINTF (2, 0);
6926 tiff_warning_handler (const char *title
, const char *format
, va_list ap
)
6928 tiff_handler ("TIFF warning: %s %s", title
, format
, ap
);
6932 /* Load TIFF image IMG for use on frame F. Value is true if
6936 tiff_load (struct frame
*f
, struct image
*img
)
6938 Lisp_Object file
, specified_file
;
6939 Lisp_Object specified_data
;
6941 int width
, height
, x
, y
, count
;
6945 tiff_memory_source memsrc
;
6948 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6949 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6951 fn_TIFFSetErrorHandler ((TIFFErrorHandler
) tiff_error_handler
);
6952 fn_TIFFSetWarningHandler ((TIFFErrorHandler
) tiff_warning_handler
);
6954 if (NILP (specified_data
))
6956 /* Read from a file */
6957 file
= x_find_image_file (specified_file
);
6958 if (!STRINGP (file
))
6960 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6964 file
= ansi_encode_filename (file
);
6967 /* Try to open the image file. */
6968 tiff
= fn_TIFFOpen (SSDATA (file
), "r");
6971 image_error ("Cannot open `%s'", file
, Qnil
);
6977 if (!STRINGP (specified_data
))
6979 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
6983 /* Memory source! */
6984 memsrc
.bytes
= SDATA (specified_data
);
6985 memsrc
.len
= SBYTES (specified_data
);
6988 tiff
= fn_TIFFClientOpen ("memory_source", "r", (thandle_t
)&memsrc
,
6989 tiff_read_from_memory
,
6990 tiff_write_from_memory
,
6991 tiff_seek_in_memory
,
6993 tiff_size_of_memory
,
6999 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
7004 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
7005 if (INTEGERP (image
))
7007 EMACS_INT ino
= XFASTINT (image
);
7008 if (! (TYPE_MINIMUM (tdir_t
) <= ino
&& ino
<= TYPE_MAXIMUM (tdir_t
)
7009 && fn_TIFFSetDirectory (tiff
, ino
)))
7011 image_error ("Invalid image number `%s' in image `%s'",
7013 fn_TIFFClose (tiff
);
7018 /* Get width and height of the image, and allocate a raster buffer
7019 of width x height 32-bit values. */
7020 fn_TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
7021 fn_TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
7023 if (!check_image_size (f
, width
, height
))
7025 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7026 fn_TIFFClose (tiff
);
7030 /* Create the X image and pixmap. */
7031 if (! (height
<= min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof *buf
/ width
7032 && image_create_x_image_and_pixmap (f
, img
, width
, height
, 0,
7035 fn_TIFFClose (tiff
);
7039 buf
= xmalloc (sizeof *buf
* width
* height
);
7041 rc
= fn_TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
7043 /* Count the number of images in the file. */
7044 for (count
= 1; fn_TIFFSetDirectory (tiff
, count
); count
++)
7048 img
->lisp_data
= Fcons (Qcount
,
7049 Fcons (make_number (count
),
7052 fn_TIFFClose (tiff
);
7055 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
7060 /* Initialize the color table. */
7061 init_color_table ();
7063 /* Process the pixel raster. Origin is in the lower-left corner. */
7064 for (y
= 0; y
< height
; ++y
)
7066 uint32
*row
= buf
+ y
* width
;
7068 for (x
= 0; x
< width
; ++x
)
7070 uint32 abgr
= row
[x
];
7071 int r
= TIFFGetR (abgr
) << 8;
7072 int g
= TIFFGetG (abgr
) << 8;
7073 int b
= TIFFGetB (abgr
) << 8;
7074 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
7078 #ifdef COLOR_TABLE_SUPPORT
7079 /* Remember the colors allocated for the image. Free the color table. */
7080 img
->colors
= colors_in_color_table (&img
->ncolors
);
7081 free_color_table ();
7082 #endif /* COLOR_TABLE_SUPPORT */
7085 img
->height
= height
;
7087 /* Maybe fill in the background field while we have ximg handy. */
7088 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7089 /* Casting avoids a GCC warning on W32. */
7090 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7092 /* Put ximg into the image. */
7093 image_put_x_image (f
, img
, ximg
, 0);
7099 #else /* HAVE_TIFF */
7103 tiff_load (struct frame
*f
, struct image
*img
)
7105 return ns_load_image (f
, img
,
7106 image_spec_value (img
->spec
, QCfile
, NULL
),
7107 image_spec_value (img
->spec
, QCdata
, NULL
));
7109 #endif /* HAVE_NS */
7111 #endif /* !HAVE_TIFF */
7115 /***********************************************************************
7117 ***********************************************************************/
7119 #if defined (HAVE_GIF) || defined (HAVE_NS)
7121 static bool gif_image_p (Lisp_Object object
);
7122 static bool gif_load (struct frame
*f
, struct image
*img
);
7123 static void gif_clear_image (struct frame
*f
, struct image
*img
);
7125 /* The symbol `gif' identifying images of this type. */
7127 static Lisp_Object Qgif
;
7129 /* Indices of image specification fields in gif_format, below. */
7131 enum gif_keyword_index
7147 /* Vector of image_keyword structures describing the format
7148 of valid user-defined image specifications. */
7150 static const struct image_keyword gif_format
[GIF_LAST
] =
7152 {":type", IMAGE_SYMBOL_VALUE
, 1},
7153 {":data", IMAGE_STRING_VALUE
, 0},
7154 {":file", IMAGE_STRING_VALUE
, 0},
7155 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7156 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
7157 {":relief", IMAGE_INTEGER_VALUE
, 0},
7158 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7159 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7160 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7161 {":index", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
7162 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7165 #if defined HAVE_NTGUI && defined WINDOWSNT
7166 static bool init_gif_functions (void);
7168 #define init_gif_functions NULL
7171 /* Structure describing the image type `gif'. */
7173 static struct image_type gif_type
=
7183 /* Free X resources of GIF image IMG which is used on frame F. */
7186 gif_clear_image (struct frame
*f
, struct image
*img
)
7188 img
->lisp_data
= Qnil
;
7189 x_clear_image (f
, img
);
7192 /* Return true if OBJECT is a valid GIF image specification. */
7195 gif_image_p (Lisp_Object object
)
7197 struct image_keyword fmt
[GIF_LAST
];
7198 memcpy (fmt
, gif_format
, sizeof fmt
);
7200 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
7203 /* Must specify either the :data or :file keyword. */
7204 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
7207 #endif /* HAVE_GIF */
7211 #if defined (HAVE_NTGUI)
7213 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7214 Undefine before redefining to avoid a preprocessor warning. */
7218 /* avoid conflict with QuickdrawText.h */
7219 #define DrawText gif_DrawText
7220 #include <gif_lib.h>
7223 /* Giflib before 5.0 didn't define these macros (used only if HAVE_NTGUI). */
7224 #ifndef GIFLIB_MINOR
7225 #define GIFLIB_MINOR 0
7227 #ifndef GIFLIB_RELEASE
7228 #define GIFLIB_RELEASE 0
7231 #else /* HAVE_NTGUI */
7233 #include <gif_lib.h>
7235 #endif /* HAVE_NTGUI */
7237 /* Giflib before 5.0 didn't define these macros. */
7238 #ifndef GIFLIB_MAJOR
7239 #define GIFLIB_MAJOR 4
7244 /* GIF library details. */
7245 DEF_IMGLIB_FN (int, DGifCloseFile
, (GifFileType
*));
7246 DEF_IMGLIB_FN (int, DGifSlurp
, (GifFileType
*));
7247 #if GIFLIB_MAJOR < 5
7248 DEF_IMGLIB_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
));
7249 DEF_IMGLIB_FN (GifFileType
*, DGifOpenFileName
, (const char *));
7251 DEF_IMGLIB_FN (GifFileType
*, DGifOpen
, (void *, InputFunc
, int *));
7252 DEF_IMGLIB_FN (GifFileType
*, DGifOpenFileName
, (const char *, int *));
7253 DEF_IMGLIB_FN (char *, GifErrorString
, (int));
7257 init_gif_functions (void)
7261 if (!(library
= w32_delayed_load (Qgif
)))
7264 LOAD_IMGLIB_FN (library
, DGifCloseFile
);
7265 LOAD_IMGLIB_FN (library
, DGifSlurp
);
7266 LOAD_IMGLIB_FN (library
, DGifOpen
);
7267 LOAD_IMGLIB_FN (library
, DGifOpenFileName
);
7268 #if GIFLIB_MAJOR >= 5
7269 LOAD_IMGLIB_FN (library
, GifErrorString
);
7276 #define fn_DGifCloseFile DGifCloseFile
7277 #define fn_DGifSlurp DGifSlurp
7278 #define fn_DGifOpen DGifOpen
7279 #define fn_DGifOpenFileName DGifOpenFileName
7280 #if 5 <= GIFLIB_MAJOR
7281 # define fn_GifErrorString GifErrorString
7284 #endif /* WINDOWSNT */
7286 /* Reading a GIF image from memory
7287 Based on the PNG memory stuff to a certain extent. */
7291 unsigned char *bytes
;
7297 /* Make the current memory source available to gif_read_from_memory.
7298 It's done this way because not all versions of libungif support
7299 a UserData field in the GifFileType structure. */
7300 static gif_memory_source
*current_gif_memory_src
;
7303 gif_read_from_memory (GifFileType
*file
, GifByteType
*buf
, int len
)
7305 gif_memory_source
*src
= current_gif_memory_src
;
7307 if (len
> src
->len
- src
->index
)
7310 memcpy (buf
, src
->bytes
+ src
->index
, len
);
7316 /* Load GIF image IMG for use on frame F. Value is true if
7319 static const int interlace_start
[] = {0, 4, 2, 1};
7320 static const int interlace_increment
[] = {8, 8, 4, 2};
7322 #define GIF_LOCAL_DESCRIPTOR_EXTENSION 249
7325 gif_load (struct frame
*f
, struct image
*img
)
7328 int rc
, width
, height
, x
, y
, i
, j
;
7330 ColorMapObject
*gif_color_map
;
7331 unsigned long pixel_colors
[256];
7333 gif_memory_source memsrc
;
7334 Lisp_Object specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
7335 Lisp_Object specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7336 Lisp_Object specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7337 unsigned long bgcolor
= 0;
7339 #if GIFLIB_MAJOR >= 5
7343 if (NILP (specified_data
))
7345 file
= x_find_image_file (specified_file
);
7346 if (!STRINGP (file
))
7348 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7352 file
= ansi_encode_filename (file
);
7355 /* Open the GIF file. */
7356 #if GIFLIB_MAJOR < 5
7357 gif
= fn_DGifOpenFileName (SSDATA (file
));
7360 image_error ("Cannot open `%s'", file
, Qnil
);
7364 gif
= fn_DGifOpenFileName (SSDATA (file
), &gif_err
);
7367 image_error ("Cannot open `%s': %s",
7368 file
, build_string (fn_GifErrorString (gif_err
)));
7375 if (!STRINGP (specified_data
))
7377 image_error ("Invalid image data `%s'", specified_data
, Qnil
);
7381 /* Read from memory! */
7382 current_gif_memory_src
= &memsrc
;
7383 memsrc
.bytes
= SDATA (specified_data
);
7384 memsrc
.len
= SBYTES (specified_data
);
7387 #if GIFLIB_MAJOR < 5
7388 gif
= fn_DGifOpen (&memsrc
, gif_read_from_memory
);
7391 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
7395 gif
= fn_DGifOpen (&memsrc
, gif_read_from_memory
, &gif_err
);
7398 image_error ("Cannot open memory source `%s': %s",
7399 img
->spec
, build_string (fn_GifErrorString (gif_err
)));
7405 /* Before reading entire contents, check the declared image size. */
7406 if (!check_image_size (f
, gif
->SWidth
, gif
->SHeight
))
7408 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7409 fn_DGifCloseFile (gif
);
7413 /* Read entire contents. */
7414 rc
= fn_DGifSlurp (gif
);
7415 if (rc
== GIF_ERROR
|| gif
->ImageCount
<= 0)
7417 image_error ("Error reading `%s'", img
->spec
, Qnil
);
7418 fn_DGifCloseFile (gif
);
7422 /* Which sub-image are we to display? */
7424 Lisp_Object image_number
= image_spec_value (img
->spec
, QCindex
, NULL
);
7425 idx
= INTEGERP (image_number
) ? XFASTINT (image_number
) : 0;
7426 if (idx
< 0 || idx
>= gif
->ImageCount
)
7428 image_error ("Invalid image number `%s' in image `%s'",
7429 image_number
, img
->spec
);
7430 fn_DGifCloseFile (gif
);
7435 width
= img
->width
= gif
->SWidth
;
7436 height
= img
->height
= gif
->SHeight
;
7438 img
->corners
[TOP_CORNER
] = gif
->SavedImages
[0].ImageDesc
.Top
;
7439 img
->corners
[LEFT_CORNER
] = gif
->SavedImages
[0].ImageDesc
.Left
;
7440 img
->corners
[BOT_CORNER
]
7441 = img
->corners
[TOP_CORNER
] + gif
->SavedImages
[0].ImageDesc
.Height
;
7442 img
->corners
[RIGHT_CORNER
]
7443 = img
->corners
[LEFT_CORNER
] + gif
->SavedImages
[0].ImageDesc
.Width
;
7445 if (!check_image_size (f
, width
, height
))
7447 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
7448 fn_DGifCloseFile (gif
);
7452 /* Check that the selected subimages fit. It's not clear whether
7453 the GIF spec requires this, but Emacs can crash if they don't fit. */
7454 for (j
= 0; j
<= idx
; ++j
)
7456 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7457 int subimg_width
= subimage
->ImageDesc
.Width
;
7458 int subimg_height
= subimage
->ImageDesc
.Height
;
7459 int subimg_top
= subimage
->ImageDesc
.Top
;
7460 int subimg_left
= subimage
->ImageDesc
.Left
;
7461 if (! (0 <= subimg_width
&& 0 <= subimg_height
7462 && 0 <= subimg_top
&& subimg_top
<= height
- subimg_height
7463 && 0 <= subimg_left
&& subimg_left
<= width
- subimg_width
))
7465 image_error ("Subimage does not fit in image", Qnil
, Qnil
);
7466 fn_DGifCloseFile (gif
);
7471 /* Create the X image and pixmap. */
7472 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
7474 fn_DGifCloseFile (gif
);
7478 /* Clear the part of the screen image not covered by the image.
7479 Full animated GIF support requires more here (see the gif89 spec,
7480 disposal methods). Let's simply assume that the part not covered
7481 by a sub-image is in the frame's background color. */
7482 for (y
= 0; y
< img
->corners
[TOP_CORNER
]; ++y
)
7483 for (x
= 0; x
< width
; ++x
)
7484 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7486 for (y
= img
->corners
[BOT_CORNER
]; y
< height
; ++y
)
7487 for (x
= 0; x
< width
; ++x
)
7488 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7490 for (y
= img
->corners
[TOP_CORNER
]; y
< img
->corners
[BOT_CORNER
]; ++y
)
7492 for (x
= 0; x
< img
->corners
[LEFT_CORNER
]; ++x
)
7493 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7494 for (x
= img
->corners
[RIGHT_CORNER
]; x
< width
; ++x
)
7495 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
7498 /* Read the GIF image into the X image. */
7500 /* FIXME: With the current implementation, loading an animated gif
7501 is quadratic in the number of animation frames, since each frame
7502 is a separate struct image. We must provide a way for a single
7503 gif_load call to construct and save all animation frames. */
7505 init_color_table ();
7506 if (STRINGP (specified_bg
))
7507 bgcolor
= x_alloc_image_color (f
, img
, specified_bg
,
7508 FRAME_BACKGROUND_PIXEL (f
));
7509 for (j
= 0; j
<= idx
; ++j
)
7511 /* We use a local variable `raster' here because RasterBits is a
7512 char *, which invites problems with bytes >= 0x80. */
7513 struct SavedImage
*subimage
= gif
->SavedImages
+ j
;
7514 unsigned char *raster
= (unsigned char *) subimage
->RasterBits
;
7515 int transparency_color_index
= -1;
7517 int subimg_width
= subimage
->ImageDesc
.Width
;
7518 int subimg_height
= subimage
->ImageDesc
.Height
;
7519 int subimg_top
= subimage
->ImageDesc
.Top
;
7520 int subimg_left
= subimage
->ImageDesc
.Left
;
7522 /* Find the Graphic Control Extension block for this sub-image.
7523 Extract the disposal method and transparency color. */
7524 for (i
= 0; i
< subimage
->ExtensionBlockCount
; i
++)
7526 ExtensionBlock
*extblock
= subimage
->ExtensionBlocks
+ i
;
7528 if ((extblock
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
)
7529 && extblock
->ByteCount
== 4
7530 && extblock
->Bytes
[0] & 1)
7532 /* From gif89a spec: 1 = "keep in place", 2 = "restore
7533 to background". Treat any other value like 2. */
7534 disposal
= (extblock
->Bytes
[0] >> 2) & 7;
7535 transparency_color_index
= (unsigned char) extblock
->Bytes
[3];
7540 /* We can't "keep in place" the first subimage. */
7544 /* For disposal == 0, the spec says "No disposal specified. The
7545 decoder is not required to take any action." In practice, it
7546 seems we need to treat this like "keep in place", see e.g.
7547 http://upload.wikimedia.org/wikipedia/commons/3/37/Clock.gif */
7551 /* Allocate subimage colors. */
7552 memset (pixel_colors
, 0, sizeof pixel_colors
);
7553 gif_color_map
= subimage
->ImageDesc
.ColorMap
;
7555 gif_color_map
= gif
->SColorMap
;
7558 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
7560 if (transparency_color_index
== i
)
7561 pixel_colors
[i
] = STRINGP (specified_bg
)
7562 ? bgcolor
: FRAME_BACKGROUND_PIXEL (f
);
7565 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
7566 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
7567 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
7568 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
7572 /* Apply the pixel values. */
7573 if (GIFLIB_MAJOR
< 5 && gif
->SavedImages
[j
].ImageDesc
.Interlace
)
7577 for (y
= 0, row
= interlace_start
[0], pass
= 0;
7579 y
++, row
+= interlace_increment
[pass
])
7581 while (subimg_height
<= row
)
7582 row
= interlace_start
[++pass
];
7584 for (x
= 0; x
< subimg_width
; x
++)
7586 int c
= raster
[y
* subimg_width
+ x
];
7587 if (transparency_color_index
!= c
|| disposal
!= 1)
7588 XPutPixel (ximg
, x
+ subimg_left
, row
+ subimg_top
,
7595 for (y
= 0; y
< subimg_height
; ++y
)
7596 for (x
= 0; x
< subimg_width
; ++x
)
7598 int c
= raster
[y
* subimg_width
+ x
];
7599 if (transparency_color_index
!= c
|| disposal
!= 1)
7600 XPutPixel (ximg
, x
+ subimg_left
, y
+ subimg_top
,
7606 #ifdef COLOR_TABLE_SUPPORT
7607 img
->colors
= colors_in_color_table (&img
->ncolors
);
7608 free_color_table ();
7609 #endif /* COLOR_TABLE_SUPPORT */
7611 /* Save GIF image extension data for `image-metadata'.
7612 Format is (count IMAGES extension-data (FUNCTION "BYTES" ...)). */
7613 img
->lisp_data
= Qnil
;
7614 if (gif
->SavedImages
[idx
].ExtensionBlockCount
> 0)
7617 ExtensionBlock
*ext
= gif
->SavedImages
[idx
].ExtensionBlocks
;
7618 for (i
= 0; i
< gif
->SavedImages
[idx
].ExtensionBlockCount
; i
++, ext
++)
7619 /* Append (... FUNCTION "BYTES") */
7622 = Fcons (make_number (ext
->Function
),
7623 Fcons (make_unibyte_string (ext
->Bytes
, ext
->ByteCount
),
7625 if (ext
->Function
== GIF_LOCAL_DESCRIPTOR_EXTENSION
7626 && ext
->ByteCount
== 4)
7628 delay
= ext
->Bytes
[2] << CHAR_BIT
;
7629 delay
|= ext
->Bytes
[1];
7632 img
->lisp_data
= list2 (Qextension_data
, img
->lisp_data
);
7636 Fcons (make_float (delay
/ 100.0),
7640 if (gif
->ImageCount
> 1)
7641 img
->lisp_data
= Fcons (Qcount
,
7642 Fcons (make_number (gif
->ImageCount
),
7645 fn_DGifCloseFile (gif
);
7647 /* Maybe fill in the background field while we have ximg handy. */
7648 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7649 /* Casting avoids a GCC warning. */
7650 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
7652 /* Put ximg into the image. */
7653 image_put_x_image (f
, img
, ximg
, 0);
7658 #else /* !HAVE_GIF */
7662 gif_load (struct frame
*f
, struct image
*img
)
7664 return ns_load_image (f
, img
,
7665 image_spec_value (img
->spec
, QCfile
, NULL
),
7666 image_spec_value (img
->spec
, QCdata
, NULL
));
7668 #endif /* HAVE_NS */
7670 #endif /* HAVE_GIF */
7673 #ifdef HAVE_IMAGEMAGICK
7675 /***********************************************************************
7677 ***********************************************************************/
7679 /* Scale an image size by returning SIZE / DIVISOR * MULTIPLIER,
7680 safely rounded and clipped to int range. */
7683 scale_image_size (int size
, size_t divisor
, size_t multiplier
)
7688 double scaled
= s
* multiplier
/ divisor
+ 0.5;
7689 if (scaled
< INT_MAX
)
7695 /* Compute the desired size of an image with native size WIDTH x HEIGHT.
7696 Use SPEC to deduce the size. Store the desired size into
7697 *D_WIDTH x *D_HEIGHT. Store -1 x -1 if the native size is OK. */
7699 compute_image_size (size_t width
, size_t height
,
7701 int *d_width
, int *d_height
)
7704 int desired_width
, desired_height
;
7706 /* If width and/or height is set in the display spec assume we want
7707 to scale to those values. If either h or w is unspecified, the
7708 unspecified should be calculated from the specified to preserve
7710 value
= image_spec_value (spec
, QCwidth
, NULL
);
7711 desired_width
= NATNUMP (value
) ? min (XFASTINT (value
), INT_MAX
) : -1;
7712 value
= image_spec_value (spec
, QCheight
, NULL
);
7713 desired_height
= NATNUMP (value
) ? min (XFASTINT (value
), INT_MAX
) : -1;
7715 if (desired_width
== -1)
7717 value
= image_spec_value (spec
, QCmax_width
, NULL
);
7718 if (NATNUMP (value
))
7720 int max_width
= min (XFASTINT (value
), INT_MAX
);
7721 if (max_width
< width
)
7723 /* The image is wider than :max-width. */
7724 desired_width
= max_width
;
7725 if (desired_height
== -1)
7727 desired_height
= scale_image_size (desired_width
,
7729 value
= image_spec_value (spec
, QCmax_height
, NULL
);
7730 if (NATNUMP (value
))
7732 int max_height
= min (XFASTINT (value
), INT_MAX
);
7733 if (max_height
< desired_height
)
7735 desired_height
= max_height
;
7736 desired_width
= scale_image_size (desired_height
,
7745 if (desired_height
== -1)
7747 value
= image_spec_value (spec
, QCmax_height
, NULL
);
7748 if (NATNUMP (value
))
7750 int max_height
= min (XFASTINT (value
), INT_MAX
);
7751 if (max_height
< height
)
7752 desired_height
= max_height
;
7756 if (desired_width
!= -1 && desired_height
== -1)
7757 /* w known, calculate h. */
7758 desired_height
= scale_image_size (desired_width
, width
, height
);
7760 if (desired_width
== -1 && desired_height
!= -1)
7761 /* h known, calculate w. */
7762 desired_width
= scale_image_size (desired_height
, height
, width
);
7764 *d_width
= desired_width
;
7765 *d_height
= desired_height
;
7768 static Lisp_Object Qimagemagick
;
7770 static bool imagemagick_image_p (Lisp_Object
);
7771 static bool imagemagick_load (struct frame
*, struct image
*);
7772 static void imagemagick_clear_image (struct frame
*, struct image
*);
7774 /* Indices of image specification fields in imagemagick_format. */
7776 enum imagemagick_keyword_index
7784 IMAGEMAGICK_ALGORITHM
,
7785 IMAGEMAGICK_HEURISTIC_MASK
,
7787 IMAGEMAGICK_BACKGROUND
,
7790 IMAGEMAGICK_MAX_HEIGHT
,
7791 IMAGEMAGICK_MAX_WIDTH
,
7793 IMAGEMAGICK_ROTATION
,
7798 /* Vector of image_keyword structures describing the format
7799 of valid user-defined image specifications. */
7801 static struct image_keyword imagemagick_format
[IMAGEMAGICK_LAST
] =
7803 {":type", IMAGE_SYMBOL_VALUE
, 1},
7804 {":data", IMAGE_STRING_VALUE
, 0},
7805 {":file", IMAGE_STRING_VALUE
, 0},
7806 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7807 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
7808 {":relief", IMAGE_INTEGER_VALUE
, 0},
7809 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7810 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7811 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7812 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
7813 {":height", IMAGE_INTEGER_VALUE
, 0},
7814 {":width", IMAGE_INTEGER_VALUE
, 0},
7815 {":max-height", IMAGE_INTEGER_VALUE
, 0},
7816 {":max-width", IMAGE_INTEGER_VALUE
, 0},
7817 {":format", IMAGE_SYMBOL_VALUE
, 0},
7818 {":rotation", IMAGE_NUMBER_VALUE
, 0},
7819 {":crop", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
7822 #if defined HAVE_NTGUI && defined WINDOWSNT
7823 static bool init_imagemagick_functions (void);
7825 #define init_imagemagick_functions NULL
7828 /* Structure describing the image type for any image handled via
7831 static struct image_type imagemagick_type
=
7834 imagemagick_image_p
,
7836 imagemagick_clear_image
,
7837 init_imagemagick_functions
,
7841 /* Free X resources of imagemagick image IMG which is used on frame F. */
7844 imagemagick_clear_image (struct frame
*f
,
7847 x_clear_image (f
, img
);
7850 /* Return true if OBJECT is a valid IMAGEMAGICK image specification. Do
7851 this by calling parse_image_spec and supplying the keywords that
7852 identify the IMAGEMAGICK format. */
7855 imagemagick_image_p (Lisp_Object object
)
7857 struct image_keyword fmt
[IMAGEMAGICK_LAST
];
7858 memcpy (fmt
, imagemagick_format
, sizeof fmt
);
7860 if (!parse_image_spec (object
, fmt
, IMAGEMAGICK_LAST
, Qimagemagick
))
7863 /* Must specify either the :data or :file keyword. */
7864 return fmt
[IMAGEMAGICK_FILE
].count
+ fmt
[IMAGEMAGICK_DATA
].count
== 1;
7867 /* The GIF library also defines DrawRectangle, but its never used in Emacs.
7868 Therefore rename the function so it doesn't collide with ImageMagick. */
7869 #define DrawRectangle DrawRectangleGif
7870 #include <wand/MagickWand.h>
7872 /* ImageMagick 6.5.3 through 6.6.5 hid PixelGetMagickColor for some reason.
7873 Emacs seems to work fine with the hidden version, so unhide it. */
7874 #include <magick/version.h>
7875 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
7876 extern WandExport
void PixelGetMagickColor (const PixelWand
*,
7877 MagickPixelPacket
*);
7880 /* Log ImageMagick error message.
7881 Useful when a ImageMagick function returns the status `MagickFalse'. */
7884 imagemagick_error (MagickWand
*wand
)
7887 ExceptionType severity
;
7889 description
= MagickGetException (wand
, &severity
);
7890 image_error ("ImageMagick error: %s",
7891 build_string (description
),
7893 MagickRelinquishMemory (description
);
7896 /* Possibly give ImageMagick some extra help to determine the image
7897 type by supplying a "dummy" filename based on the Content-Type. */
7900 imagemagick_filename_hint (Lisp_Object spec
, char hint_buffer
[MaxTextExtent
])
7902 Lisp_Object symbol
= intern ("image-format-suffixes");
7903 Lisp_Object val
= find_symbol_value (symbol
);
7909 format
= image_spec_value (spec
, intern (":format"), NULL
);
7910 val
= Fcar_safe (Fcdr_safe (Fassq (format
, val
)));
7911 if (! STRINGP (val
))
7914 /* It's OK to truncate the hint if it has MaxTextExtent or more bytes,
7915 as ImageMagick would ignore the extra bytes anyway. */
7916 snprintf (hint_buffer
, MaxTextExtent
, "/tmp/foo.%s", SSDATA (val
));
7920 /* Animated images (e.g., GIF89a) are composed from one "master image"
7921 (which is the first one, and then there's a number of images that
7922 follow. If following images have non-transparent colors, these are
7923 composed "on top" of the master image. So, in general, one has to
7924 compute ann the preceding images to be able to display a particular
7927 Computing all the preceding images is too slow, so we maintain a
7928 cache of previously computed images. We have to maintain a cache
7929 separate from the image cache, because the images may be scaled
7932 struct animation_cache
7936 struct timespec update_time
;
7937 struct animation_cache
*next
;
7938 char signature
[FLEXIBLE_ARRAY_MEMBER
];
7941 static struct animation_cache
*animation_cache
= NULL
;
7943 static struct animation_cache
*
7944 imagemagick_create_cache (char *signature
)
7946 struct animation_cache
*cache
7947 = xmalloc (offsetof (struct animation_cache
, signature
)
7948 + strlen (signature
) + 1);
7952 strcpy (cache
->signature
, signature
);
7956 /* Discard cached images that haven't been used for a minute. */
7958 imagemagick_prune_animation_cache (void)
7960 struct animation_cache
**pcache
= &animation_cache
;
7961 struct timespec old
= timespec_sub (current_timespec (),
7962 make_timespec (60, 0));
7966 struct animation_cache
*cache
= *pcache
;
7967 if (timespec_cmp (old
, cache
->update_time
) <= 0)
7968 pcache
= &cache
->next
;
7972 DestroyMagickWand (cache
->wand
);
7973 *pcache
= cache
->next
;
7979 static struct animation_cache
*
7980 imagemagick_get_animation_cache (MagickWand
*wand
)
7982 char *signature
= MagickGetImageSignature (wand
);
7983 struct animation_cache
*cache
;
7984 struct animation_cache
**pcache
= &animation_cache
;
7986 imagemagick_prune_animation_cache ();
7993 *pcache
= cache
= imagemagick_create_cache (signature
);
7996 if (strcmp (signature
, cache
->signature
) == 0)
7998 pcache
= &cache
->next
;
8001 DestroyString (signature
);
8002 cache
->update_time
= current_timespec ();
8007 imagemagick_compute_animated_image (MagickWand
*super_wand
, int ino
)
8010 MagickWand
*composite_wand
;
8011 size_t dest_width
, dest_height
;
8012 struct animation_cache
*cache
= imagemagick_get_animation_cache (super_wand
);
8014 MagickSetIteratorIndex (super_wand
, 0);
8016 if (ino
== 0 || cache
->wand
== NULL
|| cache
->index
> ino
)
8018 composite_wand
= MagickGetImage (super_wand
);
8020 DestroyMagickWand (cache
->wand
);
8023 composite_wand
= cache
->wand
;
8025 dest_width
= MagickGetImageWidth (composite_wand
);
8026 dest_height
= MagickGetImageHeight (composite_wand
);
8028 for (i
= max (1, cache
->index
+ 1); i
<= ino
; i
++)
8030 MagickWand
*sub_wand
;
8031 PixelIterator
*source_iterator
, *dest_iterator
;
8032 PixelWand
**source
, **dest
;
8033 size_t source_width
, source_height
;
8034 ssize_t source_left
, source_top
;
8035 MagickPixelPacket pixel
;
8036 DisposeType dispose
;
8037 ptrdiff_t lines
= 0;
8039 MagickSetIteratorIndex (super_wand
, i
);
8040 sub_wand
= MagickGetImage (super_wand
);
8042 MagickGetImagePage (sub_wand
, &source_width
, &source_height
,
8043 &source_left
, &source_top
);
8045 /* This flag says how to handle transparent pixels. */
8046 dispose
= MagickGetImageDispose (sub_wand
);
8048 source_iterator
= NewPixelIterator (sub_wand
);
8049 if (! source_iterator
)
8051 DestroyMagickWand (composite_wand
);
8052 DestroyMagickWand (sub_wand
);
8054 image_error ("Imagemagick pixel iterator creation failed",
8059 dest_iterator
= NewPixelIterator (composite_wand
);
8060 if (! dest_iterator
)
8062 DestroyMagickWand (composite_wand
);
8063 DestroyMagickWand (sub_wand
);
8064 DestroyPixelIterator (source_iterator
);
8066 image_error ("Imagemagick pixel iterator creation failed",
8071 /* The sub-image may not start at origin, so move the destination
8072 iterator to where the sub-image should start. */
8075 PixelSetIteratorRow (dest_iterator
, source_top
);
8079 while ((source
= PixelGetNextIteratorRow (source_iterator
, &source_width
))
8084 /* Sanity check. This shouldn't happen, but apparently
8085 does in some pictures. */
8086 if (++lines
>= dest_height
)
8089 dest
= PixelGetNextIteratorRow (dest_iterator
, &dest_width
);
8090 for (x
= 0; x
< source_width
; x
++)
8092 /* Sanity check. This shouldn't happen, but apparently
8093 also does in some pictures. */
8094 if (x
+ source_left
> dest_width
- 1)
8096 /* Normally we only copy over non-transparent pixels,
8097 but if the disposal method is "Background", then we
8098 copy over all pixels. */
8099 if (dispose
== BackgroundDispose
||
8100 PixelGetAlpha (source
[x
]))
8102 PixelGetMagickColor (source
[x
], &pixel
);
8103 PixelSetMagickColor (dest
[x
+ source_left
], &pixel
);
8106 PixelSyncIterator (dest_iterator
);
8109 DestroyPixelIterator (source_iterator
);
8110 DestroyPixelIterator (dest_iterator
);
8111 DestroyMagickWand (sub_wand
);
8114 /* Cache a copy for the next iteration. The current wand will be
8115 destroyed by the caller. */
8116 cache
->wand
= CloneMagickWand (composite_wand
);
8119 return composite_wand
;
8123 /* Helper function for imagemagick_load, which does the actual loading
8124 given contents and size, apart from frame and image structures,
8125 passed from imagemagick_load. Uses librimagemagick to do most of
8126 the image processing.
8128 F is a pointer to the Emacs frame; IMG to the image structure to
8129 prepare; CONTENTS is the string containing the IMAGEMAGICK data to
8130 be parsed; SIZE is the number of bytes of data; and FILENAME is
8131 either the file name or the image data.
8133 Return true if successful. */
8136 imagemagick_load_image (struct frame
*f
, struct image
*img
,
8137 unsigned char *contents
, unsigned int size
,
8140 size_t width
, height
;
8141 MagickBooleanType status
;
8144 MagickWand
*image_wand
;
8145 PixelIterator
*iterator
;
8146 PixelWand
**pixels
, *bg_wand
= NULL
;
8147 MagickPixelPacket pixel
;
8152 int desired_width
, desired_height
;
8155 char hint_buffer
[MaxTextExtent
];
8156 char *filename_hint
= NULL
;
8158 /* Handle image index for image types who can contain more than one image.
8159 Interface :index is same as for GIF. First we "ping" the image to see how
8160 many sub-images it contains. Pinging is faster than loading the image to
8161 find out things about it. */
8163 /* Initialize the imagemagick environment. */
8164 MagickWandGenesis ();
8165 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8166 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8167 image_wand
= NewMagickWand ();
8170 status
= MagickReadImage (image_wand
, filename
);
8173 filename_hint
= imagemagick_filename_hint (img
->spec
, hint_buffer
);
8174 MagickSetFilename (image_wand
, filename_hint
);
8175 status
= MagickReadImageBlob (image_wand
, contents
, size
);
8178 if (status
== MagickFalse
)
8180 imagemagick_error (image_wand
);
8181 DestroyMagickWand (image_wand
);
8185 if (ino
< 0 || ino
>= MagickGetNumberImages (image_wand
))
8187 image_error ("Invalid image number `%s' in image `%s'",
8189 DestroyMagickWand (image_wand
);
8193 if (MagickGetNumberImages (image_wand
) > 1)
8196 Fcons (make_number (MagickGetNumberImages (image_wand
)),
8199 /* If we have an animated image, get the new wand based on the
8201 if (MagickGetNumberImages (image_wand
) > 1)
8203 MagickWand
*super_wand
= image_wand
;
8204 image_wand
= imagemagick_compute_animated_image (super_wand
, ino
);
8206 image_wand
= super_wand
;
8208 DestroyMagickWand (super_wand
);
8211 /* Retrieve the frame's background color, for use later. */
8214 Lisp_Object specified_bg
;
8216 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8217 if (!STRINGP (specified_bg
)
8218 || !x_defined_color (f
, SSDATA (specified_bg
), &bgcolor
, 0))
8219 x_query_frame_background_color (f
, &bgcolor
);
8221 bg_wand
= NewPixelWand ();
8222 PixelSetRed (bg_wand
, (double) bgcolor
.red
/ 65535);
8223 PixelSetGreen (bg_wand
, (double) bgcolor
.green
/ 65535);
8224 PixelSetBlue (bg_wand
, (double) bgcolor
.blue
/ 65535);
8227 compute_image_size (MagickGetImageWidth (image_wand
),
8228 MagickGetImageHeight (image_wand
),
8229 img
->spec
, &desired_width
, &desired_height
);
8231 if (desired_width
!= -1 && desired_height
!= -1)
8233 status
= MagickScaleImage (image_wand
, desired_width
, desired_height
);
8234 if (status
== MagickFalse
)
8236 image_error ("Imagemagick scale failed", Qnil
, Qnil
);
8237 imagemagick_error (image_wand
);
8238 goto imagemagick_error
;
8242 /* crop behaves similar to image slicing in Emacs but is more memory
8244 crop
= image_spec_value (img
->spec
, QCcrop
, NULL
);
8246 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop
)))
8248 /* After some testing, it seems MagickCropImage is the fastest crop
8249 function in ImageMagick. This crop function seems to do less copying
8250 than the alternatives, but it still reads the entire image into memory
8251 before cropping, which is apparently difficult to avoid when using
8253 size_t crop_width
= XINT (XCAR (crop
));
8255 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop
)))
8257 size_t crop_height
= XINT (XCAR (crop
));
8259 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (ssize_t
, XCAR (crop
)))
8261 ssize_t crop_x
= XINT (XCAR (crop
));
8263 if (CONSP (crop
) && TYPE_RANGED_INTEGERP (ssize_t
, XCAR (crop
)))
8265 ssize_t crop_y
= XINT (XCAR (crop
));
8266 MagickCropImage (image_wand
, crop_width
, crop_height
,
8273 /* Furthermore :rotation. we need background color and angle for
8276 TODO background handling for rotation specified_bg =
8277 image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
8279 value
= image_spec_value (img
->spec
, QCrotation
, NULL
);
8282 rotation
= extract_float (value
);
8283 status
= MagickRotateImage (image_wand
, bg_wand
, rotation
);
8284 if (status
== MagickFalse
)
8286 image_error ("Imagemagick image rotate failed", Qnil
, Qnil
);
8287 imagemagick_error (image_wand
);
8288 goto imagemagick_error
;
8292 /* Set the canvas background color to the frame or specified
8293 background, and flatten the image. Note: as of ImageMagick
8294 6.6.0, SVG image transparency is not handled properly
8295 (e.g. etc/images/splash.svg shows a white background always). */
8297 MagickWand
*new_wand
;
8298 MagickSetImageBackgroundColor (image_wand
, bg_wand
);
8299 #ifdef HAVE_MAGICKMERGEIMAGELAYERS
8300 new_wand
= MagickMergeImageLayers (image_wand
, MergeLayer
);
8302 new_wand
= MagickFlattenImages (image_wand
);
8304 DestroyMagickWand (image_wand
);
8305 image_wand
= new_wand
;
8308 /* Finally we are done manipulating the image. Figure out the
8309 resulting width/height and transfer ownership to Emacs. */
8310 height
= MagickGetImageHeight (image_wand
);
8311 width
= MagickGetImageWidth (image_wand
);
8313 if (! (width
<= INT_MAX
&& height
<= INT_MAX
8314 && check_image_size (f
, width
, height
)))
8316 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8317 goto imagemagick_error
;
8320 /* We can now get a valid pixel buffer from the imagemagick file, if all
8323 init_color_table ();
8325 #if defined (HAVE_MAGICKEXPORTIMAGEPIXELS) && ! defined (HAVE_NS)
8326 if (imagemagick_render_type
!= 0)
8328 /* Magicexportimage is normally faster than pixelpushing. This
8329 method is also well tested. Some aspects of this method are
8330 ad-hoc and needs to be more researched. */
8331 int imagedepth
= 24; /*MagickGetImageDepth(image_wand);*/
8332 const char *exportdepth
= imagedepth
<= 8 ? "I" : "BGRP"; /*"RGBP";*/
8333 /* Try to create a x pixmap to hold the imagemagick pixmap. */
8334 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, imagedepth
,
8337 #ifdef COLOR_TABLE_SUPPORT
8338 free_color_table ();
8340 image_error ("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
8341 goto imagemagick_error
;
8344 /* Oddly, the below code doesn't seem to work:*/
8345 /* switch(ximg->bitmap_unit){ */
8347 /* pixelwidth=CharPixel; */
8350 /* pixelwidth=ShortPixel; */
8353 /* pixelwidth=LongPixel; */
8357 Here im just guessing the format of the bitmap.
8358 happens to work fine for:
8361 seems about 3 times as fast as pixel pushing(not carefully measured)
8363 pixelwidth
= CharPixel
; /*??? TODO figure out*/
8364 MagickExportImagePixels (image_wand
, 0, 0, width
, height
,
8365 exportdepth
, pixelwidth
, ximg
->data
);
8368 #endif /* HAVE_MAGICKEXPORTIMAGEPIXELS */
8370 size_t image_height
;
8372 /* Try to create a x pixmap to hold the imagemagick pixmap. */
8373 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0,
8376 #ifdef COLOR_TABLE_SUPPORT
8377 free_color_table ();
8379 image_error ("Imagemagick X bitmap allocation failure", Qnil
, Qnil
);
8380 goto imagemagick_error
;
8383 /* Copy imagemagick image to x with primitive yet robust pixel
8384 pusher loop. This has been tested a lot with many different
8387 /* Copy pixels from the imagemagick image structure to the x image map. */
8388 iterator
= NewPixelIterator (image_wand
);
8391 #ifdef COLOR_TABLE_SUPPORT
8392 free_color_table ();
8394 x_destroy_x_image (ximg
);
8395 image_error ("Imagemagick pixel iterator creation failed",
8397 goto imagemagick_error
;
8400 image_height
= MagickGetImageHeight (image_wand
);
8401 for (y
= 0; y
< image_height
; y
++)
8403 pixels
= PixelGetNextIteratorRow (iterator
, &width
);
8406 for (x
= 0; x
< (long) width
; x
++)
8408 PixelGetMagickColor (pixels
[x
], &pixel
);
8409 XPutPixel (ximg
, x
, y
,
8410 lookup_rgb_color (f
,
8416 DestroyPixelIterator (iterator
);
8419 #ifdef COLOR_TABLE_SUPPORT
8420 /* Remember colors allocated for this image. */
8421 img
->colors
= colors_in_color_table (&img
->ncolors
);
8422 free_color_table ();
8423 #endif /* COLOR_TABLE_SUPPORT */
8426 img
->height
= height
;
8428 /* Put ximg into the image. */
8429 image_put_x_image (f
, img
, ximg
, 0);
8431 /* Final cleanup. image_wand should be the only resource left. */
8432 DestroyMagickWand (image_wand
);
8433 if (bg_wand
) DestroyPixelWand (bg_wand
);
8435 /* `MagickWandTerminus' terminates the imagemagick environment. */
8436 MagickWandTerminus ();
8441 DestroyMagickWand (image_wand
);
8442 if (bg_wand
) DestroyPixelWand (bg_wand
);
8444 MagickWandTerminus ();
8445 /* TODO more cleanup. */
8446 image_error ("Error parsing IMAGEMAGICK image `%s'", img
->spec
, Qnil
);
8451 /* Load IMAGEMAGICK image IMG for use on frame F. Value is true if
8452 successful. this function will go into the imagemagick_type structure, and
8453 the prototype thus needs to be compatible with that structure. */
8456 imagemagick_load (struct frame
*f
, struct image
*img
)
8459 Lisp_Object file_name
;
8461 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8462 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8463 if (STRINGP (file_name
))
8467 file
= x_find_image_file (file_name
);
8468 if (!STRINGP (file
))
8470 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8474 file
= ansi_encode_filename (file
);
8476 success_p
= imagemagick_load_image (f
, img
, 0, 0, SSDATA (file
));
8478 /* Else its not a file, its a lisp object. Load the image from a
8479 lisp object rather than a file. */
8484 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8485 if (!STRINGP (data
))
8487 image_error ("Invalid image data `%s'", data
, Qnil
);
8490 success_p
= imagemagick_load_image (f
, img
, SDATA (data
),
8491 SBYTES (data
), NULL
);
8497 DEFUN ("imagemagick-types", Fimagemagick_types
, Simagemagick_types
, 0, 0, 0,
8498 doc
: /* Return a list of image types supported by ImageMagick.
8499 Each entry in this list is a symbol named after an ImageMagick format
8500 tag. See the ImageMagick manual for a list of ImageMagick formats and
8501 their descriptions (http://www.imagemagick.org/script/formats.php).
8502 You can also try the shell command: `identify -list format'.
8504 Note that ImageMagick recognizes many file-types that Emacs does not
8505 recognize as images, such as C. See `imagemagick-types-enable'
8506 and `imagemagick-types-inhibit'. */)
8509 Lisp_Object typelist
= Qnil
;
8514 Lisp_Object Qimagemagicktype
;
8516 GetExceptionInfo(&ex
);
8517 imtypes
= GetMagickList ("*", &numf
, &ex
);
8518 DestroyExceptionInfo(&ex
);
8520 for (i
= 0; i
< numf
; i
++)
8522 Qimagemagicktype
= intern (imtypes
[i
]);
8523 typelist
= Fcons (Qimagemagicktype
, typelist
);
8524 imtypes
[i
] = MagickRelinquishMemory (imtypes
[i
]);
8527 MagickRelinquishMemory (imtypes
);
8528 return Fnreverse (typelist
);
8531 #endif /* defined (HAVE_IMAGEMAGICK) */
8535 /***********************************************************************
8537 ***********************************************************************/
8539 #if defined (HAVE_RSVG)
8541 /* Function prototypes. */
8543 static bool svg_image_p (Lisp_Object object
);
8544 static bool svg_load (struct frame
*f
, struct image
*img
);
8546 static bool svg_load_image (struct frame
*, struct image
*,
8547 unsigned char *, ptrdiff_t);
8549 /* The symbol `svg' identifying images of this type. */
8551 static Lisp_Object Qsvg
;
8553 /* Indices of image specification fields in svg_format, below. */
8555 enum svg_keyword_index
8570 /* Vector of image_keyword structures describing the format
8571 of valid user-defined image specifications. */
8573 static const struct image_keyword svg_format
[SVG_LAST
] =
8575 {":type", IMAGE_SYMBOL_VALUE
, 1},
8576 {":data", IMAGE_STRING_VALUE
, 0},
8577 {":file", IMAGE_STRING_VALUE
, 0},
8578 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8579 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
8580 {":relief", IMAGE_INTEGER_VALUE
, 0},
8581 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8582 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8583 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8584 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8587 #if defined HAVE_NTGUI && defined WINDOWSNT
8588 static bool init_svg_functions (void);
8590 #define init_svg_functions NULL
8593 /* Structure describing the image type `svg'. Its the same type of
8594 structure defined for all image formats, handled by emacs image
8595 functions. See struct image_type in dispextern.h. */
8597 static struct image_type svg_type
=
8608 /* Return true if OBJECT is a valid SVG image specification. Do
8609 this by calling parse_image_spec and supplying the keywords that
8610 identify the SVG format. */
8613 svg_image_p (Lisp_Object object
)
8615 struct image_keyword fmt
[SVG_LAST
];
8616 memcpy (fmt
, svg_format
, sizeof fmt
);
8618 if (!parse_image_spec (object
, fmt
, SVG_LAST
, Qsvg
))
8621 /* Must specify either the :data or :file keyword. */
8622 return fmt
[SVG_FILE
].count
+ fmt
[SVG_DATA
].count
== 1;
8625 #include <librsvg/rsvg.h>
8629 /* SVG library functions. */
8630 DEF_IMGLIB_FN (RsvgHandle
*, rsvg_handle_new
, (void));
8631 DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions
, (RsvgHandle
*, RsvgDimensionData
*));
8632 DEF_IMGLIB_FN (gboolean
, rsvg_handle_write
, (RsvgHandle
*, const guchar
*, gsize
, GError
**));
8633 DEF_IMGLIB_FN (gboolean
, rsvg_handle_close
, (RsvgHandle
*, GError
**));
8634 DEF_IMGLIB_FN (GdkPixbuf
*, rsvg_handle_get_pixbuf
, (RsvgHandle
*));
8636 DEF_IMGLIB_FN (int, gdk_pixbuf_get_width
, (const GdkPixbuf
*));
8637 DEF_IMGLIB_FN (int, gdk_pixbuf_get_height
, (const GdkPixbuf
*));
8638 DEF_IMGLIB_FN (guchar
*, gdk_pixbuf_get_pixels
, (const GdkPixbuf
*));
8639 DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride
, (const GdkPixbuf
*));
8640 DEF_IMGLIB_FN (GdkColorspace
, gdk_pixbuf_get_colorspace
, (const GdkPixbuf
*));
8641 DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels
, (const GdkPixbuf
*));
8642 DEF_IMGLIB_FN (gboolean
, gdk_pixbuf_get_has_alpha
, (const GdkPixbuf
*));
8643 DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample
, (const GdkPixbuf
*));
8645 #if ! GLIB_CHECK_VERSION (2, 36, 0)
8646 DEF_IMGLIB_FN (void, g_type_init
, (void));
8648 DEF_IMGLIB_FN (void, g_object_unref
, (gpointer
));
8649 DEF_IMGLIB_FN (void, g_error_free
, (GError
*));
8651 Lisp_Object Qgdk_pixbuf
, Qglib
, Qgobject
;
8654 init_svg_functions (void)
8656 HMODULE library
, gdklib
= NULL
, glib
= NULL
, gobject
= NULL
;
8658 if (!(glib
= w32_delayed_load (Qglib
))
8659 || !(gobject
= w32_delayed_load (Qgobject
))
8660 || !(gdklib
= w32_delayed_load (Qgdk_pixbuf
))
8661 || !(library
= w32_delayed_load (Qsvg
)))
8663 if (gdklib
) FreeLibrary (gdklib
);
8664 if (gobject
) FreeLibrary (gobject
);
8665 if (glib
) FreeLibrary (glib
);
8669 LOAD_IMGLIB_FN (library
, rsvg_handle_new
);
8670 LOAD_IMGLIB_FN (library
, rsvg_handle_get_dimensions
);
8671 LOAD_IMGLIB_FN (library
, rsvg_handle_write
);
8672 LOAD_IMGLIB_FN (library
, rsvg_handle_close
);
8673 LOAD_IMGLIB_FN (library
, rsvg_handle_get_pixbuf
);
8675 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_width
);
8676 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_height
);
8677 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_pixels
);
8678 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_rowstride
);
8679 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_colorspace
);
8680 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_n_channels
);
8681 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_has_alpha
);
8682 LOAD_IMGLIB_FN (gdklib
, gdk_pixbuf_get_bits_per_sample
);
8684 #if ! GLIB_CHECK_VERSION (2, 36, 0)
8685 LOAD_IMGLIB_FN (gobject
, g_type_init
);
8687 LOAD_IMGLIB_FN (gobject
, g_object_unref
);
8688 LOAD_IMGLIB_FN (glib
, g_error_free
);
8694 /* The following aliases for library functions allow dynamic loading
8695 to be used on some platforms. */
8696 #define fn_rsvg_handle_new rsvg_handle_new
8697 #define fn_rsvg_handle_get_dimensions rsvg_handle_get_dimensions
8698 #define fn_rsvg_handle_write rsvg_handle_write
8699 #define fn_rsvg_handle_close rsvg_handle_close
8700 #define fn_rsvg_handle_get_pixbuf rsvg_handle_get_pixbuf
8702 #define fn_gdk_pixbuf_get_width gdk_pixbuf_get_width
8703 #define fn_gdk_pixbuf_get_height gdk_pixbuf_get_height
8704 #define fn_gdk_pixbuf_get_pixels gdk_pixbuf_get_pixels
8705 #define fn_gdk_pixbuf_get_rowstride gdk_pixbuf_get_rowstride
8706 #define fn_gdk_pixbuf_get_colorspace gdk_pixbuf_get_colorspace
8707 #define fn_gdk_pixbuf_get_n_channels gdk_pixbuf_get_n_channels
8708 #define fn_gdk_pixbuf_get_has_alpha gdk_pixbuf_get_has_alpha
8709 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
8711 #if ! GLIB_CHECK_VERSION (2, 36, 0)
8712 #define fn_g_type_init g_type_init
8714 #define fn_g_object_unref g_object_unref
8715 #define fn_g_error_free g_error_free
8716 #endif /* !WINDOWSNT */
8718 /* Load SVG image IMG for use on frame F. Value is true if
8722 svg_load (struct frame
*f
, struct image
*img
)
8725 Lisp_Object file_name
;
8727 /* If IMG->spec specifies a file name, create a non-file spec from it. */
8728 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
8729 if (STRINGP (file_name
))
8732 unsigned char *contents
;
8735 file
= x_find_image_file (file_name
);
8736 if (!STRINGP (file
))
8738 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
8742 /* Read the entire file into memory. */
8743 contents
= slurp_file (SSDATA (file
), &size
);
8744 if (contents
== NULL
)
8746 image_error ("Error loading SVG image `%s'", img
->spec
, Qnil
);
8749 /* If the file was slurped into memory properly, parse it. */
8750 success_p
= svg_load_image (f
, img
, contents
, size
);
8753 /* Else its not a file, its a lisp object. Load the image from a
8754 lisp object rather than a file. */
8759 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8760 if (!STRINGP (data
))
8762 image_error ("Invalid image data `%s'", data
, Qnil
);
8765 success_p
= svg_load_image (f
, img
, SDATA (data
), SBYTES (data
));
8771 /* svg_load_image is a helper function for svg_load, which does the
8772 actual loading given contents and size, apart from frame and image
8773 structures, passed from svg_load.
8775 Uses librsvg to do most of the image processing.
8777 Returns true when successful. */
8779 svg_load_image (struct frame
*f
, /* Pointer to emacs frame structure. */
8780 struct image
*img
, /* Pointer to emacs image structure. */
8781 unsigned char *contents
, /* String containing the SVG XML data to be parsed. */
8782 ptrdiff_t size
) /* Size of data in bytes. */
8784 RsvgHandle
*rsvg_handle
;
8785 RsvgDimensionData dimension_data
;
8790 const guint8
*pixels
;
8793 Lisp_Object specified_bg
;
8798 #if ! GLIB_CHECK_VERSION (2, 36, 0)
8799 /* g_type_init is a glib function that must be called prior to
8800 using gnome type library functions (obsolete since 2.36.0). */
8804 /* Make a handle to a new rsvg object. */
8805 rsvg_handle
= fn_rsvg_handle_new ();
8807 /* Parse the contents argument and fill in the rsvg_handle. */
8808 fn_rsvg_handle_write (rsvg_handle
, contents
, size
, &err
);
8809 if (err
) goto rsvg_error
;
8811 /* The parsing is complete, rsvg_handle is ready to used, close it
8812 for further writes. */
8813 fn_rsvg_handle_close (rsvg_handle
, &err
);
8814 if (err
) goto rsvg_error
;
8816 fn_rsvg_handle_get_dimensions (rsvg_handle
, &dimension_data
);
8817 if (! check_image_size (f
, dimension_data
.width
, dimension_data
.height
))
8819 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
8823 /* We can now get a valid pixel buffer from the svg file, if all
8825 pixbuf
= fn_rsvg_handle_get_pixbuf (rsvg_handle
);
8826 if (!pixbuf
) goto rsvg_error
;
8827 fn_g_object_unref (rsvg_handle
);
8829 /* Extract some meta data from the svg handle. */
8830 width
= fn_gdk_pixbuf_get_width (pixbuf
);
8831 height
= fn_gdk_pixbuf_get_height (pixbuf
);
8832 pixels
= fn_gdk_pixbuf_get_pixels (pixbuf
);
8833 rowstride
= fn_gdk_pixbuf_get_rowstride (pixbuf
);
8835 /* Validate the svg meta data. */
8836 eassert (fn_gdk_pixbuf_get_colorspace (pixbuf
) == GDK_COLORSPACE_RGB
);
8837 eassert (fn_gdk_pixbuf_get_n_channels (pixbuf
) == 4);
8838 eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf
));
8839 eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf
) == 8);
8841 /* Try to create a x pixmap to hold the svg pixmap. */
8842 if (!image_create_x_image_and_pixmap (f
, img
, width
, height
, 0, &ximg
, 0))
8844 fn_g_object_unref (pixbuf
);
8848 init_color_table ();
8850 /* Handle alpha channel by combining the image with a background
8852 specified_bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
8853 if (!STRINGP (specified_bg
)
8854 || !x_defined_color (f
, SSDATA (specified_bg
), &background
, 0))
8855 x_query_frame_background_color (f
, &background
);
8857 /* SVG pixmaps specify transparency in the last byte, so right
8858 shift 8 bits to get rid of it, since emacs doesn't support
8860 background
.red
>>= 8;
8861 background
.green
>>= 8;
8862 background
.blue
>>= 8;
8864 /* This loop handles opacity values, since Emacs assumes
8865 non-transparent images. Each pixel must be "flattened" by
8866 calculating the resulting color, given the transparency of the
8867 pixel, and the image background color. */
8868 for (y
= 0; y
< height
; ++y
)
8870 for (x
= 0; x
< width
; ++x
)
8880 opacity
= *pixels
++;
8882 red
= ((red
* opacity
)
8883 + (background
.red
* ((1 << 8) - opacity
)));
8884 green
= ((green
* opacity
)
8885 + (background
.green
* ((1 << 8) - opacity
)));
8886 blue
= ((blue
* opacity
)
8887 + (background
.blue
* ((1 << 8) - opacity
)));
8889 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, red
, green
, blue
));
8892 pixels
+= rowstride
- 4 * width
;
8895 #ifdef COLOR_TABLE_SUPPORT
8896 /* Remember colors allocated for this image. */
8897 img
->colors
= colors_in_color_table (&img
->ncolors
);
8898 free_color_table ();
8899 #endif /* COLOR_TABLE_SUPPORT */
8901 fn_g_object_unref (pixbuf
);
8904 img
->height
= height
;
8906 /* Maybe fill in the background field while we have ximg handy.
8907 Casting avoids a GCC warning. */
8908 IMAGE_BACKGROUND (img
, f
, (XImagePtr_or_DC
)ximg
);
8910 /* Put ximg into the image. */
8911 image_put_x_image (f
, img
, ximg
, 0);
8916 fn_g_object_unref (rsvg_handle
);
8917 /* FIXME: Use error->message so the user knows what is the actual
8918 problem with the image. */
8919 image_error ("Error parsing SVG image `%s'", img
->spec
, Qnil
);
8920 fn_g_error_free (err
);
8924 #endif /* defined (HAVE_RSVG) */
8929 /***********************************************************************
8931 ***********************************************************************/
8933 #ifdef HAVE_X_WINDOWS
8934 #define HAVE_GHOSTSCRIPT 1
8935 #endif /* HAVE_X_WINDOWS */
8937 #ifdef HAVE_GHOSTSCRIPT
8939 static bool gs_image_p (Lisp_Object object
);
8940 static bool gs_load (struct frame
*f
, struct image
*img
);
8941 static void gs_clear_image (struct frame
*f
, struct image
*img
);
8943 /* Keyword symbols. */
8945 static Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8947 /* Indices of image specification fields in gs_format, below. */
8949 enum gs_keyword_index
8967 /* Vector of image_keyword structures describing the format
8968 of valid user-defined image specifications. */
8970 static const struct image_keyword gs_format
[GS_LAST
] =
8972 {":type", IMAGE_SYMBOL_VALUE
, 1},
8973 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8974 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
8975 {":file", IMAGE_STRING_VALUE
, 1},
8976 {":loader", IMAGE_FUNCTION_VALUE
, 0},
8977 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
8978 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8979 {":margin", IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR
, 0},
8980 {":relief", IMAGE_INTEGER_VALUE
, 0},
8981 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8982 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8983 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8984 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8987 /* Structure describing the image type `ghostscript'. */
8989 static struct image_type gs_type
=
9000 /* Free X resources of Ghostscript image IMG which is used on frame F. */
9003 gs_clear_image (struct frame
*f
, struct image
*img
)
9005 x_clear_image (f
, img
);
9009 /* Return true if OBJECT is a valid Ghostscript image
9013 gs_image_p (Lisp_Object object
)
9015 struct image_keyword fmt
[GS_LAST
];
9019 memcpy (fmt
, gs_format
, sizeof fmt
);
9021 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
9024 /* Bounding box must be a list or vector containing 4 integers. */
9025 tem
= fmt
[GS_BOUNDING_BOX
].value
;
9028 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
9029 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
9034 else if (VECTORP (tem
))
9036 if (ASIZE (tem
) != 4)
9038 for (i
= 0; i
< 4; ++i
)
9039 if (!INTEGERP (AREF (tem
, i
)))
9049 /* Load Ghostscript image IMG for use on frame F. Value is true
9053 gs_load (struct frame
*f
, struct image
*img
)
9055 uprintmax_t printnum1
, printnum2
;
9056 char buffer
[sizeof " " + INT_STRLEN_BOUND (printmax_t
)];
9057 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
9059 double in_width
, in_height
;
9060 Lisp_Object pixel_colors
= Qnil
;
9062 /* Compute pixel size of pixmap needed from the given size in the
9063 image specification. Sizes in the specification are in pt. 1 pt
9064 = 1/72 in, xdpi and ydpi are stored in the frame's X display
9066 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
9067 in_width
= INTEGERP (pt_width
) ? XFASTINT (pt_width
) / 72.0 : 0;
9068 in_width
*= FRAME_RES_X (f
);
9069 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
9070 in_height
= INTEGERP (pt_height
) ? XFASTINT (pt_height
) / 72.0 : 0;
9071 in_height
*= FRAME_RES_Y (f
);
9073 if (! (in_width
<= INT_MAX
&& in_height
<= INT_MAX
9074 && check_image_size (f
, in_width
, in_height
)))
9076 image_error ("Invalid image size (see `max-image-size')", Qnil
, Qnil
);
9079 img
->width
= in_width
;
9080 img
->height
= in_height
;
9082 /* Create the pixmap. */
9083 eassert (img
->pixmap
== NO_PIXMAP
);
9085 if (x_check_image_size (0, img
->width
, img
->height
))
9087 /* Only W32 version did BLOCK_INPUT here. ++kfs */
9089 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9090 img
->width
, img
->height
,
9091 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
9097 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
9101 /* Call the loader to fill the pixmap. It returns a process object
9102 if successful. We do not record_unwind_protect here because
9103 other places in redisplay like calling window scroll functions
9104 don't either. Let the Lisp loader use `unwind-protect' instead. */
9105 printnum1
= FRAME_X_WINDOW (f
);
9106 printnum2
= img
->pixmap
;
9107 window_and_pixmap_id
9108 = make_formatted_string (buffer
, "%"pMu
" %"pMu
, printnum1
, printnum2
);
9110 printnum1
= FRAME_FOREGROUND_PIXEL (f
);
9111 printnum2
= FRAME_BACKGROUND_PIXEL (f
);
9113 = make_formatted_string (buffer
, "%"pMu
" %"pMu
, printnum1
, printnum2
);
9115 XSETFRAME (frame
, f
);
9116 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
9118 loader
= intern ("gs-load-image");
9120 img
->lisp_data
= call6 (loader
, frame
, img
->spec
,
9121 make_number (img
->width
),
9122 make_number (img
->height
),
9123 window_and_pixmap_id
,
9125 return PROCESSP (img
->lisp_data
);
9129 /* Kill the Ghostscript process that was started to fill PIXMAP on
9130 frame F. Called from XTread_socket when receiving an event
9131 telling Emacs that Ghostscript has finished drawing. */
9134 x_kill_gs_process (Pixmap pixmap
, struct frame
*f
)
9136 struct image_cache
*c
= FRAME_IMAGE_CACHE (f
);
9141 /* Find the image containing PIXMAP. */
9142 for (i
= 0; i
< c
->used
; ++i
)
9143 if (c
->images
[i
]->pixmap
== pixmap
)
9146 /* Should someone in between have cleared the image cache, for
9147 instance, give up. */
9151 /* Kill the GS process. We should have found PIXMAP in the image
9152 cache and its image should contain a process object. */
9154 eassert (PROCESSP (img
->lisp_data
));
9155 Fkill_process (img
->lisp_data
, Qnil
);
9156 img
->lisp_data
= Qnil
;
9158 #if defined (HAVE_X_WINDOWS)
9160 /* On displays with a mutable colormap, figure out the colors
9161 allocated for the image by looking at the pixels of an XImage for
9163 class = FRAME_X_VISUAL (f
)->class;
9164 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
9170 /* Try to get an XImage for img->pixmep. */
9171 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
9172 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
9177 /* Initialize the color table. */
9178 init_color_table ();
9180 /* For each pixel of the image, look its color up in the
9181 color table. After having done so, the color table will
9182 contain an entry for each color used by the image. */
9183 for (y
= 0; y
< img
->height
; ++y
)
9184 for (x
= 0; x
< img
->width
; ++x
)
9186 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
9187 lookup_pixel_color (f
, pixel
);
9190 /* Record colors in the image. Free color table and XImage. */
9191 #ifdef COLOR_TABLE_SUPPORT
9192 img
->colors
= colors_in_color_table (&img
->ncolors
);
9193 free_color_table ();
9195 XDestroyImage (ximg
);
9197 #if 0 /* This doesn't seem to be the case. If we free the colors
9198 here, we get a BadAccess later in x_clear_image when
9199 freeing the colors. */
9200 /* We have allocated colors once, but Ghostscript has also
9201 allocated colors on behalf of us. So, to get the
9202 reference counts right, free them once. */
9204 x_free_colors (f
, img
->colors
, img
->ncolors
);
9208 image_error ("Cannot get X image of `%s'; colors will not be freed",
9213 #endif /* HAVE_X_WINDOWS */
9215 /* Now that we have the pixmap, compute mask and transform the
9216 image if requested. */
9218 postprocess_image (f
, img
);
9222 #endif /* HAVE_GHOSTSCRIPT */
9225 /***********************************************************************
9227 ***********************************************************************/
9231 DEFUN ("imagep", Fimagep
, Simagep
, 1, 1, 0,
9232 doc
: /* Value is non-nil if SPEC is a valid image specification. */)
9235 return valid_image_p (spec
) ? Qt
: Qnil
;
9239 DEFUN ("lookup-image", Flookup_image
, Slookup_image
, 1, 1, 0, "")
9244 if (valid_image_p (spec
))
9245 id
= lookup_image (SELECTED_FRAME (), spec
);
9248 return make_number (id
);
9251 #endif /* GLYPH_DEBUG */
9254 /***********************************************************************
9256 ***********************************************************************/
9258 DEFUN ("init-image-library", Finit_image_library
, Sinit_image_library
, 1, 1, 0,
9259 doc
: /* Initialize image library implementing image type TYPE.
9260 Return non-nil if TYPE is a supported image type.
9262 If image libraries are loaded dynamically (currently only the case on
9263 MS-Windows), load the library for TYPE if it is not yet loaded, using
9264 the library file(s) specified by `dynamic-library-alist'. */)
9267 return lookup_image_type (type
) ? Qt
: Qnil
;
9270 /* Look up image type TYPE, and return a pointer to its image_type
9271 structure. Return 0 if TYPE is not a known image type. */
9273 static struct image_type
*
9274 lookup_image_type (Lisp_Object type
)
9276 /* Types pbm and xbm are built-in and always available. */
9277 if (EQ (type
, Qpbm
))
9278 return define_image_type (&pbm_type
);
9280 if (EQ (type
, Qxbm
))
9281 return define_image_type (&xbm_type
);
9283 #if defined (HAVE_XPM) || defined (HAVE_NS)
9284 if (EQ (type
, Qxpm
))
9285 return define_image_type (&xpm_type
);
9288 #if defined (HAVE_JPEG) || defined (HAVE_NS)
9289 if (EQ (type
, Qjpeg
))
9290 return define_image_type (&jpeg_type
);
9293 #if defined (HAVE_TIFF) || defined (HAVE_NS)
9294 if (EQ (type
, Qtiff
))
9295 return define_image_type (&tiff_type
);
9298 #if defined (HAVE_GIF) || defined (HAVE_NS)
9299 if (EQ (type
, Qgif
))
9300 return define_image_type (&gif_type
);
9303 #if defined (HAVE_PNG) || defined (HAVE_NS)
9304 if (EQ (type
, Qpng
))
9305 return define_image_type (&png_type
);
9308 #if defined (HAVE_RSVG)
9309 if (EQ (type
, Qsvg
))
9310 return define_image_type (&svg_type
);
9313 #if defined (HAVE_IMAGEMAGICK)
9314 if (EQ (type
, Qimagemagick
))
9315 return define_image_type (&imagemagick_type
);
9318 #ifdef HAVE_GHOSTSCRIPT
9319 if (EQ (type
, Qpostscript
))
9320 return define_image_type (&gs_type
);
9326 /* Reset image_types before dumping.
9327 Called from Fdump_emacs. */
9330 reset_image_types (void)
9334 struct image_type
*next
= image_types
->next
;
9335 xfree (image_types
);
9341 syms_of_image (void)
9343 /* Initialize this only once; it will be reset before dumping. */
9346 /* Must be defined now because we're going to update it below, while
9347 defining the supported image types. */
9348 DEFVAR_LISP ("image-types", Vimage_types
,
9349 doc
: /* List of potentially supported image types.
9350 Each element of the list is a symbol for an image type, like 'jpeg or 'png.
9351 To check whether it is really supported, use `image-type-available-p'. */);
9352 Vimage_types
= Qnil
;
9354 DEFVAR_LISP ("max-image-size", Vmax_image_size
,
9355 doc
: /* Maximum size of images.
9356 Emacs will not load an image into memory if its pixel width or
9357 pixel height exceeds this limit.
9359 If the value is an integer, it directly specifies the maximum
9360 image height and width, measured in pixels. If it is a floating
9361 point number, it specifies the maximum image height and width
9362 as a ratio to the frame height and width. If the value is
9363 non-numeric, there is no explicit limit on the size of images. */);
9364 Vmax_image_size
= make_float (MAX_IMAGE_SIZE
);
9366 DEFSYM (Qcount
, "count");
9367 DEFSYM (Qextension_data
, "extension-data");
9368 DEFSYM (Qdelay
, "delay");
9370 DEFSYM (QCascent
, ":ascent");
9371 DEFSYM (QCmargin
, ":margin");
9372 DEFSYM (QCrelief
, ":relief");
9373 DEFSYM (QCconversion
, ":conversion");
9374 DEFSYM (QCcolor_symbols
, ":color-symbols");
9375 DEFSYM (QCheuristic_mask
, ":heuristic-mask");
9376 DEFSYM (QCindex
, ":index");
9377 DEFSYM (QCgeometry
, ":geometry");
9378 DEFSYM (QCcrop
, ":crop");
9379 DEFSYM (QCrotation
, ":rotation");
9380 DEFSYM (QCmatrix
, ":matrix");
9381 DEFSYM (QCcolor_adjustment
, ":color-adjustment");
9382 DEFSYM (QCmask
, ":mask");
9384 DEFSYM (Qlaplace
, "laplace");
9385 DEFSYM (Qemboss
, "emboss");
9386 DEFSYM (Qedge_detection
, "edge-detection");
9387 DEFSYM (Qheuristic
, "heuristic");
9389 DEFSYM (Qpostscript
, "postscript");
9390 DEFSYM (QCmax_width
, ":max-width");
9391 DEFSYM (QCmax_height
, ":max-height");
9392 #ifdef HAVE_GHOSTSCRIPT
9393 ADD_IMAGE_TYPE (Qpostscript
);
9394 DEFSYM (QCloader
, ":loader");
9395 DEFSYM (QCbounding_box
, ":bounding-box");
9396 DEFSYM (QCpt_width
, ":pt-width");
9397 DEFSYM (QCpt_height
, ":pt-height");
9398 #endif /* HAVE_GHOSTSCRIPT */
9401 DEFSYM (Qlibpng_version
, "libpng-version");
9402 Fset (Qlibpng_version
,
9404 make_number (PNG_LIBPNG_VER
)
9409 DEFSYM (Qlibgif_version
, "libgif-version");
9410 Fset (Qlibgif_version
,
9412 make_number (GIFLIB_MAJOR
* 10000
9413 + GIFLIB_MINOR
* 100
9419 DEFSYM (Qlibjpeg_version
, "libjpeg-version");
9420 Fset (Qlibjpeg_version
,
9422 make_number (JPEG_LIB_VERSION
)
9429 DEFSYM (Qpbm
, "pbm");
9430 ADD_IMAGE_TYPE (Qpbm
);
9432 DEFSYM (Qxbm
, "xbm");
9433 ADD_IMAGE_TYPE (Qxbm
);
9435 #if defined (HAVE_XPM) || defined (HAVE_NS)
9436 DEFSYM (Qxpm
, "xpm");
9437 ADD_IMAGE_TYPE (Qxpm
);
9440 #if defined (HAVE_JPEG) || defined (HAVE_NS)
9441 DEFSYM (Qjpeg
, "jpeg");
9442 ADD_IMAGE_TYPE (Qjpeg
);
9445 #if defined (HAVE_TIFF) || defined (HAVE_NS)
9446 DEFSYM (Qtiff
, "tiff");
9447 ADD_IMAGE_TYPE (Qtiff
);
9450 #if defined (HAVE_GIF) || defined (HAVE_NS)
9451 DEFSYM (Qgif
, "gif");
9452 ADD_IMAGE_TYPE (Qgif
);
9455 #if defined (HAVE_PNG) || defined (HAVE_NS)
9456 DEFSYM (Qpng
, "png");
9457 ADD_IMAGE_TYPE (Qpng
);
9460 #if defined (HAVE_IMAGEMAGICK)
9461 DEFSYM (Qimagemagick
, "imagemagick");
9462 ADD_IMAGE_TYPE (Qimagemagick
);
9465 #if defined (HAVE_RSVG)
9466 DEFSYM (Qsvg
, "svg");
9467 ADD_IMAGE_TYPE (Qsvg
);
9469 /* Other libraries used directly by svg code. */
9470 DEFSYM (Qgdk_pixbuf
, "gdk-pixbuf");
9471 DEFSYM (Qglib
, "glib");
9472 DEFSYM (Qgobject
, "gobject");
9473 #endif /* HAVE_NTGUI */
9474 #endif /* HAVE_RSVG */
9476 defsubr (&Sinit_image_library
);
9477 #ifdef HAVE_IMAGEMAGICK
9478 defsubr (&Simagemagick_types
);
9480 defsubr (&Sclear_image_cache
);
9481 defsubr (&Simage_flush
);
9482 defsubr (&Simage_size
);
9483 defsubr (&Simage_mask_p
);
9484 defsubr (&Simage_metadata
);
9488 defsubr (&Slookup_image
);
9491 DEFVAR_BOOL ("cross-disabled-images", cross_disabled_images
,
9492 doc
: /* Non-nil means always draw a cross over disabled images.
9493 Disabled images are those having a `:conversion disabled' property.
9494 A cross is always drawn on black & white displays. */);
9495 cross_disabled_images
= 0;
9497 DEFVAR_LISP ("x-bitmap-file-path", Vx_bitmap_file_path
,
9498 doc
: /* List of directories to search for window system bitmap files. */);
9499 Vx_bitmap_file_path
= decode_env_path (0, PATH_BITMAPS
, 0);
9501 DEFVAR_LISP ("image-cache-eviction-delay", Vimage_cache_eviction_delay
,
9502 doc
: /* Maximum time after which images are removed from the cache.
9503 When an image has not been displayed this many seconds, Emacs
9504 automatically removes it from the image cache. If the cache contains
9505 a large number of images, the actual eviction time may be shorter.
9506 The value can also be nil, meaning the cache is never cleared.
9508 The function `clear-image-cache' disregards this variable. */);
9509 Vimage_cache_eviction_delay
= make_number (300);
9510 #ifdef HAVE_IMAGEMAGICK
9511 DEFVAR_INT ("imagemagick-render-type", imagemagick_render_type
,
9512 doc
: /* Integer indicating which ImageMagick rendering method to use.
9514 0 -- the default method (pixel pushing)
9515 1 -- a newer method ("MagickExportImagePixels") that may perform
9516 better (speed etc) in some cases, but has not been as thoroughly
9517 tested with Emacs as the default method. This method requires
9518 ImageMagick version 6.4.6 (approximately) or later.
9520 /* MagickExportImagePixels is in 6.4.6-9, but not 6.4.4-10. */
9521 imagemagick_render_type
= 0;