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