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