]> code.delx.au - gnu-emacs/blob - src/image.c
Update FSF's address.
[gnu-emacs] / src / image.c
1 /* Functions for image support on window system.
2 Copyright (C) 1989, 92, 93, 94, 95, 96, 97, 98, 99, 2000,01,02,03,04
3 Free Software Foundation.
4
5 This file is part of GNU Emacs.
6
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 2, or (at your option)
10 any later version.
11
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.
16
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. */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <math.h>
25 #include <ctype.h>
26
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31 /* This makes the fields of a Display accessible, in Xlib header files. */
32
33 #define XLIB_ILLEGAL_ACCESS
34
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
43
44 #ifdef HAVE_X_WINDOWS
45 #include "xterm.h"
46 #include <sys/types.h>
47 #include <sys/stat.h>
48
49 #define COLOR_TABLE_SUPPORT 1
50
51 typedef struct x_bitmap_record Bitmap_Record;
52 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
53 #define NO_PIXMAP None
54
55 #define RGB_PIXEL_COLOR unsigned long
56
57 #define PIX_MASK_RETAIN(f) 0
58 #define PIX_MASK_DRAW(f) 1
59 #endif /* HAVE_X_WINDOWS */
60
61
62 #ifdef HAVE_NTGUI
63 #include "w32term.h"
64
65 /* W32_TODO : Color tables on W32. */
66 #undef COLOR_TABLE_SUPPORT
67
68 typedef struct w32_bitmap_record Bitmap_Record;
69 #define GET_PIXEL(ximg, x, y) GetPixel(ximg, x, y)
70 #define NO_PIXMAP 0
71
72 #define RGB_PIXEL_COLOR COLORREF
73
74 #define PIX_MASK_RETAIN(f) 0
75 #define PIX_MASK_DRAW(f) 1
76
77 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
78 #define x_defined_color w32_defined_color
79 #define DefaultDepthOfScreen(screen) (one_w32_display_info.n_cbits)
80 #endif /* HAVE_NTGUI */
81
82
83 #ifdef MAC_OS
84 #include "macterm.h"
85 #include <sys/stat.h>
86 #ifndef MAC_OSX
87 #include <alloca.h>
88 #include <sys/param.h>
89 #endif
90 #if TARGET_API_MAC_CARBON
91 #ifdef MAC_OSX
92 #include <QuickTime/QuickTime.h>
93 #else /* not MAC_OSX */
94 #include <QuickTime.h>
95 #endif /* not MAC_OSX */
96 #else /* not TARGET_API_MAC_CARBON */
97 #include <Windows.h>
98 #include <Gestalt.h>
99 #include <TextUtils.h>
100 #include <ImageCompression.h>
101 #include <QuickTimeComponents.h>
102 #endif /* not TARGET_API_MAC_CARBON */
103
104 /* MAC_TODO : Color tables on Mac. */
105 #undef COLOR_TABLE_SUPPORT
106
107 #define ZPixmap 0 /* arbitrary */
108 typedef struct mac_bitmap_record Bitmap_Record;
109
110 #define GET_PIXEL(ximg, x, y) XGetPixel(ximg, x, y)
111 #define NO_PIXMAP 0
112
113 #define RGB_PIXEL_COLOR unsigned long
114
115 #define FRAME_X_VISUAL(f) FRAME_X_DISPLAY_INFO (f)->visual
116 #define x_defined_color mac_defined_color
117 #define DefaultDepthOfScreen(screen) (one_mac_display_info.n_planes)
118 #define XDrawLine(display, w, gc, x1, y1, x2, y2) \
119 mac_draw_line_to_pixmap(display, w, gc, x1, y1, x2, y2)
120
121 #endif /* MAC_OS */
122
123
124 /* Search path for bitmap files. */
125
126 Lisp_Object Vx_bitmap_file_path;
127
128
129 static void x_disable_image P_ ((struct frame *, struct image *));
130 static void x_edge_detection P_ ((struct frame *, struct image *, Lisp_Object,
131 Lisp_Object));
132
133 static void init_color_table P_ ((void));
134 static unsigned long lookup_rgb_color P_ ((struct frame *f, int r, int g, int b));
135 #ifdef COLOR_TABLE_SUPPORT
136 static void free_color_table P_ ((void));
137 static unsigned long *colors_in_color_table P_ ((int *n));
138 static unsigned long lookup_pixel_color P_ ((struct frame *f, unsigned long p));
139 #endif
140
141 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
142 id, which is just an int that this section returns. Bitmaps are
143 reference counted so they can be shared among frames.
144
145 Bitmap indices are guaranteed to be > 0, so a negative number can
146 be used to indicate no bitmap.
147
148 If you use x_create_bitmap_from_data, then you must keep track of
149 the bitmaps yourself. That is, creating a bitmap from the same
150 data more than once will not be caught. */
151
152 #ifdef MAC_OS
153
154 static XImagePtr
155 XGetImage (display, pixmap, x, y, width, height, plane_mask, format)
156 Display *display; /* not used */
157 Pixmap pixmap;
158 int x, y; /* not used */
159 unsigned int width, height; /* not used */
160 unsigned long plane_mask; /* not used */
161 int format; /* not used */
162 {
163 #if GLYPH_DEBUG
164 xassert (x == 0 && y == 0);
165 {
166 Rect ri, rp;
167 SetRect (&ri, 0, 0, width, height);
168 xassert (EqualRect (&ri, GetPixBounds (GetGWorldPixMap (pixmap), &rp)));
169 }
170 xassert (! (pixelsLocked & GetPixelsState (GetGWorldPixMap (pixmap))));
171 #endif
172
173 LockPixels (GetGWorldPixMap (pixmap));
174
175 return pixmap;
176 }
177
178 static void
179 XPutPixel (ximage, x, y, pixel)
180 XImagePtr ximage;
181 int x, y;
182 unsigned long pixel;
183 {
184 CGrafPtr old_port;
185 GDHandle old_gdh;
186 RGBColor color;
187
188 GetGWorld (&old_port, &old_gdh);
189 SetGWorld (ximage, NULL);
190
191 color.red = RED16_FROM_ULONG (pixel);
192 color.green = GREEN16_FROM_ULONG (pixel);
193 color.blue = BLUE16_FROM_ULONG (pixel);
194 SetCPixel (x, y, &color);
195
196 SetGWorld (old_port, old_gdh);
197 }
198
199 static unsigned long
200 XGetPixel (ximage, x, y)
201 XImagePtr ximage;
202 int x, y;
203 {
204 CGrafPtr old_port;
205 GDHandle old_gdh;
206 RGBColor color;
207
208 GetGWorld (&old_port, &old_gdh);
209 SetGWorld (ximage, NULL);
210
211 GetCPixel (x, y, &color);
212
213 SetGWorld (old_port, old_gdh);
214 return RGB_TO_ULONG (color.red >> 8, color.green >> 8, color.blue >> 8);
215 }
216
217 static void
218 XDestroyImage (ximg)
219 XImagePtr ximg;
220 {
221 UnlockPixels (GetGWorldPixMap (ximg));
222 }
223 #endif /* MAC_OS */
224
225
226 /* Functions to access the contents of a bitmap, given an id. */
227
228 int
229 x_bitmap_height (f, id)
230 FRAME_PTR f;
231 int id;
232 {
233 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].height;
234 }
235
236 int
237 x_bitmap_width (f, id)
238 FRAME_PTR f;
239 int id;
240 {
241 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].width;
242 }
243
244 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
245 int
246 x_bitmap_pixmap (f, id)
247 FRAME_PTR f;
248 int id;
249 {
250 return (int) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap;
251 }
252 #endif
253
254 #ifdef HAVE_X_WINDOWS
255 int
256 x_bitmap_mask (f, id)
257 FRAME_PTR f;
258 int id;
259 {
260 return FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].mask;
261 }
262 #endif
263
264 /* Allocate a new bitmap record. Returns index of new record. */
265
266 static int
267 x_allocate_bitmap_record (f)
268 FRAME_PTR f;
269 {
270 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
271 int i;
272
273 if (dpyinfo->bitmaps == NULL)
274 {
275 dpyinfo->bitmaps_size = 10;
276 dpyinfo->bitmaps
277 = (Bitmap_Record *) xmalloc (dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
278 dpyinfo->bitmaps_last = 1;
279 return 1;
280 }
281
282 if (dpyinfo->bitmaps_last < dpyinfo->bitmaps_size)
283 return ++dpyinfo->bitmaps_last;
284
285 for (i = 0; i < dpyinfo->bitmaps_size; ++i)
286 if (dpyinfo->bitmaps[i].refcount == 0)
287 return i + 1;
288
289 dpyinfo->bitmaps_size *= 2;
290 dpyinfo->bitmaps
291 = (Bitmap_Record *) xrealloc (dpyinfo->bitmaps,
292 dpyinfo->bitmaps_size * sizeof (Bitmap_Record));
293 return ++dpyinfo->bitmaps_last;
294 }
295
296 /* Add one reference to the reference count of the bitmap with id ID. */
297
298 void
299 x_reference_bitmap (f, id)
300 FRAME_PTR f;
301 int id;
302 {
303 ++FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].refcount;
304 }
305
306 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
307
308 int
309 x_create_bitmap_from_data (f, bits, width, height)
310 struct frame *f;
311 char *bits;
312 unsigned int width, height;
313 {
314 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
315 int id;
316
317 #ifdef HAVE_X_WINDOWS
318 Pixmap bitmap;
319 bitmap = XCreateBitmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
320 bits, width, height);
321 if (! bitmap)
322 return -1;
323 #endif /* HAVE_X_WINDOWS */
324
325 #ifdef HAVE_NTGUI
326 Pixmap bitmap;
327 bitmap = CreateBitmap (width, height,
328 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_planes,
329 FRAME_X_DISPLAY_INFO (XFRAME (frame))->n_cbits,
330 bits);
331 if (! bitmap)
332 return -1;
333 #endif /* HAVE_NTGUI */
334
335 #ifdef MAC_OS
336 /* MAC_TODO: for now fail if width is not mod 16 (toolbox requires it) */
337 if (width % 16 != 0)
338 return -1;
339 #endif
340
341 id = x_allocate_bitmap_record (f);
342 #ifdef MAC_OS
343 dpyinfo->bitmaps[id - 1].bitmap_data = (char *) xmalloc (height * width);
344 if (! dpyinfo->bitmaps[id - 1].bitmap_data)
345 return -1;
346 bcopy (bits, dpyinfo->bitmaps[id - 1].bitmap_data, height * width);
347 #endif /* MAC_OS */
348
349 dpyinfo->bitmaps[id - 1].file = NULL;
350 dpyinfo->bitmaps[id - 1].height = height;
351 dpyinfo->bitmaps[id - 1].width = width;
352 dpyinfo->bitmaps[id - 1].refcount = 1;
353
354 #ifdef HAVE_X_WINDOWS
355 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
356 dpyinfo->bitmaps[id - 1].have_mask = 0;
357 dpyinfo->bitmaps[id - 1].depth = 1;
358 #endif /* HAVE_X_WINDOWS */
359
360 #ifdef HAVE_NTGUI
361 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
362 dpyinfo->bitmaps[id - 1].hinst = NULL;
363 dpyinfo->bitmaps[id - 1].depth = 1;
364 #endif /* HAVE_NTGUI */
365
366 return id;
367 }
368
369 /* Create bitmap from file FILE for frame F. */
370
371 int
372 x_create_bitmap_from_file (f, file)
373 struct frame *f;
374 Lisp_Object file;
375 {
376 #ifdef MAC_OS
377 return -1; /* MAC_TODO : bitmap support */
378 #endif /* MAC_OS */
379
380 #ifdef HAVE_NTGUI
381 return -1; /* W32_TODO : bitmap support */
382 #endif /* HAVE_NTGUI */
383
384 #ifdef HAVE_X_WINDOWS
385 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
386 unsigned int width, height;
387 Pixmap bitmap;
388 int xhot, yhot, result, id;
389 Lisp_Object found;
390 int fd;
391 char *filename;
392
393 /* Look for an existing bitmap with the same name. */
394 for (id = 0; id < dpyinfo->bitmaps_last; ++id)
395 {
396 if (dpyinfo->bitmaps[id].refcount
397 && dpyinfo->bitmaps[id].file
398 && !strcmp (dpyinfo->bitmaps[id].file, (char *) SDATA (file)))
399 {
400 ++dpyinfo->bitmaps[id].refcount;
401 return id + 1;
402 }
403 }
404
405 /* Search bitmap-file-path for the file, if appropriate. */
406 fd = openp (Vx_bitmap_file_path, file, Qnil, &found, Qnil);
407 if (fd < 0)
408 return -1;
409 emacs_close (fd);
410
411 filename = (char *) SDATA (found);
412
413 result = XReadBitmapFile (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
414 filename, &width, &height, &bitmap, &xhot, &yhot);
415 if (result != BitmapSuccess)
416 return -1;
417
418 id = x_allocate_bitmap_record (f);
419 dpyinfo->bitmaps[id - 1].pixmap = bitmap;
420 dpyinfo->bitmaps[id - 1].have_mask = 0;
421 dpyinfo->bitmaps[id - 1].refcount = 1;
422 dpyinfo->bitmaps[id - 1].file = (char *) xmalloc (SBYTES (file) + 1);
423 dpyinfo->bitmaps[id - 1].depth = 1;
424 dpyinfo->bitmaps[id - 1].height = height;
425 dpyinfo->bitmaps[id - 1].width = width;
426 strcpy (dpyinfo->bitmaps[id - 1].file, SDATA (file));
427
428 return id;
429 #endif /* HAVE_X_WINDOWS */
430 }
431
432 /* Free bitmap B. */
433
434 static void
435 Free_Bitmap_Record (dpyinfo, bm)
436 Display_Info *dpyinfo;
437 Bitmap_Record *bm;
438 {
439 #ifdef HAVE_X_WINDOWS
440 XFreePixmap (dpyinfo->display, bm->pixmap);
441 if (bm->have_mask)
442 XFreePixmap (dpyinfo->display, bm->mask);
443 #endif /* HAVE_X_WINDOWS */
444
445 #ifdef HAVE_NTGUI
446 DeleteObject (bm->pixmap);
447 #endif /* HAVE_NTGUI */
448
449 #ifdef MAC_OS
450 xfree (bm->bitmap_data); /* Added ++kfs */
451 bm->bitmap_data = NULL;
452 #endif /* MAC_OS */
453
454 if (bm->file)
455 {
456 xfree (bm->file);
457 bm->file = NULL;
458 }
459 }
460
461 /* Remove reference to bitmap with id number ID. */
462
463 void
464 x_destroy_bitmap (f, id)
465 FRAME_PTR f;
466 int id;
467 {
468 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
469
470 if (id > 0)
471 {
472 Bitmap_Record *bm = &dpyinfo->bitmaps[id - 1];
473
474 if (--bm->refcount == 0)
475 {
476 BLOCK_INPUT;
477 Free_Bitmap_Record (dpyinfo, bm);
478 UNBLOCK_INPUT;
479 }
480 }
481 }
482
483 /* Free all the bitmaps for the display specified by DPYINFO. */
484
485 void
486 x_destroy_all_bitmaps (dpyinfo)
487 Display_Info *dpyinfo;
488 {
489 int i;
490 Bitmap_Record *bm = dpyinfo->bitmaps;
491
492 for (i = 0; i < dpyinfo->bitmaps_last; i++, bm++)
493 if (bm->refcount > 0)
494 Free_Bitmap_Record (dpyinfo, bm);
495
496 dpyinfo->bitmaps_last = 0;
497 }
498
499
500 #ifdef HAVE_X_WINDOWS
501
502 /* Useful functions defined in the section
503 `Image type independent image structures' below. */
504
505 static unsigned long four_corners_best P_ ((XImagePtr ximg, unsigned long width,
506 unsigned long height));
507
508 static int x_create_x_image_and_pixmap P_ ((struct frame *f, int width, int height,
509 int depth, XImagePtr *ximg,
510 Pixmap *pixmap));
511
512 static void x_destroy_x_image P_ ((XImagePtr ximg));
513
514
515 /* Create a mask of a bitmap. Note is this not a perfect mask.
516 It's nicer with some borders in this context */
517
518 int
519 x_create_bitmap_mask (f, id)
520 struct frame *f;
521 int id;
522 {
523 Pixmap pixmap, mask;
524 XImagePtr ximg, mask_img;
525 unsigned long width, height;
526 int result;
527 unsigned long bg;
528 unsigned long x, y, xp, xm, yp, ym;
529 GC gc;
530
531 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
532
533 if (!(id > 0))
534 return -1;
535
536 pixmap = x_bitmap_pixmap (f, id);
537 width = x_bitmap_width (f, id);
538 height = x_bitmap_height (f, id);
539
540 BLOCK_INPUT;
541 ximg = XGetImage (FRAME_X_DISPLAY (f), pixmap, 0, 0, width, height,
542 ~0, ZPixmap);
543
544 if (!ximg)
545 {
546 UNBLOCK_INPUT;
547 return -1;
548 }
549
550 result = x_create_x_image_and_pixmap (f, width, height, 1, &mask_img, &mask);
551
552 UNBLOCK_INPUT;
553 if (!result)
554 {
555 XDestroyImage (ximg);
556 return -1;
557 }
558
559 bg = four_corners_best (ximg, width, height);
560
561 for (y = 0; y < ximg->height; ++y)
562 {
563 for (x = 0; x < ximg->width; ++x)
564 {
565 xp = x != ximg->width - 1 ? x + 1 : 0;
566 xm = x != 0 ? x - 1 : ximg->width - 1;
567 yp = y != ximg->height - 1 ? y + 1 : 0;
568 ym = y != 0 ? y - 1 : ximg->height - 1;
569 if (XGetPixel (ximg, x, y) == bg
570 && XGetPixel (ximg, x, yp) == bg
571 && XGetPixel (ximg, x, ym) == bg
572 && XGetPixel (ximg, xp, y) == bg
573 && XGetPixel (ximg, xp, yp) == bg
574 && XGetPixel (ximg, xp, ym) == bg
575 && XGetPixel (ximg, xm, y) == bg
576 && XGetPixel (ximg, xm, yp) == bg
577 && XGetPixel (ximg, xm, ym) == bg)
578 XPutPixel (mask_img, x, y, 0);
579 else
580 XPutPixel (mask_img, x, y, 1);
581 }
582 }
583
584 xassert (interrupt_input_blocked);
585 gc = XCreateGC (FRAME_X_DISPLAY (f), mask, 0, NULL);
586 XPutImage (FRAME_X_DISPLAY (f), mask, gc, mask_img, 0, 0, 0, 0,
587 width, height);
588 XFreeGC (FRAME_X_DISPLAY (f), gc);
589
590 dpyinfo->bitmaps[id - 1].have_mask = 1;
591 dpyinfo->bitmaps[id - 1].mask = mask;
592
593 XDestroyImage (ximg);
594 x_destroy_x_image (mask_img);
595
596 return 0;
597 }
598
599 #endif /* HAVE_X_WINDOWS */
600
601
602 /***********************************************************************
603 Image types
604 ***********************************************************************/
605
606 /* Value is the number of elements of vector VECTOR. */
607
608 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
609
610 /* List of supported image types. Use define_image_type to add new
611 types. Use lookup_image_type to find a type for a given symbol. */
612
613 static struct image_type *image_types;
614
615 /* A list of symbols, one for each supported image type. */
616
617 Lisp_Object Vimage_types;
618
619 /* An alist of image types and libraries that implement the type. */
620
621 Lisp_Object Vimage_library_alist;
622
623 /* Cache for delayed-loading image types. */
624
625 static Lisp_Object Vimage_type_cache;
626
627 /* The symbol `xbm' which is used as the type symbol for XBM images. */
628
629 Lisp_Object Qxbm;
630
631 /* Keywords. */
632
633 extern Lisp_Object QCwidth, QCheight, QCforeground, QCbackground, QCfile;
634 extern Lisp_Object QCdata, QCtype;
635 extern Lisp_Object Qcenter;
636 Lisp_Object QCascent, QCmargin, QCrelief;
637 Lisp_Object QCconversion, QCcolor_symbols, QCheuristic_mask;
638 Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask;
639
640 /* Other symbols. */
641
642 Lisp_Object Qlaplace, Qemboss, Qedge_detection, Qheuristic;
643
644 /* Time in seconds after which images should be removed from the cache
645 if not displayed. */
646
647 Lisp_Object Vimage_cache_eviction_delay;
648
649 /* Function prototypes. */
650
651 static Lisp_Object define_image_type P_ ((struct image_type *type, int loaded));
652 static struct image_type *lookup_image_type P_ ((Lisp_Object symbol));
653 static void image_error P_ ((char *format, Lisp_Object, Lisp_Object));
654 static void x_laplace P_ ((struct frame *, struct image *));
655 static void x_emboss P_ ((struct frame *, struct image *));
656 static int x_build_heuristic_mask P_ ((struct frame *, struct image *,
657 Lisp_Object));
658
659 #define CACHE_IMAGE_TYPE(type, status) \
660 do { Vimage_type_cache = Fcons (Fcons (type, status), Vimage_type_cache); } while (0)
661
662 #define ADD_IMAGE_TYPE(type) \
663 do { Vimage_types = Fcons (type, Vimage_types); } while (0)
664
665 /* Define a new image type from TYPE. This adds a copy of TYPE to
666 image_types and caches the loading status of TYPE. */
667
668 static Lisp_Object
669 define_image_type (type, loaded)
670 struct image_type *type;
671 int loaded;
672 {
673 Lisp_Object success;
674
675 if (!loaded)
676 success = Qnil;
677 else
678 {
679 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
680 The initialized data segment is read-only. */
681 struct image_type *p = (struct image_type *) xmalloc (sizeof *p);
682 bcopy (type, p, sizeof *p);
683 p->next = image_types;
684 image_types = p;
685 success = Qt;
686 }
687
688 CACHE_IMAGE_TYPE (*type->type, success);
689 return success;
690 }
691
692
693 /* Look up image type SYMBOL, and return a pointer to its image_type
694 structure. Value is null if SYMBOL is not a known image type. */
695
696 static INLINE struct image_type *
697 lookup_image_type (symbol)
698 Lisp_Object symbol;
699 {
700 struct image_type *type;
701
702 /* We must initialize the image-type if it hasn't been already. */
703 if (NILP (Finit_image_library (symbol, Vimage_library_alist)))
704 return 0; /* unimplemented */
705
706 for (type = image_types; type; type = type->next)
707 if (EQ (symbol, *type->type))
708 break;
709
710 return type;
711 }
712
713
714 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
715 valid image specification is a list whose car is the symbol
716 `image', and whose rest is a property list. The property list must
717 contain a value for key `:type'. That value must be the name of a
718 supported image type. The rest of the property list depends on the
719 image type. */
720
721 int
722 valid_image_p (object)
723 Lisp_Object object;
724 {
725 int valid_p = 0;
726
727 if (IMAGEP (object))
728 {
729 Lisp_Object tem;
730
731 for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem))
732 if (EQ (XCAR (tem), QCtype))
733 {
734 tem = XCDR (tem);
735 if (CONSP (tem) && SYMBOLP (XCAR (tem)))
736 {
737 struct image_type *type;
738 type = lookup_image_type (XCAR (tem));
739 if (type)
740 valid_p = type->valid_p (object);
741 }
742
743 break;
744 }
745 }
746
747 return valid_p;
748 }
749
750
751 /* Log error message with format string FORMAT and argument ARG.
752 Signaling an error, e.g. when an image cannot be loaded, is not a
753 good idea because this would interrupt redisplay, and the error
754 message display would lead to another redisplay. This function
755 therefore simply displays a message. */
756
757 static void
758 image_error (format, arg1, arg2)
759 char *format;
760 Lisp_Object arg1, arg2;
761 {
762 add_to_log (format, arg1, arg2);
763 }
764
765
766 \f
767 /***********************************************************************
768 Image specifications
769 ***********************************************************************/
770
771 enum image_value_type
772 {
773 IMAGE_DONT_CHECK_VALUE_TYPE,
774 IMAGE_STRING_VALUE,
775 IMAGE_STRING_OR_NIL_VALUE,
776 IMAGE_SYMBOL_VALUE,
777 IMAGE_POSITIVE_INTEGER_VALUE,
778 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
779 IMAGE_NON_NEGATIVE_INTEGER_VALUE,
780 IMAGE_ASCENT_VALUE,
781 IMAGE_INTEGER_VALUE,
782 IMAGE_FUNCTION_VALUE,
783 IMAGE_NUMBER_VALUE,
784 IMAGE_BOOL_VALUE
785 };
786
787 /* Structure used when parsing image specifications. */
788
789 struct image_keyword
790 {
791 /* Name of keyword. */
792 char *name;
793
794 /* The type of value allowed. */
795 enum image_value_type type;
796
797 /* Non-zero means key must be present. */
798 int mandatory_p;
799
800 /* Used to recognize duplicate keywords in a property list. */
801 int count;
802
803 /* The value that was found. */
804 Lisp_Object value;
805 };
806
807
808 static int parse_image_spec P_ ((Lisp_Object, struct image_keyword *,
809 int, Lisp_Object));
810 static Lisp_Object image_spec_value P_ ((Lisp_Object, Lisp_Object, int *));
811
812
813 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
814 has the format (image KEYWORD VALUE ...). One of the keyword/
815 value pairs must be `:type TYPE'. KEYWORDS is a vector of
816 image_keywords structures of size NKEYWORDS describing other
817 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
818
819 static int
820 parse_image_spec (spec, keywords, nkeywords, type)
821 Lisp_Object spec;
822 struct image_keyword *keywords;
823 int nkeywords;
824 Lisp_Object type;
825 {
826 int i;
827 Lisp_Object plist;
828
829 if (!IMAGEP (spec))
830 return 0;
831
832 plist = XCDR (spec);
833 while (CONSP (plist))
834 {
835 Lisp_Object key, value;
836
837 /* First element of a pair must be a symbol. */
838 key = XCAR (plist);
839 plist = XCDR (plist);
840 if (!SYMBOLP (key))
841 return 0;
842
843 /* There must follow a value. */
844 if (!CONSP (plist))
845 return 0;
846 value = XCAR (plist);
847 plist = XCDR (plist);
848
849 /* Find key in KEYWORDS. Error if not found. */
850 for (i = 0; i < nkeywords; ++i)
851 if (strcmp (keywords[i].name, SDATA (SYMBOL_NAME (key))) == 0)
852 break;
853
854 if (i == nkeywords)
855 continue;
856
857 /* Record that we recognized the keyword. If a keywords
858 was found more than once, it's an error. */
859 keywords[i].value = value;
860 ++keywords[i].count;
861
862 if (keywords[i].count > 1)
863 return 0;
864
865 /* Check type of value against allowed type. */
866 switch (keywords[i].type)
867 {
868 case IMAGE_STRING_VALUE:
869 if (!STRINGP (value))
870 return 0;
871 break;
872
873 case IMAGE_STRING_OR_NIL_VALUE:
874 if (!STRINGP (value) && !NILP (value))
875 return 0;
876 break;
877
878 case IMAGE_SYMBOL_VALUE:
879 if (!SYMBOLP (value))
880 return 0;
881 break;
882
883 case IMAGE_POSITIVE_INTEGER_VALUE:
884 if (!INTEGERP (value) || XINT (value) <= 0)
885 return 0;
886 break;
887
888 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR:
889 if (INTEGERP (value) && XINT (value) >= 0)
890 break;
891 if (CONSP (value)
892 && INTEGERP (XCAR (value)) && INTEGERP (XCDR (value))
893 && XINT (XCAR (value)) >= 0 && XINT (XCDR (value)) >= 0)
894 break;
895 return 0;
896
897 case IMAGE_ASCENT_VALUE:
898 if (SYMBOLP (value) && EQ (value, Qcenter))
899 break;
900 else if (INTEGERP (value)
901 && XINT (value) >= 0
902 && XINT (value) <= 100)
903 break;
904 return 0;
905
906 case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
907 if (!INTEGERP (value) || XINT (value) < 0)
908 return 0;
909 break;
910
911 case IMAGE_DONT_CHECK_VALUE_TYPE:
912 break;
913
914 case IMAGE_FUNCTION_VALUE:
915 value = indirect_function (value);
916 if (SUBRP (value)
917 || COMPILEDP (value)
918 || (CONSP (value) && EQ (XCAR (value), Qlambda)))
919 break;
920 return 0;
921
922 case IMAGE_NUMBER_VALUE:
923 if (!INTEGERP (value) && !FLOATP (value))
924 return 0;
925 break;
926
927 case IMAGE_INTEGER_VALUE:
928 if (!INTEGERP (value))
929 return 0;
930 break;
931
932 case IMAGE_BOOL_VALUE:
933 if (!NILP (value) && !EQ (value, Qt))
934 return 0;
935 break;
936
937 default:
938 abort ();
939 break;
940 }
941
942 if (EQ (key, QCtype) && !EQ (type, value))
943 return 0;
944 }
945
946 /* Check that all mandatory fields are present. */
947 for (i = 0; i < nkeywords; ++i)
948 if (keywords[i].mandatory_p && keywords[i].count == 0)
949 return 0;
950
951 return NILP (plist);
952 }
953
954
955 /* Return the value of KEY in image specification SPEC. Value is nil
956 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
957 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
958
959 static Lisp_Object
960 image_spec_value (spec, key, found)
961 Lisp_Object spec, key;
962 int *found;
963 {
964 Lisp_Object tail;
965
966 xassert (valid_image_p (spec));
967
968 for (tail = XCDR (spec);
969 CONSP (tail) && CONSP (XCDR (tail));
970 tail = XCDR (XCDR (tail)))
971 {
972 if (EQ (XCAR (tail), key))
973 {
974 if (found)
975 *found = 1;
976 return XCAR (XCDR (tail));
977 }
978 }
979
980 if (found)
981 *found = 0;
982 return Qnil;
983 }
984
985
986 DEFUN ("image-size", Fimage_size, Simage_size, 1, 3, 0,
987 doc: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
988 PIXELS non-nil means return the size in pixels, otherwise return the
989 size in canonical character units.
990 FRAME is the frame on which the image will be displayed. FRAME nil
991 or omitted means use the selected frame. */)
992 (spec, pixels, frame)
993 Lisp_Object spec, pixels, frame;
994 {
995 Lisp_Object size;
996
997 size = Qnil;
998 if (valid_image_p (spec))
999 {
1000 struct frame *f = check_x_frame (frame);
1001 int id = lookup_image (f, spec);
1002 struct image *img = IMAGE_FROM_ID (f, id);
1003 int width = img->width + 2 * img->hmargin;
1004 int height = img->height + 2 * img->vmargin;
1005
1006 if (NILP (pixels))
1007 size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
1008 make_float ((double) height / FRAME_LINE_HEIGHT (f)));
1009 else
1010 size = Fcons (make_number (width), make_number (height));
1011 }
1012 else
1013 error ("Invalid image specification");
1014
1015 return size;
1016 }
1017
1018
1019 DEFUN ("image-mask-p", Fimage_mask_p, Simage_mask_p, 1, 2, 0,
1020 doc: /* Return t if image SPEC has a mask bitmap.
1021 FRAME is the frame on which the image will be displayed. FRAME nil
1022 or omitted means use the selected frame. */)
1023 (spec, frame)
1024 Lisp_Object spec, frame;
1025 {
1026 Lisp_Object mask;
1027
1028 mask = Qnil;
1029 if (valid_image_p (spec))
1030 {
1031 struct frame *f = check_x_frame (frame);
1032 int id = lookup_image (f, spec);
1033 struct image *img = IMAGE_FROM_ID (f, id);
1034 if (img->mask)
1035 mask = Qt;
1036 }
1037 else
1038 error ("Invalid image specification");
1039
1040 return mask;
1041 }
1042
1043 \f
1044 /***********************************************************************
1045 Image type independent image structures
1046 ***********************************************************************/
1047
1048 static struct image *make_image P_ ((Lisp_Object spec, unsigned hash));
1049 static void free_image P_ ((struct frame *f, struct image *img));
1050
1051
1052 /* Allocate and return a new image structure for image specification
1053 SPEC. SPEC has a hash value of HASH. */
1054
1055 static struct image *
1056 make_image (spec, hash)
1057 Lisp_Object spec;
1058 unsigned hash;
1059 {
1060 struct image *img = (struct image *) xmalloc (sizeof *img);
1061
1062 xassert (valid_image_p (spec));
1063 bzero (img, sizeof *img);
1064 img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
1065 xassert (img->type != NULL);
1066 img->spec = spec;
1067 img->data.lisp_val = Qnil;
1068 img->ascent = DEFAULT_IMAGE_ASCENT;
1069 img->hash = hash;
1070 return img;
1071 }
1072
1073
1074 /* Free image IMG which was used on frame F, including its resources. */
1075
1076 static void
1077 free_image (f, img)
1078 struct frame *f;
1079 struct image *img;
1080 {
1081 if (img)
1082 {
1083 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1084
1085 /* Remove IMG from the hash table of its cache. */
1086 if (img->prev)
1087 img->prev->next = img->next;
1088 else
1089 c->buckets[img->hash % IMAGE_CACHE_BUCKETS_SIZE] = img->next;
1090
1091 if (img->next)
1092 img->next->prev = img->prev;
1093
1094 c->images[img->id] = NULL;
1095
1096 /* Free resources, then free IMG. */
1097 img->type->free (f, img);
1098 xfree (img);
1099 }
1100 }
1101
1102
1103 /* Prepare image IMG for display on frame F. Must be called before
1104 drawing an image. */
1105
1106 void
1107 prepare_image_for_display (f, img)
1108 struct frame *f;
1109 struct image *img;
1110 {
1111 EMACS_TIME t;
1112
1113 /* We're about to display IMG, so set its timestamp to `now'. */
1114 EMACS_GET_TIME (t);
1115 img->timestamp = EMACS_SECS (t);
1116
1117 /* If IMG doesn't have a pixmap yet, load it now, using the image
1118 type dependent loader function. */
1119 if (img->pixmap == NO_PIXMAP && !img->load_failed_p)
1120 img->load_failed_p = img->type->load (f, img) == 0;
1121 }
1122
1123
1124 /* Value is the number of pixels for the ascent of image IMG when
1125 drawn in face FACE. */
1126
1127 int
1128 image_ascent (img, face, slice)
1129 struct image *img;
1130 struct face *face;
1131 struct glyph_slice *slice;
1132 {
1133 int height;
1134 int ascent;
1135
1136 if (slice->height == img->height)
1137 height = img->height + img->vmargin;
1138 else if (slice->y == 0)
1139 height = slice->height + img->vmargin;
1140 else
1141 height = slice->height;
1142
1143 if (img->ascent == CENTERED_IMAGE_ASCENT)
1144 {
1145 if (face->font)
1146 {
1147 #ifdef HAVE_NTGUI
1148 /* W32 specific version. Why?. ++kfs */
1149 ascent = height / 2 - (FONT_DESCENT(face->font)
1150 - FONT_BASE(face->font)) / 2;
1151 #else
1152 /* This expression is arranged so that if the image can't be
1153 exactly centered, it will be moved slightly up. This is
1154 because a typical font is `top-heavy' (due to the presence
1155 uppercase letters), so the image placement should err towards
1156 being top-heavy too. It also just generally looks better. */
1157 ascent = (height + face->font->ascent - face->font->descent + 1) / 2;
1158 #endif /* HAVE_NTGUI */
1159 }
1160 else
1161 ascent = height / 2;
1162 }
1163 else
1164 ascent = (int) (height * img->ascent / 100.0);
1165
1166 return ascent;
1167 }
1168
1169 \f
1170 /* Image background colors. */
1171
1172 /* Find the "best" corner color of a bitmap.
1173 On W32, XIMG is assumed to a device context with the bitmap selected. */
1174
1175 static RGB_PIXEL_COLOR
1176 four_corners_best (ximg, width, height)
1177 XImagePtr_or_DC ximg;
1178 unsigned long width, height;
1179 {
1180 RGB_PIXEL_COLOR corners[4], best;
1181 int i, best_count;
1182
1183 /* Get the colors at the corners of ximg. */
1184 corners[0] = GET_PIXEL (ximg, 0, 0);
1185 corners[1] = GET_PIXEL (ximg, width - 1, 0);
1186 corners[2] = GET_PIXEL (ximg, width - 1, height - 1);
1187 corners[3] = GET_PIXEL (ximg, 0, height - 1);
1188
1189 /* Choose the most frequently found color as background. */
1190 for (i = best_count = 0; i < 4; ++i)
1191 {
1192 int j, n;
1193
1194 for (j = n = 0; j < 4; ++j)
1195 if (corners[i] == corners[j])
1196 ++n;
1197
1198 if (n > best_count)
1199 best = corners[i], best_count = n;
1200 }
1201
1202 return best;
1203 }
1204
1205 /* Portability macros */
1206
1207 #ifdef HAVE_NTGUI
1208
1209 #define Destroy_Image(img_dc, prev) \
1210 do { SelectObject (img_dc, prev); DeleteDC (img_dc); } while (0)
1211
1212 #define Free_Pixmap(display, pixmap) \
1213 DeleteObject (pixmap)
1214
1215 #else
1216
1217 #define Destroy_Image(ximg, dummy) \
1218 XDestroyImage (ximg)
1219
1220 #define Free_Pixmap(display, pixmap) \
1221 XFreePixmap (display, pixmap)
1222
1223 #endif /* HAVE_NTGUI */
1224
1225
1226 /* Return the `background' field of IMG. If IMG doesn't have one yet,
1227 it is guessed heuristically. If non-zero, XIMG is an existing
1228 XImage object (or device context with the image selected on W32) to
1229 use for the heuristic. */
1230
1231 RGB_PIXEL_COLOR
1232 image_background (img, f, ximg)
1233 struct image *img;
1234 struct frame *f;
1235 XImagePtr_or_DC ximg;
1236 {
1237 if (! img->background_valid)
1238 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1239 {
1240 int free_ximg = !ximg;
1241 #ifdef HAVE_NTGUI
1242 HGDIOBJ prev;
1243 #endif /* HAVE_NTGUI */
1244
1245 if (free_ximg)
1246 {
1247 #ifndef HAVE_NTGUI
1248 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
1249 0, 0, img->width, img->height, ~0, ZPixmap);
1250 #else
1251 HDC frame_dc = get_frame_dc (f);
1252 ximg = CreateCompatibleDC (frame_dc);
1253 release_frame_dc (f, frame_dc);
1254 prev = SelectObject (ximg, img->pixmap);
1255 #endif /* !HAVE_NTGUI */
1256 }
1257
1258 img->background = four_corners_best (ximg, img->width, img->height);
1259
1260 if (free_ximg)
1261 Destroy_Image (ximg, prev);
1262
1263 img->background_valid = 1;
1264 }
1265
1266 return img->background;
1267 }
1268
1269 /* Return the `background_transparent' field of IMG. If IMG doesn't
1270 have one yet, it is guessed heuristically. If non-zero, MASK is an
1271 existing XImage object to use for the heuristic. */
1272
1273 int
1274 image_background_transparent (img, f, mask)
1275 struct image *img;
1276 struct frame *f;
1277 XImagePtr_or_DC mask;
1278 {
1279 if (! img->background_transparent_valid)
1280 /* IMG doesn't have a background yet, try to guess a reasonable value. */
1281 {
1282 if (img->mask)
1283 {
1284 int free_mask = !mask;
1285 #ifdef HAVE_NTGUI
1286 HGDIOBJ prev;
1287 #endif /* HAVE_NTGUI */
1288
1289 if (free_mask)
1290 {
1291 #ifndef HAVE_NTGUI
1292 mask = XGetImage (FRAME_X_DISPLAY (f), img->mask,
1293 0, 0, img->width, img->height, ~0, ZPixmap);
1294 #else
1295 HDC frame_dc = get_frame_dc (f);
1296 mask = CreateCompatibleDC (frame_dc);
1297 release_frame_dc (f, frame_dc);
1298 prev = SelectObject (mask, img->mask);
1299 #endif /* HAVE_NTGUI */
1300 }
1301
1302 img->background_transparent
1303 = (four_corners_best (mask, img->width, img->height) == PIX_MASK_RETAIN (f));
1304
1305 if (free_mask)
1306 Destroy_Image (mask, prev);
1307 }
1308 else
1309 img->background_transparent = 0;
1310
1311 img->background_transparent_valid = 1;
1312 }
1313
1314 return img->background_transparent;
1315 }
1316
1317 \f
1318 /***********************************************************************
1319 Helper functions for X image types
1320 ***********************************************************************/
1321
1322 static void x_clear_image_1 P_ ((struct frame *, struct image *, int,
1323 int, int));
1324 static void x_clear_image P_ ((struct frame *f, struct image *img));
1325 static unsigned long x_alloc_image_color P_ ((struct frame *f,
1326 struct image *img,
1327 Lisp_Object color_name,
1328 unsigned long dflt));
1329
1330
1331 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
1332 free the pixmap if any. MASK_P non-zero means clear the mask
1333 pixmap if any. COLORS_P non-zero means free colors allocated for
1334 the image, if any. */
1335
1336 static void
1337 x_clear_image_1 (f, img, pixmap_p, mask_p, colors_p)
1338 struct frame *f;
1339 struct image *img;
1340 int pixmap_p, mask_p, colors_p;
1341 {
1342 if (pixmap_p && img->pixmap)
1343 {
1344 Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
1345 img->pixmap = NO_PIXMAP;
1346 img->background_valid = 0;
1347 }
1348
1349 if (mask_p && img->mask)
1350 {
1351 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
1352 img->mask = NO_PIXMAP;
1353 img->background_transparent_valid = 0;
1354 }
1355
1356 if (colors_p && img->ncolors)
1357 {
1358 /* MAC_TODO: color table support. */
1359 /* W32_TODO: color table support. */
1360 #ifdef HAVE_X_WINDOWS
1361 x_free_colors (f, img->colors, img->ncolors);
1362 #endif /* HAVE_X_WINDOWS */
1363 xfree (img->colors);
1364 img->colors = NULL;
1365 img->ncolors = 0;
1366 }
1367 }
1368
1369 /* Free X resources of image IMG which is used on frame F. */
1370
1371 static void
1372 x_clear_image (f, img)
1373 struct frame *f;
1374 struct image *img;
1375 {
1376 BLOCK_INPUT;
1377 x_clear_image_1 (f, img, 1, 1, 1);
1378 UNBLOCK_INPUT;
1379 }
1380
1381
1382 /* Allocate color COLOR_NAME for image IMG on frame F. If color
1383 cannot be allocated, use DFLT. Add a newly allocated color to
1384 IMG->colors, so that it can be freed again. Value is the pixel
1385 color. */
1386
1387 static unsigned long
1388 x_alloc_image_color (f, img, color_name, dflt)
1389 struct frame *f;
1390 struct image *img;
1391 Lisp_Object color_name;
1392 unsigned long dflt;
1393 {
1394 XColor color;
1395 unsigned long result;
1396
1397 xassert (STRINGP (color_name));
1398
1399 if (x_defined_color (f, SDATA (color_name), &color, 1))
1400 {
1401 /* This isn't called frequently so we get away with simply
1402 reallocating the color vector to the needed size, here. */
1403 ++img->ncolors;
1404 img->colors =
1405 (unsigned long *) xrealloc (img->colors,
1406 img->ncolors * sizeof *img->colors);
1407 img->colors[img->ncolors - 1] = color.pixel;
1408 result = color.pixel;
1409 }
1410 else
1411 result = dflt;
1412
1413 return result;
1414 }
1415
1416
1417 \f
1418 /***********************************************************************
1419 Image Cache
1420 ***********************************************************************/
1421
1422 static void cache_image P_ ((struct frame *f, struct image *img));
1423 static void postprocess_image P_ ((struct frame *, struct image *));
1424
1425 /* Return a new, initialized image cache that is allocated from the
1426 heap. Call free_image_cache to free an image cache. */
1427
1428 struct image_cache *
1429 make_image_cache ()
1430 {
1431 struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
1432 int size;
1433
1434 bzero (c, sizeof *c);
1435 c->size = 50;
1436 c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
1437 size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
1438 c->buckets = (struct image **) xmalloc (size);
1439 bzero (c->buckets, size);
1440 return c;
1441 }
1442
1443
1444 /* Free image cache of frame F. Be aware that X frames share images
1445 caches. */
1446
1447 void
1448 free_image_cache (f)
1449 struct frame *f;
1450 {
1451 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1452 if (c)
1453 {
1454 int i;
1455
1456 /* Cache should not be referenced by any frame when freed. */
1457 xassert (c->refcount == 0);
1458
1459 for (i = 0; i < c->used; ++i)
1460 free_image (f, c->images[i]);
1461 xfree (c->images);
1462 xfree (c->buckets);
1463 xfree (c);
1464 FRAME_X_IMAGE_CACHE (f) = NULL;
1465 }
1466 }
1467
1468
1469 /* Clear image cache of frame F. FORCE_P non-zero means free all
1470 images. FORCE_P zero means clear only images that haven't been
1471 displayed for some time. Should be called from time to time to
1472 reduce the number of loaded images. If image-eviction-seconds is
1473 non-nil, this frees images in the cache which weren't displayed for
1474 at least that many seconds. */
1475
1476 void
1477 clear_image_cache (f, force_p)
1478 struct frame *f;
1479 int force_p;
1480 {
1481 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1482
1483 if (c && INTEGERP (Vimage_cache_eviction_delay))
1484 {
1485 EMACS_TIME t;
1486 unsigned long old;
1487 int i, nfreed;
1488
1489 EMACS_GET_TIME (t);
1490 old = EMACS_SECS (t) - XFASTINT (Vimage_cache_eviction_delay);
1491
1492 /* Block input so that we won't be interrupted by a SIGIO
1493 while being in an inconsistent state. */
1494 BLOCK_INPUT;
1495
1496 for (i = nfreed = 0; i < c->used; ++i)
1497 {
1498 struct image *img = c->images[i];
1499 if (img != NULL
1500 && (force_p || img->timestamp < old))
1501 {
1502 free_image (f, img);
1503 ++nfreed;
1504 }
1505 }
1506
1507 /* We may be clearing the image cache because, for example,
1508 Emacs was iconified for a longer period of time. In that
1509 case, current matrices may still contain references to
1510 images freed above. So, clear these matrices. */
1511 if (nfreed)
1512 {
1513 Lisp_Object tail, frame;
1514
1515 FOR_EACH_FRAME (tail, frame)
1516 {
1517 struct frame *f = XFRAME (frame);
1518 if (FRAME_WINDOW_P (f)
1519 && FRAME_X_IMAGE_CACHE (f) == c)
1520 clear_current_matrices (f);
1521 }
1522
1523 ++windows_or_buffers_changed;
1524 }
1525
1526 UNBLOCK_INPUT;
1527 }
1528 }
1529
1530
1531 DEFUN ("clear-image-cache", Fclear_image_cache, Sclear_image_cache,
1532 0, 1, 0,
1533 doc: /* Clear the image cache of FRAME.
1534 FRAME nil or omitted means use the selected frame.
1535 FRAME t means clear the image caches of all frames. */)
1536 (frame)
1537 Lisp_Object frame;
1538 {
1539 if (EQ (frame, Qt))
1540 {
1541 Lisp_Object tail;
1542
1543 FOR_EACH_FRAME (tail, frame)
1544 if (FRAME_WINDOW_P (XFRAME (frame)))
1545 clear_image_cache (XFRAME (frame), 1);
1546 }
1547 else
1548 clear_image_cache (check_x_frame (frame), 1);
1549
1550 return Qnil;
1551 }
1552
1553
1554 /* Compute masks and transform image IMG on frame F, as specified
1555 by the image's specification, */
1556
1557 static void
1558 postprocess_image (f, img)
1559 struct frame *f;
1560 struct image *img;
1561 {
1562 /* Manipulation of the image's mask. */
1563 if (img->pixmap)
1564 {
1565 Lisp_Object conversion, spec;
1566 Lisp_Object mask;
1567
1568 spec = img->spec;
1569
1570 /* `:heuristic-mask t'
1571 `:mask heuristic'
1572 means build a mask heuristically.
1573 `:heuristic-mask (R G B)'
1574 `:mask (heuristic (R G B))'
1575 means build a mask from color (R G B) in the
1576 image.
1577 `:mask nil'
1578 means remove a mask, if any. */
1579
1580 mask = image_spec_value (spec, QCheuristic_mask, NULL);
1581 if (!NILP (mask))
1582 x_build_heuristic_mask (f, img, mask);
1583 else
1584 {
1585 int found_p;
1586
1587 mask = image_spec_value (spec, QCmask, &found_p);
1588
1589 if (EQ (mask, Qheuristic))
1590 x_build_heuristic_mask (f, img, Qt);
1591 else if (CONSP (mask)
1592 && EQ (XCAR (mask), Qheuristic))
1593 {
1594 if (CONSP (XCDR (mask)))
1595 x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
1596 else
1597 x_build_heuristic_mask (f, img, XCDR (mask));
1598 }
1599 else if (NILP (mask) && found_p && img->mask)
1600 {
1601 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
1602 img->mask = NO_PIXMAP;
1603 }
1604 }
1605
1606
1607 /* Should we apply an image transformation algorithm? */
1608 conversion = image_spec_value (spec, QCconversion, NULL);
1609 if (EQ (conversion, Qdisabled))
1610 x_disable_image (f, img);
1611 else if (EQ (conversion, Qlaplace))
1612 x_laplace (f, img);
1613 else if (EQ (conversion, Qemboss))
1614 x_emboss (f, img);
1615 else if (CONSP (conversion)
1616 && EQ (XCAR (conversion), Qedge_detection))
1617 {
1618 Lisp_Object tem;
1619 tem = XCDR (conversion);
1620 if (CONSP (tem))
1621 x_edge_detection (f, img,
1622 Fplist_get (tem, QCmatrix),
1623 Fplist_get (tem, QCcolor_adjustment));
1624 }
1625 }
1626 }
1627
1628
1629 /* Return the id of image with Lisp specification SPEC on frame F.
1630 SPEC must be a valid Lisp image specification (see valid_image_p). */
1631
1632 int
1633 lookup_image (f, spec)
1634 struct frame *f;
1635 Lisp_Object spec;
1636 {
1637 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1638 struct image *img;
1639 int i;
1640 unsigned hash;
1641 struct gcpro gcpro1;
1642 EMACS_TIME now;
1643
1644 /* F must be a window-system frame, and SPEC must be a valid image
1645 specification. */
1646 xassert (FRAME_WINDOW_P (f));
1647 xassert (valid_image_p (spec));
1648
1649 GCPRO1 (spec);
1650
1651 /* Look up SPEC in the hash table of the image cache. */
1652 hash = sxhash (spec, 0);
1653 i = hash % IMAGE_CACHE_BUCKETS_SIZE;
1654
1655 for (img = c->buckets[i]; img; img = img->next)
1656 if (img->hash == hash && !NILP (Fequal (img->spec, spec)))
1657 break;
1658
1659 /* If not found, create a new image and cache it. */
1660 if (img == NULL)
1661 {
1662 extern Lisp_Object Qpostscript;
1663
1664 BLOCK_INPUT;
1665 img = make_image (spec, hash);
1666 cache_image (f, img);
1667 img->load_failed_p = img->type->load (f, img) == 0;
1668
1669 /* If we can't load the image, and we don't have a width and
1670 height, use some arbitrary width and height so that we can
1671 draw a rectangle for it. */
1672 if (img->load_failed_p)
1673 {
1674 Lisp_Object value;
1675
1676 value = image_spec_value (spec, QCwidth, NULL);
1677 img->width = (INTEGERP (value)
1678 ? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
1679 value = image_spec_value (spec, QCheight, NULL);
1680 img->height = (INTEGERP (value)
1681 ? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
1682 }
1683 else
1684 {
1685 /* Handle image type independent image attributes
1686 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
1687 `:background COLOR'. */
1688 Lisp_Object ascent, margin, relief, bg;
1689
1690 ascent = image_spec_value (spec, QCascent, NULL);
1691 if (INTEGERP (ascent))
1692 img->ascent = XFASTINT (ascent);
1693 else if (EQ (ascent, Qcenter))
1694 img->ascent = CENTERED_IMAGE_ASCENT;
1695
1696 margin = image_spec_value (spec, QCmargin, NULL);
1697 if (INTEGERP (margin) && XINT (margin) >= 0)
1698 img->vmargin = img->hmargin = XFASTINT (margin);
1699 else if (CONSP (margin) && INTEGERP (XCAR (margin))
1700 && INTEGERP (XCDR (margin)))
1701 {
1702 if (XINT (XCAR (margin)) > 0)
1703 img->hmargin = XFASTINT (XCAR (margin));
1704 if (XINT (XCDR (margin)) > 0)
1705 img->vmargin = XFASTINT (XCDR (margin));
1706 }
1707
1708 relief = image_spec_value (spec, QCrelief, NULL);
1709 if (INTEGERP (relief))
1710 {
1711 img->relief = XINT (relief);
1712 img->hmargin += abs (img->relief);
1713 img->vmargin += abs (img->relief);
1714 }
1715
1716 if (! img->background_valid)
1717 {
1718 bg = image_spec_value (img->spec, QCbackground, NULL);
1719 if (!NILP (bg))
1720 {
1721 img->background
1722 = x_alloc_image_color (f, img, bg,
1723 FRAME_BACKGROUND_PIXEL (f));
1724 img->background_valid = 1;
1725 }
1726 }
1727
1728 /* Do image transformations and compute masks, unless we
1729 don't have the image yet. */
1730 if (!EQ (*img->type->type, Qpostscript))
1731 postprocess_image (f, img);
1732 }
1733
1734 UNBLOCK_INPUT;
1735 }
1736
1737 /* We're using IMG, so set its timestamp to `now'. */
1738 EMACS_GET_TIME (now);
1739 img->timestamp = EMACS_SECS (now);
1740
1741 UNGCPRO;
1742
1743 /* Value is the image id. */
1744 return img->id;
1745 }
1746
1747
1748 /* Cache image IMG in the image cache of frame F. */
1749
1750 static void
1751 cache_image (f, img)
1752 struct frame *f;
1753 struct image *img;
1754 {
1755 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1756 int i;
1757
1758 /* Find a free slot in c->images. */
1759 for (i = 0; i < c->used; ++i)
1760 if (c->images[i] == NULL)
1761 break;
1762
1763 /* If no free slot found, maybe enlarge c->images. */
1764 if (i == c->used && c->used == c->size)
1765 {
1766 c->size *= 2;
1767 c->images = (struct image **) xrealloc (c->images,
1768 c->size * sizeof *c->images);
1769 }
1770
1771 /* Add IMG to c->images, and assign IMG an id. */
1772 c->images[i] = img;
1773 img->id = i;
1774 if (i == c->used)
1775 ++c->used;
1776
1777 /* Add IMG to the cache's hash table. */
1778 i = img->hash % IMAGE_CACHE_BUCKETS_SIZE;
1779 img->next = c->buckets[i];
1780 if (img->next)
1781 img->next->prev = img;
1782 img->prev = NULL;
1783 c->buckets[i] = img;
1784 }
1785
1786
1787 /* Call FN on every image in the image cache of frame F. Used to mark
1788 Lisp Objects in the image cache. */
1789
1790 void
1791 forall_images_in_image_cache (f, fn)
1792 struct frame *f;
1793 void (*fn) P_ ((struct image *img));
1794 {
1795 if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f))
1796 {
1797 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
1798 if (c)
1799 {
1800 int i;
1801 for (i = 0; i < c->used; ++i)
1802 if (c->images[i])
1803 fn (c->images[i]);
1804 }
1805 }
1806 }
1807
1808
1809 \f
1810 /***********************************************************************
1811 X / MAC / W32 support code
1812 ***********************************************************************/
1813
1814 #ifdef HAVE_NTGUI
1815
1816 /* Macro for defining functions that will be loaded from image DLLs. */
1817 #define DEF_IMGLIB_FN(func) int (FAR CDECL *fn_##func)()
1818
1819 /* Macro for loading those image functions from the library. */
1820 #define LOAD_IMGLIB_FN(lib,func) { \
1821 fn_##func = (void *) GetProcAddress (lib, #func); \
1822 if (!fn_##func) return 0; \
1823 }
1824
1825 /* Load a DLL implementing an image type.
1826 The `image-library-alist' variable associates a symbol,
1827 identifying an image type, to a list of possible filenames.
1828 The function returns NULL if no library could be loaded for
1829 the given image type, or if the library was previously loaded;
1830 else the handle of the DLL. */
1831 static HMODULE
1832 w32_delayed_load (Lisp_Object libraries, Lisp_Object type)
1833 {
1834 HMODULE library = NULL;
1835
1836 if (CONSP (libraries) && NILP (Fassq (type, Vimage_type_cache)))
1837 {
1838 Lisp_Object dlls = Fassq (type, libraries);
1839
1840 if (CONSP (dlls))
1841 for (dlls = XCDR (dlls); CONSP (dlls); dlls = XCDR (dlls))
1842 {
1843 CHECK_STRING_CAR (dlls);
1844 if (library = LoadLibrary (SDATA (XCAR (dlls))))
1845 break;
1846 }
1847 }
1848
1849 return library;
1850 }
1851
1852 #endif /* HAVE_NTGUI */
1853
1854 static int x_create_x_image_and_pixmap P_ ((struct frame *, int, int, int,
1855 XImagePtr *, Pixmap *));
1856 static void x_destroy_x_image P_ ((XImagePtr));
1857 static void x_put_x_image P_ ((struct frame *, XImagePtr, Pixmap, int, int));
1858
1859
1860 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
1861 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
1862 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
1863 via xmalloc. Print error messages via image_error if an error
1864 occurs. Value is non-zero if successful.
1865
1866 On W32, a DEPTH of zero signifies a 24 bit image, otherwise DEPTH
1867 should indicate the bit depth of the image. */
1868
1869 static int
1870 x_create_x_image_and_pixmap (f, width, height, depth, ximg, pixmap)
1871 struct frame *f;
1872 int width, height, depth;
1873 XImagePtr *ximg;
1874 Pixmap *pixmap;
1875 {
1876 #ifdef HAVE_X_WINDOWS
1877 Display *display = FRAME_X_DISPLAY (f);
1878 Window window = FRAME_X_WINDOW (f);
1879 Screen *screen = FRAME_X_SCREEN (f);
1880
1881 xassert (interrupt_input_blocked);
1882
1883 if (depth <= 0)
1884 depth = DefaultDepthOfScreen (screen);
1885 *ximg = XCreateImage (display, DefaultVisualOfScreen (screen),
1886 depth, ZPixmap, 0, NULL, width, height,
1887 depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
1888 if (*ximg == NULL)
1889 {
1890 image_error ("Unable to allocate X image", Qnil, Qnil);
1891 return 0;
1892 }
1893
1894 /* Allocate image raster. */
1895 (*ximg)->data = (char *) xmalloc ((*ximg)->bytes_per_line * height);
1896
1897 /* Allocate a pixmap of the same size. */
1898 *pixmap = XCreatePixmap (display, window, width, height, depth);
1899 if (*pixmap == NO_PIXMAP)
1900 {
1901 x_destroy_x_image (*ximg);
1902 *ximg = NULL;
1903 image_error ("Unable to create X pixmap", Qnil, Qnil);
1904 return 0;
1905 }
1906
1907 return 1;
1908 #endif /* HAVE_X_WINDOWS */
1909
1910 #ifdef HAVE_NTGUI
1911
1912 BITMAPINFOHEADER *header;
1913 HDC hdc;
1914 int scanline_width_bits;
1915 int remainder;
1916 int palette_colors = 0;
1917
1918 if (depth == 0)
1919 depth = 24;
1920
1921 if (depth != 1 && depth != 4 && depth != 8
1922 && depth != 16 && depth != 24 && depth != 32)
1923 {
1924 image_error ("Invalid image bit depth specified", Qnil, Qnil);
1925 return 0;
1926 }
1927
1928 scanline_width_bits = width * depth;
1929 remainder = scanline_width_bits % 32;
1930
1931 if (remainder)
1932 scanline_width_bits += 32 - remainder;
1933
1934 /* Bitmaps with a depth less than 16 need a palette. */
1935 /* BITMAPINFO structure already contains the first RGBQUAD. */
1936 if (depth < 16)
1937 palette_colors = 1 << depth - 1;
1938
1939 *ximg = xmalloc (sizeof (XImage) + palette_colors * sizeof (RGBQUAD));
1940 if (*ximg == NULL)
1941 {
1942 image_error ("Unable to allocate memory for XImage", Qnil, Qnil);
1943 return 0;
1944 }
1945
1946 header = &((*ximg)->info.bmiHeader);
1947 bzero (&((*ximg)->info), sizeof (BITMAPINFO));
1948 header->biSize = sizeof (*header);
1949 header->biWidth = width;
1950 header->biHeight = -height; /* negative indicates a top-down bitmap. */
1951 header->biPlanes = 1;
1952 header->biBitCount = depth;
1953 header->biCompression = BI_RGB;
1954 header->biClrUsed = palette_colors;
1955
1956 /* TODO: fill in palette. */
1957 if (depth == 1)
1958 {
1959 (*ximg)->info.bmiColors[0].rgbBlue = 0;
1960 (*ximg)->info.bmiColors[0].rgbGreen = 0;
1961 (*ximg)->info.bmiColors[0].rgbRed = 0;
1962 (*ximg)->info.bmiColors[0].rgbReserved = 0;
1963 (*ximg)->info.bmiColors[1].rgbBlue = 255;
1964 (*ximg)->info.bmiColors[1].rgbGreen = 255;
1965 (*ximg)->info.bmiColors[1].rgbRed = 255;
1966 (*ximg)->info.bmiColors[1].rgbReserved = 0;
1967 }
1968
1969 hdc = get_frame_dc (f);
1970
1971 /* Create a DIBSection and raster array for the bitmap,
1972 and store its handle in *pixmap. */
1973 *pixmap = CreateDIBSection (hdc, &((*ximg)->info),
1974 (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
1975 /* casting avoids a GCC warning */
1976 (void **)&((*ximg)->data), NULL, 0);
1977
1978 /* Realize display palette and garbage all frames. */
1979 release_frame_dc (f, hdc);
1980
1981 if (*pixmap == NULL)
1982 {
1983 DWORD err = GetLastError();
1984 Lisp_Object errcode;
1985 /* All system errors are < 10000, so the following is safe. */
1986 XSETINT (errcode, (int) err);
1987 image_error ("Unable to create bitmap, error code %d", errcode, Qnil);
1988 x_destroy_x_image (*ximg);
1989 return 0;
1990 }
1991
1992 return 1;
1993
1994 #endif /* HAVE_NTGUI */
1995
1996 #ifdef MAC_OS
1997 Display *display = FRAME_X_DISPLAY (f);
1998 Window window = FRAME_X_WINDOW (f);
1999
2000 xassert (interrupt_input_blocked);
2001
2002 /* Allocate a pixmap of the same size. */
2003 *pixmap = XCreatePixmap (display, window, width, height, depth);
2004 if (*pixmap == NO_PIXMAP)
2005 {
2006 x_destroy_x_image (*ximg);
2007 *ximg = NULL;
2008 image_error ("Unable to create X pixmap", Qnil, Qnil);
2009 return 0;
2010 }
2011
2012 LockPixels (GetGWorldPixMap (*pixmap));
2013 *ximg = *pixmap;
2014 return 1;
2015
2016 #endif /* MAC_OS */
2017 }
2018
2019
2020 /* Destroy XImage XIMG. Free XIMG->data. */
2021
2022 static void
2023 x_destroy_x_image (ximg)
2024 XImagePtr ximg;
2025 {
2026 xassert (interrupt_input_blocked);
2027 if (ximg)
2028 {
2029 #ifdef HAVE_X_WINDOWS
2030 xfree (ximg->data);
2031 ximg->data = NULL;
2032 XDestroyImage (ximg);
2033 #endif /* HAVE_X_WINDOWS */
2034 #ifdef HAVE_NTGUI
2035 /* Data will be freed by DestroyObject. */
2036 ximg->data = NULL;
2037 xfree (ximg);
2038 #endif /* HAVE_NTGUI */
2039 #ifdef MAC_OS
2040 XDestroyImage (ximg);
2041 #endif /* MAC_OS */
2042 }
2043 }
2044
2045
2046 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
2047 are width and height of both the image and pixmap. */
2048
2049 static void
2050 x_put_x_image (f, ximg, pixmap, width, height)
2051 struct frame *f;
2052 XImagePtr ximg;
2053 Pixmap pixmap;
2054 int width, height;
2055 {
2056 #ifdef HAVE_X_WINDOWS
2057 GC gc;
2058
2059 xassert (interrupt_input_blocked);
2060 gc = XCreateGC (FRAME_X_DISPLAY (f), pixmap, 0, NULL);
2061 XPutImage (FRAME_X_DISPLAY (f), pixmap, gc, ximg, 0, 0, 0, 0, width, height);
2062 XFreeGC (FRAME_X_DISPLAY (f), gc);
2063 #endif /* HAVE_X_WINDOWS */
2064
2065 #ifdef HAVE_NTGUI
2066 #if 0 /* I don't think this is necessary looking at where it is used. */
2067 HDC hdc = get_frame_dc (f);
2068 SetDIBits (hdc, pixmap, 0, height, ximg->data, &(ximg->info), DIB_RGB_COLORS);
2069 release_frame_dc (f, hdc);
2070 #endif
2071 #endif /* HAVE_NTGUI */
2072
2073 #ifdef MAC_OS
2074 xassert (ximg == pixmap);
2075 #endif /* MAC_OS */
2076 }
2077
2078 \f
2079 /***********************************************************************
2080 File Handling
2081 ***********************************************************************/
2082
2083 static unsigned char *slurp_file P_ ((char *, int *));
2084
2085
2086 /* Find image file FILE. Look in data-directory, then
2087 x-bitmap-file-path. Value is the full name of the file found, or
2088 nil if not found. */
2089
2090 Lisp_Object
2091 x_find_image_file (file)
2092 Lisp_Object file;
2093 {
2094 Lisp_Object file_found, search_path;
2095 struct gcpro gcpro1, gcpro2;
2096 int fd;
2097
2098 file_found = Qnil;
2099 search_path = Fcons (Vdata_directory, Vx_bitmap_file_path);
2100 GCPRO2 (file_found, search_path);
2101
2102 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
2103 fd = openp (search_path, file, Qnil, &file_found, Qnil);
2104
2105 if (fd == -1)
2106 file_found = Qnil;
2107 else
2108 close (fd);
2109
2110 UNGCPRO;
2111 return file_found;
2112 }
2113
2114
2115 /* Read FILE into memory. Value is a pointer to a buffer allocated
2116 with xmalloc holding FILE's contents. Value is null if an error
2117 occurred. *SIZE is set to the size of the file. */
2118
2119 static unsigned char *
2120 slurp_file (file, size)
2121 char *file;
2122 int *size;
2123 {
2124 FILE *fp = NULL;
2125 unsigned char *buf = NULL;
2126 struct stat st;
2127
2128 if (stat (file, &st) == 0
2129 && (fp = fopen (file, "rb")) != NULL
2130 && (buf = (char *) xmalloc (st.st_size),
2131 fread (buf, 1, st.st_size, fp) == st.st_size))
2132 {
2133 *size = st.st_size;
2134 fclose (fp);
2135 }
2136 else
2137 {
2138 if (fp)
2139 fclose (fp);
2140 if (buf)
2141 {
2142 xfree (buf);
2143 buf = NULL;
2144 }
2145 }
2146
2147 return buf;
2148 }
2149
2150
2151 \f
2152 #ifdef MAC_OS
2153
2154 /***********************************************************************
2155 MAC Image Load Functions
2156 ***********************************************************************/
2157
2158 static int image_load_quicktime P_ ((struct frame *, struct image *img,
2159 OSType));
2160 #ifdef MAC_OSX
2161 static int image_load_quartz2d P_ ((struct frame *, struct image *img, int));
2162 #endif
2163
2164 static OSErr
2165 find_image_fsspec (specified_file, file, fss)
2166 Lisp_Object specified_file, *file;
2167 FSSpec *fss;
2168 {
2169 #if TARGET_API_MAC_CARBON
2170 FSRef fsr;
2171 #else
2172 Str255 mac_pathname;
2173 #endif
2174 OSErr err;
2175
2176 *file = x_find_image_file (specified_file);
2177 if (!STRINGP (*file))
2178 return fnfErr; /* file or directory not found;
2179 incomplete pathname */
2180 /* Try to open the image file. */
2181 #if TARGET_API_MAC_CARBON
2182 err = FSPathMakeRef (SDATA (*file), &fsr, NULL);
2183 if (err == noErr)
2184 err = FSGetCatalogInfo (&fsr, kFSCatInfoNone, NULL, NULL, fss, NULL);
2185 #else
2186 if (posix_to_mac_pathname (SDATA (*file), mac_pathname, MAXPATHLEN+1) == 0)
2187 return fnfErr;
2188 c2pstr (mac_pathname);
2189 err = FSMakeFSSpec (0, 0, mac_pathname, fss);
2190 #endif
2191 return err;
2192 }
2193
2194 static int
2195 image_load_qt_1 (f, img, type, fss, dh)
2196 struct frame *f;
2197 struct image *img;
2198 OSType type;
2199 FSSpec *fss;
2200 Handle dh;
2201 {
2202 OSErr err;
2203 GraphicsImportComponent gi;
2204 Rect rect;
2205 int width, height;
2206 short draw_all_pixels;
2207 Lisp_Object specified_bg;
2208 XColor color;
2209 XImagePtr ximg;
2210 RGBColor bg_color;
2211
2212 err = OpenADefaultComponent (GraphicsImporterComponentType,
2213 type, &gi);
2214 if (err != noErr)
2215 {
2216 image_error ("Cannot get importer component for `%s'", img->spec, Qnil);
2217 return 0;
2218 }
2219 if (dh == NULL)
2220 {
2221 /* read from file system spec */
2222 err = GraphicsImportSetDataFile (gi, fss);
2223 if (err != noErr)
2224 {
2225 image_error ("Cannot set fsspec to graphics importer for '%s'",
2226 img->spec, Qnil);
2227 goto error;
2228 }
2229 }
2230 else
2231 {
2232 /* read from data handle */
2233 err = GraphicsImportSetDataHandle (gi, dh);
2234 if (err != noErr)
2235 {
2236 image_error ("Cannot set data handle to graphics importer for `%s'",
2237 img->spec, Qnil);
2238 goto error;
2239 }
2240 }
2241 err = GraphicsImportGetNaturalBounds (gi, &rect);
2242 if (err != noErr)
2243 {
2244 image_error ("Error reading `%s'", img->spec, Qnil);
2245 goto error;
2246 }
2247 width = img->width = rect.right - rect.left;
2248 height = img->height = rect.bottom - rect.top;
2249 err = GraphicsImportDoesDrawAllPixels (gi, &draw_all_pixels);
2250 #if 0
2251 /* Don't check the error code here. It may have an undocumented
2252 value -32766. */
2253 if (err != noErr)
2254 {
2255 image_error ("Error reading `%s'", img->spec, Qnil);
2256 goto error;
2257 }
2258 #endif
2259 if (draw_all_pixels != graphicsImporterDrawsAllPixels)
2260 {
2261 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
2262 if (!STRINGP (specified_bg) ||
2263 !mac_defined_color (f, SDATA (specified_bg), &color, 0))
2264 {
2265 color.pixel = FRAME_BACKGROUND_PIXEL (f);
2266 color.red = RED16_FROM_ULONG (color.pixel);
2267 color.green = GREEN16_FROM_ULONG (color.pixel);
2268 color.blue = BLUE16_FROM_ULONG (color.pixel);
2269 }
2270 }
2271
2272 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
2273 goto error;
2274 if (draw_all_pixels != graphicsImporterDrawsAllPixels)
2275 {
2276 CGrafPtr old_port;
2277 GDHandle old_gdh;
2278
2279 GetGWorld (&old_port, &old_gdh);
2280 SetGWorld (ximg, NULL);
2281 bg_color.red = color.red;
2282 bg_color.green = color.green;
2283 bg_color.blue = color.blue;
2284 RGBBackColor (&bg_color);
2285 #if TARGET_API_MAC_CARBON
2286 GetPortBounds (ximg, &rect);
2287 EraseRect (&rect);
2288 #else
2289 EraseRect (&(ximg->portRect));
2290 #endif
2291 SetGWorld (old_port, old_gdh);
2292 }
2293 GraphicsImportSetGWorld (gi, ximg, NULL);
2294 GraphicsImportDraw (gi);
2295 CloseComponent (gi);
2296
2297 /* Maybe fill in the background field while we have ximg handy. */
2298 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
2299 IMAGE_BACKGROUND (img, f, ximg);
2300
2301 /* Put the image into the pixmap. */
2302 x_put_x_image (f, ximg, img->pixmap, width, height);
2303 x_destroy_x_image (ximg);
2304 return 1;
2305
2306 error:
2307 CloseComponent (gi);
2308 return 0;
2309 }
2310
2311
2312 /* Load an image using the QuickTime Graphics Importer.
2313 Note: The alpha channel does not work for PNG images. */
2314 static int
2315 image_load_quicktime (f, img, type)
2316 struct frame *f;
2317 struct image *img;
2318 OSType type;
2319 {
2320 Lisp_Object specified_file;
2321 Lisp_Object specified_data;
2322 OSErr err;
2323
2324 specified_file = image_spec_value (img->spec, QCfile, NULL);
2325 specified_data = image_spec_value (img->spec, QCdata, NULL);
2326
2327 if (NILP (specified_data))
2328 {
2329 /* Read from a file */
2330 Lisp_Object file;
2331 FSSpec fss;
2332
2333 err = find_image_fsspec (specified_file, &file, &fss);
2334 if (err != noErr)
2335 {
2336 if (err == fnfErr)
2337 image_error ("Cannot find image file `%s'", specified_file, Qnil);
2338 else
2339 image_error ("Cannot open `%s'", file, Qnil);
2340 return 0;
2341 }
2342 return image_load_qt_1 (f, img, type, &fss, NULL);
2343 }
2344 else
2345 {
2346 /* Memory source! */
2347 int success_p;
2348 Handle dh;
2349
2350 err = PtrToHand (SDATA (specified_data), &dh, SBYTES (specified_data));
2351 if (err != noErr)
2352 {
2353 image_error ("Cannot allocate data handle for `%s'",
2354 img->spec, Qnil);
2355 return 0;
2356 }
2357 success_p = image_load_qt_1 (f, img, type, NULL, dh);
2358 DisposeHandle (dh);
2359 return success_p;
2360 }
2361 }
2362
2363
2364 #ifdef MAC_OSX
2365 /* Load a PNG/JPEG image using Quartz 2D decoding routines.
2366 CGImageCreateWithPNGDataProvider is provided after Mac OS X 10.2.
2367 So don't use this function directly but determine at runtime
2368 whether it exists. */
2369 typedef CGImageRef (*CGImageCreateWithPNGDataProviderProcType)
2370 (CGDataProviderRef, const float [], bool, CGColorRenderingIntent);
2371 static CGImageCreateWithPNGDataProviderProcType MyCGImageCreateWithPNGDataProvider;
2372
2373
2374 static void
2375 init_image_func_pointer ()
2376 {
2377 if (NSIsSymbolNameDefined ("_CGImageCreateWithPNGDataProvider"))
2378 {
2379 MyCGImageCreateWithPNGDataProvider
2380 = (CGImageCreateWithPNGDataProviderProcType)
2381 NSAddressOfSymbol (NSLookupAndBindSymbol
2382 ("_CGImageCreateWithPNGDataProvider"));
2383 }
2384 else
2385 MyCGImageCreateWithPNGDataProvider = NULL;
2386 }
2387
2388
2389 static int
2390 image_load_quartz2d (f, img, png_p)
2391 struct frame *f;
2392 struct image *img;
2393 int png_p;
2394 {
2395 Lisp_Object file, specified_file;
2396 Lisp_Object specified_data, specified_bg;
2397 struct gcpro gcpro1;
2398 CGDataProviderRef source;
2399 CGImageRef image;
2400 int width, height;
2401 XColor color;
2402 XImagePtr ximg = NULL;
2403 CGContextRef context;
2404 CGRect rectangle;
2405
2406 /* Open the file. */
2407 specified_file = image_spec_value (img->spec, QCfile, NULL);
2408 specified_data = image_spec_value (img->spec, QCdata, NULL);
2409
2410 file = Qnil;
2411 GCPRO1 (file);
2412
2413 if (NILP (specified_data))
2414 {
2415 CFStringRef path;
2416 CFURLRef url;
2417
2418 file = x_find_image_file (specified_file);
2419 if (!STRINGP (file))
2420 {
2421 image_error ("Cannot find image file `%s'", specified_file, Qnil);
2422 UNGCPRO;
2423 return 0;
2424 }
2425 path = cfstring_create_with_string (file);
2426 url = CFURLCreateWithFileSystemPath (NULL, path,
2427 kCFURLPOSIXPathStyle, 0);
2428 CFRelease (path);
2429 source = CGDataProviderCreateWithURL (url);
2430 CFRelease (url);
2431 }
2432 else
2433 source = CGDataProviderCreateWithData (NULL, SDATA (specified_data),
2434 SBYTES (specified_data), NULL);
2435
2436 if (png_p)
2437 image = (*MyCGImageCreateWithPNGDataProvider) (source, NULL, FALSE,
2438 kCGRenderingIntentDefault);
2439 else
2440 image = CGImageCreateWithJPEGDataProvider (source, NULL, FALSE,
2441 kCGRenderingIntentDefault);
2442
2443 CGDataProviderRelease (source);
2444 if (image == NULL)
2445 {
2446 UNGCPRO;
2447 image_error ("Error reading image `%s'", img->spec, Qnil);
2448 return 0;
2449 }
2450
2451 if (png_p)
2452 {
2453 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
2454 if (!STRINGP (specified_bg) ||
2455 !mac_defined_color (f, SDATA (specified_bg), &color, 0))
2456 {
2457 color.pixel = FRAME_BACKGROUND_PIXEL (f);
2458 color.red = RED16_FROM_ULONG (color.pixel);
2459 color.green = GREEN16_FROM_ULONG (color.pixel);
2460 color.blue = BLUE16_FROM_ULONG (color.pixel);
2461 }
2462 }
2463 width = img->width = CGImageGetWidth (image);
2464 height = img->height = CGImageGetHeight (image);
2465 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
2466 {
2467 CGImageRelease (image);
2468 UNGCPRO;
2469 return 0;
2470 }
2471 rectangle = CGRectMake (0, 0, width, height);
2472 QDBeginCGContext (ximg, &context);
2473 if (png_p)
2474 {
2475 CGContextSetRGBFillColor (context, color.red / 65535.0,
2476 color.green / 65535.0,
2477 color.blue / 65535.0, 1.0);
2478 CGContextFillRect (context, rectangle);
2479 }
2480 CGContextDrawImage (context, rectangle, image);
2481 QDEndCGContext (ximg, &context);
2482 CGImageRelease (image);
2483
2484 /* Maybe fill in the background field while we have ximg handy. */
2485 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
2486 IMAGE_BACKGROUND (img, f, ximg);
2487
2488 /* Put the image into the pixmap. */
2489 x_put_x_image (f, ximg, img->pixmap, width, height);
2490 x_destroy_x_image (ximg);
2491 UNGCPRO;
2492 return 1;
2493 }
2494 #endif
2495
2496 #endif /* MAC_OS */
2497
2498 \f
2499 /***********************************************************************
2500 XBM images
2501 ***********************************************************************/
2502
2503 static int xbm_scan P_ ((unsigned char **, unsigned char *, char *, int *));
2504 static int xbm_load P_ ((struct frame *f, struct image *img));
2505 static int xbm_load_image P_ ((struct frame *f, struct image *img,
2506 unsigned char *, unsigned char *));
2507 static int xbm_image_p P_ ((Lisp_Object object));
2508 static int xbm_read_bitmap_data P_ ((unsigned char *, unsigned char *,
2509 int *, int *, unsigned char **));
2510 static int xbm_file_p P_ ((Lisp_Object));
2511
2512
2513 /* Indices of image specification fields in xbm_format, below. */
2514
2515 enum xbm_keyword_index
2516 {
2517 XBM_TYPE,
2518 XBM_FILE,
2519 XBM_WIDTH,
2520 XBM_HEIGHT,
2521 XBM_DATA,
2522 XBM_FOREGROUND,
2523 XBM_BACKGROUND,
2524 XBM_ASCENT,
2525 XBM_MARGIN,
2526 XBM_RELIEF,
2527 XBM_ALGORITHM,
2528 XBM_HEURISTIC_MASK,
2529 XBM_MASK,
2530 XBM_LAST
2531 };
2532
2533 /* Vector of image_keyword structures describing the format
2534 of valid XBM image specifications. */
2535
2536 static struct image_keyword xbm_format[XBM_LAST] =
2537 {
2538 {":type", IMAGE_SYMBOL_VALUE, 1},
2539 {":file", IMAGE_STRING_VALUE, 0},
2540 {":width", IMAGE_POSITIVE_INTEGER_VALUE, 0},
2541 {":height", IMAGE_POSITIVE_INTEGER_VALUE, 0},
2542 {":data", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2543 {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
2544 {":background", IMAGE_STRING_OR_NIL_VALUE, 0},
2545 {":ascent", IMAGE_ASCENT_VALUE, 0},
2546 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
2547 {":relief", IMAGE_INTEGER_VALUE, 0},
2548 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2549 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
2550 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0}
2551 };
2552
2553 /* Structure describing the image type XBM. */
2554
2555 static struct image_type xbm_type =
2556 {
2557 &Qxbm,
2558 xbm_image_p,
2559 xbm_load,
2560 x_clear_image,
2561 NULL
2562 };
2563
2564 /* Tokens returned from xbm_scan. */
2565
2566 enum xbm_token
2567 {
2568 XBM_TK_IDENT = 256,
2569 XBM_TK_NUMBER
2570 };
2571
2572
2573 /* Return non-zero if OBJECT is a valid XBM-type image specification.
2574 A valid specification is a list starting with the symbol `image'
2575 The rest of the list is a property list which must contain an
2576 entry `:type xbm..
2577
2578 If the specification specifies a file to load, it must contain
2579 an entry `:file FILENAME' where FILENAME is a string.
2580
2581 If the specification is for a bitmap loaded from memory it must
2582 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
2583 WIDTH and HEIGHT are integers > 0. DATA may be:
2584
2585 1. a string large enough to hold the bitmap data, i.e. it must
2586 have a size >= (WIDTH + 7) / 8 * HEIGHT
2587
2588 2. a bool-vector of size >= WIDTH * HEIGHT
2589
2590 3. a vector of strings or bool-vectors, one for each line of the
2591 bitmap.
2592
2593 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
2594 may not be specified in this case because they are defined in the
2595 XBM file.
2596
2597 Both the file and data forms may contain the additional entries
2598 `:background COLOR' and `:foreground COLOR'. If not present,
2599 foreground and background of the frame on which the image is
2600 displayed is used. */
2601
2602 static int
2603 xbm_image_p (object)
2604 Lisp_Object object;
2605 {
2606 struct image_keyword kw[XBM_LAST];
2607
2608 bcopy (xbm_format, kw, sizeof kw);
2609 if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
2610 return 0;
2611
2612 xassert (EQ (kw[XBM_TYPE].value, Qxbm));
2613
2614 if (kw[XBM_FILE].count)
2615 {
2616 if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_DATA].count)
2617 return 0;
2618 }
2619 else if (kw[XBM_DATA].count && xbm_file_p (kw[XBM_DATA].value))
2620 {
2621 /* In-memory XBM file. */
2622 if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_FILE].count)
2623 return 0;
2624 }
2625 else
2626 {
2627 Lisp_Object data;
2628 int width, height;
2629
2630 /* Entries for `:width', `:height' and `:data' must be present. */
2631 if (!kw[XBM_WIDTH].count
2632 || !kw[XBM_HEIGHT].count
2633 || !kw[XBM_DATA].count)
2634 return 0;
2635
2636 data = kw[XBM_DATA].value;
2637 width = XFASTINT (kw[XBM_WIDTH].value);
2638 height = XFASTINT (kw[XBM_HEIGHT].value);
2639
2640 /* Check type of data, and width and height against contents of
2641 data. */
2642 if (VECTORP (data))
2643 {
2644 int i;
2645
2646 /* Number of elements of the vector must be >= height. */
2647 if (XVECTOR (data)->size < height)
2648 return 0;
2649
2650 /* Each string or bool-vector in data must be large enough
2651 for one line of the image. */
2652 for (i = 0; i < height; ++i)
2653 {
2654 Lisp_Object elt = XVECTOR (data)->contents[i];
2655
2656 if (STRINGP (elt))
2657 {
2658 if (SCHARS (elt)
2659 < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR)
2660 return 0;
2661 }
2662 else if (BOOL_VECTOR_P (elt))
2663 {
2664 if (XBOOL_VECTOR (elt)->size < width)
2665 return 0;
2666 }
2667 else
2668 return 0;
2669 }
2670 }
2671 else if (STRINGP (data))
2672 {
2673 if (SCHARS (data)
2674 < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR * height)
2675 return 0;
2676 }
2677 else if (BOOL_VECTOR_P (data))
2678 {
2679 if (XBOOL_VECTOR (data)->size < width * height)
2680 return 0;
2681 }
2682 else
2683 return 0;
2684 }
2685
2686 return 1;
2687 }
2688
2689
2690 /* Scan a bitmap file. FP is the stream to read from. Value is
2691 either an enumerator from enum xbm_token, or a character for a
2692 single-character token, or 0 at end of file. If scanning an
2693 identifier, store the lexeme of the identifier in SVAL. If
2694 scanning a number, store its value in *IVAL. */
2695
2696 static int
2697 xbm_scan (s, end, sval, ival)
2698 unsigned char **s, *end;
2699 char *sval;
2700 int *ival;
2701 {
2702 unsigned int c;
2703
2704 loop:
2705
2706 /* Skip white space. */
2707 while (*s < end && (c = *(*s)++, isspace (c)))
2708 ;
2709
2710 if (*s >= end)
2711 c = 0;
2712 else if (isdigit (c))
2713 {
2714 int value = 0, digit;
2715
2716 if (c == '0' && *s < end)
2717 {
2718 c = *(*s)++;
2719 if (c == 'x' || c == 'X')
2720 {
2721 while (*s < end)
2722 {
2723 c = *(*s)++;
2724 if (isdigit (c))
2725 digit = c - '0';
2726 else if (c >= 'a' && c <= 'f')
2727 digit = c - 'a' + 10;
2728 else if (c >= 'A' && c <= 'F')
2729 digit = c - 'A' + 10;
2730 else
2731 break;
2732 value = 16 * value + digit;
2733 }
2734 }
2735 else if (isdigit (c))
2736 {
2737 value = c - '0';
2738 while (*s < end
2739 && (c = *(*s)++, isdigit (c)))
2740 value = 8 * value + c - '0';
2741 }
2742 }
2743 else
2744 {
2745 value = c - '0';
2746 while (*s < end
2747 && (c = *(*s)++, isdigit (c)))
2748 value = 10 * value + c - '0';
2749 }
2750
2751 if (*s < end)
2752 *s = *s - 1;
2753 *ival = value;
2754 c = XBM_TK_NUMBER;
2755 }
2756 else if (isalpha (c) || c == '_')
2757 {
2758 *sval++ = c;
2759 while (*s < end
2760 && (c = *(*s)++, (isalnum (c) || c == '_')))
2761 *sval++ = c;
2762 *sval = 0;
2763 if (*s < end)
2764 *s = *s - 1;
2765 c = XBM_TK_IDENT;
2766 }
2767 else if (c == '/' && **s == '*')
2768 {
2769 /* C-style comment. */
2770 ++*s;
2771 while (**s && (**s != '*' || *(*s + 1) != '/'))
2772 ++*s;
2773 if (**s)
2774 {
2775 *s += 2;
2776 goto loop;
2777 }
2778 }
2779
2780 return c;
2781 }
2782
2783 #ifdef HAVE_NTGUI
2784
2785 /* Create a Windows bitmap from X bitmap data. */
2786 static HBITMAP
2787 w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
2788 {
2789 static unsigned char swap_nibble[16]
2790 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
2791 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
2792 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
2793 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
2794 int i, j, w1, w2;
2795 unsigned char *bits, *p;
2796 HBITMAP bmp;
2797
2798 w1 = (width + 7) / 8; /* nb of 8bits elt in X bitmap */
2799 w2 = ((width + 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
2800 bits = (unsigned char *) alloca (height * w2);
2801 bzero (bits, height * w2);
2802 for (i = 0; i < height; i++)
2803 {
2804 p = bits + i*w2;
2805 for (j = 0; j < w1; j++)
2806 {
2807 /* Bitswap XBM bytes to match how Windows does things. */
2808 unsigned char c = *data++;
2809 *p++ = (unsigned char)((swap_nibble[c & 0xf] << 4)
2810 | (swap_nibble[(c>>4) & 0xf]));
2811 }
2812 }
2813 bmp = CreateBitmap (width, height, 1, 1, (char *) bits);
2814
2815 return bmp;
2816 }
2817
2818 static void convert_mono_to_color_image (f, img, foreground, background)
2819 struct frame *f;
2820 struct image *img;
2821 COLORREF foreground, background;
2822 {
2823 HDC hdc, old_img_dc, new_img_dc;
2824 HGDIOBJ old_prev, new_prev;
2825 HBITMAP new_pixmap;
2826
2827 hdc = get_frame_dc (f);
2828 old_img_dc = CreateCompatibleDC (hdc);
2829 new_img_dc = CreateCompatibleDC (hdc);
2830 new_pixmap = CreateCompatibleBitmap (hdc, img->width, img->height);
2831 release_frame_dc (f, hdc);
2832 old_prev = SelectObject (old_img_dc, img->pixmap);
2833 new_prev = SelectObject (new_img_dc, new_pixmap);
2834 SetTextColor (new_img_dc, foreground);
2835 SetBkColor (new_img_dc, background);
2836
2837 BitBlt (new_img_dc, 0, 0, img->width, img->height, old_img_dc,
2838 0, 0, SRCCOPY);
2839
2840 SelectObject (old_img_dc, old_prev);
2841 SelectObject (new_img_dc, new_prev);
2842 DeleteDC (old_img_dc);
2843 DeleteDC (new_img_dc);
2844 DeleteObject (img->pixmap);
2845 if (new_pixmap == 0)
2846 fprintf (stderr, "Failed to convert image to color.\n");
2847 else
2848 img->pixmap = new_pixmap;
2849 }
2850
2851 #define XBM_BIT_SHUFFLE(b) (~(b))
2852
2853 #else
2854
2855 #define XBM_BIT_SHUFFLE(b) (b)
2856
2857 #endif /* HAVE_NTGUI */
2858
2859
2860 static void
2861 Create_Pixmap_From_Bitmap_Data(f, img, data, fg, bg, non_default_colors)
2862 struct frame *f;
2863 struct image *img;
2864 char *data;
2865 RGB_PIXEL_COLOR fg, bg;
2866 int non_default_colors;
2867 {
2868 #ifdef HAVE_NTGUI
2869 img->pixmap
2870 = w32_create_pixmap_from_bitmap_data (img->width, img->height, data);
2871
2872 /* If colors were specified, transfer the bitmap to a color one. */
2873 if (non_default_colors)
2874 convert_mono_to_color_image (f, img, fg, bg);
2875 #else
2876 img->pixmap
2877 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f),
2878 FRAME_X_WINDOW (f),
2879 data,
2880 img->width, img->height,
2881 fg, bg,
2882 DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
2883 #endif /* HAVE_NTGUI */
2884 }
2885
2886
2887
2888 /* Replacement for XReadBitmapFileData which isn't available under old
2889 X versions. CONTENTS is a pointer to a buffer to parse; END is the
2890 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
2891 the image. Return in *DATA the bitmap data allocated with xmalloc.
2892 Value is non-zero if successful. DATA null means just test if
2893 CONTENTS looks like an in-memory XBM file. */
2894
2895 static int
2896 xbm_read_bitmap_data (contents, end, width, height, data)
2897 unsigned char *contents, *end;
2898 int *width, *height;
2899 unsigned char **data;
2900 {
2901 unsigned char *s = contents;
2902 char buffer[BUFSIZ];
2903 int padding_p = 0;
2904 int v10 = 0;
2905 int bytes_per_line, i, nbytes;
2906 unsigned char *p;
2907 int value;
2908 int LA1;
2909
2910 #define match() \
2911 LA1 = xbm_scan (&s, end, buffer, &value)
2912
2913 #define expect(TOKEN) \
2914 if (LA1 != (TOKEN)) \
2915 goto failure; \
2916 else \
2917 match ()
2918
2919 #define expect_ident(IDENT) \
2920 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
2921 match (); \
2922 else \
2923 goto failure
2924
2925 *width = *height = -1;
2926 if (data)
2927 *data = NULL;
2928 LA1 = xbm_scan (&s, end, buffer, &value);
2929
2930 /* Parse defines for width, height and hot-spots. */
2931 while (LA1 == '#')
2932 {
2933 match ();
2934 expect_ident ("define");
2935 expect (XBM_TK_IDENT);
2936
2937 if (LA1 == XBM_TK_NUMBER);
2938 {
2939 char *p = strrchr (buffer, '_');
2940 p = p ? p + 1 : buffer;
2941 if (strcmp (p, "width") == 0)
2942 *width = value;
2943 else if (strcmp (p, "height") == 0)
2944 *height = value;
2945 }
2946 expect (XBM_TK_NUMBER);
2947 }
2948
2949 if (*width < 0 || *height < 0)
2950 goto failure;
2951 else if (data == NULL)
2952 goto success;
2953
2954 /* Parse bits. Must start with `static'. */
2955 expect_ident ("static");
2956 if (LA1 == XBM_TK_IDENT)
2957 {
2958 if (strcmp (buffer, "unsigned") == 0)
2959 {
2960 match ();
2961 expect_ident ("char");
2962 }
2963 else if (strcmp (buffer, "short") == 0)
2964 {
2965 match ();
2966 v10 = 1;
2967 if (*width % 16 && *width % 16 < 9)
2968 padding_p = 1;
2969 }
2970 else if (strcmp (buffer, "char") == 0)
2971 match ();
2972 else
2973 goto failure;
2974 }
2975 else
2976 goto failure;
2977
2978 expect (XBM_TK_IDENT);
2979 expect ('[');
2980 expect (']');
2981 expect ('=');
2982 expect ('{');
2983
2984 bytes_per_line = (*width + 7) / 8 + padding_p;
2985 nbytes = bytes_per_line * *height;
2986 p = *data = (char *) xmalloc (nbytes);
2987
2988 if (v10)
2989 {
2990 for (i = 0; i < nbytes; i += 2)
2991 {
2992 int val = value;
2993 expect (XBM_TK_NUMBER);
2994
2995 *p++ = XBM_BIT_SHUFFLE (val);
2996 if (!padding_p || ((i + 2) % bytes_per_line))
2997 *p++ = XBM_BIT_SHUFFLE (value >> 8);
2998
2999 if (LA1 == ',' || LA1 == '}')
3000 match ();
3001 else
3002 goto failure;
3003 }
3004 }
3005 else
3006 {
3007 for (i = 0; i < nbytes; ++i)
3008 {
3009 int val = value;
3010 expect (XBM_TK_NUMBER);
3011
3012 *p++ = XBM_BIT_SHUFFLE (val);
3013
3014 if (LA1 == ',' || LA1 == '}')
3015 match ();
3016 else
3017 goto failure;
3018 }
3019 }
3020
3021 success:
3022 return 1;
3023
3024 failure:
3025
3026 if (data && *data)
3027 {
3028 xfree (*data);
3029 *data = NULL;
3030 }
3031 return 0;
3032
3033 #undef match
3034 #undef expect
3035 #undef expect_ident
3036 }
3037
3038
3039 /* Load XBM image IMG which will be displayed on frame F from buffer
3040 CONTENTS. END is the end of the buffer. Value is non-zero if
3041 successful. */
3042
3043 static int
3044 xbm_load_image (f, img, contents, end)
3045 struct frame *f;
3046 struct image *img;
3047 unsigned char *contents, *end;
3048 {
3049 int rc;
3050 unsigned char *data;
3051 int success_p = 0;
3052
3053 rc = xbm_read_bitmap_data (contents, end, &img->width, &img->height, &data);
3054 if (rc)
3055 {
3056 unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
3057 unsigned long background = FRAME_BACKGROUND_PIXEL (f);
3058 int non_default_colors = 0;
3059 Lisp_Object value;
3060
3061 xassert (img->width > 0 && img->height > 0);
3062
3063 /* Get foreground and background colors, maybe allocate colors. */
3064 value = image_spec_value (img->spec, QCforeground, NULL);
3065 if (!NILP (value))
3066 {
3067 foreground = x_alloc_image_color (f, img, value, foreground);
3068 non_default_colors = 1;
3069 }
3070 value = image_spec_value (img->spec, QCbackground, NULL);
3071 if (!NILP (value))
3072 {
3073 background = x_alloc_image_color (f, img, value, background);
3074 img->background = background;
3075 img->background_valid = 1;
3076 non_default_colors = 1;
3077 }
3078
3079 Create_Pixmap_From_Bitmap_Data (f, img, data,
3080 foreground, background,
3081 non_default_colors);
3082 xfree (data);
3083
3084 if (img->pixmap == NO_PIXMAP)
3085 {
3086 x_clear_image (f, img);
3087 image_error ("Unable to create X pixmap for `%s'", img->spec, Qnil);
3088 }
3089 else
3090 success_p = 1;
3091 }
3092 else
3093 image_error ("Error loading XBM image `%s'", img->spec, Qnil);
3094
3095 return success_p;
3096 }
3097
3098
3099 /* Value is non-zero if DATA looks like an in-memory XBM file. */
3100
3101 static int
3102 xbm_file_p (data)
3103 Lisp_Object data;
3104 {
3105 int w, h;
3106 return (STRINGP (data)
3107 && xbm_read_bitmap_data (SDATA (data),
3108 (SDATA (data)
3109 + SBYTES (data)),
3110 &w, &h, NULL));
3111 }
3112
3113
3114 /* Fill image IMG which is used on frame F with pixmap data. Value is
3115 non-zero if successful. */
3116
3117 static int
3118 xbm_load (f, img)
3119 struct frame *f;
3120 struct image *img;
3121 {
3122 int success_p = 0;
3123 Lisp_Object file_name;
3124
3125 xassert (xbm_image_p (img->spec));
3126
3127 /* If IMG->spec specifies a file name, create a non-file spec from it. */
3128 file_name = image_spec_value (img->spec, QCfile, NULL);
3129 if (STRINGP (file_name))
3130 {
3131 Lisp_Object file;
3132 unsigned char *contents;
3133 int size;
3134 struct gcpro gcpro1;
3135
3136 file = x_find_image_file (file_name);
3137 GCPRO1 (file);
3138 if (!STRINGP (file))
3139 {
3140 image_error ("Cannot find image file `%s'", file_name, Qnil);
3141 UNGCPRO;
3142 return 0;
3143 }
3144
3145 contents = slurp_file (SDATA (file), &size);
3146 if (contents == NULL)
3147 {
3148 image_error ("Error loading XBM image `%s'", img->spec, Qnil);
3149 UNGCPRO;
3150 return 0;
3151 }
3152
3153 success_p = xbm_load_image (f, img, contents, contents + size);
3154 UNGCPRO;
3155 }
3156 else
3157 {
3158 struct image_keyword fmt[XBM_LAST];
3159 Lisp_Object data;
3160 unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
3161 unsigned long background = FRAME_BACKGROUND_PIXEL (f);
3162 int non_default_colors = 0;
3163 char *bits;
3164 int parsed_p;
3165 int in_memory_file_p = 0;
3166
3167 /* See if data looks like an in-memory XBM file. */
3168 data = image_spec_value (img->spec, QCdata, NULL);
3169 in_memory_file_p = xbm_file_p (data);
3170
3171 /* Parse the image specification. */
3172 bcopy (xbm_format, fmt, sizeof fmt);
3173 parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
3174 xassert (parsed_p);
3175
3176 /* Get specified width, and height. */
3177 if (!in_memory_file_p)
3178 {
3179 img->width = XFASTINT (fmt[XBM_WIDTH].value);
3180 img->height = XFASTINT (fmt[XBM_HEIGHT].value);
3181 xassert (img->width > 0 && img->height > 0);
3182 }
3183
3184 /* Get foreground and background colors, maybe allocate colors. */
3185 if (fmt[XBM_FOREGROUND].count
3186 && STRINGP (fmt[XBM_FOREGROUND].value))
3187 {
3188 foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
3189 foreground);
3190 non_default_colors = 1;
3191 }
3192
3193 if (fmt[XBM_BACKGROUND].count
3194 && STRINGP (fmt[XBM_BACKGROUND].value))
3195 {
3196 background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
3197 background);
3198 non_default_colors = 1;
3199 }
3200
3201 if (in_memory_file_p)
3202 success_p = xbm_load_image (f, img, SDATA (data),
3203 (SDATA (data)
3204 + SBYTES (data)));
3205 else
3206 {
3207 if (VECTORP (data))
3208 {
3209 int i;
3210 char *p;
3211 int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
3212
3213 p = bits = (char *) alloca (nbytes * img->height);
3214 for (i = 0; i < img->height; ++i, p += nbytes)
3215 {
3216 Lisp_Object line = XVECTOR (data)->contents[i];
3217 if (STRINGP (line))
3218 bcopy (SDATA (line), p, nbytes);
3219 else
3220 bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
3221 }
3222 }
3223 else if (STRINGP (data))
3224 bits = SDATA (data);
3225 else
3226 bits = XBOOL_VECTOR (data)->data;
3227
3228 /* Create the pixmap. */
3229
3230 Create_Pixmap_From_Bitmap_Data (f, img, bits,
3231 foreground, background,
3232 non_default_colors);
3233 if (img->pixmap)
3234 success_p = 1;
3235 else
3236 {
3237 image_error ("Unable to create pixmap for XBM image `%s'",
3238 img->spec, Qnil);
3239 x_clear_image (f, img);
3240 }
3241 }
3242 }
3243
3244 return success_p;
3245 }
3246
3247
3248 \f
3249 /***********************************************************************
3250 XPM images
3251 ***********************************************************************/
3252
3253 #if defined (HAVE_XPM) || defined (MAC_OS)
3254
3255 static int xpm_image_p P_ ((Lisp_Object object));
3256 static int xpm_load P_ ((struct frame *f, struct image *img));
3257 static int xpm_valid_color_symbols_p P_ ((Lisp_Object));
3258
3259 #endif /* HAVE_XPM || MAC_OS */
3260
3261 #ifdef HAVE_XPM
3262 #ifdef HAVE_NTGUI
3263 /* Indicate to xpm.h that we don't have Xlib. */
3264 #define FOR_MSW
3265 /* simx.h in xpm defines XColor and XImage differently than Emacs. */
3266 /* It also defines Display the same way as Emacs, but gcc 3.3 still barfs. */
3267 #define XColor xpm_XColor
3268 #define XImage xpm_XImage
3269 #define Display xpm_Display
3270 #define PIXEL_ALREADY_TYPEDEFED
3271 #include "X11/xpm.h"
3272 #undef FOR_MSW
3273 #undef XColor
3274 #undef XImage
3275 #undef Display
3276 #undef PIXEL_ALREADY_TYPEDEFED
3277 #else
3278 #include "X11/xpm.h"
3279 #endif /* HAVE_NTGUI */
3280 #endif /* HAVE_XPM */
3281
3282 #if defined (HAVE_XPM) || defined (MAC_OS)
3283 /* The symbol `xpm' identifying XPM-format images. */
3284
3285 Lisp_Object Qxpm;
3286
3287 /* Indices of image specification fields in xpm_format, below. */
3288
3289 enum xpm_keyword_index
3290 {
3291 XPM_TYPE,
3292 XPM_FILE,
3293 XPM_DATA,
3294 XPM_ASCENT,
3295 XPM_MARGIN,
3296 XPM_RELIEF,
3297 XPM_ALGORITHM,
3298 XPM_HEURISTIC_MASK,
3299 XPM_MASK,
3300 XPM_COLOR_SYMBOLS,
3301 XPM_BACKGROUND,
3302 XPM_LAST
3303 };
3304
3305 /* Vector of image_keyword structures describing the format
3306 of valid XPM image specifications. */
3307
3308 static struct image_keyword xpm_format[XPM_LAST] =
3309 {
3310 {":type", IMAGE_SYMBOL_VALUE, 1},
3311 {":file", IMAGE_STRING_VALUE, 0},
3312 {":data", IMAGE_STRING_VALUE, 0},
3313 {":ascent", IMAGE_ASCENT_VALUE, 0},
3314 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
3315 {":relief", IMAGE_INTEGER_VALUE, 0},
3316 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3317 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3318 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3319 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
3320 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
3321 };
3322
3323 /* Structure describing the image type XPM. */
3324
3325 static struct image_type xpm_type =
3326 {
3327 &Qxpm,
3328 xpm_image_p,
3329 xpm_load,
3330 x_clear_image,
3331 NULL
3332 };
3333
3334 #ifdef HAVE_X_WINDOWS
3335
3336 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
3337 functions for allocating image colors. Our own functions handle
3338 color allocation failures more gracefully than the ones on the XPM
3339 lib. */
3340
3341 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
3342 #define ALLOC_XPM_COLORS
3343 #endif
3344 #endif /* HAVE_X_WINDOWS */
3345
3346 #ifdef ALLOC_XPM_COLORS
3347
3348 static void xpm_init_color_cache P_ ((struct frame *, XpmAttributes *));
3349 static void xpm_free_color_cache P_ ((void));
3350 static int xpm_lookup_color P_ ((struct frame *, char *, XColor *));
3351 static int xpm_color_bucket P_ ((char *));
3352 static struct xpm_cached_color *xpm_cache_color P_ ((struct frame *, char *,
3353 XColor *, int));
3354
3355 /* An entry in a hash table used to cache color definitions of named
3356 colors. This cache is necessary to speed up XPM image loading in
3357 case we do color allocations ourselves. Without it, we would need
3358 a call to XParseColor per pixel in the image. */
3359
3360 struct xpm_cached_color
3361 {
3362 /* Next in collision chain. */
3363 struct xpm_cached_color *next;
3364
3365 /* Color definition (RGB and pixel color). */
3366 XColor color;
3367
3368 /* Color name. */
3369 char name[1];
3370 };
3371
3372 /* The hash table used for the color cache, and its bucket vector
3373 size. */
3374
3375 #define XPM_COLOR_CACHE_BUCKETS 1001
3376 struct xpm_cached_color **xpm_color_cache;
3377
3378 /* Initialize the color cache. */
3379
3380 static void
3381 xpm_init_color_cache (f, attrs)
3382 struct frame *f;
3383 XpmAttributes *attrs;
3384 {
3385 size_t nbytes = XPM_COLOR_CACHE_BUCKETS * sizeof *xpm_color_cache;
3386 xpm_color_cache = (struct xpm_cached_color **) xmalloc (nbytes);
3387 memset (xpm_color_cache, 0, nbytes);
3388 init_color_table ();
3389
3390 if (attrs->valuemask & XpmColorSymbols)
3391 {
3392 int i;
3393 XColor color;
3394
3395 for (i = 0; i < attrs->numsymbols; ++i)
3396 if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
3397 attrs->colorsymbols[i].value, &color))
3398 {
3399 color.pixel = lookup_rgb_color (f, color.red, color.green,
3400 color.blue);
3401 xpm_cache_color (f, attrs->colorsymbols[i].name, &color, -1);
3402 }
3403 }
3404 }
3405
3406 /* Free the color cache. */
3407
3408 static void
3409 xpm_free_color_cache ()
3410 {
3411 struct xpm_cached_color *p, *next;
3412 int i;
3413
3414 for (i = 0; i < XPM_COLOR_CACHE_BUCKETS; ++i)
3415 for (p = xpm_color_cache[i]; p; p = next)
3416 {
3417 next = p->next;
3418 xfree (p);
3419 }
3420
3421 xfree (xpm_color_cache);
3422 xpm_color_cache = NULL;
3423 free_color_table ();
3424 }
3425
3426 /* Return the bucket index for color named COLOR_NAME in the color
3427 cache. */
3428
3429 static int
3430 xpm_color_bucket (color_name)
3431 char *color_name;
3432 {
3433 unsigned h = 0;
3434 char *s;
3435
3436 for (s = color_name; *s; ++s)
3437 h = (h << 2) ^ *s;
3438 return h %= XPM_COLOR_CACHE_BUCKETS;
3439 }
3440
3441
3442 /* On frame F, cache values COLOR for color with name COLOR_NAME.
3443 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
3444 entry added. */
3445
3446 static struct xpm_cached_color *
3447 xpm_cache_color (f, color_name, color, bucket)
3448 struct frame *f;
3449 char *color_name;
3450 XColor *color;
3451 int bucket;
3452 {
3453 size_t nbytes;
3454 struct xpm_cached_color *p;
3455
3456 if (bucket < 0)
3457 bucket = xpm_color_bucket (color_name);
3458
3459 nbytes = sizeof *p + strlen (color_name);
3460 p = (struct xpm_cached_color *) xmalloc (nbytes);
3461 strcpy (p->name, color_name);
3462 p->color = *color;
3463 p->next = xpm_color_cache[bucket];
3464 xpm_color_cache[bucket] = p;
3465 return p;
3466 }
3467
3468 /* Look up color COLOR_NAME for frame F in the color cache. If found,
3469 return the cached definition in *COLOR. Otherwise, make a new
3470 entry in the cache and allocate the color. Value is zero if color
3471 allocation failed. */
3472
3473 static int
3474 xpm_lookup_color (f, color_name, color)
3475 struct frame *f;
3476 char *color_name;
3477 XColor *color;
3478 {
3479 struct xpm_cached_color *p;
3480 int h = xpm_color_bucket (color_name);
3481
3482 for (p = xpm_color_cache[h]; p; p = p->next)
3483 if (strcmp (p->name, color_name) == 0)
3484 break;
3485
3486 if (p != NULL)
3487 *color = p->color;
3488 else if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
3489 color_name, color))
3490 {
3491 color->pixel = lookup_rgb_color (f, color->red, color->green,
3492 color->blue);
3493 p = xpm_cache_color (f, color_name, color, h);
3494 }
3495 /* You get `opaque' at least from ImageMagick converting pbm to xpm
3496 with transparency, and it's useful. */
3497 else if (strcmp ("opaque", color_name) == 0)
3498 {
3499 bzero (color, sizeof (XColor)); /* Is this necessary/correct? */
3500 color->pixel = FRAME_FOREGROUND_PIXEL (f);
3501 p = xpm_cache_color (f, color_name, color, h);
3502 }
3503
3504 return p != NULL;
3505 }
3506
3507
3508 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
3509 CLOSURE is a pointer to the frame on which we allocate the
3510 color. Return in *COLOR the allocated color. Value is non-zero
3511 if successful. */
3512
3513 static int
3514 xpm_alloc_color (dpy, cmap, color_name, color, closure)
3515 Display *dpy;
3516 Colormap cmap;
3517 char *color_name;
3518 XColor *color;
3519 void *closure;
3520 {
3521 return xpm_lookup_color ((struct frame *) closure, color_name, color);
3522 }
3523
3524
3525 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
3526 is a pointer to the frame on which we allocate the color. Value is
3527 non-zero if successful. */
3528
3529 static int
3530 xpm_free_colors (dpy, cmap, pixels, npixels, closure)
3531 Display *dpy;
3532 Colormap cmap;
3533 Pixel *pixels;
3534 int npixels;
3535 void *closure;
3536 {
3537 return 1;
3538 }
3539
3540 #endif /* ALLOC_XPM_COLORS */
3541
3542
3543 #ifdef HAVE_NTGUI
3544
3545 /* XPM library details. */
3546
3547 DEF_IMGLIB_FN (XpmFreeAttributes);
3548 DEF_IMGLIB_FN (XpmCreateImageFromBuffer);
3549 DEF_IMGLIB_FN (XpmReadFileToImage);
3550 DEF_IMGLIB_FN (XImageFree);
3551
3552 static int
3553 init_xpm_functions (Lisp_Object libraries)
3554 {
3555 HMODULE library;
3556
3557 if (!(library = w32_delayed_load (libraries, Qxpm)))
3558 return 0;
3559
3560 LOAD_IMGLIB_FN (library, XpmFreeAttributes);
3561 LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
3562 LOAD_IMGLIB_FN (library, XpmReadFileToImage);
3563 LOAD_IMGLIB_FN (library, XImageFree);
3564 return 1;
3565 }
3566
3567 #endif /* HAVE_NTGUI */
3568
3569
3570 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
3571 for XPM images. Such a list must consist of conses whose car and
3572 cdr are strings. */
3573
3574 static int
3575 xpm_valid_color_symbols_p (color_symbols)
3576 Lisp_Object color_symbols;
3577 {
3578 while (CONSP (color_symbols))
3579 {
3580 Lisp_Object sym = XCAR (color_symbols);
3581 if (!CONSP (sym)
3582 || !STRINGP (XCAR (sym))
3583 || !STRINGP (XCDR (sym)))
3584 break;
3585 color_symbols = XCDR (color_symbols);
3586 }
3587
3588 return NILP (color_symbols);
3589 }
3590
3591
3592 /* Value is non-zero if OBJECT is a valid XPM image specification. */
3593
3594 static int
3595 xpm_image_p (object)
3596 Lisp_Object object;
3597 {
3598 struct image_keyword fmt[XPM_LAST];
3599 bcopy (xpm_format, fmt, sizeof fmt);
3600 return (parse_image_spec (object, fmt, XPM_LAST, Qxpm)
3601 /* Either `:file' or `:data' must be present. */
3602 && fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
3603 /* Either no `:color-symbols' or it's a list of conses
3604 whose car and cdr are strings. */
3605 && (fmt[XPM_COLOR_SYMBOLS].count == 0
3606 || xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value)));
3607 }
3608
3609 #endif /* HAVE_XPM || MAC_OS */
3610
3611 /* Load image IMG which will be displayed on frame F. Value is
3612 non-zero if successful. */
3613
3614 #ifdef HAVE_XPM
3615
3616 static int
3617 xpm_load (f, img)
3618 struct frame *f;
3619 struct image *img;
3620 {
3621 int rc;
3622 XpmAttributes attrs;
3623 Lisp_Object specified_file, color_symbols;
3624 #ifdef HAVE_NTGUI
3625 HDC hdc;
3626 xpm_XImage * xpm_image = NULL, * xpm_mask = NULL;
3627 #endif /* HAVE_NTGUI */
3628
3629 /* Configure the XPM lib. Use the visual of frame F. Allocate
3630 close colors. Return colors allocated. */
3631 bzero (&attrs, sizeof attrs);
3632
3633 #ifndef HAVE_NTGUI
3634 attrs.visual = FRAME_X_VISUAL (f);
3635 attrs.colormap = FRAME_X_COLORMAP (f);
3636 attrs.valuemask |= XpmVisual;
3637 attrs.valuemask |= XpmColormap;
3638 #endif /* HAVE_NTGUI */
3639
3640 #ifdef ALLOC_XPM_COLORS
3641 /* Allocate colors with our own functions which handle
3642 failing color allocation more gracefully. */
3643 attrs.color_closure = f;
3644 attrs.alloc_color = xpm_alloc_color;
3645 attrs.free_colors = xpm_free_colors;
3646 attrs.valuemask |= XpmAllocColor | XpmFreeColors | XpmColorClosure;
3647 #else /* not ALLOC_XPM_COLORS */
3648 /* Let the XPM lib allocate colors. */
3649 attrs.valuemask |= XpmReturnAllocPixels;
3650 #ifdef XpmAllocCloseColors
3651 attrs.alloc_close_colors = 1;
3652 attrs.valuemask |= XpmAllocCloseColors;
3653 #else /* not XpmAllocCloseColors */
3654 attrs.closeness = 600;
3655 attrs.valuemask |= XpmCloseness;
3656 #endif /* not XpmAllocCloseColors */
3657 #endif /* ALLOC_XPM_COLORS */
3658
3659 /* If image specification contains symbolic color definitions, add
3660 these to `attrs'. */
3661 color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
3662 if (CONSP (color_symbols))
3663 {
3664 Lisp_Object tail;
3665 XpmColorSymbol *xpm_syms;
3666 int i, size;
3667
3668 attrs.valuemask |= XpmColorSymbols;
3669
3670 /* Count number of symbols. */
3671 attrs.numsymbols = 0;
3672 for (tail = color_symbols; CONSP (tail); tail = XCDR (tail))
3673 ++attrs.numsymbols;
3674
3675 /* Allocate an XpmColorSymbol array. */
3676 size = attrs.numsymbols * sizeof *xpm_syms;
3677 xpm_syms = (XpmColorSymbol *) alloca (size);
3678 bzero (xpm_syms, size);
3679 attrs.colorsymbols = xpm_syms;
3680
3681 /* Fill the color symbol array. */
3682 for (tail = color_symbols, i = 0;
3683 CONSP (tail);
3684 ++i, tail = XCDR (tail))
3685 {
3686 Lisp_Object name = XCAR (XCAR (tail));
3687 Lisp_Object color = XCDR (XCAR (tail));
3688 xpm_syms[i].name = (char *) alloca (SCHARS (name) + 1);
3689 strcpy (xpm_syms[i].name, SDATA (name));
3690 xpm_syms[i].value = (char *) alloca (SCHARS (color) + 1);
3691 strcpy (xpm_syms[i].value, SDATA (color));
3692 }
3693 }
3694
3695 /* Create a pixmap for the image, either from a file, or from a
3696 string buffer containing data in the same format as an XPM file. */
3697 #ifdef ALLOC_XPM_COLORS
3698 xpm_init_color_cache (f, &attrs);
3699 #endif
3700
3701 specified_file = image_spec_value (img->spec, QCfile, NULL);
3702
3703 #ifdef HAVE_NTGUI
3704 {
3705 HDC frame_dc = get_frame_dc (f);
3706 hdc = CreateCompatibleDC (frame_dc);
3707 release_frame_dc (f, frame_dc);
3708 }
3709 #endif /* HAVE_NTGUI */
3710
3711 if (STRINGP (specified_file))
3712 {
3713 Lisp_Object file = x_find_image_file (specified_file);
3714 if (!STRINGP (file))
3715 {
3716 image_error ("Cannot find image file `%s'", specified_file, Qnil);
3717 return 0;
3718 }
3719
3720 #ifdef HAVE_NTGUI
3721 /* XpmReadFileToPixmap is not available in the Windows port of
3722 libxpm. But XpmReadFileToImage almost does what we want. */
3723 rc = fn_XpmReadFileToImage (&hdc, SDATA (file),
3724 &xpm_image, &xpm_mask,
3725 &attrs);
3726 #else
3727 rc = XpmReadFileToPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3728 SDATA (file), &img->pixmap, &img->mask,
3729 &attrs);
3730 #endif /* HAVE_NTGUI */
3731 }
3732 else
3733 {
3734 Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
3735 #ifdef HAVE_NTGUI
3736 /* XpmCreatePixmapFromBuffer is not available in the Windows port
3737 of libxpm. But XpmCreateImageFromBuffer almost does what we want. */
3738 rc = fn_XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
3739 &xpm_image, &xpm_mask,
3740 &attrs);
3741 #else
3742 rc = XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3743 SDATA (buffer),
3744 &img->pixmap, &img->mask,
3745 &attrs);
3746 #endif /* HAVE_NTGUI */
3747 }
3748
3749 if (rc == XpmSuccess)
3750 {
3751 #if defined (COLOR_TABLE_SUPPORT) && defined (ALLOC_XPM_COLORS)
3752 img->colors = colors_in_color_table (&img->ncolors);
3753 #else /* not ALLOC_XPM_COLORS */
3754 int i;
3755
3756 #ifdef HAVE_NTGUI
3757 /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
3758 plus some duplicate attributes. */
3759 if (xpm_image && xpm_image->bitmap)
3760 {
3761 img->pixmap = xpm_image->bitmap;
3762 /* XImageFree in libXpm frees XImage struct without destroying
3763 the bitmap, which is what we want. */
3764 fn_XImageFree (xpm_image);
3765 }
3766 if (xpm_mask && xpm_mask->bitmap)
3767 {
3768 /* The mask appears to be inverted compared with what we expect.
3769 TODO: invert our expectations. See other places where we
3770 have to invert bits because our idea of masks is backwards. */
3771 HGDIOBJ old_obj;
3772 old_obj = SelectObject (hdc, xpm_mask->bitmap);
3773
3774 PatBlt (hdc, 0, 0, xpm_mask->width, xpm_mask->height, DSTINVERT);
3775 SelectObject (hdc, old_obj);
3776
3777 img->mask = xpm_mask->bitmap;
3778 fn_XImageFree (xpm_mask);
3779 DeleteDC (hdc);
3780 }
3781
3782 DeleteDC (hdc);
3783 #endif /* HAVE_NTGUI */
3784
3785 /* Remember allocated colors. */
3786 img->ncolors = attrs.nalloc_pixels;
3787 img->colors = (unsigned long *) xmalloc (img->ncolors
3788 * sizeof *img->colors);
3789 for (i = 0; i < attrs.nalloc_pixels; ++i)
3790 {
3791 img->colors[i] = attrs.alloc_pixels[i];
3792 #ifdef DEBUG_X_COLORS
3793 register_color (img->colors[i]);
3794 #endif
3795 }
3796 #endif /* not ALLOC_XPM_COLORS */
3797
3798 img->width = attrs.width;
3799 img->height = attrs.height;
3800 xassert (img->width > 0 && img->height > 0);
3801
3802 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
3803 #ifdef HAVE_NTGUI
3804 fn_XpmFreeAttributes (&attrs);
3805 #else
3806 XpmFreeAttributes (&attrs);
3807 #endif /* HAVE_NTGUI */
3808 }
3809 else
3810 {
3811 #ifdef HAVE_NTGUI
3812 DeleteDC (hdc);
3813 #endif /* HAVE_NTGUI */
3814
3815 switch (rc)
3816 {
3817 case XpmOpenFailed:
3818 image_error ("Error opening XPM file (%s)", img->spec, Qnil);
3819 break;
3820
3821 case XpmFileInvalid:
3822 image_error ("Invalid XPM file (%s)", img->spec, Qnil);
3823 break;
3824
3825 case XpmNoMemory:
3826 image_error ("Out of memory (%s)", img->spec, Qnil);
3827 break;
3828
3829 case XpmColorFailed:
3830 image_error ("Color allocation error (%s)", img->spec, Qnil);
3831 break;
3832
3833 default:
3834 image_error ("Unknown error (%s)", img->spec, Qnil);
3835 break;
3836 }
3837 }
3838
3839 #ifdef ALLOC_XPM_COLORS
3840 xpm_free_color_cache ();
3841 #endif
3842 return rc == XpmSuccess;
3843 }
3844
3845 #endif /* HAVE_XPM */
3846
3847 #ifdef MAC_OS
3848
3849 /* XPM support functions for Mac OS where libxpm is not available.
3850 Only XPM version 3 (without any extensions) is supported. */
3851
3852 static int xpm_scan P_ ((unsigned char **, unsigned char *,
3853 unsigned char **, int *));
3854 static Lisp_Object xpm_make_color_table_v
3855 P_ ((void (**) (Lisp_Object, unsigned char *, int, Lisp_Object),
3856 Lisp_Object (**) (Lisp_Object, unsigned char *, int)));
3857 static void xpm_put_color_table_v P_ ((Lisp_Object, unsigned char *,
3858 int, Lisp_Object));
3859 static Lisp_Object xpm_get_color_table_v P_ ((Lisp_Object,
3860 unsigned char *, int));
3861 static Lisp_Object xpm_make_color_table_h
3862 P_ ((void (**) (Lisp_Object, unsigned char *, int, Lisp_Object),
3863 Lisp_Object (**) (Lisp_Object, unsigned char *, int)));
3864 static void xpm_put_color_table_h P_ ((Lisp_Object, unsigned char *,
3865 int, Lisp_Object));
3866 static Lisp_Object xpm_get_color_table_h P_ ((Lisp_Object,
3867 unsigned char *, int));
3868 static int xpm_str_to_color_key P_ ((char *));
3869 static int xpm_load_image P_ ((struct frame *, struct image *,
3870 unsigned char *, unsigned char *));
3871
3872 /* Tokens returned from xpm_scan. */
3873
3874 enum xpm_token
3875 {
3876 XPM_TK_IDENT = 256,
3877 XPM_TK_STRING,
3878 XPM_TK_EOF
3879 };
3880
3881 /* Scan an XPM data and return a character (< 256) or a token defined
3882 by enum xpm_token above. *S and END are the start (inclusive) and
3883 the end (exclusive) addresses of the data, respectively. Advance
3884 *S while scanning. If token is either XPM_TK_IDENT or
3885 XPM_TK_STRING, *BEG and *LEN are set to the start address and the
3886 length of the corresponding token, respectively. */
3887
3888 static int
3889 xpm_scan (s, end, beg, len)
3890 unsigned char **s, *end, **beg;
3891 int *len;
3892 {
3893 int c;
3894
3895 while (*s < end)
3896 {
3897 /* Skip white-space. */
3898 while (*s < end && (c = *(*s)++, isspace (c)))
3899 ;
3900
3901 /* gnus-pointer.xpm uses '-' in its identifier.
3902 sb-dir-plus.xpm uses '+' in its identifier. */
3903 if (isalpha (c) || c == '_' || c == '-' || c == '+')
3904 {
3905 *beg = *s - 1;
3906 while (*s < end &&
3907 (c = **s, isalnum (c) || c == '_' || c == '-' || c == '+'))
3908 ++*s;
3909 *len = *s - *beg;
3910 return XPM_TK_IDENT;
3911 }
3912 else if (c == '"')
3913 {
3914 *beg = *s;
3915 while (*s < end && **s != '"')
3916 ++*s;
3917 *len = *s - *beg;
3918 if (*s < end)
3919 ++*s;
3920 return XPM_TK_STRING;
3921 }
3922 else if (c == '/')
3923 {
3924 if (*s < end && **s == '*')
3925 {
3926 /* C-style comment. */
3927 ++*s;
3928 do
3929 {
3930 while (*s < end && *(*s)++ != '*')
3931 ;
3932 }
3933 while (*s < end && **s != '/');
3934 if (*s < end)
3935 ++*s;
3936 }
3937 else
3938 return c;
3939 }
3940 else
3941 return c;
3942 }
3943
3944 return XPM_TK_EOF;
3945 }
3946
3947 /* Functions for color table lookup in XPM data. A Key is a string
3948 specifying the color of each pixel in XPM data. A value is either
3949 an integer that specifies a pixel color, Qt that specifies
3950 transparency, or Qnil for the unspecified color. If the length of
3951 the key string is one, a vector is used as a table. Otherwise, a
3952 hash table is used. */
3953
3954 static Lisp_Object
3955 xpm_make_color_table_v (put_func, get_func)
3956 void (**put_func) (Lisp_Object, unsigned char *, int, Lisp_Object);
3957 Lisp_Object (**get_func) (Lisp_Object, unsigned char *, int);
3958 {
3959 *put_func = xpm_put_color_table_v;
3960 *get_func = xpm_get_color_table_v;
3961 return Fmake_vector (make_number (256), Qnil);
3962 }
3963
3964 static void
3965 xpm_put_color_table_v (color_table, chars_start, chars_len, color)
3966 Lisp_Object color_table;
3967 unsigned char *chars_start;
3968 int chars_len;
3969 Lisp_Object color;
3970 {
3971 XVECTOR (color_table)->contents[*chars_start] = color;
3972 }
3973
3974 static Lisp_Object
3975 xpm_get_color_table_v (color_table, chars_start, chars_len)
3976 Lisp_Object color_table;
3977 unsigned char *chars_start;
3978 int chars_len;
3979 {
3980 return XVECTOR (color_table)->contents[*chars_start];
3981 }
3982
3983 static Lisp_Object
3984 xpm_make_color_table_h (put_func, get_func)
3985 void (**put_func) (Lisp_Object, unsigned char *, int, Lisp_Object);
3986 Lisp_Object (**get_func) (Lisp_Object, unsigned char *, int);
3987 {
3988 *put_func = xpm_put_color_table_h;
3989 *get_func = xpm_get_color_table_h;
3990 return make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
3991 make_float (DEFAULT_REHASH_SIZE),
3992 make_float (DEFAULT_REHASH_THRESHOLD),
3993 Qnil, Qnil, Qnil);
3994 }
3995
3996 static void
3997 xpm_put_color_table_h (color_table, chars_start, chars_len, color)
3998 Lisp_Object color_table;
3999 unsigned char *chars_start;
4000 int chars_len;
4001 Lisp_Object color;
4002 {
4003 struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
4004 unsigned hash_code;
4005 Lisp_Object chars = make_unibyte_string (chars_start, chars_len);
4006
4007 hash_lookup (table, chars, &hash_code);
4008 hash_put (table, chars, color, hash_code);
4009 }
4010
4011 static Lisp_Object
4012 xpm_get_color_table_h (color_table, chars_start, chars_len)
4013 Lisp_Object color_table;
4014 unsigned char *chars_start;
4015 int chars_len;
4016 {
4017 struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
4018 int i = hash_lookup (table, make_unibyte_string (chars_start, chars_len),
4019 NULL);
4020
4021 return i >= 0 ? HASH_VALUE (table, i) : Qnil;
4022 }
4023
4024 enum xpm_color_key {
4025 XPM_COLOR_KEY_S,
4026 XPM_COLOR_KEY_M,
4027 XPM_COLOR_KEY_G4,
4028 XPM_COLOR_KEY_G,
4029 XPM_COLOR_KEY_C
4030 };
4031
4032 static char xpm_color_key_strings[][4] = {"s", "m", "g4", "g", "c"};
4033
4034 static int
4035 xpm_str_to_color_key (s)
4036 char *s;
4037 {
4038 int i;
4039
4040 for (i = 0;
4041 i < sizeof xpm_color_key_strings / sizeof xpm_color_key_strings[0];
4042 i++)
4043 if (strcmp (xpm_color_key_strings[i], s) == 0)
4044 return i;
4045 return -1;
4046 }
4047
4048 static int
4049 xpm_load_image (f, img, contents, end)
4050 struct frame *f;
4051 struct image *img;
4052 unsigned char *contents, *end;
4053 {
4054 unsigned char *s = contents, *beg, *str;
4055 unsigned char buffer[BUFSIZ];
4056 int width, height, x, y;
4057 int num_colors, chars_per_pixel;
4058 int len, LA1;
4059 void (*put_color_table) (Lisp_Object, unsigned char *, int, Lisp_Object);
4060 Lisp_Object (*get_color_table) (Lisp_Object, unsigned char *, int);
4061 Lisp_Object frame, color_symbols, color_table;
4062 int best_key, have_mask = 0;
4063 XImagePtr ximg = NULL, mask_img = NULL;
4064
4065 #define match() \
4066 LA1 = xpm_scan (&s, end, &beg, &len)
4067
4068 #define expect(TOKEN) \
4069 if (LA1 != (TOKEN)) \
4070 goto failure; \
4071 else \
4072 match ()
4073
4074 #define expect_ident(IDENT) \
4075 if (LA1 == XPM_TK_IDENT \
4076 && strlen ((IDENT)) == len && memcmp ((IDENT), beg, len) == 0) \
4077 match (); \
4078 else \
4079 goto failure
4080
4081 if (!(end - s >= 9 && memcmp (s, "/* XPM */", 9) == 0))
4082 goto failure;
4083 s += 9;
4084 match();
4085 expect_ident ("static");
4086 expect_ident ("char");
4087 expect ('*');
4088 expect (XPM_TK_IDENT);
4089 expect ('[');
4090 expect (']');
4091 expect ('=');
4092 expect ('{');
4093 expect (XPM_TK_STRING);
4094 if (len >= BUFSIZ)
4095 goto failure;
4096 memcpy (buffer, beg, len);
4097 buffer[len] = '\0';
4098 if (sscanf (buffer, "%d %d %d %d", &width, &height,
4099 &num_colors, &chars_per_pixel) != 4
4100 || width <= 0 || height <= 0
4101 || num_colors <= 0 || chars_per_pixel <= 0)
4102 goto failure;
4103 expect (',');
4104
4105 XSETFRAME (frame, f);
4106 if (!NILP (Fxw_display_color_p (frame)))
4107 best_key = XPM_COLOR_KEY_C;
4108 else if (!NILP (Fx_display_grayscale_p (frame)))
4109 best_key = (XFASTINT (Fx_display_planes (frame)) > 2
4110 ? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
4111 else
4112 best_key = XPM_COLOR_KEY_M;
4113
4114 color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
4115 if (chars_per_pixel == 1)
4116 color_table = xpm_make_color_table_v (&put_color_table,
4117 &get_color_table);
4118 else
4119 color_table = xpm_make_color_table_h (&put_color_table,
4120 &get_color_table);
4121
4122 while (num_colors-- > 0)
4123 {
4124 unsigned char *color, *max_color;
4125 int key, next_key, max_key = 0;
4126 Lisp_Object symbol_color = Qnil, color_val;
4127 XColor cdef;
4128
4129 expect (XPM_TK_STRING);
4130 if (len <= chars_per_pixel || len >= BUFSIZ + chars_per_pixel)
4131 goto failure;
4132 memcpy (buffer, beg + chars_per_pixel, len - chars_per_pixel);
4133 buffer[len - chars_per_pixel] = '\0';
4134
4135 str = strtok (buffer, " \t");
4136 if (str == NULL)
4137 goto failure;
4138 key = xpm_str_to_color_key (str);
4139 if (key < 0)
4140 goto failure;
4141 do
4142 {
4143 color = strtok (NULL, " \t");
4144 if (color == NULL)
4145 goto failure;
4146
4147 while (str = strtok (NULL, " \t"))
4148 {
4149 next_key = xpm_str_to_color_key (str);
4150 if (next_key >= 0)
4151 break;
4152 color[strlen (color)] = ' ';
4153 }
4154
4155 if (key == XPM_COLOR_KEY_S)
4156 {
4157 if (NILP (symbol_color))
4158 symbol_color = build_string (color);
4159 }
4160 else if (max_key < key && key <= best_key)
4161 {
4162 max_key = key;
4163 max_color = color;
4164 }
4165 key = next_key;
4166 }
4167 while (str);
4168
4169 color_val = Qnil;
4170 if (!NILP (color_symbols) && !NILP (symbol_color))
4171 {
4172 Lisp_Object specified_color = Fassoc (symbol_color, color_symbols);
4173
4174 if (CONSP (specified_color) && STRINGP (XCDR (specified_color)))
4175 if (xstricmp (SDATA (XCDR (specified_color)), "None") == 0)
4176 color_val = Qt;
4177 else if (x_defined_color (f, SDATA (XCDR (specified_color)),
4178 &cdef, 0))
4179 color_val = make_number (cdef.pixel);
4180 }
4181 if (NILP (color_val) && max_key > 0)
4182 if (xstricmp (max_color, "None") == 0)
4183 color_val = Qt;
4184 else if (x_defined_color (f, max_color, &cdef, 0))
4185 color_val = make_number (cdef.pixel);
4186 if (!NILP (color_val))
4187 (*put_color_table) (color_table, beg, chars_per_pixel, color_val);
4188
4189 expect (',');
4190 }
4191
4192 if (!x_create_x_image_and_pixmap (f, width, height, 0,
4193 &ximg, &img->pixmap)
4194 || !x_create_x_image_and_pixmap (f, width, height, 1,
4195 &mask_img, &img->mask))
4196 {
4197 image_error ("Out of memory (%s)", img->spec, Qnil);
4198 goto error;
4199 }
4200
4201 for (y = 0; y < height; y++)
4202 {
4203 expect (XPM_TK_STRING);
4204 str = beg;
4205 if (len < width * chars_per_pixel)
4206 goto failure;
4207 for (x = 0; x < width; x++, str += chars_per_pixel)
4208 {
4209 Lisp_Object color_val =
4210 (*get_color_table) (color_table, str, chars_per_pixel);
4211
4212 XPutPixel (ximg, x, y,
4213 (INTEGERP (color_val) ? XINT (color_val)
4214 : FRAME_FOREGROUND_PIXEL (f)));
4215 XPutPixel (mask_img, x, y,
4216 (!EQ (color_val, Qt) ? PIX_MASK_DRAW (f)
4217 : (have_mask = 1, PIX_MASK_RETAIN (f))));
4218 }
4219 if (y + 1 < height)
4220 expect (',');
4221 }
4222
4223 img->width = width;
4224 img->height = height;
4225
4226 x_put_x_image (f, ximg, img->pixmap, width, height);
4227 x_destroy_x_image (ximg);
4228 if (have_mask)
4229 {
4230 x_put_x_image (f, mask_img, img->mask, width, height);
4231 x_destroy_x_image (mask_img);
4232 }
4233 else
4234 {
4235 x_destroy_x_image (mask_img);
4236 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
4237 img->mask = NO_PIXMAP;
4238 }
4239
4240 return 1;
4241
4242 failure:
4243 image_error ("Invalid XPM file (%s)", img->spec, Qnil);
4244 error:
4245 x_destroy_x_image (ximg);
4246 x_destroy_x_image (mask_img);
4247 x_clear_image (f, img);
4248 return 0;
4249
4250 #undef match
4251 #undef expect
4252 #undef expect_ident
4253 }
4254
4255 static int
4256 xpm_load (f, img)
4257 struct frame *f;
4258 struct image *img;
4259 {
4260 int success_p = 0;
4261 Lisp_Object file_name;
4262
4263 /* If IMG->spec specifies a file name, create a non-file spec from it. */
4264 file_name = image_spec_value (img->spec, QCfile, NULL);
4265 if (STRINGP (file_name))
4266 {
4267 Lisp_Object file;
4268 unsigned char *contents;
4269 int size;
4270 struct gcpro gcpro1;
4271
4272 file = x_find_image_file (file_name);
4273 GCPRO1 (file);
4274 if (!STRINGP (file))
4275 {
4276 image_error ("Cannot find image file `%s'", file_name, Qnil);
4277 UNGCPRO;
4278 return 0;
4279 }
4280
4281 contents = slurp_file (SDATA (file), &size);
4282 if (contents == NULL)
4283 {
4284 image_error ("Error loading XPM image `%s'", img->spec, Qnil);
4285 UNGCPRO;
4286 return 0;
4287 }
4288
4289 success_p = xpm_load_image (f, img, contents, contents + size);
4290 xfree (contents);
4291 UNGCPRO;
4292 }
4293 else
4294 {
4295 Lisp_Object data;
4296
4297 data = image_spec_value (img->spec, QCdata, NULL);
4298 success_p = xpm_load_image (f, img, SDATA (data),
4299 SDATA (data) + SBYTES (data));
4300 }
4301
4302 return success_p;
4303 }
4304
4305 #endif /* MAC_OS */
4306
4307
4308 \f
4309 /***********************************************************************
4310 Color table
4311 ***********************************************************************/
4312
4313 #ifdef COLOR_TABLE_SUPPORT
4314
4315 /* An entry in the color table mapping an RGB color to a pixel color. */
4316
4317 struct ct_color
4318 {
4319 int r, g, b;
4320 unsigned long pixel;
4321
4322 /* Next in color table collision list. */
4323 struct ct_color *next;
4324 };
4325
4326 /* The bucket vector size to use. Must be prime. */
4327
4328 #define CT_SIZE 101
4329
4330 /* Value is a hash of the RGB color given by R, G, and B. */
4331
4332 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
4333
4334 /* The color hash table. */
4335
4336 struct ct_color **ct_table;
4337
4338 /* Number of entries in the color table. */
4339
4340 int ct_colors_allocated;
4341
4342 /* Initialize the color table. */
4343
4344 static void
4345 init_color_table ()
4346 {
4347 int size = CT_SIZE * sizeof (*ct_table);
4348 ct_table = (struct ct_color **) xmalloc (size);
4349 bzero (ct_table, size);
4350 ct_colors_allocated = 0;
4351 }
4352
4353
4354 /* Free memory associated with the color table. */
4355
4356 static void
4357 free_color_table ()
4358 {
4359 int i;
4360 struct ct_color *p, *next;
4361
4362 for (i = 0; i < CT_SIZE; ++i)
4363 for (p = ct_table[i]; p; p = next)
4364 {
4365 next = p->next;
4366 xfree (p);
4367 }
4368
4369 xfree (ct_table);
4370 ct_table = NULL;
4371 }
4372
4373
4374 /* Value is a pixel color for RGB color R, G, B on frame F. If an
4375 entry for that color already is in the color table, return the
4376 pixel color of that entry. Otherwise, allocate a new color for R,
4377 G, B, and make an entry in the color table. */
4378
4379 static unsigned long
4380 lookup_rgb_color (f, r, g, b)
4381 struct frame *f;
4382 int r, g, b;
4383 {
4384 unsigned hash = CT_HASH_RGB (r, g, b);
4385 int i = hash % CT_SIZE;
4386 struct ct_color *p;
4387 Display_Info *dpyinfo;
4388
4389 /* Handle TrueColor visuals specially, which improves performance by
4390 two orders of magnitude. Freeing colors on TrueColor visuals is
4391 a nop, and pixel colors specify RGB values directly. See also
4392 the Xlib spec, chapter 3.1. */
4393 dpyinfo = FRAME_X_DISPLAY_INFO (f);
4394 if (dpyinfo->red_bits > 0)
4395 {
4396 unsigned long pr, pg, pb;
4397
4398 /* Apply gamma-correction like normal color allocation does. */
4399 if (f->gamma)
4400 {
4401 XColor color;
4402 color.red = r, color.green = g, color.blue = b;
4403 gamma_correct (f, &color);
4404 r = color.red, g = color.green, b = color.blue;
4405 }
4406
4407 /* Scale down RGB values to the visual's bits per RGB, and shift
4408 them to the right position in the pixel color. Note that the
4409 original RGB values are 16-bit values, as usual in X. */
4410 pr = (r >> (16 - dpyinfo->red_bits)) << dpyinfo->red_offset;
4411 pg = (g >> (16 - dpyinfo->green_bits)) << dpyinfo->green_offset;
4412 pb = (b >> (16 - dpyinfo->blue_bits)) << dpyinfo->blue_offset;
4413
4414 /* Assemble the pixel color. */
4415 return pr | pg | pb;
4416 }
4417
4418 for (p = ct_table[i]; p; p = p->next)
4419 if (p->r == r && p->g == g && p->b == b)
4420 break;
4421
4422 if (p == NULL)
4423 {
4424
4425 #ifdef HAVE_X_WINDOWS
4426 XColor color;
4427 Colormap cmap;
4428 int rc;
4429
4430 color.red = r;
4431 color.green = g;
4432 color.blue = b;
4433
4434 cmap = FRAME_X_COLORMAP (f);
4435 rc = x_alloc_nearest_color (f, cmap, &color);
4436 if (rc)
4437 {
4438 ++ct_colors_allocated;
4439 p = (struct ct_color *) xmalloc (sizeof *p);
4440 p->r = r;
4441 p->g = g;
4442 p->b = b;
4443 p->pixel = color.pixel;
4444 p->next = ct_table[i];
4445 ct_table[i] = p;
4446 }
4447 else
4448 return FRAME_FOREGROUND_PIXEL (f);
4449
4450 #else
4451 COLORREF color;
4452 #ifdef HAVE_NTGUI
4453 color = PALETTERGB (r, g, b);
4454 #else
4455 color = RGB_TO_ULONG (r, g, b);
4456 #endif /* HAVE_NTGUI */
4457 ++ct_colors_allocated;
4458 p = (struct ct_color *) xmalloc (sizeof *p);
4459 p->r = r;
4460 p->g = g;
4461 p->b = b;
4462 p->pixel = color;
4463 p->next = ct_table[i];
4464 ct_table[i] = p;
4465 #endif /* HAVE_X_WINDOWS */
4466
4467 }
4468
4469 return p->pixel;
4470 }
4471
4472
4473 /* Look up pixel color PIXEL which is used on frame F in the color
4474 table. If not already present, allocate it. Value is PIXEL. */
4475
4476 static unsigned long
4477 lookup_pixel_color (f, pixel)
4478 struct frame *f;
4479 unsigned long pixel;
4480 {
4481 int i = pixel % CT_SIZE;
4482 struct ct_color *p;
4483
4484 for (p = ct_table[i]; p; p = p->next)
4485 if (p->pixel == pixel)
4486 break;
4487
4488 if (p == NULL)
4489 {
4490 XColor color;
4491 Colormap cmap;
4492 int rc;
4493
4494 #ifdef HAVE_X_WINDOWS
4495 cmap = FRAME_X_COLORMAP (f);
4496 color.pixel = pixel;
4497 x_query_color (f, &color);
4498 rc = x_alloc_nearest_color (f, cmap, &color);
4499 #else
4500 BLOCK_INPUT;
4501 cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
4502 color.pixel = pixel;
4503 XQueryColor (NULL, cmap, &color);
4504 rc = x_alloc_nearest_color (f, cmap, &color);
4505 UNBLOCK_INPUT;
4506 #endif /* HAVE_X_WINDOWS */
4507
4508 if (rc)
4509 {
4510 ++ct_colors_allocated;
4511
4512 p = (struct ct_color *) xmalloc (sizeof *p);
4513 p->r = color.red;
4514 p->g = color.green;
4515 p->b = color.blue;
4516 p->pixel = pixel;
4517 p->next = ct_table[i];
4518 ct_table[i] = p;
4519 }
4520 else
4521 return FRAME_FOREGROUND_PIXEL (f);
4522 }
4523 return p->pixel;
4524 }
4525
4526
4527 /* Value is a vector of all pixel colors contained in the color table,
4528 allocated via xmalloc. Set *N to the number of colors. */
4529
4530 static unsigned long *
4531 colors_in_color_table (n)
4532 int *n;
4533 {
4534 int i, j;
4535 struct ct_color *p;
4536 unsigned long *colors;
4537
4538 if (ct_colors_allocated == 0)
4539 {
4540 *n = 0;
4541 colors = NULL;
4542 }
4543 else
4544 {
4545 colors = (unsigned long *) xmalloc (ct_colors_allocated
4546 * sizeof *colors);
4547 *n = ct_colors_allocated;
4548
4549 for (i = j = 0; i < CT_SIZE; ++i)
4550 for (p = ct_table[i]; p; p = p->next)
4551 colors[j++] = p->pixel;
4552 }
4553
4554 return colors;
4555 }
4556
4557 #else /* COLOR_TABLE_SUPPORT */
4558
4559 static unsigned long
4560 lookup_rgb_color (f, r, g, b)
4561 struct frame *f;
4562 int r, g, b;
4563 {
4564 unsigned long pixel;
4565
4566 #ifdef MAC_OS
4567 pixel = RGB_TO_ULONG (r >> 8, g >> 8, b >> 8);
4568 gamma_correct (f, &pixel);
4569 #endif /* MAC_OS */
4570
4571 #ifdef HAVE_NTGUI
4572 pixel = PALETTERGB (r >> 8, g >> 8, b >> 8);
4573 #endif /* HAVE_NTGUI */
4574
4575 return pixel;
4576 }
4577
4578 static void
4579 init_color_table ()
4580 {
4581 }
4582 #endif /* COLOR_TABLE_SUPPORT */
4583
4584 \f
4585 /***********************************************************************
4586 Algorithms
4587 ***********************************************************************/
4588
4589 static XColor *x_to_xcolors P_ ((struct frame *, struct image *, int));
4590 static void x_from_xcolors P_ ((struct frame *, struct image *, XColor *));
4591 static void x_detect_edges P_ ((struct frame *, struct image *, int[9], int));
4592
4593 #ifdef HAVE_NTGUI
4594 static void XPutPixel (XImagePtr , int, int, COLORREF);
4595 #endif /* HAVE_NTGUI */
4596
4597 /* Non-zero means draw a cross on images having `:conversion
4598 disabled'. */
4599
4600 int cross_disabled_images;
4601
4602 /* Edge detection matrices for different edge-detection
4603 strategies. */
4604
4605 static int emboss_matrix[9] = {
4606 /* x - 1 x x + 1 */
4607 2, -1, 0, /* y - 1 */
4608 -1, 0, 1, /* y */
4609 0, 1, -2 /* y + 1 */
4610 };
4611
4612 static int laplace_matrix[9] = {
4613 /* x - 1 x x + 1 */
4614 1, 0, 0, /* y - 1 */
4615 0, 0, 0, /* y */
4616 0, 0, -1 /* y + 1 */
4617 };
4618
4619 /* Value is the intensity of the color whose red/green/blue values
4620 are R, G, and B. */
4621
4622 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
4623
4624
4625 /* On frame F, return an array of XColor structures describing image
4626 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
4627 non-zero means also fill the red/green/blue members of the XColor
4628 structures. Value is a pointer to the array of XColors structures,
4629 allocated with xmalloc; it must be freed by the caller. */
4630
4631 static XColor *
4632 x_to_xcolors (f, img, rgb_p)
4633 struct frame *f;
4634 struct image *img;
4635 int rgb_p;
4636 {
4637 int x, y;
4638 XColor *colors, *p;
4639 XImagePtr_or_DC ximg;
4640 #ifdef HAVE_NTGUI
4641 HDC hdc;
4642 HGDIOBJ prev;
4643 #endif /* HAVE_NTGUI */
4644
4645 colors = (XColor *) xmalloc (img->width * img->height * sizeof *colors);
4646
4647 #ifndef HAVE_NTGUI
4648 /* Get the X image IMG->pixmap. */
4649 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
4650 0, 0, img->width, img->height, ~0, ZPixmap);
4651 #else
4652 /* Load the image into a memory device context. */
4653 hdc = get_frame_dc (f);
4654 ximg = CreateCompatibleDC (hdc);
4655 release_frame_dc (f, hdc);
4656 prev = SelectObject (ximg, img->pixmap);
4657 #endif /* HAVE_NTGUI */
4658
4659 /* Fill the `pixel' members of the XColor array. I wished there
4660 were an easy and portable way to circumvent XGetPixel. */
4661 p = colors;
4662 for (y = 0; y < img->height; ++y)
4663 {
4664 XColor *row = p;
4665
4666 #ifdef HAVE_X_WINDOWS
4667 for (x = 0; x < img->width; ++x, ++p)
4668 p->pixel = XGetPixel (ximg, x, y);
4669 if (rgb_p)
4670 x_query_colors (f, row, img->width);
4671
4672 #else
4673
4674 for (x = 0; x < img->width; ++x, ++p)
4675 {
4676 /* W32_TODO: palette support needed here? */
4677 p->pixel = GET_PIXEL (ximg, x, y);
4678 if (rgb_p)
4679 {
4680 #ifdef MAC_OS
4681 p->red = RED16_FROM_ULONG (p->pixel);
4682 p->green = GREEN16_FROM_ULONG (p->pixel);
4683 p->blue = BLUE16_FROM_ULONG (p->pixel);
4684 #endif /* MAC_OS */
4685 #ifdef HAVE_NTGUI
4686 p->red = 256 * GetRValue (p->pixel);
4687 p->green = 256 * GetGValue (p->pixel);
4688 p->blue = 256 * GetBValue (p->pixel);
4689 #endif /* HAVE_NTGUI */
4690 }
4691 }
4692 #endif /* HAVE_X_WINDOWS */
4693 }
4694
4695 Destroy_Image (ximg, prev);
4696
4697 return colors;
4698 }
4699
4700 #ifdef HAVE_NTGUI
4701
4702 /* Put a pixel of COLOR at position X, Y in XIMG. XIMG must have been
4703 created with CreateDIBSection, with the pointer to the bit values
4704 stored in ximg->data. */
4705
4706 static void XPutPixel (ximg, x, y, color)
4707 XImagePtr ximg;
4708 int x, y;
4709 COLORREF color;
4710 {
4711 int width = ximg->info.bmiHeader.biWidth;
4712 int height = ximg->info.bmiHeader.biHeight;
4713 unsigned char * pixel;
4714
4715 /* True color images. */
4716 if (ximg->info.bmiHeader.biBitCount == 24)
4717 {
4718 int rowbytes = width * 3;
4719 /* Ensure scanlines are aligned on 4 byte boundaries. */
4720 if (rowbytes % 4)
4721 rowbytes += 4 - (rowbytes % 4);
4722
4723 pixel = ximg->data + y * rowbytes + x * 3;
4724 /* Windows bitmaps are in BGR order. */
4725 *pixel = GetBValue (color);
4726 *(pixel + 1) = GetGValue (color);
4727 *(pixel + 2) = GetRValue (color);
4728 }
4729 /* Monochrome images. */
4730 else if (ximg->info.bmiHeader.biBitCount == 1)
4731 {
4732 int rowbytes = width / 8;
4733 /* Ensure scanlines are aligned on 4 byte boundaries. */
4734 if (rowbytes % 4)
4735 rowbytes += 4 - (rowbytes % 4);
4736 pixel = ximg->data + y * rowbytes + x / 8;
4737 /* Filter out palette info. */
4738 if (color & 0x00ffffff)
4739 *pixel = *pixel | (1 << x % 8);
4740 else
4741 *pixel = *pixel & ~(1 << x % 8);
4742 }
4743 else
4744 image_error ("XPutPixel: palette image not supported", Qnil, Qnil);
4745 }
4746
4747 #endif /* HAVE_NTGUI */
4748
4749 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
4750 RGB members are set. F is the frame on which this all happens.
4751 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
4752
4753 static void
4754 x_from_xcolors (f, img, colors)
4755 struct frame *f;
4756 struct image *img;
4757 XColor *colors;
4758 {
4759 int x, y;
4760 XImagePtr oimg;
4761 Pixmap pixmap;
4762 XColor *p;
4763
4764 init_color_table ();
4765
4766 x_create_x_image_and_pixmap (f, img->width, img->height, 0,
4767 &oimg, &pixmap);
4768 p = colors;
4769 for (y = 0; y < img->height; ++y)
4770 for (x = 0; x < img->width; ++x, ++p)
4771 {
4772 unsigned long pixel;
4773 pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
4774 XPutPixel (oimg, x, y, pixel);
4775 }
4776
4777 xfree (colors);
4778 x_clear_image_1 (f, img, 1, 0, 1);
4779
4780 x_put_x_image (f, oimg, pixmap, img->width, img->height);
4781 x_destroy_x_image (oimg);
4782 img->pixmap = pixmap;
4783 #ifdef COLOR_TABLE_SUPPORT
4784 img->colors = colors_in_color_table (&img->ncolors);
4785 free_color_table ();
4786 #endif /* COLOR_TABLE_SUPPORT */
4787 }
4788
4789
4790 /* On frame F, perform edge-detection on image IMG.
4791
4792 MATRIX is a nine-element array specifying the transformation
4793 matrix. See emboss_matrix for an example.
4794
4795 COLOR_ADJUST is a color adjustment added to each pixel of the
4796 outgoing image. */
4797
4798 static void
4799 x_detect_edges (f, img, matrix, color_adjust)
4800 struct frame *f;
4801 struct image *img;
4802 int matrix[9], color_adjust;
4803 {
4804 XColor *colors = x_to_xcolors (f, img, 1);
4805 XColor *new, *p;
4806 int x, y, i, sum;
4807
4808 for (i = sum = 0; i < 9; ++i)
4809 sum += abs (matrix[i]);
4810
4811 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
4812
4813 new = (XColor *) xmalloc (img->width * img->height * sizeof *new);
4814
4815 for (y = 0; y < img->height; ++y)
4816 {
4817 p = COLOR (new, 0, y);
4818 p->red = p->green = p->blue = 0xffff/2;
4819 p = COLOR (new, img->width - 1, y);
4820 p->red = p->green = p->blue = 0xffff/2;
4821 }
4822
4823 for (x = 1; x < img->width - 1; ++x)
4824 {
4825 p = COLOR (new, x, 0);
4826 p->red = p->green = p->blue = 0xffff/2;
4827 p = COLOR (new, x, img->height - 1);
4828 p->red = p->green = p->blue = 0xffff/2;
4829 }
4830
4831 for (y = 1; y < img->height - 1; ++y)
4832 {
4833 p = COLOR (new, 1, y);
4834
4835 for (x = 1; x < img->width - 1; ++x, ++p)
4836 {
4837 int r, g, b, y1, x1;
4838
4839 r = g = b = i = 0;
4840 for (y1 = y - 1; y1 < y + 2; ++y1)
4841 for (x1 = x - 1; x1 < x + 2; ++x1, ++i)
4842 if (matrix[i])
4843 {
4844 XColor *t = COLOR (colors, x1, y1);
4845 r += matrix[i] * t->red;
4846 g += matrix[i] * t->green;
4847 b += matrix[i] * t->blue;
4848 }
4849
4850 r = (r / sum + color_adjust) & 0xffff;
4851 g = (g / sum + color_adjust) & 0xffff;
4852 b = (b / sum + color_adjust) & 0xffff;
4853 p->red = p->green = p->blue = COLOR_INTENSITY (r, g, b);
4854 }
4855 }
4856
4857 xfree (colors);
4858 x_from_xcolors (f, img, new);
4859
4860 #undef COLOR
4861 }
4862
4863
4864 /* Perform the pre-defined `emboss' edge-detection on image IMG
4865 on frame F. */
4866
4867 static void
4868 x_emboss (f, img)
4869 struct frame *f;
4870 struct image *img;
4871 {
4872 x_detect_edges (f, img, emboss_matrix, 0xffff / 2);
4873 }
4874
4875
4876 /* Transform image IMG which is used on frame F with a Laplace
4877 edge-detection algorithm. The result is an image that can be used
4878 to draw disabled buttons, for example. */
4879
4880 static void
4881 x_laplace (f, img)
4882 struct frame *f;
4883 struct image *img;
4884 {
4885 x_detect_edges (f, img, laplace_matrix, 45000);
4886 }
4887
4888
4889 /* Perform edge-detection on image IMG on frame F, with specified
4890 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
4891
4892 MATRIX must be either
4893
4894 - a list of at least 9 numbers in row-major form
4895 - a vector of at least 9 numbers
4896
4897 COLOR_ADJUST nil means use a default; otherwise it must be a
4898 number. */
4899
4900 static void
4901 x_edge_detection (f, img, matrix, color_adjust)
4902 struct frame *f;
4903 struct image *img;
4904 Lisp_Object matrix, color_adjust;
4905 {
4906 int i = 0;
4907 int trans[9];
4908
4909 if (CONSP (matrix))
4910 {
4911 for (i = 0;
4912 i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
4913 ++i, matrix = XCDR (matrix))
4914 trans[i] = XFLOATINT (XCAR (matrix));
4915 }
4916 else if (VECTORP (matrix) && ASIZE (matrix) >= 9)
4917 {
4918 for (i = 0; i < 9 && NUMBERP (AREF (matrix, i)); ++i)
4919 trans[i] = XFLOATINT (AREF (matrix, i));
4920 }
4921
4922 if (NILP (color_adjust))
4923 color_adjust = make_number (0xffff / 2);
4924
4925 if (i == 9 && NUMBERP (color_adjust))
4926 x_detect_edges (f, img, trans, (int) XFLOATINT (color_adjust));
4927 }
4928
4929
4930 /* Transform image IMG on frame F so that it looks disabled. */
4931
4932 static void
4933 x_disable_image (f, img)
4934 struct frame *f;
4935 struct image *img;
4936 {
4937 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
4938 #ifdef HAVE_NTGUI
4939 int n_planes = dpyinfo->n_planes * dpyinfo->n_cbits;
4940 #else
4941 int n_planes = dpyinfo->n_planes;
4942 #endif /* HAVE_NTGUI */
4943
4944 if (n_planes >= 2)
4945 {
4946 /* Color (or grayscale). Convert to gray, and equalize. Just
4947 drawing such images with a stipple can look very odd, so
4948 we're using this method instead. */
4949 XColor *colors = x_to_xcolors (f, img, 1);
4950 XColor *p, *end;
4951 const int h = 15000;
4952 const int l = 30000;
4953
4954 for (p = colors, end = colors + img->width * img->height;
4955 p < end;
4956 ++p)
4957 {
4958 int i = COLOR_INTENSITY (p->red, p->green, p->blue);
4959 int i2 = (0xffff - h - l) * i / 0xffff + l;
4960 p->red = p->green = p->blue = i2;
4961 }
4962
4963 x_from_xcolors (f, img, colors);
4964 }
4965
4966 /* Draw a cross over the disabled image, if we must or if we
4967 should. */
4968 if (n_planes < 2 || cross_disabled_images)
4969 {
4970 #ifndef HAVE_NTGUI
4971 Display *dpy = FRAME_X_DISPLAY (f);
4972 GC gc;
4973
4974 #ifdef MAC_OS
4975 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, NULL, 0, NULL)
4976 #define MaskForeground(f) PIX_MASK_DRAW (f)
4977 #else
4978 #define XCreateGC_pixmap(dpy, pixmap) XCreateGC (dpy, pixmap, 0, NULL)
4979 #define MaskForeground(f) WHITE_PIX_DEFAULT (f)
4980 #endif
4981
4982 gc = XCreateGC_pixmap (dpy, img->pixmap);
4983 XSetForeground (dpy, gc, BLACK_PIX_DEFAULT (f));
4984 XDrawLine (dpy, img->pixmap, gc, 0, 0,
4985 img->width - 1, img->height - 1);
4986 XDrawLine (dpy, img->pixmap, gc, 0, img->height - 1,
4987 img->width - 1, 0);
4988 XFreeGC (dpy, gc);
4989
4990 if (img->mask)
4991 {
4992 gc = XCreateGC_pixmap (dpy, img->mask);
4993 XSetForeground (dpy, gc, MaskForeground (f));
4994 XDrawLine (dpy, img->mask, gc, 0, 0,
4995 img->width - 1, img->height - 1);
4996 XDrawLine (dpy, img->mask, gc, 0, img->height - 1,
4997 img->width - 1, 0);
4998 XFreeGC (dpy, gc);
4999 }
5000 #else
5001 HDC hdc, bmpdc;
5002 HGDIOBJ prev;
5003
5004 hdc = get_frame_dc (f);
5005 bmpdc = CreateCompatibleDC (hdc);
5006 release_frame_dc (f, hdc);
5007
5008 prev = SelectObject (bmpdc, img->pixmap);
5009
5010 SetTextColor (bmpdc, BLACK_PIX_DEFAULT (f));
5011 MoveToEx (bmpdc, 0, 0, NULL);
5012 LineTo (bmpdc, img->width - 1, img->height - 1);
5013 MoveToEx (bmpdc, 0, img->height - 1, NULL);
5014 LineTo (bmpdc, img->width - 1, 0);
5015
5016 if (img->mask)
5017 {
5018 SelectObject (bmpdc, img->mask);
5019 SetTextColor (bmpdc, WHITE_PIX_DEFAULT (f));
5020 MoveToEx (bmpdc, 0, 0, NULL);
5021 LineTo (bmpdc, img->width - 1, img->height - 1);
5022 MoveToEx (bmpdc, 0, img->height - 1, NULL);
5023 LineTo (bmpdc, img->width - 1, 0);
5024 }
5025 SelectObject (bmpdc, prev);
5026 DeleteDC (bmpdc);
5027 #endif /* HAVE_NTGUI */
5028 }
5029 }
5030
5031
5032 /* Build a mask for image IMG which is used on frame F. FILE is the
5033 name of an image file, for error messages. HOW determines how to
5034 determine the background color of IMG. If it is a list '(R G B)',
5035 with R, G, and B being integers >= 0, take that as the color of the
5036 background. Otherwise, determine the background color of IMG
5037 heuristically. Value is non-zero if successful. */
5038
5039 static int
5040 x_build_heuristic_mask (f, img, how)
5041 struct frame *f;
5042 struct image *img;
5043 Lisp_Object how;
5044 {
5045 XImagePtr_or_DC ximg;
5046 #ifndef HAVE_NTGUI
5047 XImagePtr mask_img;
5048 #else
5049 HDC frame_dc;
5050 HGDIOBJ prev;
5051 char *mask_img;
5052 int row_width;
5053 #endif /* HAVE_NTGUI */
5054 int x, y, rc, use_img_background;
5055 unsigned long bg = 0;
5056
5057 if (img->mask)
5058 {
5059 Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
5060 img->mask = NO_PIXMAP;
5061 img->background_transparent_valid = 0;
5062 }
5063
5064 #ifndef HAVE_NTGUI
5065 /* Create an image and pixmap serving as mask. */
5066 rc = x_create_x_image_and_pixmap (f, img->width, img->height, 1,
5067 &mask_img, &img->mask);
5068 if (!rc)
5069 return 0;
5070
5071 /* Get the X image of IMG->pixmap. */
5072 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap, 0, 0,
5073 img->width, img->height,
5074 ~0, ZPixmap);
5075 #else
5076 /* Create the bit array serving as mask. */
5077 row_width = (img->width + 7) / 8;
5078 mask_img = xmalloc (row_width * img->height);
5079 bzero (mask_img, row_width * img->height);
5080
5081 /* Create a memory device context for IMG->pixmap. */
5082 frame_dc = get_frame_dc (f);
5083 ximg = CreateCompatibleDC (frame_dc);
5084 release_frame_dc (f, frame_dc);
5085 prev = SelectObject (ximg, img->pixmap);
5086 #endif /* HAVE_NTGUI */
5087
5088 /* Determine the background color of ximg. If HOW is `(R G B)'
5089 take that as color. Otherwise, use the image's background color. */
5090 use_img_background = 1;
5091
5092 if (CONSP (how))
5093 {
5094 int rgb[3], i;
5095
5096 for (i = 0; i < 3 && CONSP (how) && NATNUMP (XCAR (how)); ++i)
5097 {
5098 rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
5099 how = XCDR (how);
5100 }
5101
5102 if (i == 3 && NILP (how))
5103 {
5104 char color_name[30];
5105 sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
5106 bg = (
5107 #ifdef HAVE_NTGUI
5108 0x00ffffff & /* Filter out palette info. */
5109 #endif /* HAVE_NTGUI */
5110 x_alloc_image_color (f, img, build_string (color_name), 0));
5111 use_img_background = 0;
5112 }
5113 }
5114
5115 if (use_img_background)
5116 bg = four_corners_best (ximg, img->width, img->height);
5117
5118 /* Set all bits in mask_img to 1 whose color in ximg is different
5119 from the background color bg. */
5120 #ifndef HAVE_NTGUI
5121 for (y = 0; y < img->height; ++y)
5122 for (x = 0; x < img->width; ++x)
5123 XPutPixel (mask_img, x, y, (XGetPixel (ximg, x, y) != bg
5124 ? PIX_MASK_DRAW (f) : PIX_MASK_RETAIN (f)));
5125
5126 /* Fill in the background_transparent field while we have the mask handy. */
5127 image_background_transparent (img, f, mask_img);
5128
5129 /* Put mask_img into img->mask. */
5130 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
5131 x_destroy_x_image (mask_img);
5132
5133 #else
5134 for (y = 0; y < img->height; ++y)
5135 for (x = 0; x < img->width; ++x)
5136 {
5137 COLORREF p = GetPixel (ximg, x, y);
5138 if (p != bg)
5139 mask_img[y * row_width + x / 8] |= 1 << (x % 8);
5140 }
5141
5142 /* Create the mask image. */
5143 img->mask = w32_create_pixmap_from_bitmap_data (img->width, img->height,
5144 mask_img);
5145 /* Fill in the background_transparent field while we have the mask handy. */
5146 SelectObject (ximg, img->mask);
5147 image_background_transparent (img, f, ximg);
5148
5149 /* Was: x_destroy_x_image ((XImagePtr )mask_img); which seems bogus ++kfs */
5150 xfree (mask_img);
5151 #endif /* HAVE_NTGUI */
5152
5153 Destroy_Image (ximg, prev);
5154
5155 return 1;
5156 }
5157
5158 \f
5159 /***********************************************************************
5160 PBM (mono, gray, color)
5161 ***********************************************************************/
5162
5163 static int pbm_image_p P_ ((Lisp_Object object));
5164 static int pbm_load P_ ((struct frame *f, struct image *img));
5165 static int pbm_scan_number P_ ((unsigned char **, unsigned char *));
5166
5167 /* The symbol `pbm' identifying images of this type. */
5168
5169 Lisp_Object Qpbm;
5170
5171 /* Indices of image specification fields in gs_format, below. */
5172
5173 enum pbm_keyword_index
5174 {
5175 PBM_TYPE,
5176 PBM_FILE,
5177 PBM_DATA,
5178 PBM_ASCENT,
5179 PBM_MARGIN,
5180 PBM_RELIEF,
5181 PBM_ALGORITHM,
5182 PBM_HEURISTIC_MASK,
5183 PBM_MASK,
5184 PBM_FOREGROUND,
5185 PBM_BACKGROUND,
5186 PBM_LAST
5187 };
5188
5189 /* Vector of image_keyword structures describing the format
5190 of valid user-defined image specifications. */
5191
5192 static struct image_keyword pbm_format[PBM_LAST] =
5193 {
5194 {":type", IMAGE_SYMBOL_VALUE, 1},
5195 {":file", IMAGE_STRING_VALUE, 0},
5196 {":data", IMAGE_STRING_VALUE, 0},
5197 {":ascent", IMAGE_ASCENT_VALUE, 0},
5198 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
5199 {":relief", IMAGE_INTEGER_VALUE, 0},
5200 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5201 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5202 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5203 {":foreground", IMAGE_STRING_OR_NIL_VALUE, 0},
5204 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
5205 };
5206
5207 /* Structure describing the image type `pbm'. */
5208
5209 static struct image_type pbm_type =
5210 {
5211 &Qpbm,
5212 pbm_image_p,
5213 pbm_load,
5214 x_clear_image,
5215 NULL
5216 };
5217
5218
5219 /* Return non-zero if OBJECT is a valid PBM image specification. */
5220
5221 static int
5222 pbm_image_p (object)
5223 Lisp_Object object;
5224 {
5225 struct image_keyword fmt[PBM_LAST];
5226
5227 bcopy (pbm_format, fmt, sizeof fmt);
5228
5229 if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm))
5230 return 0;
5231
5232 /* Must specify either :data or :file. */
5233 return fmt[PBM_DATA].count + fmt[PBM_FILE].count == 1;
5234 }
5235
5236
5237 /* Scan a decimal number from *S and return it. Advance *S while
5238 reading the number. END is the end of the string. Value is -1 at
5239 end of input. */
5240
5241 static int
5242 pbm_scan_number (s, end)
5243 unsigned char **s, *end;
5244 {
5245 int c = 0, val = -1;
5246
5247 while (*s < end)
5248 {
5249 /* Skip white-space. */
5250 while (*s < end && (c = *(*s)++, isspace (c)))
5251 ;
5252
5253 if (c == '#')
5254 {
5255 /* Skip comment to end of line. */
5256 while (*s < end && (c = *(*s)++, c != '\n'))
5257 ;
5258 }
5259 else if (isdigit (c))
5260 {
5261 /* Read decimal number. */
5262 val = c - '0';
5263 while (*s < end && (c = *(*s)++, isdigit (c)))
5264 val = 10 * val + c - '0';
5265 break;
5266 }
5267 else
5268 break;
5269 }
5270
5271 return val;
5272 }
5273
5274
5275 #ifdef HAVE_NTGUI
5276 #if 0 /* Unused. ++kfs */
5277
5278 /* Read FILE into memory. Value is a pointer to a buffer allocated
5279 with xmalloc holding FILE's contents. Value is null if an error
5280 occurred. *SIZE is set to the size of the file. */
5281
5282 static char *
5283 pbm_read_file (file, size)
5284 Lisp_Object file;
5285 int *size;
5286 {
5287 FILE *fp = NULL;
5288 char *buf = NULL;
5289 struct stat st;
5290
5291 if (stat (SDATA (file), &st) == 0
5292 && (fp = fopen (SDATA (file), "rb")) != NULL
5293 && (buf = (char *) xmalloc (st.st_size),
5294 fread (buf, 1, st.st_size, fp) == st.st_size))
5295 {
5296 *size = st.st_size;
5297 fclose (fp);
5298 }
5299 else
5300 {
5301 if (fp)
5302 fclose (fp);
5303 if (buf)
5304 {
5305 xfree (buf);
5306 buf = NULL;
5307 }
5308 }
5309
5310 return buf;
5311 }
5312 #endif
5313 #endif /* HAVE_NTGUI */
5314
5315 /* Load PBM image IMG for use on frame F. */
5316
5317 static int
5318 pbm_load (f, img)
5319 struct frame *f;
5320 struct image *img;
5321 {
5322 int raw_p, x, y;
5323 int width, height, max_color_idx = 0;
5324 XImagePtr ximg;
5325 Lisp_Object file, specified_file;
5326 enum {PBM_MONO, PBM_GRAY, PBM_COLOR} type;
5327 struct gcpro gcpro1;
5328 unsigned char *contents = NULL;
5329 unsigned char *end, *p;
5330 int size;
5331
5332 specified_file = image_spec_value (img->spec, QCfile, NULL);
5333 file = Qnil;
5334 GCPRO1 (file);
5335
5336 if (STRINGP (specified_file))
5337 {
5338 file = x_find_image_file (specified_file);
5339 if (!STRINGP (file))
5340 {
5341 image_error ("Cannot find image file `%s'", specified_file, Qnil);
5342 UNGCPRO;
5343 return 0;
5344 }
5345
5346 contents = slurp_file (SDATA (file), &size);
5347 if (contents == NULL)
5348 {
5349 image_error ("Error reading `%s'", file, Qnil);
5350 UNGCPRO;
5351 return 0;
5352 }
5353
5354 p = contents;
5355 end = contents + size;
5356 }
5357 else
5358 {
5359 Lisp_Object data;
5360 data = image_spec_value (img->spec, QCdata, NULL);
5361 p = SDATA (data);
5362 end = p + SBYTES (data);
5363 }
5364
5365 /* Check magic number. */
5366 if (end - p < 2 || *p++ != 'P')
5367 {
5368 image_error ("Not a PBM image: `%s'", img->spec, Qnil);
5369 error:
5370 xfree (contents);
5371 UNGCPRO;
5372 return 0;
5373 }
5374
5375 switch (*p++)
5376 {
5377 case '1':
5378 raw_p = 0, type = PBM_MONO;
5379 break;
5380
5381 case '2':
5382 raw_p = 0, type = PBM_GRAY;
5383 break;
5384
5385 case '3':
5386 raw_p = 0, type = PBM_COLOR;
5387 break;
5388
5389 case '4':
5390 raw_p = 1, type = PBM_MONO;
5391 break;
5392
5393 case '5':
5394 raw_p = 1, type = PBM_GRAY;
5395 break;
5396
5397 case '6':
5398 raw_p = 1, type = PBM_COLOR;
5399 break;
5400
5401 default:
5402 image_error ("Not a PBM image: `%s'", img->spec, Qnil);
5403 goto error;
5404 }
5405
5406 /* Read width, height, maximum color-component. Characters
5407 starting with `#' up to the end of a line are ignored. */
5408 width = pbm_scan_number (&p, end);
5409 height = pbm_scan_number (&p, end);
5410
5411 if (type != PBM_MONO)
5412 {
5413 max_color_idx = pbm_scan_number (&p, end);
5414 if (raw_p && max_color_idx > 255)
5415 max_color_idx = 255;
5416 }
5417
5418 if (width < 0
5419 || height < 0
5420 || (type != PBM_MONO && max_color_idx < 0))
5421 goto error;
5422
5423 if (!x_create_x_image_and_pixmap (f, width, height, 0,
5424 &ximg, &img->pixmap))
5425 goto error;
5426
5427 /* Initialize the color hash table. */
5428 init_color_table ();
5429
5430 if (type == PBM_MONO)
5431 {
5432 int c = 0, g;
5433 struct image_keyword fmt[PBM_LAST];
5434 unsigned long fg = FRAME_FOREGROUND_PIXEL (f);
5435 unsigned long bg = FRAME_BACKGROUND_PIXEL (f);
5436
5437 /* Parse the image specification. */
5438 bcopy (pbm_format, fmt, sizeof fmt);
5439 parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
5440
5441 /* Get foreground and background colors, maybe allocate colors. */
5442 if (fmt[PBM_FOREGROUND].count
5443 && STRINGP (fmt[PBM_FOREGROUND].value))
5444 fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
5445 if (fmt[PBM_BACKGROUND].count
5446 && STRINGP (fmt[PBM_BACKGROUND].value))
5447 {
5448 bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
5449 img->background = bg;
5450 img->background_valid = 1;
5451 }
5452
5453 for (y = 0; y < height; ++y)
5454 for (x = 0; x < width; ++x)
5455 {
5456 if (raw_p)
5457 {
5458 if ((x & 7) == 0)
5459 c = *p++;
5460 g = c & 0x80;
5461 c <<= 1;
5462 }
5463 else
5464 g = pbm_scan_number (&p, end);
5465
5466 XPutPixel (ximg, x, y, g ? fg : bg);
5467 }
5468 }
5469 else
5470 {
5471 for (y = 0; y < height; ++y)
5472 for (x = 0; x < width; ++x)
5473 {
5474 int r, g, b;
5475
5476 if (type == PBM_GRAY)
5477 r = g = b = raw_p ? *p++ : pbm_scan_number (&p, end);
5478 else if (raw_p)
5479 {
5480 r = *p++;
5481 g = *p++;
5482 b = *p++;
5483 }
5484 else
5485 {
5486 r = pbm_scan_number (&p, end);
5487 g = pbm_scan_number (&p, end);
5488 b = pbm_scan_number (&p, end);
5489 }
5490
5491 if (r < 0 || g < 0 || b < 0)
5492 {
5493 x_destroy_x_image (ximg);
5494 image_error ("Invalid pixel value in image `%s'",
5495 img->spec, Qnil);
5496 goto error;
5497 }
5498
5499 /* RGB values are now in the range 0..max_color_idx.
5500 Scale this to the range 0..0xffff supported by X. */
5501 r = (double) r * 65535 / max_color_idx;
5502 g = (double) g * 65535 / max_color_idx;
5503 b = (double) b * 65535 / max_color_idx;
5504 XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
5505 }
5506 }
5507
5508 #ifdef COLOR_TABLE_SUPPORT
5509 /* Store in IMG->colors the colors allocated for the image, and
5510 free the color table. */
5511 img->colors = colors_in_color_table (&img->ncolors);
5512 free_color_table ();
5513 #endif /* COLOR_TABLE_SUPPORT */
5514
5515 img->width = width;
5516 img->height = height;
5517
5518 /* Maybe fill in the background field while we have ximg handy. */
5519
5520 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
5521 /* Casting avoids a GCC warning. */
5522 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
5523
5524 /* Put the image into a pixmap. */
5525 x_put_x_image (f, ximg, img->pixmap, width, height);
5526 x_destroy_x_image (ximg);
5527
5528 /* X and W32 versions did it here, MAC version above. ++kfs
5529 img->width = width;
5530 img->height = height; */
5531
5532 UNGCPRO;
5533 xfree (contents);
5534 return 1;
5535 }
5536
5537 \f
5538 /***********************************************************************
5539 PNG
5540 ***********************************************************************/
5541
5542 #if defined (HAVE_PNG) || defined (MAC_OS)
5543
5544 /* Function prototypes. */
5545
5546 static int png_image_p P_ ((Lisp_Object object));
5547 static int png_load P_ ((struct frame *f, struct image *img));
5548
5549 /* The symbol `png' identifying images of this type. */
5550
5551 Lisp_Object Qpng;
5552
5553 /* Indices of image specification fields in png_format, below. */
5554
5555 enum png_keyword_index
5556 {
5557 PNG_TYPE,
5558 PNG_DATA,
5559 PNG_FILE,
5560 PNG_ASCENT,
5561 PNG_MARGIN,
5562 PNG_RELIEF,
5563 PNG_ALGORITHM,
5564 PNG_HEURISTIC_MASK,
5565 PNG_MASK,
5566 PNG_BACKGROUND,
5567 PNG_LAST
5568 };
5569
5570 /* Vector of image_keyword structures describing the format
5571 of valid user-defined image specifications. */
5572
5573 static struct image_keyword png_format[PNG_LAST] =
5574 {
5575 {":type", IMAGE_SYMBOL_VALUE, 1},
5576 {":data", IMAGE_STRING_VALUE, 0},
5577 {":file", IMAGE_STRING_VALUE, 0},
5578 {":ascent", IMAGE_ASCENT_VALUE, 0},
5579 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
5580 {":relief", IMAGE_INTEGER_VALUE, 0},
5581 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5582 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5583 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
5584 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
5585 };
5586
5587 /* Structure describing the image type `png'. */
5588
5589 static struct image_type png_type =
5590 {
5591 &Qpng,
5592 png_image_p,
5593 png_load,
5594 x_clear_image,
5595 NULL
5596 };
5597
5598 /* Return non-zero if OBJECT is a valid PNG image specification. */
5599
5600 static int
5601 png_image_p (object)
5602 Lisp_Object object;
5603 {
5604 struct image_keyword fmt[PNG_LAST];
5605 bcopy (png_format, fmt, sizeof fmt);
5606
5607 if (!parse_image_spec (object, fmt, PNG_LAST, Qpng))
5608 return 0;
5609
5610 /* Must specify either the :data or :file keyword. */
5611 return fmt[PNG_FILE].count + fmt[PNG_DATA].count == 1;
5612 }
5613
5614 #endif /* HAVE_PNG || MAC_OS */
5615
5616
5617 #ifdef HAVE_PNG
5618
5619 #if defined HAVE_LIBPNG_PNG_H
5620 # include <libpng/png.h>
5621 #else
5622 # include <png.h>
5623 #endif
5624
5625 #ifdef HAVE_NTGUI
5626 /* PNG library details. */
5627
5628 DEF_IMGLIB_FN (png_get_io_ptr);
5629 DEF_IMGLIB_FN (png_check_sig);
5630 DEF_IMGLIB_FN (png_create_read_struct);
5631 DEF_IMGLIB_FN (png_create_info_struct);
5632 DEF_IMGLIB_FN (png_destroy_read_struct);
5633 DEF_IMGLIB_FN (png_set_read_fn);
5634 DEF_IMGLIB_FN (png_set_sig_bytes);
5635 DEF_IMGLIB_FN (png_read_info);
5636 DEF_IMGLIB_FN (png_get_IHDR);
5637 DEF_IMGLIB_FN (png_get_valid);
5638 DEF_IMGLIB_FN (png_set_strip_16);
5639 DEF_IMGLIB_FN (png_set_expand);
5640 DEF_IMGLIB_FN (png_set_gray_to_rgb);
5641 DEF_IMGLIB_FN (png_set_background);
5642 DEF_IMGLIB_FN (png_get_bKGD);
5643 DEF_IMGLIB_FN (png_read_update_info);
5644 DEF_IMGLIB_FN (png_get_channels);
5645 DEF_IMGLIB_FN (png_get_rowbytes);
5646 DEF_IMGLIB_FN (png_read_image);
5647 DEF_IMGLIB_FN (png_read_end);
5648 DEF_IMGLIB_FN (png_error);
5649
5650 static int
5651 init_png_functions (Lisp_Object libraries)
5652 {
5653 HMODULE library;
5654
5655 /* Try loading libpng under probable names. */
5656 if (!(library = w32_delayed_load (libraries, Qpng)))
5657 return 0;
5658
5659 LOAD_IMGLIB_FN (library, png_get_io_ptr);
5660 LOAD_IMGLIB_FN (library, png_check_sig);
5661 LOAD_IMGLIB_FN (library, png_create_read_struct);
5662 LOAD_IMGLIB_FN (library, png_create_info_struct);
5663 LOAD_IMGLIB_FN (library, png_destroy_read_struct);
5664 LOAD_IMGLIB_FN (library, png_set_read_fn);
5665 LOAD_IMGLIB_FN (library, png_set_sig_bytes);
5666 LOAD_IMGLIB_FN (library, png_read_info);
5667 LOAD_IMGLIB_FN (library, png_get_IHDR);
5668 LOAD_IMGLIB_FN (library, png_get_valid);
5669 LOAD_IMGLIB_FN (library, png_set_strip_16);
5670 LOAD_IMGLIB_FN (library, png_set_expand);
5671 LOAD_IMGLIB_FN (library, png_set_gray_to_rgb);
5672 LOAD_IMGLIB_FN (library, png_set_background);
5673 LOAD_IMGLIB_FN (library, png_get_bKGD);
5674 LOAD_IMGLIB_FN (library, png_read_update_info);
5675 LOAD_IMGLIB_FN (library, png_get_channels);
5676 LOAD_IMGLIB_FN (library, png_get_rowbytes);
5677 LOAD_IMGLIB_FN (library, png_read_image);
5678 LOAD_IMGLIB_FN (library, png_read_end);
5679 LOAD_IMGLIB_FN (library, png_error);
5680 return 1;
5681 }
5682 #else
5683
5684 #define fn_png_get_io_ptr png_get_io_ptr
5685 #define fn_png_check_sig png_check_sig
5686 #define fn_png_create_read_struct png_create_read_struct
5687 #define fn_png_create_info_struct png_create_info_struct
5688 #define fn_png_destroy_read_struct png_destroy_read_struct
5689 #define fn_png_set_read_fn png_set_read_fn
5690 #define fn_png_set_sig_bytes png_set_sig_bytes
5691 #define fn_png_read_info png_read_info
5692 #define fn_png_get_IHDR png_get_IHDR
5693 #define fn_png_get_valid png_get_valid
5694 #define fn_png_set_strip_16 png_set_strip_16
5695 #define fn_png_set_expand png_set_expand
5696 #define fn_png_set_gray_to_rgb png_set_gray_to_rgb
5697 #define fn_png_set_background png_set_background
5698 #define fn_png_get_bKGD png_get_bKGD
5699 #define fn_png_read_update_info png_read_update_info
5700 #define fn_png_get_channels png_get_channels
5701 #define fn_png_get_rowbytes png_get_rowbytes
5702 #define fn_png_read_image png_read_image
5703 #define fn_png_read_end png_read_end
5704 #define fn_png_error png_error
5705
5706 #endif /* HAVE_NTGUI */
5707
5708 /* Error and warning handlers installed when the PNG library
5709 is initialized. */
5710
5711 static void
5712 my_png_error (png_ptr, msg)
5713 png_struct *png_ptr;
5714 char *msg;
5715 {
5716 xassert (png_ptr != NULL);
5717 image_error ("PNG error: %s", build_string (msg), Qnil);
5718 longjmp (png_ptr->jmpbuf, 1);
5719 }
5720
5721
5722 static void
5723 my_png_warning (png_ptr, msg)
5724 png_struct *png_ptr;
5725 char *msg;
5726 {
5727 xassert (png_ptr != NULL);
5728 image_error ("PNG warning: %s", build_string (msg), Qnil);
5729 }
5730
5731 /* Memory source for PNG decoding. */
5732
5733 struct png_memory_storage
5734 {
5735 unsigned char *bytes; /* The data */
5736 size_t len; /* How big is it? */
5737 int index; /* Where are we? */
5738 };
5739
5740
5741 /* Function set as reader function when reading PNG image from memory.
5742 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5743 bytes from the input to DATA. */
5744
5745 static void
5746 png_read_from_memory (png_ptr, data, length)
5747 png_structp png_ptr;
5748 png_bytep data;
5749 png_size_t length;
5750 {
5751 struct png_memory_storage *tbr
5752 = (struct png_memory_storage *) fn_png_get_io_ptr (png_ptr);
5753
5754 if (length > tbr->len - tbr->index)
5755 fn_png_error (png_ptr, "Read error");
5756
5757 bcopy (tbr->bytes + tbr->index, data, length);
5758 tbr->index = tbr->index + length;
5759 }
5760
5761
5762 /* Function set as reader function when reading PNG image from a file.
5763 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
5764 bytes from the input to DATA. */
5765
5766 static void
5767 png_read_from_file (png_ptr, data, length)
5768 png_structp png_ptr;
5769 png_bytep data;
5770 png_size_t length;
5771 {
5772 FILE *fp = (FILE *) fn_png_get_io_ptr (png_ptr);
5773
5774 if (fread (data, 1, length, fp) < length)
5775 fn_png_error (png_ptr, "Read error");
5776 }
5777
5778
5779 /* Load PNG image IMG for use on frame F. Value is non-zero if
5780 successful. */
5781
5782 static int
5783 png_load (f, img)
5784 struct frame *f;
5785 struct image *img;
5786 {
5787 Lisp_Object file, specified_file;
5788 Lisp_Object specified_data;
5789 int x, y, i;
5790 XImagePtr ximg, mask_img = NULL;
5791 struct gcpro gcpro1;
5792 png_struct *png_ptr = NULL;
5793 png_info *info_ptr = NULL, *end_info = NULL;
5794 FILE *volatile fp = NULL;
5795 png_byte sig[8];
5796 png_byte * volatile pixels = NULL;
5797 png_byte ** volatile rows = NULL;
5798 png_uint_32 width, height;
5799 int bit_depth, color_type, interlace_type;
5800 png_byte channels;
5801 png_uint_32 row_bytes;
5802 int transparent_p;
5803 double screen_gamma;
5804 struct png_memory_storage tbr; /* Data to be read */
5805
5806 /* Find out what file to load. */
5807 specified_file = image_spec_value (img->spec, QCfile, NULL);
5808 specified_data = image_spec_value (img->spec, QCdata, NULL);
5809 file = Qnil;
5810 GCPRO1 (file);
5811
5812 if (NILP (specified_data))
5813 {
5814 file = x_find_image_file (specified_file);
5815 if (!STRINGP (file))
5816 {
5817 image_error ("Cannot find image file `%s'", specified_file, Qnil);
5818 UNGCPRO;
5819 return 0;
5820 }
5821
5822 /* Open the image file. */
5823 fp = fopen (SDATA (file), "rb");
5824 if (!fp)
5825 {
5826 image_error ("Cannot open image file `%s'", file, Qnil);
5827 UNGCPRO;
5828 fclose (fp);
5829 return 0;
5830 }
5831
5832 /* Check PNG signature. */
5833 if (fread (sig, 1, sizeof sig, fp) != sizeof sig
5834 || !fn_png_check_sig (sig, sizeof sig))
5835 {
5836 image_error ("Not a PNG file: `%s'", file, Qnil);
5837 UNGCPRO;
5838 fclose (fp);
5839 return 0;
5840 }
5841 }
5842 else
5843 {
5844 /* Read from memory. */
5845 tbr.bytes = SDATA (specified_data);
5846 tbr.len = SBYTES (specified_data);
5847 tbr.index = 0;
5848
5849 /* Check PNG signature. */
5850 if (tbr.len < sizeof sig
5851 || !fn_png_check_sig (tbr.bytes, sizeof sig))
5852 {
5853 image_error ("Not a PNG image: `%s'", img->spec, Qnil);
5854 UNGCPRO;
5855 return 0;
5856 }
5857
5858 /* Need to skip past the signature. */
5859 tbr.bytes += sizeof (sig);
5860 }
5861
5862 /* Initialize read and info structs for PNG lib. Casting return
5863 value avoids a GCC warning on W32. */
5864 png_ptr = (png_structp)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING,
5865 NULL, my_png_error,
5866 my_png_warning);
5867 if (!png_ptr)
5868 {
5869 if (fp) fclose (fp);
5870 UNGCPRO;
5871 return 0;
5872 }
5873
5874 /* Casting return value avoids a GCC warning on W32. */
5875 info_ptr = (png_infop)fn_png_create_info_struct (png_ptr);
5876 if (!info_ptr)
5877 {
5878 fn_png_destroy_read_struct (&png_ptr, NULL, NULL);
5879 if (fp) fclose (fp);
5880 UNGCPRO;
5881 return 0;
5882 }
5883
5884 /* Casting return value avoids a GCC warning on W32. */
5885 end_info = (png_infop)fn_png_create_info_struct (png_ptr);
5886 if (!end_info)
5887 {
5888 fn_png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
5889 if (fp) fclose (fp);
5890 UNGCPRO;
5891 return 0;
5892 }
5893
5894 /* Set error jump-back. We come back here when the PNG library
5895 detects an error. */
5896 if (setjmp (png_ptr->jmpbuf))
5897 {
5898 error:
5899 if (png_ptr)
5900 fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
5901 xfree (pixels);
5902 xfree (rows);
5903 if (fp) fclose (fp);
5904 UNGCPRO;
5905 return 0;
5906 }
5907
5908 /* Read image info. */
5909 if (!NILP (specified_data))
5910 fn_png_set_read_fn (png_ptr, (void *) &tbr, png_read_from_memory);
5911 else
5912 fn_png_set_read_fn (png_ptr, (void *) fp, png_read_from_file);
5913
5914 fn_png_set_sig_bytes (png_ptr, sizeof sig);
5915 fn_png_read_info (png_ptr, info_ptr);
5916 fn_png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
5917 &interlace_type, NULL, NULL);
5918
5919 /* If image contains simply transparency data, we prefer to
5920 construct a clipping mask. */
5921 if (fn_png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
5922 transparent_p = 1;
5923 else
5924 transparent_p = 0;
5925
5926 /* This function is easier to write if we only have to handle
5927 one data format: RGB or RGBA with 8 bits per channel. Let's
5928 transform other formats into that format. */
5929
5930 /* Strip more than 8 bits per channel. */
5931 if (bit_depth == 16)
5932 fn_png_set_strip_16 (png_ptr);
5933
5934 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
5935 if available. */
5936 fn_png_set_expand (png_ptr);
5937
5938 /* Convert grayscale images to RGB. */
5939 if (color_type == PNG_COLOR_TYPE_GRAY
5940 || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
5941 fn_png_set_gray_to_rgb (png_ptr);
5942
5943 screen_gamma = (f->gamma ? 1 / f->gamma / 0.45455 : 2.2);
5944
5945 #if 0 /* Avoid double gamma correction for PNG images. */
5946 { /* Tell the PNG lib to handle gamma correction for us. */
5947 int intent;
5948 double image_gamma;
5949 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
5950 if (png_get_sRGB (png_ptr, info_ptr, &intent))
5951 /* The libpng documentation says this is right in this case. */
5952 png_set_gamma (png_ptr, screen_gamma, 0.45455);
5953 else
5954 #endif
5955 if (png_get_gAMA (png_ptr, info_ptr, &image_gamma))
5956 /* Image contains gamma information. */
5957 png_set_gamma (png_ptr, screen_gamma, image_gamma);
5958 else
5959 /* Use the standard default for the image gamma. */
5960 png_set_gamma (png_ptr, screen_gamma, 0.45455);
5961 }
5962 #endif /* if 0 */
5963
5964 /* Handle alpha channel by combining the image with a background
5965 color. Do this only if a real alpha channel is supplied. For
5966 simple transparency, we prefer a clipping mask. */
5967 if (!transparent_p)
5968 {
5969 png_color_16 *image_bg;
5970 Lisp_Object specified_bg
5971 = image_spec_value (img->spec, QCbackground, NULL);
5972
5973 if (STRINGP (specified_bg))
5974 /* The user specified `:background', use that. */
5975 {
5976 /* W32 version incorrectly used COLORREF here!! ++kfs */
5977 XColor color;
5978 if (x_defined_color (f, SDATA (specified_bg), &color, 0))
5979 {
5980 png_color_16 user_bg;
5981
5982 bzero (&user_bg, sizeof user_bg);
5983 user_bg.red = color.red >> 8;
5984 user_bg.green = color.green >> 8;
5985 user_bg.blue = color.blue >> 8;
5986
5987 fn_png_set_background (png_ptr, &user_bg,
5988 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
5989 }
5990 }
5991 else if (fn_png_get_bKGD (png_ptr, info_ptr, &image_bg))
5992 /* Image contains a background color with which to
5993 combine the image. */
5994 fn_png_set_background (png_ptr, image_bg,
5995 PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
5996 else
5997 {
5998 /* Image does not contain a background color with which
5999 to combine the image data via an alpha channel. Use
6000 the frame's background instead. */
6001 #ifdef HAVE_X_WINDOWS
6002 XColor color;
6003 png_color_16 frame_background;
6004
6005 color.pixel = FRAME_BACKGROUND_PIXEL (f);
6006 x_query_color (f, &color);
6007
6008 bzero (&frame_background, sizeof frame_background);
6009 frame_background.red = color.red >> 8;
6010 frame_background.green = color.green >> 8;
6011 frame_background.blue = color.blue >> 8;
6012 #endif /* HAVE_X_WINDOWS */
6013
6014 #ifdef HAVE_NTGUI
6015 COLORREF color;
6016 png_color_16 frame_background;
6017 color = FRAME_BACKGROUND_PIXEL (f);
6018 #if 0 /* W32 TODO : Colormap support. */
6019 x_query_color (f, &color);
6020 #endif
6021 bzero (&frame_background, sizeof frame_background);
6022 frame_background.red = GetRValue (color);
6023 frame_background.green = GetGValue (color);
6024 frame_background.blue = GetBValue (color);
6025 #endif /* HAVE_NTGUI */
6026
6027 #ifdef MAC_OS
6028 unsigned long color;
6029 png_color_16 frame_background;
6030 color = FRAME_BACKGROUND_PIXEL (f);
6031 #if 0 /* MAC/W32 TODO : Colormap support. */
6032 x_query_color (f, &color);
6033 #endif
6034 bzero (&frame_background, sizeof frame_background);
6035 frame_background.red = RED_FROM_ULONG (color);
6036 frame_background.green = GREEN_FROM_ULONG (color);
6037 frame_background.blue = BLUE_FROM_ULONG (color);
6038 #endif /* MAC_OS */
6039
6040 fn_png_set_background (png_ptr, &frame_background,
6041 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
6042 }
6043 }
6044
6045 /* Update info structure. */
6046 fn_png_read_update_info (png_ptr, info_ptr);
6047
6048 /* Get number of channels. Valid values are 1 for grayscale images
6049 and images with a palette, 2 for grayscale images with transparency
6050 information (alpha channel), 3 for RGB images, and 4 for RGB
6051 images with alpha channel, i.e. RGBA. If conversions above were
6052 sufficient we should only have 3 or 4 channels here. */
6053 channels = fn_png_get_channels (png_ptr, info_ptr);
6054 xassert (channels == 3 || channels == 4);
6055
6056 /* Number of bytes needed for one row of the image. */
6057 row_bytes = fn_png_get_rowbytes (png_ptr, info_ptr);
6058
6059 /* Allocate memory for the image. */
6060 pixels = (png_byte *) xmalloc (row_bytes * height * sizeof *pixels);
6061 rows = (png_byte **) xmalloc (height * sizeof *rows);
6062 for (i = 0; i < height; ++i)
6063 rows[i] = pixels + i * row_bytes;
6064
6065 /* Read the entire image. */
6066 fn_png_read_image (png_ptr, rows);
6067 fn_png_read_end (png_ptr, info_ptr);
6068 if (fp)
6069 {
6070 fclose (fp);
6071 fp = NULL;
6072 }
6073
6074 /* Create the X image and pixmap. */
6075 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
6076 &img->pixmap))
6077 goto error;
6078
6079 /* Create an image and pixmap serving as mask if the PNG image
6080 contains an alpha channel. */
6081 if (channels == 4
6082 && !transparent_p
6083 && !x_create_x_image_and_pixmap (f, width, height, 1,
6084 &mask_img, &img->mask))
6085 {
6086 x_destroy_x_image (ximg);
6087 Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
6088 img->pixmap = NO_PIXMAP;
6089 goto error;
6090 }
6091
6092 /* Fill the X image and mask from PNG data. */
6093 init_color_table ();
6094
6095 for (y = 0; y < height; ++y)
6096 {
6097 png_byte *p = rows[y];
6098
6099 for (x = 0; x < width; ++x)
6100 {
6101 unsigned r, g, b;
6102
6103 r = *p++ << 8;
6104 g = *p++ << 8;
6105 b = *p++ << 8;
6106 XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
6107 /* An alpha channel, aka mask channel, associates variable
6108 transparency with an image. Where other image formats
6109 support binary transparency---fully transparent or fully
6110 opaque---PNG allows up to 254 levels of partial transparency.
6111 The PNG library implements partial transparency by combining
6112 the image with a specified background color.
6113
6114 I'm not sure how to handle this here nicely: because the
6115 background on which the image is displayed may change, for
6116 real alpha channel support, it would be necessary to create
6117 a new image for each possible background.
6118
6119 What I'm doing now is that a mask is created if we have
6120 boolean transparency information. Otherwise I'm using
6121 the frame's background color to combine the image with. */
6122
6123 if (channels == 4)
6124 {
6125 if (mask_img)
6126 XPutPixel (mask_img, x, y, *p > 0 ? PIX_MASK_DRAW (f) : PIX_MASK_RETAIN (f));
6127 ++p;
6128 }
6129 }
6130 }
6131
6132 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
6133 /* Set IMG's background color from the PNG image, unless the user
6134 overrode it. */
6135 {
6136 png_color_16 *bg;
6137 if (fn_png_get_bKGD (png_ptr, info_ptr, &bg))
6138 {
6139 img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
6140 img->background_valid = 1;
6141 }
6142 }
6143
6144 #ifdef COLOR_TABLE_SUPPORT
6145 /* Remember colors allocated for this image. */
6146 img->colors = colors_in_color_table (&img->ncolors);
6147 free_color_table ();
6148 #endif /* COLOR_TABLE_SUPPORT */
6149
6150 /* Clean up. */
6151 fn_png_destroy_read_struct (&png_ptr, &info_ptr, &end_info);
6152 xfree (rows);
6153 xfree (pixels);
6154
6155 img->width = width;
6156 img->height = height;
6157
6158 /* Maybe fill in the background field while we have ximg handy.
6159 Casting avoids a GCC warning. */
6160 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
6161
6162 /* Put the image into the pixmap, then free the X image and its buffer. */
6163 x_put_x_image (f, ximg, img->pixmap, width, height);
6164 x_destroy_x_image (ximg);
6165
6166 /* Same for the mask. */
6167 if (mask_img)
6168 {
6169 /* Fill in the background_transparent field while we have the
6170 mask handy. Casting avoids a GCC warning. */
6171 image_background_transparent (img, f, (XImagePtr_or_DC)mask_img);
6172
6173 x_put_x_image (f, mask_img, img->mask, img->width, img->height);
6174 x_destroy_x_image (mask_img);
6175 }
6176
6177 UNGCPRO;
6178 return 1;
6179 }
6180
6181 #else /* HAVE_PNG */
6182
6183 #ifdef MAC_OS
6184 static int
6185 png_load (f, img)
6186 struct frame *f;
6187 struct image *img;
6188 {
6189 #ifdef MAC_OSX
6190 if (MyCGImageCreateWithPNGDataProvider)
6191 return image_load_quartz2d (f, img, 1);
6192 else
6193 #endif
6194 return image_load_quicktime (f, img, kQTFileTypePNG);
6195 }
6196 #endif /* MAC_OS */
6197
6198 #endif /* !HAVE_PNG */
6199
6200
6201 \f
6202 /***********************************************************************
6203 JPEG
6204 ***********************************************************************/
6205
6206 #if defined (HAVE_JPEG) || defined (MAC_OS)
6207
6208 static int jpeg_image_p P_ ((Lisp_Object object));
6209 static int jpeg_load P_ ((struct frame *f, struct image *img));
6210
6211 /* The symbol `jpeg' identifying images of this type. */
6212
6213 Lisp_Object Qjpeg;
6214
6215 /* Indices of image specification fields in gs_format, below. */
6216
6217 enum jpeg_keyword_index
6218 {
6219 JPEG_TYPE,
6220 JPEG_DATA,
6221 JPEG_FILE,
6222 JPEG_ASCENT,
6223 JPEG_MARGIN,
6224 JPEG_RELIEF,
6225 JPEG_ALGORITHM,
6226 JPEG_HEURISTIC_MASK,
6227 JPEG_MASK,
6228 JPEG_BACKGROUND,
6229 JPEG_LAST
6230 };
6231
6232 /* Vector of image_keyword structures describing the format
6233 of valid user-defined image specifications. */
6234
6235 static struct image_keyword jpeg_format[JPEG_LAST] =
6236 {
6237 {":type", IMAGE_SYMBOL_VALUE, 1},
6238 {":data", IMAGE_STRING_VALUE, 0},
6239 {":file", IMAGE_STRING_VALUE, 0},
6240 {":ascent", IMAGE_ASCENT_VALUE, 0},
6241 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
6242 {":relief", IMAGE_INTEGER_VALUE, 0},
6243 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6244 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6245 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6246 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
6247 };
6248
6249 /* Structure describing the image type `jpeg'. */
6250
6251 static struct image_type jpeg_type =
6252 {
6253 &Qjpeg,
6254 jpeg_image_p,
6255 jpeg_load,
6256 x_clear_image,
6257 NULL
6258 };
6259
6260 /* Return non-zero if OBJECT is a valid JPEG image specification. */
6261
6262 static int
6263 jpeg_image_p (object)
6264 Lisp_Object object;
6265 {
6266 struct image_keyword fmt[JPEG_LAST];
6267
6268 bcopy (jpeg_format, fmt, sizeof fmt);
6269
6270 if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg))
6271 return 0;
6272
6273 /* Must specify either the :data or :file keyword. */
6274 return fmt[JPEG_FILE].count + fmt[JPEG_DATA].count == 1;
6275 }
6276
6277 #endif /* HAVE_JPEG || MAC_OS */
6278
6279 #ifdef HAVE_JPEG
6280
6281 /* Work around a warning about HAVE_STDLIB_H being redefined in
6282 jconfig.h. */
6283 #ifdef HAVE_STDLIB_H
6284 #define HAVE_STDLIB_H_1
6285 #undef HAVE_STDLIB_H
6286 #endif /* HAVE_STLIB_H */
6287
6288 #if defined (HAVE_NTGUI) && !defined (__WIN32__)
6289 /* In older releases of the jpeg library, jpeglib.h will define boolean
6290 differently depending on __WIN32__, so make sure it is defined. */
6291 #define __WIN32__ 1
6292 #endif
6293
6294 #include <jpeglib.h>
6295 #include <jerror.h>
6296 #include <setjmp.h>
6297
6298 #ifdef HAVE_STLIB_H_1
6299 #define HAVE_STDLIB_H 1
6300 #endif
6301
6302 #ifdef HAVE_NTGUI
6303
6304 /* JPEG library details. */
6305 DEF_IMGLIB_FN (jpeg_CreateDecompress);
6306 DEF_IMGLIB_FN (jpeg_start_decompress);
6307 DEF_IMGLIB_FN (jpeg_finish_decompress);
6308 DEF_IMGLIB_FN (jpeg_destroy_decompress);
6309 DEF_IMGLIB_FN (jpeg_read_header);
6310 DEF_IMGLIB_FN (jpeg_read_scanlines);
6311 DEF_IMGLIB_FN (jpeg_stdio_src);
6312 DEF_IMGLIB_FN (jpeg_std_error);
6313 DEF_IMGLIB_FN (jpeg_resync_to_restart);
6314
6315 static int
6316 init_jpeg_functions (Lisp_Object libraries)
6317 {
6318 HMODULE library;
6319
6320 if (!(library = w32_delayed_load (libraries, Qjpeg)))
6321 return 0;
6322
6323 LOAD_IMGLIB_FN (library, jpeg_finish_decompress);
6324 LOAD_IMGLIB_FN (library, jpeg_read_scanlines);
6325 LOAD_IMGLIB_FN (library, jpeg_start_decompress);
6326 LOAD_IMGLIB_FN (library, jpeg_read_header);
6327 LOAD_IMGLIB_FN (library, jpeg_stdio_src);
6328 LOAD_IMGLIB_FN (library, jpeg_CreateDecompress);
6329 LOAD_IMGLIB_FN (library, jpeg_destroy_decompress);
6330 LOAD_IMGLIB_FN (library, jpeg_std_error);
6331 LOAD_IMGLIB_FN (library, jpeg_resync_to_restart);
6332 return 1;
6333 }
6334
6335 /* Wrapper since we can't directly assign the function pointer
6336 to another function pointer that was declared more completely easily. */
6337 static boolean
6338 jpeg_resync_to_restart_wrapper(cinfo, desired)
6339 j_decompress_ptr cinfo;
6340 int desired;
6341 {
6342 return fn_jpeg_resync_to_restart (cinfo, desired);
6343 }
6344
6345 #else
6346
6347 #define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress(a)
6348 #define fn_jpeg_start_decompress jpeg_start_decompress
6349 #define fn_jpeg_finish_decompress jpeg_finish_decompress
6350 #define fn_jpeg_destroy_decompress jpeg_destroy_decompress
6351 #define fn_jpeg_read_header jpeg_read_header
6352 #define fn_jpeg_read_scanlines jpeg_read_scanlines
6353 #define fn_jpeg_stdio_src jpeg_stdio_src
6354 #define fn_jpeg_std_error jpeg_std_error
6355 #define jpeg_resync_to_restart_wrapper jpeg_resync_to_restart
6356
6357 #endif /* HAVE_NTGUI */
6358
6359 struct my_jpeg_error_mgr
6360 {
6361 struct jpeg_error_mgr pub;
6362 jmp_buf setjmp_buffer;
6363 };
6364
6365
6366 static void
6367 my_error_exit (cinfo)
6368 j_common_ptr cinfo;
6369 {
6370 struct my_jpeg_error_mgr *mgr = (struct my_jpeg_error_mgr *) cinfo->err;
6371 longjmp (mgr->setjmp_buffer, 1);
6372 }
6373
6374
6375 /* Init source method for JPEG data source manager. Called by
6376 jpeg_read_header() before any data is actually read. See
6377 libjpeg.doc from the JPEG lib distribution. */
6378
6379 static void
6380 our_init_source (cinfo)
6381 j_decompress_ptr cinfo;
6382 {
6383 }
6384
6385
6386 /* Fill input buffer method for JPEG data source manager. Called
6387 whenever more data is needed. We read the whole image in one step,
6388 so this only adds a fake end of input marker at the end. */
6389
6390 static boolean
6391 our_fill_input_buffer (cinfo)
6392 j_decompress_ptr cinfo;
6393 {
6394 /* Insert a fake EOI marker. */
6395 struct jpeg_source_mgr *src = cinfo->src;
6396 static JOCTET buffer[2];
6397
6398 buffer[0] = (JOCTET) 0xFF;
6399 buffer[1] = (JOCTET) JPEG_EOI;
6400
6401 src->next_input_byte = buffer;
6402 src->bytes_in_buffer = 2;
6403 return 1;
6404 }
6405
6406
6407 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
6408 is the JPEG data source manager. */
6409
6410 static void
6411 our_skip_input_data (cinfo, num_bytes)
6412 j_decompress_ptr cinfo;
6413 long num_bytes;
6414 {
6415 struct jpeg_source_mgr *src = (struct jpeg_source_mgr *) cinfo->src;
6416
6417 if (src)
6418 {
6419 if (num_bytes > src->bytes_in_buffer)
6420 ERREXIT (cinfo, JERR_INPUT_EOF);
6421
6422 src->bytes_in_buffer -= num_bytes;
6423 src->next_input_byte += num_bytes;
6424 }
6425 }
6426
6427
6428 /* Method to terminate data source. Called by
6429 jpeg_finish_decompress() after all data has been processed. */
6430
6431 static void
6432 our_term_source (cinfo)
6433 j_decompress_ptr cinfo;
6434 {
6435 }
6436
6437
6438 /* Set up the JPEG lib for reading an image from DATA which contains
6439 LEN bytes. CINFO is the decompression info structure created for
6440 reading the image. */
6441
6442 static void
6443 jpeg_memory_src (cinfo, data, len)
6444 j_decompress_ptr cinfo;
6445 JOCTET *data;
6446 unsigned int len;
6447 {
6448 struct jpeg_source_mgr *src;
6449
6450 if (cinfo->src == NULL)
6451 {
6452 /* First time for this JPEG object? */
6453 cinfo->src = (struct jpeg_source_mgr *)
6454 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
6455 sizeof (struct jpeg_source_mgr));
6456 src = (struct jpeg_source_mgr *) cinfo->src;
6457 src->next_input_byte = data;
6458 }
6459
6460 src = (struct jpeg_source_mgr *) cinfo->src;
6461 src->init_source = our_init_source;
6462 src->fill_input_buffer = our_fill_input_buffer;
6463 src->skip_input_data = our_skip_input_data;
6464 src->resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method. */
6465 src->term_source = our_term_source;
6466 src->bytes_in_buffer = len;
6467 src->next_input_byte = data;
6468 }
6469
6470
6471 /* Load image IMG for use on frame F. Patterned after example.c
6472 from the JPEG lib. */
6473
6474 static int
6475 jpeg_load (f, img)
6476 struct frame *f;
6477 struct image *img;
6478 {
6479 struct jpeg_decompress_struct cinfo;
6480 struct my_jpeg_error_mgr mgr;
6481 Lisp_Object file, specified_file;
6482 Lisp_Object specified_data;
6483 FILE * volatile fp = NULL;
6484 JSAMPARRAY buffer;
6485 int row_stride, x, y;
6486 XImagePtr ximg = NULL;
6487 int rc;
6488 unsigned long *colors;
6489 int width, height;
6490 struct gcpro gcpro1;
6491
6492 /* Open the JPEG file. */
6493 specified_file = image_spec_value (img->spec, QCfile, NULL);
6494 specified_data = image_spec_value (img->spec, QCdata, NULL);
6495 file = Qnil;
6496 GCPRO1 (file);
6497
6498 if (NILP (specified_data))
6499 {
6500 file = x_find_image_file (specified_file);
6501 if (!STRINGP (file))
6502 {
6503 image_error ("Cannot find image file `%s'", specified_file, Qnil);
6504 UNGCPRO;
6505 return 0;
6506 }
6507
6508 fp = fopen (SDATA (file), "rb");
6509 if (fp == NULL)
6510 {
6511 image_error ("Cannot open `%s'", file, Qnil);
6512 UNGCPRO;
6513 return 0;
6514 }
6515 }
6516
6517 /* Customize libjpeg's error handling to call my_error_exit when an
6518 error is detected. This function will perform a longjmp.
6519 Casting return value avoids a GCC warning on W32. */
6520 cinfo.err = (struct jpeg_error_mgr *)fn_jpeg_std_error (&mgr.pub);
6521 mgr.pub.error_exit = my_error_exit;
6522
6523 if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
6524 {
6525 if (rc == 1)
6526 {
6527 /* Called from my_error_exit. Display a JPEG error. */
6528 char buffer[JMSG_LENGTH_MAX];
6529 cinfo.err->format_message ((j_common_ptr) &cinfo, buffer);
6530 image_error ("Error reading JPEG image `%s': %s", img->spec,
6531 build_string (buffer));
6532 }
6533
6534 /* Close the input file and destroy the JPEG object. */
6535 if (fp)
6536 fclose ((FILE *) fp);
6537 fn_jpeg_destroy_decompress (&cinfo);
6538
6539 /* If we already have an XImage, free that. */
6540 x_destroy_x_image (ximg);
6541
6542 /* Free pixmap and colors. */
6543 x_clear_image (f, img);
6544
6545 UNGCPRO;
6546 return 0;
6547 }
6548
6549 /* Create the JPEG decompression object. Let it read from fp.
6550 Read the JPEG image header. */
6551 fn_jpeg_CreateDecompress (&cinfo, JPEG_LIB_VERSION, sizeof (cinfo));
6552
6553 if (NILP (specified_data))
6554 fn_jpeg_stdio_src (&cinfo, (FILE *) fp);
6555 else
6556 jpeg_memory_src (&cinfo, SDATA (specified_data),
6557 SBYTES (specified_data));
6558
6559 fn_jpeg_read_header (&cinfo, 1);
6560
6561 /* Customize decompression so that color quantization will be used.
6562 Start decompression. */
6563 cinfo.quantize_colors = 1;
6564 fn_jpeg_start_decompress (&cinfo);
6565 width = img->width = cinfo.output_width;
6566 height = img->height = cinfo.output_height;
6567
6568 /* Create X image and pixmap. */
6569 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
6570 longjmp (mgr.setjmp_buffer, 2);
6571
6572 /* Allocate colors. When color quantization is used,
6573 cinfo.actual_number_of_colors has been set with the number of
6574 colors generated, and cinfo.colormap is a two-dimensional array
6575 of color indices in the range 0..cinfo.actual_number_of_colors.
6576 No more than 255 colors will be generated. */
6577 {
6578 int i, ir, ig, ib;
6579
6580 if (cinfo.out_color_components > 2)
6581 ir = 0, ig = 1, ib = 2;
6582 else if (cinfo.out_color_components > 1)
6583 ir = 0, ig = 1, ib = 0;
6584 else
6585 ir = 0, ig = 0, ib = 0;
6586
6587 /* Use the color table mechanism because it handles colors that
6588 cannot be allocated nicely. Such colors will be replaced with
6589 a default color, and we don't have to care about which colors
6590 can be freed safely, and which can't. */
6591 init_color_table ();
6592 colors = (unsigned long *) alloca (cinfo.actual_number_of_colors
6593 * sizeof *colors);
6594
6595 for (i = 0; i < cinfo.actual_number_of_colors; ++i)
6596 {
6597 /* Multiply RGB values with 255 because X expects RGB values
6598 in the range 0..0xffff. */
6599 int r = cinfo.colormap[ir][i] << 8;
6600 int g = cinfo.colormap[ig][i] << 8;
6601 int b = cinfo.colormap[ib][i] << 8;
6602 colors[i] = lookup_rgb_color (f, r, g, b);
6603 }
6604
6605 #ifdef COLOR_TABLE_SUPPORT
6606 /* Remember those colors actually allocated. */
6607 img->colors = colors_in_color_table (&img->ncolors);
6608 free_color_table ();
6609 #endif /* COLOR_TABLE_SUPPORT */
6610 }
6611
6612 /* Read pixels. */
6613 row_stride = width * cinfo.output_components;
6614 buffer = cinfo.mem->alloc_sarray ((j_common_ptr) &cinfo, JPOOL_IMAGE,
6615 row_stride, 1);
6616 for (y = 0; y < height; ++y)
6617 {
6618 fn_jpeg_read_scanlines (&cinfo, buffer, 1);
6619 for (x = 0; x < cinfo.output_width; ++x)
6620 XPutPixel (ximg, x, y, colors[buffer[0][x]]);
6621 }
6622
6623 /* Clean up. */
6624 fn_jpeg_finish_decompress (&cinfo);
6625 fn_jpeg_destroy_decompress (&cinfo);
6626 if (fp)
6627 fclose ((FILE *) fp);
6628
6629 /* Maybe fill in the background field while we have ximg handy. */
6630 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
6631 /* Casting avoids a GCC warning. */
6632 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
6633
6634 /* Put the image into the pixmap. */
6635 x_put_x_image (f, ximg, img->pixmap, width, height);
6636 x_destroy_x_image (ximg);
6637 UNGCPRO;
6638 return 1;
6639 }
6640
6641 #else /* HAVE_JPEG */
6642
6643 #ifdef MAC_OS
6644 static int
6645 jpeg_load (f, img)
6646 struct frame *f;
6647 struct image *img;
6648 {
6649 #ifdef MAC_OSX
6650 return image_load_quartz2d (f, img, 0);
6651 #else
6652 return image_load_quicktime (f, img, kQTFileTypeJPEG);
6653 #endif
6654 }
6655 #endif /* MAC_OS */
6656
6657 #endif /* !HAVE_JPEG */
6658
6659
6660 \f
6661 /***********************************************************************
6662 TIFF
6663 ***********************************************************************/
6664
6665 #if defined (HAVE_TIFF) || defined (MAC_OS)
6666
6667 static int tiff_image_p P_ ((Lisp_Object object));
6668 static int tiff_load P_ ((struct frame *f, struct image *img));
6669
6670 /* The symbol `tiff' identifying images of this type. */
6671
6672 Lisp_Object Qtiff;
6673
6674 /* Indices of image specification fields in tiff_format, below. */
6675
6676 enum tiff_keyword_index
6677 {
6678 TIFF_TYPE,
6679 TIFF_DATA,
6680 TIFF_FILE,
6681 TIFF_ASCENT,
6682 TIFF_MARGIN,
6683 TIFF_RELIEF,
6684 TIFF_ALGORITHM,
6685 TIFF_HEURISTIC_MASK,
6686 TIFF_MASK,
6687 TIFF_BACKGROUND,
6688 TIFF_LAST
6689 };
6690
6691 /* Vector of image_keyword structures describing the format
6692 of valid user-defined image specifications. */
6693
6694 static struct image_keyword tiff_format[TIFF_LAST] =
6695 {
6696 {":type", IMAGE_SYMBOL_VALUE, 1},
6697 {":data", IMAGE_STRING_VALUE, 0},
6698 {":file", IMAGE_STRING_VALUE, 0},
6699 {":ascent", IMAGE_ASCENT_VALUE, 0},
6700 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
6701 {":relief", IMAGE_INTEGER_VALUE, 0},
6702 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6703 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6704 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
6705 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
6706 };
6707
6708 /* Structure describing the image type `tiff'. */
6709
6710 static struct image_type tiff_type =
6711 {
6712 &Qtiff,
6713 tiff_image_p,
6714 tiff_load,
6715 x_clear_image,
6716 NULL
6717 };
6718
6719 /* Return non-zero if OBJECT is a valid TIFF image specification. */
6720
6721 static int
6722 tiff_image_p (object)
6723 Lisp_Object object;
6724 {
6725 struct image_keyword fmt[TIFF_LAST];
6726 bcopy (tiff_format, fmt, sizeof fmt);
6727
6728 if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff))
6729 return 0;
6730
6731 /* Must specify either the :data or :file keyword. */
6732 return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
6733 }
6734
6735 #endif /* HAVE_TIFF || MAC_OS */
6736
6737 #ifdef HAVE_TIFF
6738
6739 #include <tiffio.h>
6740
6741 #ifdef HAVE_NTGUI
6742
6743 /* TIFF library details. */
6744 DEF_IMGLIB_FN (TIFFSetErrorHandler);
6745 DEF_IMGLIB_FN (TIFFSetWarningHandler);
6746 DEF_IMGLIB_FN (TIFFOpen);
6747 DEF_IMGLIB_FN (TIFFClientOpen);
6748 DEF_IMGLIB_FN (TIFFGetField);
6749 DEF_IMGLIB_FN (TIFFReadRGBAImage);
6750 DEF_IMGLIB_FN (TIFFClose);
6751
6752 static int
6753 init_tiff_functions (Lisp_Object libraries)
6754 {
6755 HMODULE library;
6756
6757 if (!(library = w32_delayed_load (libraries, Qtiff)))
6758 return 0;
6759
6760 LOAD_IMGLIB_FN (library, TIFFSetErrorHandler);
6761 LOAD_IMGLIB_FN (library, TIFFSetWarningHandler);
6762 LOAD_IMGLIB_FN (library, TIFFOpen);
6763 LOAD_IMGLIB_FN (library, TIFFClientOpen);
6764 LOAD_IMGLIB_FN (library, TIFFGetField);
6765 LOAD_IMGLIB_FN (library, TIFFReadRGBAImage);
6766 LOAD_IMGLIB_FN (library, TIFFClose);
6767 return 1;
6768 }
6769
6770 #else
6771
6772 #define fn_TIFFSetErrorHandler TIFFSetErrorHandler
6773 #define fn_TIFFSetWarningHandler TIFFSetWarningHandler
6774 #define fn_TIFFOpen TIFFOpen
6775 #define fn_TIFFClientOpen TIFFClientOpen
6776 #define fn_TIFFGetField TIFFGetField
6777 #define fn_TIFFReadRGBAImage TIFFReadRGBAImage
6778 #define fn_TIFFClose TIFFClose
6779
6780 #endif /* HAVE_NTGUI */
6781
6782
6783 /* Reading from a memory buffer for TIFF images Based on the PNG
6784 memory source, but we have to provide a lot of extra functions.
6785 Blah.
6786
6787 We really only need to implement read and seek, but I am not
6788 convinced that the TIFF library is smart enough not to destroy
6789 itself if we only hand it the function pointers we need to
6790 override. */
6791
6792 typedef struct
6793 {
6794 unsigned char *bytes;
6795 size_t len;
6796 int index;
6797 }
6798 tiff_memory_source;
6799
6800 static size_t
6801 tiff_read_from_memory (data, buf, size)
6802 thandle_t data;
6803 tdata_t buf;
6804 tsize_t size;
6805 {
6806 tiff_memory_source *src = (tiff_memory_source *) data;
6807
6808 if (size > src->len - src->index)
6809 return (size_t) -1;
6810 bcopy (src->bytes + src->index, buf, size);
6811 src->index += size;
6812 return size;
6813 }
6814
6815 static size_t
6816 tiff_write_from_memory (data, buf, size)
6817 thandle_t data;
6818 tdata_t buf;
6819 tsize_t size;
6820 {
6821 return (size_t) -1;
6822 }
6823
6824 static toff_t
6825 tiff_seek_in_memory (data, off, whence)
6826 thandle_t data;
6827 toff_t off;
6828 int whence;
6829 {
6830 tiff_memory_source *src = (tiff_memory_source *) data;
6831 int idx;
6832
6833 switch (whence)
6834 {
6835 case SEEK_SET: /* Go from beginning of source. */
6836 idx = off;
6837 break;
6838
6839 case SEEK_END: /* Go from end of source. */
6840 idx = src->len + off;
6841 break;
6842
6843 case SEEK_CUR: /* Go from current position. */
6844 idx = src->index + off;
6845 break;
6846
6847 default: /* Invalid `whence'. */
6848 return -1;
6849 }
6850
6851 if (idx > src->len || idx < 0)
6852 return -1;
6853
6854 src->index = idx;
6855 return src->index;
6856 }
6857
6858 static int
6859 tiff_close_memory (data)
6860 thandle_t data;
6861 {
6862 /* NOOP */
6863 return 0;
6864 }
6865
6866 static int
6867 tiff_mmap_memory (data, pbase, psize)
6868 thandle_t data;
6869 tdata_t *pbase;
6870 toff_t *psize;
6871 {
6872 /* It is already _IN_ memory. */
6873 return 0;
6874 }
6875
6876 static void
6877 tiff_unmap_memory (data, base, size)
6878 thandle_t data;
6879 tdata_t base;
6880 toff_t size;
6881 {
6882 /* We don't need to do this. */
6883 }
6884
6885 static toff_t
6886 tiff_size_of_memory (data)
6887 thandle_t data;
6888 {
6889 return ((tiff_memory_source *) data)->len;
6890 }
6891
6892
6893 static void
6894 tiff_error_handler (title, format, ap)
6895 const char *title, *format;
6896 va_list ap;
6897 {
6898 char buf[512];
6899 int len;
6900
6901 len = sprintf (buf, "TIFF error: %s ", title);
6902 vsprintf (buf + len, format, ap);
6903 add_to_log (buf, Qnil, Qnil);
6904 }
6905
6906
6907 static void
6908 tiff_warning_handler (title, format, ap)
6909 const char *title, *format;
6910 va_list ap;
6911 {
6912 char buf[512];
6913 int len;
6914
6915 len = sprintf (buf, "TIFF warning: %s ", title);
6916 vsprintf (buf + len, format, ap);
6917 add_to_log (buf, Qnil, Qnil);
6918 }
6919
6920
6921 /* Load TIFF image IMG for use on frame F. Value is non-zero if
6922 successful. */
6923
6924 static int
6925 tiff_load (f, img)
6926 struct frame *f;
6927 struct image *img;
6928 {
6929 Lisp_Object file, specified_file;
6930 Lisp_Object specified_data;
6931 TIFF *tiff;
6932 int width, height, x, y;
6933 uint32 *buf;
6934 int rc;
6935 XImagePtr ximg;
6936 struct gcpro gcpro1;
6937 tiff_memory_source memsrc;
6938
6939 specified_file = image_spec_value (img->spec, QCfile, NULL);
6940 specified_data = image_spec_value (img->spec, QCdata, NULL);
6941 file = Qnil;
6942 GCPRO1 (file);
6943
6944 fn_TIFFSetErrorHandler (tiff_error_handler);
6945 fn_TIFFSetWarningHandler (tiff_warning_handler);
6946
6947 if (NILP (specified_data))
6948 {
6949 /* Read from a file */
6950 file = x_find_image_file (specified_file);
6951 if (!STRINGP (file))
6952 {
6953 image_error ("Cannot find image file `%s'", specified_file, Qnil);
6954 UNGCPRO;
6955 return 0;
6956 }
6957
6958 /* Try to open the image file. Casting return value avoids a
6959 GCC warning on W32. */
6960 tiff = (TIFF *)fn_TIFFOpen (SDATA (file), "r");
6961 if (tiff == NULL)
6962 {
6963 image_error ("Cannot open `%s'", file, Qnil);
6964 UNGCPRO;
6965 return 0;
6966 }
6967 }
6968 else
6969 {
6970 /* Memory source! */
6971 memsrc.bytes = SDATA (specified_data);
6972 memsrc.len = SBYTES (specified_data);
6973 memsrc.index = 0;
6974
6975 /* Casting return value avoids a GCC warning on W32. */
6976 tiff = (TIFF *)fn_TIFFClientOpen ("memory_source", "r", &memsrc,
6977 (TIFFReadWriteProc) tiff_read_from_memory,
6978 (TIFFReadWriteProc) tiff_write_from_memory,
6979 tiff_seek_in_memory,
6980 tiff_close_memory,
6981 tiff_size_of_memory,
6982 tiff_mmap_memory,
6983 tiff_unmap_memory);
6984
6985 if (!tiff)
6986 {
6987 image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
6988 UNGCPRO;
6989 return 0;
6990 }
6991 }
6992
6993 /* Get width and height of the image, and allocate a raster buffer
6994 of width x height 32-bit values. */
6995 fn_TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
6996 fn_TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
6997 buf = (uint32 *) xmalloc (width * height * sizeof *buf);
6998
6999 rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
7000 fn_TIFFClose (tiff);
7001 if (!rc)
7002 {
7003 image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
7004 xfree (buf);
7005 UNGCPRO;
7006 return 0;
7007 }
7008
7009 /* Create the X image and pixmap. */
7010 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
7011 {
7012 xfree (buf);
7013 UNGCPRO;
7014 return 0;
7015 }
7016
7017 /* Initialize the color table. */
7018 init_color_table ();
7019
7020 /* Process the pixel raster. Origin is in the lower-left corner. */
7021 for (y = 0; y < height; ++y)
7022 {
7023 uint32 *row = buf + y * width;
7024
7025 for (x = 0; x < width; ++x)
7026 {
7027 uint32 abgr = row[x];
7028 int r = TIFFGetR (abgr) << 8;
7029 int g = TIFFGetG (abgr) << 8;
7030 int b = TIFFGetB (abgr) << 8;
7031 XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
7032 }
7033 }
7034
7035 #ifdef COLOR_TABLE_SUPPORT
7036 /* Remember the colors allocated for the image. Free the color table. */
7037 img->colors = colors_in_color_table (&img->ncolors);
7038 free_color_table ();
7039 #endif /* COLOR_TABLE_SUPPORT */
7040
7041 img->width = width;
7042 img->height = height;
7043
7044 /* Maybe fill in the background field while we have ximg handy. */
7045 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
7046 /* Casting avoids a GCC warning on W32. */
7047 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
7048
7049 /* Put the image into the pixmap, then free the X image and its buffer. */
7050 x_put_x_image (f, ximg, img->pixmap, width, height);
7051 x_destroy_x_image (ximg);
7052 xfree (buf);
7053
7054 UNGCPRO;
7055 return 1;
7056 }
7057
7058 #else /* HAVE_TIFF */
7059
7060 #ifdef MAC_OS
7061 static int
7062 tiff_load (f, img)
7063 struct frame *f;
7064 struct image *img;
7065 {
7066 return image_load_quicktime (f, img, kQTFileTypeTIFF);
7067 }
7068 #endif /* MAC_OS */
7069
7070 #endif /* !HAVE_TIFF */
7071
7072
7073 \f
7074 /***********************************************************************
7075 GIF
7076 ***********************************************************************/
7077
7078 #if defined (HAVE_GIF) || defined (MAC_OS)
7079
7080 static int gif_image_p P_ ((Lisp_Object object));
7081 static int gif_load P_ ((struct frame *f, struct image *img));
7082
7083 /* The symbol `gif' identifying images of this type. */
7084
7085 Lisp_Object Qgif;
7086
7087 /* Indices of image specification fields in gif_format, below. */
7088
7089 enum gif_keyword_index
7090 {
7091 GIF_TYPE,
7092 GIF_DATA,
7093 GIF_FILE,
7094 GIF_ASCENT,
7095 GIF_MARGIN,
7096 GIF_RELIEF,
7097 GIF_ALGORITHM,
7098 GIF_HEURISTIC_MASK,
7099 GIF_MASK,
7100 GIF_IMAGE,
7101 GIF_BACKGROUND,
7102 GIF_LAST
7103 };
7104
7105 /* Vector of image_keyword structures describing the format
7106 of valid user-defined image specifications. */
7107
7108 static struct image_keyword gif_format[GIF_LAST] =
7109 {
7110 {":type", IMAGE_SYMBOL_VALUE, 1},
7111 {":data", IMAGE_STRING_VALUE, 0},
7112 {":file", IMAGE_STRING_VALUE, 0},
7113 {":ascent", IMAGE_ASCENT_VALUE, 0},
7114 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
7115 {":relief", IMAGE_INTEGER_VALUE, 0},
7116 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7117 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7118 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7119 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE, 0},
7120 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
7121 };
7122
7123 /* Structure describing the image type `gif'. */
7124
7125 static struct image_type gif_type =
7126 {
7127 &Qgif,
7128 gif_image_p,
7129 gif_load,
7130 x_clear_image,
7131 NULL
7132 };
7133
7134 /* Return non-zero if OBJECT is a valid GIF image specification. */
7135
7136 static int
7137 gif_image_p (object)
7138 Lisp_Object object;
7139 {
7140 struct image_keyword fmt[GIF_LAST];
7141 bcopy (gif_format, fmt, sizeof fmt);
7142
7143 if (!parse_image_spec (object, fmt, GIF_LAST, Qgif))
7144 return 0;
7145
7146 /* Must specify either the :data or :file keyword. */
7147 return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
7148 }
7149
7150 #endif /* HAVE_GIF || MAC_OS */
7151
7152 #ifdef HAVE_GIF
7153
7154 #if defined (HAVE_NTGUI) || defined (MAC_OS)
7155 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
7156 Undefine before redefining to avoid a preprocessor warning. */
7157 #ifdef DrawText
7158 #undef DrawText
7159 #endif
7160 /* avoid conflict with QuickdrawText.h */
7161 #define DrawText gif_DrawText
7162 #include <gif_lib.h>
7163 #undef DrawText
7164
7165 #else /* HAVE_NTGUI || MAC_OS */
7166
7167 #include <gif_lib.h>
7168
7169 #endif /* HAVE_NTGUI || MAC_OS */
7170
7171
7172 #ifdef HAVE_NTGUI
7173
7174 /* GIF library details. */
7175 DEF_IMGLIB_FN (DGifCloseFile);
7176 DEF_IMGLIB_FN (DGifSlurp);
7177 DEF_IMGLIB_FN (DGifOpen);
7178 DEF_IMGLIB_FN (DGifOpenFileName);
7179
7180 static int
7181 init_gif_functions (Lisp_Object libraries)
7182 {
7183 HMODULE library;
7184
7185 if (!(library = w32_delayed_load (libraries, Qgif)))
7186 return 0;
7187
7188 LOAD_IMGLIB_FN (library, DGifCloseFile);
7189 LOAD_IMGLIB_FN (library, DGifSlurp);
7190 LOAD_IMGLIB_FN (library, DGifOpen);
7191 LOAD_IMGLIB_FN (library, DGifOpenFileName);
7192 return 1;
7193 }
7194
7195 #else
7196
7197 #define fn_DGifCloseFile DGifCloseFile
7198 #define fn_DGifSlurp DGifSlurp
7199 #define fn_DGifOpen DGifOpen
7200 #define fn_DGifOpenFileName DGifOpenFileName
7201
7202 #endif /* HAVE_NTGUI */
7203
7204 /* Reading a GIF image from memory
7205 Based on the PNG memory stuff to a certain extent. */
7206
7207 typedef struct
7208 {
7209 unsigned char *bytes;
7210 size_t len;
7211 int index;
7212 }
7213 gif_memory_source;
7214
7215 /* Make the current memory source available to gif_read_from_memory.
7216 It's done this way because not all versions of libungif support
7217 a UserData field in the GifFileType structure. */
7218 static gif_memory_source *current_gif_memory_src;
7219
7220 static int
7221 gif_read_from_memory (file, buf, len)
7222 GifFileType *file;
7223 GifByteType *buf;
7224 int len;
7225 {
7226 gif_memory_source *src = current_gif_memory_src;
7227
7228 if (len > src->len - src->index)
7229 return -1;
7230
7231 bcopy (src->bytes + src->index, buf, len);
7232 src->index += len;
7233 return len;
7234 }
7235
7236
7237 /* Load GIF image IMG for use on frame F. Value is non-zero if
7238 successful. */
7239
7240 static int
7241 gif_load (f, img)
7242 struct frame *f;
7243 struct image *img;
7244 {
7245 Lisp_Object file, specified_file;
7246 Lisp_Object specified_data;
7247 int rc, width, height, x, y, i;
7248 XImagePtr ximg;
7249 ColorMapObject *gif_color_map;
7250 unsigned long pixel_colors[256];
7251 GifFileType *gif;
7252 struct gcpro gcpro1;
7253 Lisp_Object image;
7254 int ino, image_left, image_top, image_width, image_height;
7255 gif_memory_source memsrc;
7256 unsigned char *raster;
7257
7258 specified_file = image_spec_value (img->spec, QCfile, NULL);
7259 specified_data = image_spec_value (img->spec, QCdata, NULL);
7260 file = Qnil;
7261 GCPRO1 (file);
7262
7263 if (NILP (specified_data))
7264 {
7265 file = x_find_image_file (specified_file);
7266 if (!STRINGP (file))
7267 {
7268 image_error ("Cannot find image file `%s'", specified_file, Qnil);
7269 UNGCPRO;
7270 return 0;
7271 }
7272
7273 /* Open the GIF file. Casting return value avoids a GCC warning
7274 on W32. */
7275 gif = (GifFileType *)fn_DGifOpenFileName (SDATA (file));
7276 if (gif == NULL)
7277 {
7278 image_error ("Cannot open `%s'", file, Qnil);
7279 UNGCPRO;
7280 return 0;
7281 }
7282 }
7283 else
7284 {
7285 /* Read from memory! */
7286 current_gif_memory_src = &memsrc;
7287 memsrc.bytes = SDATA (specified_data);
7288 memsrc.len = SBYTES (specified_data);
7289 memsrc.index = 0;
7290
7291 /* Casting return value avoids a GCC warning on W32. */
7292 gif = (GifFileType *)fn_DGifOpen(&memsrc, gif_read_from_memory);
7293 if (!gif)
7294 {
7295 image_error ("Cannot open memory source `%s'", img->spec, Qnil);
7296 UNGCPRO;
7297 return 0;
7298 }
7299 }
7300
7301 /* Read entire contents. */
7302 rc = fn_DGifSlurp (gif);
7303 if (rc == GIF_ERROR)
7304 {
7305 image_error ("Error reading `%s'", img->spec, Qnil);
7306 fn_DGifCloseFile (gif);
7307 UNGCPRO;
7308 return 0;
7309 }
7310
7311 image = image_spec_value (img->spec, QCindex, NULL);
7312 ino = INTEGERP (image) ? XFASTINT (image) : 0;
7313 if (ino >= gif->ImageCount)
7314 {
7315 image_error ("Invalid image number `%s' in image `%s'",
7316 image, img->spec);
7317 fn_DGifCloseFile (gif);
7318 UNGCPRO;
7319 return 0;
7320 }
7321
7322 width = img->width = max (gif->SWidth, gif->Image.Left + gif->Image.Width);
7323 height = img->height = max (gif->SHeight, gif->Image.Top + gif->Image.Height);
7324
7325 /* Create the X image and pixmap. */
7326 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
7327 {
7328 fn_DGifCloseFile (gif);
7329 UNGCPRO;
7330 return 0;
7331 }
7332
7333 /* Allocate colors. */
7334 gif_color_map = gif->SavedImages[ino].ImageDesc.ColorMap;
7335 if (!gif_color_map)
7336 gif_color_map = gif->SColorMap;
7337 init_color_table ();
7338 bzero (pixel_colors, sizeof pixel_colors);
7339
7340 for (i = 0; i < gif_color_map->ColorCount; ++i)
7341 {
7342 int r = gif_color_map->Colors[i].Red << 8;
7343 int g = gif_color_map->Colors[i].Green << 8;
7344 int b = gif_color_map->Colors[i].Blue << 8;
7345 pixel_colors[i] = lookup_rgb_color (f, r, g, b);
7346 }
7347
7348 #ifdef COLOR_TABLE_SUPPORT
7349 img->colors = colors_in_color_table (&img->ncolors);
7350 free_color_table ();
7351 #endif /* COLOR_TABLE_SUPPORT */
7352
7353 /* Clear the part of the screen image that are not covered by
7354 the image from the GIF file. Full animated GIF support
7355 requires more than can be done here (see the gif89 spec,
7356 disposal methods). Let's simply assume that the part
7357 not covered by a sub-image is in the frame's background color. */
7358 image_top = gif->SavedImages[ino].ImageDesc.Top;
7359 image_left = gif->SavedImages[ino].ImageDesc.Left;
7360 image_width = gif->SavedImages[ino].ImageDesc.Width;
7361 image_height = gif->SavedImages[ino].ImageDesc.Height;
7362
7363 for (y = 0; y < image_top; ++y)
7364 for (x = 0; x < width; ++x)
7365 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7366
7367 for (y = image_top + image_height; y < height; ++y)
7368 for (x = 0; x < width; ++x)
7369 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7370
7371 for (y = image_top; y < image_top + image_height; ++y)
7372 {
7373 for (x = 0; x < image_left; ++x)
7374 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7375 for (x = image_left + image_width; x < width; ++x)
7376 XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
7377 }
7378
7379 /* Read the GIF image into the X image. We use a local variable
7380 `raster' here because RasterBits below is a char *, and invites
7381 problems with bytes >= 0x80. */
7382 raster = (unsigned char *) gif->SavedImages[ino].RasterBits;
7383
7384 if (gif->SavedImages[ino].ImageDesc.Interlace)
7385 {
7386 static int interlace_start[] = {0, 4, 2, 1};
7387 static int interlace_increment[] = {8, 8, 4, 2};
7388 int pass;
7389 int row = interlace_start[0];
7390
7391 pass = 0;
7392
7393 for (y = 0; y < image_height; y++)
7394 {
7395 if (row >= image_height)
7396 {
7397 row = interlace_start[++pass];
7398 while (row >= image_height)
7399 row = interlace_start[++pass];
7400 }
7401
7402 for (x = 0; x < image_width; x++)
7403 {
7404 int i = raster[(y * image_width) + x];
7405 XPutPixel (ximg, x + image_left, row + image_top,
7406 pixel_colors[i]);
7407 }
7408
7409 row += interlace_increment[pass];
7410 }
7411 }
7412 else
7413 {
7414 for (y = 0; y < image_height; ++y)
7415 for (x = 0; x < image_width; ++x)
7416 {
7417 int i = raster[y * image_width + x];
7418 XPutPixel (ximg, x + image_left, y + image_top, pixel_colors[i]);
7419 }
7420 }
7421
7422 fn_DGifCloseFile (gif);
7423
7424 /* Maybe fill in the background field while we have ximg handy. */
7425 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
7426 /* Casting avoids a GCC warning. */
7427 IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
7428
7429 /* Put the image into the pixmap, then free the X image and its buffer. */
7430 x_put_x_image (f, ximg, img->pixmap, width, height);
7431 x_destroy_x_image (ximg);
7432
7433 UNGCPRO;
7434 return 1;
7435 }
7436
7437 #else /* !HAVE_GIF */
7438
7439 #ifdef MAC_OS
7440 static int
7441 gif_load (f, img)
7442 struct frame *f;
7443 struct image *img;
7444 {
7445 Lisp_Object specified_file, file;
7446 Lisp_Object specified_data;
7447 OSErr err;
7448 Boolean graphic_p, movie_p, prefer_graphic_p;
7449 Handle dh = NULL;
7450 Movie movie = NULL;
7451 Lisp_Object image;
7452 Track track = NULL;
7453 Media media = NULL;
7454 long nsamples;
7455 Rect rect;
7456 Lisp_Object specified_bg;
7457 XColor color;
7458 RGBColor bg_color;
7459 int width, height;
7460 XImagePtr ximg;
7461 TimeValue time;
7462 struct gcpro gcpro1;
7463 int ino;
7464 CGrafPtr old_port;
7465 GDHandle old_gdh;
7466
7467 specified_file = image_spec_value (img->spec, QCfile, NULL);
7468 specified_data = image_spec_value (img->spec, QCdata, NULL);
7469
7470 if (NILP (specified_data))
7471 {
7472 /* Read from a file */
7473 FSSpec fss;
7474 short refnum;
7475
7476 err = find_image_fsspec (specified_file, &file, &fss);
7477 if (err != noErr)
7478 {
7479 if (err == fnfErr)
7480 image_error ("Cannot find image file `%s'", specified_file, Qnil);
7481 else
7482 goto open_error;
7483 }
7484
7485 err = CanQuickTimeOpenFile (&fss, kQTFileTypeGIF, 0,
7486 &graphic_p, &movie_p, &prefer_graphic_p, 0);
7487 if (err != noErr)
7488 goto open_error;
7489
7490 if (!graphic_p && !movie_p)
7491 goto open_error;
7492 if (prefer_graphic_p)
7493 return image_load_qt_1 (f, img, kQTFileTypeGIF, &fss, NULL);
7494 err = OpenMovieFile (&fss, &refnum, fsRdPerm);
7495 if (err != noErr)
7496 goto open_error;
7497 err = NewMovieFromFile (&movie, refnum, NULL, NULL, 0, NULL);
7498 CloseMovieFile (refnum);
7499 if (err != noErr)
7500 {
7501 image_error ("Error reading `%s'", file, Qnil);
7502 return 0;
7503 }
7504 }
7505 else
7506 {
7507 /* Memory source! */
7508 Handle dref = NULL;
7509 long file_type_atom[3];
7510
7511 err = PtrToHand (SDATA (specified_data), &dh, SBYTES (specified_data));
7512 if (err != noErr)
7513 {
7514 image_error ("Cannot allocate data handle for `%s'",
7515 img->spec, Qnil);
7516 goto error;
7517 }
7518
7519 file_type_atom[0] = EndianU32_NtoB (sizeof (long) * 3);
7520 file_type_atom[1] = EndianU32_NtoB (kDataRefExtensionMacOSFileType);
7521 file_type_atom[2] = EndianU32_NtoB (kQTFileTypeGIF);
7522 err = PtrToHand (&dh, &dref, sizeof (Handle));
7523 if (err == noErr)
7524 /* no file name */
7525 err = PtrAndHand ("\p", dref, 1);
7526 if (err == noErr)
7527 err = PtrAndHand (file_type_atom, dref, sizeof (long) * 3);
7528 if (err != noErr)
7529 {
7530 image_error ("Cannot allocate handle data ref for `%s'", img->spec, Qnil);
7531 goto error;
7532 }
7533 err = CanQuickTimeOpenDataRef (dref, HandleDataHandlerSubType, &graphic_p,
7534 &movie_p, &prefer_graphic_p, 0);
7535 if (err != noErr)
7536 goto open_error;
7537
7538 if (!graphic_p && !movie_p)
7539 goto open_error;
7540 if (prefer_graphic_p)
7541 {
7542 int success_p;
7543
7544 DisposeHandle (dref);
7545 success_p = image_load_qt_1 (f, img, kQTFileTypeGIF, NULL, dh);
7546 DisposeHandle (dh);
7547 return success_p;
7548 }
7549 err = NewMovieFromDataRef (&movie, 0, NULL, dref,
7550 HandleDataHandlerSubType);
7551 DisposeHandle (dref);
7552 if (err != noErr)
7553 goto open_error;
7554 }
7555
7556 image = image_spec_value (img->spec, QCindex, NULL);
7557 ino = INTEGERP (image) ? XFASTINT (image) : 0;
7558 track = GetMovieIndTrack (movie, 1);
7559 media = GetTrackMedia (track);
7560 nsamples = GetMediaSampleCount (media);
7561 if (ino >= nsamples)
7562 {
7563 image_error ("Invalid image number `%s' in image `%s'",
7564 image, img->spec);
7565 goto error;
7566 }
7567
7568 specified_bg = image_spec_value (img->spec, QCbackground, NULL);
7569 if (!STRINGP (specified_bg) ||
7570 !mac_defined_color (f, SDATA (specified_bg), &color, 0))
7571 {
7572 color.pixel = FRAME_BACKGROUND_PIXEL (f);
7573 color.red = RED16_FROM_ULONG (color.pixel);
7574 color.green = GREEN16_FROM_ULONG (color.pixel);
7575 color.blue = BLUE16_FROM_ULONG (color.pixel);
7576 }
7577 GetMovieBox (movie, &rect);
7578 width = img->width = rect.right - rect.left;
7579 height = img->height = rect.bottom - rect.top;
7580 if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
7581 goto error;
7582
7583 GetGWorld (&old_port, &old_gdh);
7584 SetGWorld (ximg, NULL);
7585 bg_color.red = color.red;
7586 bg_color.green = color.green;
7587 bg_color.blue = color.blue;
7588 RGBBackColor (&bg_color);
7589 SetGWorld (old_port, old_gdh);
7590 SetMovieActive (movie, 1);
7591 SetMovieGWorld (movie, ximg, NULL);
7592 SampleNumToMediaTime (media, ino + 1, &time, NULL);
7593 SetMovieTimeValue (movie, time);
7594 MoviesTask (movie, 0L);
7595 DisposeTrackMedia (media);
7596 DisposeMovieTrack (track);
7597 DisposeMovie (movie);
7598 if (dh)
7599 DisposeHandle (dh);
7600 /* Maybe fill in the background field while we have ximg handy. */
7601 if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
7602 IMAGE_BACKGROUND (img, f, ximg);
7603
7604 /* Put the image into the pixmap. */
7605 x_put_x_image (f, ximg, img->pixmap, width, height);
7606 x_destroy_x_image (ximg);
7607 return 1;
7608
7609 open_error:
7610 image_error ("Cannot open `%s'", file, Qnil);
7611 error:
7612 if (media)
7613 DisposeTrackMedia (media);
7614 if (track)
7615 DisposeMovieTrack (track);
7616 if (movie)
7617 DisposeMovie (movie);
7618 if (dh)
7619 DisposeHandle (dh);
7620 return 0;
7621 }
7622 #endif /* MAC_OS */
7623
7624 #endif /* HAVE_GIF */
7625
7626
7627 \f
7628 /***********************************************************************
7629 Ghostscript
7630 ***********************************************************************/
7631
7632 #ifdef HAVE_X_WINDOWS
7633 #define HAVE_GHOSTSCRIPT 1
7634 #endif /* HAVE_X_WINDOWS */
7635
7636 /* The symbol `postscript' identifying images of this type. */
7637
7638 Lisp_Object Qpostscript;
7639
7640 #ifdef HAVE_GHOSTSCRIPT
7641
7642 static int gs_image_p P_ ((Lisp_Object object));
7643 static int gs_load P_ ((struct frame *f, struct image *img));
7644 static void gs_clear_image P_ ((struct frame *f, struct image *img));
7645
7646 /* Keyword symbols. */
7647
7648 Lisp_Object QCloader, QCbounding_box, QCpt_width, QCpt_height;
7649
7650 /* Indices of image specification fields in gs_format, below. */
7651
7652 enum gs_keyword_index
7653 {
7654 GS_TYPE,
7655 GS_PT_WIDTH,
7656 GS_PT_HEIGHT,
7657 GS_FILE,
7658 GS_LOADER,
7659 GS_BOUNDING_BOX,
7660 GS_ASCENT,
7661 GS_MARGIN,
7662 GS_RELIEF,
7663 GS_ALGORITHM,
7664 GS_HEURISTIC_MASK,
7665 GS_MASK,
7666 GS_BACKGROUND,
7667 GS_LAST
7668 };
7669
7670 /* Vector of image_keyword structures describing the format
7671 of valid user-defined image specifications. */
7672
7673 static struct image_keyword gs_format[GS_LAST] =
7674 {
7675 {":type", IMAGE_SYMBOL_VALUE, 1},
7676 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE, 1},
7677 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE, 1},
7678 {":file", IMAGE_STRING_VALUE, 1},
7679 {":loader", IMAGE_FUNCTION_VALUE, 0},
7680 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE, 1},
7681 {":ascent", IMAGE_ASCENT_VALUE, 0},
7682 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR, 0},
7683 {":relief", IMAGE_INTEGER_VALUE, 0},
7684 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7685 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7686 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE, 0},
7687 {":background", IMAGE_STRING_OR_NIL_VALUE, 0}
7688 };
7689
7690 /* Structure describing the image type `ghostscript'. */
7691
7692 static struct image_type gs_type =
7693 {
7694 &Qpostscript,
7695 gs_image_p,
7696 gs_load,
7697 gs_clear_image,
7698 NULL
7699 };
7700
7701
7702 /* Free X resources of Ghostscript image IMG which is used on frame F. */
7703
7704 static void
7705 gs_clear_image (f, img)
7706 struct frame *f;
7707 struct image *img;
7708 {
7709 /* IMG->data.ptr_val may contain a recorded colormap. */
7710 xfree (img->data.ptr_val);
7711 x_clear_image (f, img);
7712 }
7713
7714
7715 /* Return non-zero if OBJECT is a valid Ghostscript image
7716 specification. */
7717
7718 static int
7719 gs_image_p (object)
7720 Lisp_Object object;
7721 {
7722 struct image_keyword fmt[GS_LAST];
7723 Lisp_Object tem;
7724 int i;
7725
7726 bcopy (gs_format, fmt, sizeof fmt);
7727
7728 if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript))
7729 return 0;
7730
7731 /* Bounding box must be a list or vector containing 4 integers. */
7732 tem = fmt[GS_BOUNDING_BOX].value;
7733 if (CONSP (tem))
7734 {
7735 for (i = 0; i < 4; ++i, tem = XCDR (tem))
7736 if (!CONSP (tem) || !INTEGERP (XCAR (tem)))
7737 return 0;
7738 if (!NILP (tem))
7739 return 0;
7740 }
7741 else if (VECTORP (tem))
7742 {
7743 if (XVECTOR (tem)->size != 4)
7744 return 0;
7745 for (i = 0; i < 4; ++i)
7746 if (!INTEGERP (XVECTOR (tem)->contents[i]))
7747 return 0;
7748 }
7749 else
7750 return 0;
7751
7752 return 1;
7753 }
7754
7755
7756 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
7757 if successful. */
7758
7759 static int
7760 gs_load (f, img)
7761 struct frame *f;
7762 struct image *img;
7763 {
7764 char buffer[100];
7765 Lisp_Object window_and_pixmap_id = Qnil, loader, pt_height, pt_width;
7766 struct gcpro gcpro1, gcpro2;
7767 Lisp_Object frame;
7768 double in_width, in_height;
7769 Lisp_Object pixel_colors = Qnil;
7770
7771 /* Compute pixel size of pixmap needed from the given size in the
7772 image specification. Sizes in the specification are in pt. 1 pt
7773 = 1/72 in, xdpi and ydpi are stored in the frame's X display
7774 info. */
7775 pt_width = image_spec_value (img->spec, QCpt_width, NULL);
7776 in_width = XFASTINT (pt_width) / 72.0;
7777 img->width = in_width * FRAME_X_DISPLAY_INFO (f)->resx;
7778 pt_height = image_spec_value (img->spec, QCpt_height, NULL);
7779 in_height = XFASTINT (pt_height) / 72.0;
7780 img->height = in_height * FRAME_X_DISPLAY_INFO (f)->resy;
7781
7782 /* Create the pixmap. */
7783 xassert (img->pixmap == NO_PIXMAP);
7784
7785 /* Only W32 version did BLOCK_INPUT here. ++kfs */
7786 BLOCK_INPUT;
7787 img->pixmap = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7788 img->width, img->height,
7789 DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
7790 UNBLOCK_INPUT;
7791
7792 if (!img->pixmap)
7793 {
7794 image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
7795 return 0;
7796 }
7797
7798 /* Call the loader to fill the pixmap. It returns a process object
7799 if successful. We do not record_unwind_protect here because
7800 other places in redisplay like calling window scroll functions
7801 don't either. Let the Lisp loader use `unwind-protect' instead. */
7802 GCPRO2 (window_and_pixmap_id, pixel_colors);
7803
7804 sprintf (buffer, "%lu %lu",
7805 (unsigned long) FRAME_X_WINDOW (f),
7806 (unsigned long) img->pixmap);
7807 window_and_pixmap_id = build_string (buffer);
7808
7809 sprintf (buffer, "%lu %lu",
7810 FRAME_FOREGROUND_PIXEL (f),
7811 FRAME_BACKGROUND_PIXEL (f));
7812 pixel_colors = build_string (buffer);
7813
7814 XSETFRAME (frame, f);
7815 loader = image_spec_value (img->spec, QCloader, NULL);
7816 if (NILP (loader))
7817 loader = intern ("gs-load-image");
7818
7819 img->data.lisp_val = call6 (loader, frame, img->spec,
7820 make_number (img->width),
7821 make_number (img->height),
7822 window_and_pixmap_id,
7823 pixel_colors);
7824 UNGCPRO;
7825 return PROCESSP (img->data.lisp_val);
7826 }
7827
7828
7829 /* Kill the Ghostscript process that was started to fill PIXMAP on
7830 frame F. Called from XTread_socket when receiving an event
7831 telling Emacs that Ghostscript has finished drawing. */
7832
7833 void
7834 x_kill_gs_process (pixmap, f)
7835 Pixmap pixmap;
7836 struct frame *f;
7837 {
7838 struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
7839 int class, i;
7840 struct image *img;
7841
7842 /* Find the image containing PIXMAP. */
7843 for (i = 0; i < c->used; ++i)
7844 if (c->images[i]->pixmap == pixmap)
7845 break;
7846
7847 /* Should someone in between have cleared the image cache, for
7848 instance, give up. */
7849 if (i == c->used)
7850 return;
7851
7852 /* Kill the GS process. We should have found PIXMAP in the image
7853 cache and its image should contain a process object. */
7854 img = c->images[i];
7855 xassert (PROCESSP (img->data.lisp_val));
7856 Fkill_process (img->data.lisp_val, Qnil);
7857 img->data.lisp_val = Qnil;
7858
7859 #if defined (HAVE_X_WINDOWS)
7860
7861 /* On displays with a mutable colormap, figure out the colors
7862 allocated for the image by looking at the pixels of an XImage for
7863 img->pixmap. */
7864 class = FRAME_X_VISUAL (f)->class;
7865 if (class != StaticColor && class != StaticGray && class != TrueColor)
7866 {
7867 XImagePtr ximg;
7868
7869 BLOCK_INPUT;
7870
7871 /* Try to get an XImage for img->pixmep. */
7872 ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
7873 0, 0, img->width, img->height, ~0, ZPixmap);
7874 if (ximg)
7875 {
7876 int x, y;
7877
7878 /* Initialize the color table. */
7879 init_color_table ();
7880
7881 /* For each pixel of the image, look its color up in the
7882 color table. After having done so, the color table will
7883 contain an entry for each color used by the image. */
7884 for (y = 0; y < img->height; ++y)
7885 for (x = 0; x < img->width; ++x)
7886 {
7887 unsigned long pixel = XGetPixel (ximg, x, y);
7888 lookup_pixel_color (f, pixel);
7889 }
7890
7891 /* Record colors in the image. Free color table and XImage. */
7892 #ifdef COLOR_TABLE_SUPPORT
7893 img->colors = colors_in_color_table (&img->ncolors);
7894 free_color_table ();
7895 #endif
7896 XDestroyImage (ximg);
7897
7898 #if 0 /* This doesn't seem to be the case. If we free the colors
7899 here, we get a BadAccess later in x_clear_image when
7900 freeing the colors. */
7901 /* We have allocated colors once, but Ghostscript has also
7902 allocated colors on behalf of us. So, to get the
7903 reference counts right, free them once. */
7904 if (img->ncolors)
7905 x_free_colors (f, img->colors, img->ncolors);
7906 #endif
7907 }
7908 else
7909 image_error ("Cannot get X image of `%s'; colors will not be freed",
7910 img->spec, Qnil);
7911
7912 UNBLOCK_INPUT;
7913 }
7914 #endif /* HAVE_X_WINDOWS */
7915
7916 /* Now that we have the pixmap, compute mask and transform the
7917 image if requested. */
7918 BLOCK_INPUT;
7919 postprocess_image (f, img);
7920 UNBLOCK_INPUT;
7921 }
7922
7923 #endif /* HAVE_GHOSTSCRIPT */
7924
7925 \f
7926 /***********************************************************************
7927 Tests
7928 ***********************************************************************/
7929
7930 #if GLYPH_DEBUG
7931
7932 DEFUN ("imagep", Fimagep, Simagep, 1, 1, 0,
7933 doc: /* Value is non-nil if SPEC is a valid image specification. */)
7934 (spec)
7935 Lisp_Object spec;
7936 {
7937 return valid_image_p (spec) ? Qt : Qnil;
7938 }
7939
7940
7941 DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
7942 (spec)
7943 Lisp_Object spec;
7944 {
7945 int id = -1;
7946
7947 if (valid_image_p (spec))
7948 id = lookup_image (SELECTED_FRAME (), spec);
7949
7950 debug_print (spec);
7951 return make_number (id);
7952 }
7953
7954 #endif /* GLYPH_DEBUG != 0 */
7955
7956
7957 /***********************************************************************
7958 Initialization
7959 ***********************************************************************/
7960
7961 #ifdef HAVE_NTGUI
7962 /* Image types that rely on external libraries are loaded dynamically
7963 if the library is available. */
7964 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7965 define_image_type (image_type, init_lib_fn (libraries))
7966 #else
7967 #define CHECK_LIB_AVAILABLE(image_type, init_lib_fn, libraries) \
7968 define_image_type (image_type, 1)
7969 #endif /* HAVE_NTGUI */
7970
7971 DEFUN ("init-image-library", Finit_image_library, Sinit_image_library, 2, 2, 0,
7972 doc: /* Initialize image library implementing image type TYPE.
7973 Return non-nil if TYPE is a supported image type.
7974
7975 Image types pbm and xbm are prebuilt; other types are loaded here.
7976 Libraries to load are specified in alist LIBRARIES (usually, the value
7977 of `image-library-alist', which see). */)
7978 (type, libraries)
7979 Lisp_Object type, libraries;
7980 {
7981 Lisp_Object tested;
7982
7983 /* Don't try to reload the library. */
7984 tested = Fassq (type, Vimage_type_cache);
7985 if (CONSP (tested))
7986 return XCDR (tested);
7987
7988 #if defined (HAVE_XPM) || defined (MAC_OS)
7989 if (EQ (type, Qxpm))
7990 return CHECK_LIB_AVAILABLE (&xpm_type, init_xpm_functions, libraries);
7991 #endif
7992
7993 #if defined (HAVE_JPEG) || defined (MAC_OS)
7994 if (EQ (type, Qjpeg))
7995 return CHECK_LIB_AVAILABLE (&jpeg_type, init_jpeg_functions, libraries);
7996 #endif
7997
7998 #if defined (HAVE_TIFF) || defined (MAC_OS)
7999 if (EQ (type, Qtiff))
8000 return CHECK_LIB_AVAILABLE (&tiff_type, init_tiff_functions, libraries);
8001 #endif
8002
8003 #if defined (HAVE_GIF) || defined (MAC_OS)
8004 if (EQ (type, Qgif))
8005 return CHECK_LIB_AVAILABLE (&gif_type, init_gif_functions, libraries);
8006 #endif
8007
8008 #if defined (HAVE_PNG) || defined (MAC_OS)
8009 if (EQ (type, Qpng))
8010 return CHECK_LIB_AVAILABLE (&png_type, init_png_functions, libraries);
8011 #endif
8012
8013 #ifdef HAVE_GHOSTSCRIPT
8014 if (EQ (type, Qpostscript))
8015 return CHECK_LIB_AVAILABLE (&gs_type, init_gs_functions, libraries);
8016 #endif
8017
8018 /* If the type is not recognized, avoid testing it ever again. */
8019 CACHE_IMAGE_TYPE (type, Qnil);
8020 return Qnil;
8021 }
8022
8023 void
8024 syms_of_image ()
8025 {
8026 extern Lisp_Object Qrisky_local_variable; /* Syms_of_xdisp has already run. */
8027
8028 /* Must be defined now becase we're going to update it below, while
8029 defining the supported image types. */
8030 DEFVAR_LISP ("image-types", &Vimage_types,
8031 doc: /* List of potentially supported image types.
8032 Each element of the list is a symbol for a image type, like 'jpeg or 'png.
8033 To check whether it is really supported, use `image-type-available-p'. */);
8034 Vimage_types = Qnil;
8035
8036 DEFVAR_LISP ("image-library-alist", &Vimage_library_alist,
8037 doc: /* Alist of image types vs external libraries needed to display them.
8038
8039 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
8040 representing a supported image type, and the rest are strings giving
8041 alternate filenames for the corresponding external libraries.
8042
8043 Emacs tries to load the libraries in the order they appear on the
8044 list; if none is loaded, the running session of Emacs won't
8045 support the image type. Types 'pbm and 'xbm don't need to be
8046 listed; they're always supported. */);
8047 Vimage_library_alist = Qnil;
8048 Fput (intern ("image-library-alist"), Qrisky_local_variable, Qt);
8049
8050 Vimage_type_cache = Qnil;
8051 staticpro (&Vimage_type_cache);
8052
8053 QCascent = intern (":ascent");
8054 staticpro (&QCascent);
8055 QCmargin = intern (":margin");
8056 staticpro (&QCmargin);
8057 QCrelief = intern (":relief");
8058 staticpro (&QCrelief);
8059 QCconversion = intern (":conversion");
8060 staticpro (&QCconversion);
8061 QCcolor_symbols = intern (":color-symbols");
8062 staticpro (&QCcolor_symbols);
8063 QCheuristic_mask = intern (":heuristic-mask");
8064 staticpro (&QCheuristic_mask);
8065 QCindex = intern (":index");
8066 staticpro (&QCindex);
8067 QCmatrix = intern (":matrix");
8068 staticpro (&QCmatrix);
8069 QCcolor_adjustment = intern (":color-adjustment");
8070 staticpro (&QCcolor_adjustment);
8071 QCmask = intern (":mask");
8072 staticpro (&QCmask);
8073
8074 Qlaplace = intern ("laplace");
8075 staticpro (&Qlaplace);
8076 Qemboss = intern ("emboss");
8077 staticpro (&Qemboss);
8078 Qedge_detection = intern ("edge-detection");
8079 staticpro (&Qedge_detection);
8080 Qheuristic = intern ("heuristic");
8081 staticpro (&Qheuristic);
8082
8083 Qpostscript = intern ("postscript");
8084 staticpro (&Qpostscript);
8085 #ifdef HAVE_GHOSTSCRIPT
8086 ADD_IMAGE_TYPE(Qpostscript);
8087 QCloader = intern (":loader");
8088 staticpro (&QCloader);
8089 QCbounding_box = intern (":bounding-box");
8090 staticpro (&QCbounding_box);
8091 QCpt_width = intern (":pt-width");
8092 staticpro (&QCpt_width);
8093 QCpt_height = intern (":pt-height");
8094 staticpro (&QCpt_height);
8095 #endif /* HAVE_GHOSTSCRIPT */
8096
8097 Qpbm = intern ("pbm");
8098 staticpro (&Qpbm);
8099 ADD_IMAGE_TYPE(Qpbm);
8100
8101 Qxbm = intern ("xbm");
8102 staticpro (&Qxbm);
8103 ADD_IMAGE_TYPE(Qxbm);
8104
8105 #if defined (HAVE_XPM) || defined (MAC_OS)
8106 Qxpm = intern ("xpm");
8107 staticpro (&Qxpm);
8108 ADD_IMAGE_TYPE(Qxpm);
8109 #endif
8110
8111 #if defined (HAVE_JPEG) || defined (MAC_OS)
8112 Qjpeg = intern ("jpeg");
8113 staticpro (&Qjpeg);
8114 ADD_IMAGE_TYPE(Qjpeg);
8115 #endif
8116
8117 #if defined (HAVE_TIFF) || defined (MAC_OS)
8118 Qtiff = intern ("tiff");
8119 staticpro (&Qtiff);
8120 ADD_IMAGE_TYPE(Qtiff);
8121 #endif
8122
8123 #if defined (HAVE_GIF) || defined (MAC_OS)
8124 Qgif = intern ("gif");
8125 staticpro (&Qgif);
8126 ADD_IMAGE_TYPE(Qgif);
8127 #endif
8128
8129 #if defined (HAVE_PNG) || defined (MAC_OS)
8130 Qpng = intern ("png");
8131 staticpro (&Qpng);
8132 ADD_IMAGE_TYPE(Qpng);
8133 #endif
8134
8135 defsubr (&Sinit_image_library);
8136 defsubr (&Sclear_image_cache);
8137 defsubr (&Simage_size);
8138 defsubr (&Simage_mask_p);
8139
8140 #if GLYPH_DEBUG
8141 defsubr (&Simagep);
8142 defsubr (&Slookup_image);
8143 #endif
8144
8145 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images,
8146 doc: /* Non-nil means always draw a cross over disabled images.
8147 Disabled images are those having an `:conversion disabled' property.
8148 A cross is always drawn on black & white displays. */);
8149 cross_disabled_images = 0;
8150
8151 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
8152 doc: /* List of directories to search for window system bitmap files. */);
8153 Vx_bitmap_file_path = decode_env_path ((char *) 0, PATH_BITMAPS);
8154
8155 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay,
8156 doc: /* Time after which cached images are removed from the cache.
8157 When an image has not been displayed this many seconds, remove it
8158 from the image cache. Value must be an integer or nil with nil
8159 meaning don't clear the cache. */);
8160 Vimage_cache_eviction_delay = make_number (30 * 60);
8161 }
8162
8163 void
8164 init_image ()
8165 {
8166 image_types = NULL;
8167
8168 define_image_type (&xbm_type, 1);
8169 define_image_type (&pbm_type, 1);
8170
8171 #ifdef MAC_OS
8172 /* Animated gifs use QuickTime Movie Toolbox. So initialize it here. */
8173 EnterMovies ();
8174 #ifdef MAC_OSX
8175 init_image_func_pointer ();
8176 #endif
8177 #endif
8178 }
8179
8180 /* arch-tag: 123c2a5e-14a8-4c53-ab95-af47d7db49b9
8181 (do not change this comment) */