rnd-20100608-1-src
[rocksndiamonds.git] / src / libgame / image.c
1 /***********************************************************
2 * Artsoft Retro-Game Library                               *
3 *----------------------------------------------------------*
4 * (c) 1994-2006 Artsoft Entertainment                      *
5 *               Holger Schemel                             *
6 *               Detmolder Strasse 189                      *
7 *               33604 Bielefeld                            *
8 *               Germany                                    *
9 *               e-mail: info@artsoft.org                   *
10 *----------------------------------------------------------*
11 * image.c                                                  *
12 ***********************************************************/
13
14 #include "image.h"
15 #include "pcx.h"
16 #include "misc.h"
17 #include "setup.h"
18
19
20 /* ========================================================================= */
21 /* PLATFORM SPECIFIC IMAGE FUNCTIONS                                         */
22 /* ========================================================================= */
23
24 #if defined(TARGET_X11)
25
26 /* for MS-DOS/Allegro, exclude all except newImage() and freeImage() */
27
28 Image *newImage(unsigned int width, unsigned int height, unsigned int depth)
29 {
30   Image *image;
31   unsigned int bytes_per_pixel = (depth + 7) / 8;
32   int i;
33
34   image = checked_calloc(sizeof(Image));
35   image->data = checked_calloc(width * height * bytes_per_pixel);
36   image->width = width;
37   image->height = height;
38   image->depth = depth;
39   image->bytes_per_pixel = bytes_per_pixel;
40   image->bytes_per_row = width * bytes_per_pixel;
41
42   image->rgb.used = 0;
43   for (i = 0; i < MAX_COLORS; i++)
44     image->rgb.color_used[i] = FALSE;
45
46   image->type = (depth < 8 ? IMAGETYPE_BITMAP :
47                  depth > 8 ? IMAGETYPE_TRUECOLOR : IMAGETYPE_RGB);
48
49   return image;
50 }
51
52 void freeImage(Image *image)
53 {
54   free(image->data);
55   free(image);
56 }
57
58 #if defined(PLATFORM_UNIX)
59
60 /* extra colors to try allocating in private color maps to minimize flashing */
61 #define NOFLASH_COLORS 256
62
63 /* architecture independent value <-> memory conversions;
64    note: the internal format is big endian */
65
66 #define memory_to_value(ptr, len) (                                         \
67 (len) == 1 ? (unsigned long)(                 *( (byte *)(ptr))         ) : \
68 (len) == 2 ? (unsigned long)(((unsigned long)(*( (byte *)(ptr))   ))<< 8)   \
69                           + (                 *(((byte *)(ptr))+1)      ) : \
70 (len) == 3 ? (unsigned long)(((unsigned long)(*( (byte *)(ptr))   ))<<16)   \
71                           + (((unsigned long)(*(((byte *)(ptr))+1)))<< 8)   \
72                           + (                 *(((byte *)(ptr))+2)      ) : \
73              (unsigned long)(((unsigned long)(*( (byte *)(ptr))   ))<<24)   \
74                           + (((unsigned long)(*(((byte *)(ptr))+1)))<<16)   \
75                           + (((unsigned long)(*(((byte *)(ptr))+2)))<< 8)   \
76                           + (                 *(((byte *)(ptr))+3)      ) )
77
78
79 #define value_to_memory(value, ptr, len) (                              \
80 (len) == 1 ? (*( (byte *)(ptr)   ) = ( value     ) ) :                  \
81 (len) == 2 ? (*( (byte *)(ptr)   ) = (((unsigned long)(value))>> 8),    \
82               *(((byte *)(ptr))+1) = ( value     ) ) :                  \
83 (len) == 3 ? (*( (byte *)(ptr)   ) = (((unsigned long)(value))>>16),    \
84               *(((byte *)(ptr))+1) = (((unsigned long)(value))>> 8),    \
85               *(((byte *)(ptr))+2) = ( value     ) ) :                  \
86              (*( (byte *)(ptr)   ) = (((unsigned long)(value))>>24),    \
87               *(((byte *)(ptr))+1) = (((unsigned long)(value))>>16),    \
88               *(((byte *)(ptr))+2) = (((unsigned long)(value))>> 8),    \
89               *(((byte *)(ptr))+3) = ( value     ) ))
90
91 static Pixmap Image_to_Mask(Image *image, Display *display, Window window)
92 {
93   byte *src_ptr, *dst_ptr, *dst_ptr2;
94   unsigned int bytes_per_row;
95   unsigned int x, y, i;
96   byte bitmask;
97   byte *mask_data;
98   Pixmap mask_pixmap;
99
100   bytes_per_row = (image->width + 7) / 8;
101   mask_data = checked_calloc(bytes_per_row * image->height);
102
103   src_ptr = image->data;
104   dst_ptr = mask_data;
105
106   /* create bitmap data which can be used by 'XCreateBitmapFromData()'
107    * directly to create a pixmap of depth 1 for use as a clip mask for
108    * the corresponding image pixmap
109    */
110
111   for (y = 0; y < image->height; y++)
112   {
113     bitmask = 0x01;             /* start with leftmost bit in the byte     */
114     dst_ptr2 = dst_ptr;         /* start with leftmost byte in the row     */
115
116     for (x = 0; x < image->width; x++)
117     {
118       for (i = 0; i < image->bytes_per_pixel; i++)
119         if (*src_ptr++)         /* source pixel solid? (pixel index != 0)  */
120           *dst_ptr2 |= bitmask; /* then write a bit into the image mask    */
121
122       if ((bitmask <<= 1) == 0) /* bit at rightmost byte position reached? */
123       {
124         bitmask = 0x01;         /* start again with leftmost bit position  */
125         dst_ptr2++;             /* continue with next byte in image mask   */
126       }
127     }
128
129     dst_ptr += bytes_per_row;   /* continue with leftmost byte of next row */
130   }
131
132   if ((mask_pixmap = XCreateBitmapFromData(display, window, (char *)mask_data,
133                                            image->width, image->height))
134       == None)
135     Error(ERR_EXIT, "Image_to_Mask(): XCreateBitmapFromData() failed");
136
137   free(mask_data);
138
139   return mask_pixmap;
140 }
141
142 Pixmap Pixmap_to_Mask(Pixmap src_pixmap, int src_width, int src_height)
143 {
144   XImage *src_ximage;
145   byte *src_ptr, *dst_ptr, *dst_ptr2;
146   int bits_per_pixel;
147   int bytes_per_pixel;
148   unsigned int bytes_per_row;
149   unsigned int x, y, i;
150   byte bitmask;
151   byte *mask_data;
152   Pixmap mask_pixmap;
153
154   /* copy source pixmap to temporary image */
155   if ((src_ximage = XGetImage(display, src_pixmap, 0, 0, src_width, src_height,
156                               AllPlanes, ZPixmap)) == NULL)
157     Error(ERR_EXIT, "Pixmap_to_Mask(): XGetImage() failed");
158
159   bits_per_pixel = src_ximage->bits_per_pixel;
160   bytes_per_pixel = (bits_per_pixel + 7) / 8;
161
162   bytes_per_row = (src_width + 7) / 8;
163   mask_data = checked_calloc(bytes_per_row * src_height);
164
165   src_ptr = (byte *)src_ximage->data;
166   dst_ptr = mask_data;
167
168   /* create bitmap data which can be used by 'XCreateBitmapFromData()'
169    * directly to create a pixmap of depth 1 for use as a clip mask for
170    * the corresponding image pixmap
171    */
172
173   for (y = 0; y < src_height; y++)
174   {
175     bitmask = 0x01;             /* start with leftmost bit in the byte     */
176     dst_ptr2 = dst_ptr;         /* start with leftmost byte in the row     */
177
178     for (x = 0; x < src_width; x++)
179     {
180       for (i = 0; i < bytes_per_pixel; i++)
181         if (*src_ptr++)         /* source pixel solid? (pixel index != 0)  */
182           *dst_ptr2 |= bitmask; /* then write a bit into the image mask    */
183
184       if ((bitmask <<= 1) == 0) /* bit at rightmost byte position reached? */
185       {
186         bitmask = 0x01;         /* start again with leftmost bit position  */
187         dst_ptr2++;             /* continue with next byte in image mask   */
188       }
189     }
190
191     dst_ptr += bytes_per_row;   /* continue with leftmost byte of next row */
192   }
193
194   if ((mask_pixmap = XCreateBitmapFromData(display, window->drawable,
195                                            (char *)mask_data,
196                                            src_width, src_height)) == None)
197     Error(ERR_EXIT, "Pixmap_to_Mask(): XCreateBitmapFromData() failed");
198
199   free(mask_data);
200
201   return mask_pixmap;
202 }
203
204 static int bitsPerPixelAtDepth(Display *display, int screen, int depth)
205 {
206   XPixmapFormatValues *pixmap_format;
207   int i, num_pixmap_formats, bits_per_pixel = -1;
208
209   /* get Pixmap formats supported by the X server */
210   pixmap_format = XListPixmapFormats(display, &num_pixmap_formats);
211
212   /* find format that matches the given depth */
213   for (i = 0; i < num_pixmap_formats; i++)
214     if (pixmap_format[i].depth == depth)
215       bits_per_pixel = pixmap_format[i].bits_per_pixel;
216
217   XFree(pixmap_format);
218
219   if (bits_per_pixel == -1)
220     Error(ERR_EXIT, "cannot find pixmap format for depth %d", depth);
221
222   return bits_per_pixel;
223 }
224
225 XImageInfo *Image_to_Pixmap(Display *display, int screen, Visual *visual,
226                             Window window, GC gc, int depth, Image *image)
227 {
228   static XColor xcolor_private[NOFLASH_COLORS];
229   static int colorcell_used[NOFLASH_COLORS];
230   static Colormap global_cmap = 0;
231   static Pixel *global_cmap_index;
232   static int num_cmap_entries, free_cmap_entries;
233   static boolean private_cmap = FALSE;
234   Pixel *redvalue, *greenvalue, *bluevalue;
235   unsigned int display_bytes_per_pixel, display_bits_per_pixel;
236   unsigned int a, c = 0, x, y;
237   XColor xcolor;
238   XImage *ximage;
239   XImageInfo *ximageinfo;
240   byte *src_ptr, *dst_ptr;
241   char *error = "Image_to_Pixmap(): %s";
242
243   if (image->type == IMAGETYPE_TRUECOLOR && depth == 8)
244   {
245     SetError(error, "cannot handle true-color images on 8-bit display");
246     return NULL;
247   }
248
249   if (!global_cmap)
250   {
251     if (visual == DefaultVisual(display, screen))
252       global_cmap = DefaultColormap(display, screen);
253     else
254     {
255       global_cmap = XCreateColormap(display, RootWindow(display, screen),
256                                     visual, AllocNone);
257       private_cmap = TRUE;
258     }
259   }
260
261   xcolor.flags = DoRed | DoGreen | DoBlue;
262   redvalue = greenvalue = bluevalue = NULL;
263   ximageinfo = checked_malloc(sizeof(XImageInfo));
264   ximageinfo->display = display;
265   ximageinfo->depth = depth;
266
267   switch (visual->class)
268   {
269     case TrueColor:
270     case DirectColor:
271     {
272       Pixel pixval;
273       unsigned int redcolors, greencolors, bluecolors;
274       unsigned int redstep, greenstep, bluestep;
275       unsigned int redbottom, greenbottom, bluebottom;
276       unsigned int redtop, greentop, bluetop;
277
278       redvalue = (Pixel *)checked_malloc(sizeof(Pixel) * 256);
279       greenvalue = (Pixel *)checked_malloc(sizeof(Pixel) * 256);
280       bluevalue = (Pixel *)checked_malloc(sizeof(Pixel) * 256);
281
282       ximageinfo->cmap = global_cmap;
283
284       retry_direct: /* tag we hit if a DirectColor allocation fails on
285                      * default colormap */
286
287       /* calculate number of distinct colors in each band */
288
289       redcolors = greencolors = bluecolors = 1;
290       for (pixval = 1; pixval; pixval <<= 1)
291       {
292         if (pixval & visual->red_mask)
293           redcolors <<= 1;
294         if (pixval & visual->green_mask)
295           greencolors <<= 1;
296         if (pixval & visual->blue_mask)
297           bluecolors <<= 1;
298       }
299       
300       /* consistency check */
301       if (redcolors > visual->map_entries ||
302           greencolors > visual->map_entries ||
303           bluecolors > visual->map_entries)
304         Error(ERR_WARN, "inconsistency in color information");
305
306       redstep = 256 / redcolors;
307       greenstep = 256 / greencolors;
308       bluestep = 256 / bluecolors;
309       redbottom = greenbottom = bluebottom = 0;
310       redtop = greentop = bluetop = 0;
311
312       for (a = 0; a < visual->map_entries; a++)
313       {
314         if (redbottom < 256)
315           redtop = redbottom + redstep;
316         if (greenbottom < 256)
317           greentop = greenbottom + greenstep;
318         if (bluebottom < 256)
319           bluetop = bluebottom + bluestep;
320
321         xcolor.red = (redtop - 1) << 8;
322         xcolor.green = (greentop - 1) << 8;
323         xcolor.blue = (bluetop - 1) << 8;
324         if (!XAllocColor(display, ximageinfo->cmap, &xcolor))
325         {
326           /* if an allocation fails for a DirectColor default visual then
327              we should create a private colormap and try again. */
328
329           if ((visual->class == DirectColor) &&
330               (visual == DefaultVisual(display, screen)))
331           {
332             global_cmap = XCopyColormapAndFree(display, global_cmap);
333             ximageinfo->cmap = global_cmap;
334             private_cmap = TRUE;
335
336             goto retry_direct;
337           }
338
339           /* something completely unexpected happened */
340
341           fprintf(stderr, "Image_to_Pixmap: XAllocColor failed on a TrueColor/Directcolor visual\n");
342
343           free(redvalue);
344           free(greenvalue);
345           free(bluevalue);
346           free(ximageinfo);
347
348           return NULL;
349         }
350
351         /* fill in pixel values for each band at this intensity */
352
353         while ((redbottom < 256) && (redbottom < redtop))
354           redvalue[redbottom++] = xcolor.pixel & visual->red_mask;
355         while ((greenbottom < 256) && (greenbottom < greentop))
356           greenvalue[greenbottom++] = xcolor.pixel & visual->green_mask;
357         while ((bluebottom < 256) && (bluebottom < bluetop))
358           bluevalue[bluebottom++] = xcolor.pixel & visual->blue_mask;
359       }
360
361       break;
362     }
363
364     case PseudoColor:
365
366       ximageinfo->cmap = global_cmap;
367
368       for (a = 0; a < MAX_COLORS; a++)
369       {
370         XColor xcolor2;
371         unsigned short mask;
372         int color_found;
373         int i;
374
375         if (!image->rgb.color_used[a])
376           continue;
377
378         xcolor.red = *(image->rgb.red + a);
379         xcolor.green = *(image->rgb.green + a);
380         xcolor.blue = *(image->rgb.blue + a);
381   
382         /* look if this color already exists in our colormap */
383         if (!XAllocColor(display, ximageinfo->cmap, &xcolor))
384         {
385           if (!private_cmap)
386           {
387             if (options.verbose)
388               Error(ERR_INFO, "switching to private colormap");
389
390             /* we just filled up the default colormap -- get a private one
391                which contains all already allocated colors */
392
393             global_cmap = XCopyColormapAndFree(display, global_cmap);
394             ximageinfo->cmap = global_cmap;
395             private_cmap = TRUE;
396
397             /* allocate the rest of the color cells read/write */
398             global_cmap_index =
399               (Pixel *)checked_malloc(sizeof(Pixel) * NOFLASH_COLORS);
400             for (i = 0; i < NOFLASH_COLORS; i++)
401               if (!XAllocColorCells(display, global_cmap, FALSE, NULL, 0,
402                                     global_cmap_index + i, 1))
403                 break;
404             num_cmap_entries = free_cmap_entries = i;
405
406             /*
407             printf("We've got %d free colormap entries.\n", free_cmap_entries);
408             */
409
410             /* to minimize colormap flashing, copy default colors and try
411                to keep them as near as possible to the old values */
412
413             for (i = 0; i < num_cmap_entries; i++)
414             {
415               xcolor2.pixel = *(global_cmap_index + i);
416               XQueryColor(display, DefaultColormap(display, screen), &xcolor2);
417               XStoreColor(display, global_cmap, &xcolor2);
418               xcolor_private[xcolor2.pixel] = xcolor2;
419               colorcell_used[xcolor2.pixel] = FALSE;
420             }
421
422             /* now we have the default colormap private: all colors we
423                successfully allocated so far are read-only, which is okay,
424                because we don't want to change them anymore -- if we need
425                an existing color again, we get it by XAllocColor; all other
426                colors are read/write and we can set them by XStoreColor,
427                but we will try to overwrite those color cells with our new
428                color which are as close as possible to our new color */
429           }
430
431           /* look for an existing default color close the one we want */
432
433           mask = 0xf000;
434           color_found = FALSE;
435
436           while (!color_found)
437           {
438             for (i = num_cmap_entries - 1; i >= 0; i--)
439             {
440               xcolor2.pixel = *(global_cmap_index + i);
441               xcolor2 = xcolor_private[xcolor2.pixel];
442
443               if (colorcell_used[xcolor2.pixel])
444                 continue;
445
446               if ((xcolor.red & mask) == (xcolor2.red & mask) &&
447                   (xcolor.green & mask) == (xcolor2.green & mask) &&
448                   (xcolor.blue & mask) == (xcolor2.blue & mask))
449               {
450                 /*
451                 printf("replacing color cell %ld with a close color\n",
452                        xcolor2.pixel);
453                        */
454                 color_found = TRUE;
455                 break;
456               }
457             }
458
459             if (mask == 0x0000)
460               break;
461
462             mask = (mask << 1) & 0xffff;
463           }
464
465           if (!color_found)             /* no more free color cells */
466           {
467             SetError(error, "cannot allocate enough color cells");
468             return NULL;
469           }
470
471           xcolor.pixel = xcolor2.pixel;
472           xcolor_private[xcolor.pixel] = xcolor;
473           colorcell_used[xcolor.pixel] = TRUE;
474           XStoreColor(display, ximageinfo->cmap, &xcolor);
475           free_cmap_entries--;
476         }
477
478         *(ximageinfo->index + a) = xcolor.pixel;
479       }
480
481       /*
482       printf("still %d free colormap entries\n", free_cmap_entries);
483       */
484
485       ximageinfo->no = a;       /* number of pixels allocated for this image */
486       break;
487   
488     default:
489       Error(ERR_INFO,"DirectColor, TrueColor or PseudoColor display needed");
490       SetError(error, "display class not supported");
491
492       return NULL;
493   }
494
495 #if DEBUG_TIMING
496   debug_print_timestamp(2, "   ALLOCATING IMAGE COLORS:   ");
497 #endif
498
499   /* create XImage from internal image structure and convert it to Pixmap */
500
501   display_bits_per_pixel = bitsPerPixelAtDepth(display, screen, depth);
502   display_bytes_per_pixel = (display_bits_per_pixel + 7) / 8;
503
504   ximage = XCreateImage(display, visual, depth, ZPixmap,
505                         0, NULL, image->width, image->height,
506                         8, image->width * display_bytes_per_pixel);
507   ximage->data =
508     checked_malloc(image->width * image->height * display_bytes_per_pixel);
509   ximage->byte_order = MSBFirst;
510
511   src_ptr = image->data;
512   dst_ptr = (byte *)ximage->data;
513
514   switch (visual->class)
515   {
516     case DirectColor:
517     case TrueColor:
518     {
519       Pixel pixval;
520
521       switch (image->type)
522       {
523         case IMAGETYPE_RGB:
524         {
525           for (y = 0; y < image->height; y++)           /* general case */
526           {
527             for (x = 0; x < image->width; x++)
528             {
529               pixval = *src_ptr++;
530               pixval =
531                 redvalue[image->rgb.red[pixval] >> 8] |
532                 greenvalue[image->rgb.green[pixval] >> 8] |
533                 bluevalue[image->rgb.blue[pixval] >> 8];
534               value_to_memory(pixval, dst_ptr, display_bytes_per_pixel);
535               dst_ptr += display_bytes_per_pixel;
536             }
537           }
538
539           break;
540         }
541
542         case IMAGETYPE_TRUECOLOR:
543         {
544           for (y = 0; y < image->height; y++)           /* general case */
545           {
546             for (x = 0; x < image->width; x++)
547             {
548               pixval = memory_to_value(src_ptr, image->bytes_per_pixel);
549               pixval =
550                 redvalue[TRUECOLOR_RED(pixval)] |
551                 greenvalue[TRUECOLOR_GREEN(pixval)] |
552                 bluevalue[TRUECOLOR_BLUE(pixval)];
553               value_to_memory(pixval, dst_ptr, display_bytes_per_pixel);
554               src_ptr += image->bytes_per_pixel;
555               dst_ptr += display_bytes_per_pixel;
556             }
557           }
558
559           break;
560         }
561
562         default:
563           Error(ERR_INFO, "RGB or TrueColor image needed");
564           SetError(error, "image type not supported");
565
566           return NULL;
567       }
568
569       break;
570     }
571
572     case PseudoColor:
573     {
574       if (display_bytes_per_pixel == 1)         /* special case */
575       {
576         for (y = 0; y < image->height; y++)
577           for (x = 0; x < image->width; x++)
578             *dst_ptr++ = ximageinfo->index[c + *src_ptr++];
579       }
580       else                                      /* general case */
581       {
582         for (y = 0; y < image->height; y++)
583         {
584           for (x = 0; x < image->width; x++)
585           {
586             value_to_memory(ximageinfo->index[c + *src_ptr++],
587                             dst_ptr, display_bytes_per_pixel);
588             dst_ptr += display_bytes_per_pixel;
589           }
590         }
591       }
592
593       break;
594     }
595
596     default:
597       Error(ERR_INFO,"DirectColor, TrueColor or PseudoColor display needed");
598       SetError(error, "display class not supported");
599
600       return NULL;
601   }
602
603   if (redvalue)
604   {
605     free((byte *)redvalue);
606     free((byte *)greenvalue);
607     free((byte *)bluevalue);
608   }
609
610 #if DEBUG_TIMING
611   debug_print_timestamp(2, "   CONVERTING IMAGE TO XIMAGE:");
612 #endif
613
614   ximageinfo->pixmap = XCreatePixmap(display, window,
615                                      ximage->width, ximage->height,
616                                      ximageinfo->depth);
617
618   XPutImage(ximageinfo->display, ximageinfo->pixmap, gc,
619             ximage, 0, 0, 0, 0, ximage->width, ximage->height);
620
621   X11DestroyImage(ximage);
622
623   return ximageinfo;
624 }
625
626 /*
627   -----------------------------------------------------------------------------
628   ZoomPixmap
629
630   Important note: The scaling code currently only supports scaling of the image
631   up or down by a power of 2 -- other scaling factors currently not supported!
632   Also not supported is scaling of pixmap masks (with depth 1); to scale them,
633   better use Pixmap_to_Mask() for now.
634   -----------------------------------------------------------------------------
635 */
636
637 void ZoomPixmap(Display *display, GC gc, Pixmap src_pixmap, Pixmap dst_pixmap,
638                 int src_width, int src_height,
639                 int dst_width, int dst_height)
640 {
641   XImage *src_ximage, *dst_ximage;
642   byte *src_ptr, *dst_ptr;
643   int bits_per_pixel;
644   int bytes_per_pixel;
645   int x, y, xx, yy, i;
646   int row_skip, col_skip;
647   int zoom_factor;
648   boolean scale_down = (src_width > dst_width);
649
650   if (scale_down)
651   {
652 #if 1
653     zoom_factor = MIN(src_width / dst_width, src_height / dst_height);
654 #else
655     zoom_factor = src_width / dst_width;
656 #endif
657
658     /* adjust source image size to integer multiple of destination size */
659     src_width  = dst_width  * zoom_factor;
660     src_height = dst_height * zoom_factor;
661   }
662   else
663   {
664 #if 1
665     zoom_factor = MIN(dst_width / src_width, dst_height / src_height);
666 #else
667     zoom_factor = dst_width / src_width;
668 #endif
669
670     /* no adjustment needed when scaling up (some pixels may be left blank) */
671   }
672
673   /* copy source pixmap to temporary image */
674   if ((src_ximage = XGetImage(display, src_pixmap, 0, 0, src_width, src_height,
675                               AllPlanes, ZPixmap)) == NULL)
676     Error(ERR_EXIT, "ZoomPixmap(): XGetImage() failed");
677
678   bits_per_pixel = src_ximage->bits_per_pixel;
679   bytes_per_pixel = (bits_per_pixel + 7) / 8;
680
681   if ((dst_ximage = XCreateImage(display, visual, src_ximage->depth, ZPixmap,
682                                  0, NULL, dst_width, dst_height,
683                                  8, dst_width * bytes_per_pixel)) == NULL)
684     Error(ERR_EXIT, "ZoomPixmap(): XCreateImage() failed");
685
686   dst_ximage->data =
687     checked_malloc(dst_width * dst_height * bytes_per_pixel);
688   dst_ximage->byte_order = src_ximage->byte_order;
689
690   src_ptr = (byte *)src_ximage->data;
691   dst_ptr = (byte *)dst_ximage->data;
692
693   if (scale_down)
694   {
695     col_skip = (zoom_factor - 1) * bytes_per_pixel;
696     row_skip = col_skip * src_width;
697
698     /* scale image down by scaling factor 'zoom_factor' */
699     for (y = 0; y < src_height; y += zoom_factor, src_ptr += row_skip)
700       for (x = 0; x < src_width; x += zoom_factor, src_ptr += col_skip)
701         for (i = 0; i < bytes_per_pixel; i++)
702           *dst_ptr++ = *src_ptr++;
703   }
704   else
705   {
706     row_skip = src_width * bytes_per_pixel;
707
708     /* scale image up by scaling factor 'zoom_factor' */
709     for (y = 0; y < src_height; y++)
710     {
711       for (yy = 0; yy < zoom_factor; yy++)
712       {
713         if (yy > 0)
714           src_ptr -= row_skip;
715
716         for (x = 0; x < src_width; x++)
717         {
718           for (xx = 0; xx < zoom_factor; xx++)
719             for (i = 0; i < bytes_per_pixel; i++)
720               *dst_ptr++ = *(src_ptr + i);
721
722           src_ptr += bytes_per_pixel;
723         }
724       }
725     }
726   }
727
728   /* copy scaled image to destination pixmap */
729   XPutImage(display, dst_pixmap, gc, dst_ximage, 0, 0, 0, 0,
730             dst_width, dst_height);
731
732   /* free temporary images */
733   X11DestroyImage(src_ximage);
734   X11DestroyImage(dst_ximage);
735 }
736
737 void freeXImage(Image *image, XImageInfo *ximageinfo)
738 {
739   if (ximageinfo->index != NULL && ximageinfo->no > 0)
740     XFreeColors(ximageinfo->display, ximageinfo->cmap, ximageinfo->index,
741                 ximageinfo->no, 0);
742   /* this       ^^^^^^^^^^^^^^ is wrong, because the used color cells
743    * are somewhere between 0 and MAX_COLORS; there are indeed 'ximageinfo->no'
744    * used color cells, but they are not at array position 0 - 'ximageinfo->no'
745    */
746
747   free(ximageinfo);
748 }
749
750 int Read_PCX_to_Pixmap(Display *display, Window window, GC gc, char *filename,
751                        Pixmap *pixmap, Pixmap *pixmap_mask)
752 {
753   Image *image;
754   XImageInfo *ximageinfo;
755   int screen;
756   Visual *visual;
757   int depth;
758
759 #if DEBUG_TIMING
760   debug_print_timestamp(2, NULL);       /* initialize timestamp function */
761 #endif
762
763   /* read the graphic file in PCX format to image structure */
764   if ((image = Read_PCX_to_Image(filename)) == NULL)
765     return errno_pcx;
766
767 #if DEBUG_TIMING
768   printf("%s:\n", filename);
769   debug_print_timestamp(2, "   READING PCX FILE TO IMAGE: ");
770 #endif
771
772   screen = DefaultScreen(display);
773   visual = DefaultVisual(display, screen);
774   depth = DefaultDepth(display, screen);
775
776   /* convert image structure to X11 Pixmap */
777   if (!(ximageinfo = Image_to_Pixmap(display, screen, visual,
778                                      window, gc, depth, image)))
779   {
780     freeImage(image);
781
782     return PCX_OtherError;
783   }
784
785   /* if a private colormap has been created, install it */
786   if (ximageinfo->cmap != DefaultColormap(display, screen))
787     XSetWindowColormap(display, window, ximageinfo->cmap);
788
789 #if DEBUG_TIMING
790   debug_print_timestamp(2, "   CONVERTING IMAGE TO PIXMAP:");
791 #endif
792
793   /* create clip mask for the image */
794   ximageinfo->pixmap_mask = Image_to_Mask(image, display, window);
795
796 #if DEBUG_TIMING
797   debug_print_timestamp(2, "   CONVERTING IMAGE TO MASK:  ");
798 #endif
799
800   *pixmap = ximageinfo->pixmap;
801   *pixmap_mask = ximageinfo->pixmap_mask;
802
803   /* free generic image and ximageinfo after native Pixmap has been created */
804   free(ximageinfo);
805   freeImage(image);
806
807   return PCX_Success;
808 }
809
810 #endif  /* PLATFORM_UNIX */
811 #endif  /* TARGET_X11 */
812
813
814 /* ========================================================================= */
815 /* PLATFORM INDEPENDENT IMAGE FUNCTIONS                                      */
816 /* ========================================================================= */
817
818 struct ImageInfo
819 {
820   char *source_filename;
821   int num_references;
822
823   Bitmap *bitmap;
824
825   int original_width;                   /* original image file width */
826   int original_height;                  /* original image file height */
827
828   boolean contains_small_images;        /* set after adding small images */
829   boolean scaled_up;                    /* set after scaling up */
830 };
831 typedef struct ImageInfo ImageInfo;
832
833 static struct ArtworkListInfo *image_info = NULL;
834
835 static void *Load_PCX(char *filename)
836 {
837   ImageInfo *img_info;
838
839 #if 0
840   printf("::: loading PCX file '%s'\n", filename);
841 #endif
842
843   img_info = checked_calloc(sizeof(ImageInfo));
844
845   if ((img_info->bitmap = LoadImage(filename)) == NULL)
846   {
847     Error(ERR_WARN, "cannot load image file '%s': LoadImage() failed: %s",
848           filename, GetError());
849     free(img_info);
850     return NULL;
851   }
852
853   img_info->source_filename = getStringCopy(filename);
854
855   img_info->original_width  = img_info->bitmap->width;
856   img_info->original_height = img_info->bitmap->height;
857
858   img_info->contains_small_images = FALSE;
859   img_info->scaled_up = FALSE;
860
861   return img_info;
862 }
863
864 static void FreeImage(void *ptr)
865 {
866   ImageInfo *image = (ImageInfo *)ptr;
867
868   if (image == NULL)
869     return;
870
871   if (image->bitmap)
872     FreeBitmap(image->bitmap);
873
874   if (image->source_filename)
875     free(image->source_filename);
876
877   free(image);
878 }
879
880 int getImageListSize()
881 {
882   return (image_info->num_file_list_entries +
883           image_info->num_dynamic_file_list_entries);
884 }
885
886 struct FileInfo *getImageListEntryFromImageID(int pos)
887 {
888   int num_list_entries = image_info->num_file_list_entries;
889   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
890
891   return (pos < num_list_entries ? &image_info->file_list[list_pos] :
892           &image_info->dynamic_file_list[list_pos]);
893 }
894
895 static ImageInfo *getImageInfoEntryFromImageID(int pos)
896 {
897   int num_list_entries = image_info->num_file_list_entries;
898   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
899   ImageInfo **img_info =
900     (ImageInfo **)(pos < num_list_entries ? image_info->artwork_list :
901                    image_info->dynamic_artwork_list);
902
903   return img_info[list_pos];
904 }
905
906 Bitmap *getBitmapFromImageID(int pos)
907 {
908   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
909
910   return (img_info != NULL ? img_info->bitmap : NULL);
911 }
912
913 int getOriginalImageWidthFromImageID(int pos)
914 {
915   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
916
917   return (img_info != NULL ? img_info->original_width : 0);
918 }
919
920 int getOriginalImageHeightFromImageID(int pos)
921 {
922   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
923
924   return (img_info != NULL ? img_info->original_height : 0);
925 }
926
927 char *getTokenFromImageID(int graphic)
928 {
929   struct FileInfo *file_list = getImageListEntryFromImageID(graphic);
930
931   return (file_list != NULL ? file_list->token : NULL);
932 }
933
934 int getImageIDFromToken(char *token)
935 {
936   struct FileInfo *file_list = image_info->file_list;
937   int num_list_entries = image_info->num_file_list_entries;
938   int i;
939
940   for (i = 0; i < num_list_entries; i++)
941     if (strEqual(file_list[i].token, token))
942       return i;
943
944   return -1;
945 }
946
947 char *getImageConfigFilename()
948 {
949   return getCustomArtworkConfigFilename(image_info->type);
950 }
951
952 int getImageListPropertyMappingSize()
953 {
954   return image_info->num_property_mapping_entries;
955 }
956
957 struct PropertyMapping *getImageListPropertyMapping()
958 {
959   return image_info->property_mapping;
960 }
961
962 void InitImageList(struct ConfigInfo *config_list, int num_file_list_entries,
963                    struct ConfigTypeInfo *config_suffix_list,
964                    char **base_prefixes, char **ext1_suffixes,
965                    char **ext2_suffixes, char **ext3_suffixes,
966                    char **ignore_tokens)
967 {
968   int i;
969
970   image_info = checked_calloc(sizeof(struct ArtworkListInfo));
971   image_info->type = ARTWORK_TYPE_GRAPHICS;
972
973   /* ---------- initialize file list and suffix lists ---------- */
974
975   image_info->num_file_list_entries = num_file_list_entries;
976   image_info->num_dynamic_file_list_entries = 0;
977
978   image_info->file_list =
979     getFileListFromConfigList(config_list, config_suffix_list, ignore_tokens,
980                               num_file_list_entries);
981   image_info->dynamic_file_list = NULL;
982
983   image_info->num_suffix_list_entries = 0;
984   for (i = 0; config_suffix_list[i].token != NULL; i++)
985     image_info->num_suffix_list_entries++;
986
987   image_info->suffix_list = config_suffix_list;
988
989   /* ---------- initialize base prefix and suffixes lists ---------- */
990
991   image_info->num_base_prefixes = 0;
992   for (i = 0; base_prefixes[i] != NULL; i++)
993     image_info->num_base_prefixes++;
994
995   image_info->num_ext1_suffixes = 0;
996   for (i = 0; ext1_suffixes[i] != NULL; i++)
997     image_info->num_ext1_suffixes++;
998
999   image_info->num_ext2_suffixes = 0;
1000   for (i = 0; ext2_suffixes[i] != NULL; i++)
1001     image_info->num_ext2_suffixes++;
1002
1003   image_info->num_ext3_suffixes = 0;
1004   for (i = 0; ext3_suffixes[i] != NULL; i++)
1005     image_info->num_ext3_suffixes++;
1006
1007   image_info->num_ignore_tokens = 0;
1008   for (i = 0; ignore_tokens[i] != NULL; i++)
1009     image_info->num_ignore_tokens++;
1010
1011   image_info->base_prefixes = base_prefixes;
1012   image_info->ext1_suffixes = ext1_suffixes;
1013   image_info->ext2_suffixes = ext2_suffixes;
1014   image_info->ext3_suffixes = ext3_suffixes;
1015   image_info->ignore_tokens = ignore_tokens;
1016
1017   image_info->num_property_mapping_entries = 0;
1018
1019   image_info->property_mapping = NULL;
1020
1021   /* ---------- initialize artwork reference and content lists ---------- */
1022
1023   image_info->sizeof_artwork_list_entry = sizeof(ImageInfo *);
1024
1025   image_info->artwork_list =
1026     checked_calloc(num_file_list_entries * sizeof(ImageInfo *));
1027   image_info->dynamic_artwork_list = NULL;
1028
1029   image_info->content_list = NULL;
1030
1031   /* ---------- initialize artwork loading/freeing functions ---------- */
1032
1033   image_info->load_artwork = Load_PCX;
1034   image_info->free_artwork = FreeImage;
1035 }
1036
1037 void ReloadCustomImages()
1038 {
1039 #if 0
1040   printf("::: reloading images '%s' ...\n", artwork.gfx_current_identifier);
1041 #endif
1042
1043   LoadArtworkConfig(image_info);
1044   ReloadCustomArtworkList(image_info);
1045 }
1046
1047 void CreateImageWithSmallImages(int pos, int zoom_factor)
1048 {
1049   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
1050
1051   if (img_info == NULL || img_info->contains_small_images)
1052     return;
1053
1054   CreateBitmapWithSmallBitmaps(img_info->bitmap, zoom_factor);
1055
1056   img_info->contains_small_images = TRUE;
1057   img_info->scaled_up = TRUE;
1058 }
1059
1060 void ScaleImage(int pos, int zoom_factor)
1061 {
1062   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
1063
1064   if (img_info == NULL || img_info->scaled_up)
1065     return;
1066
1067   if (zoom_factor != 1)
1068     ScaleBitmap(img_info->bitmap, zoom_factor);
1069
1070   img_info->scaled_up = TRUE;
1071 }
1072
1073 void FreeAllImages()
1074 {
1075   FreeCustomArtworkLists(image_info);
1076 }