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