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