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