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