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     zoom_factor = src_width / dst_width;
 653
 654     /* adjust source image size to integer multiple of destination size */
 655     src_width  = dst_width  * zoom_factor;
 656     src_height = dst_height * zoom_factor;
 657   }
 658   else
 659   {
 660     zoom_factor = dst_width / src_width;
 661
 662     /* no adjustment needed when scaling up (some pixels may be left blank) */
 663   }
 664
 665   /* copy source pixmap to temporary image */
 666   if ((src_ximage = XGetImage(display, src_pixmap, 0, 0, src_width, src_height,
 667                               AllPlanes, ZPixmap)) == NULL)
 668     Error(ERR_EXIT, "ZoomPixmap(): XGetImage() failed");
 669
 670   bits_per_pixel = src_ximage->bits_per_pixel;
 671   bytes_per_pixel = (bits_per_pixel + 7) / 8;
 672
 673   if ((dst_ximage = XCreateImage(display, visual, src_ximage->depth, ZPixmap,
 674                                  0, NULL, dst_width, dst_height,
 675                                  8, dst_width * bytes_per_pixel)) == NULL)
 676     Error(ERR_EXIT, "ZoomPixmap(): XCreateImage() failed");
 677
 678   dst_ximage->data =
 679     checked_malloc(dst_width * dst_height * bytes_per_pixel);
 680   dst_ximage->byte_order = src_ximage->byte_order;
 681
 682   src_ptr = (byte *)src_ximage->data;
 683   dst_ptr = (byte *)dst_ximage->data;
 684
 685   if (scale_down)
 686   {
 687     col_skip = (zoom_factor - 1) * bytes_per_pixel;
 688     row_skip = col_skip * src_width;
 689
 690     /* scale image down by scaling factor 'zoom_factor' */
 691     for (y = 0; y < src_height; y += zoom_factor, src_ptr += row_skip)
 692       for (x = 0; x < src_width; x += zoom_factor, src_ptr += col_skip)
 693         for (i = 0; i < bytes_per_pixel; i++)
 694           *dst_ptr++ = *src_ptr++;
 695   }
 696   else
 697   {
 698     row_skip = src_width * bytes_per_pixel;
 699
 700     /* scale image up by scaling factor 'zoom_factor' */
 701     for (y = 0; y < src_height; y++)
 702     {
 703       for (yy = 0; yy < zoom_factor; yy++)
 704       {
 705         if (yy > 0)
 706           src_ptr -= row_skip;
 707
 708         for (x = 0; x < src_width; x++)
 709         {
 710           for (xx = 0; xx < zoom_factor; xx++)
 711             for (i = 0; i < bytes_per_pixel; i++)
 712               *dst_ptr++ = *(src_ptr + i);
 713
 714           src_ptr += bytes_per_pixel;
 715         }
 716       }
 717     }
 718   }
 719
 720   /* copy scaled image to destination pixmap */
 721   XPutImage(display, dst_pixmap, gc, dst_ximage, 0, 0, 0, 0,
 722             dst_width, dst_height);
 723
 724   /* free temporary images */
 725   X11DestroyImage(src_ximage);
 726   X11DestroyImage(dst_ximage);
 727 }
 728
 729 void freeXImage(Image *image, XImageInfo *ximageinfo)
 730 {
 731   if (ximageinfo->index != NULL && ximageinfo->no > 0)
 732     XFreeColors(ximageinfo->display, ximageinfo->cmap, ximageinfo->index,
 733                 ximageinfo->no, 0);
 734   /* this       ^^^^^^^^^^^^^^ is wrong, because the used color cells
 735    * are somewhere between 0 and MAX_COLORS; there are indeed 'ximageinfo->no'
 736    * used color cells, but they are not at array position 0 - 'ximageinfo->no'
 737    */
 738
 739   free(ximageinfo);
 740 }
 741
 742 int Read_PCX_to_Pixmap(Display *display, Window window, GC gc, char *filename,
 743                        Pixmap *pixmap, Pixmap *pixmap_mask)
 744 {
 745   Image *image;
 746   XImageInfo *ximageinfo;
 747   int screen;
 748   Visual *visual;
 749   int depth;
 750
 751 #if DEBUG_TIMING
 752   debug_print_timestamp(2, NULL);       /* initialize timestamp function */
 753 #endif
 754
 755   /* read the graphic file in PCX format to image structure */
 756   if ((image = Read_PCX_to_Image(filename)) == NULL)
 757     return errno_pcx;
 758
 759 #if DEBUG_TIMING
 760   printf("%s:\n", filename);
 761   debug_print_timestamp(2, "   READING PCX FILE TO IMAGE: ");
 762 #endif
 763
 764   screen = DefaultScreen(display);
 765   visual = DefaultVisual(display, screen);
 766   depth = DefaultDepth(display, screen);
 767
 768   /* convert image structure to X11 Pixmap */
 769   if (!(ximageinfo = Image_to_Pixmap(display, screen, visual,
 770                                      window, gc, depth, image)))
 771   {
 772     freeImage(image);
 773
 774     return PCX_OtherError;
 775   }
 776
 777   /* if a private colormap has been created, install it */
 778   if (ximageinfo->cmap != DefaultColormap(display, screen))
 779     XSetWindowColormap(display, window, ximageinfo->cmap);
 780
 781 #if DEBUG_TIMING
 782   debug_print_timestamp(2, "   CONVERTING IMAGE TO PIXMAP:");
 783 #endif
 784
 785   /* create clip mask for the image */
 786   ximageinfo->pixmap_mask = Image_to_Mask(image, display, window);
 787
 788 #if DEBUG_TIMING
 789   debug_print_timestamp(2, "   CONVERTING IMAGE TO MASK:  ");
 790 #endif
 791
 792   *pixmap = ximageinfo->pixmap;
 793   *pixmap_mask = ximageinfo->pixmap_mask;
 794
 795   /* free generic image and ximageinfo after native Pixmap has been created */
 796   free(ximageinfo);
 797   freeImage(image);
 798
 799   return PCX_Success;
 800 }
 801
 802 #endif  /* PLATFORM_UNIX */
 803 #endif  /* TARGET_X11 */
 804
 805
 806 /* ========================================================================= */
 807 /* PLATFORM INDEPENDENT IMAGE FUNCTIONS                                      */
 808 /* ========================================================================= */
 809
 810 struct ImageInfo
 811 {
 812   char *source_filename;
 813   int num_references;
 814
 815   Bitmap *bitmap;
 816
 817   int original_width;                   /* original image file width */
 818   int original_height;                  /* original image file height */
 819
 820   boolean contains_small_images;        /* set after adding small images */
 821   boolean scaled_up;                    /* set after scaling up */
 822 };
 823 typedef struct ImageInfo ImageInfo;
 824
 825 static struct ArtworkListInfo *image_info = NULL;
 826
 827 static void *Load_PCX(char *filename)
 828 {
 829   ImageInfo *img_info;
 830
 831 #if 0
 832   printf("::: loading PCX file '%s'\n", filename);
 833 #endif
 834
 835   img_info = checked_calloc(sizeof(ImageInfo));
 836
 837   if ((img_info->bitmap = LoadImage(filename)) == NULL)
 838   {
 839     Error(ERR_WARN, "cannot load image file '%s': LoadImage() failed: %s",
 840           filename, GetError());
 841     free(img_info);
 842     return NULL;
 843   }
 844
 845   img_info->source_filename = getStringCopy(filename);
 846
 847   img_info->original_width  = img_info->bitmap->width;
 848   img_info->original_height = img_info->bitmap->height;
 849
 850   img_info->contains_small_images = FALSE;
 851   img_info->scaled_up = FALSE;
 852
 853   return img_info;
 854 }
 855
 856 static void FreeImage(void *ptr)
 857 {
 858   ImageInfo *image = (ImageInfo *)ptr;
 859
 860   if (image == NULL)
 861     return;
 862
 863   if (image->bitmap)
 864     FreeBitmap(image->bitmap);
 865
 866   if (image->source_filename)
 867     free(image->source_filename);
 868
 869   free(image);
 870 }
 871
 872 int getImageListSize()
 873 {
 874   return (image_info->num_file_list_entries +
 875           image_info->num_dynamic_file_list_entries);
 876 }
 877
 878 struct FileInfo *getImageListEntryFromImageID(int pos)
 879 {
 880   int num_list_entries = image_info->num_file_list_entries;
 881   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
 882
 883   return (pos < num_list_entries ? &image_info->file_list[list_pos] :
 884           &image_info->dynamic_file_list[list_pos]);
 885 }
 886
 887 static ImageInfo *getImageInfoEntryFromImageID(int pos)
 888 {
 889   int num_list_entries = image_info->num_file_list_entries;
 890   int list_pos = (pos < num_list_entries ? pos : pos - num_list_entries);
 891   ImageInfo **img_info =
 892     (ImageInfo **)(pos < num_list_entries ? image_info->artwork_list :
 893                    image_info->dynamic_artwork_list);
 894
 895   return img_info[list_pos];
 896 }
 897
 898 Bitmap *getBitmapFromImageID(int pos)
 899 {
 900   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
 901
 902   return (img_info != NULL ? img_info->bitmap : NULL);
 903 }
 904
 905 int getOriginalImageWidthFromImageID(int pos)
 906 {
 907   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
 908
 909   return (img_info != NULL ? img_info->original_width : 0);
 910 }
 911
 912 int getOriginalImageHeightFromImageID(int pos)
 913 {
 914   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
 915
 916   return (img_info != NULL ? img_info->original_height : 0);
 917 }
 918
 919 char *getTokenFromImageID(int graphic)
 920 {
 921   struct FileInfo *file_list = getImageListEntryFromImageID(graphic);
 922
 923   return (file_list != NULL ? file_list->token : NULL);
 924 }
 925
 926 int getImageIDFromToken(char *token)
 927 {
 928   struct FileInfo *file_list = image_info->file_list;
 929   int num_list_entries = image_info->num_file_list_entries;
 930   int i;
 931
 932   for (i = 0; i < num_list_entries; i++)
 933     if (strEqual(file_list[i].token, token))
 934       return i;
 935
 936   return -1;
 937 }
 938
 939 char *getImageConfigFilename()
 940 {
 941   return getCustomArtworkConfigFilename(image_info->type);
 942 }
 943
 944 int getImageListPropertyMappingSize()
 945 {
 946   return image_info->num_property_mapping_entries;
 947 }
 948
 949 struct PropertyMapping *getImageListPropertyMapping()
 950 {
 951   return image_info->property_mapping;
 952 }
 953
 954 void InitImageList(struct ConfigInfo *config_list, int num_file_list_entries,
 955                    struct ConfigTypeInfo *config_suffix_list,
 956                    char **base_prefixes, char **ext1_suffixes,
 957                    char **ext2_suffixes, char **ext3_suffixes,
 958                    char **ignore_tokens)
 959 {
 960   int i;
 961
 962   image_info = checked_calloc(sizeof(struct ArtworkListInfo));
 963   image_info->type = ARTWORK_TYPE_GRAPHICS;
 964
 965   /* ---------- initialize file list and suffix lists ---------- */
 966
 967   image_info->num_file_list_entries = num_file_list_entries;
 968   image_info->num_dynamic_file_list_entries = 0;
 969
 970   image_info->file_list =
 971     getFileListFromConfigList(config_list, config_suffix_list, ignore_tokens,
 972                               num_file_list_entries);
 973   image_info->dynamic_file_list = NULL;
 974
 975   image_info->num_suffix_list_entries = 0;
 976   for (i = 0; config_suffix_list[i].token != NULL; i++)
 977     image_info->num_suffix_list_entries++;
 978
 979   image_info->suffix_list = config_suffix_list;
 980
 981   /* ---------- initialize base prefix and suffixes lists ---------- */
 982
 983   image_info->num_base_prefixes = 0;
 984   for (i = 0; base_prefixes[i] != NULL; i++)
 985     image_info->num_base_prefixes++;
 986
 987   image_info->num_ext1_suffixes = 0;
 988   for (i = 0; ext1_suffixes[i] != NULL; i++)
 989     image_info->num_ext1_suffixes++;
 990
 991   image_info->num_ext2_suffixes = 0;
 992   for (i = 0; ext2_suffixes[i] != NULL; i++)
 993     image_info->num_ext2_suffixes++;
 994
 995   image_info->num_ext3_suffixes = 0;
 996   for (i = 0; ext3_suffixes[i] != NULL; i++)
 997     image_info->num_ext3_suffixes++;
 998
 999   image_info->num_ignore_tokens = 0;
1000   for (i = 0; ignore_tokens[i] != NULL; i++)
1001     image_info->num_ignore_tokens++;
1002
1003   image_info->base_prefixes = base_prefixes;
1004   image_info->ext1_suffixes = ext1_suffixes;
1005   image_info->ext2_suffixes = ext2_suffixes;
1006   image_info->ext3_suffixes = ext3_suffixes;
1007   image_info->ignore_tokens = ignore_tokens;
1008
1009   image_info->num_property_mapping_entries = 0;
1010
1011   image_info->property_mapping = NULL;
1012
1013   /* ---------- initialize artwork reference and content lists ---------- */
1014
1015   image_info->sizeof_artwork_list_entry = sizeof(ImageInfo *);
1016
1017   image_info->artwork_list =
1018     checked_calloc(num_file_list_entries * sizeof(ImageInfo *));
1019   image_info->dynamic_artwork_list = NULL;
1020
1021   image_info->content_list = NULL;
1022
1023   /* ---------- initialize artwork loading/freeing functions ---------- */
1024
1025   image_info->load_artwork = Load_PCX;
1026   image_info->free_artwork = FreeImage;
1027 }
1028
1029 void ReloadCustomImages()
1030 {
1031 #if 0
1032   printf("::: reloading images '%s' ...\n", artwork.gfx_current_identifier);
1033 #endif
1034
1035   LoadArtworkConfig(image_info);
1036   ReloadCustomArtworkList(image_info);
1037 }
1038
1039 void CreateImageWithSmallImages(int pos, int zoom_factor)
1040 {
1041   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
1042
1043   if (img_info == NULL || img_info->contains_small_images)
1044     return;
1045
1046   CreateBitmapWithSmallBitmaps(img_info->bitmap, zoom_factor);
1047
1048   img_info->contains_small_images = TRUE;
1049   img_info->scaled_up = TRUE;
1050 }
1051
1052 void ScaleImage(int pos, int zoom_factor)
1053 {
1054   ImageInfo *img_info = getImageInfoEntryFromImageID(pos);
1055
1056   if (img_info == NULL || img_info->scaled_up)
1057     return;
1058
1059   if (zoom_factor != 1)
1060     ScaleBitmap(img_info->bitmap, zoom_factor);
1061
1062   img_info->scaled_up = TRUE;
1063 }
1064
1065 void FreeAllImages()
1066 {
1067   FreeCustomArtworkLists(image_info);
1068 }