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