source/blender/imbuf/intern/tiff.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Contributor(s): Jonathan Merritt.
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 /** \file blender/imbuf/intern/tiff.c
  24  *  \ingroup imbuf
  25  */
  26
  27
  28 /**
  29  * Provides TIFF file loading and saving for Blender, via libtiff.
  30  *
  31  * The task of loading is complicated somewhat by the fact that Blender has
  32  * already loaded the file into a memory buffer.  libtiff is not well
  33  * configured to handle files in memory, so a client wrapper is written to
  34  * surround the memory and turn it into a virtual file.  Currently, reading
  35  * of TIFF files is done using libtiff's RGBAImage support.  This is a
  36  * high-level routine that loads all images as 32-bit RGBA, handling all the
  37  * required conversions between many different TIFF types internally.
  38  *
  39  * Saving supports RGB, RGBA and BW (grayscale) images correctly, with
  40  * 8 bits per channel in all cases.  The "deflate" compression algorithm is
  41  * used to compress images.
  42  */
  43
  44 #include <string.h>
  45
  46 #include "imbuf.h"
  47
  48 #include "BLI_math.h"
  49 #include "BLI_utildefines.h"
  50
  51 #include "BKE_global.h"
  52
  53 #include "IMB_imbuf_types.h"
  54 #include "IMB_imbuf.h"
  55
  56 #include "IMB_filetype.h"
  57
  58 #include "IMB_colormanagement.h"
  59 #include "IMB_colormanagement_intern.h"
  60
  61 #include "tiffio.h"
  62
  63 #ifdef WIN32
  64 #include "utfconv.h"
  65 #endif
  66
  67 /***********************
  68  * Local declarations. *
  69  ***********************/
  70 /* Reading and writing of an in-memory TIFF file. */
  71 static tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n);
  72 static tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n);
  73 static toff_t  imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence);
  74 static int     imb_tiff_CloseProc(thandle_t handle);
  75 static toff_t  imb_tiff_SizeProc(thandle_t handle);
  76 static int     imb_tiff_DummyMapProc(thandle_t fd, tdata_t *pbase, toff_t *psize);
  77 static void    imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size);
  78
  79
  80 /* Structure for in-memory TIFF file. */
  81 typedef struct ImbTIFFMemFile {
  82         unsigned char *mem; /* Location of first byte of TIFF file. */
  83         toff_t offset;      /* Current offset within the file.      */
  84         tsize_t size;       /* Size of the TIFF file.               */
  85 } ImbTIFFMemFile;
  86 #define IMB_TIFF_GET_MEMFILE(x) ((ImbTIFFMemFile *)(x))
  87
  88
  89
  90 /*****************************
  91  * Function implementations. *
  92  *****************************/
  93
  94
  95 static void imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  96 {
  97         (void)fd;
  98         (void)base;
  99         (void)size;
 100 }
 101
 102 static int imb_tiff_DummyMapProc(thandle_t fd, tdata_t *pbase, toff_t *psize)
 103 {
 104         (void)fd;
 105         (void)pbase;
 106         (void)psize;
 107
 108         return (0);
 109 }
 110
 111 /**
 112  * Reads data from an in-memory TIFF file.
 113  *
 114  * \param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile).
 115  * \param data:   Buffer to contain data (treat as (void *)).
 116  * \param n:      Number of bytes to read.
 117  *
 118  * \return: Number of bytes actually read.
 119  *   0 = EOF.
 120  */
 121 static tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n)
 122 {
 123         tsize_t nRemaining, nCopy;
 124         ImbTIFFMemFile *mfile;
 125         void *srcAddr;
 126
 127         /* get the pointer to the in-memory file */
 128         mfile = IMB_TIFF_GET_MEMFILE(handle);
 129         if (!mfile || !mfile->mem) {
 130                 fprintf(stderr, "imb_tiff_ReadProc: !mfile || !mfile->mem!\n");
 131                 return 0;
 132         }
 133
 134         /* find the actual number of bytes to read (copy) */
 135         nCopy = n;
 136         if ((tsize_t)mfile->offset >= mfile->size)
 137                 nRemaining = 0;
 138         else
 139                 nRemaining = mfile->size - mfile->offset;
 140
 141         if (nCopy > nRemaining)
 142                 nCopy = nRemaining;
 143
 144         /* on EOF, return immediately and read (copy) nothing */
 145         if (nCopy <= 0)
 146                 return (0);
 147
 148         /* all set -> do the read (copy) */
 149         srcAddr = (void *)(&(mfile->mem[mfile->offset]));
 150         memcpy((void *)data, srcAddr, nCopy);
 151         mfile->offset += nCopy;     /* advance file ptr by copied bytes */
 152         return nCopy;
 153 }
 154
 155
 156
 157 /**
 158  * Writes data to an in-memory TIFF file.
 159  *
 160  * NOTE: The current Blender implementation should not need this function.  It
 161  *       is simply a stub.
 162  */
 163 static tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n)
 164 {
 165         (void)handle;
 166         (void)data;
 167         (void)n;
 168
 169         printf("imb_tiff_WriteProc: this function should not be called.\n");
 170         return (-1);
 171 }
 172
 173
 174
 175 /**
 176  * Seeks to a new location in an in-memory TIFF file.
 177  *
 178  * \param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile).
 179  * \param ofs:    Offset value (interpreted according to whence below).
 180  * \param whence: This can be one of three values:
 181  *  SEEK_SET - The offset is set to ofs bytes.
 182  *  SEEK_CUR - The offset is set to its current location plus ofs bytes.
 183  *  SEEK_END - (This is unsupported and will return -1, indicating an
 184  *              error).
 185  *
 186  * \return: Resulting offset location within the file, measured in bytes from
 187  *          the beginning of the file.  (-1) indicates an error.
 188  */
 189 static toff_t imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence)
 190 {
 191         ImbTIFFMemFile *mfile;
 192         toff_t new_offset;
 193
 194         /* get the pointer to the in-memory file */
 195         mfile = IMB_TIFF_GET_MEMFILE(handle);
 196         if (!mfile || !mfile->mem) {
 197                 fprintf(stderr, "imb_tiff_SeekProc: !mfile || !mfile->mem!\n");
 198                 return (-1);
 199         }
 200
 201         /* find the location we plan to seek to */
 202         switch (whence) {
 203                 case SEEK_SET:
 204                         new_offset = ofs;
 205                         break;
 206                 case SEEK_CUR:
 207                         new_offset = mfile->offset + ofs;
 208                         break;
 209                 default:
 210                         /* no other types are supported - return an error */
 211                         fprintf(stderr,
 212                                 "imb_tiff_SeekProc: "
 213                                 "Unsupported TIFF SEEK type.\n");
 214                         return (-1);
 215         }
 216
 217         /* set the new location */
 218         mfile->offset = new_offset;
 219         return mfile->offset;
 220 }
 221
 222
 223
 224 /**
 225  * Closes (virtually) an in-memory TIFF file.
 226  *
 227  * NOTE: All this function actually does is sets the data pointer within the
 228  *       TIFF file to NULL.  That should trigger assertion errors if attempts
 229  *       are made to access the file after that point.  However, no such
 230  *       attempts should ever be made (in theory).
 231  *
 232  * \param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile).
 233  *
 234  * \return: 0
 235  */
 236 static int imb_tiff_CloseProc(thandle_t handle)
 237 {
 238         ImbTIFFMemFile *mfile;
 239
 240         /* get the pointer to the in-memory file */
 241         mfile = IMB_TIFF_GET_MEMFILE(handle);
 242         if (!mfile || !mfile->mem) {
 243                 fprintf(stderr, "imb_tiff_CloseProc: !mfile || !mfile->mem!\n");
 244                 return (0);
 245         }
 246
 247         /* virtually close the file */
 248         mfile->mem    = NULL;
 249         mfile->offset = 0;
 250         mfile->size   = 0;
 251
 252         return (0);
 253 }
 254
 255
 256
 257 /**
 258  * Returns the size of an in-memory TIFF file in bytes.
 259  *
 260  * \return: Size of file (in bytes).
 261  */
 262 static toff_t imb_tiff_SizeProc(thandle_t handle)
 263 {
 264         ImbTIFFMemFile *mfile;
 265
 266         /* get the pointer to the in-memory file */
 267         mfile = IMB_TIFF_GET_MEMFILE(handle);
 268         if (!mfile || !mfile->mem) {
 269                 fprintf(stderr, "imb_tiff_SizeProc: !mfile || !mfile->mem!\n");
 270                 return (0);
 271         }
 272
 273         /* return the size */
 274         return (toff_t)(mfile->size);
 275 }
 276
 277 static TIFF *imb_tiff_client_open(ImbTIFFMemFile *memFile, unsigned char *mem, size_t size)
 278 {
 279         /* open the TIFF client layer interface to the in-memory file */
 280         memFile->mem = mem;
 281         memFile->offset = 0;
 282         memFile->size = size;
 283
 284         return TIFFClientOpen("(Blender TIFF Interface Layer)",
 285                               "r", (thandle_t)(memFile),
 286                               imb_tiff_ReadProc, imb_tiff_WriteProc,
 287                               imb_tiff_SeekProc, imb_tiff_CloseProc,
 288                               imb_tiff_SizeProc, imb_tiff_DummyMapProc, imb_tiff_DummyUnmapProc);
 289 }
 290
 291 /**
 292  * Checks whether a given memory buffer contains a TIFF file.
 293  *
 294  * This method uses the format identifiers from:
 295  *     http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-9.html
 296  * The first four bytes of big-endian and little-endian TIFF files
 297  * respectively are (hex):
 298  *  4d 4d 00 2a
 299  *  49 49 2a 00
 300  * Note that TIFF files on *any* platform can be either big- or little-endian;
 301  * it's not platform-specific.
 302  *
 303  * AFAICT, libtiff doesn't provide a method to do this automatically, and
 304  * hence my manual comparison. - Jonathan Merritt (lancelet) 4th Sept 2005.
 305  */
 306 #define IMB_TIFF_NCB 4      /* number of comparison bytes used */
 307 int imb_is_a_tiff(unsigned char *mem)
 308 {
 309         char big_endian[IMB_TIFF_NCB] = { 0x4d, 0x4d, 0x00, 0x2a };
 310         char lil_endian[IMB_TIFF_NCB] = { 0x49, 0x49, 0x2a, 0x00 };
 311
 312         return ((memcmp(big_endian, mem, IMB_TIFF_NCB) == 0) ||
 313                 (memcmp(lil_endian, mem, IMB_TIFF_NCB) == 0));
 314 }
 315
 316 static void scanline_contig_16bit(float *rectf, const unsigned short *sbuf, int scanline_w, int spp)
 317 {
 318         int i;
 319         for (i = 0; i < scanline_w; i++) {
 320                 rectf[i * 4 + 0] = sbuf[i * spp + 0] / 65535.0;
 321                 rectf[i * 4 + 1] = (spp >= 3) ? sbuf[i * spp + 1] / 65535.0 : sbuf[i * spp + 0] / 65535.0;
 322                 rectf[i * 4 + 2] = (spp >= 3) ? sbuf[i * spp + 2] / 65535.0 : sbuf[i * spp + 0] / 65535.0;
 323                 rectf[i * 4 + 3] = (spp == 4) ? (sbuf[i * spp + 3] / 65535.0) : 1.0;
 324         }
 325 }
 326
 327 static void scanline_contig_32bit(float *rectf, const float *fbuf, int scanline_w, int spp)
 328 {
 329         int i;
 330         for (i = 0; i < scanline_w; i++) {
 331                 rectf[i * 4 + 0] = fbuf[i * spp + 0];
 332                 rectf[i * 4 + 1] = (spp >= 3) ? fbuf[i * spp + 1] : fbuf[i * spp + 0];
 333                 rectf[i * 4 + 2] = (spp >= 3) ? fbuf[i * spp + 2] : fbuf[i * spp + 0];
 334                 rectf[i * 4 + 3] = (spp == 4) ? fbuf[i * spp + 3] : 1.0f;
 335         }
 336 }
 337
 338 static void scanline_separate_16bit(float *rectf, const unsigned short *sbuf, int scanline_w, int chan)
 339 {
 340         int i;
 341         for (i = 0; i < scanline_w; i++)
 342                 rectf[i * 4 + chan] = sbuf[i] / 65535.0;
 343 }
 344
 345 static void scanline_separate_32bit(float *rectf, const float *fbuf, int scanline_w, int chan)
 346 {
 347         int i;
 348         for (i = 0; i < scanline_w; i++)
 349                 rectf[i * 4 + chan] = fbuf[i];
 350 }
 351
 352 static void imb_read_tiff_resolution(ImBuf *ibuf, TIFF *image)
 353 {
 354         uint16 unit;
 355         float xres;
 356         float yres;
 357
 358         TIFFGetFieldDefaulted(image, TIFFTAG_RESOLUTIONUNIT, &unit);
 359         TIFFGetFieldDefaulted(image, TIFFTAG_XRESOLUTION, &xres);
 360         TIFFGetFieldDefaulted(image, TIFFTAG_YRESOLUTION, &yres);
 361
 362         if (unit == RESUNIT_CENTIMETER) {
 363                 ibuf->ppm[0] = (double)xres * 100.0;
 364                 ibuf->ppm[1] = (double)yres * 100.0;
 365         }
 366         else {
 367                 ibuf->ppm[0] = (double)xres / 0.0254;
 368                 ibuf->ppm[1] = (double)yres / 0.0254;
 369         }
 370 }
 371
 372 /*
 373  * Use the libTIFF scanline API to read a TIFF image.
 374  * This method is most flexible and can handle multiple different bit depths
 375  * and RGB channel orderings.
 376  */
 377 static int imb_read_tiff_pixels(ImBuf *ibuf, TIFF *image)
 378 {
 379         ImBuf *tmpibuf;
 380         int success = 0;
 381         short bitspersample, spp, config;
 382         size_t scanline;
 383         int ib_flag = 0, row, chan;
 384         float *fbuf = NULL;
 385         unsigned short *sbuf = NULL;
 386
 387         TIFFGetField(image, TIFFTAG_BITSPERSAMPLE, &bitspersample);
 388         TIFFGetField(image, TIFFTAG_SAMPLESPERPIXEL, &spp);     /* number of 'channels' */
 389         TIFFGetField(image, TIFFTAG_PLANARCONFIG, &config);
 390
 391         if (spp == 4) {
 392                 /* HACK: this is really tricky hack, which is only needed to force libtiff
 393                  *       do not touch RGB channels when there's alpha channel present
 394                  *       The thing is: libtiff will premul RGB if alpha mode is set to
 395                  *       unassociated, which really conflicts with blender's assumptions
 396                  *
 397                  *       Alternative would be to unpremul after load, but it'll be really
 398                  *       lossy and unwanted behavior
 399                  *
 400                  *       So let's keep this thing here for until proper solution is found (sergey)
 401                  */
 402
 403                 unsigned short extraSampleTypes[1];
 404                 extraSampleTypes[0] = EXTRASAMPLE_ASSOCALPHA;
 405                 TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1, extraSampleTypes);
 406         }
 407
 408         imb_read_tiff_resolution(ibuf, image);
 409
 410         scanline = TIFFScanlineSize(image);
 411
 412         if (bitspersample == 32) {
 413                 ib_flag = IB_rectfloat;
 414                 fbuf = (float *)_TIFFmalloc(scanline);
 415         }
 416         else if (bitspersample == 16) {
 417                 ib_flag = IB_rectfloat;
 418                 sbuf = (unsigned short *)_TIFFmalloc(scanline);
 419         }
 420         else {
 421                 ib_flag = IB_rect;
 422         }
 423
 424         tmpibuf = IMB_allocImBuf(ibuf->x, ibuf->y, ibuf->planes, ib_flag);
 425
 426         /* simple RGBA image */
 427         if (!(bitspersample == 32 || bitspersample == 16)) {
 428                 success |= TIFFReadRGBAImage(image, ibuf->x, ibuf->y, tmpibuf->rect, 0);
 429         }
 430         /* contiguous channels: RGBRGBRGB */
 431         else if (config == PLANARCONFIG_CONTIG) {
 432                 for (row = 0; row < ibuf->y; row++) {
 433                         int ib_offset = ibuf->x * ibuf->y * 4 - ibuf->x * 4 * (row + 1);
 434
 435                         if (bitspersample == 32) {
 436                                 success |= TIFFReadScanline(image, fbuf, row, 0);
 437                                 scanline_contig_32bit(tmpibuf->rect_float + ib_offset, fbuf, ibuf->x, spp);
 438
 439                         }
 440                         else if (bitspersample == 16) {
 441                                 success |= TIFFReadScanline(image, sbuf, row, 0);
 442                                 scanline_contig_16bit(tmpibuf->rect_float + ib_offset, sbuf, ibuf->x, spp);
 443                         }
 444                 }
 445                 /* separate channels: RRRGGGBBB */
 446         }
 447         else if (config == PLANARCONFIG_SEPARATE) {
 448
 449                 /* imbufs always have 4 channels of data, so we iterate over all of them
 450                  * but only fill in from the TIFF scanline where necessary. */
 451                 for (chan = 0; chan < 4; chan++) {
 452                         for (row = 0; row < ibuf->y; row++) {
 453                                 int ib_offset = ibuf->x * ibuf->y * 4 - ibuf->x * 4 * (row + 1);
 454
 455                                 if (bitspersample == 32) {
 456                                         if (chan == 3 && spp == 3) /* fill alpha if only RGB TIFF */
 457                                                 fill_vn_fl(fbuf, ibuf->x, 1.0f);
 458                                         else if (chan >= spp) /* for grayscale, duplicate first channel into G and B */
 459                                                 success |= TIFFReadScanline(image, fbuf, row, 0);
 460                                         else
 461                                                 success |= TIFFReadScanline(image, fbuf, row, chan);
 462                                         scanline_separate_32bit(tmpibuf->rect_float + ib_offset, fbuf, ibuf->x, chan);
 463
 464                                 }
 465                                 else if (bitspersample == 16) {
 466                                         if (chan == 3 && spp == 3) /* fill alpha if only RGB TIFF */
 467                                                 fill_vn_ushort(sbuf, ibuf->x, 65535);
 468                                         else if (chan >= spp) /* for grayscale, duplicate first channel into G and B */
 469                                                 success |= TIFFReadScanline(image, fbuf, row, 0);
 470                                         else
 471                                                 success |= TIFFReadScanline(image, sbuf, row, chan);
 472                                         scanline_separate_16bit(tmpibuf->rect_float + ib_offset, sbuf, ibuf->x, chan);
 473
 474                                 }
 475                         }
 476                 }
 477         }
 478
 479         if (bitspersample == 32)
 480                 _TIFFfree(fbuf);
 481         else if (bitspersample == 16)
 482                 _TIFFfree(sbuf);
 483
 484         if (success) {
 485                 /* Code seems to be not needed for 16 bits tif, on PPC G5 OSX (ton) */
 486                 if (bitspersample < 16)
 487                         if (ENDIAN_ORDER == B_ENDIAN)
 488                                 IMB_convert_rgba_to_abgr(tmpibuf);
 489
 490                 /* assign rect last */
 491                 if (tmpibuf->rect_float)
 492                         ibuf->rect_float = tmpibuf->rect_float;
 493                 else
 494                         ibuf->rect = tmpibuf->rect;
 495                 ibuf->mall |= ib_flag;
 496                 ibuf->flags |= ib_flag;
 497
 498                 tmpibuf->mall &= ~ib_flag;
 499         }
 500
 501         IMB_freeImBuf(tmpibuf);
 502
 503         return success;
 504 }
 505
 506 void imb_inittiff(void)
 507 {
 508         if (!(G.debug & G_DEBUG))
 509                 TIFFSetErrorHandler(NULL);
 510 }
 511
 512 /**
 513  * Loads a TIFF file.
 514  *
 515  *
 516  * \param mem:   Memory containing the TIFF file.
 517  * \param size:  Size of the mem buffer.
 518  * \param flags: If flags has IB_test set then the file is not actually loaded,
 519  *                but all other operations take place.
 520  *
 521  * \return: A newly allocated ImBuf structure if successful, otherwise NULL.
 522  */
 523 ImBuf *imb_loadtiff(unsigned char *mem, size_t size, int flags, char colorspace[IM_MAX_SPACE])
 524 {
 525         TIFF *image = NULL;
 526         ImBuf *ibuf = NULL, *hbuf;
 527         ImbTIFFMemFile memFile;
 528         uint32 width, height;
 529         char *format = NULL;
 530         int level;
 531         short spp;
 532         int ib_depth;
 533         int found;
 534
 535         /* check whether or not we have a TIFF file */
 536         if (size < IMB_TIFF_NCB) {
 537                 fprintf(stderr, "imb_loadtiff: size < IMB_TIFF_NCB\n");
 538                 return NULL;
 539         }
 540         if (imb_is_a_tiff(mem) == 0)
 541                 return NULL;
 542
 543         /* both 8 and 16 bit PNGs are default to standard byte colorspace */
 544         colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);
 545
 546         image = imb_tiff_client_open(&memFile, mem, size);
 547
 548         if (image == NULL) {
 549                 printf("imb_loadtiff: could not open TIFF IO layer.\n");
 550                 return NULL;
 551         }
 552
 553         /* allocate the image buffer */
 554         TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
 555         TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
 556         TIFFGetField(image, TIFFTAG_SAMPLESPERPIXEL, &spp);
 557
 558         ib_depth = (spp == 3) ? 24 : 32;
 559
 560         ibuf = IMB_allocImBuf(width, height, ib_depth, 0);
 561         if (ibuf) {
 562                 ibuf->ftype = TIF;
 563         }
 564         else {
 565                 fprintf(stderr,
 566                         "imb_loadtiff: could not allocate memory for TIFF "
 567                         "image.\n");
 568                 TIFFClose(image);
 569                 return NULL;
 570         }
 571
 572         /* get alpha mode from file header */
 573         if (flags & IB_alphamode_detect) {
 574                 if (spp == 4) {
 575                         unsigned short extra, *extraSampleTypes;
 576
 577                         found = TIFFGetField(image, TIFFTAG_EXTRASAMPLES, &extra, &extraSampleTypes);
 578
 579                         if (found && (extraSampleTypes[0] == EXTRASAMPLE_ASSOCALPHA)) {
 580                                 ibuf->flags |= IB_alphamode_premul;
 581                         }
 582                 }
 583         }
 584
 585         /* if testing, we're done */
 586         if (flags & IB_test) {
 587                 TIFFClose(image);
 588                 return ibuf;
 589         }
 590
 591         /* detect if we are reading a tiled/mipmapped texture, in that case
 592          * we don't read pixels but leave it to the cache to load tiles */
 593         if (flags & IB_tilecache) {
 594                 format = NULL;
 595                 TIFFGetField(image, TIFFTAG_PIXAR_TEXTUREFORMAT, &format);
 596
 597                 if (format && STREQ(format, "Plain Texture") && TIFFIsTiled(image)) {
 598                         int numlevel = TIFFNumberOfDirectories(image);
 599
 600                         /* create empty mipmap levels in advance */
 601                         for (level = 0; level < numlevel; level++) {
 602                                 if (!TIFFSetDirectory(image, level))
 603                                         break;
 604
 605                                 if (level > 0) {
 606                                         width = (width > 1) ? width / 2 : 1;
 607                                         height = (height > 1) ? height / 2 : 1;
 608
 609                                         hbuf = IMB_allocImBuf(width, height, 32, 0);
 610                                         hbuf->miplevel = level;
 611                                         hbuf->ftype = ibuf->ftype;
 612                                         ibuf->mipmap[level - 1] = hbuf;
 613                                 }
 614                                 else
 615                                         hbuf = ibuf;
 616
 617                                 hbuf->flags |= IB_tilecache;
 618
 619                                 TIFFGetField(image, TIFFTAG_TILEWIDTH, &hbuf->tilex);
 620                                 TIFFGetField(image, TIFFTAG_TILELENGTH, &hbuf->tiley);
 621
 622                                 hbuf->xtiles = ceil(hbuf->x / (float)hbuf->tilex);
 623                                 hbuf->ytiles = ceil(hbuf->y / (float)hbuf->tiley);
 624
 625                                 imb_addtilesImBuf(hbuf);
 626
 627                                 ibuf->miptot++;
 628                         }
 629                 }
 630         }
 631
 632         /* read pixels */
 633         if (!(ibuf->flags & IB_tilecache) && !imb_read_tiff_pixels(ibuf, image)) {
 634                 fprintf(stderr, "imb_loadtiff: Failed to read tiff image.\n");
 635                 TIFFClose(image);
 636                 return NULL;
 637         }
 638
 639         /* close the client layer interface to the in-memory file */
 640         TIFFClose(image);
 641
 642         /* return successfully */
 643         return ibuf;
 644 }
 645
 646 void imb_loadtiletiff(ImBuf *ibuf, unsigned char *mem, size_t size, int tx, int ty, unsigned int *rect)
 647 {
 648         TIFF *image = NULL;
 649         uint32 width, height;
 650         ImbTIFFMemFile memFile;
 651
 652         image = imb_tiff_client_open(&memFile, mem, size);
 653
 654         if (image == NULL) {
 655                 printf("imb_loadtiff: could not open TIFF IO layer for loading mipmap level.\n");
 656                 return;
 657         }
 658
 659         if (TIFFSetDirectory(image, ibuf->miplevel)) { /* allocate the image buffer */
 660                 TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
 661                 TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
 662
 663                 if (width == ibuf->x && height == ibuf->y) {
 664                         if (rect) {
 665                                 /* tiff pixels are bottom to top, tiles are top to bottom */
 666                                 if (TIFFReadRGBATile(image, tx * ibuf->tilex, (ibuf->ytiles - 1 - ty) * ibuf->tiley, rect) == 1) {
 667                                         if (ibuf->tiley > ibuf->y)
 668                                                 memmove(rect, rect + ibuf->tilex * (ibuf->tiley - ibuf->y), sizeof(int) * ibuf->tilex * ibuf->y);
 669                                 }
 670                                 else
 671                                         printf("imb_loadtiff: failed to read tiff tile at mipmap level %d\n", ibuf->miplevel);
 672                         }
 673                 }
 674                 else
 675                         printf("imb_loadtiff: mipmap level %d has unexpected size %ux%u instead of %dx%d\n", ibuf->miplevel, width, height, ibuf->x, ibuf->y);
 676         }
 677         else
 678                 printf("imb_loadtiff: could not find mipmap level %d\n", ibuf->miplevel);
 679
 680         /* close the client layer interface to the in-memory file */
 681         TIFFClose(image);
 682 }
 683
 684 /**
 685  * Saves a TIFF file.
 686  *
 687  * ImBuf structures with 1, 3 or 4 bytes per pixel (GRAY, RGB, RGBA
 688  * respectively) are accepted, and interpreted correctly.  Note that the TIFF
 689  * convention is to use pre-multiplied alpha, which can be achieved within
 690  * Blender by setting "Premul" alpha handling.  Other alpha conventions are
 691  * not strictly correct, but are permitted anyhow.
 692  *
 693  * \param ibuf:  Image buffer.
 694  * \param name:  Name of the TIFF file to create.
 695  * \param flags: Currently largely ignored.
 696  *
 697  * \return: 1 if the function is successful, 0 on failure.
 698  */
 699
 700 int imb_savetiff(ImBuf *ibuf, const char *name, int flags)
 701 {
 702         TIFF *image = NULL;
 703         uint16 samplesperpixel, bitspersample;
 704         size_t npixels;
 705         unsigned char *pixels = NULL;
 706         unsigned char *from = NULL, *to = NULL;
 707         unsigned short *pixels16 = NULL, *to16 = NULL;
 708         float *fromf = NULL;
 709         float xres, yres;
 710         int x, y, from_i, to_i, i;
 711
 712         /* check for a valid number of bytes per pixel.  Like the PNG writer,
 713          * the TIFF writer supports 1, 3 or 4 bytes per pixel, corresponding
 714          * to gray, RGB, RGBA respectively. */
 715         samplesperpixel = (uint16)((ibuf->planes + 7) >> 3);
 716         if ((samplesperpixel > 4) || (samplesperpixel == 2)) {
 717                 fprintf(stderr,
 718                         "imb_savetiff: unsupported number of bytes per "
 719                         "pixel: %d\n", samplesperpixel);
 720                 return (0);
 721         }
 722
 723         if ((ibuf->ftype & TIF_16BIT) && ibuf->rect_float)
 724                 bitspersample = 16;
 725         else
 726                 bitspersample = 8;
 727
 728         /* open TIFF file for writing */
 729         if (flags & IB_mem) {
 730                 /* bork at the creation of a TIFF in memory */
 731                 fprintf(stderr,
 732                         "imb_savetiff: creation of in-memory TIFF files is "
 733                         "not yet supported.\n");
 734                 return (0);
 735         }
 736         else {
 737                 /* create image as a file */
 738 #ifdef WIN32
 739                 wchar_t *wname = alloc_utf16_from_8(name, 0);
 740                 image = TIFFOpenW(wname, "w");
 741                 free(wname);
 742 #else
 743                 image = TIFFOpen(name, "w");
 744 #endif
 745         }
 746         if (image == NULL) {
 747                 fprintf(stderr,
 748                         "imb_savetiff: could not open TIFF for writing.\n");
 749                 return (0);
 750         }
 751
 752         /* allocate array for pixel data */
 753         npixels = ibuf->x * ibuf->y;
 754         if (bitspersample == 16)
 755                 pixels16 = (unsigned short *)_TIFFmalloc(npixels *
 756                                                          samplesperpixel * sizeof(unsigned short));
 757         else
 758                 pixels = (unsigned char *)_TIFFmalloc(npixels *
 759                                                       samplesperpixel * sizeof(unsigned char));
 760
 761         if (pixels == NULL && pixels16 == NULL) {
 762                 fprintf(stderr,
 763                         "imb_savetiff: could not allocate pixels array.\n");
 764                 TIFFClose(image);
 765                 return (0);
 766         }
 767
 768         /* setup pointers */
 769         if (bitspersample == 16) {
 770                 fromf = ibuf->rect_float;
 771                 to16   = pixels16;
 772         }
 773         else {
 774                 from = (unsigned char *)ibuf->rect;
 775                 to   = pixels;
 776         }
 777
 778         /* setup samples per pixel */
 779         TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, bitspersample);
 780         TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
 781
 782         if (samplesperpixel == 4) {
 783                 unsigned short extraSampleTypes[1];
 784
 785                 if (bitspersample == 16)
 786                         extraSampleTypes[0] = EXTRASAMPLE_ASSOCALPHA;
 787                 else
 788                         extraSampleTypes[0] = EXTRASAMPLE_UNASSALPHA;
 789
 790                 /* RGBA images */
 791                 TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1,
 792                              extraSampleTypes);
 793                 TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
 794                              PHOTOMETRIC_RGB);
 795         }
 796         else if (samplesperpixel == 3) {
 797                 /* RGB images */
 798                 TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
 799                              PHOTOMETRIC_RGB);
 800         }
 801         else if (samplesperpixel == 1) {
 802                 /* grayscale images, 1 channel */
 803                 TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
 804                              PHOTOMETRIC_MINISBLACK);
 805         }
 806
 807         /* copy pixel data.  While copying, we flip the image vertically. */
 808         for (x = 0; x < ibuf->x; x++) {
 809                 for (y = 0; y < ibuf->y; y++) {
 810                         from_i = 4 * (y * ibuf->x + x);
 811                         to_i   = samplesperpixel * ((ibuf->y - y - 1) * ibuf->x + x);
 812
 813                         if (pixels16) {
 814                                 /* convert from float source */
 815                                 float rgb[4];
 816
 817                                 if (ibuf->float_colorspace) {
 818                                         /* float buffer was managed already, no need in color space conversion */
 819                                         copy_v3_v3(rgb, &fromf[from_i]);
 820                                 }
 821                                 else {
 822                                         /* standard linear-to-srgb conversion if float buffer wasn't managed */
 823                                         linearrgb_to_srgb_v3_v3(rgb, &fromf[from_i]);
 824                                 }
 825
 826                                 rgb[3] = fromf[from_i + 3];
 827
 828                                 for (i = 0; i < samplesperpixel; i++, to_i++)
 829                                         to16[to_i] = FTOUSHORT(rgb[i]);
 830                         }
 831                         else {
 832                                 for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
 833                                         to[to_i] = from[from_i];
 834                         }
 835                 }
 836         }
 837
 838         /* write the actual TIFF file */
 839         TIFFSetField(image, TIFFTAG_IMAGEWIDTH,      ibuf->x);
 840         TIFFSetField(image, TIFFTAG_IMAGELENGTH,     ibuf->y);
 841         TIFFSetField(image, TIFFTAG_ROWSPERSTRIP,    ibuf->y);
 842         TIFFSetField(image, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
 843         TIFFSetField(image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
 844         TIFFSetField(image, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 845
 846
 847         if (ibuf->ppm[0] > 0.0 && ibuf->ppm[1] > 0.0) {
 848                 xres = (float)(ibuf->ppm[0] * 0.0254);
 849                 yres = (float)(ibuf->ppm[1] * 0.0254);
 850         }
 851         else {
 852                 xres = yres = IMB_DPI_DEFAULT;
 853         }
 854
 855         TIFFSetField(image, TIFFTAG_XRESOLUTION,     xres);
 856         TIFFSetField(image, TIFFTAG_YRESOLUTION,     yres);
 857         TIFFSetField(image, TIFFTAG_RESOLUTIONUNIT,  RESUNIT_INCH);
 858         if (TIFFWriteEncodedStrip(image, 0,
 859                                   (bitspersample == 16) ? (unsigned char *)pixels16 : pixels,
 860                                   (size_t)ibuf->x * ibuf->y * samplesperpixel * bitspersample / 8) == -1)
 861         {
 862                 fprintf(stderr,
 863                         "imb_savetiff: Could not write encoded TIFF.\n");
 864                 TIFFClose(image);
 865                 if (pixels) _TIFFfree(pixels);
 866                 if (pixels16) _TIFFfree(pixels16);
 867                 return (1);
 868         }
 869
 870         /* close the TIFF file */
 871         TIFFClose(image);
 872         if (pixels) _TIFFfree(pixels);
 873         if (pixels16) _TIFFfree(pixels16);
 874         return (1);
 875 }