Fix buffer overflows in TIFF, PNG, IRIS, DPX, HDR and AVI loading.
[blender.git] / 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         const 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, const 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(const 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 = NULL;
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                 if (!fbuf) {
416                         goto cleanup;
417                 }
418         }
419         else if (bitspersample == 16) {
420                 ib_flag = IB_rectfloat;
421                 sbuf = (unsigned short *)_TIFFmalloc(scanline);
422                 if (!sbuf) {
423                         goto cleanup;
424                 }
425         }
426         else {
427                 ib_flag = IB_rect;
428         }
429         
430         tmpibuf = IMB_allocImBuf(ibuf->x, ibuf->y, ibuf->planes, ib_flag);
431         if (!tmpibuf) {
432                 goto cleanup;
433         }
434         
435         /* simple RGBA image */
436         if (!(bitspersample == 32 || bitspersample == 16)) {
437                 success |= TIFFReadRGBAImage(image, ibuf->x, ibuf->y, tmpibuf->rect, 0);
438         }
439         /* contiguous channels: RGBRGBRGB */
440         else if (config == PLANARCONFIG_CONTIG) {
441                 for (row = 0; row < ibuf->y; row++) {
442                         size_t ib_offset = (size_t)ibuf->x * 4 * ((size_t)ibuf->y - ((size_t)row + 1));
443                 
444                         if (bitspersample == 32) {
445                                 success |= TIFFReadScanline(image, fbuf, row, 0);
446                                 scanline_contig_32bit(tmpibuf->rect_float + ib_offset, fbuf, ibuf->x, spp);
447                                 
448                         }
449                         else if (bitspersample == 16) {
450                                 success |= TIFFReadScanline(image, sbuf, row, 0);
451                                 scanline_contig_16bit(tmpibuf->rect_float + ib_offset, sbuf, ibuf->x, spp);
452                         }
453                 }
454                 /* separate channels: RRRGGGBBB */
455         }
456         else if (config == PLANARCONFIG_SEPARATE) {
457                 
458                 /* imbufs always have 4 channels of data, so we iterate over all of them
459                  * but only fill in from the TIFF scanline where necessary. */
460                 for (chan = 0; chan < 4; chan++) {
461                         for (row = 0; row < ibuf->y; row++) {
462                                 size_t ib_offset = (size_t)ibuf->x * 4 * ((size_t)ibuf->y - ((size_t)row + 1));
463                                 
464                                 if (bitspersample == 32) {
465                                         if (chan == 3 && spp == 3) /* fill alpha if only RGB TIFF */
466                                                 copy_vn_fl(fbuf, ibuf->x, 1.0f);
467                                         else if (chan >= spp) /* for grayscale, duplicate first channel into G and B */
468                                                 success |= TIFFReadScanline(image, fbuf, row, 0);
469                                         else
470                                                 success |= TIFFReadScanline(image, fbuf, row, chan);
471                                         scanline_separate_32bit(tmpibuf->rect_float + ib_offset, fbuf, ibuf->x, chan);
472                                         
473                                 }
474                                 else if (bitspersample == 16) {
475                                         if (chan == 3 && spp == 3) /* fill alpha if only RGB TIFF */
476                                                 copy_vn_ushort(sbuf, ibuf->x, 65535);
477                                         else if (chan >= spp) /* for grayscale, duplicate first channel into G and B */
478                                                 success |= TIFFReadScanline(image, fbuf, row, 0);
479                                         else
480                                                 success |= TIFFReadScanline(image, sbuf, row, chan);
481                                         scanline_separate_16bit(tmpibuf->rect_float + ib_offset, sbuf, ibuf->x, chan);
482                                         
483                                 }
484                         }
485                 }
486         }
487
488         if (success) {
489                 /* Code seems to be not needed for 16 bits tif, on PPC G5 OSX (ton) */
490                 if (bitspersample < 16)
491                         if (ENDIAN_ORDER == B_ENDIAN)
492                                 IMB_convert_rgba_to_abgr(tmpibuf);
493                 
494                 /* assign rect last */
495                 if (tmpibuf->rect_float)
496                         ibuf->rect_float = tmpibuf->rect_float;
497                 else
498                         ibuf->rect = tmpibuf->rect;
499                 ibuf->mall |= ib_flag;
500                 ibuf->flags |= ib_flag;
501                 
502                 tmpibuf->mall &= ~ib_flag;
503         }
504
505 cleanup:
506         if (bitspersample == 32)
507                 _TIFFfree(fbuf);
508         else if (bitspersample == 16)
509                 _TIFFfree(sbuf);
510
511         IMB_freeImBuf(tmpibuf);
512         
513         return success;
514 }
515
516 void imb_inittiff(void)
517 {
518         if (!(G.debug & G_DEBUG))
519                 TIFFSetErrorHandler(NULL);
520 }
521
522 /**
523  * Loads a TIFF file.
524  *
525  *
526  * \param mem:   Memory containing the TIFF file.
527  * \param size:  Size of the mem buffer.
528  * \param flags: If flags has IB_test set then the file is not actually loaded,
529  *                but all other operations take place.
530  *
531  * \return: A newly allocated ImBuf structure if successful, otherwise NULL.
532  */
533 ImBuf *imb_loadtiff(const unsigned char *mem, size_t size, int flags, char colorspace[IM_MAX_SPACE])
534 {
535         TIFF *image = NULL;
536         ImBuf *ibuf = NULL, *hbuf;
537         ImbTIFFMemFile memFile;
538         uint32 width, height;
539         char *format = NULL;
540         int level;
541         short spp;
542         int ib_depth;
543         int found;
544
545         /* check whether or not we have a TIFF file */
546         if (size < IMB_TIFF_NCB) {
547                 fprintf(stderr, "imb_loadtiff: size < IMB_TIFF_NCB\n");
548                 return NULL;
549         }
550         if (imb_is_a_tiff(mem) == 0)
551                 return NULL;
552
553         /* both 8 and 16 bit PNGs are default to standard byte colorspace */
554         colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);
555
556         image = imb_tiff_client_open(&memFile, mem, size);
557
558         if (image == NULL) {
559                 printf("imb_loadtiff: could not open TIFF IO layer.\n");
560                 return NULL;
561         }
562
563         /* allocate the image buffer */
564         TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
565         TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
566         TIFFGetField(image, TIFFTAG_SAMPLESPERPIXEL, &spp);
567         
568         ib_depth = (spp == 3) ? 24 : 32;
569         
570         ibuf = IMB_allocImBuf(width, height, ib_depth, 0);
571         if (ibuf) {
572                 ibuf->ftype = IMB_FTYPE_TIF;
573         }
574         else {
575                 fprintf(stderr, 
576                         "imb_loadtiff: could not allocate memory for TIFF "
577                         "image.\n");
578                 TIFFClose(image);
579                 return NULL;
580         }
581
582         /* get alpha mode from file header */
583         if (flags & IB_alphamode_detect) {
584                 if (spp == 4) {
585                         unsigned short extra, *extraSampleTypes;
586
587                         found = TIFFGetField(image, TIFFTAG_EXTRASAMPLES, &extra, &extraSampleTypes);
588
589                         if (found && (extraSampleTypes[0] == EXTRASAMPLE_ASSOCALPHA)) {
590                                 ibuf->flags |= IB_alphamode_premul;
591                         }
592                 }
593         }
594
595         /* if testing, we're done */
596         if (flags & IB_test) {
597                 TIFFClose(image);
598                 return ibuf;
599         }
600
601         /* detect if we are reading a tiled/mipmapped texture, in that case
602          * we don't read pixels but leave it to the cache to load tiles */
603         if (flags & IB_tilecache) {
604                 format = NULL;
605                 TIFFGetField(image, TIFFTAG_PIXAR_TEXTUREFORMAT, &format);
606
607                 if (format && STREQ(format, "Plain Texture") && TIFFIsTiled(image)) {
608                         int numlevel = TIFFNumberOfDirectories(image);
609
610                         /* create empty mipmap levels in advance */
611                         for (level = 0; level < numlevel; level++) {
612                                 if (!TIFFSetDirectory(image, level))
613                                         break;
614
615                                 if (level > 0) {
616                                         width = (width > 1) ? width / 2 : 1;
617                                         height = (height > 1) ? height / 2 : 1;
618
619                                         hbuf = IMB_allocImBuf(width, height, 32, 0);
620                                         hbuf->miplevel = level;
621                                         hbuf->ftype = ibuf->ftype;
622                                         ibuf->mipmap[level - 1] = hbuf;
623                                 }
624                                 else
625                                         hbuf = ibuf;
626
627                                 hbuf->flags |= IB_tilecache;
628
629                                 TIFFGetField(image, TIFFTAG_TILEWIDTH, &hbuf->tilex);
630                                 TIFFGetField(image, TIFFTAG_TILELENGTH, &hbuf->tiley);
631
632                                 hbuf->xtiles = ceil(hbuf->x / (float)hbuf->tilex);
633                                 hbuf->ytiles = ceil(hbuf->y / (float)hbuf->tiley);
634
635                                 imb_addtilesImBuf(hbuf);
636
637                                 ibuf->miptot++;
638                         }
639                 }
640         }
641
642         /* read pixels */
643         if (!(ibuf->flags & IB_tilecache) && !imb_read_tiff_pixels(ibuf, image)) {
644                 fprintf(stderr, "imb_loadtiff: Failed to read tiff image.\n");
645                 TIFFClose(image);
646                 return NULL;
647         }
648
649         /* close the client layer interface to the in-memory file */
650         TIFFClose(image);
651
652         /* return successfully */
653         return ibuf;
654 }
655
656 void imb_loadtiletiff(ImBuf *ibuf, const unsigned char *mem, size_t size, int tx, int ty, unsigned int *rect)
657 {
658         TIFF *image = NULL;
659         uint32 width, height;
660         ImbTIFFMemFile memFile;
661
662         image = imb_tiff_client_open(&memFile, mem, size);
663
664         if (image == NULL) {
665                 printf("imb_loadtiff: could not open TIFF IO layer for loading mipmap level.\n");
666                 return;
667         }
668
669         if (TIFFSetDirectory(image, ibuf->miplevel)) { /* allocate the image buffer */
670                 TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
671                 TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
672
673                 if (width == ibuf->x && height == ibuf->y) {
674                         if (rect) {
675                                 /* tiff pixels are bottom to top, tiles are top to bottom */
676                                 if (TIFFReadRGBATile(image, tx * ibuf->tilex, (ibuf->ytiles - 1 - ty) * ibuf->tiley, rect) == 1) {
677                                         if (ibuf->tiley > ibuf->y)
678                                                 memmove(rect, rect + ibuf->tilex * (ibuf->tiley - ibuf->y), sizeof(int) * ibuf->tilex * ibuf->y);
679                                 }
680                                 else
681                                         printf("imb_loadtiff: failed to read tiff tile at mipmap level %d\n", ibuf->miplevel);
682                         }
683                 }
684                 else
685                         printf("imb_loadtiff: mipmap level %d has unexpected size %ux%u instead of %dx%d\n", ibuf->miplevel, width, height, ibuf->x, ibuf->y);
686         }
687         else
688                 printf("imb_loadtiff: could not find mipmap level %d\n", ibuf->miplevel);
689
690         /* close the client layer interface to the in-memory file */
691         TIFFClose(image);
692 }
693
694 /**
695  * Saves a TIFF file.
696  *
697  * ImBuf structures with 1, 3 or 4 bytes per pixel (GRAY, RGB, RGBA 
698  * respectively) are accepted, and interpreted correctly.  Note that the TIFF
699  * convention is to use pre-multiplied alpha, which can be achieved within
700  * Blender by setting "Premul" alpha handling.  Other alpha conventions are
701  * not strictly correct, but are permitted anyhow.
702  *
703  * \param ibuf:  Image buffer.
704  * \param name:  Name of the TIFF file to create.
705  * \param flags: Currently largely ignored.
706  *
707  * \return: 1 if the function is successful, 0 on failure.
708  */
709
710 int imb_savetiff(ImBuf *ibuf, const char *name, int flags)
711 {
712         TIFF *image = NULL;
713         uint16 samplesperpixel, bitspersample;
714         size_t npixels;
715         unsigned char *pixels = NULL;
716         unsigned char *from = NULL, *to = NULL;
717         unsigned short *pixels16 = NULL, *to16 = NULL;
718         float *fromf = NULL;
719         float xres, yres;
720         int x, y, from_i, to_i, i;
721         int compress_mode = COMPRESSION_NONE;
722
723         /* check for a valid number of bytes per pixel.  Like the PNG writer,
724          * the TIFF writer supports 1, 3 or 4 bytes per pixel, corresponding
725          * to gray, RGB, RGBA respectively. */
726         samplesperpixel = (uint16)((ibuf->planes + 7) >> 3);
727         if ((samplesperpixel > 4) || (samplesperpixel == 2)) {
728                 fprintf(stderr,
729                         "imb_savetiff: unsupported number of bytes per "
730                         "pixel: %d\n", samplesperpixel);
731                 return (0);
732         }
733
734         if ((ibuf->foptions.flag & TIF_16BIT) && ibuf->rect_float)
735                 bitspersample = 16;
736         else
737                 bitspersample = 8;
738
739         if (ibuf->foptions.flag & TIF_COMPRESS_DEFLATE)
740                 compress_mode = COMPRESSION_DEFLATE;
741         else if (ibuf->foptions.flag & TIF_COMPRESS_LZW)
742                 compress_mode = COMPRESSION_LZW;
743         else if (ibuf->foptions.flag & TIF_COMPRESS_PACKBITS)
744                 compress_mode = COMPRESSION_PACKBITS;
745
746         /* open TIFF file for writing */
747         if (flags & IB_mem) {
748                 /* bork at the creation of a TIFF in memory */
749                 fprintf(stderr,
750                         "imb_savetiff: creation of in-memory TIFF files is "
751                         "not yet supported.\n");
752                 return (0);
753         }
754         else {
755                 /* create image as a file */
756 #ifdef WIN32
757                 wchar_t *wname = alloc_utf16_from_8(name, 0);
758                 image = TIFFOpenW(wname, "w");
759                 free(wname);
760 #else
761                 image = TIFFOpen(name, "w");
762 #endif
763         }
764         if (image == NULL) {
765                 fprintf(stderr,
766                         "imb_savetiff: could not open TIFF for writing.\n");
767                 return (0);
768         }
769
770         /* allocate array for pixel data */
771         npixels = ibuf->x * ibuf->y;
772         if (bitspersample == 16)
773                 pixels16 = (unsigned short *)_TIFFmalloc(npixels *
774                                                          samplesperpixel * sizeof(unsigned short));
775         else
776                 pixels = (unsigned char *)_TIFFmalloc(npixels *
777                                                       samplesperpixel * sizeof(unsigned char));
778
779         if (pixels == NULL && pixels16 == NULL) {
780                 fprintf(stderr,
781                         "imb_savetiff: could not allocate pixels array.\n");
782                 TIFFClose(image);
783                 return (0);
784         }
785
786         /* setup pointers */
787         if (bitspersample == 16) {
788                 fromf = ibuf->rect_float;
789                 to16   = pixels16;
790         }
791         else {
792                 from = (unsigned char *)ibuf->rect;
793                 to   = pixels;
794         }
795
796         /* setup samples per pixel */
797         TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, bitspersample);
798         TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
799
800         if (samplesperpixel == 4) {
801                 unsigned short extraSampleTypes[1];
802
803                 if (bitspersample == 16)
804                         extraSampleTypes[0] = EXTRASAMPLE_ASSOCALPHA;
805                 else
806                         extraSampleTypes[0] = EXTRASAMPLE_UNASSALPHA;
807
808                 /* RGBA images */
809                 TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1,
810                              extraSampleTypes);
811                 TIFFSetField(image, TIFFTAG_PHOTOMETRIC, 
812                              PHOTOMETRIC_RGB);
813         }
814         else if (samplesperpixel == 3) {
815                 /* RGB images */
816                 TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
817                              PHOTOMETRIC_RGB);
818         }
819         else if (samplesperpixel == 1) {
820                 /* grayscale images, 1 channel */
821                 TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
822                              PHOTOMETRIC_MINISBLACK);
823         }
824
825         /* copy pixel data.  While copying, we flip the image vertically. */
826         const int channels_in_float = ibuf->channels ? ibuf->channels : 4;
827         for (x = 0; x < ibuf->x; x++) {
828                 for (y = 0; y < ibuf->y; y++) {
829                         from_i = ((size_t)channels_in_float) * (y * ibuf->x + x);
830                         to_i   = samplesperpixel * ((ibuf->y - y - 1) * ibuf->x + x);
831
832                         if (pixels16) {
833                                 /* convert from float source */
834                                 float rgb[4];
835
836                                 if (channels_in_float == 3 || channels_in_float == 4) {
837                                         if (ibuf->float_colorspace ||
838                                             (ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA))
839                                         {
840                                                 /* Float buffer was managed already, no need in color
841                                                  * space conversion.
842                                                  */
843                                                 copy_v3_v3(rgb, &fromf[from_i]);
844                                         }
845                                         else {
846                                                 /* Standard linear-to-srgb conversion if float buffer
847                                                  * wasn't managed.
848                                                  */
849                                                 linearrgb_to_srgb_v3_v3(rgb, &fromf[from_i]);
850                                         }
851                                         if (channels_in_float == 4) {
852                                                 rgb[3] = fromf[from_i + 3];
853                                         }
854                                         else {
855                                                 rgb[3] = 1.0f;
856                                         }
857                                 }
858                                 else {
859                                         if (ibuf->float_colorspace ||
860                                             (ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA))
861                                         {
862                                                 rgb[0] = fromf[from_i];
863                                         }
864                                         else {
865                                                 rgb[0] = linearrgb_to_srgb(fromf[from_i]);
866                                         }
867                                         rgb[1] = rgb[2] = rgb[0];
868                                         rgb[3] = 1.0f;
869                                 }
870
871                                 for (i = 0; i < samplesperpixel; i++, to_i++)
872                                         to16[to_i] = FTOUSHORT(rgb[i]);
873                         }
874                         else {
875                                 for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
876                                         to[to_i] = from[from_i];
877                         }
878                 }
879         }
880
881         /* write the actual TIFF file */
882         TIFFSetField(image, TIFFTAG_IMAGEWIDTH,      ibuf->x);
883         TIFFSetField(image, TIFFTAG_IMAGELENGTH,     ibuf->y);
884         TIFFSetField(image, TIFFTAG_ROWSPERSTRIP,    ibuf->y);
885         TIFFSetField(image, TIFFTAG_COMPRESSION, compress_mode);
886         TIFFSetField(image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
887         TIFFSetField(image, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
888
889
890         if (ibuf->ppm[0] > 0.0 && ibuf->ppm[1] > 0.0) {
891                 xres = (float)(ibuf->ppm[0] * 0.0254);
892                 yres = (float)(ibuf->ppm[1] * 0.0254);
893         }
894         else {
895                 xres = yres = IMB_DPI_DEFAULT;
896         }
897
898         TIFFSetField(image, TIFFTAG_XRESOLUTION,     xres);
899         TIFFSetField(image, TIFFTAG_YRESOLUTION,     yres);
900         TIFFSetField(image, TIFFTAG_RESOLUTIONUNIT,  RESUNIT_INCH);
901         if (TIFFWriteEncodedStrip(image, 0,
902                                   (bitspersample == 16) ? (unsigned char *)pixels16 : pixels,
903                                   (size_t)ibuf->x * ibuf->y * samplesperpixel * bitspersample / 8) == -1)
904         {
905                 fprintf(stderr,
906                         "imb_savetiff: Could not write encoded TIFF.\n");
907                 TIFFClose(image);
908                 if (pixels) _TIFFfree(pixels);
909                 if (pixels16) _TIFFfree(pixels16);
910                 return (1);
911         }
912
913         /* close the TIFF file */
914         TIFFClose(image);
915         if (pixels) _TIFFfree(pixels);
916         if (pixels16) _TIFFfree(pixels16);
917         return (1);
918 }