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