images/io-main.c

   1 /*
   2  *      Image Library -- Image compression/decompression interface
   3  *
   4  *      (c) 2006 Pavel Charvat <pchar@ucw.cz>
   5  *
   6  *      This software may be freely distributed and used according to the terms
   7  *      of the GNU Lesser General Public License.
   8  */
   9
  10 #undef LOCAL_DEBUG
  11
  12 #include "lib/lib.h"
  13 #include "images/images.h"
  14 #include <string.h>
  15
  16 void
  17 image_io_init(struct image_thread *it, struct image_io *io)
  18 {
  19   DBG("image_io_init()");
  20   bzero(io, sizeof(*io));
  21   io->thread = it;
  22   io->internal_pool = mp_new(1024);
  23 }
  24
  25 static inline void
  26 image_io_read_cancel(struct image_io *io)
  27 {
  28   if (io->read_cancel)
  29     {
  30       io->read_cancel(io);
  31       io->read_cancel = NULL;
  32     }
  33 }
  34
  35 static inline void
  36 image_io_image_destroy(struct image_io *io)
  37 {
  38   if (io->image_destroy)
  39     {
  40       image_destroy(io->thread, io->image);
  41       io->image_destroy = 0;
  42       io->image = NULL;
  43     }
  44 }
  45
  46 void
  47 image_io_cleanup(struct image_io *io)
  48 {
  49   DBG("image_io_cleanup()");
  50   image_io_read_cancel(io);
  51   image_io_image_destroy(io);
  52   mp_delete(io->internal_pool);
  53 }
  54
  55 void
  56 image_io_reset(struct image_io *io)
  57 {
  58   DBG("image_io_reset()");
  59   image_io_read_cancel(io);
  60   image_io_image_destroy(io);
  61   struct mempool *pool = io->internal_pool;
  62   mp_flush(pool);
  63   bzero(io, sizeof(*io));
  64   io->internal_pool = pool;
  65 }
  66
  67 int
  68 image_io_read_header(struct image_io *io)
  69 {
  70   DBG("image_io_read_header()");
  71   image_io_read_cancel(io);
  72   image_io_image_destroy(io);
  73   switch (io->format) {
  74     case IMAGE_FORMAT_JPEG:
  75 #if defined(CONFIG_LIBJPEG)
  76       return libjpeg_read_header(io);
  77 #elif defined(CONFIG_LIBMAGICK)
  78       return libmagick_read_header(io);
  79 #endif
  80       break;
  81
  82     case IMAGE_FORMAT_PNG:
  83 #if defined(CONFIG_LIBPNG)
  84       return libpng_read_header(io);
  85 #elif defined(CONFIG_LIBMAGICK)
  86       return libmagick_read_header(io);
  87 #endif
  88       break;
  89
  90     case IMAGE_FORMAT_GIF:
  91 #if defined(CONFIG_LIBUNGIG)
  92       return libungif_read_header(io);
  93 #elif defined(CONFIG_LIBMAGICK)
  94       return libmagick_read_header(io);
  95 #endif
  96       break;
  97
  98     case IMAGE_FORMAT_UNKNOWN:
  99       // FIXME: auto-detect
 100       break;
 101
 102     default:
 103       ASSERT(0);
 104   }
 105   image_thread_err(io->thread, IMAGE_ERR_INVALID_FILE_FORMAT, "Image format not supported.");
 106   return 0;
 107 }
 108
 109 struct image *
 110 image_io_read_data(struct image_io *io, int ref)
 111 {
 112   DBG("image_io_read_data()");
 113   ASSERT(io->read_cancel);
 114   io->read_cancel = NULL;
 115   int result;
 116   switch (io->format) {
 117     case IMAGE_FORMAT_JPEG:
 118 #if defined(CONFIG_LIBJPEG)
 119       result = libjpeg_read_data(io);
 120 #elif defined(CONFIG_LIBMAGICK)
 121       result = libmagick_read_data(io);
 122 #else
 123       ASSERT(0);
 124 #endif
 125       break;
 126
 127     case IMAGE_FORMAT_PNG:
 128 #if defined(CONFIG_LIBPNG)
 129       result = libpng_read_data(io);
 130 #elif defined(CONFIG_LIBMAGICK)
 131       result = libmagick_read_data(io);
 132 #else
 133       ASSERT(0);
 134 #endif
 135       break;
 136
 137     case IMAGE_FORMAT_GIF:
 138 #if defined(CONFIG_LIBUNGIF)
 139       result = libungif_read_data(io);
 140 #elif defined(CONFIG_LIBMAGICK)
 141       result = libmagick_read_data(io);
 142 #else
 143       ASSERT(0);
 144 #endif
 145       break;
 146
 147     default:
 148       ASSERT(0);
 149   }
 150   if (result)
 151     {
 152       if (ref)
 153         io->image_destroy = 0;
 154       return io->image;
 155     }
 156   else
 157     return NULL;
 158 }
 159
 160 struct image *
 161 image_io_read(struct image_io *io, int ref)
 162 {
 163   if (!image_io_read_header(io))
 164     return NULL;
 165   return image_io_read_data(io, ref);
 166 }
 167
 168 int
 169 image_io_write(struct image_io *io)
 170 {
 171   DBG("image_io_write()");
 172   image_io_read_cancel(io);
 173   switch (io->format) {
 174     case IMAGE_FORMAT_JPEG:
 175 #if defined(CONFIG_LIBJPEG)
 176       return libjpeg_write(io);
 177 #endif
 178       break;
 179
 180     case IMAGE_FORMAT_PNG:
 181       break;
 182
 183     case IMAGE_FORMAT_GIF:
 184       break;
 185
 186     default:
 187       break;
 188   }
 189   image_thread_err(io->thread, IMAGE_ERR_INVALID_FILE_FORMAT, "Image format not supported.");
 190   return 0;
 191 }
 192
 193 byte *
 194 image_format_to_extension(enum image_format format)
 195 {
 196   switch (format)
 197     {
 198       case IMAGE_FORMAT_JPEG:
 199         return "jpg";
 200       case IMAGE_FORMAT_PNG:
 201         return "png";
 202       case IMAGE_FORMAT_GIF:
 203         return "gif";
 204       default:
 205         return NULL;
 206     }
 207 }
 208
 209 enum image_format
 210 image_extension_to_format(byte *extension)
 211 {
 212   if (!strcasecmp(extension, "jpg"))
 213     return IMAGE_FORMAT_JPEG;
 214   if (!strcasecmp(extension, "jpeg"))
 215     return IMAGE_FORMAT_JPEG;
 216   if (!strcasecmp(extension, "png"))
 217     return IMAGE_FORMAT_PNG;
 218   if (!strcasecmp(extension, "gif"))
 219     return IMAGE_FORMAT_GIF;
 220   return IMAGE_FORMAT_UNKNOWN;
 221 }
 222
 223 enum image_format
 224 image_file_name_to_format(byte *file_name)
 225 {
 226   byte *extension = strrchr(file_name, '.');
 227   return extension ? image_extension_to_format(extension + 1) : IMAGE_FORMAT_UNKNOWN;
 228 }