wrlib/load.c

   1 /* load.c - load image from file
   2  *
   3  *  Raster graphics library
   4  *
   5  *  Copyright (c) 1997 Alfredo K. Kojima
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Library General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 2 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Library General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <config.h>
  23
  24 #include <X11/Xlib.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <sys/stat.h>
  30 #include <string.h>
  31 #include <time.h>
  32
  33 #ifdef USE_PNG
  34 #include <png.h>
  35 #endif
  36
  37 #include "wraster.h"
  38
  39
  40 typedef struct RCachedImage {
  41     RImage      *image;
  42     char        *file;
  43     time_t      last_modif;            /* last time file was modified */
  44     time_t      last_use;              /* last time image was used */
  45 } RCachedImage;
  46
  47
  48 /*
  49  * Size of image cache
  50  */
  51 static int RImageCacheSize = -1;
  52
  53 /*
  54  * Max. size of image to store in cache
  55  */
  56 static int RImageCacheMaxImage = -1; /* 0 = any size */
  57
  58 #define IMAGE_CACHE_SIZE        8
  59
  60 #define IMAGE_CACHE_MAX_IMAGE   64*64
  61
  62 static RCachedImage *RImageCache;
  63
  64
  65
  66
  67
  68 #define IM_ERROR        -1
  69 #define IM_UNKNOWN      0
  70 #define IM_XPM          1
  71 #define IM_TIFF         2
  72 #define IM_PNG          3
  73 #define IM_PPM          4
  74 #define IM_JPEG         5
  75 #define IM_GIF          6
  76 /* How many image types do we have. */
  77 /* Increase this when adding new image types! */
  78 #define IM_TYPES        6
  79
  80
  81 static int identFile(char *path);
  82
  83 extern RImage *RLoadPPM(RContext *context, char *file_name, int index);
  84
  85 extern RImage *RLoadXPM(RContext *context, char *file, int index);
  86
  87
  88 #ifdef USE_TIFF
  89 extern RImage *RLoadTIFF(RContext *context, char *file, int index);
  90 #endif
  91 #ifdef USE_PNG
  92 extern RImage *RLoadPNG(RContext *context, char *file, int index);
  93 #endif
  94 #ifdef USE_JPEG
  95 extern RImage *RLoadJPEG(RContext *context, char *file_name, int index);
  96 #endif
  97 #ifdef USE_GIF
  98 extern RImage *RLoadGIF(RContext *context, char *file_name, int index);
  99 #endif
 100
 101
 102 static char*
 103 wstrdup(char *s)
 104 {
 105     char *tmp;
 106
 107     tmp = malloc(strlen(s)+1);
 108     if (!tmp)
 109         return NULL;
 110     return strcpy(tmp, s);
 111 }
 112
 113 char**
 114 RSupportedFileFormats(void)
 115 {
 116     char **tmp;
 117     int i = 0;
 118
 119     tmp = malloc(sizeof(char*)*(IM_TYPES+1));
 120     if (!tmp)
 121         return NULL;
 122     memset(tmp, 0, sizeof(char*)*(IM_TYPES+1));
 123
 124     /* built-in */
 125     tmp[i++] = wstrdup("XPM");
 126     if (!tmp[i-1]) {
 127         RFreeStringList(tmp);
 128         return NULL;
 129     }
 130     /* built-in */
 131     tmp[i++] = wstrdup("PPM");
 132     if (!tmp[i-1]) {
 133         RFreeStringList(tmp);
 134         return NULL;
 135     }
 136 #ifdef USE_TIFF
 137     tmp[i++] = wstrdup("TIFF");
 138     if (!tmp[i-1]) {
 139         RFreeStringList(tmp);
 140         return NULL;
 141     }
 142 #endif
 143 #ifdef USE_PNG
 144     tmp[i++] = wstrdup("PNG");
 145     if (!tmp[i-1]) {
 146         RFreeStringList(tmp);
 147         return NULL;
 148     }
 149 #endif
 150 #ifdef USE_JPEG
 151     tmp[i++] = wstrdup("JPEG");
 152     if (!tmp[i-1]) {
 153         RFreeStringList(tmp);
 154         return NULL;
 155     }
 156 #endif
 157 #ifdef USE_GIF
 158     tmp[i++] = wstrdup("GIF");
 159     if (!tmp[i-1]) {
 160         RFreeStringList(tmp);
 161         return NULL;
 162     }
 163 #endif
 164     tmp[i] = NULL;
 165
 166     return tmp;
 167 }
 168
 169
 170 void
 171 RFreeStringList(char **list)
 172 {
 173     int i;
 174
 175     for (i = 0; list[i]!=NULL; i++) {
 176         free(list[i]);
 177     }
 178     free(list);
 179 }
 180
 181
 182 static void
 183 init_cache()
 184 {
 185     char *tmp;
 186
 187     tmp = getenv("RIMAGE_CACHE");
 188     if (!tmp || sscanf(tmp, "%i", &RImageCacheSize)!=1) {
 189         RImageCacheSize = IMAGE_CACHE_SIZE;
 190     }
 191     if (RImageCacheSize<0)
 192         RImageCacheSize = 0;
 193
 194     tmp = getenv("RIMAGE_CACHE_SIZE");
 195     if (!tmp || sscanf(tmp, "%i", &RImageCacheMaxImage)!=1) {
 196         RImageCacheMaxImage = IMAGE_CACHE_MAX_IMAGE;
 197     }
 198
 199     if (RImageCacheSize>0) {
 200         RImageCache = malloc(sizeof(RCachedImage)*RImageCacheSize);
 201         if (RImageCache==NULL) {
 202             printf("wrlib: out of memory for image cache\n");
 203             return;
 204         }
 205         memset(RImageCache, 0, sizeof(RCachedImage)*RImageCacheSize);
 206     }
 207 }
 208
 209
 210 RImage*
 211 RLoadImage(RContext *context, char *file, int index)
 212 {
 213     RImage *image = NULL;
 214     int i;
 215     struct stat st;
 216
 217     RErrorString[0] = 0;
 218
 219     if (RImageCacheSize<0) {
 220         init_cache();
 221     }
 222
 223     if (RImageCacheSize>0) {
 224
 225         for (i=0; i<RImageCacheSize; i++) {
 226             if (RImageCache[i].file
 227                 && strcmp(file, RImageCache[i].file)==0) {
 228
 229                 if (stat(file, &st)==0
 230                     && st.st_mtime == RImageCache[i].last_modif) {
 231                     RImageCache[i].last_use = time(NULL);
 232
 233                     return RCloneImage(RImageCache[i].image);
 234
 235                 } else {
 236                     free(RImageCache[i].file);
 237                     RImageCache[i].file = NULL;
 238                     RDestroyImage(RImageCache[i].image);
 239                 }
 240             }
 241         }
 242     }
 243
 244     switch (identFile(file)) {
 245      case IM_ERROR:
 246         sprintf(RErrorString, "error opening file");
 247         return NULL;
 248
 249      case IM_UNKNOWN:
 250         sprintf(RErrorString, "unknown image format");
 251         return NULL;
 252
 253      case IM_XPM:
 254         image = RLoadXPM(context, file, index);
 255         break;
 256
 257 #ifdef USE_TIFF
 258      case IM_TIFF:
 259         image = RLoadTIFF(context, file, index);
 260         break;
 261 #endif /* USE_TIFF */
 262
 263 #ifdef USE_PNG
 264      case IM_PNG:
 265         image = RLoadPNG(context, file, index);
 266         break;
 267 #endif /* USE_PNG */
 268
 269 #ifdef USE_JPEG
 270      case IM_JPEG:
 271         image = RLoadJPEG(context, file, index);
 272         break;
 273 #endif /* USE_JPEG */
 274
 275 #ifdef USE_GIF
 276      case IM_GIF:
 277         image = RLoadGIF(context, file, index);
 278         break;
 279 #endif /* USE_GIF */
 280
 281      case IM_PPM:
 282         image = RLoadPPM(context, file, index);
 283         break;
 284
 285      default:
 286         sprintf(RErrorString, "unsupported image format");
 287         return NULL;
 288     }
 289
 290
 291     /* store image in cache */
 292     if (RImageCacheSize>0 && image &&
 293         (RImageCacheMaxImage==0
 294          || RImageCacheMaxImage >= image->width*image->height)) {
 295         time_t oldest=time(NULL);
 296         int oldest_idx = 0;
 297         int done = 0;
 298
 299         for (i=0; i<RImageCacheSize; i++) {
 300             if (!RImageCache[i].file) {
 301                 RImageCache[i].file = malloc(strlen(file)+1);
 302                 strcpy(RImageCache[i].file, file);
 303                 RImageCache[i].image = RCloneImage(image);
 304                 RImageCache[i].last_modif = st.st_mtime;
 305                 RImageCache[i].last_use = time(NULL);
 306                 done = 1;
 307                 break;
 308             } else {
 309                 if (oldest > RImageCache[i].last_use) {
 310                     oldest = RImageCache[i].last_use;
 311                     oldest_idx = i;
 312                 }
 313             }
 314         }
 315
 316         /* if no slot available, dump least recently used one */
 317         if (!done) {
 318             free(RImageCache[oldest_idx].file);
 319             RDestroyImage(RImageCache[oldest_idx].image);
 320             RImageCache[oldest_idx].file = malloc(strlen(file)+1);
 321             strcpy(RImageCache[oldest_idx].file, file);
 322             RImageCache[oldest_idx].image = RCloneImage(image);
 323             RImageCache[oldest_idx].last_modif = st.st_mtime;
 324             RImageCache[oldest_idx].last_use = time(NULL);
 325         }
 326     }
 327
 328     return image;
 329 }
 330
 331
 332
 333
 334
 335 static int
 336 identFile(char *path)
 337 {
 338     int fd;
 339     unsigned char buffer[32];
 340
 341     if (!path)
 342         return IM_ERROR;
 343
 344     fd = open(path, O_RDONLY);
 345     if (fd < 0)
 346         return IM_ERROR;
 347     if (read(fd, buffer, 32)<1) {
 348         close(fd);
 349         return IM_ERROR;
 350     }
 351     close(fd);
 352
 353     /* check for XPM */
 354     if (strncmp((char*)buffer, "/* XPM */", 9)==0)
 355         return IM_XPM;
 356
 357     /* check for TIFF */
 358     if ((buffer[0]=='I' && buffer[1]=='I' && buffer[2]=='*' && buffer[3]==0)
 359         ||(buffer[0]=='M' && buffer[1]=='M' && buffer[2]==0 && buffer[3]=='*'))
 360         return IM_TIFF;
 361
 362 #ifdef USE_PNG
 363     /* check for PNG */
 364     if (png_check_sig(buffer, 8))
 365         return IM_PNG;
 366 #endif
 367
 368     /* check for raw PPM or PGM */
 369     if (buffer[0]=='P' && (buffer[1]=='5' || buffer[1]=='6'))
 370         return IM_PPM;
 371
 372     /* check for JPEG */
 373     if (buffer[0] == 0xff && buffer[1] == 0xd8)
 374         return IM_JPEG;
 375
 376     /* check for GIF */
 377     if (buffer[0] == 'G' && buffer[1] == 'I' && buffer[2] == 'F')
 378         return IM_GIF;
 379
 380     return IM_UNKNOWN;
 381 }
 382
 383
 384