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