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