diff options
author | Kent Mein <mein@cs.umn.edu> | 2005-11-22 21:50:03 +0300 |
---|---|---|
committer | Kent Mein <mein@cs.umn.edu> | 2005-11-22 21:50:03 +0300 |
commit | 00f266c651a52027b662f725d081af6b51aae343 (patch) | |
tree | 40fd6d4d9a76f1eddcc63e5af6091c1442922dca /source/blender/imbuf/intern/tiff.c | |
parent | b63e26e109ba8c651ea20f553e3ca8e0604fc73f (diff) |
This is a modified version of patch #2995
To enable dynamic tiff support.
I had to fix some of the logic in the fileselect box for icons,
I also expanded the patch to look in various default locations for
a dynamic libtiff.so/libtiff.dll
and look at the env variable BF_TIFF_LIB if it can't find it automatically.
If unable to load the library it prints a message about setting BF_TIFF_LIB
to the console.
I haven't been able to test it on a lot of platforms but hopefully it
will just work ;) I added the files to scons but have not had a chance to
test that as well.
Kent
Diffstat (limited to 'source/blender/imbuf/intern/tiff.c')
-rw-r--r-- | source/blender/imbuf/intern/tiff.c | 528 |
1 files changed, 528 insertions, 0 deletions
diff --git a/source/blender/imbuf/intern/tiff.c b/source/blender/imbuf/intern/tiff.c new file mode 100644 index 00000000000..9f5ecf18dd9 --- /dev/null +++ b/source/blender/imbuf/intern/tiff.c @@ -0,0 +1,528 @@ +/* + * tiff.c + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * 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. + * + * Contributor(s): Jonathan Merritt. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +/** + * Provides TIFF file loading and saving for Blender, via libtiff. + * + * The task of loading is complicated somewhat by the fact that Blender has + * already loaded the file into a memory buffer. libtiff is not well + * configured to handle files in memory, so a client wrapper is written to + * surround the memory and turn it into a virtual file. Currently, reading + * of TIFF files is done using libtiff's RGBAImage support. This is a + * high-level routine that loads all images as 32-bit RGBA, handling all the + * required conversions between many different TIFF types internally. + * + * Saving supports RGB, RGBA and BW (greyscale) images correctly, with + * 8 bits per channel in all cases. The "deflate" compression algorithm is + * used to compress images. + */ + +#include <assert.h> +#include <string.h> + +#include "imbuf.h" +#include "imbuf_patch.h" + +#include "IMB_imbuf_types.h" +#include "IMB_imbuf.h" + +#include "IMB_allocimbuf.h" +#include "IMB_cmap.h" +#include "IMB_tiff.h" + +#include "dynlibtiff.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); +/* Structure for in-memory TIFF file. */ +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)); + + + +/***************************** + * Function implementations. * + *****************************/ + + + +/** + * Reads data from an in-memory TIFF file. + * + * @param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile). + * @param data: Buffer to contain data (treat as void*). + * @param n: Number of bytes to read. + * + * @return: Number of bytes actually read. + * 0 = EOF. + * -1 = Error (never returned). + */ +tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n) +{ + tsize_t nRemaining, nCopy; + struct ImbTIFFMemFile* mfile; + void *srcAddr; + + /* get the pointer to the in-memory file */ + mfile = IMB_TIFF_GET_MEMFILE(handle); + assert(mfile != NULL); + assert(mfile->mem != NULL); + + /* find the actual number of bytes to read (copy) */ + nCopy = n; + if ((tsize_t)mfile->offset >= mfile->size) + nRemaining = 0; + else + nRemaining = mfile->size - mfile->offset; + + if (nCopy > nRemaining) + nCopy = nRemaining; + + /* on EOF, return immediately and read (copy) nothing */ + if (nCopy <= 0) + return (0); + + /* all set -> do the read (copy) */ + assert(sizeof(unsigned char) == 1); + srcAddr = (void*)(&(mfile->mem[mfile->offset])); + memcpy((void*)data, srcAddr, nCopy); + mfile->offset += nCopy; /* advance file ptr by copied bytes */ + return nCopy; +} + + + +/** + * Writes data to an in-memory TIFF file. + * + * 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) +{ + printf("imb_tiff_WriteProc: this function should not be called.\n"); + return (-1); +} + + + +/** + * Seeks to a new location in an in-memory TIFF file. + * + * @param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile). + * @param ofs: Offset value (interpreted according to whence below). + * @param whence: This can be one of three values: + * SEEK_SET - The offset is set to ofs bytes. + * SEEK_CUR - The offset is set to its current location plus ofs bytes. + * SEEK_END - (This is unsupported and will return -1, indicating an + * error). + * + * @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) +{ + struct ImbTIFFMemFile *mfile; + toff_t new_offset; + + /* get the pointer to the in-memory file */ + mfile = IMB_TIFF_GET_MEMFILE(handle); + assert(mfile != NULL); + assert(mfile->mem != NULL); + + /* find the location we plan to seek to */ + switch (whence) { + case SEEK_SET: + new_offset = ofs; + break; + case SEEK_CUR: + new_offset = mfile->offset + ofs; + break; + default: + /* no other types are supported - return an error */ + printf("Unsupported TIFF SEEK type.\n"); + return (-1); + } + + /* set the new location */ + mfile->offset = new_offset; + return mfile->offset; +} + + + +/** + * Closes (virtually) an in-memory TIFF file. + * + * NOTE: All this function actually does is sets the data pointer within the + * TIFF file to NULL. That should trigger assertion errors if attempts + * are made to access the file after that point. However, no such + * attempts should ever be made (in theory). + * + * @param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile). + * + * @return: 0 + */ +int imb_tiff_CloseProc(thandle_t handle) +{ + struct ImbTIFFMemFile *mfile; + + /* get the pointer to the in-memory file */ + mfile = IMB_TIFF_GET_MEMFILE(handle); + assert(mfile != NULL); + assert(mfile->mem != NULL); /* the file has not been closed yet */ + + /* virtually close the file */ + mfile->mem = NULL; + mfile->offset = 0; + mfile->size = 0; + + return (0); +} + + + +/** + * Returns the size of an in-memory TIFF file in bytes. + * + * @return: Size of file (in bytes). + */ +toff_t imb_tiff_SizeProc(thandle_t handle) +{ + struct ImbTIFFMemFile* mfile; + + /* get the pointer to the in-memory file */ + mfile = IMB_TIFF_GET_MEMFILE(handle); + assert(mfile != NULL); + assert(mfile->mem != NULL); + + /* return the size */ + return (toff_t)(mfile->size); +} + + + +/** + * 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 + * respectively are (hex): + * 4d 4d 00 2a + * 49 49 2a 00 + * Note that TIFF files on *any* platform can be either big- or little-endian; + * it's not platform-specific. + * + * AFAICT, libtiff doesn't provide a method to do this automatically, and + * 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) +{ + char big_endian[IMB_TIFF_NCB] = { 0x4d, 0x4d, 0x00, 0x2a }; + char lil_endian[IMB_TIFF_NCB] = { 0x49, 0x49, 0x2a, 0x00 }; + + return ( (memcmp(big_endian, mem, IMB_TIFF_NCB) == 0) || + (memcmp(lil_endian, mem, IMB_TIFF_NCB) == 0) ); +} + + + +/** + * 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. + * @param flags: If flags has IB_test set then the file is not actually loaded, + * but all other operations take place. + * + * @return: A newly allocated ImBuf structure if successful, otherwise NULL. + */ +struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags) +{ + TIFF *image = NULL; + struct ImBuf *ibuf = NULL; + struct ImbTIFFMemFile memFile = { mem, 0, size }; + uint32 width, height; + int bytesperpixel; + int success; + unsigned int pixel_i, byte_i; + uint32 *raster = NULL; + uint32 pixel; + unsigned char *to = NULL; + + /* check whether or not we have a TIFF file */ + assert(size >= IMB_TIFF_NCB); + 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, (TIFFMapFileProc)NULL, + (TIFFUnmapFileProc)NULL); + 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) { + ibuf->ftype = TIF; + } else { + printf("imb_loadtiff: could not allocate memory for TIFF " \ + "image.\n"); + libtiff_TIFFClose(image); + return NULL; + } + + /* read in the image data */ + if (!(flags & IB_test)) { + + /* allocate memory for the ibuf->rect */ + imb_addrectImBuf(ibuf); + + /* 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) { + printf("imb_loadtiff: This TIFF format is not " \ + "currently supported by Blender.\n"); + libtiff__TIFFfree(raster); + libtiff_TIFFClose(image); + return NULL; + } + + /* 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 */ + printf("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); + } + } + + libtiff__TIFFfree(raster); + } + + /* close the client layer interface to the in-memory file */ + libtiff_TIFFClose(image); + + /* return successfully */ + return (ibuf); +} + + + +/** + * Saves a TIFF file. + * + * ImBuf structures with 1, 3 or 4 bytes per pixel (GRAY, RGB, RGBA + * respectively) are accepted, and interpreted correctly. Note that the TIFF + * convention is to use pre-multiplied alpha, which can be achieved within + * Blender by setting "Premul" alpha handling. Other alpha conventions are + * not strictly correct, but are permitted anyhow. + * + * @param ibuf: Image buffer. + * @param name: Name of the TIFF file to create. + * @param flags: Currently largely ignored. + * + * @return: 1 if the function is successful, 0 on failure. + */ +short imb_savetiff(struct ImBuf *ibuf, char *name, int flags) +{ + TIFF *image = NULL; + uint16 samplesperpixel; + size_t npixels; + unsigned char *pixels = NULL; + unsigned char *from = NULL, *to = NULL; + int x, y, from_i, to_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)) { + printf("imb_savetiff: unsupported number of bytes per " \ + "pixel: %d\n", samplesperpixel); + return (0); + } + + /* open TIFF file for writing */ + if (flags & IB_mem) { + /* bork at the creation of a TIFF in memory */ + printf("imb_savetiff: creation of in-memory TIFF files is " \ + "not yet supported.\n"); + return (0); + } else { + /* create image as a file */ + image = libtiff_TIFFOpen(name, "w"); + } + if (image == NULL) { + printf("imb_savetiff: could not open TIFF for writing.\n"); + return (0); + } + + /* allocate array for pixel data */ + npixels = ibuf->x * ibuf->y; + pixels = (unsigned char*)libtiff__TIFFmalloc(npixels * + samplesperpixel * sizeof(unsigned char)); + if (pixels == NULL) { + printf("imb_savetiff: could not allocate pixels array.\n"); + libtiff_TIFFClose(image); + return (0); + } + + /* copy pixel data. While copying, we flip the image + * vertically. */ + from = (unsigned char*)ibuf->rect; + to = pixels; + libtiff_TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel); + switch (samplesperpixel) { + case 4: /* RGBA images, 8 bits per channel */ + libtiff_TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1, + extraSampleTypes); + libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, 8); + libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC, + PHOTOMETRIC_RGB); + for (x = 0; x < ibuf->x; x++) { + for (y = 0; y < ibuf->y; y++) { + from_i = 4*(y*ibuf->x+x); + to_i = 4*((ibuf->y-y-1)*ibuf->x+x); + + to[to_i++] = from[from_i++]; + to[to_i++] = from[from_i++]; + to[to_i++] = from[from_i++]; + to[to_i] = from[from_i]; + } + } + break; + case 3: /* RGB images, 8 bits per channel */ + libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, 8); + libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC, + PHOTOMETRIC_RGB); + for (x = 0; x < ibuf->x; x++) { + for (y = 0; y < ibuf->y; y++) { + from_i = 4*(y*ibuf->x+x); + to_i = 3*((ibuf->y-y-1)*ibuf->x+x); + + to[to_i++] = from[from_i++]; + to[to_i++] = from[from_i++]; + to[to_i] = from[from_i]; + } + } + break; + case 1: /* greyscale images, 1 channel with 8 bits */ + libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, 8); + libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC, + PHOTOMETRIC_MINISBLACK); + for (x = 0; x < ibuf->x; x++) { + for (y = 0; y < ibuf->y; y++) { + from_i = 4*(y*ibuf->x+x); + to_i = 1*((ibuf->y-y-1)*ibuf->x+x); + + to[to_i] = from[from_i]; + } + } + break; + } + + /* 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, pixels, + ibuf->x*ibuf->y*samplesperpixel) == -1) { + printf("imb_savetiff: Could not write encoded TIFF.\n"); + libtiff_TIFFClose(image); + libtiff__TIFFfree(pixels); + return (1); + } + + /* close the TIFF file */ + libtiff_TIFFClose(image); + libtiff__TIFFfree(pixels); + return (1); +} + |