- use %u rather tham %d for unsigned ints in string formatting funcs.
[blender.git] / source / blender / imbuf / intern / tiff.c
index a14bad42203f0e94916bbc3ed5a7cbe665da1edf..7beb853fe62ba0fc58cef0809766f22d2d3ed86a 100644 (file)
@@ -3,15 +3,12 @@
  *
  * $Id$
  * 
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. The Blender
- * Foundation also sells licenses for use in proprietary software under
- * the Blender License.  See http://www.blender.org/BL/ for information
- * about this.
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * Contributor(s): Jonathan Merritt.
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/imbuf/intern/tiff.c
+ *  \ingroup imbuf
+ */
+
+
 /**
  * Provides TIFF file loading and saving for Blender, via libtiff.
  *
  * used to compress images.
  */
 
+#ifdef WITH_TIFF
+
 #include <string.h>
 
 #include "imbuf.h"
-#include "imbuf_patch.h"
 
+#include "BLI_math.h"
+#include "BLI_string.h"
+#include "BLI_utildefines.h"
 #include "BKE_global.h"
 
+
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
 
 #include "IMB_allocimbuf.h"
-#include "IMB_cmap.h"
-#include "IMB_tiff.h"
+#include "IMB_filetype.h"
+#include "IMB_filter.h"
 
-#include "dynlibtiff.h"
+#include "tiffio.h"
 
 
 
  * Local declarations. *
  ***********************/
 /* Reading and writing of an in-memory TIFF file. */
-tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n);
-tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n);
-toff_t  imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence);
-int     imb_tiff_CloseProc(thandle_t handle);
-toff_t  imb_tiff_SizeProc(thandle_t handle);
-int     imb_tiff_DummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize);
-void    imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size);
+static tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n);
+static tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n);
+static toff_t  imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence);
+static int     imb_tiff_CloseProc(thandle_t handle);
+static toff_t  imb_tiff_SizeProc(thandle_t handle);
+static int     imb_tiff_DummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize);
+static void    imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size);
 
 
 /* Structure for in-memory TIFF file. */
-struct ImbTIFFMemFile {
+typedef struct ImbTIFFMemFile {
        unsigned char *mem;     /* Location of first byte of TIFF file. */
        toff_t offset;          /* Current offset within the file.      */
        tsize_t size;           /* Size of the TIFF file.               */
-};
-#define IMB_TIFF_GET_MEMFILE(x) ((struct ImbTIFFMemFile*)(x));
+} ImbTIFFMemFile;
+#define IMB_TIFF_GET_MEMFILE(x) ((ImbTIFFMemFile*)(x));
 
 
 
@@ -89,13 +97,20 @@ struct ImbTIFFMemFile {
  *****************************/
 
 
-void imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
+static void imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
 {
+       (void)fd;
+       (void)base;
+       (void)size;
 }
 
-int imb_tiff_DummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) 
+static int imb_tiff_DummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) 
 {
-            return (0);
+       (void)fd;
+       (void)pbase;
+       (void)psize;
+
+       return (0);
 }
 
 /**
@@ -108,31 +123,31 @@ int imb_tiff_DummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  * @return: Number of bytes actually read.
  *      0 = EOF.
  */
-tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n)
+static tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n)
 {
        tsize_t nRemaining, nCopy;
-       struct ImbTIFFMemFile* mfile;
+       ImbTIFFMemFile* mfile;
        void *srcAddr;
 
        /* get the pointer to the in-memory file */
        mfile = IMB_TIFF_GET_MEMFILE(handle);
-       if (!mfile || !mfile->mem) {
+       if(!mfile || !mfile->mem) {
                fprintf(stderr, "imb_tiff_ReadProc: !mfile || !mfile->mem!\n");
                return 0;
        }
 
        /* find the actual number of bytes to read (copy) */
        nCopy = n;
-       if ((tsize_t)mfile->offset >= mfile->size)
+       if((tsize_t)mfile->offset >= mfile->size)
                nRemaining = 0;
        else
                nRemaining = mfile->size - mfile->offset;
        
-       if (nCopy > nRemaining)
+       if(nCopy > nRemaining)
                nCopy = nRemaining;
        
        /* on EOF, return immediately and read (copy) nothing */
-       if (nCopy <= 0)
+       if(nCopy <= 0)
                return (0);
 
        /* all set -> do the read (copy) */
@@ -150,8 +165,12 @@ tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n)
  * NOTE: The current Blender implementation should not need this function.  It
  *       is simply a stub.
  */
-tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n)
+static tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n)
 {
+       (void)handle;
+       (void)data;
+       (void)n;
+       
        printf("imb_tiff_WriteProc: this function should not be called.\n");
        return (-1);
 }
