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