(vc-bzr-registered): Use \0 instead of literal NULs.
[emacs.git] / src / image.c
bloba3cd319521709ad258da99a9dfe420b9a41effcf
1 /* Functions for image support on window system.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007 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, or (at your option)
10 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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 #include <config.h>
23 #include <stdio.h>
24 #include <math.h>
25 #include <ctype.h>
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
31 /* This makes the fields of a Display accessible, in Xlib header files. */
33 #define XLIB_ILLEGAL_ACCESS
35 #include "lisp.h"
36 #include "frame.h"
37 #include "window.h"
38 #include "dispextern.h"
39 #include "blockinput.h"
40 #include "systime.h"
41 #include <epaths.h>
42 #include "charset.h"
43 #include "coding.h"
46 #ifdef HAVE_X_WINDOWS
47 #include "xterm.h"
48 #include <sys/types.h>
49 #include <sys/stat.h>
51 #define COLOR_TABLE_SUPPORT 1
53 typedef struct x_bitmap_record Bitmap_Record;
54 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
55 #define NO_PIXMAP None
57 #define RGB_PIXEL_COLOR unsigned long
59 #define PIX_MASK_RETAIN 0
60 #define PIX_MASK_DRAW 1
61 #endif /* HAVE_X_WINDOWS */
64 #ifdef HAVE_NTGUI
65 #include "w32term.h"
67 /* W32_TODO : Color tables on W32. */
68 #undef COLOR_TABLE_SUPPORT
70 typedef struct w32_bitmap_record Bitmap_Record;
71 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
72 #define NO_PIXMAP 0
74 #define RGB_PIXEL_COLOR COLORREF
76 #define PIX_MASK_RETAIN 0
77 #define PIX_MASK_DRAW 1
79 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
80 #define x_defined_color w32_defined_color
81 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
82 #endif /* HAVE_NTGUI */
85 #ifdef MAC_OS
86 #include "macterm.h"
87 #include <sys/stat.h>
88 #ifndef MAC_OSX
89 #include <alloca.h>
90 #include <sys/param.h>
91 #endif
92 #if TARGET_API_MAC_CARBON
93 #ifdef MAC_OSX
94 #include <QuickTime/QuickTime.h>
95 #else /* not MAC_OSX */
96 #include <QuickTime.h>
97 #endif /* not MAC_OSX */
98 #else /* not TARGET_API_MAC_CARBON */
99 #include <Windows.h>
100 #include <Gestalt.h>
101 #include <TextUtils.h>
102 #include <ImageCompression.h>
103 #include <QuickTimeComponents.h>
104 #endif /* not TARGET_API_MAC_CARBON */
106 /* MAC_TODO : Color tables on Mac. */
107 #undef COLOR_TABLE_SUPPORT
109 #define ZPixmap 0 /* arbitrary */
110 typedef struct mac_bitmap_record Bitmap_Record;
112 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
113 #define NO_PIXMAP 0
115 #define RGB_PIXEL_COLOR unsigned long
117 /* A black pixel in a mask bitmap/pixmap means ``draw a source
118 pixel''. A white pixel means ``retain the current pixel''. */
119 #define PIX_MASK_DRAW RGB_TO_ULONG(0,0,0)
120 #define PIX_MASK_RETAIN RGB_TO_ULONG(255,255,255)
122 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
123 #define x_defined_color mac_defined_color
124 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
126 #endif /* MAC_OS */
129 /* Search path for bitmap files. */
131 Lisp_Object Vx_bitmap_file_path;
134 static void x_disable_image P_ ((struct frame *, struct image *));
135 static void x_edge_detection P_ ((struct frame *, struct image *, Lisp_Object,
136 Lisp_Object));
138 static void init_color_table P_ ((void));
139 static unsigned long lookup_rgb_color P_ ((struct frame *f, int r, int g, int b));
140 #ifdef COLOR_TABLE_SUPPORT
141 static void free_color_table P_ ((void));
142 static unsigned long *colors_in_color_table P_ ((int *n));
143 static unsigned long lookup_pixel_color P_ ((struct frame *f, unsigned long p));
144 #endif
146 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
147 id, which is just an int that this section returns. Bitmaps are
148 reference counted so they can be shared among frames.
150 Bitmap indices are guaranteed to be > 0, so a negative number can
151 be used to indicate no bitmap.
153 If you use x_create_bitmap_from_data, then you must keep track of
154 the bitmaps yourself. That is, creating a bitmap from the same
155 data more than once will not be caught. */
157 #ifdef MAC_OS
159 static XImagePtr
160 XGetImage (display, pixmap, x, y, width, height, plane_mask, format)
161 Display *display; /* not used */
162 Pixmap pixmap;
163 int x, y; /* not used */
164 unsigned int width, height; /* not used */
165 unsigned long plane_mask; /* not used */
166 int format; /* not used */
168 #if GLYPH_DEBUG
169 xassert (x == 0 && y == 0);
171 Rect ri, rp;
172 SetRect (&ri, 0, 0, width, height);
173 xassert (EqualRect (&ri, GetPixBounds (GetGWorldPixMap (pixmap), &rp)));
175 xassert (! (pixelsLocked & GetPixelsState (GetGWorldPixMap (pixmap))));
176 #endif
178 LockPixels (GetGWorldPixMap (pixmap));
180 return pixmap;
183 static void
184 XPutPixel (ximage, x, y, pixel)
185 XImagePtr ximage;
186 int x, y;
187 unsigned long pixel;
189 PixMapHandle pixmap = GetGWorldPixMap (ximage);
190 short depth = GetPixDepth (pixmap);
192 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
193 if (depth == 32)
195 char *base_addr = GetPixBaseAddr (pixmap);
196 short row_bytes = GetPixRowBytes (pixmap);
198 ((unsigned long *) (base_addr + y * row_bytes))[x] = 0xff000000 | pixel;
200 else
201 #endif
202 if (depth == 1)
204 char *base_addr = GetPixBaseAddr (pixmap);
205 short row_bytes = GetPixRowBytes (pixmap);
207 if (pixel == PIX_MASK_DRAW)
208 base_addr[y * row_bytes + x / 8] |= (1 << 7) >> (x & 7);
209 else
210 base_addr[y * row_bytes + x / 8] &= ~((1 << 7) >> (x & 7));
212 else
214 CGrafPtr old_port;
215 GDHandle old_gdh;
216 RGBColor color;
218 GetGWorld (&old_port, &old_gdh);
219 SetGWorld (ximage, NULL);
221 color.red = RED16_FROM_ULONG (pixel);
222 color.green = GREEN16_FROM_ULONG (pixel);
223 color.blue = BLUE16_FROM_ULONG (pixel);
225 SetCPixel (x, y, &color);
227 SetGWorld (old_port, old_gdh);
231 static unsigned long
232 XGetPixel (ximage, x, y)
233 XImagePtr ximage;
234 int x, y;
236 PixMapHandle pixmap = GetGWorldPixMap (ximage);
237 short depth = GetPixDepth (pixmap);
239 #if defined (WORDS_BIG_ENDIAN) || !USE_CG_DRAWING
240 if (depth == 32)
242 char *base_addr = GetPixBaseAddr (pixmap);
243 short row_bytes = GetPixRowBytes (pixmap);
245 return ((unsigned long *) (base_addr + y * row_bytes))[x] & 0x00ffffff;
247 else
248 #endif
249 if (depth == 1)
251 char *base_addr = GetPixBaseAddr (pixmap);
252 short row_bytes = GetPixRowBytes (pixmap);
254 if (base_addr[y * row_bytes + x / 8] & (1 << (~x & 7)))
255 return PIX_MASK_DRAW;
256 else
257 return PIX_MASK_RETAIN;
259 else
261 CGrafPtr old_port;
262 GDHandle old_gdh;
263 RGBColor color;
265 GetGWorld (&old_port, &old_gdh);
266 SetGWorld (ximage, NULL);
268 GetCPixel (x, y, &color);
270 SetGWorld (old_port, old_gdh);
271 return RGB_TO_ULONG (color.red >> 8, color.green >> 8, color.blue >> 8);
275 static void
276 XDestroyImage (ximg)
277 XImagePtr ximg;
279 UnlockPixels (GetGWorldPixMap (ximg));
282 #if USE_CG_DRAWING
283 static CGImageRef
284 mac_create_cg_image_from_image (f, img)
285 struct frame *f;
286 struct image *img;
288 Pixmap mask;
289 CGImageRef result = NULL;
291 BLOCK_INPUT;
292 if (img->mask)
293 mask = img->mask;
294 else
296 mask = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
297 img->width, img->height, 1);
298 if (mask)
300 CGrafPtr old_port;
301 GDHandle old_gdh;
302 Rect r;
304 GetGWorld (&old_port, &old_gdh);
305 SetGWorld (mask, NULL);
306 BackColor (blackColor); /* Don't mask. */
307 SetRect (&r, 0, 0, img->width, img->height);
308 EraseRect (&r);
309 SetGWorld (old_port, old_gdh);
312 if (mask)
314 CreateCGImageFromPixMaps (GetGWorldPixMap (img->pixmap),
315 GetGWorldPixMap (mask), &result);
316 if (mask != img->mask)
317 XFreePixmap (FRAME_X_DISPLAY (f), mask);
319 UNBLOCK_INPUT;
321 return result;
323 #endif /* USE_CG_DRAWING */
324 #endif /* MAC_OS */
327 /* Functions to access the contents of a bitmap, given an id. */
330 x_bitmap_height (f, id)
331 FRAME_PTR f;
332 int id;
334 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].height;
338 x_bitmap_width (f, id)
339 FRAME_PTR f;
340 int id;
342 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].width;
345 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
347 x_bitmap_pixmap (f, id)
348 FRAME_PTR f;
349 int id;
351 return (int) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap;
353 #endif
355 #ifdef HAVE_X_WINDOWS
357 x_bitmap_mask (f, id)
358 FRAME_PTR f;
359 int id;
361 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].mask;
363 #endif
365 /* Allocate a new bitmap record. Returns index of new record. */
367 static int
368 x_allocate_bitmap_record (f)
369 FRAME_PTR f;
371 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
372 int i;
374 if (dpyinfo->bitmaps == NULL)
376 dpyinfo->bitmaps_size = 10;
377 dpyinfo->bitmaps
378 = (Bitmap_Record *) xmalloc (dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
379 dpyinfo->bitmaps_last = 1;
380 return 1;
383 if (dpyinfo->bitmaps_last < dpyinfo->bitmaps_size)
384 return ++dpyinfo->bitmaps_last;
386 for (i = 0; i < dpyinfo->bitmaps_size; ++i)
387 if (dpyinfo->bitmaps[i].refcount == 0)
388 return i + 1;
390 dpyinfo->bitmaps_size *= 2;
391 dpyinfo->bitmaps
392 = (Bitmap_Record *) xrealloc (dpyinfo->bitmaps,
393 dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
394 return ++dpyinfo->bitmaps_last;
397 /* Add one reference to the reference count of the bitmap with id ID. */
399 void
400 x_reference_bitmap (f, id)
401 FRAME_PTR f;
402 int id;
404 ++FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].refcount;
407 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
410 x_create_bitmap_from_data (f, bits, width, height)
411 struct frame *f;
412 char *bits;
413 unsigned int width, height;
415 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
416 int id;
418 #ifdef HAVE_X_WINDOWS
419 Pixmap bitmap;
420 bitmap = XCreateBitmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
421 bits, width, height);
422 if (! bitmap)
423 return -1;
424 #endif /* HAVE_X_WINDOWS */
426 #ifdef HAVE_NTGUI
427 Pixmap bitmap;
428 bitmap = CreateBitmap (width, height,
429 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_planes,
430 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_cbits,
431 bits);
432 if (! bitmap)
433 return -1;
434 #endif /* HAVE_NTGUI */
436 #ifdef MAC_OS
437 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
438 if (width % 16 != 0)
439 return -1;
440 #endif
442 id = x_allocate_bitmap_record (f);
443 #ifdef MAC_OS
444 dpyinfo->bitmaps[id - 1].bitmap_data = (char *) xmalloc (height * width);
445 bcopy (bits, dpyinfo->bitmaps[id - 1].bitmap_data, height * width);
446 #endif /* MAC_OS */
448 dpyinfo->bitmaps[id - 1].file = NULL;
449 dpyinfo->bitmaps[id - 1].height = height;
450 dpyinfo->bitmaps[id - 1].width = width;
451 dpyinfo->bitmaps[id - 1].refcount = 1;
453 #ifdef HAVE_X_WINDOWS
454 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
455 dpyinfo->bitmaps[id - 1].have_mask = 0;
456 dpyinfo->bitmaps[id - 1].depth = 1;
457 #endif /* HAVE_X_WINDOWS */
459 #ifdef HAVE_NTGUI
460 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
461 dpyinfo->bitmaps[id - 1].hinst = NULL;
462 dpyinfo->bitmaps[id - 1].depth = 1;
463 #endif /* HAVE_NTGUI */
465 return id;
468 /* Create bitmap from file FILE for frame F. */
471 x_create_bitmap_from_file (f, file)
472 struct frame *f;
473 Lisp_Object file;
475 #ifdef MAC_OS
476 return -1; /* MAC_TODO : bitmap support */
477 #endif /* MAC_OS */
479 #ifdef HAVE_NTGUI
480 return -1; /* W32_TODO : bitmap support */
481 #endif /* HAVE_NTGUI */
483 #ifdef HAVE_X_WINDOWS
484 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
485 unsigned int width, height;
486 Pixmap bitmap;
487 int xhot, yhot, result, id;
488 Lisp_Object found;
489 int fd;
490 char *filename;
492 /* Look for an existing bitmap with the same name. */
493 for (id = 0; id < dpyinfo->bitmaps_last; ++id)
495 if (dpyinfo->bitmaps[id].refcount
496 && dpyinfo->bitmaps[id].file
497 && !strcmp (dpyinfo->bitmaps[id].file, (char *) SDATA (file)))
499 ++dpyinfo->bitmaps[id].refcount;
500 return id + 1;
504 /* Search bitmap-file-path for the file, if appropriate. */
505 fd = openp (Vx_bitmap_file_path, file, Qnil, &found, Qnil);
506 if (fd < 0)
507 return -1;
508 emacs_close (fd);
510 filename = (char *) SDATA (found);
512 result = XReadBitmapFile (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
513 filename, &width, &height, &bitmap, &xhot, &yhot);
514 if (result != BitmapSuccess)
515 return -1;
517 id = x_allocate_bitmap_record (f);
518 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
519 dpyinfo->bitmaps[id - 1].have_mask = 0;
520 dpyinfo->bitmaps[id - 1].refcount = 1;
521 dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SBYTES (file) + 1);
522 dpyinfo->bitmaps[id - 1].depth = 1;
523 dpyinfo->bitmaps[id - 1].height = height;
524 dpyinfo->bitmaps[id - 1].width = width;
525 strcpy (dpyinfo->bitmaps[id - 1].file, SDATA (file));
527 return id;
528 #endif /* HAVE_X_WINDOWS */
531 /* Free bitmap B. */
533 static void
534 Free_Bitmap_Record (dpyinfo, bm)
535 Display_Info *dpyinfo;
536 Bitmap_Record *bm;
538 #ifdef HAVE_X_WINDOWS
539 XFreePixmap (dpyinfo->display, bm->pixmap);
540 if (bm->have_mask)
541 XFreePixmap (dpyinfo->display, bm->mask);
542 #endif /* HAVE_X_WINDOWS */
544 #ifdef HAVE_NTGUI
545 DeleteObject (bm->pixmap);
546 #endif /* HAVE_NTGUI */
548 #ifdef MAC_OS
549 xfree (bm->bitmap_data); /* Added ++kfs */
550 bm->bitmap_data = NULL;
551 #endif /* MAC_OS */
553 if (bm->file)
555 xfree (bm->file);
556 bm->file = NULL;
560 /* Remove reference to bitmap with id number ID. */
562 void
563 x_destroy_bitmap (f, id)
564 FRAME_PTR f;
565 int id;
567 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
569 if (id > 0)
571 Bitmap_Record *bm = &dpyinfo->bitmaps[id - 1];
573 if (--bm->refcount == 0)
575 BLOCK_INPUT;
576 Free_Bitmap_Record (dpyinfo, bm);
577 UNBLOCK_INPUT;
582 /* Free all the bitmaps for the display specified by DPYINFO. */
584 void
585 x_destroy_all_bitmaps (dpyinfo)
586 Display_Info *dpyinfo;
588 int i;
589 Bitmap_Record *bm = dpyinfo->bitmaps;
591 for (i = 0; i < dpyinfo->bitmaps_last; i++, bm++)
592 if (bm->refcount > 0)
593 Free_Bitmap_Record (dpyinfo, bm);
595 dpyinfo->bitmaps_last = 0;
599 #ifdef HAVE_X_WINDOWS
601 /* Useful functions defined in the section
602 `Image type independent image structures' below. */
604 static unsigned long four_corners_best P_ ((XImagePtr ximg,
605 int *corners,
606 unsigned long width,
607 unsigned long height));
609 static int x_create_x_image_and_pixmap P_ ((struct frame *f, int width, int height,
610 int depth, XImagePtr *ximg,
611 Pixmap *pixmap));
613 static void x_destroy_x_image P_ ((XImagePtr ximg));
616 /* Create a mask of a bitmap. Note is this not a perfect mask.
617 It's nicer with some borders in this context */
620 x_create_bitmap_mask (f, id)
621 struct frame *f;
622 int id;
624 Pixmap pixmap, mask;
625 XImagePtr ximg, mask_img;
626 unsigned long width, height;
627 int result;
628 unsigned long bg;
629 unsigned long x, y, xp, xm, yp, ym;
630 GC gc;
632 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
634 if (!(id > 0))
635 return -1;
637 pixmap = x_bitmap_pixmap (f, id);
638 width = x_bitmap_width (f, id);
639 height = x_bitmap_height (f, id);
641 BLOCK_INPUT;
642 ximg = XGetImage (FRAME_X_DISPLAY (f), pixmap, 0, 0, width, height,
643 ~0, ZPixmap);
645 if (!ximg)
647 UNBLOCK_INPUT;
648 return -1;
651 result = x_create_x_image_and_pixmap (f, width, height, 1, &mask_img, &mask);
653 UNBLOCK_INPUT;
654 if (!result)
656 XDestroyImage (ximg);
657 return -1;
660 bg = four_corners_best (ximg, NULL, width, height);
662 for (y = 0; y < ximg->height; ++y)
664 for (x = 0; x < ximg->width; ++x)
666 xp = x != ximg->width - 1 ? x + 1 : 0;
667 xm = x != 0 ? x - 1 : ximg->width - 1;
668 yp = y != ximg->height - 1 ? y + 1 : 0;
669 ym = y != 0 ? y - 1 : ximg->height - 1;
670 if (XGetPixel (ximg, x, y) == bg
671 && XGetPixel (ximg, x, yp) == bg
672 && XGetPixel (ximg, x, ym) == bg
673 && XGetPixel (ximg, xp, y) == bg
674 && XGetPixel (ximg, xp, yp) == bg
675 && XGetPixel (ximg, xp, ym) == bg
676 && XGetPixel (ximg, xm, y) == bg
677 && XGetPixel (ximg, xm, yp) == bg
678 && XGetPixel (ximg, xm, ym) == bg)
679 XPutPixel (mask_img, x, y, 0);
680 else
681 XPutPixel (mask_img, x, y, 1);
685 xassert (interrupt_input_blocked);
686 gc = XCreateGC (FRAME_X_DISPLAY (f), mask, 0, NULL);
687 XPutImage (FRAME_X_DISPLAY (f), mask, gc, mask_img, 0, 0, 0, 0,
688 width, height);
689 XFreeGC (FRAME_X_DISPLAY (f), gc);
691 dpyinfo->bitmaps[id - 1].have_mask = 1;
692 dpyinfo->bitmaps[id - 1].mask = mask;
694 XDestroyImage (ximg);
695 x_destroy_x_image (mask_img);
697 return 0;
700 #endif /* HAVE_X_WINDOWS */
703 /***********************************************************************
704 Image types
705 ***********************************************************************/
707 /* Value is the number of elements of vector VECTOR. */
709 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
711 /* List of supported image types. Use define_image_type to add new
712 types. Use lookup_image_type to find a type for a given symbol. */
714 static struct image_type *image_types;
716 /* A list of symbols, one for each supported image type. */
718 Lisp_Object Vimage_types;
720 /* An alist of image types and libraries that implement the type. */
722 Lisp_Object Vimage_library_alist;
724 /* Cache for delayed-loading image types. */
726 static Lisp_Object Vimage_type_cache;
728 /* The symbol `xbm' which is used as the type symbol for XBM images. */
730 Lisp_Object Qxbm;
732 /* Keywords. */
734 extern Lisp_Object QCwidth, QCheight, QCforeground, QCbackground, QCfile;
735 extern Lisp_Object QCdata, QCtype, Qcount;
736 extern Lisp_Object Qcenter;
737 Lisp_Object QCascent, QCmargin, QCrelief;
738 Lisp_Object QCconversion, QCcolor_symbols, QCheuristic_mask;
739 Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask;
741 /* Other symbols. */
743 Lisp_Object Qlaplace, Qemboss, Qedge_detection, Qheuristic;
745 /* Time in seconds after which images should be removed from the cache
746 if not displayed. */
748 Lisp_Object Vimage_cache_eviction_delay;
750 /* Function prototypes. */
752 static Lisp_Object define_image_type P_ ((struct image_type *type, int loaded));
753 static struct image_type *lookup_image_type P_ ((Lisp_Object symbol));
754 static void image_error P_ ((char *format, Lisp_Object, Lisp_Object));
755 static void x_laplace P_ ((struct frame *, struct image *));
756 static void x_emboss P_ ((struct frame *, struct image *));
757 static int x_build_heuristic_mask P_ ((struct frame *, struct image *,
758 Lisp_Object));
760 #define CACHE_IMAGE_TYPE(type, status) \
761 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
763 #define ADD_IMAGE_TYPE(type) \
764 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
766 /* Define a new image type from TYPE. This adds a copy of TYPE to
767 image_types and caches the loading status of TYPE. */
769 static Lisp_Object
770 define_image_type (type, loaded)
771 struct image_type *type;
772 int loaded;
774 Lisp_Object success;
776 if (!loaded)
777 success = Qnil;
778 else
780 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
781 The initialized data segment is read-only. */
782 struct image_type *p = (struct image_type *) xmalloc (sizeof *p);
783 bcopy (type, p, sizeof *p);
784 p->next = image_types;
785 image_types = p;
786 success = Qt;
789 CACHE_IMAGE_TYPE (*type->type, success);
790 return success;
794 /* Look up image type SYMBOL, and return a pointer to its image_type
795 structure. Value is null if SYMBOL is not a known image type. */
797 static INLINE struct image_type *
798 lookup_image_type (symbol)
799 Lisp_Object symbol;
801 struct image_type *type;
803 /* We must initialize the image-type if it hasn't been already. */
804 if (NILP (Finit_image_library (symbol, Vimage_library_alist)))
805 return 0; /* unimplemented */
807 for (type = image_types; type; type = type->next)
808 if (EQ (symbol, *type->type))
809 break;
811 return type;
815 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
816 valid image specification is a list whose car is the symbol
817 `image', and whose rest is a property list. The property list must
818 contain a value for key `:type'. That value must be the name of a
819 supported image type. The rest of the property list depends on the
820 image type. */
823 valid_image_p (object)
824 Lisp_Object object;
826 int valid_p = 0;
828 if (IMAGEP (object))
830 Lisp_Object tem;
832 for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem))
833 if (EQ (XCAR (tem), QCtype))
835 tem = XCDR (tem);
836 if (CONSP (tem) && SYMBOLP (XCAR (tem)))
838 struct image_type *type;
839 type = lookup_image_type (XCAR (tem));
840 if (type)
841 valid_p = type->valid_p (object);
844 break;
848 return valid_p;
852 /* Log error message with format string FORMAT and argument ARG.
853 Signaling an error, e.g. when an image cannot be loaded, is not a
854 good idea because this would interrupt redisplay, and the error
855 message display would lead to another redisplay. This function
856 therefore simply displays a message. */
858 static void
859 image_error (format, arg1, arg2)
860 char *format;
861 Lisp_Object arg1, arg2;
863 add_to_log (format, arg1, arg2);
868 /***********************************************************************
869 Image specifications
870 ***********************************************************************/
872 enum image_value_type
874 IMAGE_DONT_CHECK_VALUE_TYPE,
875 IMAGE_STRING_VALUE,
876 IMAGE_STRING_OR_NIL_VALUE,
877 IMAGE_SYMBOL_VALUE,
878 IMAGE_POSITIVE_INTEGER_VALUE,
879 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
880 IMAGE_NON_NEGATIVE_INTEGER_VALUE,
881 IMAGE_ASCENT_VALUE,
882 IMAGE_INTEGER_VALUE,
883 IMAGE_FUNCTION_VALUE,
884 IMAGE_NUMBER_VALUE,
885 IMAGE_BOOL_VALUE
888 /* Structure used when parsing image specifications. */
890 struct image_keyword
892 /* Name of keyword. */
893 char *name;
895 /* The type of value allowed. */
896 enum image_value_type type;
898 /* Non-zero means key must be present. */
899 int mandatory_p;
901 /* Used to recognize duplicate keywords in a property list. */
902 int count;
904 /* The value that was found. */
905 Lisp_Object value;
909 static int parse_image_spec P_ ((Lisp_Object, struct image_keyword *,
910 int, Lisp_Object));
911 static Lisp_Object image_spec_value P_ ((Lisp_Object, Lisp_Object, int *));
914 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
915 has the format (image KEYWORD VALUE ...). One of the keyword/
916 value pairs must be `:type TYPE'. KEYWORDS is a vector of
917 image_keywords structures of size NKEYWORDS describing other
918 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
920 static int
921 parse_image_spec (spec, keywords, nkeywords, type)
922 Lisp_Object spec;
923 struct image_keyword *keywords;
924 int nkeywords;
925 Lisp_Object type;
927 int i;
928 Lisp_Object plist;
930 if (!IMAGEP (spec))
931 return 0;
933 plist = XCDR (spec);
934 while (CONSP (plist))
936 Lisp_Object key, value;
938 /* First element of a pair must be a symbol. */
939 key = XCAR (plist);
940 plist = XCDR (plist);
941 if (!SYMBOLP (key))
942 return 0;
944 /* There must follow a value. */
945 if (!CONSP (plist))
946 return 0;
947 value = XCAR (plist);
948 plist = XCDR (plist);
950 /* Find key in KEYWORDS. Error if not found. */
951 for (i = 0; i < nkeywords; ++i)
952 if (strcmp (keywords[i].name, SDATA (SYMBOL_NAME (key))) == 0)
953 break;
955 if (i == nkeywords)
956 continue;
958 /* Record that we recognized the keyword. If a keywords
959 was found more than once, it's an error. */
960 keywords[i].value = value;
961 ++keywords[i].count;
963 if (keywords[i].count > 1)
964 return 0;
966 /* Check type of value against allowed type. */
967 switch (keywords[i].type)
969 case IMAGE_STRING_VALUE:
970 if (!STRINGP (value))
971 return 0;
972 break;
974 case IMAGE_STRING_OR_NIL_VALUE:
975 if (!STRINGP (value) && !NILP (value))
976 return 0;
977 break;
979 case IMAGE_SYMBOL_VALUE:
980 if (!SYMBOLP (value))
981 return 0;
982 break;
984 case IMAGE_POSITIVE_INTEGER_VALUE:
985 if (!INTEGERP (value) || XINT (value) <= 0)
986 return 0;
987 break;
989 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR:
990 if (INTEGERP (value) && XINT (value) >= 0)
991 break;
992 if (CONSP (value)
993 && INTEGERP (XCAR (value)) && INTEGERP (XCDR (value))
994 && XINT (XCAR (value)) >= 0 && XINT (XCDR (value)) >= 0)
995 break;
996 return 0;
998 case IMAGE_ASCENT_VALUE:
999 if (SYMBOLP (value) && EQ (value, Qcenter))
1000 break;
1001 else if (INTEGERP (value)
1002 && XINT (value) >= 0
1003 && XINT (value) <= 100)
1004 break;
1005 return 0;
1007 case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
1008 if (!INTEGERP (value) || XINT (value) < 0)
1009 return 0;
1010 break;
1012 case IMAGE_DONT_CHECK_VALUE_TYPE:
1013 break;
1015 case IMAGE_FUNCTION_VALUE:
1016 value = indirect_function (value);
1017 if (SUBRP (value)
1018 || COMPILEDP (value)
1019 || (CONSP (value) && EQ (XCAR (value), Qlambda)))
1020 break;
1021 return 0;
1023 case IMAGE_NUMBER_VALUE:
1024 if (!INTEGERP (value) && !FLOATP (value))
1025 return 0;
1026 break;
1028 case IMAGE_INTEGER_VALUE:
1029 if (!INTEGERP (value))
1030 return 0;
1031 break;
1033 case IMAGE_BOOL_VALUE:
1034 if (!NILP (value) && !EQ (value, Qt))
1035 return 0;
1036 break;
1038 default:
1039 abort ();
1040 break;
1043 if (EQ (key, QCtype) && !EQ (type, value))
1044 return 0;
1047 /* Check that all mandatory fields are present. */
1048 for (i = 0; i < nkeywords; ++i)
1049 if (keywords[i].mandatory_p && keywords[i].count == 0)
1050 return 0;
1052 return NILP (plist);
1056 /* Return the value of KEY in image specification SPEC. Value is nil
1057 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
1058 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
1060 static Lisp_Object
1061 image_spec_value (spec, key, found)
1062 Lisp_Object spec, key;
1063 int *found;
1065 Lisp_Object tail;
1067 xassert (valid_image_p (spec));
1069 for (tail = XCDR (spec);
1070 CONSP (tail) && CONSP (XCDR (tail));
1071 tail = XCDR (XCDR (tail)))
1073 if (EQ (XCAR (tail), key))
1075 if (found)
1076 *found = 1;
1077 return XCAR (XCDR (tail));
1081 if (found)
1082 *found = 0;
1083 return Qnil;
1087 DEFUN ("image-size", Fimage_size, Simage_size, 1, 3, 0,
1088 doc: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
1089 PIXELS non-nil means return the size in pixels, otherwise return the
1090 size in canonical character units.
1091 FRAME is the frame on which the image will be displayed. FRAME nil
1092 or omitted means use the selected frame. */)
1093 (spec, pixels, frame)
1094 Lisp_Object spec, pixels, frame;
1096 Lisp_Object size;
1098 size = Qnil;
1099 if (valid_image_p (spec))
1101 struct frame *f = check_x_frame (frame);
1102 int id = lookup_image (f, spec);
1103 struct image *img = IMAGE_FROM_ID (f, id);
1104 int width = img->width + 2 * img->hmargin;
1105 int height = img->height + 2 * img->vmargin;
1107 if (NILP (pixels))
1108 size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
1109 make_float ((double) height / FRAME_LINE_HEIGHT (f)));
1110 else
1111 size = Fcons (make_number (width), make_number (height));
1113 else
1114 error ("Invalid image specification");
1116 return size;
1120 DEFUN ("image-mask-p", Fimage_mask_p, Simage_mask_p, 1, 2, 0,
1121 doc: /* Return t if image SPEC has a mask bitmap.
1122 FRAME is the frame on which the image will be displayed. FRAME nil
1123 or omitted means use the selected frame. */)
1124 (spec, frame)
1125 Lisp_Object spec, frame;
1127 Lisp_Object mask;
1129 mask = Qnil;
1130 if (valid_image_p (spec))
1132 struct frame *f = check_x_frame (frame);
1133 int id = lookup_image (f, spec);
1134 struct image *img = IMAGE_FROM_ID (f, id);
1135 if (img->mask)
1136 mask = Qt;
1138 else
1139 error ("Invalid image specification");
1141 return mask;
1144 DEFUN ("image-extension-data", Fimage_extension_data, Simage_extension_data, 1, 2, 0,
1145 doc: /* Return extension data for image SPEC.
1146 FRAME is the frame on which the image will be displayed. FRAME nil
1147 or omitted means use the selected frame. */)
1148 (spec, frame)
1149 Lisp_Object spec, frame;
1151 Lisp_Object ext;
1153 ext = Qnil;
1154 if (valid_image_p (spec))
1156 struct frame *f = check_x_frame (frame);
1157 int id = lookup_image (f, spec);
1158 struct image *img = IMAGE_FROM_ID (f, id);
1159 ext = img->data.lisp_val;
1162 return ext;
1166 /***********************************************************************
1167 Image type independent image structures
1168 ***********************************************************************/
1170 static struct image *make_image P_ ((Lisp_Object spec, unsigned hash));
1171 static void free_image P_ ((struct frame *f, struct image *img));
1172 static int check_image_size P_ ((struct frame *f, int width, int height));
1174 #define MAX_IMAGE_SIZE 6.0
1175 Lisp_Object Vmax_image_size;
1177 /* Allocate and return a new image structure for image specification
1178 SPEC. SPEC has a hash value of HASH. */
1180 static struct image *
1181 make_image (spec, hash)
1182 Lisp_Object spec;
1183 unsigned hash;
1185 struct image *img = (struct image *) xmalloc (sizeof *img);
1187 xassert (valid_image_p (spec));
1188 bzero (img, sizeof *img);
1189 img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
1190 xassert (img->type != NULL);
1191 img->spec = spec;
1192 img->data.lisp_val = Qnil;
1193 img->ascent = DEFAULT_IMAGE_ASCENT;
1194 img->hash = hash;
1195 img->corners[BOT_CORNER] = -1; /* Full image */
1196 return img;
1200 /* Free image IMG which was used on frame F, including its resources. */
1202 static void
1203 free_image (f, img)
1204 struct frame *f;
1205 struct image *img;
1207 if (img)
1209 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1211 /* Remove IMG from the hash table of its cache. */
1212 if (img->prev)
1213 img->prev->next = img->next;
1214 else
1215 c->buckets[img->hash % IMAGE_CACHE_BUCKETS_SIZE] = img->next;
1217 if (img->next)
1218 img->next->prev = img->prev;
1220 c->images[img->id] = NULL;
1222 /* Free resources, then free IMG. */
1223 img->type->free (f, img);
1224 xfree (img);
1228 /* Return 1 if the given widths and heights are valid for display;
1229 otherwise, return 0. */
1232 check_image_size (f, width, height)
1233 struct frame *f;
1234 int width;
1235 int height;
1237 int w, h;
1239 if (width <= 0 || height <= 0)
1240 return 0;
1242 if (INTEGERP (Vmax_image_size))
1243 w = h = XINT (Vmax_image_size);
1244 else if (FLOATP (Vmax_image_size))
1246 if (f != NULL)
1248 w = FRAME_PIXEL_WIDTH (f);
1249 h = FRAME_PIXEL_HEIGHT (f);
1251 else
1252 w = h = 1024; /* Arbitrary size for unknown frame. */
1253 w = (int) (XFLOAT_DATA (Vmax_image_size) * w);
1254 h = (int) (XFLOAT_DATA (Vmax_image_size) * h);
1256 else
1257 return 1;
1259 return (width <= w && height <= h);
1262 /* Prepare image IMG for display on frame F. Must be called before
1263 drawing an image. */
1265 void
1266 prepare_image_for_display (f, img)
1267 struct frame *f;
1268 struct image *img;
1270 EMACS_TIME t;
1272 /* We're about to display IMG, so set its timestamp to `now'. */
1273 EMACS_GET_TIME (t);
1274 img->timestamp = EMACS_SECS (t);
1276 /* If IMG doesn't have a pixmap yet, load it now, using the image
1277 type dependent loader function. */
1278 if (img->pixmap == NO_PIXMAP && !img->load_failed_p)
1279 img->load_failed_p = img->type->load (f, img) == 0;
1281 #if defined (MAC_OS) && USE_CG_DRAWING
1282 if (!img->load_failed_p && img->data.ptr_val == NULL)
1284 img->data.ptr_val = mac_create_cg_image_from_image (f, img);
1285 if (img->data.ptr_val == NULL)
1287 img->load_failed_p = 1;
1288 img->type->free (f, img);
1291 #endif
1295 /* Value is the number of pixels for the ascent of image IMG when
1296 drawn in face FACE. */
1299 image_ascent (img, face, slice)
1300 struct image *img;
1301 struct face *face;
1302 struct glyph_slice *slice;
1304 int height;
1305 int ascent;
1307 if (slice->height == img->height)
1308 height = img->height + img->vmargin;
1309 else if (slice->y == 0)
1310 height = slice->height + img->vmargin;
1311 else
1312 height = slice->height;
1314 if (img->ascent == CENTERED_IMAGE_ASCENT)
1316 if (face->font)
1318 #ifdef HAVE_NTGUI
1319 /* W32 specific version. Why?. ++kfs */
1320 ascent = height / 2 - (FONT_DESCENT(face->font)
1321 - FONT_BASE(face->font)) / 2;
1322 #else
1323 /* This expression is arranged so that if the image can't be
1324 exactly centered, it will be moved slightly up. This is
1325 because a typical font is `top-heavy' (due to the presence
1326 uppercase letters), so the image placement should err towards
1327 being top-heavy too. It also just generally looks better. */
1328 ascent = (height + face->font->ascent - face->font->descent + 1) / 2;
1329 #endif /* HAVE_NTGUI */
1331 else
1332 ascent = height / 2;
1334 else
1335 ascent = (int) (height * img->ascent / 100.0);
1337 return ascent;
1341 /* Image background colors. */
1343 /* Find the "best" corner color of a bitmap.
1344 On W32, XIMG is assumed to a device context with the bitmap selected. */
1346 static RGB_PIXEL_COLOR
1347 four_corners_best (ximg, corners, width, height)
1348 XImagePtr_or_DC ximg;
1349 int *corners;
1350 unsigned long width, height;
1352 RGB_PIXEL_COLOR corner_pixels[4], best;
1353 int i, best_count;
1355 if (corners && corners[BOT_CORNER] >= 0)
1357 /* Get the colors at the corner_pixels of ximg. */
1358 corner_pixels[0] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[TOP_CORNER]);
1359 corner_pixels[1] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[TOP_CORNER]);
1360 corner_pixels[2] = GET_PIXEL (ximg, corners[RIGHT_CORNER] - 1, corners[BOT_CORNER] - 1);
1361 corner_pixels[3] = GET_PIXEL (ximg, corners[LEFT_CORNER], corners[BOT_CORNER] - 1);
1363 else
1365 /* Get the colors at the corner_pixels of ximg. */
1366 corner_pixels[0] = GET_PIXEL (ximg, 0, 0);
1367 corner_pixels[1] = GET_PIXEL (ximg, width - 1, 0);
1368 corner_pixels[2] = GET_PIXEL (ximg, width - 1, height - 1);
1369 corner_pixels[3] = GET_PIXEL (ximg, 0, height - 1);
1371 /* Choose the most frequently found color as background. */
1372 for (i = best_count = 0; i < 4; ++i)
1374 int j, n;
1376 for (j = n = 0; j < 4; ++j)
1377 if (corner_pixels[i] == corner_pixels[j])
1378 ++n;
1380 if (n > best_count)
1381 best = corner_pixels[i], best_count = n;
1384 return best;
1387 /* Portability macros */
1389 #ifdef HAVE_NTGUI
1391 #define Destroy_Image(img_dc, prev) \
1392 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1394 #define Free_Pixmap(display, pixmap) \
1395 DeleteObject (pixmap)
1397 #else
1399 #define Destroy_Image(ximg, dummy) \
1400 XDestroyImage (ximg)
1402 #define Free_Pixmap(display, pixmap) \
1403 XFreePixmap (display, pixmap)
1405 #endif /* HAVE_NTGUI */
1408 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1409 it is guessed heuristically. If non-zero, XIMG is an existing
1410 XImage object (or device context with the image selected on W32) to
1411 use for the heuristic. */
1413 RGB_PIXEL_COLOR
1414 image_background (img, f, ximg)
1415 struct image *img;
1416 struct frame *f;
1417 XImagePtr_or_DC ximg;
1419 if (! img->background_valid)
1420 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1422 int free_ximg = !ximg;
1423 #ifdef HAVE_NTGUI
1424 HGDIOBJ prev;
1425 #endif /* HAVE_NTGUI */
1427 if (free_ximg)
1429 #ifndef HAVE_NTGUI
1430 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
1431 0, 0, img->width, img->height, ~0, ZPixmap);
1432 #else
1433 HDC frame_dc = get_frame_dc (f);
1434 ximg = CreateCompatibleDC (frame_dc);
1435 release_frame_dc (f, frame_dc);
1436 prev = SelectObject (ximg, img->pixmap);
1437 #endif /* !HAVE_NTGUI */
1440 img->background = four_corners_best (ximg, img->corners, img->width, img->height);
1442 if (free_ximg)
1443 Destroy_Image (ximg, prev);
1445 img->background_valid = 1;
1448 return img->background;
1451 /* Return the `background_transparent' field of IMG. If IMG doesn't
1452 have one yet, it is guessed heuristically. If non-zero, MASK is an
1453 existing XImage object to use for the heuristic. */
1456 image_background_transparent (img, f, mask)
1457 struct image *img;
1458 struct frame *f;
1459 XImagePtr_or_DC mask;
1461 if (! img->background_transparent_valid)
1462 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1464 if (img->mask)
1466 int free_mask = !mask;
1467 #ifdef HAVE_NTGUI
1468 HGDIOBJ prev;
1469 #endif /* HAVE_NTGUI */
1471 if (free_mask)
1473 #ifndef HAVE_NTGUI
1474 mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
1475 0, 0, img->width, img->height, ~0, ZPixmap);
1476 #else
1477 HDC frame_dc = get_frame_dc (f);
1478 mask = CreateCompatibleDC (frame_dc);
1479 release_frame_dc (f, frame_dc);
1480 prev = SelectObject (mask, img->mask);
1481 #endif /* HAVE_NTGUI */
1484 img->background_transparent
1485 = (four_corners_best (mask, img->corners, img->width, img->height) == PIX_MASK_RETAIN);
1487 if (free_mask)
1488 Destroy_Image (mask, prev);
1490 else
1491 img->background_transparent = 0;
1493 img->background_transparent_valid = 1;
1496 return img->background_transparent;
1500 /***********************************************************************
1501 Helper functions for X image types
1502 ***********************************************************************/
1504 static void x_clear_image_1 P_ ((struct frame *, struct image *, int,
1505 int, int));
1506 static void x_clear_image P_ ((struct frame *f, struct image *img));
1507 static unsigned long x_alloc_image_color P_ ((struct frame *f,
1508 struct image *img,
1509 Lisp_Object color_name,
1510 unsigned long dflt));
1513 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1514 free the pixmap if any. MASK_P non-zero means clear the mask
1515 pixmap if any. COLORS_P non-zero means free colors allocated for
1516 the image, if any. */
1518 static void
1519 x_clear_image_1 (f, img, pixmap_p, mask_p, colors_p)
1520 struct frame *f;
1521 struct image *img;
1522 int pixmap_p, mask_p, colors_p;
1524 if (pixmap_p && img->pixmap)
1526 Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
1527 img->pixmap = NO_PIXMAP;
1528 img->background_valid = 0;
1531 if (mask_p && img->mask)
1533 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
1534 img->mask = NO_PIXMAP;
1535 img->background_transparent_valid = 0;
1538 if (colors_p && img->ncolors)
1540 /* MAC_TODO: color table support. */
1541 /* W32_TODO: color table support. */
1542 #ifdef HAVE_X_WINDOWS
1543 x_free_colors (f, img->colors, img->ncolors);
1544 #endif /* HAVE_X_WINDOWS */
1545 xfree (img->colors);
1546 img->colors = NULL;
1547 img->ncolors = 0;
1550 #if defined (MAC_OS) && USE_CG_DRAWING
1551 if (img->data.ptr_val)
1553 CGImageRelease (img->data.ptr_val);
1554 img->data.ptr_val = NULL;
1556 #endif
1559 /* Free X resources of image IMG which is used on frame F. */
1561 static void
1562 x_clear_image (f, img)
1563 struct frame *f;
1564 struct image *img;
1566 BLOCK_INPUT;
1567 x_clear_image_1 (f, img, 1, 1, 1);
1568 UNBLOCK_INPUT;
1572 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1573 cannot be allocated, use DFLT. Add a newly allocated color to
1574 IMG->colors, so that it can be freed again. Value is the pixel
1575 color. */
1577 static unsigned long
1578 x_alloc_image_color (f, img, color_name, dflt)
1579 struct frame *f;
1580 struct image *img;
1581 Lisp_Object color_name;
1582 unsigned long dflt;
1584 XColor color;
1585 unsigned long result;
1587 xassert (STRINGP (color_name));
1589 if (x_defined_color (f, SDATA (color_name), &color, 1))
1591 /* This isn't called frequently so we get away with simply
1592 reallocating the color vector to the needed size, here. */
1593 ++img->ncolors;
1594 img->colors =
1595 (unsigned long *) xrealloc (img->colors,
1596 img->ncolors * sizeof *img->colors);
1597 img->colors[img->ncolors - 1] = color.pixel;
1598 result = color.pixel;
1600 else
1601 result = dflt;
1603 return result;
1608 /***********************************************************************
1609 Image Cache
1610 ***********************************************************************/
1612 static struct image *search_image_cache P_ ((struct frame *, Lisp_Object, unsigned));
1613 static void cache_image P_ ((struct frame *f, struct image *img));
1614 static void postprocess_image P_ ((struct frame *, struct image *));
1616 /* Return a new, initialized image cache that is allocated from the
1617 heap. Call free_image_cache to free an image cache. */
1619 struct image_cache *
1620 make_image_cache ()
1622 struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
1623 int size;
1625 bzero (c, sizeof *c);
1626 c->size = 50;
1627 c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
1628 size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
1629 c->buckets = (struct image **) xmalloc (size);
1630 bzero (c->buckets, size);
1631 return c;
1635 /* Find an image matching SPEC in the cache, and return it. If no
1636 image is found, return NULL. */
1637 static struct image *
1638 search_image_cache (f, spec, hash)
1639 struct frame *f;
1640 Lisp_Object spec;
1641 unsigned hash;
1643 struct image *img;
1644 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1645 int i = hash % IMAGE_CACHE_BUCKETS_SIZE;
1647 if (!c) return NULL;
1649 /* If the image spec does not specify a background color, the cached
1650 image must have the same background color as the current frame.
1651 The foreground color must also match, for the sake of monochrome
1652 images.
1654 In fact, we could ignore the foreground color matching condition
1655 for color images, or if the image spec specifies :foreground;
1656 similarly we could ignore the background color matching condition
1657 for formats that don't use transparency (such as jpeg), or if the
1658 image spec specifies :background. However, the extra memory
1659 usage is probably negligible in practice, so we don't bother. */
1661 for (img = c->buckets[i]; img; img = img->next)
1662 if (img->hash == hash
1663 && !NILP (Fequal (img->spec, spec))
1664 && img->frame_foreground == FRAME_FOREGROUND_PIXEL (f)
1665 && img->frame_background == FRAME_BACKGROUND_PIXEL (f))
1666 break;
1667 return img;
1671 /* Search frame F for an image with spec SPEC, and free it. */
1673 static void
1674 uncache_image (f, spec)
1675 struct frame *f;
1676 Lisp_Object spec;
1678 struct image *img = search_image_cache (f, spec, sxhash (spec, 0));
1679 if (img)
1680 free_image (f, img);
1684 /* Free image cache of frame F. Be aware that X frames share images
1685 caches. */
1687 void
1688 free_image_cache (f)
1689 struct frame *f;
1691 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1692 if (c)
1694 int i;
1696 /* Cache should not be referenced by any frame when freed. */
1697 xassert (c->refcount == 0);
1699 for (i = 0; i < c->used; ++i)
1700 free_image (f, c->images[i]);
1701 xfree (c->images);
1702 xfree (c->buckets);
1703 xfree (c);
1704 FRAME_X_IMAGE_CACHE (f) = NULL;
1709 /* Clear image cache of frame F. FORCE_P non-zero means free all
1710 images. FORCE_P zero means clear only images that haven't been
1711 displayed for some time. Should be called from time to time to
1712 reduce the number of loaded images. If image-eviction-seconds is
1713 non-nil, this frees images in the cache which weren't displayed for
1714 at least that many seconds. */
1716 void
1717 clear_image_cache (f, force_p)
1718 struct frame *f;
1719 int force_p;
1721 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1723 if (c && INTEGERP (Vimage_cache_eviction_delay))
1725 EMACS_TIME t;
1726 unsigned long old;
1727 int i, nfreed;
1729 EMACS_GET_TIME (t);
1730 old = EMACS_SECS (t) - XFASTINT (Vimage_cache_eviction_delay);
1732 /* Block input so that we won't be interrupted by a SIGIO
1733 while being in an inconsistent state. */
1734 BLOCK_INPUT;
1736 for (i = nfreed = 0; i < c->used; ++i)
1738 struct image *img = c->images[i];
1739 if (img != NULL
1740 && (force_p || img->timestamp < old))
1742 free_image (f, img);
1743 ++nfreed;
1747 /* We may be clearing the image cache because, for example,
1748 Emacs was iconified for a longer period of time. In that
1749 case, current matrices may still contain references to
1750 images freed above. So, clear these matrices. */
1751 if (nfreed)
1753 Lisp_Object tail, frame;
1755 FOR_EACH_FRAME (tail, frame)
1757 struct frame *f = XFRAME (frame);
1758 if (FRAME_WINDOW_P (f)
1759 && FRAME_X_IMAGE_CACHE (f) == c)
1760 clear_current_matrices (f);
1763 ++windows_or_buffers_changed;
1766 UNBLOCK_INPUT;
1771 DEFUN ("clear-image-cache", Fclear_image_cache, Sclear_image_cache,
1772 0, 1, 0,
1773 doc: /* Clear the image cache of FRAME.
1774 FRAME nil or omitted means use the selected frame.
1775 FRAME t means clear the image caches of all frames. */)
1776 (frame)
1777 Lisp_Object frame;
1779 if (EQ (frame, Qt))
1781 Lisp_Object tail;
1783 FOR_EACH_FRAME (tail, frame)
1784 if (FRAME_WINDOW_P (XFRAME (frame)))
1785 clear_image_cache (XFRAME (frame), 1);
1787 else
1788 clear_image_cache (check_x_frame (frame), 1);
1790 return Qnil;
1794 DEFUN ("image-refresh", Fimage_refresh, Simage_refresh,
1795 1, 2, 0,
1796 doc: /* Refresh the image with specification SPEC on frame FRAME.
1797 If SPEC specifies an image file, the displayed image is updated with
1798 the current contents of that file.
1799 FRAME nil or omitted means use the selected frame.
1800 FRAME t means refresh the image on all frames. */)
1801 (spec, frame)
1802 Lisp_Object spec, frame;
1804 if (!valid_image_p (spec))
1805 error ("Invalid image specification");
1807 if (EQ (frame, Qt))
1809 Lisp_Object tail;
1810 FOR_EACH_FRAME (tail, frame)
1812 struct frame *f = XFRAME (frame);
1813 if (FRAME_WINDOW_P (f))
1814 uncache_image (f, spec);
1817 else
1818 uncache_image (check_x_frame (frame), spec);
1820 return Qnil;
1824 /* Compute masks and transform image IMG on frame F, as specified
1825 by the image's specification, */
1827 static void
1828 postprocess_image (f, img)
1829 struct frame *f;
1830 struct image *img;
1832 /* Manipulation of the image's mask. */
1833 if (img->pixmap)
1835 Lisp_Object conversion, spec;
1836 Lisp_Object mask;
1838 spec = img->spec;
1840 /* `:heuristic-mask t'
1841 `:mask heuristic'
1842 means build a mask heuristically.
1843 `:heuristic-mask (R G B)'
1844 `:mask (heuristic (R G B))'
1845 means build a mask from color (R G B) in the
1846 image.
1847 `:mask nil'
1848 means remove a mask, if any. */
1850 mask = image_spec_value (spec, QCheuristic_mask, NULL);
1851 if (!NILP (mask))
1852 x_build_heuristic_mask (f, img, mask);
1853 else
1855 int found_p;
1857 mask = image_spec_value (spec, QCmask, &found_p);
1859 if (EQ (mask, Qheuristic))
1860 x_build_heuristic_mask (f, img, Qt);
1861 else if (CONSP (mask)
1862 && EQ (XCAR (mask), Qheuristic))
1864 if (CONSP (XCDR (mask)))
1865 x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
1866 else
1867 x_build_heuristic_mask (f, img, XCDR (mask));
1869 else if (NILP (mask) && found_p && img->mask)
1871 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
1872 img->mask = NO_PIXMAP;
1877 /* Should we apply an image transformation algorithm? */
1878 conversion = image_spec_value (spec, QCconversion, NULL);
1879 if (EQ (conversion, Qdisabled))
1880 x_disable_image (f, img);
1881 else if (EQ (conversion, Qlaplace))
1882 x_laplace (f, img);
1883 else if (EQ (conversion, Qemboss))
1884 x_emboss (f, img);
1885 else if (CONSP (conversion)
1886 && EQ (XCAR (conversion), Qedge_detection))
1888 Lisp_Object tem;
1889 tem = XCDR (conversion);
1890 if (CONSP (tem))
1891 x_edge_detection (f, img,
1892 Fplist_get (tem, QCmatrix),
1893 Fplist_get (tem, QCcolor_adjustment));
1899 /* Return the id of image with Lisp specification SPEC on frame F.
1900 SPEC must be a valid Lisp image specification (see valid_image_p). */
1903 lookup_image (f, spec)
1904 struct frame *f;
1905 Lisp_Object spec;
1907 struct image *img;
1908 unsigned hash;
1909 struct gcpro gcpro1;
1910 EMACS_TIME now;
1912 /* F must be a window-system frame, and SPEC must be a valid image
1913 specification. */
1914 xassert (FRAME_WINDOW_P (f));
1915 xassert (valid_image_p (spec));
1917 GCPRO1 (spec);
1919 /* Look up SPEC in the hash table of the image cache. */
1920 hash = sxhash (spec, 0);
1921 img = search_image_cache (f, spec, hash);
1922 if (img && img->load_failed_p)
1924 free_image (f, img);
1925 img = NULL;
1928 /* If not found, create a new image and cache it. */
1929 if (img == NULL)
1931 extern Lisp_Object Qpostscript;
1933 BLOCK_INPUT;
1934 img = make_image (spec, hash);
1935 cache_image (f, img);
1936 img->load_failed_p = img->type->load (f, img) == 0;
1937 img->frame_foreground = FRAME_FOREGROUND_PIXEL (f);
1938 img->frame_background = FRAME_BACKGROUND_PIXEL (f);
1940 /* If we can't load the image, and we don't have a width and
1941 height, use some arbitrary width and height so that we can
1942 draw a rectangle for it. */
1943 if (img->load_failed_p)
1945 Lisp_Object value;
1947 value = image_spec_value (spec, QCwidth, NULL);
1948 img->width = (INTEGERP (value)
1949 ? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
1950 value = image_spec_value (spec, QCheight, NULL);
1951 img->height = (INTEGERP (value)
1952 ? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
1954 else
1956 /* Handle image type independent image attributes
1957 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1958 `:background COLOR'. */
1959 Lisp_Object ascent, margin, relief, bg;
1961 ascent = image_spec_value (spec, QCascent, NULL);
1962 if (INTEGERP (ascent))
1963 img->ascent = XFASTINT (ascent);
1964 else if (EQ (ascent, Qcenter))
1965 img->ascent = CENTERED_IMAGE_ASCENT;
1967 margin = image_spec_value (spec, QCmargin, NULL);
1968 if (INTEGERP (margin) && XINT (margin) >= 0)
1969 img->vmargin = img->hmargin = XFASTINT (margin);
1970 else if (CONSP (margin) && INTEGERP (XCAR (margin))
1971 && INTEGERP (XCDR (margin)))
1973 if (XINT (XCAR (margin)) > 0)
1974 img->hmargin = XFASTINT (XCAR (margin));
1975 if (XINT (XCDR (margin)) > 0)
1976 img->vmargin = XFASTINT (XCDR (margin));
1979 relief = image_spec_value (spec, QCrelief, NULL);
1980 if (INTEGERP (relief))
1982 img->relief = XINT (relief);
1983 img->hmargin += abs (img->relief);
1984 img->vmargin += abs (img->relief);
1987 if (! img->background_valid)
1989 bg = image_spec_value (img->spec, QCbackground, NULL);
1990 if (!NILP (bg))
1992 img->background
1993 = x_alloc_image_color (f, img, bg,
1994 FRAME_BACKGROUND_PIXEL (f));
1995 img->background_valid = 1;
1999 /* Do image transformations and compute masks, unless we
2000 don't have the image yet. */
2001 if (!EQ (*img->type->type, Qpostscript))
2002 postprocess_image (f, img);
2005 UNBLOCK_INPUT;
2008 /* We're using IMG, so set its timestamp to `now'. */
2009 EMACS_GET_TIME (now);
2010 img->timestamp = EMACS_SECS (now);
2012 UNGCPRO;
2014 /* Value is the image id. */
2015 return img->id;
2019 /* Cache image IMG in the image cache of frame F. */
2021 static void
2022 cache_image (f, img)
2023 struct frame *f;
2024 struct image *img;
2026 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
2027 int i;
2029 /* Find a free slot in c->images. */
2030 for (i = 0; i < c->used; ++i)
2031 if (c->images[i] == NULL)
2032 break;
2034 /* If no free slot found, maybe enlarge c->images. */
2035 if (i == c->used && c->used == c->size)
2037 c->size *= 2;
2038 c->images = (struct image **) xrealloc (c->images,
2039 c->size * sizeof *c->images);
2042 /* Add IMG to c->images, and assign IMG an id. */
2043 c->images[i] = img;
2044 img->id = i;
2045 if (i == c->used)
2046 ++c->used;
2048 /* Add IMG to the cache's hash table. */
2049 i = img->hash % IMAGE_CACHE_BUCKETS_SIZE;
2050 img->next = c->buckets[i];
2051 if (img->next)
2052 img->next->prev = img;
2053 img->prev = NULL;
2054 c->buckets[i] = img;
2058 /* Call FN on every image in the image cache of frame F. Used to mark
2059 Lisp Objects in the image cache. */
2061 void
2062 forall_images_in_image_cache (f, fn)
2063 struct frame *f;
2064 void (*fn) P_ ((struct image *img));
2066 if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f))
2068 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
2069 if (c)
2071 int i;
2072 for (i = 0; i < c->used; ++i)
2073 if (c->images[i])
2074 fn (c->images[i]);
2081 /***********************************************************************
2082 X / MAC / W32 support code
2083 ***********************************************************************/
2085 #ifdef HAVE_NTGUI
2087 /* Macro for defining functions that will be loaded from image DLLs. */
2088 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
2090 /* Macro for loading those image functions from the library. */
2091 #define LOAD_IMGLIB_FN(lib,func) { \
2092 fn_##func = (void *) GetProcAddress (lib, #func); \
2093 if (!fn_##func) return 0; \
2096 /* Load a DLL implementing an image type.
2097 The `image-library-alist' variable associates a symbol,
2098 identifying an image type, to a list of possible filenames.
2099 The function returns NULL if no library could be loaded for
2100 the given image type, or if the library was previously loaded;
2101 else the handle of the DLL. */
2102 static HMODULE
2103 w32_delayed_load (Lisp_Object libraries, Lisp_Object type)
2105 HMODULE library = NULL;
2107 if (CONSP (libraries) && NILP (Fassq (type, Vimage_type_cache)))
2109 Lisp_Object dlls = Fassq (type, libraries);
2111 if (CONSP (dlls))
2112 for (dlls = XCDR (dlls); CONSP (dlls); dlls = XCDR (dlls))
2114 CHECK_STRING_CAR (dlls);
2115 if (library = LoadLibrary (SDATA (XCAR (dlls))))
2116 break;
2120 return library;
2123 #endif /* HAVE_NTGUI */
2125 static int x_create_x_image_and_pixmap P_ ((struct frame *, int, int, int,
2126 XImagePtr *, Pixmap *));
2127 static void x_destroy_x_image P_ ((XImagePtr));
2128 static void x_put_x_image P_ ((struct frame *, XImagePtr, Pixmap, int, int));
2131 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
2132 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
2133 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
2134 via xmalloc. Print error messages via image_error if an error
2135 occurs. Value is non-zero if successful.
2137 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
2138 should indicate the bit depth of the image. */
2140 static int
2141 x_create_x_image_and_pixmap (f, width, height, depth, ximg, pixmap)
2142 struct frame *f;
2143 int width, height, depth;
2144 XImagePtr *ximg;
2145 Pixmap *pixmap;
2147 #ifdef HAVE_X_WINDOWS
2148 Display *display = FRAME_X_DISPLAY (f);
2149 Window window = FRAME_X_WINDOW (f);
2150 Screen *screen = FRAME_X_SCREEN (f);
2152 xassert (interrupt_input_blocked);
2154 if (depth <= 0)
2155 depth = DefaultDepthOfScreen (screen);
2156 *ximg = XCreateImage (display, DefaultVisualOfScreen (screen),
2157 depth, ZPixmap, 0, NULL, width, height,
2158 depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
2159 if (*ximg == NULL)
2161 image_error ("Unable to allocate X image", Qnil, Qnil);
2162 return 0;
2165 /* Allocate image raster. */
2166 (*ximg)->data = (char *) xmalloc ((*ximg)->bytes_per_line * height);
2168 /* Allocate a pixmap of the same size. */
2169 *pixmap = XCreatePixmap (display, window, width, height, depth);
2170 if (*pixmap == NO_PIXMAP)
2172 x_destroy_x_image (*ximg);
2173 *ximg = NULL;
2174 image_error ("Unable to create X pixmap", Qnil, Qnil);
2175 return 0;
2178 return 1;
2179 #endif /* HAVE_X_WINDOWS */
2181 #ifdef HAVE_NTGUI
2183 BITMAPINFOHEADER *header;
2184 HDC hdc;
2185 int scanline_width_bits;
2186 int remainder;
2187 int palette_colors = 0;
2189 if (depth == 0)
2190 depth = 24;
2192 if (depth != 1 && depth != 4 && depth != 8
2193 && depth != 16 && depth != 24 && depth != 32)
2195 image_error ("Invalid image bit depth specified", Qnil, Qnil);
2196 return 0;
2199 scanline_width_bits = width * depth;
2200 remainder = scanline_width_bits % 32;
2202 if (remainder)
2203 scanline_width_bits += 32 - remainder;
2205 /* Bitmaps with a depth less than 16 need a palette. */
2206 /* BITMAPINFO structure already contains the first RGBQUAD. */
2207 if (depth < 16)
2208 palette_colors = 1 << depth - 1;
2210 *ximg = xmalloc (sizeof (XImage) + palette_colors * sizeof (RGBQUAD));
2211 if (*ximg == NULL)
2213 image_error ("Unable to allocate memory for XImage", Qnil, Qnil);
2214 return 0;
2217 header = &((*ximg)->info.bmiHeader);
2218 bzero (&((*ximg)->info), sizeof (BITMAPINFO));
2219 header->biSize = sizeof (*header);
2220 header->biWidth = width;
2221 header->biHeight = -height; /* negative indicates a top-down bitmap. */
2222 header->biPlanes = 1;
2223 header->biBitCount = depth;
2224 header->biCompression = BI_RGB;
2225 header->biClrUsed = palette_colors;
2227 /* TODO: fill in palette. */
2228 if (depth == 1)
2230 (*ximg)->info.bmiColors[0].rgbBlue = 0;
2231 (*ximg)->info.bmiColors[0].rgbGreen = 0;
2232 (*ximg)->info.bmiColors[0].rgbRed = 0;
2233 (*ximg)->info.bmiColors[0].rgbReserved = 0;
2234 (*ximg)->info.bmiColors[1].rgbBlue = 255;
2235 (*ximg)->info.bmiColors[1].rgbGreen = 255;
2236 (*ximg)->info.bmiColors[1].rgbRed = 255;
2237 (*ximg)->info.bmiColors[1].rgbReserved = 0;
2240 hdc = get_frame_dc (f);
2242 /* Create a DIBSection and raster array for the bitmap,
2243 and store its handle in *pixmap. */
2244 *pixmap = CreateDIBSection (hdc, &((*ximg)->info),
2245 (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
2246 /* casting avoids a GCC warning */
2247 (void **)&((*ximg)->data), NULL, 0);
2249 /* Realize display palette and garbage all frames. */
2250 release_frame_dc (f, hdc);
2252 if (*pixmap == NULL)
2254 DWORD err = GetLastError();
2255 Lisp_Object errcode;
2256 /* All system errors are < 10000, so the following is safe. */
2257 XSETINT (errcode, (int) err);
2258 image_error ("Unable to create bitmap, error code %d", errcode, Qnil);
2259 x_destroy_x_image (*ximg);
2260 return 0;
2263 return 1;
2265 #endif /* HAVE_NTGUI */
2267 #ifdef MAC_OS
2268 Display *display = FRAME_X_DISPLAY (f);
2269 Window window = FRAME_X_WINDOW (f);
2271 xassert (interrupt_input_blocked);
2273 /* Allocate a pixmap of the same size. */
2274 *pixmap = XCreatePixmap (display, window, width, height, depth);
2275 if (*pixmap == NO_PIXMAP)
2277 *ximg = NULL;
2278 image_error ("Unable to create X pixmap", Qnil, Qnil);
2279 return 0;
2282 LockPixels (GetGWorldPixMap (*pixmap));
2283 *ximg = *pixmap;
2284 return 1;
2286 #endif /* MAC_OS */
2290 /* Destroy XImage XIMG. Free XIMG->data. */
2292 static void
2293 x_destroy_x_image (ximg)
2294 XImagePtr ximg;
2296 xassert (interrupt_input_blocked);
2297 if (ximg)
2299 #ifdef HAVE_X_WINDOWS
2300 xfree (ximg->data);
2301 ximg->data = NULL;
2302 XDestroyImage (ximg);
2303 #endif /* HAVE_X_WINDOWS */
2304 #ifdef HAVE_NTGUI
2305 /* Data will be freed by DestroyObject. */
2306 ximg->data = NULL;
2307 xfree (ximg);
2308 #endif /* HAVE_NTGUI */
2309 #ifdef MAC_OS
2310 XDestroyImage (ximg);
2311 #endif /* MAC_OS */
2316 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2317 are width and height of both the image and pixmap. */
2319 static void
2320 x_put_x_image (f, ximg, pixmap, width, height)
2321 struct frame *f;
2322 XImagePtr ximg;
2323 Pixmap pixmap;
2324 int width, height;
2326 #ifdef HAVE_X_WINDOWS
2327 GC gc;
2329 xassert (interrupt_input_blocked);
2330 gc = XCreateGC (FRAME_X_DISPLAY (f), pixmap, 0, NULL);
2331 XPutImage (FRAME_X_DISPLAY (f), pixmap, gc, ximg, 0, 0, 0, 0, width, height);
2332 XFreeGC (FRAME_X_DISPLAY (f), gc);
2333 #endif /* HAVE_X_WINDOWS */
2335 #ifdef HAVE_NTGUI
2336 #if 0 /* I don't think this is necessary looking at where it is used. */
2337 HDC hdc = get_frame_dc (f);
2338 SetDIBits (hdc, pixmap, 0, height, ximg->data, &(ximg->info), DIB_RGB_COLORS);
2339 release_frame_dc (f, hdc);
2340 #endif
2341 #endif /* HAVE_NTGUI */
2343 #ifdef MAC_OS
2344 xassert (ximg == pixmap);
2345 #endif /* MAC_OS */
2349 /***********************************************************************
2350 File Handling
2351 ***********************************************************************/
2353 static unsigned char *slurp_file P_ ((char *, int *));
2356 /* Find image file FILE. Look in data-directory, then
2357 x-bitmap-file-path. Value is the encoded full name of the file
2358 found, or nil if not found. */
2360 Lisp_Object
2361 x_find_image_file (file)
2362 Lisp_Object file;
2364 Lisp_Object file_found, search_path;
2365 struct gcpro gcpro1, gcpro2;
2366 int fd;
2368 file_found = Qnil;
2369 search_path = Fcons (Vdata_directory, Vx_bitmap_file_path);
2370 GCPRO2 (file_found, search_path);
2372 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2373 fd = openp (search_path, file, Qnil, &file_found, Qnil);
2375 if (fd == -1)
2376 file_found = Qnil;
2377 else
2379 file_found = ENCODE_FILE (file_found);
2380 close (fd);
2383 UNGCPRO;
2384 return file_found;
2388 /* Read FILE into memory. Value is a pointer to a buffer allocated
2389 with xmalloc holding FILE's contents. Value is null if an error
2390 occurred. *SIZE is set to the size of the file. */
2392 static unsigned char *
2393 slurp_file (file, size)
2394 char *file;
2395 int *size;
2397 FILE *fp = NULL;
2398 unsigned char *buf = NULL;
2399 struct stat st;
2401 if (stat (file, &st) == 0
2402 && (fp = fopen (file, "rb")) != NULL
2403 && (buf = (unsigned char *) xmalloc (st.st_size),
2404 fread (buf, 1, st.st_size, fp) == st.st_size))
2406 *size = st.st_size;
2407 fclose (fp);
2409 else
2411 if (fp)
2412 fclose (fp);
2413 if (buf)
2415 xfree (buf);
2416 buf = NULL;
2420 return buf;
2425 #ifdef MAC_OS
2427 /***********************************************************************
2428 MAC Image Load Functions
2429 ***********************************************************************/
2431 static int image_load_quicktime P_ ((struct frame *, struct image *img,
2432 OSType));
2433 #ifdef MAC_OSX
2434 static int image_load_quartz2d P_ ((struct frame *, struct image *img, int));
2435 #endif
2437 static OSErr
2438 find_image_fsspec (specified_file, file, fss)
2439 Lisp_Object specified_file, *file;
2440 FSSpec *fss;
2442 OSErr err;
2443 AEDesc desc;
2445 *file = x_find_image_file (specified_file);
2446 if (!STRINGP (*file))
2447 return fnfErr; /* file or directory not found;
2448 incomplete pathname */
2449 /* Try to open the image file. */
2450 err = AECoercePtr (TYPE_FILE_NAME, SDATA (*file),
2451 SBYTES (*file), typeFSS, &desc);
2452 if (err == noErr)
2454 #if TARGET_API_MAC_CARBON
2455 err = AEGetDescData (&desc, fss, sizeof (FSSpec));
2456 #else
2457 *fss = *(FSSpec *)(*(desc.dataHandle));
2458 #endif
2459 AEDisposeDesc (&desc);
2461 return err;
2464 static int
2465 image_load_qt_1 (f, img, type, fss, dh)
2466 struct frame *f;
2467 struct image *img;
2468 OSType type;
2469 const FSSpec *fss;
2470 Handle dh;
2472 ComponentResult err;
2473 GraphicsImportComponent gi;
2474 Rect rect;
2475 int width, height;
2476 ImageDescriptionHandle desc_handle;
2477 short draw_all_pixels;
2478 Lisp_Object specified_bg;
2479 XColor color;
2480 XImagePtr ximg;
2481 RGBColor bg_color;
2483 err = OpenADefaultComponent (GraphicsImporterComponentType, type, &gi);
2484 if (err != noErr)
2486 image_error ("Cannot get importer component for `%s'", img->spec, Qnil);
2487 return 0;
2489 if (dh == NULL)
2491 /* read from file system spec */
2492 err = GraphicsImportSetDataFile (gi, fss);
2493 if (err != noErr)
2495 image_error ("Cannot set fsspec to graphics importer for '%s'",
2496 img->spec, Qnil);
2497 goto error;
2500 else
2502 /* read from data handle */
2503 err = GraphicsImportSetDataHandle (gi, dh);
2504 if (err != noErr)
2506 image_error ("Cannot set data handle to graphics importer for `%s'",
2507 img->spec, Qnil);
2508 goto error;
2511 err = GraphicsImportGetImageDescription (gi, &desc_handle);
2512 if (err != noErr || desc_handle == NULL)
2514 image_error ("Error reading `%s'", img->spec, Qnil);
2515 goto error;
2517 width = img->width = (*desc_handle)->width;
2518 height = img->height = (*desc_handle)->height;
2519 DisposeHandle ((Handle)desc_handle);
2521 if (!check_image_size (f, width, height))
2523 image_error ("Invalid image size", Qnil, Qnil);
2524 goto error;
2527 err = GraphicsImportDoesDrawAllPixels (gi, &draw_all_pixels);
2528 #if 0
2529 /* Don't check the error code here. It may have an undocumented
2530 value -32766. */
2531 if (err != noErr)
2533 image_error ("Error reading `%s'", img->spec, Qnil);
2534 goto error;
2536 #endif
2537 if (draw_all_pixels != graphicsImporterDrawsAllPixels)
2539 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
2540 if (!STRINGP (specified_bg) ||
2541 !mac_defined_color (f, SDATA (specified_bg), &color, 0))
2543 color.pixel = FRAME_BACKGROUND_PIXEL (f);
2544 color.red = RED16_FROM_ULONG (color.pixel);
2545 color.green = GREEN16_FROM_ULONG (color.pixel);
2546 color.blue = BLUE16_FROM_ULONG (color.pixel);
2550 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
2551 goto error;
2552 if (draw_all_pixels != graphicsImporterDrawsAllPixels)
2554 CGrafPtr old_port;
2555 GDHandle old_gdh;
2557 GetGWorld (&old_port, &old_gdh);
2558 SetGWorld (ximg, NULL);
2559 bg_color.red = color.red;
2560 bg_color.green = color.green;
2561 bg_color.blue = color.blue;
2562 RGBBackColor (&bg_color);
2563 #if TARGET_API_MAC_CARBON
2564 GetPortBounds (ximg, &rect);
2565 EraseRect (&rect);
2566 #else
2567 EraseRect (&(ximg->portRect));
2568 #endif
2569 SetGWorld (old_port, old_gdh);
2571 GraphicsImportSetGWorld (gi, ximg, NULL);
2572 GraphicsImportDraw (gi);
2573 CloseComponent (gi);
2575 /* Maybe fill in the background field while we have ximg handy. */
2576 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
2577 IMAGE_BACKGROUND (img, f, ximg);
2579 /* Put the image into the pixmap. */
2580 x_put_x_image (f, ximg, img->pixmap, width, height);
2581 x_destroy_x_image (ximg);
2582 return 1;
2584 error:
2585 CloseComponent (gi);
2586 return 0;
2590 /* Load an image using the QuickTime Graphics Importer.
2591 Note: The alpha channel does not work for PNG images. */
2592 static int
2593 image_load_quicktime (f, img, type)
2594 struct frame *f;
2595 struct image *img;
2596 OSType type;
2598 Lisp_Object specified_file;
2599 Lisp_Object specified_data;
2600 OSErr err;
2602 specified_file = image_spec_value (img->spec, QCfile, NULL);
2603 specified_data = image_spec_value (img->spec, QCdata, NULL);
2605 if (NILP (specified_data))
2607 /* Read from a file */
2608 Lisp_Object file;
2609 FSSpec fss;
2611 err = find_image_fsspec (specified_file, &file, &fss);
2612 if (err != noErr)
2614 if (err == fnfErr)
2615 image_error ("Cannot find image file `%s'", specified_file, Qnil);
2616 else
2617 image_error ("Cannot open `%s'", file, Qnil);
2618 return 0;
2620 return image_load_qt_1 (f, img, type, &fss, NULL);
2622 else
2624 /* Memory source! */
2625 int success_p;
2626 Handle dh;
2628 err = PtrToHand (SDATA (specified_data), &dh, SBYTES (specified_data));
2629 if (err != noErr)
2631 image_error ("Cannot allocate data handle for `%s'",
2632 img->spec, Qnil);
2633 return 0;
2635 success_p = image_load_qt_1 (f, img, type, NULL, dh);
2636 DisposeHandle (dh);
2637 return success_p;
2642 #ifdef MAC_OSX
2643 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2644 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2645 So don't use this function directly but determine at runtime
2646 whether it exists. */
2647 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType)
2648 (CGDataProviderRef, const float [], bool, CGColorRenderingIntent);
2649 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider;
2652 static void
2653 init_image_func_pointer ()
2655 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2657 MyCGImageCreateWithPNGDataProvider
2658 = (CGImageCreateWithPNGDataProviderProcType)
2659 NSAddressOfSymbol (NSLookupAndBindSymbol
2660 ("_CGImageCreateWithPNGDataProvider"));
2662 else
2663 MyCGImageCreateWithPNGDataProvider = NULL;
2667 static int
2668 image_load_quartz2d (f, img, png_p)
2669 struct frame *f;
2670 struct image *img;
2671 int png_p;
2673 Lisp_Object file, specified_file;
2674 Lisp_Object specified_data, specified_bg;
2675 struct gcpro gcpro1;
2676 CGDataProviderRef source;
2677 CGImageRef image;
2678 int width, height;
2679 XColor color;
2680 XImagePtr ximg = NULL;
2681 CGContextRef context;
2682 CGRect rectangle;
2684 /* Open the file. */
2685 specified_file = image_spec_value (img->spec, QCfile, NULL);
2686 specified_data = image_spec_value (img->spec, QCdata, NULL);
2688 file = Qnil;
2689 GCPRO1 (file);
2691 if (NILP (specified_data))
2693 CFStringRef path;
2694 CFURLRef url;
2696 file = x_find_image_file (specified_file);
2697 if (!STRINGP (file))
2699 image_error ("Cannot find image file `%s'", specified_file, Qnil);
2700 UNGCPRO;
2701 return 0;
2703 path = cfstring_create_with_utf8_cstring (SDATA (file));
2704 url = CFURLCreateWithFileSystemPath (NULL, path,
2705 kCFURLPOSIXPathStyle, 0);
2706 CFRelease (path);
2707 source = CGDataProviderCreateWithURL (url);
2708 CFRelease (url);
2710 else
2711 source = CGDataProviderCreateWithData (NULL, SDATA (specified_data),
2712 SBYTES (specified_data), NULL);
2714 if (png_p)
2715 image = (*MyCGImageCreateWithPNGDataProvider) (source, NULL, FALSE,
2716 kCGRenderingIntentDefault);
2717 else
2718 image = CGImageCreateWithJPEGDataProvider (source, NULL, FALSE,
2719 kCGRenderingIntentDefault);
2721 CGDataProviderRelease (source);
2722 if (image == NULL)
2724 UNGCPRO;
2725 image_error ("Error reading image `%s'", img->spec, Qnil);
2726 return 0;
2728 width = img->width = CGImageGetWidth (image);
2729 height = img->height = CGImageGetHeight (image);
2731 if (!check_image_size (f, width, height))
2733 CGImageRelease (image);
2734 UNGCPRO;
2735 image_error ("Invalid image size", Qnil, Qnil);
2736 return 0;
2739 if (png_p)
2741 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
2742 if (!STRINGP (specified_bg) ||
2743 !mac_defined_color (f, SDATA (specified_bg), &color, 0))
2745 color.pixel = FRAME_BACKGROUND_PIXEL (f);
2746 color.red = RED16_FROM_ULONG (color.pixel);
2747 color.green = GREEN16_FROM_ULONG (color.pixel);
2748 color.blue = BLUE16_FROM_ULONG (color.pixel);
2752 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
2754 CGImageRelease (image);
2755 UNGCPRO;
2756 return 0;
2758 rectangle = CGRectMake (0, 0, width, height);
2759 QDBeginCGContext (ximg, &context);
2760 if (png_p)
2762 CGContextSetRGBFillColor (context, color.red / 65535.0,
2763 color.green / 65535.0,
2764 color.blue / 65535.0, 1.0);
2765 CGContextFillRect (context, rectangle);
2767 CGContextDrawImage (context, rectangle, image);
2768 QDEndCGContext (ximg, &context);
2769 CGImageRelease (image);
2771 /* Maybe fill in the background field while we have ximg handy. */
2772 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
2773 IMAGE_BACKGROUND (img, f, ximg);
2775 /* Put the image into the pixmap. */
2776 x_put_x_image (f, ximg, img->pixmap, width, height);
2777 x_destroy_x_image (ximg);
2778 UNGCPRO;
2779 return 1;
2781 #endif
2783 #endif /* MAC_OS */
2786 /***********************************************************************
2787 XBM images
2788 ***********************************************************************/
2790 static int xbm_scan P_ ((unsigned char **, unsigned char *, char *, int *));
2791 static int xbm_load P_ ((struct frame *f, struct image *img));
2792 static int xbm_load_image P_ ((struct frame *f, struct image *img,
2793 unsigned char *, unsigned char *));
2794 static int xbm_image_p P_ ((Lisp_Object object));
2795 static int xbm_read_bitmap_data P_ ((struct frame *f,
2796 unsigned char *, unsigned char *,
2797 int *, int *, unsigned char **));
2798 static int xbm_file_p P_ ((Lisp_Object));
2801 /* Indices of image specification fields in xbm_format, below. */
2803 enum xbm_keyword_index
2805 XBM_TYPE,
2806 XBM_FILE,
2807 XBM_WIDTH,
2808 XBM_HEIGHT,
2809 XBM_DATA,
2810 XBM_FOREGROUND,
2811 XBM_BACKGROUND,
2812 XBM_ASCENT,
2813 XBM_MARGIN,
2814 XBM_RELIEF,
2815 XBM_ALGORITHM,
2816 XBM_HEURISTIC_MASK,
2817 XBM_MASK,
2818 XBM_LAST
2821 /* Vector of image_keyword structures describing the format
2822 of valid XBM image specifications. */
2824 static struct image_keyword xbm_format[XBM_LAST] =
2826 {":type", IMAGE_SYMBOL_VALUE, 1},
2827 {":file", IMAGE_STRING_VALUE, 0},
2828 {":width", IMAGE_POSITIVE_INTEGER_VALUE, 0},
2829 {":height", IMAGE_POSITIVE_INTEGER_VALUE, 0},
2830 {":data", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2831 {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
2832 {":background", IMAGE_STRING_OR_NIL_VALUE, 0},
2833 {":ascent", IMAGE_ASCENT_VALUE, 0},
2834 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
2835 {":relief", IMAGE_INTEGER_VALUE, 0},
2836 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2837 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2838 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
2841 /* Structure describing the image type XBM. */
2843 static struct image_type xbm_type =
2845 &Qxbm,
2846 xbm_image_p,
2847 xbm_load,
2848 x_clear_image,
2849 NULL
2852 /* Tokens returned from xbm_scan. */
2854 enum xbm_token
2856 XBM_TK_IDENT = 256,
2857 XBM_TK_NUMBER
2861 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2862 A valid specification is a list starting with the symbol `image'
2863 The rest of the list is a property list which must contain an
2864 entry `:type xbm..
2866 If the specification specifies a file to load, it must contain
2867 an entry `:file FILENAME' where FILENAME is a string.
2869 If the specification is for a bitmap loaded from memory it must
2870 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2871 WIDTH and HEIGHT are integers > 0. DATA may be:
2873 1. a string large enough to hold the bitmap data, i.e. it must
2874 have a size >= (WIDTH + 7) / 8 * HEIGHT
2876 2. a bool-vector of size >= WIDTH * HEIGHT
2878 3. a vector of strings or bool-vectors, one for each line of the
2879 bitmap.
2881 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2882 may not be specified in this case because they are defined in the
2883 XBM file.
2885 Both the file and data forms may contain the additional entries
2886 `:background COLOR' and `:foreground COLOR'. If not present,
2887 foreground and background of the frame on which the image is
2888 displayed is used. */
2890 static int
2891 xbm_image_p (object)
2892 Lisp_Object object;
2894 struct image_keyword kw[XBM_LAST];
2896 bcopy (xbm_format, kw, sizeof kw);
2897 if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
2898 return 0;
2900 xassert (EQ (kw[XBM_TYPE].value, Qxbm));
2902 if (kw[XBM_FILE].count)
2904 if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_DATA].count)
2905 return 0;
2907 else if (kw[XBM_DATA].count && xbm_file_p (kw[XBM_DATA].value))
2909 /* In-memory XBM file. */
2910 if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_FILE].count)
2911 return 0;
2913 else
2915 Lisp_Object data;
2916 int width, height;
2918 /* Entries for `:width', `:height' and `:data' must be present. */
2919 if (!kw[XBM_WIDTH].count
2920 || !kw[XBM_HEIGHT].count
2921 || !kw[XBM_DATA].count)
2922 return 0;
2924 data = kw[XBM_DATA].value;
2925 width = XFASTINT (kw[XBM_WIDTH].value);
2926 height = XFASTINT (kw[XBM_HEIGHT].value);
2928 /* Check type of data, and width and height against contents of
2929 data. */
2930 if (VECTORP (data))
2932 int i;
2934 /* Number of elements of the vector must be >= height. */
2935 if (XVECTOR (data)->size < height)
2936 return 0;
2938 /* Each string or bool-vector in data must be large enough
2939 for one line of the image. */
2940 for (i = 0; i < height; ++i)
2942 Lisp_Object elt = XVECTOR (data)->contents[i];
2944 if (STRINGP (elt))
2946 if (SCHARS (elt)
2947 < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR)
2948 return 0;
2950 else if (BOOL_VECTOR_P (elt))
2952 if (XBOOL_VECTOR (elt)->size < width)
2953 return 0;
2955 else
2956 return 0;
2959 else if (STRINGP (data))
2961 if (SCHARS (data)
2962 < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR * height)
2963 return 0;
2965 else if (BOOL_VECTOR_P (data))
2967 if (XBOOL_VECTOR (data)->size < width * height)
2968 return 0;
2970 else
2971 return 0;
2974 return 1;
2978 /* Scan a bitmap file. FP is the stream to read from. Value is
2979 either an enumerator from enum xbm_token, or a character for a
2980 single-character token, or 0 at end of file. If scanning an
2981 identifier, store the lexeme of the identifier in SVAL. If
2982 scanning a number, store its value in *IVAL. */
2984 static int
2985 xbm_scan (s, end, sval, ival)
2986 unsigned char **s, *end;
2987 char *sval;
2988 int *ival;
2990 unsigned int c;
2992 loop:
2994 /* Skip white space. */
2995 while (*s < end && (c = *(*s)++, isspace (c)))
2998 if (*s >= end)
2999 c = 0;
3000 else if (isdigit (c))
3002 int value = 0, digit;
3004 if (c == '0' && *s < end)
3006 c = *(*s)++;
3007 if (c == 'x' || c == 'X')
3009 while (*s < end)
3011 c = *(*s)++;
3012 if (isdigit (c))
3013 digit = c - '0';
3014 else if (c >= 'a' && c <= 'f')
3015 digit = c - 'a' + 10;
3016 else if (c >= 'A' && c <= 'F')
3017 digit = c - 'A' + 10;
3018 else
3019 break;
3020 value = 16 * value + digit;
3023 else if (isdigit (c))
3025 value = c - '0';
3026 while (*s < end
3027 && (c = *(*s)++, isdigit (c)))
3028 value = 8 * value + c - '0';
3031 else
3033 value = c - '0';
3034 while (*s < end
3035 && (c = *(*s)++, isdigit (c)))
3036 value = 10 * value + c - '0';
3039 if (*s < end)
3040 *s = *s - 1;
3041 *ival = value;
3042 c = XBM_TK_NUMBER;
3044 else if (isalpha (c) || c == '_')
3046 *sval++ = c;
3047 while (*s < end
3048 && (c = *(*s)++, (isalnum (c) || c == '_')))
3049 *sval++ = c;
3050 *sval = 0;
3051 if (*s < end)
3052 *s = *s - 1;
3053 c = XBM_TK_IDENT;
3055 else if (c == '/' && **s == '*')
3057 /* C-style comment. */
3058 ++*s;
3059 while (**s && (**s != '*' || *(*s + 1) != '/'))
3060 ++*s;
3061 if (**s)
3063 *s += 2;
3064 goto loop;
3068 return c;
3071 #ifdef HAVE_NTGUI
3073 /* Create a Windows bitmap from X bitmap data. */
3074 static HBITMAP
3075 w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
3077 static unsigned char swap_nibble[16]
3078 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
3079 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
3080 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
3081 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
3082 int i, j, w1, w2;
3083 unsigned char *bits, *p;
3084 HBITMAP bmp;
3086 w1 = (width + 7) / 8; /* nb of 8bits elt in X bitmap */
3087 w2 = ((width + 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
3088 bits = (unsigned char *) alloca (height * w2);
3089 bzero (bits, height * w2);
3090 for (i = 0; i < height; i++)
3092 p = bits + i*w2;
3093 for (j = 0; j < w1; j++)
3095 /* Bitswap XBM bytes to match how Windows does things. */
3096 unsigned char c = *data++;
3097 *p++ = (unsigned char)((swap_nibble[c & 0xf] << 4)
3098 | (swap_nibble[(c>>4) & 0xf]));
3101 bmp = CreateBitmap (width, height, 1, 1, (char *) bits);
3103 return bmp;
3106 static void convert_mono_to_color_image (f, img, foreground, background)
3107 struct frame *f;
3108 struct image *img;
3109 COLORREF foreground, background;
3111 HDC hdc, old_img_dc, new_img_dc;
3112 HGDIOBJ old_prev, new_prev;
3113 HBITMAP new_pixmap;
3115 hdc = get_frame_dc (f);
3116 old_img_dc = CreateCompatibleDC (hdc);
3117 new_img_dc = CreateCompatibleDC (hdc);
3118 new_pixmap = CreateCompatibleBitmap (hdc, img->width, img->height);
3119 release_frame_dc (f, hdc);
3120 old_prev = SelectObject (old_img_dc, img->pixmap);
3121 new_prev = SelectObject (new_img_dc, new_pixmap);
3122 SetTextColor (new_img_dc, background);
3123 SetBkColor (new_img_dc, foreground);
3125 BitBlt (new_img_dc, 0, 0, img->width, img->height, old_img_dc,
3126 0, 0, SRCCOPY);
3128 SelectObject (old_img_dc, old_prev);
3129 SelectObject (new_img_dc, new_prev);
3130 DeleteDC (old_img_dc);
3131 DeleteDC (new_img_dc);
3132 DeleteObject (img->pixmap);
3133 if (new_pixmap == 0)
3134 fprintf (stderr, "Failed to convert image to color.\n");
3135 else
3136 img->pixmap = new_pixmap;
3139 #define XBM_BIT_SHUFFLE(b) (~(b))
3141 #else
3143 #define XBM_BIT_SHUFFLE(b) (b)
3145 #endif /* HAVE_NTGUI */
3148 static void
3149 Create_Pixmap_From_Bitmap_Data(f, img, data, fg, bg, non_default_colors)
3150 struct frame *f;
3151 struct image *img;
3152 char *data;
3153 RGB_PIXEL_COLOR fg, bg;
3154 int non_default_colors;
3156 #ifdef HAVE_NTGUI
3157 img->pixmap
3158 = w32_create_pixmap_from_bitmap_data (img->width, img->height, data);
3160 /* If colors were specified, transfer the bitmap to a color one. */
3161 if (non_default_colors)
3162 convert_mono_to_color_image (f, img, fg, bg);
3163 #else
3164 img->pixmap
3165 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f),
3166 FRAME_X_WINDOW (f),
3167 data,
3168 img->width, img->height,
3169 fg, bg,
3170 DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
3171 #endif /* HAVE_NTGUI */
3176 /* Replacement for XReadBitmapFileData which isn't available under old
3177 X versions. CONTENTS is a pointer to a buffer to parse; END is the
3178 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
3179 the image. Return in *DATA the bitmap data allocated with xmalloc.
3180 Value is non-zero if successful. DATA null means just test if
3181 CONTENTS looks like an in-memory XBM file. */
3183 static int
3184 xbm_read_bitmap_data (f, contents, end, width, height, data)
3185 struct frame *f;
3186 unsigned char *contents, *end;
3187 int *width, *height;
3188 unsigned char **data;
3190 unsigned char *s = contents;
3191 char buffer[BUFSIZ];
3192 int padding_p = 0;
3193 int v10 = 0;
3194 int bytes_per_line, i, nbytes;
3195 unsigned char *p;
3196 int value;
3197 int LA1;
3199 #define match() \
3200 LA1 = xbm_scan (&s, end, buffer, &value)
3202 #define expect(TOKEN) \
3203 if (LA1 != (TOKEN)) \
3204 goto failure; \
3205 else \
3206 match ()
3208 #define expect_ident(IDENT) \
3209 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
3210 match (); \
3211 else \
3212 goto failure
3214 *width = *height = -1;
3215 if (data)
3216 *data = NULL;
3217 LA1 = xbm_scan (&s, end, buffer, &value);
3219 /* Parse defines for width, height and hot-spots. */
3220 while (LA1 == '#')
3222 match ();
3223 expect_ident ("define");
3224 expect (XBM_TK_IDENT);
3226 if (LA1 == XBM_TK_NUMBER)
3228 char *p = strrchr (buffer, '_');
3229 p = p ? p + 1 : buffer;
3230 if (strcmp (p, "width") == 0)
3231 *width = value;
3232 else if (strcmp (p, "height") == 0)
3233 *height = value;
3235 expect (XBM_TK_NUMBER);
3238 if (!check_image_size (f, *width, *height))
3239 goto failure;
3240 else if (data == NULL)
3241 goto success;
3243 /* Parse bits. Must start with `static'. */
3244 expect_ident ("static");
3245 if (LA1 == XBM_TK_IDENT)
3247 if (strcmp (buffer, "unsigned") == 0)
3249 match ();
3250 expect_ident ("char");
3252 else if (strcmp (buffer, "short") == 0)
3254 match ();
3255 v10 = 1;
3256 if (*width % 16 && *width % 16 < 9)
3257 padding_p = 1;
3259 else if (strcmp (buffer, "char") == 0)
3260 match ();
3261 else
3262 goto failure;
3264 else
3265 goto failure;
3267 expect (XBM_TK_IDENT);
3268 expect ('[');
3269 expect (']');
3270 expect ('=');
3271 expect ('{');
3273 bytes_per_line = (*width + 7) / 8 + padding_p;
3274 nbytes = bytes_per_line * *height;
3275 p = *data = (unsigned char *) xmalloc (nbytes);
3277 if (v10)
3279 for (i = 0; i < nbytes; i += 2)
3281 int val = value;
3282 expect (XBM_TK_NUMBER);
3284 *p++ = XBM_BIT_SHUFFLE (val);
3285 if (!padding_p || ((i + 2) % bytes_per_line))
3286 *p++ = XBM_BIT_SHUFFLE (value >> 8);
3288 if (LA1 == ',' || LA1 == '}')
3289 match ();
3290 else
3291 goto failure;
3294 else
3296 for (i = 0; i < nbytes; ++i)
3298 int val = value;
3299 expect (XBM_TK_NUMBER);
3301 *p++ = XBM_BIT_SHUFFLE (val);
3303 if (LA1 == ',' || LA1 == '}')
3304 match ();
3305 else
3306 goto failure;
3310 success:
3311 return 1;
3313 failure:
3315 if (data && *data)
3317 xfree (*data);
3318 *data = NULL;
3320 return 0;
3322 #undef match
3323 #undef expect
3324 #undef expect_ident
3328 /* Load XBM image IMG which will be displayed on frame F from buffer
3329 CONTENTS. END is the end of the buffer. Value is non-zero if
3330 successful. */
3332 static int
3333 xbm_load_image (f, img, contents, end)
3334 struct frame *f;
3335 struct image *img;
3336 unsigned char *contents, *end;
3338 int rc;
3339 unsigned char *data;
3340 int success_p = 0;
3342 rc = xbm_read_bitmap_data (f, contents, end, &img->width, &img->height, &data);
3343 if (rc)
3345 unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
3346 unsigned long background = FRAME_BACKGROUND_PIXEL (f);
3347 int non_default_colors = 0;
3348 Lisp_Object value;
3350 xassert (img->width > 0 && img->height > 0);
3352 /* Get foreground and background colors, maybe allocate colors. */
3353 value = image_spec_value (img->spec, QCforeground, NULL);
3354 if (!NILP (value))
3356 foreground = x_alloc_image_color (f, img, value, foreground);
3357 non_default_colors = 1;
3359 value = image_spec_value (img->spec, QCbackground, NULL);
3360 if (!NILP (value))
3362 background = x_alloc_image_color (f, img, value, background);
3363 img->background = background;
3364 img->background_valid = 1;
3365 non_default_colors = 1;
3368 Create_Pixmap_From_Bitmap_Data (f, img, data,
3369 foreground, background,
3370 non_default_colors);
3371 xfree (data);
3373 if (img->pixmap == NO_PIXMAP)
3375 x_clear_image (f, img);
3376 image_error ("Unable to create X pixmap for `%s'", img->spec, Qnil);
3378 else
3379 success_p = 1;
3381 else
3382 image_error ("Error loading XBM image `%s'", img->spec, Qnil);
3384 return success_p;
3388 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3390 static int
3391 xbm_file_p (data)
3392 Lisp_Object data;
3394 int w, h;
3395 return (STRINGP (data)
3396 && xbm_read_bitmap_data (NULL, SDATA (data),
3397 (SDATA (data)
3398 + SBYTES (data)),
3399 &w, &h, NULL));
3403 /* Fill image IMG which is used on frame F with pixmap data. Value is
3404 non-zero if successful. */
3406 static int
3407 xbm_load (f, img)
3408 struct frame *f;
3409 struct image *img;
3411 int success_p = 0;
3412 Lisp_Object file_name;
3414 xassert (xbm_image_p (img->spec));
3416 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3417 file_name = image_spec_value (img->spec, QCfile, NULL);
3418 if (STRINGP (file_name))
3420 Lisp_Object file;
3421 unsigned char *contents;
3422 int size;
3423 struct gcpro gcpro1;
3425 file = x_find_image_file (file_name);
3426 GCPRO1 (file);
3427 if (!STRINGP (file))
3429 image_error ("Cannot find image file `%s'", file_name, Qnil);
3430 UNGCPRO;
3431 return 0;
3434 contents = slurp_file (SDATA (file), &size);
3435 if (contents == NULL)
3437 image_error ("Error loading XBM image `%s'", img->spec, Qnil);
3438 UNGCPRO;
3439 return 0;
3442 success_p = xbm_load_image (f, img, contents, contents + size);
3443 UNGCPRO;
3445 else
3447 struct image_keyword fmt[XBM_LAST];
3448 Lisp_Object data;
3449 unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
3450 unsigned long background = FRAME_BACKGROUND_PIXEL (f);
3451 int non_default_colors = 0;
3452 char *bits;
3453 int parsed_p;
3454 int in_memory_file_p = 0;
3456 /* See if data looks like an in-memory XBM file. */
3457 data = image_spec_value (img->spec, QCdata, NULL);
3458 in_memory_file_p = xbm_file_p (data);
3460 /* Parse the image specification. */
3461 bcopy (xbm_format, fmt, sizeof fmt);
3462 parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
3463 xassert (parsed_p);
3465 /* Get specified width, and height. */
3466 if (!in_memory_file_p)
3468 img->width = XFASTINT (fmt[XBM_WIDTH].value);
3469 img->height = XFASTINT (fmt[XBM_HEIGHT].value);
3470 xassert (img->width > 0 && img->height > 0);
3473 /* Get foreground and background colors, maybe allocate colors. */
3474 if (fmt[XBM_FOREGROUND].count
3475 && STRINGP (fmt[XBM_FOREGROUND].value))
3477 foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
3478 foreground);
3479 non_default_colors = 1;
3482 if (fmt[XBM_BACKGROUND].count
3483 && STRINGP (fmt[XBM_BACKGROUND].value))
3485 background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
3486 background);
3487 non_default_colors = 1;
3490 if (in_memory_file_p)
3491 success_p = xbm_load_image (f, img, SDATA (data),
3492 (SDATA (data)
3493 + SBYTES (data)));
3494 else
3496 if (VECTORP (data))
3498 int i;
3499 char *p;
3500 int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
3502 p = bits = (char *) alloca (nbytes * img->height);
3503 for (i = 0; i < img->height; ++i, p += nbytes)
3505 Lisp_Object line = XVECTOR (data)->contents[i];
3506 if (STRINGP (line))
3507 bcopy (SDATA (line), p, nbytes);
3508 else
3509 bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
3512 else if (STRINGP (data))
3513 bits = SDATA (data);
3514 else
3515 bits = XBOOL_VECTOR (data)->data;
3517 /* Create the pixmap. */
3519 Create_Pixmap_From_Bitmap_Data (f, img, bits,
3520 foreground, background,
3521 non_default_colors);
3522 if (img->pixmap)
3523 success_p = 1;
3524 else
3526 image_error ("Unable to create pixmap for XBM image `%s'",
3527 img->spec, Qnil);
3528 x_clear_image (f, img);
3533 return success_p;
3538 /***********************************************************************
3539 XPM images
3540 ***********************************************************************/
3542 #if defined (HAVE_XPM) || defined (MAC_OS)
3544 static int xpm_image_p P_ ((Lisp_Object object));
3545 static int xpm_load P_ ((struct frame *f, struct image *img));
3546 static int xpm_valid_color_symbols_p P_ ((Lisp_Object));
3548 #endif /* HAVE_XPM || MAC_OS */
3550 #ifdef HAVE_XPM
3551 #ifdef HAVE_NTGUI
3552 /* Indicate to xpm.h that we don't have Xlib. */
3553 #define FOR_MSW
3554 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3555 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3556 #define XColor xpm_XColor
3557 #define XImage xpm_XImage
3558 #define Display xpm_Display
3559 #define PIXEL_ALREADY_TYPEDEFED
3560 #include "X11/xpm.h"
3561 #undef FOR_MSW
3562 #undef XColor
3563 #undef XImage
3564 #undef Display
3565 #undef PIXEL_ALREADY_TYPEDEFED
3566 #else
3567 #include "X11/xpm.h"
3568 #endif /* HAVE_NTGUI */
3569 #endif /* HAVE_XPM */
3571 #if defined (HAVE_XPM) || defined (MAC_OS)
3572 /* The symbol `xpm' identifying XPM-format images. */
3574 Lisp_Object Qxpm;
3576 /* Indices of image specification fields in xpm_format, below. */
3578 enum xpm_keyword_index
3580 XPM_TYPE,
3581 XPM_FILE,
3582 XPM_DATA,
3583 XPM_ASCENT,
3584 XPM_MARGIN,
3585 XPM_RELIEF,
3586 XPM_ALGORITHM,
3587 XPM_HEURISTIC_MASK,
3588 XPM_MASK,
3589 XPM_COLOR_SYMBOLS,
3590 XPM_BACKGROUND,
3591 XPM_LAST
3594 /* Vector of image_keyword structures describing the format
3595 of valid XPM image specifications. */
3597 static struct image_keyword xpm_format[XPM_LAST] =
3599 {":type", IMAGE_SYMBOL_VALUE, 1},
3600 {":file", IMAGE_STRING_VALUE, 0},
3601 {":data", IMAGE_STRING_VALUE, 0},
3602 {":ascent", IMAGE_ASCENT_VALUE, 0},
3603 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
3604 {":relief", IMAGE_INTEGER_VALUE, 0},
3605 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3606 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3607 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3608 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3609 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
3612 /* Structure describing the image type XPM. */
3614 static struct image_type xpm_type =
3616 &Qxpm,
3617 xpm_image_p,
3618 xpm_load,
3619 x_clear_image,
3620 NULL
3623 #ifdef HAVE_X_WINDOWS
3625 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3626 functions for allocating image colors. Our own functions handle
3627 color allocation failures more gracefully than the ones on the XPM
3628 lib. */
3630 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3631 #define ALLOC_XPM_COLORS
3632 #endif
3633 #endif /* HAVE_X_WINDOWS */
3635 #ifdef ALLOC_XPM_COLORS
3637 static void xpm_init_color_cache P_ ((struct frame *, XpmAttributes *));
3638 static void xpm_free_color_cache P_ ((void));
3639 static int xpm_lookup_color P_ ((struct frame *, char *, XColor *));
3640 static int xpm_color_bucket P_ ((char *));
3641 static struct xpm_cached_color *xpm_cache_color P_ ((struct frame *, char *,
3642 XColor *, int));
3644 /* An entry in a hash table used to cache color definitions of named
3645 colors. This cache is necessary to speed up XPM image loading in
3646 case we do color allocations ourselves. Without it, we would need
3647 a call to XParseColor per pixel in the image. */
3649 struct xpm_cached_color
3651 /* Next in collision chain. */
3652 struct xpm_cached_color *next;
3654 /* Color definition (RGB and pixel color). */
3655 XColor color;
3657 /* Color name. */
3658 char name[1];
3661 /* The hash table used for the color cache, and its bucket vector
3662 size. */
3664 #define XPM_COLOR_CACHE_BUCKETS 1001
3665 struct xpm_cached_color **xpm_color_cache;
3667 /* Initialize the color cache. */
3669 static void
3670 xpm_init_color_cache (f, attrs)
3671 struct frame *f;
3672 XpmAttributes *attrs;
3674 size_t nbytes = XPM_COLOR_CACHE_BUCKETS * sizeof *xpm_color_cache;
3675 xpm_color_cache = (struct xpm_cached_color **) xmalloc (nbytes);
3676 memset (xpm_color_cache, 0, nbytes);
3677 init_color_table ();
3679 if (attrs->valuemask & XpmColorSymbols)
3681 int i;
3682 XColor color;
3684 for (i = 0; i < attrs->numsymbols; ++i)
3685 if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
3686 attrs->colorsymbols[i].value, &color))
3688 color.pixel = lookup_rgb_color (f, color.red, color.green,
3689 color.blue);
3690 xpm_cache_color (f, attrs->colorsymbols[i].name, &color, -1);
3695 /* Free the color cache. */
3697 static void
3698 xpm_free_color_cache ()
3700 struct xpm_cached_color *p, *next;
3701 int i;
3703 for (i = 0; i < XPM_COLOR_CACHE_BUCKETS; ++i)
3704 for (p = xpm_color_cache[i]; p; p = next)
3706 next = p->next;
3707 xfree (p);
3710 xfree (xpm_color_cache);
3711 xpm_color_cache = NULL;
3712 free_color_table ();
3715 /* Return the bucket index for color named COLOR_NAME in the color
3716 cache. */
3718 static int
3719 xpm_color_bucket (color_name)
3720 char *color_name;
3722 unsigned h = 0;
3723 char *s;
3725 for (s = color_name; *s; ++s)
3726 h = (h << 2) ^ *s;
3727 return h %= XPM_COLOR_CACHE_BUCKETS;
3731 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3732 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3733 entry added. */
3735 static struct xpm_cached_color *
3736 xpm_cache_color (f, color_name, color, bucket)
3737 struct frame *f;
3738 char *color_name;
3739 XColor *color;
3740 int bucket;
3742 size_t nbytes;
3743 struct xpm_cached_color *p;
3745 if (bucket < 0)
3746 bucket = xpm_color_bucket (color_name);
3748 nbytes = sizeof *p + strlen (color_name);
3749 p = (struct xpm_cached_color *) xmalloc (nbytes);
3750 strcpy (p->name, color_name);
3751 p->color = *color;
3752 p->next = xpm_color_cache[bucket];
3753 xpm_color_cache[bucket] = p;
3754 return p;
3757 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3758 return the cached definition in *COLOR. Otherwise, make a new
3759 entry in the cache and allocate the color. Value is zero if color
3760 allocation failed. */
3762 static int
3763 xpm_lookup_color (f, color_name, color)
3764 struct frame *f;
3765 char *color_name;
3766 XColor *color;
3768 struct xpm_cached_color *p;
3769 int h = xpm_color_bucket (color_name);
3771 for (p = xpm_color_cache[h]; p; p = p->next)
3772 if (strcmp (p->name, color_name) == 0)
3773 break;
3775 if (p != NULL)
3776 *color = p->color;
3777 else if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
3778 color_name, color))
3780 color->pixel = lookup_rgb_color (f, color->red, color->green,
3781 color->blue);
3782 p = xpm_cache_color (f, color_name, color, h);
3784 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3785 with transparency, and it's useful. */
3786 else if (strcmp ("opaque", color_name) == 0)
3788 bzero (color, sizeof (XColor)); /* Is this necessary/correct? */
3789 color->pixel = FRAME_FOREGROUND_PIXEL (f);
3790 p = xpm_cache_color (f, color_name, color, h);
3793 return p != NULL;
3797 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3798 CLOSURE is a pointer to the frame on which we allocate the
3799 color. Return in *COLOR the allocated color. Value is non-zero
3800 if successful. */
3802 static int
3803 xpm_alloc_color (dpy, cmap, color_name, color, closure)
3804 Display *dpy;
3805 Colormap cmap;
3806 char *color_name;
3807 XColor *color;
3808 void *closure;
3810 return xpm_lookup_color ((struct frame *) closure, color_name, color);
3814 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3815 is a pointer to the frame on which we allocate the color. Value is
3816 non-zero if successful. */
3818 static int
3819 xpm_free_colors (dpy, cmap, pixels, npixels, closure)
3820 Display *dpy;
3821 Colormap cmap;
3822 Pixel *pixels;
3823 int npixels;
3824 void *closure;
3826 return 1;
3829 #endif /* ALLOC_XPM_COLORS */
3832 #ifdef HAVE_NTGUI
3834 /* XPM library details. */
3836 DEF_IMGLIB_FN (XpmFreeAttributes);
3837 DEF_IMGLIB_FN (XpmCreateImageFromBuffer);
3838 DEF_IMGLIB_FN (XpmReadFileToImage);
3839 DEF_IMGLIB_FN (XImageFree);
3841 static int
3842 init_xpm_functions (Lisp_Object libraries)
3844 HMODULE library;
3846 if (!(library = w32_delayed_load (libraries, Qxpm)))
3847 return 0;
3849 LOAD_IMGLIB_FN (library, XpmFreeAttributes);
3850 LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
3851 LOAD_IMGLIB_FN (library, XpmReadFileToImage);
3852 LOAD_IMGLIB_FN (library, XImageFree);
3853 return 1;
3856 #endif /* HAVE_NTGUI */
3859 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3860 for XPM images. Such a list must consist of conses whose car and
3861 cdr are strings. */
3863 static int
3864 xpm_valid_color_symbols_p (color_symbols)
3865 Lisp_Object color_symbols;
3867 while (CONSP (color_symbols))
3869 Lisp_Object sym = XCAR (color_symbols);
3870 if (!CONSP (sym)
3871 || !STRINGP (XCAR (sym))
3872 || !STRINGP (XCDR (sym)))
3873 break;
3874 color_symbols = XCDR (color_symbols);
3877 return NILP (color_symbols);
3881 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3883 static int
3884 xpm_image_p (object)
3885 Lisp_Object object;
3887 struct image_keyword fmt[XPM_LAST];
3888 bcopy (xpm_format, fmt, sizeof fmt);
3889 return (parse_image_spec (object, fmt, XPM_LAST, Qxpm)
3890 /* Either `:file' or `:data' must be present. */
3891 && fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
3892 /* Either no `:color-symbols' or it's a list of conses
3893 whose car and cdr are strings. */
3894 && (fmt[XPM_COLOR_SYMBOLS].count == 0
3895 || xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value)));
3898 #endif /* HAVE_XPM || MAC_OS */
3900 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
3902 x_create_bitmap_from_xpm_data (f, bits)
3903 struct frame *f;
3904 char **bits;
3906 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3907 int id, rc;
3908 XpmAttributes attrs;
3909 Pixmap bitmap, mask;
3911 bzero (&attrs, sizeof attrs);
3913 attrs.visual = FRAME_X_VISUAL (f);
3914 attrs.colormap = FRAME_X_COLORMAP (f);
3915 attrs.valuemask |= XpmVisual;
3916 attrs.valuemask |= XpmColormap;
3918 rc = XpmCreatePixmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3919 bits, &bitmap, &mask, &attrs);
3920 if (rc != XpmSuccess)
3922 XpmFreeAttributes (&attrs);
3923 return -1;
3926 id = x_allocate_bitmap_record (f);
3927 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
3928 dpyinfo->bitmaps[id - 1].have_mask = 1;
3929 dpyinfo->bitmaps[id - 1].mask = mask;
3930 dpyinfo->bitmaps[id - 1].file = NULL;
3931 dpyinfo->bitmaps[id - 1].height = attrs.height;
3932 dpyinfo->bitmaps[id - 1].width = attrs.width;
3933 dpyinfo->bitmaps[id - 1].depth = attrs.depth;
3934 dpyinfo->bitmaps[id - 1].refcount = 1;
3936 XpmFreeAttributes (&attrs);
3937 return id;
3939 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
3941 /* Load image IMG which will be displayed on frame F. Value is
3942 non-zero if successful. */
3944 #ifdef HAVE_XPM
3946 static int
3947 xpm_load (f, img)
3948 struct frame *f;
3949 struct image *img;
3951 int rc;
3952 XpmAttributes attrs;
3953 Lisp_Object specified_file, color_symbols;
3954 #ifdef HAVE_NTGUI
3955 HDC hdc;
3956 xpm_XImage * xpm_image = NULL, * xpm_mask = NULL;
3957 #endif /* HAVE_NTGUI */
3959 /* Configure the XPM lib. Use the visual of frame F. Allocate
3960 close colors. Return colors allocated. */
3961 bzero (&attrs, sizeof attrs);
3963 #ifndef HAVE_NTGUI
3964 attrs.visual = FRAME_X_VISUAL (f);
3965 attrs.colormap = FRAME_X_COLORMAP (f);
3966 attrs.valuemask |= XpmVisual;
3967 attrs.valuemask |= XpmColormap;
3968 #endif /* HAVE_NTGUI */
3970 #ifdef ALLOC_XPM_COLORS
3971 /* Allocate colors with our own functions which handle
3972 failing color allocation more gracefully. */
3973 attrs.color_closure = f;
3974 attrs.alloc_color = xpm_alloc_color;
3975 attrs.free_colors = xpm_free_colors;
3976 attrs.valuemask |= XpmAllocColor | XpmFreeColors | XpmColorClosure;
3977 #else /* not ALLOC_XPM_COLORS */
3978 /* Let the XPM lib allocate colors. */
3979 attrs.valuemask |= XpmReturnAllocPixels;
3980 #ifdef XpmAllocCloseColors
3981 attrs.alloc_close_colors = 1;
3982 attrs.valuemask |= XpmAllocCloseColors;
3983 #else /* not XpmAllocCloseColors */
3984 attrs.closeness = 600;
3985 attrs.valuemask |= XpmCloseness;
3986 #endif /* not XpmAllocCloseColors */
3987 #endif /* ALLOC_XPM_COLORS */
3989 /* If image specification contains symbolic color definitions, add
3990 these to `attrs'. */
3991 color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
3992 if (CONSP (color_symbols))
3994 Lisp_Object tail;
3995 XpmColorSymbol *xpm_syms;
3996 int i, size;
3998 attrs.valuemask |= XpmColorSymbols;
4000 /* Count number of symbols. */
4001 attrs.numsymbols = 0;
4002 for (tail = color_symbols; CONSP (tail); tail = XCDR (tail))
4003 ++attrs.numsymbols;
4005 /* Allocate an XpmColorSymbol array. */
4006 size = attrs.numsymbols * sizeof *xpm_syms;
4007 xpm_syms = (XpmColorSymbol *) alloca (size);
4008 bzero (xpm_syms, size);
4009 attrs.colorsymbols = xpm_syms;
4011 /* Fill the color symbol array. */
4012 for (tail = color_symbols, i = 0;
4013 CONSP (tail);
4014 ++i, tail = XCDR (tail))
4016 Lisp_Object name = XCAR (XCAR (tail));
4017 Lisp_Object color = XCDR (XCAR (tail));
4018 xpm_syms[i].name = (char *) alloca (SCHARS (name) + 1);
4019 strcpy (xpm_syms[i].name, SDATA (name));
4020 xpm_syms[i].value = (char *) alloca (SCHARS (color) + 1);
4021 strcpy (xpm_syms[i].value, SDATA (color));
4025 /* Create a pixmap for the image, either from a file, or from a
4026 string buffer containing data in the same format as an XPM file. */
4027 #ifdef ALLOC_XPM_COLORS
4028 xpm_init_color_cache (f, &attrs);
4029 #endif
4031 specified_file = image_spec_value (img->spec, QCfile, NULL);
4033 #ifdef HAVE_NTGUI
4035 HDC frame_dc = get_frame_dc (f);
4036 hdc = CreateCompatibleDC (frame_dc);
4037 release_frame_dc (f, frame_dc);
4039 #endif /* HAVE_NTGUI */
4041 if (STRINGP (specified_file))
4043 Lisp_Object file = x_find_image_file (specified_file);
4044 if (!STRINGP (file))
4046 image_error ("Cannot find image file `%s'", specified_file, Qnil);
4047 return 0;
4050 #ifdef HAVE_NTGUI
4051 /* XpmReadFileToPixmap is not available in the Windows port of
4052 libxpm. But XpmReadFileToImage almost does what we want. */
4053 rc = fn_XpmReadFileToImage (&hdc, SDATA (file),
4054 &xpm_image, &xpm_mask,
4055 &attrs);
4056 #else
4057 rc = XpmReadFileToPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
4058 SDATA (file), &img->pixmap, &img->mask,
4059 &attrs);
4060 #endif /* HAVE_NTGUI */
4062 else
4064 Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
4065 #ifdef HAVE_NTGUI
4066 /* XpmCreatePixmapFromBuffer is not available in the Windows port
4067 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
4068 rc = fn_XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
4069 &xpm_image, &xpm_mask,
4070 &attrs);
4071 #else
4072 rc = XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
4073 SDATA (buffer),
4074 &img->pixmap, &img->mask,
4075 &attrs);
4076 #endif /* HAVE_NTGUI */
4079 if (rc == XpmSuccess)
4081 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
4082 img->colors = colors_in_color_table (&img->ncolors);
4083 #else /* not ALLOC_XPM_COLORS */
4084 int i;
4086 #ifdef HAVE_NTGUI
4087 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
4088 plus some duplicate attributes. */
4089 if (xpm_image && xpm_image->bitmap)
4091 img->pixmap = xpm_image->bitmap;
4092 /* XImageFree in libXpm frees XImage struct without destroying
4093 the bitmap, which is what we want. */
4094 fn_XImageFree (xpm_image);
4096 if (xpm_mask && xpm_mask->bitmap)
4098 /* The mask appears to be inverted compared with what we expect.
4099 TODO: invert our expectations. See other places where we
4100 have to invert bits because our idea of masks is backwards. */
4101 HGDIOBJ old_obj;
4102 old_obj = SelectObject (hdc, xpm_mask->bitmap);
4104 PatBlt (hdc, 0, 0, xpm_mask->width, xpm_mask->height, DSTINVERT);
4105 SelectObject (hdc, old_obj);
4107 img->mask = xpm_mask->bitmap;
4108 fn_XImageFree (xpm_mask);
4109 DeleteDC (hdc);
4112 DeleteDC (hdc);
4113 #endif /* HAVE_NTGUI */
4115 /* Remember allocated colors. */
4116 img->ncolors = attrs.nalloc_pixels;
4117 img->colors = (unsigned long *) xmalloc (img->ncolors
4118 * sizeof *img->colors);
4119 for (i = 0; i < attrs.nalloc_pixels; ++i)
4121 img->colors[i] = attrs.alloc_pixels[i];
4122 #ifdef DEBUG_X_COLORS
4123 register_color (img->colors[i]);
4124 #endif
4126 #endif /* not ALLOC_XPM_COLORS */
4128 img->width = attrs.width;
4129 img->height = attrs.height;
4130 xassert (img->width > 0 && img->height > 0);
4132 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
4133 #ifdef HAVE_NTGUI
4134 fn_XpmFreeAttributes (&attrs);
4135 #else
4136 XpmFreeAttributes (&attrs);
4137 #endif /* HAVE_NTGUI */
4139 else
4141 #ifdef HAVE_NTGUI
4142 DeleteDC (hdc);
4143 #endif /* HAVE_NTGUI */
4145 switch (rc)
4147 case XpmOpenFailed:
4148 image_error ("Error opening XPM file (%s)", img->spec, Qnil);
4149 break;
4151 case XpmFileInvalid:
4152 image_error ("Invalid XPM file (%s)", img->spec, Qnil);
4153 break;
4155 case XpmNoMemory:
4156 image_error ("Out of memory (%s)", img->spec, Qnil);
4157 break;
4159 case XpmColorFailed:
4160 image_error ("Color allocation error (%s)", img->spec, Qnil);
4161 break;
4163 default:
4164 image_error ("Unknown error (%s)", img->spec, Qnil);
4165 break;
4169 #ifdef ALLOC_XPM_COLORS
4170 xpm_free_color_cache ();
4171 #endif
4172 return rc == XpmSuccess;
4175 #endif /* HAVE_XPM */
4177 #ifdef MAC_OS
4179 /* XPM support functions for Mac OS where libxpm is not available.
4180 Only XPM version 3 (without any extensions) is supported. */
4182 static int xpm_scan P_ ((const unsigned char **, const unsigned char *,
4183 const unsigned char **, int *));
4184 static Lisp_Object xpm_make_color_table_v
4185 P_ ((void (**) (Lisp_Object, const unsigned char *, int, Lisp_Object),
4186 Lisp_Object (**) (Lisp_Object, const unsigned char *, int)));
4187 static void xpm_put_color_table_v P_ ((Lisp_Object, const unsigned char *,
4188 int, Lisp_Object));
4189 static Lisp_Object xpm_get_color_table_v P_ ((Lisp_Object,
4190 const unsigned char *, int));
4191 static Lisp_Object xpm_make_color_table_h
4192 P_ ((void (**) (Lisp_Object, const unsigned char *, int, Lisp_Object),
4193 Lisp_Object (**) (Lisp_Object, const unsigned char *, int)));
4194 static void xpm_put_color_table_h P_ ((Lisp_Object, const unsigned char *,
4195 int, Lisp_Object));
4196 static Lisp_Object xpm_get_color_table_h P_ ((Lisp_Object,
4197 const unsigned char *, int));
4198 static int xpm_str_to_color_key P_ ((const char *));
4199 static int xpm_load_image P_ ((struct frame *, struct image *,
4200 const unsigned char *, const unsigned char *));
4202 /* Tokens returned from xpm_scan. */
4204 enum xpm_token
4206 XPM_TK_IDENT = 256,
4207 XPM_TK_STRING,
4208 XPM_TK_EOF
4211 /* Scan an XPM data and return a character (< 256) or a token defined
4212 by enum xpm_token above. *S and END are the start (inclusive) and
4213 the end (exclusive) addresses of the data, respectively. Advance
4214 *S while scanning. If token is either XPM_TK_IDENT or
4215 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
4216 length of the corresponding token, respectively. */
4218 static int
4219 xpm_scan (s, end, beg, len)
4220 const unsigned char **s, *end, **beg;
4221 int *len;
4223 int c;
4225 while (*s < end)
4227 /* Skip white-space. */
4228 while (*s < end && (c = *(*s)++, isspace (c)))
4231 /* gnus-pointer.xpm uses '-' in its identifier.
4232 sb-dir-plus.xpm uses '+' in its identifier. */
4233 if (isalpha (c) || c == '_' || c == '-' || c == '+')
4235 *beg = *s - 1;
4236 while (*s < end &&
4237 (c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))
4238 ++*s;
4239 *len = *s - *beg;
4240 return XPM_TK_IDENT;
4242 else if (c == '"')
4244 *beg = *s;
4245 while (*s < end && **s != '"')
4246 ++*s;
4247 *len = *s - *beg;
4248 if (*s < end)
4249 ++*s;
4250 return XPM_TK_STRING;
4252 else if (c == '/')
4254 if (*s < end && **s == '*')
4256 /* C-style comment. */
4257 ++*s;
4260 while (*s < end && *(*s)++ != '*')
4263 while (*s < end && **s != '/');
4264 if (*s < end)
4265 ++*s;
4267 else
4268 return c;
4270 else
4271 return c;
4274 return XPM_TK_EOF;
4277 /* Functions for color table lookup in XPM data. A Key is a string
4278 specifying the color of each pixel in XPM data. A value is either
4279 an integer that specifies a pixel color, Qt that specifies
4280 transparency, or Qnil for the unspecified color. If the length of
4281 the key string is one, a vector is used as a table. Otherwise, a
4282 hash table is used. */
4284 static Lisp_Object
4285 xpm_make_color_table_v (put_func, get_func)
4286 void (**put_func) (Lisp_Object, const unsigned char *, int, Lisp_Object);
4287 Lisp_Object (**get_func) (Lisp_Object, const unsigned char *, int);
4289 *put_func = xpm_put_color_table_v;
4290 *get_func = xpm_get_color_table_v;
4291 return Fmake_vector (make_number (256), Qnil);
4294 static void
4295 xpm_put_color_table_v (color_table, chars_start, chars_len, color)
4296 Lisp_Object color_table;
4297 const unsigned char *chars_start;
4298 int chars_len;
4299 Lisp_Object color;
4301 XVECTOR (color_table)->contents[*chars_start] = color;
4304 static Lisp_Object
4305 xpm_get_color_table_v (color_table, chars_start, chars_len)
4306 Lisp_Object color_table;
4307 const unsigned char *chars_start;
4308 int chars_len;
4310 return XVECTOR (color_table)->contents[*chars_start];
4313 static Lisp_Object
4314 xpm_make_color_table_h (put_func, get_func)
4315 void (**put_func) (Lisp_Object, const unsigned char *, int, Lisp_Object);
4316 Lisp_Object (**get_func) (Lisp_Object, const unsigned char *, int);
4318 *put_func = xpm_put_color_table_h;
4319 *get_func = xpm_get_color_table_h;
4320 return make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
4321 make_float (DEFAULT_REHASH_SIZE),
4322 make_float (DEFAULT_REHASH_THRESHOLD),
4323 Qnil, Qnil, Qnil);
4326 static void
4327 xpm_put_color_table_h (color_table, chars_start, chars_len, color)
4328 Lisp_Object color_table;
4329 const unsigned char *chars_start;
4330 int chars_len;
4331 Lisp_Object color;
4333 struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
4334 unsigned hash_code;
4335 Lisp_Object chars = make_unibyte_string (chars_start, chars_len);
4337 hash_lookup (table, chars, &hash_code);
4338 hash_put (table, chars, color, hash_code);
4341 static Lisp_Object
4342 xpm_get_color_table_h (color_table, chars_start, chars_len)
4343 Lisp_Object color_table;
4344 const unsigned char *chars_start;
4345 int chars_len;
4347 struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
4348 int i = hash_lookup (table, make_unibyte_string (chars_start, chars_len),
4349 NULL);
4351 return i >= 0 ? HASH_VALUE (table, i) : Qnil;
4354 enum xpm_color_key {
4355 XPM_COLOR_KEY_S,
4356 XPM_COLOR_KEY_M,
4357 XPM_COLOR_KEY_G4,
4358 XPM_COLOR_KEY_G,
4359 XPM_COLOR_KEY_C
4362 static const char xpm_color_key_strings[][4] = {"s", "m", "g4", "g", "c"};
4364 static int
4365 xpm_str_to_color_key (s)
4366 const char *s;
4368 int i;
4370 for (i = 0;
4371 i < sizeof xpm_color_key_strings / sizeof xpm_color_key_strings[0];
4372 i++)
4373 if (strcmp (xpm_color_key_strings[i], s) == 0)
4374 return i;
4375 return -1;
4378 static int
4379 xpm_load_image (f, img, contents, end)
4380 struct frame *f;
4381 struct image *img;
4382 const unsigned char *contents, *end;
4384 const unsigned char *s = contents, *beg, *str;
4385 unsigned char buffer[BUFSIZ];
4386 int width, height, x, y;
4387 int num_colors, chars_per_pixel;
4388 int len, LA1;
4389 void (*put_color_table) (Lisp_Object, const unsigned char *, int, Lisp_Object);
4390 Lisp_Object (*get_color_table) (Lisp_Object, const unsigned char *, int);
4391 Lisp_Object frame, color_symbols, color_table;
4392 int best_key, have_mask = 0;
4393 XImagePtr ximg = NULL, mask_img = NULL;
4395 #define match() \
4396 LA1 = xpm_scan (&s, end, &beg, &len)
4398 #define expect(TOKEN) \
4399 if (LA1 != (TOKEN)) \
4400 goto failure; \
4401 else \
4402 match ()
4404 #define expect_ident(IDENT) \
4405 if (LA1 == XPM_TK_IDENT \
4406 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4407 match (); \
4408 else \
4409 goto failure
4411 if (!(end - s >= 9 && memcmp (s, "/* XPM */", 9) == 0))
4412 goto failure;
4413 s += 9;
4414 match();
4415 expect_ident ("static");
4416 expect_ident ("char");
4417 expect ('*');
4418 expect (XPM_TK_IDENT);
4419 expect ('[');
4420 expect (']');
4421 expect ('=');
4422 expect ('{');
4423 expect (XPM_TK_STRING);
4424 if (len >= BUFSIZ)
4425 goto failure;
4426 memcpy (buffer, beg, len);
4427 buffer[len] = '\0';
4428 if (sscanf (buffer, "%d %d %d %d", &width, &height,
4429 &num_colors, &chars_per_pixel) != 4
4430 || width <= 0 || height <= 0
4431 || num_colors <= 0 || chars_per_pixel <= 0)
4432 goto failure;
4434 if (!check_image_size (f, width, height))
4436 image_error ("Invalid image size", Qnil, Qnil);
4437 goto failure;
4440 expect (',');
4442 XSETFRAME (frame, f);
4443 if (!NILP (Fxw_display_color_p (frame)))
4444 best_key = XPM_COLOR_KEY_C;
4445 else if (!NILP (Fx_display_grayscale_p (frame)))
4446 best_key = (XFASTINT (Fx_display_planes (frame)) > 2
4447 ? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
4448 else
4449 best_key = XPM_COLOR_KEY_M;
4451 color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
4452 if (chars_per_pixel == 1)
4453 color_table = xpm_make_color_table_v (&put_color_table,
4454 &get_color_table);
4455 else
4456 color_table = xpm_make_color_table_h (&put_color_table,
4457 &get_color_table);
4459 while (num_colors-- > 0)
4461 unsigned char *color, *max_color;
4462 int key, next_key, max_key = 0;
4463 Lisp_Object symbol_color = Qnil, color_val;
4464 XColor cdef;
4466 expect (XPM_TK_STRING);
4467 if (len <= chars_per_pixel || len >= BUFSIZ + chars_per_pixel)
4468 goto failure;
4469 memcpy (buffer, beg + chars_per_pixel, len - chars_per_pixel);
4470 buffer[len - chars_per_pixel] = '\0';
4472 str = strtok (buffer, " \t");
4473 if (str == NULL)
4474 goto failure;
4475 key = xpm_str_to_color_key (str);
4476 if (key < 0)
4477 goto failure;
4480 color = strtok (NULL, " \t");
4481 if (color == NULL)
4482 goto failure;
4484 while ((str = strtok (NULL, " \t")) != NULL)
4486 next_key = xpm_str_to_color_key (str);
4487 if (next_key >= 0)
4488 break;
4489 color[strlen (color)] = ' ';
4492 if (key == XPM_COLOR_KEY_S)
4494 if (NILP (symbol_color))
4495 symbol_color = build_string (color);
4497 else if (max_key < key && key <= best_key)
4499 max_key = key;
4500 max_color = color;
4502 key = next_key;
4504 while (str);
4506 color_val = Qnil;
4507 if (!NILP (color_symbols) && !NILP (symbol_color))
4509 Lisp_Object specified_color = Fassoc (symbol_color, color_symbols);
4511 if (CONSP (specified_color) && STRINGP (XCDR (specified_color)))
4513 if (xstricmp (SDATA (XCDR (specified_color)), "None") == 0)
4514 color_val = Qt;
4515 else if (x_defined_color (f, SDATA (XCDR (specified_color)),
4516 &cdef, 0))
4517 color_val = make_number (cdef.pixel);
4520 if (NILP (color_val) && max_key > 0)
4522 if (xstricmp (max_color, "None") == 0)
4523 color_val = Qt;
4524 else if (x_defined_color (f, max_color, &cdef, 0))
4525 color_val = make_number (cdef.pixel);
4527 if (!NILP (color_val))
4528 (*put_color_table) (color_table, beg, chars_per_pixel, color_val);
4530 expect (',');
4533 if (!x_create_x_image_and_pixmap (f, width, height, 0,
4534 &ximg, &img->pixmap)
4535 || !x_create_x_image_and_pixmap (f, width, height, 1,
4536 &mask_img, &img->mask))
4538 image_error ("Out of memory (%s)", img->spec, Qnil);
4539 goto error;
4542 for (y = 0; y < height; y++)
4544 expect (XPM_TK_STRING);
4545 str = beg;
4546 if (len < width * chars_per_pixel)
4547 goto failure;
4548 for (x = 0; x < width; x++, str += chars_per_pixel)
4550 Lisp_Object color_val =
4551 (*get_color_table) (color_table, str, chars_per_pixel);
4553 XPutPixel (ximg, x, y,
4554 (INTEGERP (color_val) ? XINT (color_val)
4555 : FRAME_FOREGROUND_PIXEL (f)));
4556 XPutPixel (mask_img, x, y,
4557 (!EQ (color_val, Qt) ? PIX_MASK_DRAW
4558 : (have_mask = 1, PIX_MASK_RETAIN)));
4560 if (y + 1 < height)
4561 expect (',');
4564 img->width = width;
4565 img->height = height;
4567 /* Maybe fill in the background field while we have ximg handy. */
4568 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
4569 IMAGE_BACKGROUND (img, f, ximg);
4571 x_put_x_image (f, ximg, img->pixmap, width, height);
4572 x_destroy_x_image (ximg);
4573 if (have_mask)
4575 /* Fill in the background_transparent field while we have the
4576 mask handy. */
4577 image_background_transparent (img, f, mask_img);
4579 x_put_x_image (f, mask_img, img->mask, width, height);
4580 x_destroy_x_image (mask_img);
4582 else
4584 x_destroy_x_image (mask_img);
4585 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
4586 img->mask = NO_PIXMAP;
4589 return 1;
4591 failure:
4592 image_error ("Invalid XPM file (%s)", img->spec, Qnil);
4593 error:
4594 x_destroy_x_image (ximg);
4595 x_destroy_x_image (mask_img);
4596 x_clear_image (f, img);
4597 return 0;
4599 #undef match
4600 #undef expect
4601 #undef expect_ident
4604 static int
4605 xpm_load (f, img)
4606 struct frame *f;
4607 struct image *img;
4609 int success_p = 0;
4610 Lisp_Object file_name;
4612 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4613 file_name = image_spec_value (img->spec, QCfile, NULL);
4614 if (STRINGP (file_name))
4616 Lisp_Object file;
4617 unsigned char *contents;
4618 int size;
4619 struct gcpro gcpro1;
4621 file = x_find_image_file (file_name);
4622 GCPRO1 (file);
4623 if (!STRINGP (file))
4625 image_error ("Cannot find image file `%s'", file_name, Qnil);
4626 UNGCPRO;
4627 return 0;
4630 contents = slurp_file (SDATA (file), &size);
4631 if (contents == NULL)
4633 image_error ("Error loading XPM image `%s'", img->spec, Qnil);
4634 UNGCPRO;
4635 return 0;
4638 success_p = xpm_load_image (f, img, contents, contents + size);
4639 xfree (contents);
4640 UNGCPRO;
4642 else
4644 Lisp_Object data;
4646 data = image_spec_value (img->spec, QCdata, NULL);
4647 success_p = xpm_load_image (f, img, SDATA (data),
4648 SDATA (data) + SBYTES (data));
4651 return success_p;
4654 #endif /* MAC_OS */
4658 /***********************************************************************
4659 Color table
4660 ***********************************************************************/
4662 #ifdef COLOR_TABLE_SUPPORT
4664 /* An entry in the color table mapping an RGB color to a pixel color. */
4666 struct ct_color
4668 int r, g, b;
4669 unsigned long pixel;
4671 /* Next in color table collision list. */
4672 struct ct_color *next;
4675 /* The bucket vector size to use. Must be prime. */
4677 #define CT_SIZE 101
4679 /* Value is a hash of the RGB color given by R, G, and B. */
4681 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4683 /* The color hash table. */
4685 struct ct_color **ct_table;
4687 /* Number of entries in the color table. */
4689 int ct_colors_allocated;
4691 /* Initialize the color table. */
4693 static void
4694 init_color_table ()
4696 int size = CT_SIZE * sizeof (*ct_table);
4697 ct_table = (struct ct_color **) xmalloc (size);
4698 bzero (ct_table, size);
4699 ct_colors_allocated = 0;
4703 /* Free memory associated with the color table. */
4705 static void
4706 free_color_table ()
4708 int i;
4709 struct ct_color *p, *next;
4711 for (i = 0; i < CT_SIZE; ++i)
4712 for (p = ct_table[i]; p; p = next)
4714 next = p->next;
4715 xfree (p);
4718 xfree (ct_table);
4719 ct_table = NULL;
4723 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4724 entry for that color already is in the color table, return the
4725 pixel color of that entry. Otherwise, allocate a new color for R,
4726 G, B, and make an entry in the color table. */
4728 static unsigned long
4729 lookup_rgb_color (f, r, g, b)
4730 struct frame *f;
4731 int r, g, b;
4733 unsigned hash = CT_HASH_RGB (r, g, b);
4734 int i = hash % CT_SIZE;
4735 struct ct_color *p;
4736 Display_Info *dpyinfo;
4738 /* Handle TrueColor visuals specially, which improves performance by
4739 two orders of magnitude. Freeing colors on TrueColor visuals is
4740 a nop, and pixel colors specify RGB values directly. See also
4741 the Xlib spec, chapter 3.1. */
4742 dpyinfo = FRAME_X_DISPLAY_INFO (f);
4743 if (dpyinfo->red_bits > 0)
4745 unsigned long pr, pg, pb;
4747 /* Apply gamma-correction like normal color allocation does. */
4748 if (f->gamma)
4750 XColor color;
4751 color.red = r, color.green = g, color.blue = b;
4752 gamma_correct (f, &color);
4753 r = color.red, g = color.green, b = color.blue;
4756 /* Scale down RGB values to the visual's bits per RGB, and shift
4757 them to the right position in the pixel color. Note that the
4758 original RGB values are 16-bit values, as usual in X. */
4759 pr = (r >> (16 - dpyinfo->red_bits)) << dpyinfo->red_offset;
4760 pg = (g >> (16 - dpyinfo->green_bits)) << dpyinfo->green_offset;
4761 pb = (b >> (16 - dpyinfo->blue_bits)) << dpyinfo->blue_offset;
4763 /* Assemble the pixel color. */
4764 return pr | pg | pb;
4767 for (p = ct_table[i]; p; p = p->next)
4768 if (p->r == r && p->g == g && p->b == b)
4769 break;
4771 if (p == NULL)
4774 #ifdef HAVE_X_WINDOWS
4775 XColor color;
4776 Colormap cmap;
4777 int rc;
4779 color.red = r;
4780 color.green = g;
4781 color.blue = b;
4783 cmap = FRAME_X_COLORMAP (f);
4784 rc = x_alloc_nearest_color (f, cmap, &color);
4785 if (rc)
4787 ++ct_colors_allocated;
4788 p = (struct ct_color *) xmalloc (sizeof *p);
4789 p->r = r;
4790 p->g = g;
4791 p->b = b;
4792 p->pixel = color.pixel;
4793 p->next = ct_table[i];
4794 ct_table[i] = p;
4796 else
4797 return FRAME_FOREGROUND_PIXEL (f);
4799 #else
4800 COLORREF color;
4801 #ifdef HAVE_NTGUI
4802 color = PALETTERGB (r, g, b);
4803 #else
4804 color = RGB_TO_ULONG (r, g, b);
4805 #endif /* HAVE_NTGUI */
4806 ++ct_colors_allocated;
4807 p = (struct ct_color *) xmalloc (sizeof *p);
4808 p->r = r;
4809 p->g = g;
4810 p->b = b;
4811 p->pixel = color;
4812 p->next = ct_table[i];
4813 ct_table[i] = p;
4814 #endif /* HAVE_X_WINDOWS */
4818 return p->pixel;
4822 /* Look up pixel color PIXEL which is used on frame F in the color
4823 table. If not already present, allocate it. Value is PIXEL. */
4825 static unsigned long
4826 lookup_pixel_color (f, pixel)
4827 struct frame *f;
4828 unsigned long pixel;
4830 int i = pixel % CT_SIZE;
4831 struct ct_color *p;
4833 for (p = ct_table[i]; p; p = p->next)
4834 if (p->pixel == pixel)
4835 break;
4837 if (p == NULL)
4839 XColor color;
4840 Colormap cmap;
4841 int rc;
4843 #ifdef HAVE_X_WINDOWS
4844 cmap = FRAME_X_COLORMAP (f);
4845 color.pixel = pixel;
4846 x_query_color (f, &color);
4847 rc = x_alloc_nearest_color (f, cmap, &color);
4848 #else
4849 BLOCK_INPUT;
4850 cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
4851 color.pixel = pixel;
4852 XQueryColor (NULL, cmap, &color);
4853 rc = x_alloc_nearest_color (f, cmap, &color);
4854 UNBLOCK_INPUT;
4855 #endif /* HAVE_X_WINDOWS */
4857 if (rc)
4859 ++ct_colors_allocated;
4861 p = (struct ct_color *) xmalloc (sizeof *p);
4862 p->r = color.red;
4863 p->g = color.green;
4864 p->b = color.blue;
4865 p->pixel = pixel;
4866 p->next = ct_table[i];
4867 ct_table[i] = p;
4869 else
4870 return FRAME_FOREGROUND_PIXEL (f);
4872 return p->pixel;
4876 /* Value is a vector of all pixel colors contained in the color table,
4877 allocated via xmalloc. Set *N to the number of colors. */
4879 static unsigned long *
4880 colors_in_color_table (n)
4881 int *n;
4883 int i, j;
4884 struct ct_color *p;
4885 unsigned long *colors;
4887 if (ct_colors_allocated == 0)
4889 *n = 0;
4890 colors = NULL;
4892 else
4894 colors = (unsigned long *) xmalloc (ct_colors_allocated
4895 * sizeof *colors);
4896 *n = ct_colors_allocated;
4898 for (i = j = 0; i < CT_SIZE; ++i)
4899 for (p = ct_table[i]; p; p = p->next)
4900 colors[j++] = p->pixel;
4903 return colors;
4906 #else /* COLOR_TABLE_SUPPORT */
4908 static unsigned long
4909 lookup_rgb_color (f, r, g, b)
4910 struct frame *f;
4911 int r, g, b;
4913 unsigned long pixel;
4915 #ifdef MAC_OS
4916 pixel = RGB_TO_ULONG (r >> 8, g >> 8, b >> 8);
4917 gamma_correct (f, &pixel);
4918 #endif /* MAC_OS */
4920 #ifdef HAVE_NTGUI
4921 pixel = PALETTERGB (r >> 8, g >> 8, b >> 8);
4922 #endif /* HAVE_NTGUI */
4924 return pixel;
4927 static void
4928 init_color_table ()
4931 #endif /* COLOR_TABLE_SUPPORT */
4934 /***********************************************************************
4935 Algorithms
4936 ***********************************************************************/
4938 static XColor *x_to_xcolors P_ ((struct frame *, struct image *, int));
4939 static void x_from_xcolors P_ ((struct frame *, struct image *, XColor *));
4940 static void x_detect_edges P_ ((struct frame *, struct image *, int[9], int));
4942 #ifdef HAVE_NTGUI
4943 static void XPutPixel (XImagePtr , int, int, COLORREF);
4944 #endif /* HAVE_NTGUI */
4946 /* Non-zero means draw a cross on images having `:conversion
4947 disabled'. */
4949 int cross_disabled_images;
4951 /* Edge detection matrices for different edge-detection
4952 strategies. */
4954 static int emboss_matrix[9] = {
4955 /* x - 1 x x + 1 */
4956 2, -1, 0, /* y - 1 */
4957 -1, 0, 1, /* y */
4958 0, 1, -2 /* y + 1 */
4961 static int laplace_matrix[9] = {
4962 /* x - 1 x x + 1 */
4963 1, 0, 0, /* y - 1 */
4964 0, 0, 0, /* y */
4965 0, 0, -1 /* y + 1 */
4968 /* Value is the intensity of the color whose red/green/blue values
4969 are R, G, and B. */
4971 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4974 /* On frame F, return an array of XColor structures describing image
4975 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4976 non-zero means also fill the red/green/blue members of the XColor
4977 structures. Value is a pointer to the array of XColors structures,
4978 allocated with xmalloc; it must be freed by the caller. */
4980 static XColor *
4981 x_to_xcolors (f, img, rgb_p)
4982 struct frame *f;
4983 struct image *img;
4984 int rgb_p;
4986 int x, y;
4987 XColor *colors, *p;
4988 XImagePtr_or_DC ximg;
4989 #ifdef HAVE_NTGUI
4990 HDC hdc;
4991 HGDIOBJ prev;
4992 #endif /* HAVE_NTGUI */
4994 colors = (XColor *) xmalloc (img->width * img->height * sizeof *colors);
4996 #ifndef HAVE_NTGUI
4997 /* Get the X image IMG->pixmap. */
4998 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
4999 0, 0, img->width, img->height, ~0, ZPixmap);
5000 #else
5001 /* Load the image into a memory device context. */
5002 hdc = get_frame_dc (f);
5003 ximg = CreateCompatibleDC (hdc);
5004 release_frame_dc (f, hdc);
5005 prev = SelectObject (ximg, img->pixmap);
5006 #endif /* HAVE_NTGUI */
5008 /* Fill the `pixel' members of the XColor array. I wished there
5009 were an easy and portable way to circumvent XGetPixel. */
5010 p = colors;
5011 for (y = 0; y < img->height; ++y)
5013 XColor *row = p;
5015 #ifdef HAVE_X_WINDOWS
5016 for (x = 0; x < img->width; ++x, ++p)
5017 p->pixel = XGetPixel (ximg, x, y);
5018 if (rgb_p)
5019 x_query_colors (f, row, img->width);
5021 #else
5023 for (x = 0; x < img->width; ++x, ++p)
5025 /* W32_TODO: palette support needed here? */
5026 p->pixel = GET_PIXEL (ximg, x, y);
5027 if (rgb_p)
5029 #ifdef MAC_OS
5030 p->red = RED16_FROM_ULONG (p->pixel);
5031 p->green = GREEN16_FROM_ULONG (p->pixel);
5032 p->blue = BLUE16_FROM_ULONG (p->pixel);
5033 #endif /* MAC_OS */
5034 #ifdef HAVE_NTGUI
5035 p->red = 256 * GetRValue (p->pixel);
5036 p->green = 256 * GetGValue (p->pixel);
5037 p->blue = 256 * GetBValue (p->pixel);
5038 #endif /* HAVE_NTGUI */
5041 #endif /* HAVE_X_WINDOWS */
5044 Destroy_Image (ximg, prev);
5046 return colors;
5049 #ifdef HAVE_NTGUI
5051 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
5052 created with CreateDIBSection, with the pointer to the bit values
5053 stored in ximg->data. */
5055 static void XPutPixel (ximg, x, y, color)
5056 XImagePtr ximg;
5057 int x, y;
5058 COLORREF color;
5060 int width = ximg->info.bmiHeader.biWidth;
5061 int height = ximg->info.bmiHeader.biHeight;
5062 unsigned char * pixel;
5064 /* True color images. */
5065 if (ximg->info.bmiHeader.biBitCount == 24)
5067 int rowbytes = width * 3;
5068 /* Ensure scanlines are aligned on 4 byte boundaries. */
5069 if (rowbytes % 4)
5070 rowbytes += 4 - (rowbytes % 4);
5072 pixel = ximg->data + y * rowbytes + x * 3;
5073 /* Windows bitmaps are in BGR order. */
5074 *pixel = GetBValue (color);
5075 *(pixel + 1) = GetGValue (color);
5076 *(pixel + 2) = GetRValue (color);
5078 /* Monochrome images. */
5079 else if (ximg->info.bmiHeader.biBitCount == 1)
5081 int rowbytes = width / 8;
5082 /* Ensure scanlines are aligned on 4 byte boundaries. */
5083 if (rowbytes % 4)
5084 rowbytes += 4 - (rowbytes % 4);
5085 pixel = ximg->data + y * rowbytes + x / 8;
5086 /* Filter out palette info. */
5087 if (color & 0x00ffffff)
5088 *pixel = *pixel | (1 << x % 8);
5089 else
5090 *pixel = *pixel & ~(1 << x % 8);
5092 else
5093 image_error ("XPutPixel: palette image not supported", Qnil, Qnil);
5096 #endif /* HAVE_NTGUI */
5098 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
5099 RGB members are set. F is the frame on which this all happens.
5100 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
5102 static void
5103 x_from_xcolors (f, img, colors)
5104 struct frame *f;
5105 struct image *img;
5106 XColor *colors;
5108 int x, y;
5109 XImagePtr oimg;
5110 Pixmap pixmap;
5111 XColor *p;
5113 init_color_table ();
5115 x_create_x_image_and_pixmap (f, img->width, img->height, 0,
5116 &oimg, &pixmap);
5117 p = colors;
5118 for (y = 0; y < img->height; ++y)
5119 for (x = 0; x < img->width; ++x, ++p)
5121 unsigned long pixel;
5122 pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
5123 XPutPixel (oimg, x, y, pixel);
5126 xfree (colors);
5127 x_clear_image_1 (f, img, 1, 0, 1);
5129 x_put_x_image (f, oimg, pixmap, img->width, img->height);
5130 x_destroy_x_image (oimg);
5131 img->pixmap = pixmap;
5132 #ifdef COLOR_TABLE_SUPPORT
5133 img->colors = colors_in_color_table (&img->ncolors);
5134 free_color_table ();
5135 #endif /* COLOR_TABLE_SUPPORT */
5139 /* On frame F, perform edge-detection on image IMG.
5141 MATRIX is a nine-element array specifying the transformation
5142 matrix. See emboss_matrix for an example.
5144 COLOR_ADJUST is a color adjustment added to each pixel of the
5145 outgoing image. */
5147 static void
5148 x_detect_edges (f, img, matrix, color_adjust)
5149 struct frame *f;
5150 struct image *img;
5151 int matrix[9], color_adjust;
5153 XColor *colors = x_to_xcolors (f, img, 1);
5154 XColor *new, *p;
5155 int x, y, i, sum;
5157 for (i = sum = 0; i < 9; ++i)
5158 sum += abs (matrix[i]);
5160 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
5162 new = (XColor *) xmalloc (img->width * img->height * sizeof *new);
5164 for (y = 0; y < img->height; ++y)
5166 p = COLOR (new, 0, y);
5167 p->red = p->green = p->blue = 0xffff/2;
5168 p = COLOR (new, img->width - 1, y);
5169 p->red = p->green = p->blue = 0xffff/2;
5172 for (x = 1; x < img->width - 1; ++x)
5174 p = COLOR (new, x, 0);
5175 p->red = p->green = p->blue = 0xffff/2;
5176 p = COLOR (new, x, img->height - 1);
5177 p->red = p->green = p->blue = 0xffff/2;
5180 for (y = 1; y < img->height - 1; ++y)
5182 p = COLOR (new, 1, y);
5184 for (x = 1; x < img->width - 1; ++x, ++p)
5186 int r, g, b, y1, x1;
5188 r = g = b = i = 0;
5189 for (y1 = y - 1; y1 < y + 2; ++y1)
5190 for (x1 = x - 1; x1 < x + 2; ++x1, ++i)
5191 if (matrix[i])
5193 XColor *t = COLOR (colors, x1, y1);
5194 r += matrix[i] * t->red;
5195 g += matrix[i] * t->green;
5196 b += matrix[i] * t->blue;
5199 r = (r / sum + color_adjust) & 0xffff;
5200 g = (g / sum + color_adjust) & 0xffff;
5201 b = (b / sum + color_adjust) & 0xffff;
5202 p->red = p->green = p->blue = COLOR_INTENSITY (r, g, b);
5206 xfree (colors);
5207 x_from_xcolors (f, img, new);
5209 #undef COLOR
5213 /* Perform the pre-defined `emboss' edge-detection on image IMG
5214 on frame F. */
5216 static void
5217 x_emboss (f, img)
5218 struct frame *f;
5219 struct image *img;
5221 x_detect_edges (f, img, emboss_matrix, 0xffff / 2);
5225 /* Transform image IMG which is used on frame F with a Laplace
5226 edge-detection algorithm. The result is an image that can be used
5227 to draw disabled buttons, for example. */
5229 static void
5230 x_laplace (f, img)
5231 struct frame *f;
5232 struct image *img;
5234 x_detect_edges (f, img, laplace_matrix, 45000);
5238 /* Perform edge-detection on image IMG on frame F, with specified
5239 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
5241 MATRIX must be either
5243 - a list of at least 9 numbers in row-major form
5244 - a vector of at least 9 numbers
5246 COLOR_ADJUST nil means use a default; otherwise it must be a
5247 number. */
5249 static void
5250 x_edge_detection (f, img, matrix, color_adjust)
5251 struct frame *f;
5252 struct image *img;
5253 Lisp_Object matrix, color_adjust;
5255 int i = 0;
5256 int trans[9];
5258 if (CONSP (matrix))
5260 for (i = 0;
5261 i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
5262 ++i, matrix = XCDR (matrix))
5263 trans[i] = XFLOATINT (XCAR (matrix));
5265 else if (VECTORP (matrix) && ASIZE (matrix) >= 9)
5267 for (i = 0; i < 9 && NUMBERP (AREF (matrix, i)); ++i)
5268 trans[i] = XFLOATINT (AREF (matrix, i));
5271 if (NILP (color_adjust))
5272 color_adjust = make_number (0xffff / 2);
5274 if (i == 9 && NUMBERP (color_adjust))
5275 x_detect_edges (f, img, trans, (int) XFLOATINT (color_adjust));
5279 /* Transform image IMG on frame F so that it looks disabled. */
5281 static void
5282 x_disable_image (f, img)
5283 struct frame *f;
5284 struct image *img;
5286 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
5287 #ifdef HAVE_NTGUI
5288 int n_planes = dpyinfo->n_planes * dpyinfo->n_cbits;
5289 #else
5290 int n_planes = dpyinfo->n_planes;
5291 #endif /* HAVE_NTGUI */
5293 if (n_planes >= 2)
5295 /* Color (or grayscale). Convert to gray, and equalize. Just
5296 drawing such images with a stipple can look very odd, so
5297 we're using this method instead. */
5298 XColor *colors = x_to_xcolors (f, img, 1);
5299 XColor *p, *end;
5300 const int h = 15000;
5301 const int l = 30000;
5303 for (p = colors, end = colors + img->width * img->height;
5304 p < end;
5305 ++p)
5307 int i = COLOR_INTENSITY (p->red, p->green, p->blue);
5308 int i2 = (0xffff - h - l) * i / 0xffff + l;
5309 p->red = p->green = p->blue = i2;
5312 x_from_xcolors (f, img, colors);
5315 /* Draw a cross over the disabled image, if we must or if we
5316 should. */
5317 if (n_planes < 2 || cross_disabled_images)
5319 #ifndef HAVE_NTGUI
5320 Display *dpy = FRAME_X_DISPLAY (f);
5321 GC gc;
5323 #ifdef MAC_OS
5324 #define MaskForeground(f) PIX_MASK_DRAW
5325 #else
5326 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
5327 #endif
5329 gc = XCreateGC (dpy, img->pixmap, 0, NULL);
5330 XSetForeground (dpy, gc, BLACK_PIX_DEFAULT (f));
5331 XDrawLine (dpy, img->pixmap, gc, 0, 0,
5332 img->width - 1, img->height - 1);
5333 XDrawLine (dpy, img->pixmap, gc, 0, img->height - 1,
5334 img->width - 1, 0);
5335 XFreeGC (dpy, gc);
5337 if (img->mask)
5339 gc = XCreateGC (dpy, img->mask, 0, NULL);
5340 XSetForeground (dpy, gc, MaskForeground (f));
5341 XDrawLine (dpy, img->mask, gc, 0, 0,
5342 img->width - 1, img->height - 1);
5343 XDrawLine (dpy, img->mask, gc, 0, img->height - 1,
5344 img->width - 1, 0);
5345 XFreeGC (dpy, gc);
5347 #else
5348 HDC hdc, bmpdc;
5349 HGDIOBJ prev;
5351 hdc = get_frame_dc (f);
5352 bmpdc = CreateCompatibleDC (hdc);
5353 release_frame_dc (f, hdc);
5355 prev = SelectObject (bmpdc, img->pixmap);
5357 SetTextColor (bmpdc, BLACK_PIX_DEFAULT (f));
5358 MoveToEx (bmpdc, 0, 0, NULL);
5359 LineTo (bmpdc, img->width - 1, img->height - 1);
5360 MoveToEx (bmpdc, 0, img->height - 1, NULL);
5361 LineTo (bmpdc, img->width - 1, 0);
5363 if (img->mask)
5365 SelectObject (bmpdc, img->mask);
5366 SetTextColor (bmpdc, WHITE_PIX_DEFAULT (f));
5367 MoveToEx (bmpdc, 0, 0, NULL);
5368 LineTo (bmpdc, img->width - 1, img->height - 1);
5369 MoveToEx (bmpdc, 0, img->height - 1, NULL);
5370 LineTo (bmpdc, img->width - 1, 0);
5372 SelectObject (bmpdc, prev);
5373 DeleteDC (bmpdc);
5374 #endif /* HAVE_NTGUI */
5379 /* Build a mask for image IMG which is used on frame F. FILE is the
5380 name of an image file, for error messages. HOW determines how to
5381 determine the background color of IMG. If it is a list '(R G B)',
5382 with R, G, and B being integers >= 0, take that as the color of the
5383 background. Otherwise, determine the background color of IMG
5384 heuristically. Value is non-zero if successful. */
5386 static int
5387 x_build_heuristic_mask (f, img, how)
5388 struct frame *f;
5389 struct image *img;
5390 Lisp_Object how;
5392 XImagePtr_or_DC ximg;
5393 #ifndef HAVE_NTGUI
5394 XImagePtr mask_img;
5395 #else
5396 HDC frame_dc;
5397 HGDIOBJ prev;
5398 char *mask_img;
5399 int row_width;
5400 #endif /* HAVE_NTGUI */
5401 int x, y, rc, use_img_background;
5402 unsigned long bg = 0;
5404 if (img->mask)
5406 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
5407 img->mask = NO_PIXMAP;
5408 img->background_transparent_valid = 0;
5411 #ifndef HAVE_NTGUI
5412 /* Create an image and pixmap serving as mask. */
5413 rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
5414 &mask_img, &img->mask);
5415 if (!rc)
5416 return 0;
5418 /* Get the X image of IMG->pixmap. */
5419 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap, 0, 0,
5420 img->width, img->height,
5421 ~0, ZPixmap);
5422 #else
5423 /* Create the bit array serving as mask. */
5424 row_width = (img->width + 7) / 8;
5425 mask_img = xmalloc (row_width * img->height);
5426 bzero (mask_img, row_width * img->height);
5428 /* Create a memory device context for IMG->pixmap. */
5429 frame_dc = get_frame_dc (f);
5430 ximg = CreateCompatibleDC (frame_dc);
5431 release_frame_dc (f, frame_dc);
5432 prev = SelectObject (ximg, img->pixmap);
5433 #endif /* HAVE_NTGUI */
5435 /* Determine the background color of ximg. If HOW is `(R G B)'
5436 take that as color. Otherwise, use the image's background color. */
5437 use_img_background = 1;
5439 if (CONSP (how))
5441 int rgb[3], i;
5443 for (i = 0; i < 3 && CONSP (how) && NATNUMP (XCAR (how)); ++i)
5445 rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
5446 how = XCDR (how);
5449 if (i == 3 && NILP (how))
5451 char color_name[30];
5452 sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
5453 bg = (
5454 #ifdef HAVE_NTGUI
5455 0x00ffffff & /* Filter out palette info. */
5456 #endif /* HAVE_NTGUI */
5457 x_alloc_image_color (f, img, build_string (color_name), 0));
5458 use_img_background = 0;
5462 if (use_img_background)
5463 bg = four_corners_best (ximg, img->corners, img->width, img->height);
5465 /* Set all bits in mask_img to 1 whose color in ximg is different
5466 from the background color bg. */
5467 #ifndef HAVE_NTGUI
5468 for (y = 0; y < img->height; ++y)
5469 for (x = 0; x < img->width; ++x)
5470 XPutPixel (mask_img, x, y, (XGetPixel (ximg, x, y) != bg
5471 ? PIX_MASK_DRAW : PIX_MASK_RETAIN));
5473 /* Fill in the background_transparent field while we have the mask handy. */
5474 image_background_transparent (img, f, mask_img);
5476 /* Put mask_img into img->mask. */
5477 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
5478 x_destroy_x_image (mask_img);
5480 #else
5481 for (y = 0; y < img->height; ++y)
5482 for (x = 0; x < img->width; ++x)
5484 COLORREF p = GetPixel (ximg, x, y);
5485 if (p != bg)
5486 mask_img[y * row_width + x / 8] |= 1 << (x % 8);
5489 /* Create the mask image. */
5490 img->mask = w32_create_pixmap_from_bitmap_data (img->width, img->height,
5491 mask_img);
5492 /* Fill in the background_transparent field while we have the mask handy. */
5493 SelectObject (ximg, img->mask);
5494 image_background_transparent (img, f, ximg);
5496 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5497 xfree (mask_img);
5498 #endif /* HAVE_NTGUI */
5500 Destroy_Image (ximg, prev);
5502 return 1;
5506 /***********************************************************************
5507 PBM (mono, gray, color)
5508 ***********************************************************************/
5510 static int pbm_image_p P_ ((Lisp_Object object));
5511 static int pbm_load P_ ((struct frame *f, struct image *img));
5512 static int pbm_scan_number P_ ((unsigned char **, unsigned char *));
5514 /* The symbol `pbm' identifying images of this type. */
5516 Lisp_Object Qpbm;
5518 /* Indices of image specification fields in gs_format, below. */
5520 enum pbm_keyword_index
5522 PBM_TYPE,
5523 PBM_FILE,
5524 PBM_DATA,
5525 PBM_ASCENT,
5526 PBM_MARGIN,
5527 PBM_RELIEF,
5528 PBM_ALGORITHM,
5529 PBM_HEURISTIC_MASK,
5530 PBM_MASK,
5531 PBM_FOREGROUND,
5532 PBM_BACKGROUND,
5533 PBM_LAST
5536 /* Vector of image_keyword structures describing the format
5537 of valid user-defined image specifications. */
5539 static struct image_keyword pbm_format[PBM_LAST] =
5541 {":type", IMAGE_SYMBOL_VALUE, 1},
5542 {":file", IMAGE_STRING_VALUE, 0},
5543 {":data", IMAGE_STRING_VALUE, 0},
5544 {":ascent", IMAGE_ASCENT_VALUE, 0},
5545 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
5546 {":relief", IMAGE_INTEGER_VALUE, 0},
5547 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5548 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5549 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5550 {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
5551 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
5554 /* Structure describing the image type `pbm'. */
5556 static struct image_type pbm_type =
5558 &Qpbm,
5559 pbm_image_p,
5560 pbm_load,
5561 x_clear_image,
5562 NULL
5566 /* Return non-zero if OBJECT is a valid PBM image specification. */
5568 static int
5569 pbm_image_p (object)
5570 Lisp_Object object;
5572 struct image_keyword fmt[PBM_LAST];
5574 bcopy (pbm_format, fmt, sizeof fmt);
5576 if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm))
5577 return 0;
5579 /* Must specify either :data or :file. */
5580 return fmt[PBM_DATA].count + fmt[PBM_FILE].count == 1;
5584 /* Scan a decimal number from *S and return it. Advance *S while
5585 reading the number. END is the end of the string. Value is -1 at
5586 end of input. */
5588 static int
5589 pbm_scan_number (s, end)
5590 unsigned char **s, *end;
5592 int c = 0, val = -1;
5594 while (*s < end)
5596 /* Skip white-space. */
5597 while (*s < end && (c = *(*s)++, isspace (c)))
5600 if (c == '#')
5602 /* Skip comment to end of line. */
5603 while (*s < end && (c = *(*s)++, c != '\n'))
5606 else if (isdigit (c))
5608 /* Read decimal number. */
5609 val = c - '0';
5610 while (*s < end && (c = *(*s)++, isdigit (c)))
5611 val = 10 * val + c - '0';
5612 break;
5614 else
5615 break;
5618 return val;
5622 #ifdef HAVE_NTGUI
5623 #if 0 /* Unused. ++kfs */
5625 /* Read FILE into memory. Value is a pointer to a buffer allocated
5626 with xmalloc holding FILE's contents. Value is null if an error
5627 occurred. *SIZE is set to the size of the file. */
5629 static char *
5630 pbm_read_file (file, size)
5631 Lisp_Object file;
5632 int *size;
5634 FILE *fp = NULL;
5635 char *buf = NULL;
5636 struct stat st;
5638 if (stat (SDATA (file), &st) == 0
5639 && (fp = fopen (SDATA (file), "rb")) != NULL
5640 && (buf = (char *) xmalloc (st.st_size),
5641 fread (buf, 1, st.st_size, fp) == st.st_size))
5643 *size = st.st_size;
5644 fclose (fp);
5646 else
5648 if (fp)
5649 fclose (fp);
5650 if (buf)
5652 xfree (buf);
5653 buf = NULL;
5657 return buf;
5659 #endif
5660 #endif /* HAVE_NTGUI */
5662 /* Load PBM image IMG for use on frame F. */
5664 static int
5665 pbm_load (f, img)
5666 struct frame *f;
5667 struct image *img;
5669 int raw_p, x, y;
5670 int width, height, max_color_idx = 0;
5671 XImagePtr ximg;
5672 Lisp_Object file, specified_file;
5673 enum {PBM_MONO, PBM_GRAY, PBM_COLOR} type;
5674 struct gcpro gcpro1;
5675 unsigned char *contents = NULL;
5676 unsigned char *end, *p;
5677 int size;
5679 specified_file = image_spec_value (img->spec, QCfile, NULL);
5680 file = Qnil;
5681 GCPRO1 (file);
5683 if (STRINGP (specified_file))
5685 file = x_find_image_file (specified_file);
5686 if (!STRINGP (file))
5688 image_error ("Cannot find image file `%s'", specified_file, Qnil);
5689 UNGCPRO;
5690 return 0;
5693 contents = slurp_file (SDATA (file), &size);
5694 if (contents == NULL)
5696 image_error ("Error reading `%s'", file, Qnil);
5697 UNGCPRO;
5698 return 0;
5701 p = contents;
5702 end = contents + size;
5704 else
5706 Lisp_Object data;
5707 data = image_spec_value (img->spec, QCdata, NULL);
5708 p = SDATA (data);
5709 end = p + SBYTES (data);
5712 /* Check magic number. */
5713 if (end - p < 2 || *p++ != 'P')
5715 image_error ("Not a PBM image: `%s'", img->spec, Qnil);
5716 error:
5717 xfree (contents);
5718 UNGCPRO;
5719 return 0;
5722 switch (*p++)
5724 case '1':
5725 raw_p = 0, type = PBM_MONO;
5726 break;
5728 case '2':
5729 raw_p = 0, type = PBM_GRAY;
5730 break;
5732 case '3':
5733 raw_p = 0, type = PBM_COLOR;
5734 break;
5736 case '4':
5737 raw_p = 1, type = PBM_MONO;
5738 break;
5740 case '5':
5741 raw_p = 1, type = PBM_GRAY;
5742 break;
5744 case '6':
5745 raw_p = 1, type = PBM_COLOR;
5746 break;
5748 default:
5749 image_error ("Not a PBM image: `%s'", img->spec, Qnil);
5750 goto error;
5753 /* Read width, height, maximum color-component. Characters
5754 starting with `#' up to the end of a line are ignored. */
5755 width = pbm_scan_number (&p, end);
5756 height = pbm_scan_number (&p, end);
5758 if (type != PBM_MONO)
5760 max_color_idx = pbm_scan_number (&p, end);
5761 if (raw_p && max_color_idx > 255)
5762 max_color_idx = 255;
5765 if (!check_image_size (f, width, height)
5766 || (type != PBM_MONO && max_color_idx < 0))
5767 goto error;
5769 if (!x_create_x_image_and_pixmap (f, width, height, 0,
5770 &ximg, &img->pixmap))
5771 goto error;
5773 /* Initialize the color hash table. */
5774 init_color_table ();
5776 if (type == PBM_MONO)
5778 int c = 0, g;
5779 struct image_keyword fmt[PBM_LAST];
5780 unsigned long fg = FRAME_FOREGROUND_PIXEL (f);
5781 unsigned long bg = FRAME_BACKGROUND_PIXEL (f);
5783 /* Parse the image specification. */
5784 bcopy (pbm_format, fmt, sizeof fmt);
5785 parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
5787 /* Get foreground and background colors, maybe allocate colors. */
5788 if (fmt[PBM_FOREGROUND].count
5789 && STRINGP (fmt[PBM_FOREGROUND].value))
5790 fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
5791 if (fmt[PBM_BACKGROUND].count
5792 && STRINGP (fmt[PBM_BACKGROUND].value))
5794 bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
5795 img->background = bg;
5796 img->background_valid = 1;
5799 for (y = 0; y < height; ++y)
5800 for (x = 0; x < width; ++x)
5802 if (raw_p)
5804 if ((x & 7) == 0)
5806 if (p >= end)
5808 x_destroy_x_image (ximg);
5809 x_clear_image (f, img);
5810 image_error ("Invalid image size in image `%s'",
5811 img->spec, Qnil);
5812 goto error;
5814 c = *p++;
5816 g = c & 0x80;
5817 c <<= 1;
5819 else
5820 g = pbm_scan_number (&p, end);
5822 XPutPixel (ximg, x, y, g ? fg : bg);
5825 else
5827 if (raw_p
5828 && ((type == PBM_GRAY)
5829 ? (p + height * width > end)
5830 : (p + 3 * height * width > end)))
5832 x_destroy_x_image (ximg);
5833 x_clear_image (f, img);
5834 image_error ("Invalid image size in image `%s'",
5835 img->spec, Qnil);
5836 goto error;
5839 for (y = 0; y < height; ++y)
5840 for (x = 0; x < width; ++x)
5842 int r, g, b;
5844 if (type == PBM_GRAY)
5845 r = g = b = raw_p ? *p++ : pbm_scan_number (&p, end);
5846 else if (raw_p)
5848 r = *p++;
5849 g = *p++;
5850 b = *p++;
5852 else
5854 r = pbm_scan_number (&p, end);
5855 g = pbm_scan_number (&p, end);
5856 b = pbm_scan_number (&p, end);
5859 if (r < 0 || g < 0 || b < 0)
5861 x_destroy_x_image (ximg);
5862 image_error ("Invalid pixel value in image `%s'",
5863 img->spec, Qnil);
5864 goto error;
5867 /* RGB values are now in the range 0..max_color_idx.
5868 Scale this to the range 0..0xffff supported by X. */
5869 r = (double) r * 65535 / max_color_idx;
5870 g = (double) g * 65535 / max_color_idx;
5871 b = (double) b * 65535 / max_color_idx;
5872 XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
5876 #ifdef COLOR_TABLE_SUPPORT
5877 /* Store in IMG->colors the colors allocated for the image, and
5878 free the color table. */
5879 img->colors = colors_in_color_table (&img->ncolors);
5880 free_color_table ();
5881 #endif /* COLOR_TABLE_SUPPORT */
5883 img->width = width;
5884 img->height = height;
5886 /* Maybe fill in the background field while we have ximg handy. */
5888 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
5889 /* Casting avoids a GCC warning. */
5890 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
5892 /* Put the image into a pixmap. */
5893 x_put_x_image (f, ximg, img->pixmap, width, height);
5894 x_destroy_x_image (ximg);
5896 /* X and W32 versions did it here, MAC version above. ++kfs
5897 img->width = width;
5898 img->height = height; */
5900 UNGCPRO;
5901 xfree (contents);
5902 return 1;
5906 /***********************************************************************
5908 ***********************************************************************/
5910 #if defined (HAVE_PNG) || defined (MAC_OS)
5912 /* Function prototypes. */
5914 static int png_image_p P_ ((Lisp_Object object));
5915 static int png_load P_ ((struct frame *f, struct image *img));
5917 /* The symbol `png' identifying images of this type. */
5919 Lisp_Object Qpng;
5921 /* Indices of image specification fields in png_format, below. */
5923 enum png_keyword_index
5925 PNG_TYPE,
5926 PNG_DATA,
5927 PNG_FILE,
5928 PNG_ASCENT,
5929 PNG_MARGIN,
5930 PNG_RELIEF,
5931 PNG_ALGORITHM,
5932 PNG_HEURISTIC_MASK,
5933 PNG_MASK,
5934 PNG_BACKGROUND,
5935 PNG_LAST
5938 /* Vector of image_keyword structures describing the format
5939 of valid user-defined image specifications. */
5941 static struct image_keyword png_format[PNG_LAST] =
5943 {":type", IMAGE_SYMBOL_VALUE, 1},
5944 {":data", IMAGE_STRING_VALUE, 0},
5945 {":file", IMAGE_STRING_VALUE, 0},
5946 {":ascent", IMAGE_ASCENT_VALUE, 0},
5947 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
5948 {":relief", IMAGE_INTEGER_VALUE, 0},
5949 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5950 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5951 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5952 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
5955 /* Structure describing the image type `png'. */
5957 static struct image_type png_type =
5959 &Qpng,
5960 png_image_p,
5961 png_load,
5962 x_clear_image,
5963 NULL
5966 /* Return non-zero if OBJECT is a valid PNG image specification. */
5968 static int
5969 png_image_p (object)
5970 Lisp_Object object;
5972 struct image_keyword fmt[PNG_LAST];
5973 bcopy (png_format, fmt, sizeof fmt);
5975 if (!parse_image_spec (object, fmt, PNG_LAST, Qpng))
5976 return 0;
5978 /* Must specify either the :data or :file keyword. */
5979 return fmt[PNG_FILE].count + fmt[PNG_DATA].count == 1;
5982 #endif /* HAVE_PNG || MAC_OS */
5985 #ifdef HAVE_PNG
5987 #if defined HAVE_LIBPNG_PNG_H
5988 # include <libpng/png.h>
5989 #else
5990 # include <png.h>
5991 #endif
5993 #ifdef HAVE_NTGUI
5994 /* PNG library details. */
5996 DEF_IMGLIB_FN (png_get_io_ptr);
5997 DEF_IMGLIB_FN (png_check_sig);
5998 DEF_IMGLIB_FN (png_create_read_struct);
5999 DEF_IMGLIB_FN (png_create_info_struct);
6000 DEF_IMGLIB_FN (png_destroy_read_struct);
6001 DEF_IMGLIB_FN (png_set_read_fn);
6002 DEF_IMGLIB_FN (png_set_sig_bytes);
6003 DEF_IMGLIB_FN (png_read_info);
6004 DEF_IMGLIB_FN (png_get_IHDR);
6005 DEF_IMGLIB_FN (png_get_valid);
6006 DEF_IMGLIB_FN (png_set_strip_16);
6007 DEF_IMGLIB_FN (png_set_expand);
6008 DEF_IMGLIB_FN (png_set_gray_to_rgb);
6009 DEF_IMGLIB_FN (png_set_background);
6010 DEF_IMGLIB_FN (png_get_bKGD);
6011 DEF_IMGLIB_FN (png_read_update_info);
6012 DEF_IMGLIB_FN (png_get_channels);
6013 DEF_IMGLIB_FN (png_get_rowbytes);
6014 DEF_IMGLIB_FN (png_read_image);
6015 DEF_IMGLIB_FN (png_read_end);
6016 DEF_IMGLIB_FN (png_error);
6018 static int
6019 init_png_functions (Lisp_Object libraries)
6021 HMODULE library;
6023 /* Try loading libpng under probable names. */
6024 if (!(library = w32_delayed_load (libraries, Qpng)))
6025 return 0;
6027 LOAD_IMGLIB_FN (library, png_get_io_ptr);
6028 LOAD_IMGLIB_FN (library, png_check_sig);
6029 LOAD_IMGLIB_FN (library, png_create_read_struct);
6030 LOAD_IMGLIB_FN (library, png_create_info_struct);
6031 LOAD_IMGLIB_FN (library, png_destroy_read_struct);
6032 LOAD_IMGLIB_FN (library, png_set_read_fn);
6033 LOAD_IMGLIB_FN (library, png_set_sig_bytes);
6034 LOAD_IMGLIB_FN (library, png_read_info);
6035 LOAD_IMGLIB_FN (library, png_get_IHDR);
6036 LOAD_IMGLIB_FN (library, png_get_valid);
6037 LOAD_IMGLIB_FN (library, png_set_strip_16);
6038 LOAD_IMGLIB_FN (library, png_set_expand);
6039 LOAD_IMGLIB_FN (library, png_set_gray_to_rgb);
6040 LOAD_IMGLIB_FN (library, png_set_background);
6041 LOAD_IMGLIB_FN (library, png_get_bKGD);
6042 LOAD_IMGLIB_FN (library, png_read_update_info);
6043 LOAD_IMGLIB_FN (library, png_get_channels);
6044 LOAD_IMGLIB_FN (library, png_get_rowbytes);
6045 LOAD_IMGLIB_FN (library, png_read_image);
6046 LOAD_IMGLIB_FN (library, png_read_end);
6047 LOAD_IMGLIB_FN (library, png_error);
6048 return 1;
6050 #else
6052 #define fn_png_get_io_ptr png_get_io_ptr
6053 #define fn_png_check_sig png_check_sig
6054 #define fn_png_create_read_struct png_create_read_struct
6055 #define fn_png_create_info_struct png_create_info_struct
6056 #define fn_png_destroy_read_struct png_destroy_read_struct
6057 #define fn_png_set_read_fn png_set_read_fn
6058 #define fn_png_set_sig_bytes png_set_sig_bytes
6059 #define fn_png_read_info png_read_info
6060 #define fn_png_get_IHDR png_get_IHDR
6061 #define fn_png_get_valid png_get_valid
6062 #define fn_png_set_strip_16 png_set_strip_16
6063 #define fn_png_set_expand png_set_expand
6064 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
6065 #define fn_png_set_background png_set_background
6066 #define fn_png_get_bKGD png_get_bKGD
6067 #define fn_png_read_update_info png_read_update_info
6068 #define fn_png_get_channels png_get_channels
6069 #define fn_png_get_rowbytes png_get_rowbytes
6070 #define fn_png_read_image png_read_image
6071 #define fn_png_read_end png_read_end
6072 #define fn_png_error png_error
6074 #endif /* HAVE_NTGUI */
6076 /* Error and warning handlers installed when the PNG library
6077 is initialized. */
6079 static void
6080 my_png_error (png_ptr, msg)
6081 png_struct *png_ptr;
6082 char *msg;
6084 xassert (png_ptr != NULL);
6085 image_error ("PNG error: %s", build_string (msg), Qnil);
6086 longjmp (png_ptr->jmpbuf, 1);
6090 static void
6091 my_png_warning (png_ptr, msg)
6092 png_struct *png_ptr;
6093 char *msg;
6095 xassert (png_ptr != NULL);
6096 image_error ("PNG warning: %s", build_string (msg), Qnil);
6099 /* Memory source for PNG decoding. */
6101 struct png_memory_storage
6103 unsigned char *bytes; /* The data */
6104 size_t len; /* How big is it? */
6105 int index; /* Where are we? */
6109 /* Function set as reader function when reading PNG image from memory.
6110 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6111 bytes from the input to DATA. */
6113 static void
6114 png_read_from_memory (png_ptr, data, length)
6115 png_structp png_ptr;
6116 png_bytep data;
6117 png_size_t length;
6119 struct png_memory_storage *tbr
6120 = (struct png_memory_storage *) fn_png_get_io_ptr (png_ptr);
6122 if (length > tbr->len - tbr->index)
6123 fn_png_error (png_ptr, "Read error");
6125 bcopy (tbr->bytes + tbr->index, data, length);
6126 tbr->index = tbr->index + length;
6130 /* Function set as reader function when reading PNG image from a file.
6131 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
6132 bytes from the input to DATA. */
6134 static void
6135 png_read_from_file (png_ptr, data, length)
6136 png_structp png_ptr;
6137 png_bytep data;
6138 png_size_t length;
6140 FILE *fp = (FILE *) fn_png_get_io_ptr (png_ptr);
6142 if (fread (data, 1, length, fp) < length)
6143 fn_png_error (png_ptr, "Read error");
6147 /* Load PNG image IMG for use on frame F. Value is non-zero if
6148 successful. */
6150 static int
6151 png_load (f, img)
6152 struct frame *f;
6153 struct image *img;
6155 Lisp_Object file, specified_file;
6156 Lisp_Object specified_data;
6157 int x, y, i;
6158 XImagePtr ximg, mask_img = NULL;
6159 struct gcpro gcpro1;
6160 png_struct *png_ptr = NULL;
6161 png_info *info_ptr = NULL, *end_info = NULL;
6162 FILE *volatile fp = NULL;
6163 png_byte sig[8];
6164 png_byte * volatile pixels = NULL;
6165 png_byte ** volatile rows = NULL;
6166 png_uint_32 width, height;
6167 int bit_depth, color_type, interlace_type;
6168 png_byte channels;
6169 png_uint_32 row_bytes;
6170 int transparent_p;
6171 double screen_gamma;
6172 struct png_memory_storage tbr; /* Data to be read */
6174 /* Find out what file to load. */
6175 specified_file = image_spec_value (img->spec, QCfile, NULL);
6176 specified_data = image_spec_value (img->spec, QCdata, NULL);
6177 file = Qnil;
6178 GCPRO1 (file);
6180 if (NILP (specified_data))
6182 file = x_find_image_file (specified_file);
6183 if (!STRINGP (file))
6185 image_error ("Cannot find image file `%s'", specified_file, Qnil);
6186 UNGCPRO;
6187 return 0;
6190 /* Open the image file. */
6191 fp = fopen (SDATA (file), "rb");
6192 if (!fp)
6194 image_error ("Cannot open image file `%s'", file, Qnil);
6195 UNGCPRO;
6196 return 0;
6199 /* Check PNG signature. */
6200 if (fread (sig, 1, sizeof sig, fp) != sizeof sig
6201 || !fn_png_check_sig (sig, sizeof sig))
6203 image_error ("Not a PNG file: `%s'", file, Qnil);
6204 UNGCPRO;
6205 fclose (fp);
6206 return 0;
6209 else
6211 /* Read from memory. */
6212 tbr.bytes = SDATA (specified_data);
6213 tbr.len = SBYTES (specified_data);
6214 tbr.index = 0;
6216 /* Check PNG signature. */
6217 if (tbr.len < sizeof sig
6218 || !fn_png_check_sig (tbr.bytes, sizeof sig))
6220 image_error ("Not a PNG image: `%s'", img->spec, Qnil);
6221 UNGCPRO;
6222 return 0;
6225 /* Need to skip past the signature. */
6226 tbr.bytes += sizeof (sig);
6229 /* Initialize read and info structs for PNG lib. Casting return
6230 value avoids a GCC warning on W32. */
6231 png_ptr = (png_structp)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING,
6232 NULL, my_png_error,
6233 my_png_warning);
6234 if (!png_ptr)
6236 if (fp) fclose (fp);
6237 UNGCPRO;
6238 return 0;
6241 /* Casting return value avoids a GCC warning on W32. */
6242 info_ptr = (png_infop)fn_png_create_info_struct (png_ptr);
6243 if (!info_ptr)
6245 fn_png_destroy_read_struct (&png_ptr, NULL, NULL);
6246 if (fp) fclose (fp);
6247 UNGCPRO;
6248 return 0;
6251 /* Casting return value avoids a GCC warning on W32. */
6252 end_info = (png_infop)fn_png_create_info_struct (png_ptr);
6253 if (!end_info)
6255 fn_png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
6256 if (fp) fclose (fp);
6257 UNGCPRO;
6258 return 0;
6261 /* Set error jump-back. We come back here when the PNG library
6262 detects an error. */
6263 if (setjmp (png_ptr->jmpbuf))
6265 error:
6266 if (png_ptr)
6267 fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
6268 xfree (pixels);
6269 xfree (rows);
6270 if (fp) fclose (fp);
6271 UNGCPRO;
6272 return 0;
6275 /* Read image info. */
6276 if (!NILP (specified_data))
6277 fn_png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
6278 else
6279 fn_png_set_read_fn (png_ptr, (void *) fp, png_read_from_file);
6281 fn_png_set_sig_bytes (png_ptr, sizeof sig);
6282 fn_png_read_info (png_ptr, info_ptr);
6283 fn_png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
6284 &interlace_type, NULL, NULL);
6286 if (!check_image_size (f, width, height))
6287 goto error;
6289 /* If image contains simply transparency data, we prefer to
6290 construct a clipping mask. */
6291 if (fn_png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
6292 transparent_p = 1;
6293 else
6294 transparent_p = 0;
6296 /* This function is easier to write if we only have to handle
6297 one data format: RGB or RGBA with 8 bits per channel. Let's
6298 transform other formats into that format. */
6300 /* Strip more than 8 bits per channel. */
6301 if (bit_depth == 16)
6302 fn_png_set_strip_16 (png_ptr);
6304 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
6305 if available. */
6306 fn_png_set_expand (png_ptr);
6308 /* Convert grayscale images to RGB. */
6309 if (color_type == PNG_COLOR_TYPE_GRAY
6310 || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
6311 fn_png_set_gray_to_rgb (png_ptr);
6313 screen_gamma = (f->gamma ? 1 / f->gamma / 0.45455 : 2.2);
6315 #if 0 /* Avoid double gamma correction for PNG images. */
6316 { /* Tell the PNG lib to handle gamma correction for us. */
6317 int intent;
6318 double image_gamma;
6319 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
6320 if (png_get_sRGB (png_ptr, info_ptr, &intent))
6321 /* The libpng documentation says this is right in this case. */
6322 png_set_gamma (png_ptr, screen_gamma, 0.45455);
6323 else
6324 #endif
6325 if (png_get_gAMA (png_ptr, info_ptr, &image_gamma))
6326 /* Image contains gamma information. */
6327 png_set_gamma (png_ptr, screen_gamma, image_gamma);
6328 else
6329 /* Use the standard default for the image gamma. */
6330 png_set_gamma (png_ptr, screen_gamma, 0.45455);
6332 #endif /* if 0 */
6334 /* Handle alpha channel by combining the image with a background
6335 color. Do this only if a real alpha channel is supplied. For
6336 simple transparency, we prefer a clipping mask. */
6337 if (!transparent_p)
6339 png_color_16 *image_bg;
6340 Lisp_Object specified_bg
6341 = image_spec_value (img->spec, QCbackground, NULL);
6343 if (STRINGP (specified_bg))
6344 /* The user specified `:background', use that. */
6346 /* W32 version incorrectly used COLORREF here!! ++kfs */
6347 XColor color;
6348 if (x_defined_color (f, SDATA (specified_bg), &color, 0))
6350 png_color_16 user_bg;
6352 bzero (&user_bg, sizeof user_bg);
6353 user_bg.red = color.red >> 8;
6354 user_bg.green = color.green >> 8;
6355 user_bg.blue = color.blue >> 8;
6357 fn_png_set_background (png_ptr, &user_bg,
6358 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
6361 /* The commented-out code checked if the png specifies a default
6362 background color, and uses that. Since we use the current
6363 frame background, it is OK for us to ignore this.
6365 else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
6366 fn_png_set_background (png_ptr, image_bg,
6367 PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
6369 else
6371 /* Image does not contain a background color with which
6372 to combine the image data via an alpha channel. Use
6373 the frame's background instead. */
6374 #ifdef HAVE_X_WINDOWS
6375 XColor color;
6376 png_color_16 frame_background;
6378 color.pixel = FRAME_BACKGROUND_PIXEL (f);
6379 x_query_color (f, &color);
6381 bzero (&frame_background, sizeof frame_background);
6382 frame_background.red = color.red >> 8;
6383 frame_background.green = color.green >> 8;
6384 frame_background.blue = color.blue >> 8;
6385 #endif /* HAVE_X_WINDOWS */
6387 #ifdef HAVE_NTGUI
6388 COLORREF color;
6389 png_color_16 frame_background;
6390 color = FRAME_BACKGROUND_PIXEL (f);
6391 #if 0 /* W32 TODO : Colormap support. */
6392 x_query_color (f, &color);
6393 #endif
6394 bzero (&frame_background, sizeof frame_background);
6395 frame_background.red = GetRValue (color);
6396 frame_background.green = GetGValue (color);
6397 frame_background.blue = GetBValue (color);
6398 #endif /* HAVE_NTGUI */
6400 #ifdef MAC_OS
6401 unsigned long color;
6402 png_color_16 frame_background;
6403 color = FRAME_BACKGROUND_PIXEL (f);
6404 #if 0 /* MAC/W32 TODO : Colormap support. */
6405 x_query_color (f, &color);
6406 #endif
6407 bzero (&frame_background, sizeof frame_background);
6408 frame_background.red = RED_FROM_ULONG (color);
6409 frame_background.green = GREEN_FROM_ULONG (color);
6410 frame_background.blue = BLUE_FROM_ULONG (color);
6411 #endif /* MAC_OS */
6413 fn_png_set_background (png_ptr, &frame_background,
6414 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
6418 /* Update info structure. */
6419 fn_png_read_update_info (png_ptr, info_ptr);
6421 /* Get number of channels. Valid values are 1 for grayscale images
6422 and images with a palette, 2 for grayscale images with transparency
6423 information (alpha channel), 3 for RGB images, and 4 for RGB
6424 images with alpha channel, i.e. RGBA. If conversions above were
6425 sufficient we should only have 3 or 4 channels here. */
6426 channels = fn_png_get_channels (png_ptr, info_ptr);
6427 xassert (channels == 3 || channels == 4);
6429 /* Number of bytes needed for one row of the image. */
6430 row_bytes = fn_png_get_rowbytes (png_ptr, info_ptr);
6432 /* Allocate memory for the image. */
6433 pixels = (png_byte *) xmalloc (row_bytes * height * sizeof *pixels);
6434 rows = (png_byte **) xmalloc (height * sizeof *rows);
6435 for (i = 0; i < height; ++i)
6436 rows[i] = pixels + i * row_bytes;
6438 /* Read the entire image. */
6439 fn_png_read_image (png_ptr, rows);
6440 fn_png_read_end (png_ptr, info_ptr);
6441 if (fp)
6443 fclose (fp);
6444 fp = NULL;
6447 /* Create the X image and pixmap. */
6448 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
6449 &img->pixmap))
6450 goto error;
6452 /* Create an image and pixmap serving as mask if the PNG image
6453 contains an alpha channel. */
6454 if (channels == 4
6455 && !transparent_p
6456 && !x_create_x_image_and_pixmap (f, width, height, 1,
6457 &mask_img, &img->mask))
6459 x_destroy_x_image (ximg);
6460 Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
6461 img->pixmap = NO_PIXMAP;
6462 goto error;
6465 /* Fill the X image and mask from PNG data. */
6466 init_color_table ();
6468 for (y = 0; y < height; ++y)
6470 png_byte *p = rows[y];
6472 for (x = 0; x < width; ++x)
6474 unsigned r, g, b;
6476 r = *p++ << 8;
6477 g = *p++ << 8;
6478 b = *p++ << 8;
6479 XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
6480 /* An alpha channel, aka mask channel, associates variable
6481 transparency with an image. Where other image formats
6482 support binary transparency---fully transparent or fully
6483 opaque---PNG allows up to 254 levels of partial transparency.
6484 The PNG library implements partial transparency by combining
6485 the image with a specified background color.
6487 I'm not sure how to handle this here nicely: because the
6488 background on which the image is displayed may change, for
6489 real alpha channel support, it would be necessary to create
6490 a new image for each possible background.
6492 What I'm doing now is that a mask is created if we have
6493 boolean transparency information. Otherwise I'm using
6494 the frame's background color to combine the image with. */
6496 if (channels == 4)
6498 if (mask_img)
6499 XPutPixel (mask_img, x, y, *p > 0 ? PIX_MASK_DRAW : PIX_MASK_RETAIN);
6500 ++p;
6505 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
6506 /* Set IMG's background color from the PNG image, unless the user
6507 overrode it. */
6509 png_color_16 *bg;
6510 if (fn_png_get_bKGD (png_ptr, info_ptr, &bg))
6512 img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
6513 img->background_valid = 1;
6517 #ifdef COLOR_TABLE_SUPPORT
6518 /* Remember colors allocated for this image. */
6519 img->colors = colors_in_color_table (&img->ncolors);
6520 free_color_table ();
6521 #endif /* COLOR_TABLE_SUPPORT */
6523 /* Clean up. */
6524 fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
6525 xfree (rows);
6526 xfree (pixels);
6528 img->width = width;
6529 img->height = height;
6531 /* Maybe fill in the background field while we have ximg handy.
6532 Casting avoids a GCC warning. */
6533 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
6535 /* Put the image into the pixmap, then free the X image and its buffer. */
6536 x_put_x_image (f, ximg, img->pixmap, width, height);
6537 x_destroy_x_image (ximg);
6539 /* Same for the mask. */
6540 if (mask_img)
6542 /* Fill in the background_transparent field while we have the
6543 mask handy. Casting avoids a GCC warning. */
6544 image_background_transparent (img, f, (XImagePtr_or_DC)mask_img);
6546 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
6547 x_destroy_x_image (mask_img);
6550 UNGCPRO;
6551 return 1;
6554 #else /* HAVE_PNG */
6556 #ifdef MAC_OS
6557 static int
6558 png_load (f, img)
6559 struct frame *f;
6560 struct image *img;
6562 #ifdef MAC_OSX
6563 if (MyCGImageCreateWithPNGDataProvider)
6564 return image_load_quartz2d (f, img, 1);
6565 else
6566 #endif
6567 return image_load_quicktime (f, img, kQTFileTypePNG);
6569 #endif /* MAC_OS */
6571 #endif /* !HAVE_PNG */
6575 /***********************************************************************
6576 JPEG
6577 ***********************************************************************/
6579 #if defined (HAVE_JPEG) || defined (MAC_OS)
6581 static int jpeg_image_p P_ ((Lisp_Object object));
6582 static int jpeg_load P_ ((struct frame *f, struct image *img));
6584 /* The symbol `jpeg' identifying images of this type. */
6586 Lisp_Object Qjpeg;
6588 /* Indices of image specification fields in gs_format, below. */
6590 enum jpeg_keyword_index
6592 JPEG_TYPE,
6593 JPEG_DATA,
6594 JPEG_FILE,
6595 JPEG_ASCENT,
6596 JPEG_MARGIN,
6597 JPEG_RELIEF,
6598 JPEG_ALGORITHM,
6599 JPEG_HEURISTIC_MASK,
6600 JPEG_MASK,
6601 JPEG_BACKGROUND,
6602 JPEG_LAST
6605 /* Vector of image_keyword structures describing the format
6606 of valid user-defined image specifications. */
6608 static struct image_keyword jpeg_format[JPEG_LAST] =
6610 {":type", IMAGE_SYMBOL_VALUE, 1},
6611 {":data", IMAGE_STRING_VALUE, 0},
6612 {":file", IMAGE_STRING_VALUE, 0},
6613 {":ascent", IMAGE_ASCENT_VALUE, 0},
6614 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
6615 {":relief", IMAGE_INTEGER_VALUE, 0},
6616 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6617 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6618 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6619 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
6622 /* Structure describing the image type `jpeg'. */
6624 static struct image_type jpeg_type =
6626 &Qjpeg,
6627 jpeg_image_p,
6628 jpeg_load,
6629 x_clear_image,
6630 NULL
6633 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6635 static int
6636 jpeg_image_p (object)
6637 Lisp_Object object;
6639 struct image_keyword fmt[JPEG_LAST];
6641 bcopy (jpeg_format, fmt, sizeof fmt);
6643 if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg))
6644 return 0;
6646 /* Must specify either the :data or :file keyword. */
6647 return fmt[JPEG_FILE].count + fmt[JPEG_DATA].count == 1;
6650 #endif /* HAVE_JPEG || MAC_OS */
6652 #ifdef HAVE_JPEG
6654 /* Work around a warning about HAVE_STDLIB_H being redefined in
6655 jconfig.h. */
6656 #ifdef HAVE_STDLIB_H
6657 #define HAVE_STDLIB_H_1
6658 #undef HAVE_STDLIB_H
6659 #endif /* HAVE_STLIB_H */
6661 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6662 /* In older releases of the jpeg library, jpeglib.h will define boolean
6663 differently depending on __WIN32__, so make sure it is defined. */
6664 #define __WIN32__ 1
6665 #endif
6667 #include <jpeglib.h>
6668 #include <jerror.h>
6669 #include <setjmp.h>
6671 #ifdef HAVE_STLIB_H_1
6672 #define HAVE_STDLIB_H 1
6673 #endif
6675 #ifdef HAVE_NTGUI
6677 /* JPEG library details. */
6678 DEF_IMGLIB_FN (jpeg_CreateDecompress);
6679 DEF_IMGLIB_FN (jpeg_start_decompress);
6680 DEF_IMGLIB_FN (jpeg_finish_decompress);
6681 DEF_IMGLIB_FN (jpeg_destroy_decompress);
6682 DEF_IMGLIB_FN (jpeg_read_header);
6683 DEF_IMGLIB_FN (jpeg_read_scanlines);
6684 DEF_IMGLIB_FN (jpeg_std_error);
6685 DEF_IMGLIB_FN (jpeg_resync_to_restart);
6687 static int
6688 init_jpeg_functions (Lisp_Object libraries)
6690 HMODULE library;
6692 if (!(library = w32_delayed_load (libraries, Qjpeg)))
6693 return 0;
6695 LOAD_IMGLIB_FN (library, jpeg_finish_decompress);
6696 LOAD_IMGLIB_FN (library, jpeg_read_scanlines);
6697 LOAD_IMGLIB_FN (library, jpeg_start_decompress);
6698 LOAD_IMGLIB_FN (library, jpeg_read_header);
6699 LOAD_IMGLIB_FN (library, jpeg_CreateDecompress);
6700 LOAD_IMGLIB_FN (library, jpeg_destroy_decompress);
6701 LOAD_IMGLIB_FN (library, jpeg_std_error);
6702 LOAD_IMGLIB_FN (library, jpeg_resync_to_restart);
6703 return 1;
6706 /* Wrapper since we can't directly assign the function pointer
6707 to another function pointer that was declared more completely easily. */
6708 static boolean
6709 jpeg_resync_to_restart_wrapper(cinfo, desired)
6710 j_decompress_ptr cinfo;
6711 int desired;
6713 return fn_jpeg_resync_to_restart (cinfo, desired);
6716 #else
6718 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6719 #define fn_jpeg_start_decompress jpeg_start_decompress
6720 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6721 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6722 #define fn_jpeg_read_header jpeg_read_header
6723 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6724 #define fn_jpeg_std_error jpeg_std_error
6725 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6727 #endif /* HAVE_NTGUI */
6729 struct my_jpeg_error_mgr
6731 struct jpeg_error_mgr pub;
6732 jmp_buf setjmp_buffer;
6736 static void
6737 my_error_exit (cinfo)
6738 j_common_ptr cinfo;
6740 struct my_jpeg_error_mgr *mgr = (struct my_jpeg_error_mgr *) cinfo->err;
6741 longjmp (mgr->setjmp_buffer, 1);
6745 /* Init source method for JPEG data source manager. Called by
6746 jpeg_read_header() before any data is actually read. See
6747 libjpeg.doc from the JPEG lib distribution. */
6749 static void
6750 our_common_init_source (cinfo)
6751 j_decompress_ptr cinfo;
6756 /* Method to terminate data source. Called by
6757 jpeg_finish_decompress() after all data has been processed. */
6759 static void
6760 our_common_term_source (cinfo)
6761 j_decompress_ptr cinfo;
6766 /* Fill input buffer method for JPEG data source manager. Called
6767 whenever more data is needed. We read the whole image in one step,
6768 so this only adds a fake end of input marker at the end. */
6770 static boolean
6771 our_memory_fill_input_buffer (cinfo)
6772 j_decompress_ptr cinfo;
6774 /* Insert a fake EOI marker. */
6775 struct jpeg_source_mgr *src = cinfo->src;
6776 static JOCTET buffer[2];
6778 buffer[0] = (JOCTET) 0xFF;
6779 buffer[1] = (JOCTET) JPEG_EOI;
6781 src->next_input_byte = buffer;
6782 src->bytes_in_buffer = 2;
6783 return 1;
6787 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6788 is the JPEG data source manager. */
6790 static void
6791 our_memory_skip_input_data (cinfo, num_bytes)
6792 j_decompress_ptr cinfo;
6793 long num_bytes;
6795 struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
6797 if (src)
6799 if (num_bytes > src->bytes_in_buffer)
6800 ERREXIT (cinfo, JERR_INPUT_EOF);
6802 src->bytes_in_buffer -= num_bytes;
6803 src->next_input_byte += num_bytes;
6808 /* Set up the JPEG lib for reading an image from DATA which contains
6809 LEN bytes. CINFO is the decompression info structure created for
6810 reading the image. */
6812 static void
6813 jpeg_memory_src (cinfo, data, len)
6814 j_decompress_ptr cinfo;
6815 JOCTET *data;
6816 unsigned int len;
6818 struct jpeg_source_mgr *src;
6820 if (cinfo->src == NULL)
6822 /* First time for this JPEG object? */
6823 cinfo->src = (struct jpeg_source_mgr *)
6824 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
6825 sizeof (struct jpeg_source_mgr));
6826 src = (struct jpeg_source_mgr *) cinfo->src;
6827 src->next_input_byte = data;
6830 src = (struct jpeg_source_mgr *) cinfo->src;
6831 src->init_source = our_common_init_source;
6832 src->fill_input_buffer = our_memory_fill_input_buffer;
6833 src->skip_input_data = our_memory_skip_input_data;
6834 src->resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method. */
6835 src->term_source = our_common_term_source;
6836 src->bytes_in_buffer = len;
6837 src->next_input_byte = data;
6841 struct jpeg_stdio_mgr
6843 struct jpeg_source_mgr mgr;
6844 boolean finished;
6845 FILE *file;
6846 JOCTET *buffer;
6850 /* Size of buffer to read JPEG from file.
6851 Not too big, as we want to use alloc_small. */
6852 #define JPEG_STDIO_BUFFER_SIZE 8192
6855 /* Fill input buffer method for JPEG data source manager. Called
6856 whenever more data is needed. The data is read from a FILE *. */
6858 static boolean
6859 our_stdio_fill_input_buffer (cinfo)
6860 j_decompress_ptr cinfo;
6862 struct jpeg_stdio_mgr *src;
6864 src = (struct jpeg_stdio_mgr *) cinfo->src;
6865 if (!src->finished)
6867 size_t bytes;
6869 bytes = fread (src->buffer, 1, JPEG_STDIO_BUFFER_SIZE, src->file);
6870 if (bytes > 0)
6871 src->mgr.bytes_in_buffer = bytes;
6872 else
6874 WARNMS (cinfo, JWRN_JPEG_EOF);
6875 src->finished = 1;
6876 src->buffer[0] = (JOCTET) 0xFF;
6877 src->buffer[1] = (JOCTET) JPEG_EOI;
6878 src->mgr.bytes_in_buffer = 2;
6880 src->mgr.next_input_byte = src->buffer;
6883 return 1;
6887 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6888 is the JPEG data source manager. */
6890 static void
6891 our_stdio_skip_input_data (cinfo, num_bytes)
6892 j_decompress_ptr cinfo;
6893 long num_bytes;
6895 struct jpeg_stdio_mgr *src;
6896 src = (struct jpeg_stdio_mgr *) cinfo->src;
6898 while (num_bytes > 0 && !src->finished)
6900 if (num_bytes <= src->mgr.bytes_in_buffer)
6902 src->mgr.bytes_in_buffer -= num_bytes;
6903 src->mgr.next_input_byte += num_bytes;
6904 break;
6906 else
6908 num_bytes -= src->mgr.bytes_in_buffer;
6909 src->mgr.bytes_in_buffer = 0;
6910 src->mgr.next_input_byte = NULL;
6912 our_stdio_fill_input_buffer (cinfo);
6918 /* Set up the JPEG lib for reading an image from a FILE *.
6919 CINFO is the decompression info structure created for
6920 reading the image. */
6922 static void
6923 jpeg_file_src (cinfo, fp)
6924 j_decompress_ptr cinfo;
6925 FILE *fp;
6927 struct jpeg_stdio_mgr *src;
6929 if (cinfo->src != NULL)
6930 src = (struct jpeg_stdio_mgr *) cinfo->src;
6931 else
6933 /* First time for this JPEG object? */
6934 cinfo->src = (struct jpeg_source_mgr *)
6935 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
6936 sizeof (struct jpeg_stdio_mgr));
6937 src = (struct jpeg_stdio_mgr *) cinfo->src;
6938 src->buffer = (JOCTET *)
6939 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
6940 JPEG_STDIO_BUFFER_SIZE);
6943 src->file = fp;
6944 src->finished = 0;
6945 src->mgr.init_source = our_common_init_source;
6946 src->mgr.fill_input_buffer = our_stdio_fill_input_buffer;
6947 src->mgr.skip_input_data = our_stdio_skip_input_data;
6948 src->mgr.resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method. */
6949 src->mgr.term_source = our_common_term_source;
6950 src->mgr.bytes_in_buffer = 0;
6951 src->mgr.next_input_byte = NULL;
6955 /* Load image IMG for use on frame F. Patterned after example.c
6956 from the JPEG lib. */
6958 static int
6959 jpeg_load (f, img)
6960 struct frame *f;
6961 struct image *img;
6963 struct jpeg_decompress_struct cinfo;
6964 struct my_jpeg_error_mgr mgr;
6965 Lisp_Object file, specified_file;
6966 Lisp_Object specified_data;
6967 FILE * volatile fp = NULL;
6968 JSAMPARRAY buffer;
6969 int row_stride, x, y;
6970 XImagePtr ximg = NULL;
6971 int rc;
6972 unsigned long *colors;
6973 int width, height;
6974 struct gcpro gcpro1;
6976 /* Open the JPEG file. */
6977 specified_file = image_spec_value (img->spec, QCfile, NULL);
6978 specified_data = image_spec_value (img->spec, QCdata, NULL);
6979 file = Qnil;
6980 GCPRO1 (file);
6982 if (NILP (specified_data))
6984 file = x_find_image_file (specified_file);
6985 if (!STRINGP (file))
6987 image_error ("Cannot find image file `%s'", specified_file, Qnil);
6988 UNGCPRO;
6989 return 0;
6992 fp = fopen (SDATA (file), "rb");
6993 if (fp == NULL)
6995 image_error ("Cannot open `%s'", file, Qnil);
6996 UNGCPRO;
6997 return 0;
7001 /* Customize libjpeg's error handling to call my_error_exit when an
7002 error is detected. This function will perform a longjmp.
7003 Casting return value avoids a GCC warning on W32. */
7004 cinfo.err = (struct jpeg_error_mgr *)fn_jpeg_std_error (&mgr.pub);
7005 mgr.pub.error_exit = my_error_exit;
7007 if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
7009 if (rc == 1)
7011 /* Called from my_error_exit. Display a JPEG error. */
7012 char buffer[JMSG_LENGTH_MAX];
7013 cinfo.err->format_message ((j_common_ptr) &cinfo, buffer);
7014 image_error ("Error reading JPEG image `%s': %s", img->spec,
7015 build_string (buffer));
7018 /* Close the input file and destroy the JPEG object. */
7019 if (fp)
7020 fclose ((FILE *) fp);
7021 fn_jpeg_destroy_decompress (&cinfo);
7023 /* If we already have an XImage, free that. */
7024 x_destroy_x_image (ximg);
7026 /* Free pixmap and colors. */
7027 x_clear_image (f, img);
7029 UNGCPRO;
7030 return 0;
7033 /* Create the JPEG decompression object. Let it read from fp.
7034 Read the JPEG image header. */
7035 fn_jpeg_CreateDecompress (&cinfo, JPEG_LIB_VERSION, sizeof (cinfo));
7037 if (NILP (specified_data))
7038 jpeg_file_src (&cinfo, (FILE *) fp);
7039 else
7040 jpeg_memory_src (&cinfo, SDATA (specified_data),
7041 SBYTES (specified_data));
7043 fn_jpeg_read_header (&cinfo, 1);
7045 /* Customize decompression so that color quantization will be used.
7046 Start decompression. */
7047 cinfo.quantize_colors = 1;
7048 fn_jpeg_start_decompress (&cinfo);
7049 width = img->width = cinfo.output_width;
7050 height = img->height = cinfo.output_height;
7052 if (!check_image_size (f, width, height))
7054 image_error ("Invalid image size", Qnil, Qnil);
7055 longjmp (mgr.setjmp_buffer, 2);
7058 /* Create X image and pixmap. */
7059 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
7060 longjmp (mgr.setjmp_buffer, 2);
7062 /* Allocate colors. When color quantization is used,
7063 cinfo.actual_number_of_colors has been set with the number of
7064 colors generated, and cinfo.colormap is a two-dimensional array
7065 of color indices in the range 0..cinfo.actual_number_of_colors.
7066 No more than 255 colors will be generated. */
7068 int i, ir, ig, ib;
7070 if (cinfo.out_color_components > 2)
7071 ir = 0, ig = 1, ib = 2;
7072 else if (cinfo.out_color_components > 1)
7073 ir = 0, ig = 1, ib = 0;
7074 else
7075 ir = 0, ig = 0, ib = 0;
7077 /* Use the color table mechanism because it handles colors that
7078 cannot be allocated nicely. Such colors will be replaced with
7079 a default color, and we don't have to care about which colors
7080 can be freed safely, and which can't. */
7081 init_color_table ();
7082 colors = (unsigned long *) alloca (cinfo.actual_number_of_colors
7083 * sizeof *colors);
7085 for (i = 0; i < cinfo.actual_number_of_colors; ++i)
7087 /* Multiply RGB values with 255 because X expects RGB values
7088 in the range 0..0xffff. */
7089 int r = cinfo.colormap[ir][i] << 8;
7090 int g = cinfo.colormap[ig][i] << 8;
7091 int b = cinfo.colormap[ib][i] << 8;
7092 colors[i] = lookup_rgb_color (f, r, g, b);
7095 #ifdef COLOR_TABLE_SUPPORT
7096 /* Remember those colors actually allocated. */
7097 img->colors = colors_in_color_table (&img->ncolors);
7098 free_color_table ();
7099 #endif /* COLOR_TABLE_SUPPORT */
7102 /* Read pixels. */
7103 row_stride = width * cinfo.output_components;
7104 buffer = cinfo.mem->alloc_sarray ((j_common_ptr) &cinfo, JPOOL_IMAGE,
7105 row_stride, 1);
7106 for (y = 0; y < height; ++y)
7108 fn_jpeg_read_scanlines (&cinfo, buffer, 1);
7109 for (x = 0; x < cinfo.output_width; ++x)
7110 XPutPixel (ximg, x, y, colors[buffer[0][x]]);
7113 /* Clean up. */
7114 fn_jpeg_finish_decompress (&cinfo);
7115 fn_jpeg_destroy_decompress (&cinfo);
7116 if (fp)
7117 fclose ((FILE *) fp);
7119 /* Maybe fill in the background field while we have ximg handy. */
7120 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
7121 /* Casting avoids a GCC warning. */
7122 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
7124 /* Put the image into the pixmap. */
7125 x_put_x_image (f, ximg, img->pixmap, width, height);
7126 x_destroy_x_image (ximg);
7127 UNGCPRO;
7128 return 1;
7131 #else /* HAVE_JPEG */
7133 #ifdef MAC_OS
7134 static int
7135 jpeg_load (f, img)
7136 struct frame *f;
7137 struct image *img;
7139 #ifdef MAC_OSX
7140 return image_load_quartz2d (f, img, 0);
7141 #else
7142 return image_load_quicktime (f, img, kQTFileTypeJPEG);
7143 #endif
7145 #endif /* MAC_OS */
7147 #endif /* !HAVE_JPEG */
7151 /***********************************************************************
7152 TIFF
7153 ***********************************************************************/
7155 #if defined (HAVE_TIFF) || defined (MAC_OS)
7157 static int tiff_image_p P_ ((Lisp_Object object));
7158 static int tiff_load P_ ((struct frame *f, struct image *img));
7160 /* The symbol `tiff' identifying images of this type. */
7162 Lisp_Object Qtiff;
7164 /* Indices of image specification fields in tiff_format, below. */
7166 enum tiff_keyword_index
7168 TIFF_TYPE,
7169 TIFF_DATA,
7170 TIFF_FILE,
7171 TIFF_ASCENT,
7172 TIFF_MARGIN,
7173 TIFF_RELIEF,
7174 TIFF_ALGORITHM,
7175 TIFF_HEURISTIC_MASK,
7176 TIFF_MASK,
7177 TIFF_BACKGROUND,
7178 TIFF_LAST
7181 /* Vector of image_keyword structures describing the format
7182 of valid user-defined image specifications. */
7184 static struct image_keyword tiff_format[TIFF_LAST] =
7186 {":type", IMAGE_SYMBOL_VALUE, 1},
7187 {":data", IMAGE_STRING_VALUE, 0},
7188 {":file", IMAGE_STRING_VALUE, 0},
7189 {":ascent", IMAGE_ASCENT_VALUE, 0},
7190 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
7191 {":relief", IMAGE_INTEGER_VALUE, 0},
7192 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7193 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7194 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7195 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
7198 /* Structure describing the image type `tiff'. */
7200 static struct image_type tiff_type =
7202 &Qtiff,
7203 tiff_image_p,
7204 tiff_load,
7205 x_clear_image,
7206 NULL
7209 /* Return non-zero if OBJECT is a valid TIFF image specification. */
7211 static int
7212 tiff_image_p (object)
7213 Lisp_Object object;
7215 struct image_keyword fmt[TIFF_LAST];
7216 bcopy (tiff_format, fmt, sizeof fmt);
7218 if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff))
7219 return 0;
7221 /* Must specify either the :data or :file keyword. */
7222 return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
7225 #endif /* HAVE_TIFF || MAC_OS */
7227 #ifdef HAVE_TIFF
7229 #include <tiffio.h>
7231 #ifdef HAVE_NTGUI
7233 /* TIFF library details. */
7234 DEF_IMGLIB_FN (TIFFSetErrorHandler);
7235 DEF_IMGLIB_FN (TIFFSetWarningHandler);
7236 DEF_IMGLIB_FN (TIFFOpen);
7237 DEF_IMGLIB_FN (TIFFClientOpen);
7238 DEF_IMGLIB_FN (TIFFGetField);
7239 DEF_IMGLIB_FN (TIFFReadRGBAImage);
7240 DEF_IMGLIB_FN (TIFFClose);
7242 static int
7243 init_tiff_functions (Lisp_Object libraries)
7245 HMODULE library;
7247 if (!(library = w32_delayed_load (libraries, Qtiff)))
7248 return 0;
7250 LOAD_IMGLIB_FN (library, TIFFSetErrorHandler);
7251 LOAD_IMGLIB_FN (library, TIFFSetWarningHandler);
7252 LOAD_IMGLIB_FN (library, TIFFOpen);
7253 LOAD_IMGLIB_FN (library, TIFFClientOpen);
7254 LOAD_IMGLIB_FN (library, TIFFGetField);
7255 LOAD_IMGLIB_FN (library, TIFFReadRGBAImage);
7256 LOAD_IMGLIB_FN (library, TIFFClose);
7257 return 1;
7260 #else
7262 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
7263 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
7264 #define fn_TIFFOpen TIFFOpen
7265 #define fn_TIFFClientOpen TIFFClientOpen
7266 #define fn_TIFFGetField TIFFGetField
7267 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
7268 #define fn_TIFFClose TIFFClose
7270 #endif /* HAVE_NTGUI */
7273 /* Reading from a memory buffer for TIFF images Based on the PNG
7274 memory source, but we have to provide a lot of extra functions.
7275 Blah.
7277 We really only need to implement read and seek, but I am not
7278 convinced that the TIFF library is smart enough not to destroy
7279 itself if we only hand it the function pointers we need to
7280 override. */
7282 typedef struct
7284 unsigned char *bytes;
7285 size_t len;
7286 int index;
7288 tiff_memory_source;
7290 static size_t
7291 tiff_read_from_memory (data, buf, size)
7292 thandle_t data;
7293 tdata_t buf;
7294 tsize_t size;
7296 tiff_memory_source *src = (tiff_memory_source *) data;
7298 if (size > src->len - src->index)
7299 return (size_t) -1;
7300 bcopy (src->bytes + src->index, buf, size);
7301 src->index += size;
7302 return size;
7305 static size_t
7306 tiff_write_from_memory (data, buf, size)
7307 thandle_t data;
7308 tdata_t buf;
7309 tsize_t size;
7311 return (size_t) -1;
7314 static toff_t
7315 tiff_seek_in_memory (data, off, whence)
7316 thandle_t data;
7317 toff_t off;
7318 int whence;
7320 tiff_memory_source *src = (tiff_memory_source *) data;
7321 int idx;
7323 switch (whence)
7325 case SEEK_SET: /* Go from beginning of source. */
7326 idx = off;
7327 break;
7329 case SEEK_END: /* Go from end of source. */
7330 idx = src->len + off;
7331 break;
7333 case SEEK_CUR: /* Go from current position. */
7334 idx = src->index + off;
7335 break;
7337 default: /* Invalid `whence'. */
7338 return -1;
7341 if (idx > src->len || idx < 0)
7342 return -1;
7344 src->index = idx;
7345 return src->index;
7348 static int
7349 tiff_close_memory (data)
7350 thandle_t data;
7352 /* NOOP */
7353 return 0;
7356 static int
7357 tiff_mmap_memory (data, pbase, psize)
7358 thandle_t data;
7359 tdata_t *pbase;
7360 toff_t *psize;
7362 /* It is already _IN_ memory. */
7363 return 0;
7366 static void
7367 tiff_unmap_memory (data, base, size)
7368 thandle_t data;
7369 tdata_t base;
7370 toff_t size;
7372 /* We don't need to do this. */
7375 static toff_t
7376 tiff_size_of_memory (data)
7377 thandle_t data;
7379 return ((tiff_memory_source *) data)->len;
7383 static void
7384 tiff_error_handler (title, format, ap)
7385 const char *title, *format;
7386 va_list ap;
7388 char buf[512];
7389 int len;
7391 len = sprintf (buf, "TIFF error: %s ", title);
7392 vsprintf (buf + len, format, ap);
7393 add_to_log (buf, Qnil, Qnil);
7397 static void
7398 tiff_warning_handler (title, format, ap)
7399 const char *title, *format;
7400 va_list ap;
7402 char buf[512];
7403 int len;
7405 len = sprintf (buf, "TIFF warning: %s ", title);
7406 vsprintf (buf + len, format, ap);
7407 add_to_log (buf, Qnil, Qnil);
7411 /* Load TIFF image IMG for use on frame F. Value is non-zero if
7412 successful. */
7414 static int
7415 tiff_load (f, img)
7416 struct frame *f;
7417 struct image *img;
7419 Lisp_Object file, specified_file;
7420 Lisp_Object specified_data;
7421 TIFF *tiff;
7422 int width, height, x, y;
7423 uint32 *buf;
7424 int rc;
7425 XImagePtr ximg;
7426 struct gcpro gcpro1;
7427 tiff_memory_source memsrc;
7429 specified_file = image_spec_value (img->spec, QCfile, NULL);
7430 specified_data = image_spec_value (img->spec, QCdata, NULL);
7431 file = Qnil;
7432 GCPRO1 (file);
7434 fn_TIFFSetErrorHandler (tiff_error_handler);
7435 fn_TIFFSetWarningHandler (tiff_warning_handler);
7437 if (NILP (specified_data))
7439 /* Read from a file */
7440 file = x_find_image_file (specified_file);
7441 if (!STRINGP (file))
7443 image_error ("Cannot find image file `%s'", specified_file, Qnil);
7444 UNGCPRO;
7445 return 0;
7448 /* Try to open the image file. Casting return value avoids a
7449 GCC warning on W32. */
7450 tiff = (TIFF *)fn_TIFFOpen (SDATA (file), "r");
7451 if (tiff == NULL)
7453 image_error ("Cannot open `%s'", file, Qnil);
7454 UNGCPRO;
7455 return 0;
7458 else
7460 /* Memory source! */
7461 memsrc.bytes = SDATA (specified_data);
7462 memsrc.len = SBYTES (specified_data);
7463 memsrc.index = 0;
7465 /* Casting return value avoids a GCC warning on W32. */
7466 tiff = (TIFF *)fn_TIFFClientOpen ("memory_source", "r", &memsrc,
7467 (TIFFReadWriteProc) tiff_read_from_memory,
7468 (TIFFReadWriteProc) tiff_write_from_memory,
7469 tiff_seek_in_memory,
7470 tiff_close_memory,
7471 tiff_size_of_memory,
7472 tiff_mmap_memory,
7473 tiff_unmap_memory);
7475 if (!tiff)
7477 image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
7478 UNGCPRO;
7479 return 0;
7483 /* Get width and height of the image, and allocate a raster buffer
7484 of width x height 32-bit values. */
7485 fn_TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
7486 fn_TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
7488 if (!check_image_size (f, width, height))
7490 image_error ("Invalid image size", Qnil, Qnil);
7491 UNGCPRO;
7492 return 0;
7495 buf = (uint32 *) xmalloc (width * height * sizeof *buf);
7497 rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
7498 fn_TIFFClose (tiff);
7499 if (!rc)
7501 image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
7502 xfree (buf);
7503 UNGCPRO;
7504 return 0;
7507 /* Create the X image and pixmap. */
7508 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
7510 xfree (buf);
7511 UNGCPRO;
7512 return 0;
7515 /* Initialize the color table. */
7516 init_color_table ();
7518 /* Process the pixel raster. Origin is in the lower-left corner. */
7519 for (y = 0; y < height; ++y)
7521 uint32 *row = buf + y * width;
7523 for (x = 0; x < width; ++x)
7525 uint32 abgr = row[x];
7526 int r = TIFFGetR (abgr) << 8;
7527 int g = TIFFGetG (abgr) << 8;
7528 int b = TIFFGetB (abgr) << 8;
7529 XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
7533 #ifdef COLOR_TABLE_SUPPORT
7534 /* Remember the colors allocated for the image. Free the color table. */
7535 img->colors = colors_in_color_table (&img->ncolors);
7536 free_color_table ();
7537 #endif /* COLOR_TABLE_SUPPORT */
7539 img->width = width;
7540 img->height = height;
7542 /* Maybe fill in the background field while we have ximg handy. */
7543 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
7544 /* Casting avoids a GCC warning on W32. */
7545 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
7547 /* Put the image into the pixmap, then free the X image and its buffer. */
7548 x_put_x_image (f, ximg, img->pixmap, width, height);
7549 x_destroy_x_image (ximg);
7550 xfree (buf);
7552 UNGCPRO;
7553 return 1;
7556 #else /* HAVE_TIFF */
7558 #ifdef MAC_OS
7559 static int
7560 tiff_load (f, img)
7561 struct frame *f;
7562 struct image *img;
7564 return image_load_quicktime (f, img, kQTFileTypeTIFF);
7566 #endif /* MAC_OS */
7568 #endif /* !HAVE_TIFF */
7572 /***********************************************************************
7574 ***********************************************************************/
7576 #if defined (HAVE_GIF) || defined (MAC_OS)
7578 static int gif_image_p P_ ((Lisp_Object object));
7579 static int gif_load P_ ((struct frame *f, struct image *img));
7580 static void gif_clear_image P_ ((struct frame *f, struct image *img));
7582 /* The symbol `gif' identifying images of this type. */
7584 Lisp_Object Qgif;
7586 /* Indices of image specification fields in gif_format, below. */
7588 enum gif_keyword_index
7590 GIF_TYPE,
7591 GIF_DATA,
7592 GIF_FILE,
7593 GIF_ASCENT,
7594 GIF_MARGIN,
7595 GIF_RELIEF,
7596 GIF_ALGORITHM,
7597 GIF_HEURISTIC_MASK,
7598 GIF_MASK,
7599 GIF_IMAGE,
7600 GIF_BACKGROUND,
7601 GIF_LAST
7604 /* Vector of image_keyword structures describing the format
7605 of valid user-defined image specifications. */
7607 static struct image_keyword gif_format[GIF_LAST] =
7609 {":type", IMAGE_SYMBOL_VALUE, 1},
7610 {":data", IMAGE_STRING_VALUE, 0},
7611 {":file", IMAGE_STRING_VALUE, 0},
7612 {":ascent", IMAGE_ASCENT_VALUE, 0},
7613 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
7614 {":relief", IMAGE_INTEGER_VALUE, 0},
7615 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7616 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7617 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7618 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
7619 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
7622 /* Structure describing the image type `gif'. */
7624 static struct image_type gif_type =
7626 &Qgif,
7627 gif_image_p,
7628 gif_load,
7629 gif_clear_image,
7630 NULL
7633 /* Free X resources of GIF image IMG which is used on frame F. */
7635 static void
7636 gif_clear_image (f, img)
7637 struct frame *f;
7638 struct image *img;
7640 /* IMG->data.ptr_val may contain extension data. */
7641 img->data.lisp_val = Qnil;
7642 x_clear_image (f, img);
7645 /* Return non-zero if OBJECT is a valid GIF image specification. */
7647 static int
7648 gif_image_p (object)
7649 Lisp_Object object;
7651 struct image_keyword fmt[GIF_LAST];
7652 bcopy (gif_format, fmt, sizeof fmt);
7654 if (!parse_image_spec (object, fmt, GIF_LAST, Qgif))
7655 return 0;
7657 /* Must specify either the :data or :file keyword. */
7658 return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
7661 #endif /* HAVE_GIF || MAC_OS */
7663 #ifdef HAVE_GIF
7665 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7666 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7667 Undefine before redefining to avoid a preprocessor warning. */
7668 #ifdef DrawText
7669 #undef DrawText
7670 #endif
7671 /* avoid conflict with QuickdrawText.h */
7672 #define DrawText gif_DrawText
7673 #include <gif_lib.h>
7674 #undef DrawText
7676 #else /* HAVE_NTGUI || MAC_OS */
7678 #include <gif_lib.h>
7680 #endif /* HAVE_NTGUI || MAC_OS */
7683 #ifdef HAVE_NTGUI
7685 /* GIF library details. */
7686 DEF_IMGLIB_FN (DGifCloseFile);
7687 DEF_IMGLIB_FN (DGifSlurp);
7688 DEF_IMGLIB_FN (DGifOpen);
7689 DEF_IMGLIB_FN (DGifOpenFileName);
7691 static int
7692 init_gif_functions (Lisp_Object libraries)
7694 HMODULE library;
7696 if (!(library = w32_delayed_load (libraries, Qgif)))
7697 return 0;
7699 LOAD_IMGLIB_FN (library, DGifCloseFile);
7700 LOAD_IMGLIB_FN (library, DGifSlurp);
7701 LOAD_IMGLIB_FN (library, DGifOpen);
7702 LOAD_IMGLIB_FN (library, DGifOpenFileName);
7703 return 1;
7706 #else
7708 #define fn_DGifCloseFile DGifCloseFile
7709 #define fn_DGifSlurp DGifSlurp
7710 #define fn_DGifOpen DGifOpen
7711 #define fn_DGifOpenFileName DGifOpenFileName
7713 #endif /* HAVE_NTGUI */
7715 /* Reading a GIF image from memory
7716 Based on the PNG memory stuff to a certain extent. */
7718 typedef struct
7720 unsigned char *bytes;
7721 size_t len;
7722 int index;
7724 gif_memory_source;
7726 /* Make the current memory source available to gif_read_from_memory.
7727 It's done this way because not all versions of libungif support
7728 a UserData field in the GifFileType structure. */
7729 static gif_memory_source *current_gif_memory_src;
7731 static int
7732 gif_read_from_memory (file, buf, len)
7733 GifFileType *file;
7734 GifByteType *buf;
7735 int len;
7737 gif_memory_source *src = current_gif_memory_src;
7739 if (len > src->len - src->index)
7740 return -1;
7742 bcopy (src->bytes + src->index, buf, len);
7743 src->index += len;
7744 return len;
7748 /* Load GIF image IMG for use on frame F. Value is non-zero if
7749 successful. */
7751 static int
7752 gif_load (f, img)
7753 struct frame *f;
7754 struct image *img;
7756 Lisp_Object file, specified_file;
7757 Lisp_Object specified_data;
7758 int rc, width, height, x, y, i;
7759 XImagePtr ximg;
7760 ColorMapObject *gif_color_map;
7761 unsigned long pixel_colors[256];
7762 GifFileType *gif;
7763 struct gcpro gcpro1;
7764 Lisp_Object image;
7765 int ino, image_height, image_width;
7766 gif_memory_source memsrc;
7767 unsigned char *raster;
7769 specified_file = image_spec_value (img->spec, QCfile, NULL);
7770 specified_data = image_spec_value (img->spec, QCdata, NULL);
7771 file = Qnil;
7772 GCPRO1 (file);
7774 if (NILP (specified_data))
7776 file = x_find_image_file (specified_file);
7777 if (!STRINGP (file))
7779 image_error ("Cannot find image file `%s'", specified_file, Qnil);
7780 UNGCPRO;
7781 return 0;
7784 /* Open the GIF file. Casting return value avoids a GCC warning
7785 on W32. */
7786 gif = (GifFileType *)fn_DGifOpenFileName (SDATA (file));
7787 if (gif == NULL)
7789 image_error ("Cannot open `%s'", file, Qnil);
7790 UNGCPRO;
7791 return 0;
7794 else
7796 /* Read from memory! */
7797 current_gif_memory_src = &memsrc;
7798 memsrc.bytes = SDATA (specified_data);
7799 memsrc.len = SBYTES (specified_data);
7800 memsrc.index = 0;
7802 /* Casting return value avoids a GCC warning on W32. */
7803 gif = (GifFileType *)fn_DGifOpen(&memsrc, gif_read_from_memory);
7804 if (!gif)
7806 image_error ("Cannot open memory source `%s'", img->spec, Qnil);
7807 UNGCPRO;
7808 return 0;
7812 /* Before reading entire contents, check the declared image size. */
7813 if (!check_image_size (f, gif->SWidth, gif->SHeight))
7815 image_error ("Invalid image size", Qnil, Qnil);
7816 fn_DGifCloseFile (gif);
7817 UNGCPRO;
7818 return 0;
7821 /* Read entire contents. */
7822 rc = fn_DGifSlurp (gif);
7823 if (rc == GIF_ERROR)
7825 image_error ("Error reading `%s'", img->spec, Qnil);
7826 fn_DGifCloseFile (gif);
7827 UNGCPRO;
7828 return 0;
7831 image = image_spec_value (img->spec, QCindex, NULL);
7832 ino = INTEGERP (image) ? XFASTINT (image) : 0;
7833 if (ino >= gif->ImageCount)
7835 image_error ("Invalid image number `%s' in image `%s'",
7836 image, img->spec);
7837 fn_DGifCloseFile (gif);
7838 UNGCPRO;
7839 return 0;
7842 img->corners[TOP_CORNER] = gif->SavedImages[ino].ImageDesc.Top;
7843 img->corners[LEFT_CORNER] = gif->SavedImages[ino].ImageDesc.Left;
7844 image_height = gif->SavedImages[ino].ImageDesc.Height;
7845 img->corners[BOT_CORNER] = img->corners[TOP_CORNER] + image_height;
7846 image_width = gif->SavedImages[ino].ImageDesc.Width;
7847 img->corners[RIGHT_CORNER] = img->corners[LEFT_CORNER] + image_width;
7849 width = img->width = max (gif->SWidth,
7850 max (gif->Image.Left + gif->Image.Width,
7851 img->corners[RIGHT_CORNER]));
7852 height = img->height = max (gif->SHeight,
7853 max (gif->Image.Top + gif->Image.Height,
7854 img->corners[BOT_CORNER]));
7856 if (!check_image_size (f, width, height))
7858 image_error ("Invalid image size", Qnil, Qnil);
7859 fn_DGifCloseFile (gif);
7860 UNGCPRO;
7861 return 0;
7864 /* Create the X image and pixmap. */
7865 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
7867 fn_DGifCloseFile (gif);
7868 UNGCPRO;
7869 return 0;
7872 /* Allocate colors. */
7873 gif_color_map = gif->SavedImages[ino].ImageDesc.ColorMap;
7874 if (!gif_color_map)
7875 gif_color_map = gif->SColorMap;
7876 init_color_table ();
7877 bzero (pixel_colors, sizeof pixel_colors);
7879 for (i = 0; i < gif_color_map->ColorCount; ++i)
7881 int r = gif_color_map->Colors[i].Red << 8;
7882 int g = gif_color_map->Colors[i].Green << 8;
7883 int b = gif_color_map->Colors[i].Blue << 8;
7884 pixel_colors[i] = lookup_rgb_color (f, r, g, b);
7887 #ifdef COLOR_TABLE_SUPPORT
7888 img->colors = colors_in_color_table (&img->ncolors);
7889 free_color_table ();
7890 #endif /* COLOR_TABLE_SUPPORT */
7892 /* Clear the part of the screen image that are not covered by
7893 the image from the GIF file. Full animated GIF support
7894 requires more than can be done here (see the gif89 spec,
7895 disposal methods). Let's simply assume that the part
7896 not covered by a sub-image is in the frame's background color. */
7897 for (y = 0; y < img->corners[TOP_CORNER]; ++y)
7898 for (x = 0; x < width; ++x)
7899 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7901 for (y = img->corners[BOT_CORNER]; y < height; ++y)
7902 for (x = 0; x < width; ++x)
7903 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7905 for (y = img->corners[TOP_CORNER]; y < img->corners[BOT_CORNER]; ++y)
7907 for (x = 0; x < img->corners[LEFT_CORNER]; ++x)
7908 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7909 for (x = img->corners[RIGHT_CORNER]; x < width; ++x)
7910 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7913 /* Read the GIF image into the X image. We use a local variable
7914 `raster' here because RasterBits below is a char *, and invites
7915 problems with bytes >= 0x80. */
7916 raster = (unsigned char *) gif->SavedImages[ino].RasterBits;
7918 if (gif->SavedImages[ino].ImageDesc.Interlace)
7920 static int interlace_start[] = {0, 4, 2, 1};
7921 static int interlace_increment[] = {8, 8, 4, 2};
7922 int pass;
7923 int row = interlace_start[0];
7925 pass = 0;
7927 for (y = 0; y < image_height; y++)
7929 if (row >= image_height)
7931 row = interlace_start[++pass];
7932 while (row >= image_height)
7933 row = interlace_start[++pass];
7936 for (x = 0; x < image_width; x++)
7938 int i = raster[(y * image_width) + x];
7939 XPutPixel (ximg, x + img->corners[LEFT_CORNER],
7940 row + img->corners[TOP_CORNER], pixel_colors[i]);
7943 row += interlace_increment[pass];
7946 else
7948 for (y = 0; y < image_height; ++y)
7949 for (x = 0; x < image_width; ++x)
7951 int i = raster[y * image_width + x];
7952 XPutPixel (ximg, x + img->corners[LEFT_CORNER],
7953 y + img->corners[TOP_CORNER], pixel_colors[i]);
7957 /* Save GIF image extension data for `image-extension-data'.
7958 Format is (count IMAGES FUNCTION "BYTES" ...). */
7959 img->data.lisp_val = Qnil;
7960 if (gif->SavedImages[ino].ExtensionBlockCount > 0)
7962 ExtensionBlock *ext = gif->SavedImages[ino].ExtensionBlocks;
7963 for (i = 0; i < gif->SavedImages[ino].ExtensionBlockCount; i++, ext++)
7964 /* Append (... FUNCTION "BYTES") */
7965 img->data.lisp_val = Fcons (make_unibyte_string (ext->Bytes, ext->ByteCount),
7966 Fcons (make_number (ext->Function),
7967 img->data.lisp_val));
7968 img->data.lisp_val = Fnreverse (img->data.lisp_val);
7970 if (gif->ImageCount > 1)
7971 img->data.lisp_val = Fcons (Qcount,
7972 Fcons (make_number (gif->ImageCount),
7973 img->data.lisp_val));
7975 fn_DGifCloseFile (gif);
7977 /* Maybe fill in the background field while we have ximg handy. */
7978 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
7979 /* Casting avoids a GCC warning. */
7980 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
7982 /* Put the image into the pixmap, then free the X image and its buffer. */
7983 x_put_x_image (f, ximg, img->pixmap, width, height);
7984 x_destroy_x_image (ximg);
7986 UNGCPRO;
7987 return 1;
7990 #else /* !HAVE_GIF */
7992 #ifdef MAC_OS
7993 static int
7994 gif_load (f, img)
7995 struct frame *f;
7996 struct image *img;
7998 Lisp_Object specified_file, file;
7999 Lisp_Object specified_data;
8000 OSErr err;
8001 Boolean graphic_p, movie_p, prefer_graphic_p;
8002 Handle dh = NULL;
8003 Movie movie = NULL;
8004 Lisp_Object image;
8005 Track track = NULL;
8006 Media media = NULL;
8007 long nsamples;
8008 Rect rect;
8009 Lisp_Object specified_bg;
8010 XColor color;
8011 RGBColor bg_color;
8012 int width, height;
8013 XImagePtr ximg;
8014 TimeScale time_scale;
8015 TimeValue time, duration;
8016 int ino;
8017 CGrafPtr old_port;
8018 GDHandle old_gdh;
8020 specified_file = image_spec_value (img->spec, QCfile, NULL);
8021 specified_data = image_spec_value (img->spec, QCdata, NULL);
8023 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8024 EnterMovies ();
8026 if (NILP (specified_data))
8028 /* Read from a file */
8029 FSSpec fss;
8030 short refnum;
8032 err = find_image_fsspec (specified_file, &file, &fss);
8033 if (err != noErr)
8035 if (err == fnfErr)
8036 image_error ("Cannot find image file `%s'", specified_file, Qnil);
8037 else
8038 goto open_error;
8041 err = CanQuickTimeOpenFile (&fss, kQTFileTypeGIF, 0,
8042 &graphic_p, &movie_p, &prefer_graphic_p, 0);
8043 if (err != noErr)
8044 goto open_error;
8046 if (!graphic_p && !movie_p)
8047 goto open_error;
8048 if (prefer_graphic_p)
8049 return image_load_qt_1 (f, img, kQTFileTypeGIF, &fss, NULL);
8050 err = OpenMovieFile (&fss, &refnum, fsRdPerm);
8051 if (err != noErr)
8052 goto open_error;
8053 err = NewMovieFromFile (&movie, refnum, NULL, NULL, 0, NULL);
8054 CloseMovieFile (refnum);
8055 if (err != noErr)
8057 image_error ("Error reading `%s'", file, Qnil);
8058 return 0;
8061 else
8063 /* Memory source! */
8064 Handle dref = NULL;
8065 long file_type_atom[3];
8067 err = PtrToHand (SDATA (specified_data), &dh, SBYTES (specified_data));
8068 if (err != noErr)
8070 image_error ("Cannot allocate data handle for `%s'",
8071 img->spec, Qnil);
8072 goto error;
8075 file_type_atom[0] = EndianU32_NtoB (sizeof (long) * 3);
8076 file_type_atom[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType);
8077 file_type_atom[2] = EndianU32_NtoB (kQTFileTypeGIF);
8078 err = PtrToHand (&dh, &dref, sizeof (Handle));
8079 if (err == noErr)
8080 /* no file name */
8081 err = PtrAndHand ("\p", dref, 1);
8082 if (err == noErr)
8083 err = PtrAndHand (file_type_atom, dref, sizeof (long) * 3);
8084 if (err != noErr)
8086 image_error ("Cannot allocate handle data ref for `%s'", img->spec, Qnil);
8087 goto error;
8089 err = CanQuickTimeOpenDataRef (dref, HandleDataHandlerSubType, &graphic_p,
8090 &movie_p, &prefer_graphic_p, 0);
8091 if (err != noErr)
8092 goto open_error;
8094 if (!graphic_p && !movie_p)
8095 goto open_error;
8096 if (prefer_graphic_p)
8098 int success_p;
8100 DisposeHandle (dref);
8101 success_p = image_load_qt_1 (f, img, kQTFileTypeGIF, NULL, dh);
8102 DisposeHandle (dh);
8103 return success_p;
8105 err = NewMovieFromDataRef (&movie, 0, NULL, dref,
8106 HandleDataHandlerSubType);
8107 DisposeHandle (dref);
8108 if (err != noErr)
8109 goto open_error;
8112 image = image_spec_value (img->spec, QCindex, NULL);
8113 ino = INTEGERP (image) ? XFASTINT (image) : 0;
8114 track = GetMovieIndTrack (movie, 1);
8115 media = GetTrackMedia (track);
8116 nsamples = GetMediaSampleCount (media);
8117 if (ino >= nsamples)
8119 image_error ("Invalid image number `%s' in image `%s'",
8120 image, img->spec);
8121 goto error;
8123 time_scale = GetMediaTimeScale (media);
8125 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
8126 if (!STRINGP (specified_bg) ||
8127 !mac_defined_color (f, SDATA (specified_bg), &color, 0))
8129 color.pixel = FRAME_BACKGROUND_PIXEL (f);
8130 color.red = RED16_FROM_ULONG (color.pixel);
8131 color.green = GREEN16_FROM_ULONG (color.pixel);
8132 color.blue = BLUE16_FROM_ULONG (color.pixel);
8134 GetMovieBox (movie, &rect);
8135 width = img->width = rect.right - rect.left;
8136 height = img->height = rect.bottom - rect.top;
8137 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
8138 goto error;
8140 GetGWorld (&old_port, &old_gdh);
8141 SetGWorld (ximg, NULL);
8142 bg_color.red = color.red;
8143 bg_color.green = color.green;
8144 bg_color.blue = color.blue;
8145 RGBBackColor (&bg_color);
8146 SetGWorld (old_port, old_gdh);
8147 SetMovieActive (movie, 1);
8148 SetMovieGWorld (movie, ximg, NULL);
8149 SampleNumToMediaTime (media, ino + 1, &time, &duration);
8150 SetMovieTimeValue (movie, time);
8151 MoviesTask (movie, 0L);
8152 DisposeTrackMedia (media);
8153 DisposeMovieTrack (track);
8154 DisposeMovie (movie);
8155 if (dh)
8156 DisposeHandle (dh);
8158 /* Save GIF image extension data for `image-extension-data'.
8159 Format is (count IMAGES 0xf9 GRAPHIC_CONTROL_EXTENSION_BLOCK). */
8161 Lisp_Object gce = make_uninit_string (4);
8162 int centisec = ((float)duration / time_scale) * 100.0f + 0.5f;
8164 /* Fill the delay time field. */
8165 SSET (gce, 1, centisec & 0xff);
8166 SSET (gce, 2, (centisec >> 8) & 0xff);
8167 /* We don't know about other fields. */
8168 SSET (gce, 0, 0);
8169 SSET (gce, 3, 0);
8171 img->data.lisp_val = list4 (Qcount, make_number (nsamples),
8172 make_number (0xf9), gce);
8175 /* Maybe fill in the background field while we have ximg handy. */
8176 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
8177 IMAGE_BACKGROUND (img, f, ximg);
8179 /* Put the image into the pixmap. */
8180 x_put_x_image (f, ximg, img->pixmap, width, height);
8181 x_destroy_x_image (ximg);
8182 return 1;
8184 open_error:
8185 image_error ("Cannot open `%s'", file, Qnil);
8186 error:
8187 if (media)
8188 DisposeTrackMedia (media);
8189 if (track)
8190 DisposeMovieTrack (track);
8191 if (movie)
8192 DisposeMovie (movie);
8193 if (dh)
8194 DisposeHandle (dh);
8195 return 0;
8197 #endif /* MAC_OS */
8199 #endif /* HAVE_GIF */
8203 /***********************************************************************
8204 Ghostscript
8205 ***********************************************************************/
8207 #ifdef HAVE_X_WINDOWS
8208 #define HAVE_GHOSTSCRIPT 1
8209 #endif /* HAVE_X_WINDOWS */
8211 /* The symbol `postscript' identifying images of this type. */
8213 Lisp_Object Qpostscript;
8215 #ifdef HAVE_GHOSTSCRIPT
8217 static int gs_image_p P_ ((Lisp_Object object));
8218 static int gs_load P_ ((struct frame *f, struct image *img));
8219 static void gs_clear_image P_ ((struct frame *f, struct image *img));
8221 /* Keyword symbols. */
8223 Lisp_Object QCloader, QCbounding_box, QCpt_width, QCpt_height;
8225 /* Indices of image specification fields in gs_format, below. */
8227 enum gs_keyword_index
8229 GS_TYPE,
8230 GS_PT_WIDTH,
8231 GS_PT_HEIGHT,
8232 GS_FILE,
8233 GS_LOADER,
8234 GS_BOUNDING_BOX,
8235 GS_ASCENT,
8236 GS_MARGIN,
8237 GS_RELIEF,
8238 GS_ALGORITHM,
8239 GS_HEURISTIC_MASK,
8240 GS_MASK,
8241 GS_BACKGROUND,
8242 GS_LAST
8245 /* Vector of image_keyword structures describing the format
8246 of valid user-defined image specifications. */
8248 static struct image_keyword gs_format[GS_LAST] =
8250 {":type", IMAGE_SYMBOL_VALUE, 1},
8251 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE, 1},
8252 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE, 1},
8253 {":file", IMAGE_STRING_VALUE, 1},
8254 {":loader", IMAGE_FUNCTION_VALUE, 0},
8255 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE, 1},
8256 {":ascent", IMAGE_ASCENT_VALUE, 0},
8257 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
8258 {":relief", IMAGE_INTEGER_VALUE, 0},
8259 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8260 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8261 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
8262 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
8265 /* Structure describing the image type `ghostscript'. */
8267 static struct image_type gs_type =
8269 &Qpostscript,
8270 gs_image_p,
8271 gs_load,
8272 gs_clear_image,
8273 NULL
8277 /* Free X resources of Ghostscript image IMG which is used on frame F. */
8279 static void
8280 gs_clear_image (f, img)
8281 struct frame *f;
8282 struct image *img;
8284 /* IMG->data.ptr_val may contain a recorded colormap. */
8285 xfree (img->data.ptr_val);
8286 x_clear_image (f, img);
8290 /* Return non-zero if OBJECT is a valid Ghostscript image
8291 specification. */
8293 static int
8294 gs_image_p (object)
8295 Lisp_Object object;
8297 struct image_keyword fmt[GS_LAST];
8298 Lisp_Object tem;
8299 int i;
8301 bcopy (gs_format, fmt, sizeof fmt);
8303 if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript))
8304 return 0;
8306 /* Bounding box must be a list or vector containing 4 integers. */
8307 tem = fmt[GS_BOUNDING_BOX].value;
8308 if (CONSP (tem))
8310 for (i = 0; i < 4; ++i, tem = XCDR (tem))
8311 if (!CONSP (tem) || !INTEGERP (XCAR (tem)))
8312 return 0;
8313 if (!NILP (tem))
8314 return 0;
8316 else if (VECTORP (tem))
8318 if (XVECTOR (tem)->size != 4)
8319 return 0;
8320 for (i = 0; i < 4; ++i)
8321 if (!INTEGERP (XVECTOR (tem)->contents[i]))
8322 return 0;
8324 else
8325 return 0;
8327 return 1;
8331 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
8332 if successful. */
8334 static int
8335 gs_load (f, img)
8336 struct frame *f;
8337 struct image *img;
8339 char buffer[100];
8340 Lisp_Object window_and_pixmap_id = Qnil, loader, pt_height, pt_width;
8341 struct gcpro gcpro1, gcpro2;
8342 Lisp_Object frame;
8343 double in_width, in_height;
8344 Lisp_Object pixel_colors = Qnil;
8346 /* Compute pixel size of pixmap needed from the given size in the
8347 image specification. Sizes in the specification are in pt. 1 pt
8348 = 1/72 in, xdpi and ydpi are stored in the frame's X display
8349 info. */
8350 pt_width = image_spec_value (img->spec, QCpt_width, NULL);
8351 in_width = XFASTINT (pt_width) / 72.0;
8352 img->width = in_width * FRAME_X_DISPLAY_INFO (f)->resx;
8353 pt_height = image_spec_value (img->spec, QCpt_height, NULL);
8354 in_height = XFASTINT (pt_height) / 72.0;
8355 img->height = in_height * FRAME_X_DISPLAY_INFO (f)->resy;
8357 if (!check_image_size (f, img->width, img->height))
8359 image_error ("Invalid image size", Qnil, Qnil);
8360 return 0;
8363 /* Create the pixmap. */
8364 xassert (img->pixmap == NO_PIXMAP);
8366 /* Only W32 version did BLOCK_INPUT here. ++kfs */
8367 BLOCK_INPUT;
8368 img->pixmap = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8369 img->width, img->height,
8370 DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
8371 UNBLOCK_INPUT;
8373 if (!img->pixmap)
8375 image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
8376 return 0;
8379 /* Call the loader to fill the pixmap. It returns a process object
8380 if successful. We do not record_unwind_protect here because
8381 other places in redisplay like calling window scroll functions
8382 don't either. Let the Lisp loader use `unwind-protect' instead. */
8383 GCPRO2 (window_and_pixmap_id, pixel_colors);
8385 sprintf (buffer, "%lu %lu",
8386 (unsigned long) FRAME_X_WINDOW (f),
8387 (unsigned long) img->pixmap);
8388 window_and_pixmap_id = build_string (buffer);
8390 sprintf (buffer, "%lu %lu",
8391 FRAME_FOREGROUND_PIXEL (f),
8392 FRAME_BACKGROUND_PIXEL (f));
8393 pixel_colors = build_string (buffer);
8395 XSETFRAME (frame, f);
8396 loader = image_spec_value (img->spec, QCloader, NULL);
8397 if (NILP (loader))
8398 loader = intern ("gs-load-image");
8400 img->data.lisp_val = call6 (loader, frame, img->spec,
8401 make_number (img->width),
8402 make_number (img->height),
8403 window_and_pixmap_id,
8404 pixel_colors);
8405 UNGCPRO;
8406 return PROCESSP (img->data.lisp_val);
8410 /* Kill the Ghostscript process that was started to fill PIXMAP on
8411 frame F. Called from XTread_socket when receiving an event
8412 telling Emacs that Ghostscript has finished drawing. */
8414 void
8415 x_kill_gs_process (pixmap, f)
8416 Pixmap pixmap;
8417 struct frame *f;
8419 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
8420 int class, i;
8421 struct image *img;
8423 /* Find the image containing PIXMAP. */
8424 for (i = 0; i < c->used; ++i)
8425 if (c->images[i]->pixmap == pixmap)
8426 break;
8428 /* Should someone in between have cleared the image cache, for
8429 instance, give up. */
8430 if (i == c->used)
8431 return;
8433 /* Kill the GS process. We should have found PIXMAP in the image
8434 cache and its image should contain a process object. */
8435 img = c->images[i];
8436 xassert (PROCESSP (img->data.lisp_val));
8437 Fkill_process (img->data.lisp_val, Qnil);
8438 img->data.lisp_val = Qnil;
8440 #if defined (HAVE_X_WINDOWS)
8442 /* On displays with a mutable colormap, figure out the colors
8443 allocated for the image by looking at the pixels of an XImage for
8444 img->pixmap. */
8445 class = FRAME_X_VISUAL (f)->class;
8446 if (class != StaticColor && class != StaticGray && class != TrueColor)
8448 XImagePtr ximg;
8450 BLOCK_INPUT;
8452 /* Try to get an XImage for img->pixmep. */
8453 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
8454 0, 0, img->width, img->height, ~0, ZPixmap);
8455 if (ximg)
8457 int x, y;
8459 /* Initialize the color table. */
8460 init_color_table ();
8462 /* For each pixel of the image, look its color up in the
8463 color table. After having done so, the color table will
8464 contain an entry for each color used by the image. */
8465 for (y = 0; y < img->height; ++y)
8466 for (x = 0; x < img->width; ++x)
8468 unsigned long pixel = XGetPixel (ximg, x, y);
8469 lookup_pixel_color (f, pixel);
8472 /* Record colors in the image. Free color table and XImage. */
8473 #ifdef COLOR_TABLE_SUPPORT
8474 img->colors = colors_in_color_table (&img->ncolors);
8475 free_color_table ();
8476 #endif
8477 XDestroyImage (ximg);
8479 #if 0 /* This doesn't seem to be the case. If we free the colors
8480 here, we get a BadAccess later in x_clear_image when
8481 freeing the colors. */
8482 /* We have allocated colors once, but Ghostscript has also
8483 allocated colors on behalf of us. So, to get the
8484 reference counts right, free them once. */
8485 if (img->ncolors)
8486 x_free_colors (f, img->colors, img->ncolors);
8487 #endif
8489 else
8490 image_error ("Cannot get X image of `%s'; colors will not be freed",
8491 img->spec, Qnil);
8493 UNBLOCK_INPUT;
8495 #endif /* HAVE_X_WINDOWS */
8497 /* Now that we have the pixmap, compute mask and transform the
8498 image if requested. */
8499 BLOCK_INPUT;
8500 postprocess_image (f, img);
8501 UNBLOCK_INPUT;
8504 #endif /* HAVE_GHOSTSCRIPT */
8507 /***********************************************************************
8508 Tests
8509 ***********************************************************************/
8511 #if GLYPH_DEBUG
8513 DEFUN ("imagep", Fimagep, Simagep, 1, 1, 0,
8514 doc: /* Value is non-nil if SPEC is a valid image specification. */)
8515 (spec)
8516 Lisp_Object spec;
8518 return valid_image_p (spec) ? Qt : Qnil;
8522 DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
8523 (spec)
8524 Lisp_Object spec;
8526 int id = -1;
8528 if (valid_image_p (spec))
8529 id = lookup_image (SELECTED_FRAME (), spec);
8531 debug_print (spec);
8532 return make_number (id);
8535 #endif /* GLYPH_DEBUG != 0 */
8538 /***********************************************************************
8539 Initialization
8540 ***********************************************************************/
8542 #ifdef HAVE_NTGUI
8543 /* Image types that rely on external libraries are loaded dynamically
8544 if the library is available. */
8545 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8546 define_image_type (image_type, init_lib_fn (libraries))
8547 #else
8548 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
8549 define_image_type (image_type, 1)
8550 #endif /* HAVE_NTGUI */
8552 DEFUN ("init-image-library", Finit_image_library, Sinit_image_library, 2, 2, 0,
8553 doc: /* Initialize image library implementing image type TYPE.
8554 Return non-nil if TYPE is a supported image type.
8556 Image types pbm and xbm are prebuilt; other types are loaded here.
8557 Libraries to load are specified in alist LIBRARIES (usually, the value
8558 of `image-library-alist', which see). */)
8559 (type, libraries)
8560 Lisp_Object type, libraries;
8562 Lisp_Object tested;
8564 /* Don't try to reload the library. */
8565 tested = Fassq (type, Vimage_type_cache);
8566 if (CONSP (tested))
8567 return XCDR (tested);
8569 #if defined (HAVE_XPM) || defined (MAC_OS)
8570 if (EQ (type, Qxpm))
8571 return CHECK_LIB_AVAILABLE (&xpm_type, init_xpm_functions, libraries);
8572 #endif
8574 #if defined (HAVE_JPEG) || defined (MAC_OS)
8575 if (EQ (type, Qjpeg))
8576 return CHECK_LIB_AVAILABLE (&jpeg_type, init_jpeg_functions, libraries);
8577 #endif
8579 #if defined (HAVE_TIFF) || defined (MAC_OS)
8580 if (EQ (type, Qtiff))
8581 return CHECK_LIB_AVAILABLE (&tiff_type, init_tiff_functions, libraries);
8582 #endif
8584 #if defined (HAVE_GIF) || defined (MAC_OS)
8585 if (EQ (type, Qgif))
8586 return CHECK_LIB_AVAILABLE (&gif_type, init_gif_functions, libraries);
8587 #endif
8589 #if defined (HAVE_PNG) || defined (MAC_OS)
8590 if (EQ (type, Qpng))
8591 return CHECK_LIB_AVAILABLE (&png_type, init_png_functions, libraries);
8592 #endif
8594 #ifdef HAVE_GHOSTSCRIPT
8595 if (EQ (type, Qpostscript))
8596 return CHECK_LIB_AVAILABLE (&gs_type, init_gs_functions, libraries);
8597 #endif
8599 /* If the type is not recognized, avoid testing it ever again. */
8600 CACHE_IMAGE_TYPE (type, Qnil);
8601 return Qnil;
8604 void
8605 syms_of_image ()
8607 extern Lisp_Object Qrisky_local_variable; /* Syms_of_xdisp has already run. */
8609 /* Initialize this only once, since that's what we do with Vimage_types
8610 and they are supposed to be in sync. Initializing here gives correct
8611 operation on GNU/Linux of calling dump-emacs after loading some images. */
8612 image_types = NULL;
8614 /* Must be defined now becase we're going to update it below, while
8615 defining the supported image types. */
8616 DEFVAR_LISP ("image-types", &Vimage_types,
8617 doc: /* List of potentially supported image types.
8618 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8619 To check whether it is really supported, use `image-type-available-p'. */);
8620 Vimage_types = Qnil;
8622 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist,
8623 doc: /* Alist of image types vs external libraries needed to display them.
8625 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8626 representing a supported image type, and the rest are strings giving
8627 alternate filenames for the corresponding external libraries.
8629 Emacs tries to load the libraries in the order they appear on the
8630 list; if none is loaded, the running session of Emacs won't
8631 support the image type. Types 'pbm and 'xbm don't need to be
8632 listed; they're always supported. */);
8633 Vimage_library_alist = Qnil;
8634 Fput (intern ("image-library-alist"), Qrisky_local_variable, Qt);
8636 DEFVAR_LISP ("max-image-size", &Vmax_image_size,
8637 doc: /* Maximum size of images.
8638 Emacs will not load an image into memory if its pixel width or
8639 pixel height exceeds this limit.
8641 If the value is an integer, it directly specifies the maximum
8642 image height and width, measured in pixels. If it is a floating
8643 point number, it specifies the maximum image height and width
8644 as a ratio to the frame height and width. If the value is
8645 non-numeric, there is no explicit limit on the size of images. */);
8646 Vmax_image_size = make_float (MAX_IMAGE_SIZE);
8648 Vimage_type_cache = Qnil;
8649 staticpro (&Vimage_type_cache);
8651 Qpbm = intern ("pbm");
8652 staticpro (&Qpbm);
8653 ADD_IMAGE_TYPE(Qpbm);
8655 Qxbm = intern ("xbm");
8656 staticpro (&Qxbm);
8657 ADD_IMAGE_TYPE(Qxbm);
8659 define_image_type (&xbm_type, 1);
8660 define_image_type (&pbm_type, 1);
8662 QCascent = intern (":ascent");
8663 staticpro (&QCascent);
8664 QCmargin = intern (":margin");
8665 staticpro (&QCmargin);
8666 QCrelief = intern (":relief");
8667 staticpro (&QCrelief);
8668 QCconversion = intern (":conversion");
8669 staticpro (&QCconversion);
8670 QCcolor_symbols = intern (":color-symbols");
8671 staticpro (&QCcolor_symbols);
8672 QCheuristic_mask = intern (":heuristic-mask");
8673 staticpro (&QCheuristic_mask);
8674 QCindex = intern (":index");
8675 staticpro (&QCindex);
8676 QCmatrix = intern (":matrix");
8677 staticpro (&QCmatrix);
8678 QCcolor_adjustment = intern (":color-adjustment");
8679 staticpro (&QCcolor_adjustment);
8680 QCmask = intern (":mask");
8681 staticpro (&QCmask);
8683 Qlaplace = intern ("laplace");
8684 staticpro (&Qlaplace);
8685 Qemboss = intern ("emboss");
8686 staticpro (&Qemboss);
8687 Qedge_detection = intern ("edge-detection");
8688 staticpro (&Qedge_detection);
8689 Qheuristic = intern ("heuristic");
8690 staticpro (&Qheuristic);
8692 Qpostscript = intern ("postscript");
8693 staticpro (&Qpostscript);
8694 #ifdef HAVE_GHOSTSCRIPT
8695 ADD_IMAGE_TYPE(Qpostscript);
8696 QCloader = intern (":loader");
8697 staticpro (&QCloader);
8698 QCbounding_box = intern (":bounding-box");
8699 staticpro (&QCbounding_box);
8700 QCpt_width = intern (":pt-width");
8701 staticpro (&QCpt_width);
8702 QCpt_height = intern (":pt-height");
8703 staticpro (&QCpt_height);
8704 #endif /* HAVE_GHOSTSCRIPT */
8706 #if defined (HAVE_XPM) || defined (MAC_OS)
8707 Qxpm = intern ("xpm");
8708 staticpro (&Qxpm);
8709 ADD_IMAGE_TYPE(Qxpm);
8710 #endif
8712 #if defined (HAVE_JPEG) || defined (MAC_OS)
8713 Qjpeg = intern ("jpeg");
8714 staticpro (&Qjpeg);
8715 ADD_IMAGE_TYPE(Qjpeg);
8716 #endif
8718 #if defined (HAVE_TIFF) || defined (MAC_OS)
8719 Qtiff = intern ("tiff");
8720 staticpro (&Qtiff);
8721 ADD_IMAGE_TYPE(Qtiff);
8722 #endif
8724 #if defined (HAVE_GIF) || defined (MAC_OS)
8725 Qgif = intern ("gif");
8726 staticpro (&Qgif);
8727 ADD_IMAGE_TYPE(Qgif);
8728 #endif
8730 #if defined (HAVE_PNG) || defined (MAC_OS)
8731 Qpng = intern ("png");
8732 staticpro (&Qpng);
8733 ADD_IMAGE_TYPE(Qpng);
8734 #endif
8736 defsubr (&Sinit_image_library);
8737 defsubr (&Sclear_image_cache);
8738 defsubr (&Simage_refresh);
8739 defsubr (&Simage_size);
8740 defsubr (&Simage_mask_p);
8741 defsubr (&Simage_extension_data);
8743 #if GLYPH_DEBUG
8744 defsubr (&Simagep);
8745 defsubr (&Slookup_image);
8746 #endif
8748 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images,
8749 doc: /* Non-nil means always draw a cross over disabled images.
8750 Disabled images are those having an `:conversion disabled' property.
8751 A cross is always drawn on black & white displays. */);
8752 cross_disabled_images = 0;
8754 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
8755 doc: /* List of directories to search for window system bitmap files. */);
8756 Vx_bitmap_file_path = decode_env_path ((char *) 0, PATH_BITMAPS);
8758 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay,
8759 doc: /* Time after which cached images are removed from the cache.
8760 When an image has not been displayed this many seconds, remove it
8761 from the image cache. Value must be an integer or nil with nil
8762 meaning don't clear the cache. */);
8763 Vimage_cache_eviction_delay = make_number (30 * 60);
8766 void
8767 init_image ()
8769 #if defined (MAC_OSX) && TARGET_API_MAC_CARBON
8770 init_image_func_pointer ();
8771 #endif
8774 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8775 (do not change this comment) */