@@ -172,14 +191,14 @@ tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n)
  * @return: Resulting offset location within the file, measured in bytes from
  *          the beginning of the file.  (-1) indicates an error.
  */
-toff_t imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence)
+static toff_t imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence)
 {
-       struct ImbTIFFMemFile *mfile;
+       ImbTIFFMemFile *mfile;
        toff_t new_offset;
 
        /* get the pointer to the in-memory file */
        mfile = IMB_TIFF_GET_MEMFILE(handle);
-       if (!mfile || !mfile->mem) {
+       if(!mfile || !mfile->mem) {
                fprintf(stderr, "imb_tiff_SeekProc: !mfile || !mfile->mem!\n");
                return (-1);
        }
@@ -219,13 +238,13 @@ toff_t imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence)
  *
  * @return: 0
  */
-int imb_tiff_CloseProc(thandle_t handle)
+static int imb_tiff_CloseProc(thandle_t handle)
 {
-       struct ImbTIFFMemFile *mfile;
+       ImbTIFFMemFile *mfile;
 
        /* get the pointer to the in-memory file */
        mfile = IMB_TIFF_GET_MEMFILE(handle);
-       if (!mfile || !mfile->mem) {
+       if(!mfile || !mfile->mem) {
                fprintf(stderr,"imb_tiff_CloseProc: !mfile || !mfile->mem!\n");
                return (0);
        }
@@ -245,13 +264,13 @@ int imb_tiff_CloseProc(thandle_t handle)
  *
  * @return: Size of file (in bytes).
  */
-toff_t imb_tiff_SizeProc(thandle_t handle)
+static toff_t imb_tiff_SizeProc(thandle_t handle)
 {
-       struct ImbTIFFMemFile* mfile;
+       ImbTIFFMemFile* mfile;
 
        /* get the pointer to the in-memory file */
        mfile = IMB_TIFF_GET_MEMFILE(handle);
-       if (!mfile || !mfile->mem) {
+       if(!mfile || !mfile->mem) {
                fprintf(stderr,"imb_tiff_SizeProc: !mfile || !mfile->mem!\n");
                return (0);
        }
@@ -260,14 +279,23 @@ toff_t imb_tiff_SizeProc(thandle_t handle)
        return (toff_t)(mfile->size);
 }
 
+static TIFF *imb_tiff_client_open(ImbTIFFMemFile *memFile, unsigned char *mem, size_t size)
+{
+       /* open the TIFF client layer interface to the in-memory file */
+       memFile->mem = mem;
+       memFile->offset = 0;
+       memFile->size = size;
 
+       return TIFFClientOpen("(Blender TIFF Interface Layer)", 
+               "r", (thandle_t)(memFile),
+               imb_tiff_ReadProc, imb_tiff_WriteProc,
+               imb_tiff_SeekProc, imb_tiff_CloseProc,
+               imb_tiff_SizeProc, imb_tiff_DummyMapProc, imb_tiff_DummyUnmapProc);
+}
 
 /**
  * Checks whether a given memory buffer contains a TIFF file.
  *
- * FIXME: Possible memory leak if mem is less than IMB_TIFF_NCB bytes long.
- *        However, changing this will require up-stream modifications.
- *
  * This method uses the format identifiers from:
  *     http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-9.html
  * The first four bytes of big-endian and little-endian TIFF files
@@ -281,7 +309,7 @@ toff_t imb_tiff_SizeProc(thandle_t handle)
  * hence my manual comparison. - Jonathan Merritt (lancelet) 4th Sept 2005.
  */
 #define IMB_TIFF_NCB 4         /* number of comparison bytes used */
-int imb_is_a_tiff(void *mem)
+int imb_is_a_tiff(unsigned char *mem)
 {
        char big_endian[IMB_TIFF_NCB] = { 0x4d, 0x4d, 0x00, 0x2a };
        char lil_endian[IMB_TIFF_NCB] = { 0x49, 0x49, 0x2a, 0x00 };
@@ -290,14 +318,185 @@ int imb_is_a_tiff(void *mem)
                 (memcmp(lil_endian, mem, IMB_TIFF_NCB) == 0) );
 }
 
+static void scanline_contig_16bit(float *rectf, unsigned short *sbuf, int scanline_w, int spp)
+{
+       int i;
+       for (i=0; i < scanline_w; i++) {
+               rectf[i*4 + 0] = sbuf[i*spp + 0] / 65535.0;
+               rectf[i*4 + 1] = sbuf[i*spp + 1] / 65535.0;
+               rectf[i*4 + 2] = sbuf[i*spp + 2] / 65535.0;
+               rectf[i*4 + 3] = (spp==4)?(sbuf[i*spp + 3] / 65535.0):1.0;
+       }
+}
+
+static void scanline_contig_32bit(float *rectf, float *fbuf, int scanline_w, int spp)
+{
+       int i;
+       for (i=0; i < scanline_w; i++) {
+               rectf[i*4 + 0] = fbuf[i*spp + 0];
+               rectf[i*4 + 1] = fbuf[i*spp + 1];
+               rectf[i*4 + 2] = fbuf[i*spp + 2];
+               rectf[i*4 + 3] = (spp==4)?fbuf[i*spp + 3]:1.0f;
+       }
+}
 
+static void scanline_separate_16bit(float *rectf, unsigned short *sbuf, int scanline_w, int chan)
+{
+       int i;
+       for (i=0; i < scanline_w; i++)
+               rectf[i*4 + chan] = sbuf[i] / 65535.0;
+}
+
+static void scanline_separate_32bit(float *rectf, float *fbuf, int scanline_w, int chan)
+{
+       int i;
+       for (i=0; i < scanline_w; i++)
+               rectf[i*4 + chan] = fbuf[i];
+}
+
+static void imb_read_tiff_resolution(ImBuf *ibuf, TIFF *image)
+{
+       uint16 unit;
+       float xres;
+       float yres;
+
+       TIFFGetFieldDefaulted(image, TIFFTAG_RESOLUTIONUNIT, &unit);
+       TIFFGetFieldDefaulted(image, TIFFTAG_XRESOLUTION, &xres);
+       TIFFGetFieldDefaulted(image, TIFFTAG_YRESOLUTION, &yres);
+
+       if(unit == RESUNIT_CENTIMETER) {
+               ibuf->ppm[0]= (double)xres * 100.0;
+               ibuf->ppm[1]= (double)yres * 100.0;
+       }
+       else {
+               ibuf->ppm[0]= (double)xres / 0.0254;
+               ibuf->ppm[1]= (double)yres / 0.0254;
+       }
+}
+
+/* 
+ * Use the libTIFF scanline API to read a TIFF image.
+ * This method is most flexible and can handle multiple different bit depths 
+ * and RGB channel orderings.
+ */
+static int imb_read_tiff_pixels(ImBuf *ibuf, TIFF *image, int premul)
+{
+       ImBuf *tmpibuf;
+       int success= 0;
+       short bitspersample, spp, config;
+       size_t scanline;
+       int ib_flag=0, row, chan;
+       float *fbuf=NULL;
+       unsigned short *sbuf=NULL;
+
+       TIFFGetField(image, TIFFTAG_BITSPERSAMPLE, &bitspersample);
+       TIFFGetField(image, TIFFTAG_SAMPLESPERPIXEL, &spp);             /* number of 'channels' */
+       TIFFGetField(image, TIFFTAG_PLANARCONFIG, &config);
+
+       imb_read_tiff_resolution(ibuf, image);
+
+       scanline = TIFFScanlineSize(image);
+       
+       if (bitspersample == 32) {
+               ib_flag = IB_rectfloat;
+               fbuf = (float *)_TIFFmalloc(scanline);
+       } else if (bitspersample == 16) {
+               ib_flag = IB_rectfloat;
+               sbuf = (unsigned short *)_TIFFmalloc(scanline);
+       } else {
+               ib_flag = IB_rect;
+       }
+       
+       tmpibuf= IMB_allocImBuf(ibuf->x, ibuf->y, ibuf->depth, ib_flag);
+       
+       /* simple RGBA image */
+       if (!(bitspersample == 32 || bitspersample == 16)) {
+               success |= TIFFReadRGBAImage(image, ibuf->x, ibuf->y, tmpibuf->rect, 0);
+       }
+       /* contiguous channels: RGBRGBRGB */
+       else if (config == PLANARCONFIG_CONTIG) {
+               for (row = 0; row < ibuf->y; row++) {
+                       int ib_offset = ibuf->x*ibuf->y*4 - ibuf->x*4 * (row+1);
+               
+                       if (bitspersample == 32) {
+                               success |= TIFFReadScanline(image, fbuf, row, 0);
+                               scanline_contig_32bit(tmpibuf->rect_float+ib_offset, fbuf, ibuf->x, spp);
+                               
+                       } else if (bitspersample == 16) {
+                               success |= TIFFReadScanline(image, sbuf, row, 0);
+                               scanline_contig_16bit(tmpibuf->rect_float+ib_offset, sbuf, ibuf->x, spp);
+                       }
+               }
+       /* separate channels: RRRGGGBBB */
+       } else if (config == PLANARCONFIG_SEPARATE) {
+               
+               /* imbufs always have 4 channels of data, so we iterate over all of them
+                * but only fill in from the TIFF scanline where necessary. */
+               for (chan = 0; chan < 4; chan++) {
+                       for (row = 0; row < ibuf->y; row++) {
+                               int ib_offset = ibuf->x*ibuf->y*4 - ibuf->x*4 * (row+1);
+                               
+                               if (bitspersample == 32) {
+                                       if (chan == 3 && spp == 3) /* fill alpha if only RGB TIFF */
+                                               memset(fbuf, 1.0, sizeof(fbuf));
+                                       else
+                                               success |= TIFFReadScanline(image, fbuf, row, chan);
+                                       scanline_separate_32bit(tmpibuf->rect_float+ib_offset, fbuf, ibuf->x, chan);
+                                       
+                               } else if (bitspersample == 16) {
+                                       if (chan == 3 && spp == 3) /* fill alpha if only RGB TIFF */
+                                               memset(sbuf, 65535, sizeof(sbuf));
+                                       else
+                                               success |= TIFFReadScanline(image, sbuf, row, chan);
+                                       scanline_separate_16bit(tmpibuf->rect_float+ib_offset, sbuf, ibuf->x, chan);
+                                       
+                               }
+                       }
+               }
+       }
+       
+       if (bitspersample == 32)
+               _TIFFfree(fbuf);
+       else if (bitspersample == 16)
+               _TIFFfree(sbuf);
+
+       if(success) {
+               ibuf->profile = (bitspersample==32)?IB_PROFILE_LINEAR_RGB:IB_PROFILE_SRGB;
+
+//             Code seems to be not needed for 16 bits tif, on PPC G5 OSX (ton)
+               if(bitspersample < 16)
+                       if(ENDIAN_ORDER == B_ENDIAN)
+                               IMB_convert_rgba_to_abgr(tmpibuf);
+               if(premul) {
+                       IMB_premultiply_alpha(tmpibuf);
+                       ibuf->flags |= IB_premul;
+               }
+               
+               /* assign rect last */
+               if (tmpibuf->rect_float)
+                       ibuf->rect_float= tmpibuf->rect_float;
+               else    
+                       ibuf->rect= tmpibuf->rect;
+               ibuf->mall |= ib_flag;
+               ibuf->flags |= ib_flag;
+               
+               tmpibuf->mall &= ~ib_flag;
+       }
+
+       IMB_freeImBuf(tmpibuf);
+       
+       return success;
+}
+
+void imb_inittiff(void)
+{
+       if (!(G.f & G_DEBUG))
+               TIFFSetErrorHandler(NULL);
+}
 
 /**
  * Loads a TIFF file.
  *
- * This function uses the "RGBA Image" support from libtiff, which enables
- * it to load most commonly-encountered TIFF formats.  libtiff handles format
- * conversion, color depth conversion, etc.
  *
  * @param mem:   Memory containing the TIFF file.
  * @param size:  Size of the mem buffer.
@@ -306,116 +505,154 @@ int imb_is_a_tiff(void *mem)
  *
  * @return: A newly allocated ImBuf structure if successful, otherwise NULL.
  */
-struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
+ImBuf *imb_loadtiff(unsigned char *mem, size_t size, int flags)
 {
        TIFF *image = NULL;
-       struct ImBuf *ibuf = NULL;
-       struct ImbTIFFMemFile memFile;
+       ImBuf *ibuf = NULL, *hbuf;
+       ImbTIFFMemFile memFile;
        uint32 width, height;
-       int bytesperpixel;
-       int success;
-       unsigned int pixel_i, byte_i;
-       uint32 *raster = NULL;
-       uint32 pixel;
-       unsigned char *to = NULL;
-
-       memFile.mem = mem;
-       memFile.offset = 0;
-       memFile.size = size;
+       char *format = NULL;
+       int level;
+       short spp;
+       int ib_depth;
 
        /* check whether or not we have a TIFF file */
-        if (size < IMB_TIFF_NCB) {
+       if(size < IMB_TIFF_NCB) {
                fprintf(stderr, "imb_loadtiff: size < IMB_TIFF_NCB\n");
                return NULL;
        }
-       if (imb_is_a_tiff(mem) == 0)
+       if(imb_is_a_tiff(mem) == 0)
                return NULL;
 
-       /* open the TIFF client layer interface to the in-memory file */
-       image = libtiff_TIFFClientOpen("(Blender TIFF Interface Layer)", 
-               "r", (thandle_t)(&memFile),
-               imb_tiff_ReadProc, imb_tiff_WriteProc,
-               imb_tiff_SeekProc, imb_tiff_CloseProc,
-               imb_tiff_SizeProc, imb_tiff_DummyMapProc, imb_tiff_DummyUnmapProc);
-       if (image == NULL) {
+       image = imb_tiff_client_open(&memFile, mem, size);
+
+       if(image == NULL) {
                printf("imb_loadtiff: could not open TIFF IO layer.\n");
                return NULL;
        }
 
        /* allocate the image buffer */
-       bytesperpixel = 4;  /* 1 byte per channel, 4 channels */
-       libtiff_TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
-       libtiff_TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
-       ibuf = IMB_allocImBuf(width, height, 8*bytesperpixel, 0, 0);
-       if (ibuf) {
+       TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
+       TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
+       TIFFGetField(image, TIFFTAG_SAMPLESPERPIXEL, &spp);
+       
+       ib_depth = (spp==3)?24:32;
+       
+       ibuf = IMB_allocImBuf(width, height, ib_depth, 0);
+       if(ibuf) {
                ibuf->ftype = TIF;
-       } else {
+       }
+       else {
                fprintf(stderr, 
                        "imb_loadtiff: could not allocate memory for TIFF " \
                        "image.\n");
-               libtiff_TIFFClose(image);
+               TIFFClose(image);
                return NULL;
        }
 
-       /* read in the image data */
-       if (!(flags & IB_test)) {
+       /* if testing, we're done */
+       if(flags & IB_test) {
+               TIFFClose(image);
+               return ibuf;
+       }
 
-               /* allocate memory for the ibuf->rect */
-               imb_addrectImBuf(ibuf);
+       /* detect if we are reading a tiled/mipmapped texture, in that case
+          we don't read pixels but leave it to the cache to load tiles */
+       if(flags & IB_tilecache) {
+               format= NULL;
+               TIFFGetField(image, TIFFTAG_PIXAR_TEXTUREFORMAT, &format);
 
-               /* perform actual read */
-               raster = (uint32*)libtiff__TIFFmalloc(
-                               width*height * sizeof(uint32));
-               if (raster == NULL) {
-                       libtiff_TIFFClose(image);
-                       return NULL;
-               }
-               success = libtiff_TIFFReadRGBAImage(
-                               image, width, height, raster, 0);
-               if (!success) {
-                       fprintf(stderr,
-                               "imb_loadtiff: This TIFF format is not " 
-                               "currently supported by Blender.\n");
-                       libtiff__TIFFfree(raster);
-                       libtiff_TIFFClose(image);
-                       return NULL;
-               }
+               if(format && strcmp(format, "Plain Texture")==0 && TIFFIsTiled(image)) {
+                       int numlevel = TIFFNumberOfDirectories(image);
 
-               /* copy raster to ibuf->rect; we do a fast copy if possible,
-                * otherwise revert to a slower component-wise copy */
-               if (sizeof(unsigned int) == sizeof(uint32)) {
-                       memcpy(ibuf->rect, raster, 
-                               width*height*sizeof(uint32));
-               } else {
-                       /* this may not be entirely necessary, but is put here
-                        * in case sizeof(unsigned int) is not a 32-bit
-                        * quantity */
-                       fprintf(stderr,
-                               "imb_loadtiff: using (slower) component-wise "
-                               "buffer copy.\n");
-                       to = (unsigned char*)ibuf->rect;
-                       for (pixel_i=0; pixel_i < width*height; pixel_i++)
-                       {       
-                               byte_i = sizeof(unsigned int)*pixel_i;
-                               pixel = raster[pixel_i];
-       
-                               to[byte_i++] = (unsigned char)TIFFGetR(pixel);
-                               to[byte_i++] = (unsigned char)TIFFGetG(pixel);
-                               to[byte_i++] = (unsigned char)TIFFGetB(pixel);
-                               to[byte_i++] = (unsigned char)TIFFGetA(pixel);
+                       /* create empty mipmap levels in advance */
+                       for(level=0; level<numlevel; level++) {
+                               if(!TIFFSetDirectory(image, level))
+                                       break;
+
+                               if(level > 0) {
+                                       width= (width > 1)? width/2: 1;
+                                       height= (height > 1)? height/2: 1;
+
+                                       hbuf= IMB_allocImBuf(width, height, 32, 0);
+                                       hbuf->miplevel= level;
+                                       hbuf->ftype= ibuf->ftype;
+                                       ibuf->mipmap[level-1] = hbuf;
+
+                                       if(flags & IB_premul)
+                                               hbuf->flags |= IB_premul;
+                               }
+                               else
+                                       hbuf= ibuf;
+
+                               hbuf->flags |= IB_tilecache;
+
+                               TIFFGetField(image, TIFFTAG_TILEWIDTH, &hbuf->tilex);
+                               TIFFGetField(image, TIFFTAG_TILELENGTH, &hbuf->tiley);
+
+                               hbuf->xtiles= ceil(hbuf->x/(float)hbuf->tilex);
+                               hbuf->ytiles= ceil(hbuf->y/(float)hbuf->tiley);
+
+                               imb_addtilesImBuf(hbuf);
+
+                               ibuf->miptot++;
                        }
                }
+       }
 
-               libtiff__TIFFfree(raster);
+       /* read pixels */
+       if(!(ibuf->flags & IB_tilecache) && !imb_read_tiff_pixels(ibuf, image, 0)) {
+               fprintf(stderr, "imb_loadtiff: Failed to read tiff image.\n");
+               TIFFClose(image);
+               return NULL;
        }
 
        /* close the client layer interface to the in-memory file */
-       libtiff_TIFFClose(image);
-
-       if (G.order == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
+       TIFFClose(image);
 
        /* return successfully */
-       return (ibuf);
+       return ibuf;
+}
+
+void imb_loadtiletiff(ImBuf *ibuf, unsigned char *mem, size_t size, int tx, int ty, unsigned int *rect)
+{
+       TIFF *image = NULL;
+       uint32 width, height;
+       ImbTIFFMemFile memFile;
+
+       image = imb_tiff_client_open(&memFile, mem, size);
+
+       if(image == NULL) {
+               printf("imb_loadtiff: could not open TIFF IO layer for loading mipmap level.\n");
+               return;
+       }
+
+       if(TIFFSetDirectory(image, ibuf->miplevel)) { /* allocate the image buffer */
+               TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
+               TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
+
+               if(width == ibuf->x && height == ibuf->y) {
+                       if(rect) {
+                               /* tiff pixels are bottom to top, tiles are top to bottom */
+                               if(TIFFReadRGBATile(image, tx*ibuf->tilex, (ibuf->ytiles - 1 - ty)*ibuf->tiley, rect) == 1) {
+                                       if(ibuf->tiley > ibuf->y)
+                                               memmove(rect, rect+ibuf->tilex*(ibuf->tiley - ibuf->y), sizeof(int)*ibuf->tilex*ibuf->y);
+
+                                       if(ibuf->flags & IB_premul)
+                                               IMB_premultiply_rect(rect, 32, ibuf->tilex, ibuf->tiley);
+                               }
+                               else
+                                       printf("imb_loadtiff: failed to read tiff tile at mipmap level %d\n", ibuf->miplevel);
+                       }
+               }
+               else
+                       printf("imb_loadtiff: mipmap level %d has unexpected size %ux%u instead of %dx%d\n", ibuf->miplevel, width, height, ibuf->x, ibuf->y);
+       }
+       else
+               printf("imb_loadtiff: could not find mipmap level %d\n", ibuf->miplevel);
+
+       /* close the client layer interface to the in-memory file */
+       TIFFClose(image);
 }
 
 /**
@@ -434,9 +671,7 @@ struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
  * @return: 1 if the function is successful, 0 on failure.
  */
 
-#define FTOUSHORT(f) ((f >= 1.0f-0.5f/65535)? 65535: (f <= 0.0f)? 0: (unsigned short)(f*65535.0f + 0.5f))
-
-short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
+int imb_savetiff(ImBuf *ibuf, const char *name, int flags)
 {
        TIFF *image = NULL;
        uint16 samplesperpixel, bitspersample;
@@ -445,14 +680,16 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
        unsigned char *from = NULL, *to = NULL;
        unsigned short *pixels16 = NULL, *to16 = NULL;
        float *fromf = NULL;
+       float xres, yres;
        int x, y, from_i, to_i, i;
        int extraSampleTypes[1] = { EXTRASAMPLE_ASSOCALPHA };
+       
 
        /* check for a valid number of bytes per pixel.  Like the PNG writer,
         * the TIFF writer supports 1, 3 or 4 bytes per pixel, corresponding
         * to gray, RGB, RGBA respectively. */
        samplesperpixel = (uint16)((ibuf->depth + 7) >> 3);
-       if ((samplesperpixel > 4) || (samplesperpixel == 2)) {
+       if((samplesperpixel > 4) || (samplesperpixel == 2)) {
                fprintf(stderr,
                        "imb_savetiff: unsupported number of bytes per " 
                        "pixel: %d\n", samplesperpixel);
@@ -465,17 +702,18 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
                bitspersample = 8;
 
        /* open TIFF file for writing */
-       if (flags & IB_mem) {
+       if(flags & IB_mem) {
                /* bork at the creation of a TIFF in memory */
                fprintf(stderr,
                        "imb_savetiff: creation of in-memory TIFF files is " 
                        "not yet supported.\n");
                return (0);
-       } else {
+       }
+       else {
                /* create image as a file */
-               image = libtiff_TIFFOpen(name, "w");
+               image = TIFFOpen(name, "w");
        }
-       if (image == NULL) {
+       if(image == NULL) {
                fprintf(stderr,
                        "imb_savetiff: could not open TIFF for writing.\n");
                return (0);
@@ -483,22 +721,22 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
 
        /* allocate array for pixel data */
        npixels = ibuf->x * ibuf->y;
-       if(ibuf->ftype & TIF_16BIT)
-               pixels16 = (unsigned short*)libtiff__TIFFmalloc(npixels *
+       if(bitspersample == 16)
+               pixels16 = (unsigned short*)_TIFFmalloc(npixels *
                        samplesperpixel * sizeof(unsigned short));
        else
-               pixels = (unsigned char*)libtiff__TIFFmalloc(npixels *
+               pixels = (unsigned char*)_TIFFmalloc(npixels *
                        samplesperpixel * sizeof(unsigned char));
 
-       if (pixels == NULL && pixels16 == NULL) {
+       if(pixels == NULL && pixels16 == NULL) {
                fprintf(stderr,
                        "imb_savetiff: could not allocate pixels array.\n");
-               libtiff_TIFFClose(image);
+               TIFFClose(image);
                return (0);
        }
 
        /* setup pointers */
-       if(ibuf->ftype & TIF_16BIT) {
+       if(bitspersample == 16) {
                fromf = ibuf->rect_float;
                to16   = pixels16;
        }
@@ -508,67 +746,95 @@ short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
        }
 
        /* setup samples per pixel */
-       libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, bitspersample);
-       libtiff_TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
+       TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, bitspersample);
+       TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
 
        if(samplesperpixel == 4) {
                /* RGBA images */
-               libtiff_TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1,
+               TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1,
                                extraSampleTypes);
-               libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC, 
+               TIFFSetField(image, TIFFTAG_PHOTOMETRIC, 
                                PHOTOMETRIC_RGB);
        }
        else if(samplesperpixel == 3) {
                /* RGB images */
-               libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
+               TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
                                PHOTOMETRIC_RGB);
        }
        else if(samplesperpixel == 1) {
                /* greyscale images, 1 channel */
-               libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
+               TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
                                PHOTOMETRIC_MINISBLACK);
        }
 
        /* copy pixel data.  While copying, we flip the image vertically. */
-       for (x = 0; x < ibuf->x; x++) {
-               for (y = 0; y < ibuf->y; y++) {
+       for(x = 0; x < ibuf->x; x++) {
+               for(y = 0; y < ibuf->y; y++) {
                        from_i = 4*(y*ibuf->x+x);
                        to_i   = samplesperpixel*((ibuf->y-y-1)*ibuf->x+x);
 
                        if(pixels16) {
-                               for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
-                                       to16[to_i] = FTOUSHORT(fromf[from_i]);
+                               /* convert from float source */
+                               float rgb[3];
+                               
+                               if (ibuf->profile == IB_PROFILE_LINEAR_RGB)
+                                       linearrgb_to_srgb_v3_v3(rgb, &fromf[from_i]);
+                               else
+                                       copy_v3_v3(rgb, &fromf[from_i]);
+
+                               to16[to_i+0] = FTOUSHORT(rgb[0]);
+                               to16[to_i+1] = FTOUSHORT(rgb[1]);
+                               to16[to_i+2] = FTOUSHORT(rgb[2]);
+                               to_i += 3; from_i+=3;
+                               
+                               if (samplesperpixel == 4) {
+                                       to16[to_i+3] = FTOUSHORT(fromf[from_i+3]);
+                                       /*to_i++; from_i++;*/ /*unused, set on each loop */
+                               }
                        }
                        else {
-                               for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
+                               for(i = 0; i < samplesperpixel; i++, to_i++, from_i++)
                                        to[to_i] = from[from_i];
                        }
                }
        }
 
        /* write the actual TIFF file */
-       libtiff_TIFFSetField(image, TIFFTAG_IMAGEWIDTH,      ibuf->x);
-       libtiff_TIFFSetField(image, TIFFTAG_IMAGELENGTH,     ibuf->y);
-       libtiff_TIFFSetField(image, TIFFTAG_ROWSPERSTRIP,    ibuf->y);
-       libtiff_TIFFSetField(image, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
-       libtiff_TIFFSetField(image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
-       libtiff_TIFFSetField(image, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
-       libtiff_TIFFSetField(image, TIFFTAG_XRESOLUTION,     150.0);
-       libtiff_TIFFSetField(image, TIFFTAG_YRESOLUTION,     150.0);
-       libtiff_TIFFSetField(image, TIFFTAG_RESOLUTIONUNIT,  RESUNIT_INCH);
-       if (libtiff_TIFFWriteEncodedStrip(image, 0,
+       TIFFSetField(image, TIFFTAG_IMAGEWIDTH,      ibuf->x);
+       TIFFSetField(image, TIFFTAG_IMAGELENGTH,     ibuf->y);
+       TIFFSetField(image, TIFFTAG_ROWSPERSTRIP,    ibuf->y);
+       TIFFSetField(image, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
+       TIFFSetField(image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
+       TIFFSetField(image, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+
+
+       if(ibuf->ppm[0] > 0.0 && ibuf->ppm[1] > 0.0) {
+               xres= (float)(ibuf->ppm[0] * 0.0254);
+               yres= (float)(ibuf->ppm[1] * 0.0254);
+       }
+       else {
+               xres= yres= 150.0f;
+       }
+
+       TIFFSetField(image, TIFFTAG_XRESOLUTION,     xres);
+       TIFFSetField(image, TIFFTAG_YRESOLUTION,     yres);
+       TIFFSetField(image, TIFFTAG_RESOLUTIONUNIT,  RESUNIT_INCH);
+       if(TIFFWriteEncodedStrip(image, 0,
                        (bitspersample == 16)? (unsigned char*)pixels16: pixels,
                        ibuf->x*ibuf->y*samplesperpixel*bitspersample/8) == -1) {
                fprintf(stderr,
                        "imb_savetiff: Could not write encoded TIFF.\n");
-               libtiff_TIFFClose(image);
-               libtiff__TIFFfree(pixels);
+               TIFFClose(image);
+               if(pixels) _TIFFfree(pixels);
+               if(pixels16) _TIFFfree(pixels16);
                return (1);
        }
 
        /* close the TIFF file */
-       libtiff_TIFFClose(image);
-       libtiff__TIFFfree(pixels);
+       TIFFClose(image);
+       if(pixels) _TIFFfree(pixels);
+       if(pixels16) _TIFFfree(pixels16);
        return (1);
 }
 
+#endif /* WITH_TIFF */