src/image_load_tiff.c

   1 /*
   2  * Geeqie
   3  * (C) 2004 John Ellis
   4  * Copyright (C) 2008 - 2011 The Geeqie Team
   5  *
   6  * Author: Vladimir Nadvornik
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13 /* based on code from GdkPixbuf library - TIFF image loader
  14  *
  15  * Copyright (C) 1999 Mark Crichton
  16  * Copyright (C) 1999 The Free Software Foundation
  17  *
  18  * Authors: Mark Crichton <crichton@gimp.org>
  19  *          Federico Mena-Quintero <federico@gimp.org>
  20  *          Jonathan Blandford <jrb@redhat.com>
  21  *          S�ren Sandmann <sandmann@daimi.au.dk>
  22  *
  23  * This library is free software; you can redistribute it and/or
  24  * modify it under the terms of the GNU Lesser General Public
  25  * License as published by the Free Software Foundation; either
  26  * version 2 of the License, or (at your option) any later version.
  27  *
  28  * This library is distributed in the hope that it will be useful,
  29  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  31  * Lesser General Public License for more details.
  32  *
  33  * You should have received a copy of the GNU Lesser General Public
  34  * License along with this library; if not, write to the
  35  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  36  * Boston, MA 02111-1307, USA.
  37  */
  38
  39 #include "main.h"
  40
  41 #include "image-load.h"
  42 #include "image_load_tiff.h"
  43
  44 #ifdef HAVE_TIFF
  45
  46 #include <tiffio.h>
  47
  48 typedef struct _ImageLoaderTiff ImageLoaderTiff;
  49 struct _ImageLoaderTiff {
  50         ImageLoaderBackendCbAreaUpdated area_updated_cb;
  51         ImageLoaderBackendCbSize size_cb;
  52         ImageLoaderBackendCbAreaPrepared area_prepared_cb;
  53
  54         gpointer data;
  55
  56         GdkPixbuf *pixbuf;
  57         guint requested_width;
  58         guint requested_height;
  59
  60         gboolean abort;
  61
  62         const guchar *buffer;
  63         toff_t used;
  64         toff_t pos;
  65 };
  66
  67 static void free_buffer (guchar *pixels, gpointer data)
  68 {
  69         g_free (pixels);
  70 }
  71
  72 static tsize_t
  73 tiff_load_read (thandle_t handle, tdata_t buf, tsize_t size)
  74 {
  75         ImageLoaderTiff *context = (ImageLoaderTiff *)handle;
  76
  77         if (context->pos + size > context->used)
  78                 return 0;
  79
  80         memcpy (buf, context->buffer + context->pos, size);
  81         context->pos += size;
  82         return size;
  83 }
  84
  85 static tsize_t
  86 tiff_load_write (thandle_t handle, tdata_t buf, tsize_t size)
  87 {
  88         return -1;
  89 }
  90
  91 static toff_t
  92 tiff_load_seek (thandle_t handle, toff_t offset, int whence)
  93 {
  94         ImageLoaderTiff *context = (ImageLoaderTiff *)handle;
  95
  96         switch (whence)
  97                 {
  98                 case SEEK_SET:
  99                         if (offset > context->used)
 100                                 return -1;
 101                         context->pos = offset;
 102                         break;
 103                 case SEEK_CUR:
 104                         if (offset + context->pos >= context->used)
 105                                 return -1;
 106                         context->pos += offset;
 107                         break;
 108                 case SEEK_END:
 109                         if (offset + context->used > context->used)
 110                                 return -1;
 111                         context->pos = context->used + offset;
 112                         break;
 113                 default:
 114                         return -1;
 115                 }
 116
 117         return context->pos;
 118 }
 119
 120 static int
 121 tiff_load_close (thandle_t context)
 122 {
 123         return 0;
 124 }
 125
 126 static toff_t
 127 tiff_load_size (thandle_t handle)
 128 {
 129         ImageLoaderTiff *context = (ImageLoaderTiff *)handle;
 130         return context->used;
 131 }
 132
 133 static int
 134 tiff_load_map_file (thandle_t handle, tdata_t *buf, toff_t *size)
 135 {
 136         ImageLoaderTiff *context = (ImageLoaderTiff *)handle;
 137
 138         *buf = (tdata_t *) context->buffer;
 139         *size = context->used;
 140
 141         return 0;
 142 }
 143
 144 static void
 145 tiff_load_unmap_file (thandle_t handle, tdata_t data, toff_t offset)
 146 {
 147 }
 148
 149 static gboolean image_loader_tiff_load (gpointer loader, const guchar *buf, gsize count, GError **error)
 150 {
 151         ImageLoaderTiff *lt = (ImageLoaderTiff *) loader;
 152
 153         TIFF *tiff;
 154         guchar *pixels = NULL;
 155         gint width, height, rowstride, bytes;
 156         uint16 orientation = 0;
 157         uint16 transform = 0;
 158         uint32 rowsperstrip;
 159
 160         lt->buffer = buf;
 161         lt->used = count;
 162         lt->pos = 0;
 163
 164         TIFFSetWarningHandler(NULL);
 165
 166         tiff = TIFFClientOpen ( "libtiff-geeqie", "r", lt,
 167                                                         tiff_load_read, tiff_load_write,
 168                                                         tiff_load_seek, tiff_load_close,
 169                                                         tiff_load_size,
 170                                                         tiff_load_map_file, tiff_load_unmap_file);
 171         if (!tiff)
 172                 {
 173                 DEBUG_1("Failed to open TIFF image");
 174                 return FALSE;
 175                 }
 176
 177
 178         if (!TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width))
 179                 {
 180                 DEBUG_1("Could not get image width (bad TIFF file)");
 181                 TIFFClose(tiff);
 182                 return FALSE;
 183                 }
 184
 185         if (!TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height))
 186                 {
 187                 DEBUG_1("Could not get image height (bad TIFF file)");
 188                 TIFFClose(tiff);
 189                 return FALSE;
 190                 }
 191
 192         if (width <= 0 || height <= 0)
 193                 {
 194                 DEBUG_1("Width or height of TIFF image is zero");
 195                 TIFFClose(tiff);
 196                 return FALSE;
 197                 }
 198
 199         rowstride = width * 4;
 200         if (rowstride / 4 != width)
 201                 { /* overflow */
 202                 DEBUG_1("Dimensions of TIFF image too large");
 203                 TIFFClose(tiff);
 204                 return FALSE;
 205                 }
 206
 207         bytes = height * rowstride;
 208         if (bytes / rowstride != height)
 209                 { /* overflow */
 210                 DEBUG_1("Dimensions of TIFF image too large");
 211                 TIFFClose(tiff);
 212                 return FALSE;
 213                 }
 214
 215         lt->requested_width = width;
 216         lt->requested_height = height;
 217         lt->size_cb(loader, lt->requested_width, lt->requested_height, lt->data);
 218
 219         pixels = g_try_malloc (bytes);
 220
 221         if (!pixels)
 222                 {
 223                 DEBUG_1("Insufficient memory to open TIFF file");
 224                 TIFFClose(tiff);
 225                 return FALSE;
 226                 }
 227
 228         lt->pixbuf = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8,
 229                                                                                    width, height, rowstride,
 230                                                                                    free_buffer, NULL);
 231         if (!lt->pixbuf)
 232                 {
 233                 g_free (pixels);
 234                 DEBUG_1("Insufficient memory to open TIFF file");
 235                 TIFFClose(tiff);
 236                 return FALSE;
 237                 }
 238
 239         /* Set the "orientation" key associated with this image. libtiff
 240            orientation handling is odd, so further processing is required
 241            by higher-level functions based on this tag. If the embedded
 242            orientation tag is 1-4, libtiff flips/mirrors the image as
 243            required, and no client processing is required - so we report
 244            no orientation. Orientations 5-8 require rotations which would
 245            swap the width and height of the image. libtiff does not do this.
 246            Instead it interprets orientations 5-8 the same as 1-4.
 247            See http://bugzilla.remotesensing.org/show_bug.cgi?id=1548.
 248            To correct for this, the client must apply the transform normally
 249            used for orientation 5 to both orientations 5 and 7, and apply
 250            the transform normally used for orientation 7 for both
 251            orientations 6 and 8. Then everythings works out OK! */
 252
 253         TIFFGetField (tiff, TIFFTAG_ORIENTATION, &orientation);
 254
 255         switch (orientation) {
 256                 case 5:
 257                 case 7:
 258                         transform = 5;
 259                         break;
 260                 case 6:
 261                 case 8:
 262                         transform = 7;
 263                         break;
 264                 default:
 265                         transform = 0;
 266                         break;
 267         }
 268
 269         lt->area_prepared_cb(loader, lt->data);
 270
 271         if (TIFFGetField(tiff, TIFFTAG_ROWSPERSTRIP, &rowsperstrip))
 272                 {
 273                 /* read by strip */
 274                 int row;
 275                 guchar *wrk_line = (guchar *)g_malloc(width * sizeof (uint32));
 276
 277                 for (row = 0; row < height; row += rowsperstrip)
 278                         {
 279                         int rows_to_write, i_row;
 280
 281                         if (lt->abort) {
 282                                 break;
 283                         }
 284
 285                         /* Read the strip into an RGBA array */
 286                         if (!TIFFReadRGBAStrip(tiff, row, (uint32 *)(pixels + row * rowstride))) {
 287                                 break;
 288                         }
 289
 290                         /*
 291                          * Figure out the number of scanlines actually in this strip.
 292                         */
 293                         if (row + (int)rowsperstrip > height)
 294                                 rows_to_write = height - row;
 295                         else
 296                                 rows_to_write = rowsperstrip;
 297
 298                         /*
 299                          * For some reason the TIFFReadRGBAStrip() function chooses the
 300                          * lower left corner as the origin.  Vertically mirror scanlines.
 301                          */
 302                         for (i_row = 0; i_row < rows_to_write / 2; i_row++)
 303                                 {
 304                                 guchar *top_line, *bottom_line;
 305
 306                                 top_line = pixels + (row + i_row) * rowstride;
 307                                 bottom_line = pixels + (row + rows_to_write - i_row - 1) * rowstride;
 308
 309                                 memcpy(wrk_line, top_line, 4*width);
 310                                 memcpy(top_line, bottom_line, 4*width);
 311                                 memcpy(bottom_line, wrk_line, 4*width);
 312                                 }
 313                         lt->area_updated_cb(loader, 0, row, width, rows_to_write, lt->data);
 314                         }
 315                 g_free(wrk_line);
 316                 }
 317         else
 318                 {
 319                 /* fallback, tiled tiff */
 320                 if (!TIFFReadRGBAImageOriented (tiff, width, height, (uint32 *)pixels, ORIENTATION_TOPLEFT, 1))
 321                         {
 322                         TIFFClose(tiff);
 323                         return FALSE;
 324                         }
 325
 326 #if G_BYTE_ORDER == G_BIG_ENDIAN
 327                 /* Turns out that the packing used by TIFFRGBAImage depends on
 328                  * the host byte order...
 329                  */
 330                 while (pixels < lt->pixbuf->pixels + bytes)
 331                         {
 332                         uint32 pixel = *(uint32 *)pixels;
 333                         int r = TIFFGetR(pixel);
 334                         int g = TIFFGetG(pixel);
 335                         int b = TIFFGetB(pixel);
 336                         int a = TIFFGetA(pixel);
 337                         *pixels++ = r;
 338                         *pixels++ = g;
 339                         *pixels++ = b;
 340                         *pixels++ = a;
 341                         }
 342 #endif
 343
 344                 lt->area_updated_cb(loader, 0, 0, width, height, lt->data);
 345                 }
 346         TIFFClose(tiff);
 347
 348         return TRUE;
 349 }
 350
 351
 352 static gpointer image_loader_tiff_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data)
 353 {
 354         ImageLoaderTiff *loader = g_new0(ImageLoaderTiff, 1);
 355
 356         loader->area_updated_cb = area_updated_cb;
 357         loader->size_cb = size_cb;
 358         loader->area_prepared_cb = area_prepared_cb;
 359         loader->data = data;
 360         return (gpointer) loader;
 361 }
 362
 363
 364 static void image_loader_tiff_set_size(gpointer loader, int width, int height)
 365 {
 366         ImageLoaderTiff *lt = (ImageLoaderTiff *) loader;
 367         lt->requested_width = width;
 368         lt->requested_height = height;
 369 }
 370
 371 static GdkPixbuf* image_loader_tiff_get_pixbuf(gpointer loader)
 372 {
 373         ImageLoaderTiff *lt = (ImageLoaderTiff *) loader;
 374         return lt->pixbuf;
 375 }
 376
 377 static gchar* image_loader_tiff_get_format_name(gpointer loader)
 378 {
 379         return g_strdup("tiff");
 380 }
 381 static gchar** image_loader_tiff_get_format_mime_types(gpointer loader)
 382 {
 383         static gchar *mime[] = {"image/tiff", NULL};
 384         return g_strdupv(mime);
 385 }
 386
 387 static gboolean image_loader_tiff_close(gpointer loader, GError **error)
 388 {
 389         return TRUE;
 390 }
 391
 392 static void image_loader_tiff_abort(gpointer loader)
 393 {
 394         ImageLoaderTiff *lt = (ImageLoaderTiff *) loader;
 395         lt->abort = TRUE;
 396 }
 397
 398 static void image_loader_tiff_free(gpointer loader)
 399 {
 400         ImageLoaderTiff *lt = (ImageLoaderTiff *) loader;
 401         if (lt->pixbuf) g_object_unref(lt->pixbuf);
 402         g_free(lt);
 403 }
 404
 405
 406 void image_loader_backend_set_tiff(ImageLoaderBackend *funcs)
 407 {
 408         funcs->loader_new = image_loader_tiff_new;
 409         funcs->set_size = image_loader_tiff_set_size;
 410         funcs->load = image_loader_tiff_load;
 411         funcs->write = NULL;
 412         funcs->get_pixbuf = image_loader_tiff_get_pixbuf;
 413         funcs->close = image_loader_tiff_close;
 414         funcs->abort = image_loader_tiff_abort;
 415         funcs->free = image_loader_tiff_free;
 416
 417         funcs->get_format_name = image_loader_tiff_get_format_name;
 418         funcs->get_format_mime_types = image_loader_tiff_get_format_mime_types;
 419 }
 420
 421
 422
 423 #endif
 424 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */