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