python api for ID property access by Joseph Eager, copied from blender 2.4x.
[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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 tsize_t imb_tiff_ReadProc(thandle_t handle, tdata_t data, tsize_t n);
66 tsize_t imb_tiff_WriteProc(thandle_t handle, tdata_t data, tsize_t n);
67 toff_t  imb_tiff_SeekProc(thandle_t handle, toff_t ofs, int whence);
68 int     imb_tiff_CloseProc(thandle_t handle);
69 toff_t  imb_tiff_SizeProc(thandle_t handle);
70 int     imb_tiff_DummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize);
71 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 void imb_tiff_DummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
90 {
91 }
92
93 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 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 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 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 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 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         } else {
351                 fprintf(stderr, 
352                         "imb_loadtiff: could not allocate memory for TIFF " \
353                         "image.\n");
354                 libtiff_TIFFClose(image);
355                 return NULL;
356         }
357
358         /* read in the image data */
359         if (!(flags & IB_test)) {
360
361                 /* allocate memory for the ibuf->rect */
362                 imb_addrectImBuf(ibuf);
363
364                 /* perform actual read */
365                 raster = (uint32*)libtiff__TIFFmalloc(
366                                 width*height * sizeof(uint32));
367                 if (raster == NULL) {
368                         libtiff_TIFFClose(image);
369                         return NULL;
370                 }
371                 success = libtiff_TIFFReadRGBAImage(
372                                 image, width, height, raster, 0);
373                 if (!success) {
374                         fprintf(stderr,
375                                 "imb_loadtiff: This TIFF format is not " 
376                                 "currently supported by Blender.\n");
377                         libtiff__TIFFfree(raster);
378                         libtiff_TIFFClose(image);
379                         return NULL;
380                 }
381
382                 /* copy raster to ibuf->rect; we do a fast copy if possible,
383                  * otherwise revert to a slower component-wise copy */
384                 if (sizeof(unsigned int) == sizeof(uint32)) {
385                         memcpy(ibuf->rect, raster, 
386                                 width*height*sizeof(uint32));
387                 } else {
388                         /* this may not be entirely necessary, but is put here
389                          * in case sizeof(unsigned int) is not a 32-bit
390                          * quantity */
391                         fprintf(stderr,
392                                 "imb_loadtiff: using (slower) component-wise "
393                                 "buffer copy.\n");
394                         to = (unsigned char*)ibuf->rect;
395                         for (pixel_i=0; pixel_i < width*height; pixel_i++)
396                         {       
397                                 byte_i = sizeof(unsigned int)*pixel_i;
398                                 pixel = raster[pixel_i];
399         
400                                 to[byte_i++] = (unsigned char)TIFFGetR(pixel);
401                                 to[byte_i++] = (unsigned char)TIFFGetG(pixel);
402                                 to[byte_i++] = (unsigned char)TIFFGetB(pixel);
403                                 to[byte_i++] = (unsigned char)TIFFGetA(pixel);
404                         }
405                 }
406
407                 libtiff__TIFFfree(raster);
408         }
409
410         /* close the client layer interface to the in-memory file */
411         libtiff_TIFFClose(image);
412
413         if (ENDIAN_ORDER == B_ENDIAN) IMB_convert_rgba_to_abgr(ibuf);
414
415         /* return successfully */
416         return (ibuf);
417 }
418
419 /**
420  * Saves a TIFF file.
421  *
422  * ImBuf structures with 1, 3 or 4 bytes per pixel (GRAY, RGB, RGBA 
423  * respectively) are accepted, and interpreted correctly.  Note that the TIFF
424  * convention is to use pre-multiplied alpha, which can be achieved within
425  * Blender by setting "Premul" alpha handling.  Other alpha conventions are
426  * not strictly correct, but are permitted anyhow.
427  *
428  * @param ibuf:  Image buffer.
429  * @param name:  Name of the TIFF file to create.
430  * @param flags: Currently largely ignored.
431  *
432  * @return: 1 if the function is successful, 0 on failure.
433  */
434
435 #define FTOUSHORT(val) ((val >= 1.0f-0.5f/65535)? 65535: (val <= 0.0f)? 0: (unsigned short)(val*65535.0f + 0.5f))
436
437 short imb_savetiff(struct ImBuf *ibuf, char *name, int flags)
438 {
439         TIFF *image = NULL;
440         uint16 samplesperpixel, bitspersample;
441         size_t npixels;
442         unsigned char *pixels = NULL;
443         unsigned char *from = NULL, *to = NULL;
444         unsigned short *pixels16 = NULL, *to16 = NULL;
445         float *fromf = NULL;
446         int x, y, from_i, to_i, i;
447         int extraSampleTypes[1] = { EXTRASAMPLE_ASSOCALPHA };
448
449         /* check for a valid number of bytes per pixel.  Like the PNG writer,
450          * the TIFF writer supports 1, 3 or 4 bytes per pixel, corresponding
451          * to gray, RGB, RGBA respectively. */
452         samplesperpixel = (uint16)((ibuf->depth + 7) >> 3);
453         if ((samplesperpixel > 4) || (samplesperpixel == 2)) {
454                 fprintf(stderr,
455                         "imb_savetiff: unsupported number of bytes per " 
456                         "pixel: %d\n", samplesperpixel);
457                 return (0);
458         }
459
460         if((ibuf->ftype & TIF_16BIT) && ibuf->rect_float)
461                 bitspersample = 16;
462         else
463                 bitspersample = 8;
464
465         /* open TIFF file for writing */
466         if (flags & IB_mem) {
467                 /* bork at the creation of a TIFF in memory */
468                 fprintf(stderr,
469                         "imb_savetiff: creation of in-memory TIFF files is " 
470                         "not yet supported.\n");
471                 return (0);
472         } else {
473                 /* create image as a file */
474                 image = libtiff_TIFFOpen(name, "w");
475         }
476         if (image == NULL) {
477                 fprintf(stderr,
478                         "imb_savetiff: could not open TIFF for writing.\n");
479                 return (0);
480         }
481
482         /* allocate array for pixel data */
483         npixels = ibuf->x * ibuf->y;
484         if(bitspersample == 16)
485                 pixels16 = (unsigned short*)libtiff__TIFFmalloc(npixels *
486                         samplesperpixel * sizeof(unsigned short));
487         else
488                 pixels = (unsigned char*)libtiff__TIFFmalloc(npixels *
489                         samplesperpixel * sizeof(unsigned char));
490
491         if (pixels == NULL && pixels16 == NULL) {
492                 fprintf(stderr,
493                         "imb_savetiff: could not allocate pixels array.\n");
494                 libtiff_TIFFClose(image);
495                 return (0);
496         }
497
498         /* setup pointers */
499         if(bitspersample == 16) {
500                 fromf = ibuf->rect_float;
501                 to16   = pixels16;
502         }
503         else {
504                 from = (unsigned char*)ibuf->rect;
505                 to   = pixels;
506         }
507
508         /* setup samples per pixel */
509         libtiff_TIFFSetField(image, TIFFTAG_BITSPERSAMPLE, bitspersample);
510         libtiff_TIFFSetField(image, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel);
511
512         if(samplesperpixel == 4) {
513                 /* RGBA images */
514                 libtiff_TIFFSetField(image, TIFFTAG_EXTRASAMPLES, 1,
515                                 extraSampleTypes);
516                 libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC, 
517                                 PHOTOMETRIC_RGB);
518         }
519         else if(samplesperpixel == 3) {
520                 /* RGB images */
521                 libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
522                                 PHOTOMETRIC_RGB);
523         }
524         else if(samplesperpixel == 1) {
525                 /* greyscale images, 1 channel */
526                 libtiff_TIFFSetField(image, TIFFTAG_PHOTOMETRIC,
527                                 PHOTOMETRIC_MINISBLACK);
528         }
529
530         /* copy pixel data.  While copying, we flip the image vertically. */
531         for (x = 0; x < ibuf->x; x++) {
532                 for (y = 0; y < ibuf->y; y++) {
533                         from_i = 4*(y*ibuf->x+x);
534                         to_i   = samplesperpixel*((ibuf->y-y-1)*ibuf->x+x);
535
536                         if(pixels16) {
537                                 for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
538                                         to16[to_i] = FTOUSHORT(fromf[from_i]);
539                         }
540                         else {
541                                 for (i = 0; i < samplesperpixel; i++, to_i++, from_i++)
542                                         to[to_i] = from[from_i];
543                         }
544                 }
545         }
546
547         /* write the actual TIFF file */
548         libtiff_TIFFSetField(image, TIFFTAG_IMAGEWIDTH,      ibuf->x);
549         libtiff_TIFFSetField(image, TIFFTAG_IMAGELENGTH,     ibuf->y);
550         libtiff_TIFFSetField(image, TIFFTAG_ROWSPERSTRIP,    ibuf->y);
551         libtiff_TIFFSetField(image, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
552         libtiff_TIFFSetField(image, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB);
553         libtiff_TIFFSetField(image, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
554         libtiff_TIFFSetField(image, TIFFTAG_XRESOLUTION,     150.0);
555         libtiff_TIFFSetField(image, TIFFTAG_YRESOLUTION,     150.0);
556         libtiff_TIFFSetField(image, TIFFTAG_RESOLUTIONUNIT,  RESUNIT_INCH);
557         if (libtiff_TIFFWriteEncodedStrip(image, 0,
558                         (bitspersample == 16)? (unsigned char*)pixels16: pixels,
559                         ibuf->x*ibuf->y*samplesperpixel*bitspersample/8) == -1) {
560                 fprintf(stderr,
561                         "imb_savetiff: Could not write encoded TIFF.\n");
562                 libtiff_TIFFClose(image);
563                 if(pixels) libtiff__TIFFfree(pixels);
564                 if(pixels16) libtiff__TIFFfree(pixels16);
565                 return (1);
566         }
567
568         /* close the TIFF file */
569         libtiff_TIFFClose(image);
570         if(pixels) libtiff__TIFFfree(pixels);
571         if(pixels16) libtiff__TIFFfree(pixels16);
572         return (1);
573 }
574