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