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 "lib/mempool.h"
  14 #include "images/images.h"
  15 #include "images/error.h"
  16 #include "images/io-main.h"
  17
  18 #include <string.h>
  19
  20 int
  21 image_io_init(struct image_context *ctx, struct image_io *io)
  22 {
  23   DBG("image_io_init()");
  24   bzero(io, sizeof(*io));
  25   io->context = ctx;
  26 #ifdef CONFIG_IMAGES_LIBJPEG
  27   if (!libjpeg_init(io))
  28     goto libjpeg_failed;
  29 #endif
  30 #ifdef CONFIG_IMAGES_LIBPNG
  31   if (!libpng_init(io))
  32     goto libpng_failed;
  33 #endif
  34 #ifdef CONFIG_IMAGES_LIBUNGIF
  35   if (!libungif_init(io))
  36     goto libungif_failed;
  37 #endif
  38 #ifdef CONFIG_IMAGES_LIBMAGICK
  39   if (!libmagick_init(io))
  40     goto libmagick_failed;
  41 #endif
  42   io->internal_pool = mp_new(1024);
  43   return 1;
  44 #ifdef CONFIG_IMAGES_LIBMAGICK
  45   libmagick_cleanup(io);
  46 libmagick_failed:
  47 #endif
  48 #ifdef CONFIG_IMAGES_LIBUNGIF
  49   libungif_cleanup(io);
  50 libungif_failed:
  51 #endif
  52 #ifdef CONFIG_IMAGES_LIBPNG
  53   libpng_cleanup(io);
  54 libpng_failed:
  55 #endif
  56 #ifdef CONFIG_IMAGES_LIBJPEG
  57   libjpeg_cleanup(io);
  58 libjpeg_failed:
  59 #endif
  60   return 0;
  61 }
  62
  63 static inline void
  64 image_io_read_cancel(struct image_io *io)
  65 {
  66   if (io->read_cancel)
  67     {
  68       io->read_cancel(io);
  69       io->read_cancel = NULL;
  70     }
  71 }
  72
  73 static inline void
  74 image_io_image_destroy(struct image_io *io)
  75 {
  76   if (io->image && (io->flags & IMAGE_IO_NEED_DESTROY))
  77     {
  78       image_destroy(io->image);
  79       io->flags &= ~IMAGE_IO_NEED_DESTROY;
  80       io->image = NULL;
  81     }
  82 }
  83
  84 void
  85 image_io_cleanup(struct image_io *io)
  86 {
  87   DBG("image_io_cleanup()");
  88   image_io_read_cancel(io);
  89   image_io_image_destroy(io);
  90 #ifdef CONFIG_IMAGES_LIBMAGICK
  91   libmagick_cleanup(io);
  92 #endif
  93 #ifdef CONFIG_IMAGES_LIBUNGIF
  94   libungif_cleanup(io);
  95 #endif
  96 #ifdef CONFIG_IMAGES_LIBPNG
  97   libpng_cleanup(io);
  98 #endif
  99 #ifdef CONFIG_IMAGES_LIBJPEG
 100   libjpeg_cleanup(io);
 101 #endif
 102   mp_delete(io->internal_pool);
 103 }
 104
 105 void
 106 image_io_reset(struct image_io *io)
 107 {
 108   DBG("image_io_reset()");
 109   image_io_read_cancel(io);
 110   image_io_image_destroy(io);
 111   struct mempool *pool = io->internal_pool;
 112   struct image_context *ctx = io->context;
 113   mp_flush(pool);
 114   bzero(io, sizeof(*io));
 115   io->internal_pool = pool;
 116   io->context = ctx;
 117 }
 118
 119 int
 120 image_io_read_header(struct image_io *io)
 121 {
 122   DBG("image_io_read_header()");
 123   image_io_read_cancel(io);
 124   image_io_image_destroy(io);
 125   switch (io->format) {
 126     case IMAGE_FORMAT_JPEG:
 127 #if defined(CONFIG_IMAGES_LIBJPEG)
 128       return libjpeg_read_header(io);
 129 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 130       return libmagick_read_header(io);
 131 #endif
 132       break;
 133
 134     case IMAGE_FORMAT_PNG:
 135 #if defined(CONFIG_IMAGES_LIBPNG)
 136       return libpng_read_header(io);
 137 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 138       return libmagick_read_header(io);
 139 #endif
 140       break;
 141
 142     case IMAGE_FORMAT_GIF:
 143 #if defined(CONFIG_IMAGES_LIBUNGIF) || defined(CONFIG_IMAGES_LIBGIF)
 144       return libungif_read_header(io);
 145 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 146       return libmagick_read_header(io);
 147 #endif
 148       break;
 149
 150     case IMAGE_FORMAT_UNDEFINED:
 151 #if defined (CONFIG_IMAGES_LIBMAGICK)
 152       return libmagick_read_header(io);
 153 #endif
 154       break;
 155
 156     default:
 157       ASSERT(0);
 158   }
 159   IMAGE_ERROR(io->context, IMAGE_ERROR_INVALID_FILE_FORMAT, "Image format not supported.");
 160   return 0;
 161 }
 162
 163 struct image *
 164 image_io_read_data(struct image_io *io, int ref)
 165 {
 166   DBG("image_io_read_data()");
 167   ASSERT(io->read_cancel);
 168   io->read_cancel = NULL;
 169   int result;
 170   switch (io->format) {
 171     case IMAGE_FORMAT_JPEG:
 172 #if defined(CONFIG_IMAGES_LIBJPEG)
 173       result = libjpeg_read_data(io);
 174 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 175       result = libmagick_read_data(io);
 176 #else
 177       ASSERT(0);
 178 #endif
 179       break;
 180
 181     case IMAGE_FORMAT_PNG:
 182 #if defined(CONFIG_IMAGES_LIBPNG)
 183       result = libpng_read_data(io);
 184 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 185       result = libmagick_read_data(io);
 186 #else
 187       ASSERT(0);
 188 #endif
 189       break;
 190
 191     case IMAGE_FORMAT_GIF:
 192 #if defined(CONFIG_IMAGES_LIBUNGIF) || defined(CONFIG_IMAGES_LIBGIF)
 193       result = libungif_read_data(io);
 194 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 195       result = libmagick_read_data(io);
 196 #else
 197       ASSERT(0);
 198 #endif
 199       break;
 200
 201     case IMAGE_FORMAT_UNDEFINED:
 202 #if defined(CONFIG_IMAGES_LIBMAGICK)
 203       result = libmagick_read_data(io);
 204 #else
 205       ASSERT(0);
 206 #endif
 207       break;
 208
 209     default:
 210       ASSERT(0);
 211   }
 212   if (result)
 213     {
 214       if (!ref)
 215         io->flags |= IMAGE_IO_NEED_DESTROY;
 216       else
 217         io->flags &= ~IMAGE_IO_NEED_DESTROY;
 218       return io->image;
 219     }
 220   else
 221     return NULL;
 222 }
 223
 224 struct image *
 225 image_io_read(struct image_io *io, int ref)
 226 {
 227   if (!image_io_read_header(io))
 228     return NULL;
 229   return image_io_read_data(io, ref);
 230 }
 231
 232 int
 233 image_io_write(struct image_io *io)
 234 {
 235   DBG("image_io_write()");
 236   image_io_read_cancel(io);
 237   switch (io->format) {
 238     case IMAGE_FORMAT_JPEG:
 239 #if defined(CONFIG_IMAGES_LIBJPEG)
 240       return libjpeg_write(io);
 241 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 242       return libmagick_write(io);
 243 #endif
 244       break;
 245
 246     case IMAGE_FORMAT_PNG:
 247 #if defined(CONFIG_IMAGES_LIBPNG)
 248       return libpng_write(io);
 249 #elif defined(CONFIG_IMAGES_LIBMAGICK)
 250       return libmagick_write(io);
 251 #endif
 252       break;
 253
 254     case IMAGE_FORMAT_GIF:
 255 #if defined(CONFIG_IMAGES_LIBMAGICK)
 256       return libmagick_write(io);
 257 #endif
 258       break;
 259
 260     default:
 261       break;
 262   }
 263   IMAGE_ERROR(io->context, IMAGE_ERROR_INVALID_FILE_FORMAT, "Output format not supported.");
 264   return 0;
 265 }
 266
 267 byte *
 268 image_format_to_extension(enum image_format format)
 269 {
 270   switch (format)
 271     {
 272       case IMAGE_FORMAT_JPEG:
 273         return "jpg";
 274       case IMAGE_FORMAT_PNG:
 275         return "png";
 276       case IMAGE_FORMAT_GIF:
 277         return "gif";
 278       default:
 279         return NULL;
 280     }
 281 }
 282
 283 enum image_format
 284 image_extension_to_format(byte *extension)
 285 {
 286   if (!strcasecmp(extension, "jpg"))
 287     return IMAGE_FORMAT_JPEG;
 288   if (!strcasecmp(extension, "jpeg"))
 289     return IMAGE_FORMAT_JPEG;
 290   if (!strcasecmp(extension, "png"))
 291     return IMAGE_FORMAT_PNG;
 292   if (!strcasecmp(extension, "gif"))
 293     return IMAGE_FORMAT_GIF;
 294   return IMAGE_FORMAT_UNDEFINED;
 295 }
 296
 297 enum image_format
 298 image_file_name_to_format(byte *file_name)
 299 {
 300   byte *extension = strrchr(file_name, '.');
 301   return extension ? image_extension_to_format(extension + 1) : IMAGE_FORMAT_UNDEFINED;
 302 }
 303
 304 struct image *
 305 image_io_read_data_prepare(struct image_io_read_data_internals *rdi, struct image_io *io, uns cols, uns rows, uns flags)
 306 {
 307   DBG("image_io_read_data_prepare()");
 308   if (rdi->need_transformations = io->cols != cols || io->rows != rows ||
 309       ((io->flags ^ flags) & IMAGE_NEW_FLAGS))
 310     return rdi->image = image_new(io->context, cols, rows, flags & IMAGE_IO_IMAGE_FLAGS, NULL);
 311   else
 312     return rdi->image = image_new(io->context, io->cols, io->rows, io->flags & IMAGE_IO_IMAGE_FLAGS, io->pool);
 313 }
 314
 315 int
 316 image_io_read_data_finish(struct image_io_read_data_internals *rdi, struct image_io *io)
 317 {
 318   DBG("image_io_read_data_finish()");
 319   if (rdi->need_transformations)
 320     {
 321       /* Scale the image */
 322       if (io->cols != rdi->image->cols || io->rows != rdi->image->rows)
 323         {
 324           DBG("Scaling image");
 325           uns flags = rdi->image->flags;
 326           if (!(rdi->need_transformations = ((io->flags ^ rdi->image->flags) & (IMAGE_NEW_FLAGS & ~IMAGE_PIXELS_ALIGNED))))
 327             flags = io->flags;
 328           struct image *img = image_new(io->context, io->cols, io->rows, flags, rdi->need_transformations ? NULL : io->pool);
 329           if (unlikely(!img))
 330             {
 331               image_destroy(rdi->image);
 332               return 0;
 333             }
 334           if (unlikely(!image_scale(io->context, img, rdi->image)))
 335             {
 336               image_destroy(rdi->image);
 337               image_destroy(img);
 338               return 0;
 339             }
 340           image_destroy(rdi->image);
 341           rdi->image = img;
 342         }
 343
 344       /* Merge with background */
 345       if ((io->flags ^ rdi->image->flags) & IMAGE_ALPHA)
 346         {
 347           DBG("Aplying background");
 348           uns flags = rdi->image->flags & ~IMAGE_ALPHA;
 349           if (!(rdi->need_transformations = (flags ^ io->flags) & (IMAGE_NEW_FLAGS & ~IMAGE_PIXELS_ALIGNED)))
 350             flags = io->flags;
 351           struct image *img = image_new(io->context, io->cols, io->rows, flags, rdi->need_transformations ? NULL : io->pool);
 352           if (unlikely(!img))
 353             {
 354               image_destroy(rdi->image);
 355               return 0;
 356             }
 357           if (unlikely(!image_apply_background(io->context, img, rdi->image, &io->background_color)))
 358             {
 359               image_destroy(rdi->image);
 360               image_destroy(img);
 361               return 0;
 362             }
 363           image_destroy(rdi->image);
 364           rdi->image = img;
 365         }
 366
 367       // FIXME: support for various color spaces
 368
 369       ASSERT(!rdi->need_transformations);
 370     }
 371
 372   /* Success */
 373   io->image = rdi->image;
 374   return 1;
 375 }
 376
 377 void
 378 image_io_read_data_break(struct image_io_read_data_internals *rdi, struct image_io *io UNUSED)
 379 {
 380   DBG("image_io_read_data_break()");
 381   if (rdi->image)
 382     image_destroy(rdi->image);
 383 }