9f5ecf18dd9ff4e8fc5dbf44c721266ce98402c9
[blender-staging.git] / source / blender / imbuf / intern / tiff.c
1 /*
2  * tiff.c
3  *
4  * $Id$
5  * 
6  * ***** BEGIN GPL/BL DUAL 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. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * Contributor(s): Jonathan Merritt.
26  *
27  * ***** END GPL/BL DUAL LICENSE BLOCK *****
28  */
29
30 /**
31  * Provides TIFF file loading and saving for Blender, via libtiff.
32  *
33  * The task of loading is complicated somewhat by the fact that Blender has
34  * already loaded the file into a memory buffer.  libtiff is not well
35  * configured to handle files in memory, so a client wrapper is written to
36  * surround the memory and turn it into a virtual file.  Currently, reading
37  * of TIFF files is done using libtiff's RGBAImage support.  This is a 
38  * high-level routine that loads all images as 32-bit RGBA, handling all the
39  * required conversions between many different TIFF types internally.
40  * 
41  * Saving supports RGB, RGBA and BW (greyscale) images correctly, with
42  * 8 bits per channel in all cases.  The "deflate" compression algorithm is
43  * used to compress images.
44  */
45
46 #include <assert.h>
47 #include <string.h>
48
49 #include "imbuf.h"
50 #include "imbuf_patch.h"
51
52 #include "IMB_imbuf_types.h"
53 #include "IMB_imbuf.h"
54
55 #include "IMB_allocimbuf.h"
56 #include "IMB_cmap.h"
57 #include "IMB_tiff.h"
58
59 #include "dynlibtiff.h"
60
61
62
63 /***********************
64  * Local declarations. *
65  ***********************/
66 /* Reading and writing of an in-memory TIFF file. */
67 tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n);
68 tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n);
69 toff_t  imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence);
70 int     imb_tiff_CloseProc(thandle_t handle);
71 toff_t  imb_tiff_SizeProc(thandle_t handle);
72 /* Structure for in-memory TIFF file. */
73 struct ImbTIFFMemFile {
74         unsigned char *mem;     /* Location of first byte of TIFF file. */
75         toff_t offset;          /* Current offset within the file.      */
76         tsize_t size;           /* Size of the TIFF file.               */
77 };
78 #define IMB_TIFF_GET_MEMFILE(x) ((struct ImbTIFFMemFile*)(x));
79
80
81
82 /*****************************
83  * Function implementations. *
84  *****************************/
85
86
87
88 /**
89  * Reads data from an in-memory TIFF file.
90  *
91  * @param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile).
92  * @param data:   Buffer to contain data (treat as void*).
93  * @param n:      Number of bytes to read.
94  *
95  * @return: Number of bytes actually read.
96  *       0 = EOF.
97  *      -1 = Error (never returned).
98  */
99 tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n)
100 {
101         tsize_t nRemaining, nCopy;
102         struct ImbTIFFMemFile* mfile;
103         void *srcAddr;
104
105         /* get the pointer to the in-memory file */
106         mfile = IMB_TIFF_GET_MEMFILE(handle);
107         assert(mfile != NULL);
108         assert(mfile->mem != NULL);
109
110         /* find the actual number of bytes to read (copy) */
111         nCopy = n;
112         if ((tsize_t)mfile->offset >= mfile->size)
113                 nRemaining = 0;
114         else
115                 nRemaining = mfile->size - mfile->offset;
116         
117         if (nCopy > nRemaining)
118                 nCopy = nRemaining;
119         
120         /* on EOF, return immediately and read (copy) nothing */
121         if (nCopy <= 0)
122                 return (0);
123
124         /* all set -> do the read (copy) */
125         assert(sizeof(unsigned char) == 1);
126         srcAddr = (void*)(&(mfile->mem[mfile->offset]));
127         memcpy((void*)data, srcAddr, nCopy);
128         mfile->offset += nCopy;         /* advance file ptr by copied bytes */
129         return nCopy;
130 }
131
132
133
134 /**
135  * Writes data to an in-memory TIFF file.
136  *
137  * NOTE: The current Blender implementation should not need this function.  It
138  *       is simply a stub.
139  */
140 tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n)
141 {
142         printf("imb_tiff_WriteProc: this function should not be called.\n");
143         return (-1);
144 }
145
146
147
148 /**
149  * Seeks to a new location in an in-memory TIFF file.
150  *
151  * @param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile).
152  * @param ofs:    Offset value (interpreted according to whence below).
153  * @param whence: This can be one of three values:
154  *      SEEK_SET - The offset is set to ofs bytes.
155  *      SEEK_CUR - The offset is set to its current location plus ofs bytes.
156  *      SEEK_END - (This is unsupported and will return -1, indicating an
157  *                  error).
158  *
159  * @return: Resulting offset location within the file, measured in bytes from
160  *          the beginning of the file.  (-1) indicates an error.
161  */
162 toff_t imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence)
163 {
164         struct ImbTIFFMemFile *mfile;
165         toff_t new_offset;
166
167         /* get the pointer to the in-memory file */
168         mfile = IMB_TIFF_GET_MEMFILE(handle);
169         assert(mfile != NULL);
170         assert(mfile->mem != NULL);
171
172         /* find the location we plan to seek to */
173         switch (whence) {
174                 case SEEK_SET:
175                         new_offset = ofs;
176                         break;
177                 case SEEK_CUR:
178                         new_offset = mfile->offset + ofs;
179                         break;
180                 default:
181                         /* no other types are supported - return an error */
182                         printf("Unsupported TIFF SEEK type.\n");
183                         return (-1);
184         }
185
186         /* set the new location */
187         mfile->offset = new_offset;
188         return mfile->offset;
189 }
190
191
192
193 /**
194  * Closes (virtually) an in-memory TIFF file.
195  *
196  * NOTE: All this function actually does is sets the data pointer within the
197  *       TIFF file to NULL.  That should trigger assertion errors if attempts
198  *       are made to access the file after that point.  However, no such
199  *       attempts should ever be made (in theory).
200  *
201  * @param handle: Handle of the TIFF file (pointer to ImbTIFFMemFile).
202  *
203  * @return: 0
204  */
205 int imb_tiff_CloseProc(thandle_t handle)
206 {
207         struct ImbTIFFMemFile *mfile;
208
209         /* get the pointer to the in-memory file */
210         mfile = IMB_TIFF_GET_MEMFILE(handle);
211         assert(mfile != NULL);
212         assert(mfile->mem != NULL);     /* the file has not been closed yet */
213         
214         /* virtually close the file */
215         mfile->mem    = NULL;
216         mfile->offset = 0;
217         mfile->size   = 0;
218         
219         return (0);
220 }
221
222
223
224 /**
225  * Returns the size of an in-memory TIFF file in bytes.
226  *
227  * @return: Size of file (in bytes).
228  */
229 toff_t imb_tiff_SizeProc(thandle_t handle)
230 {
231         struct ImbTIFFMemFile* mfile;
232
233         /* get the pointer to the in-memory file */
234         mfile = IMB_TIFF_GET_MEMFILE(handle);
235         assert(mfile != NULL);
236         assert(mfile->mem != NULL);
237
238         /* return the size */
239         return (toff_t)(mfile->size);
240 }
241
242
243
244 /**
245  * Checks whether a given memory buffer contains a TIFF file.
246  *
247  * FIXME: Possible memory leak if mem is less than IMB_TIFF_NCB bytes long.
248  *        However, changing this will require up-stream modifications.
249  *
250  * This method uses the format identifiers from:
251  *     http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-9.html
252  * The first four bytes of big-endian and little-endian TIFF files
253  * respectively are (hex):
254  *      4d 4d 00 2a
255  *      49 49 2a 00
256  * Note that TIFF files on *any* platform can be either big- or little-endian;
257  * it's not platform-specific.
258  *
259  * AFAICT, libtiff doesn't provide a method to do this automatically, and
260  * hence my manual comparison. - Jonathan Merritt (lancelet) 4th Sept 2005.
261  */
262 #define IMB_TIFF_NCB 4          /* number of comparison bytes used */
263 int imb_is_a_tiff(void *mem)
264 {
265         char big_endian[IMB_TIFF_NCB] = { 0x4d, 0x4d, 0x00, 0x2a };
266         char lil_endian[IMB_TIFF_NCB] = { 0x49, 0x49, 0x2a, 0x00 };
267
268         return ( (memcmp(big_endian, mem, IMB_TIFF_NCB) == 0) ||
269                  (memcmp(lil_endian, mem, IMB_TIFF_NCB) == 0) );
270 }
271
272
273
274 /**
275  * Loads a TIFF file.
276  *
277  * This function uses the "RGBA Image" support from libtiff, which enables
278  * it to load most commonly-encountered TIFF formats.  libtiff handles format
279  * conversion, color depth conversion, etc.
280  *
281  * @param mem:   Memory containing the TIFF file.
282  * @param size:  Size of the mem buffer.
283  * @param flags: If flags has IB_test set then the file is not actually loaded,
284  *                but all other operations take place.
285  *
286  * @return: A newly allocated ImBuf structure if successful, otherwise NULL.
287  */
288 struct ImBuf *imb_loadtiff(unsigned char *mem, int size, int flags)
289 {
290         TIFF *image = NULL;
291         struct ImBuf *ibuf = NULL;
292         struct ImbTIFFMemFile memFile = { mem, 0, size };
293         uint32 width, height;
294         int bytesperpixel;
295         int success;
296         unsigned int pixel_i, byte_i;
297         uint32 *raster = NULL;
298         uint32 pixel;
299         unsigned char *to = NULL;
300
301         /* check whether or not we have a TIFF file */
302         assert(size >= IMB_TIFF_NCB);
303         if (imb_is_a_tiff(mem) == 0)
304                 return NULL;
305
306         /* open the TIFF client layer interface to the in-memory file */
307         image = libtiff_TIFFClientOpen("(Blender TIFF Interface Layer)", 
308                 "r", (thandle_t)(&memFile),
309                 imb_tiff_ReadProc, imb_tiff_WriteProc,
310                 imb_tiff_SeekProc, imb_tiff_CloseProc,
311                 imb_tiff_SizeProc, (TIFFMapFileProc)NULL,
312                 (TIFFUnmapFileProc)NULL);
313         if (image == NULL) {
314                 printf("imb_loadtiff: could not open TIFF IO layer.\n");
315                 return NULL;
316         }
317
318         /* allocate the image buffer */
319         bytesperpixel = 4;  /* 1 byte per channel, 4 channels */
320         libtiff_TIFFGetField(image, TIFFTAG_IMAGEWIDTH,  &width);
321         libtiff_TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
322         ibuf = IMB_allocImBuf(width, height, 8*bytesperpixel, 0, 0);
323         if (ibuf) {
324                 ibuf->ftype = TIF;
325         } else {
326                 printf("imb_loadtiff: could not allocate memory for TIFF " \
327                         "image.\n");
328                 libtiff_TIFFClose(image);
329                 return NULL;
330         }
331
332         /* read in the image data */
333         if (!(flags & IB_test)) {
334
335                 /* allocate memory for the ibuf->rect */
336                 imb_addrectImBuf(ibuf);
337
338                 /* perform actual read */
339                 raster = (uint32*)libtiff__TIFFmalloc(
340                                 width*height * sizeof(uint32));
341                 if (raster == NULL) {
342                         libtiff_TIFFClose(image);
343                         return NULL;
344                 }
345                 success = libtiff_TIFFReadRGBAImage(
346                                 image, width, height, raster, 0);
347                 if (!success) {
348                         printf("imb_loadtiff: This TIFF format is not " \
349                                 "currently supported by Blender.\n");
350                         libtiff__TIFFfree(raster);
351                         libtiff_TIFFClose(image);
352                         return NULL;
353                 }
354
355                 /* copy raster to ibuf->rect; we do a fast copy if possible,
356                  * otherwise revert to a slower component-wise copy */
357                 if (sizeof(unsigned int) == sizeof(uint32)) {
358                         memcpy(ibuf->rect, raster, 
359                                 width*height*sizeof(uint32));
360                 } else {
361                         /* this may not be entirely necessary, but is put here
362                          * in case sizeof(unsigned int) is not a 32-bit
363                          * quantity */
364                         printf("imb_loadtiff: using (slower) component-wise " \
365                                 "buffer copy.\n");
366                         to = (unsigned char*)ibuf->rect;
367                         for (pixel_i=0; pixel_i < width*height; pixel_i++)
368                         {       
369                                 byte_i = sizeof(unsigned int)*pixel_i;
370                                 pixel = raster[pixel_i];
371         
372                                 to[byte_i++] = (unsigned char)TIFFGetR(pixel);
373                                 to[byte_i++] = (unsigned char)TIFFGetG(pixel);
374                                 to[byte_i++] = (unsigned char)TIFFGetB(pixel);
375                                 to[byte_i++] = (unsigned char)TIFFGetA(pixel);
376                         }
377                 }
378
379                 libtiff__TIFFfree(raster);
380         }
381
382         /* close the client layer interface to the in-memory file */
383         libtiff_TIFFClose(image);
384
385         /* return successfully */
386         return (ibuf);
387 }
388
389
390
391 /**
392  * Saves a TIFF file.
393  *
394  * ImBuf structures with 1, 3 or 4 bytes per pixel (GRAY, RGB, RGBA 
395  * respectively) are accepted, and interpreted correctly.  Note that the TIFF
396  * convention is to use pre-multiplied alpha, which can be achieved within
397  * Blender by setting "Premul" alpha handling.  Other alpha conventions are
398  * not strictly correct, but are permitted anyhow.
399  *
400  * @param ibuf:  Image buffer.
401  * @param name:  Name of the TIFF file to create.
402  * @param flags: Currently largely ignored.
403  *
404  * @return: 1 if the function is successful, 0 on failure.
405  */
406 short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
407 {
408         TIFF *image = NULL;
409         uint16 samplesperpixel;
410         size_t npixels;
411         unsigned char *pixels = NULL;
412         unsigned char *from = NULL, *to = NULL;
413         int x, y, from_i, to_i;
414         int extraSampleTypes[1] = { EXTRASAMPLE_ASSOCALPHA };
415
416         /* check for a valid number of bytes per pixel.  Like the PNG writer,
417          * the TIFF writer supports 1, 3 or 4 bytes per pixel, corresponding
418          * to gray, RGB, RGBA respectively. */
419         samplesperpixel = (uint16)((ibuf->depth + 7) >> 3);
420         if ((samplesperpixel > 4) || (samplesperpixel == 2)) {
421                 printf("imb_savetiff: unsupported number of bytes per " \
422                         "pixel: %d\n", samplesperpixel);
423                 return (0);
424         }
425
426         /* open TIFF file for writing */
427         if (flags & IB_mem) {
428                 /* bork at the creation of a TIFF in memory */
429                 printf("imb_savetiff: creation of in-memory TIFF files is " \
430                         "not yet supported.\n");
431                 return (0);
432         } else {
433                 /* create image as a file */
434                 image = libtiff_TIFFOpen(name, "w");
435         }
436         if (image == NULL) {
437                 printf("imb_savetiff: could not open TIFF for writing.\n");
438                 return (0);
439         }
440
441         /* allocate array for pixel data */
442         npixels = ibuf->x * ibuf->y;
443         pixels = (unsigned char*)libtiff__TIFFmalloc(npixels *
444                 samplesperpixel * sizeof(unsigned char));
445         if (pixels == NULL) {
446                 printf("imb_savetiff: could not allocate pixels array.\n");
447                 libtiff_TIFFClose(image);
448                 return (0);
449         }
450
451         /* copy pixel data.  While copying, we flip the image
452          * vertically. */
453         from = (unsigned char*)ibuf->rect;
454         to   = pixels;
455         libtiff_TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
456         switch (samplesperpixel) {
457                 case 4: /* RGBA images, 8 bits per channel */
458                         libtiff_TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1,
459                                         extraSampleTypes);
460                         libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, 8);
461                         libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC, 
462                                         PHOTOMETRIC_RGB);
463                         for (x = 0; x < ibuf->x; x++) {
464                                 for (y = 0; y < ibuf->y; y++) {
465                                         from_i = 4*(y*ibuf->x+x);
466                                         to_i   = 4*((ibuf->y-y-1)*ibuf->x+x);
467
468                                         to[to_i++] = from[from_i++];
469                                         to[to_i++] = from[from_i++];
470                                         to[to_i++] = from[from_i++];
471                                         to[to_i]   = from[from_i];
472                                 }
473                         }
474                         break;
475                 case 3: /* RGB images, 8 bits per channel */
476                         libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, 8);
477                         libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
478                                         PHOTOMETRIC_RGB);
479                         for (x = 0; x < ibuf->x; x++) {
480                                 for (y = 0; y < ibuf->y; y++) {
481                                         from_i = 4*(y*ibuf->x+x);
482                                         to_i   = 3*((ibuf->y-y-1)*ibuf->x+x);
483                                         
484                                         to[to_i++] = from[from_i++];
485                                         to[to_i++] = from[from_i++];
486                                         to[to_i]   = from[from_i];
487                                 }
488                         }
489                         break;
490                 case 1: /* greyscale images, 1 channel with 8 bits */
491                         libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, 8);
492                         libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
493                                         PHOTOMETRIC_MINISBLACK);
494                         for (x = 0; x < ibuf->x; x++) {
495                                 for (y = 0; y < ibuf->y; y++) {
496                                         from_i = 4*(y*ibuf->x+x);
497                                         to_i   = 1*((ibuf->y-y-1)*ibuf->x+x);
498
499                                         to[to_i] = from[from_i];
500                                 }
501                         }
502                         break;
503         }
504
505         /* write the actual TIFF file */
506         libtiff_TIFFSetField(image, TIFFTAG_IMAGEWIDTH,      ibuf->x);
507         libtiff_TIFFSetField(image, TIFFTAG_IMAGELENGTH,     ibuf->y);
508         libtiff_TIFFSetField(image, TIFFTAG_ROWSPERSTRIP,    ibuf->y);
509         libtiff_TIFFSetField(image, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
510         libtiff_TIFFSetField(image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
511         libtiff_TIFFSetField(image, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
512         libtiff_TIFFSetField(image, TIFFTAG_XRESOLUTION,     150.0);
513         libtiff_TIFFSetField(image, TIFFTAG_YRESOLUTION,     150.0);
514         libtiff_TIFFSetField(image, TIFFTAG_RESOLUTIONUNIT,  RESUNIT_INCH);
515         if (libtiff_TIFFWriteEncodedStrip(image, 0, pixels, 
516                         ibuf->x*ibuf->y*samplesperpixel) == -1) {
517                 printf("imb_savetiff: Could not write encoded TIFF.\n");
518                 libtiff_TIFFClose(image);
519                 libtiff__TIFFfree(pixels);
520                 return (1);
521         }
522
523         /* close the TIFF file */
524         libtiff_TIFFClose(image);
525         libtiff__TIFFfree(pixels);
526         return (1);
527 }
528