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