Various changes:
[imager.git] / tiff.c
1 #include "imager.h"
2 #include "tiffio.h"
3 #include "iolayer.h"
4 #include "imageri.h"
5
6 /*
7 =head1 NAME
8
9 tiff.c - implements reading and writing tiff files, uses io layer.
10
11 =head1 SYNOPSIS
12
13    io_glue *ig = io_new_fd( fd );
14    i_img *im   = i_readtiff_wiol(ig, -1); // no limit on how much is read
15    // or 
16    io_glue *ig = io_new_fd( fd );
17    return_code = i_writetiff_wiol(im, ig); 
18
19 =head1 DESCRIPTION
20
21 tiff.c implements the basic functions to read and write tiff files.
22 It uses the iolayer and needs either a seekable source or an entire
23 memory mapped buffer.
24
25 =head1 FUNCTION REFERENCE
26
27 Some of these functions are internal.
28
29 =over
30
31 =cut
32 */
33
34 #define byteswap_macro(x) \
35      ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) |     \
36       (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
37
38 struct tag_name {
39   char *name;
40   uint32 tag;
41 };
42
43 static struct tag_name text_tag_names[] =
44 {
45   { "tiff_documentname", TIFFTAG_DOCUMENTNAME, },
46   { "tiff_imagedescription", TIFFTAG_IMAGEDESCRIPTION, },
47   { "tiff_make", TIFFTAG_MAKE, },
48   { "tiff_model", TIFFTAG_MODEL, },
49   { "tiff_pagename", TIFFTAG_PAGENAME, },
50   { "tiff_software", TIFFTAG_SOFTWARE, },
51   { "tiff_datetime", TIFFTAG_DATETIME, },
52   { "tiff_artist", TIFFTAG_ARTIST, },
53   { "tiff_hostcomputer", TIFFTAG_HOSTCOMPUTER, },
54 };
55
56 static const int text_tag_count = 
57   sizeof(text_tag_names) / sizeof(*text_tag_names);
58
59 static void error_handler(char const *module, char const *fmt, va_list ap) {
60   i_push_errorvf(0, fmt, ap);
61 }
62
63 #define WARN_BUFFER_LIMIT 10000
64 static char *warn_buffer = NULL;
65 static int warn_buffer_size = 0;
66
67 static void warn_handler(char const *module, char const *fmt, va_list ap) {
68   char buf[1000];
69
70   buf[0] = '\0';
71 #ifdef HAVE_SNPRINTF
72   vsnprintf(buf, sizeof(buf), fmt, ap);
73 #else
74   vsprintf(buf, fmt, ap);
75 #endif
76   if (!warn_buffer || strlen(warn_buffer)+strlen(buf)+2 > warn_buffer_size) {
77     int new_size = warn_buffer_size + strlen(buf) + 2;
78     char *old_buffer = warn_buffer;
79     if (new_size > WARN_BUFFER_LIMIT) {
80       new_size = WARN_BUFFER_LIMIT;
81     }
82     warn_buffer = myrealloc(warn_buffer, new_size);
83     if (!old_buffer) *warn_buffer = '\0';
84     warn_buffer_size = new_size;
85   }
86   if (strlen(warn_buffer)+strlen(buf)+2 <= warn_buffer_size) {
87     strcat(warn_buffer, buf);
88     strcat(warn_buffer, "\n");
89   }
90 }
91
92 static int save_tiff_tags(TIFF *tif, i_img *im);
93
94 static void expand_4bit_hl(unsigned char *buf, int count);
95
96 static void pack_4bit_hl(unsigned char *buf, int count);
97
98
99 static toff_t sizeproc(thandle_t x) {
100         return 0;
101 }
102
103
104 /*
105 =item comp_seek(h, o, w)
106
107 Compatability for 64 bit systems like latest freebsd (internal)
108
109    h - tiff handle, cast an io_glue object
110    o - offset
111    w - whence
112
113 =cut
114 */
115
116 static
117 toff_t
118 comp_seek(thandle_t h, toff_t o, int w) {
119   io_glue *ig = (io_glue*)h;
120   return (toff_t) ig->seekcb(ig, o, w);
121 }
122
123 /*
124 =item comp_mmap(thandle_t, tdata_t*, toff_t*)
125
126 Dummy mmap stub.
127
128 This shouldn't ever be called but newer tifflibs want it anyway.
129
130 =cut
131 */
132
133 static 
134 int
135 comp_mmap(thandle_t h, tdata_t*p, toff_t*off) {
136   return -1;
137 }
138
139 /*
140 =item comp_munmap(thandle_t h, tdata_t p, toff_t off)
141
142 Dummy munmap stub.
143
144 This shouldn't ever be called but newer tifflibs want it anyway.
145
146 =cut
147 */
148
149 static void
150 comp_munmap(thandle_t h, tdata_t p, toff_t off) {
151   /* do nothing */
152 }
153
154 static i_img *read_one_tiff(TIFF *tif, int allow_partial) {
155   i_img *im;
156   uint32 width, height;
157   uint16 channels;
158   uint32* raster = NULL;
159   int tiled, error;
160   float xres, yres;
161   uint16 resunit;
162   int gotXres, gotYres;
163   uint16 photometric;
164   uint16 bits_per_sample;
165   int i;
166   int ch;
167
168   error = 0;
169
170   TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
171   TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
172   TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &channels);
173   tiled = TIFFIsTiled(tif);
174   TIFFGetFieldDefaulted(tif, TIFFTAG_PHOTOMETRIC, &photometric);
175   TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &bits_per_sample);
176
177   mm_log((1, "i_readtiff_wiol: width=%d, height=%d, channels=%d\n", width, height, channels));
178   mm_log((1, "i_readtiff_wiol: %stiled\n", tiled?"":"not "));
179   mm_log((1, "i_readtiff_wiol: %sbyte swapped\n", TIFFIsByteSwapped(tif)?"":"not "));
180
181   /* separated defaults to CMYK, but if the user is using some strange
182      ink system we can't work out the color anyway */
183   if (photometric == PHOTOMETRIC_SEPARATED && channels >= 4) {
184     /* TIFF can have more than one alpha channel on an image,
185        but Imager can't, only store the first one */
186     
187     channels = channels == 4 ? 3 : 4;
188
189     /* unfortunately the RGBA functions don't try to deal with the alpha
190        channel on CMYK images, at some point I'm planning on expanding
191        TIFF support to handle 16-bit/sample images and I'll deal with
192        it then */
193   }
194
195   /* TIFF images can have more than one alpha channel, but Imager can't
196      this ignores the possibility of 2 channel images with 2 alpha,
197      but there's not much I can do about that */
198   if (channels > 4)
199     channels = 4;
200
201   if (photometric == PHOTOMETRIC_PALETTE && bits_per_sample <= 8) {
202     channels = 3;
203     im = i_img_pal_new(width, height, channels, 256);
204   }
205   else {
206     im = i_img_empty_ch(NULL, width, height, channels);
207   }
208
209   if (!im)
210     return NULL;
211
212   /* general metadata */
213   i_tags_addn(&im->tags, "tiff_bitspersample", 0, bits_per_sample);
214   i_tags_addn(&im->tags, "tiff_photometric", 0, photometric);
215     
216   /* resolution tags */
217   TIFFGetFieldDefaulted(tif, TIFFTAG_RESOLUTIONUNIT, &resunit);
218   gotXres = TIFFGetField(tif, TIFFTAG_XRESOLUTION, &xres);
219   gotYres = TIFFGetField(tif, TIFFTAG_YRESOLUTION, &yres);
220   if (gotXres || gotYres) {
221     if (!gotXres)
222       xres = yres;
223     else if (!gotYres)
224       yres = xres;
225     i_tags_addn(&im->tags, "tiff_resolutionunit", 0, resunit);
226     if (resunit == RESUNIT_CENTIMETER) {
227       /* from dots per cm to dpi */
228       xres *= 2.54;
229       yres *= 2.54;
230       i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "centimeter", -1, 0);
231     }
232     else if (resunit == RESUNIT_NONE) {
233       i_tags_addn(&im->tags, "i_aspect_only", 0, 1);
234       i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "none", -1, 0);
235     }
236     else if (resunit == RESUNIT_INCH) {
237       i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "inch", -1, 0);
238     }
239     else {
240       i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "unknown", -1, 0);
241     }
242     /* tifflib doesn't seem to provide a way to get to the original rational
243        value of these, which would let me provide a more reasonable
244        precision. So make up a number. */
245     i_tags_set_float2(&im->tags, "i_xres", 0, xres, 6);
246     i_tags_set_float2(&im->tags, "i_yres", 0, yres, 6);
247   }
248
249   /* Text tags */
250   for (i = 0; i < text_tag_count; ++i) {
251     char *data;
252     if (TIFFGetField(tif, text_tag_names[i].tag, &data)) {
253       mm_log((1, "i_readtiff_wiol: tag %d has value %s\n", 
254               text_tag_names[i].tag, data));
255       i_tags_add(&im->tags, text_tag_names[i].name, 0, data, 
256                  strlen(data), 0);
257     }
258   }
259
260   i_tags_add(&im->tags, "i_format", 0, "tiff", -1, 0);
261   if (warn_buffer && *warn_buffer) {
262     i_tags_add(&im->tags, "i_warning", 0, warn_buffer, -1, 0);
263     *warn_buffer = '\0';
264   }
265   
266   /*   TIFFPrintDirectory(tif, stdout, 0); good for debugging */
267
268   if (photometric == PHOTOMETRIC_PALETTE &&
269       (bits_per_sample == 4 || bits_per_sample == 8)) {
270     uint16 *maps[3];
271     char used[256];
272     int maxused;
273     uint32 row, col;
274     unsigned char *buffer;
275
276     if (!TIFFGetField(tif, TIFFTAG_COLORMAP, maps+0, maps+1, maps+2)) {
277       i_push_error(0, "Cannot get colormap for paletted image");
278       i_img_destroy(im);
279       return NULL;
280     }
281     buffer = (unsigned char *)_TIFFmalloc(width+2);
282     if (!buffer) {
283       i_push_error(0, "out of memory");
284       i_img_destroy(im);
285       return NULL;
286     }
287     row = 0;
288     memset(used, 0, sizeof(used));
289     while (row < height && TIFFReadScanline(tif, buffer, row, 0) > 0) {
290       if (bits_per_sample == 4)
291         expand_4bit_hl(buffer, (width+1)/2);
292       for (col = 0; col < width; ++col) {
293         used[buffer[col]] = 1;
294       }
295       i_ppal(im, 0, width, row, buffer);
296       ++row;
297     }
298     if (row < height) {
299       if (allow_partial) {
300         i_tags_setn(&im->tags, "i_lines_read", row);
301       }
302       else {
303         i_img_destroy(im);
304         _TIFFfree(buffer);
305         return NULL;
306       }
307       error = 1;
308     }
309     /* Ideally we'd optimize the palette, but that could be expensive
310        since we'd have to re-index every pixel.
311
312        Optimizing the palette (even at this level) might not 
313        be what the user wants, so I don't do it.
314
315        We'll add a function to optimize a paletted image instead.
316     */
317     maxused = (1 << bits_per_sample)-1;
318     if (!error) {
319       while (maxused >= 0 && !used[maxused])
320         --maxused;
321     }
322     for (i = 0; i < 1 << bits_per_sample; ++i) {
323       i_color c;
324       for (ch = 0; ch < 3; ++ch) {
325         c.channel[ch] = Sample16To8(maps[ch][i]);
326       }
327       i_addcolors(im, &c, 1);
328     }
329     _TIFFfree(buffer);
330   }
331   else {
332     if (tiled) {
333       int ok = 1;
334       uint32 row, col;
335       uint32 tile_width, tile_height;
336       
337       TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width);
338       TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height);
339       mm_log((1, "i_readtiff_wiol: tile_width=%d, tile_height=%d\n", tile_width, tile_height));
340       
341       raster = (uint32*)_TIFFmalloc(tile_width * tile_height * sizeof (uint32));
342       if (!raster) {
343         i_img_destroy(im);
344         i_push_error(0, "No space for raster buffer");
345         return NULL;
346       }
347       
348       for( row = 0; row < height; row += tile_height ) {
349         for( col = 0; ok && col < width; col += tile_width ) {
350           uint32 i_row, x, newrows, newcols;
351           
352           /* Read the tile into an RGBA array */
353           if (!TIFFReadRGBATile(tif, col, row, raster)) {
354             ok = 0;
355             break;
356           }
357           newrows = (row+tile_height > height) ? height-row : tile_height;
358           mm_log((1, "i_readtiff_wiol: newrows=%d\n", newrows));
359           newcols = (col+tile_width  > width ) ? width-row  : tile_width;
360           for( i_row = 0; i_row < tile_height; i_row++ ) {
361             for(x = 0; x < newcols; x++) {
362               i_color val;
363               uint32 temp = raster[x+tile_width*(tile_height-i_row-1)];
364               val.rgba.r = TIFFGetR(temp);
365               val.rgba.g = TIFFGetG(temp);
366               val.rgba.b = TIFFGetB(temp);
367               val.rgba.a = TIFFGetA(temp);
368               i_ppix(im, col+x, row+i_row, &val);
369             }
370           }
371         }
372       }
373     } else {
374       uint32 rowsperstrip, row;
375       int rc = TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
376       mm_log((1, "i_readtiff_wiol: rowsperstrip=%d rc = %d\n", rowsperstrip, rc));
377   
378                         if (rc != 1 || rowsperstrip==-1) {
379                                 rowsperstrip = height;
380                         }
381     
382       raster = (uint32*)_TIFFmalloc(width * rowsperstrip * sizeof (uint32));
383       if (!raster) {
384         i_img_destroy(im);
385         i_push_error(0, "No space for raster buffer");
386         return NULL;
387       }
388       
389       for( row = 0; row < height; row += rowsperstrip ) {
390         uint32 newrows, i_row;
391         
392         if (!TIFFReadRGBAStrip(tif, row, raster)) {
393           if (allow_partial) {
394             i_tags_setn(&im->tags, "i_lines_read", row);
395             error++;
396             break;
397           }
398           else {
399             i_push_error(0, "could not read TIFF image strip");
400             _TIFFfree(raster);
401             i_img_destroy(im);
402             return NULL;
403           }
404         }
405         
406         newrows = (row+rowsperstrip > height) ? height-row : rowsperstrip;
407         mm_log((1, "newrows=%d\n", newrows));
408         
409         for( i_row = 0; i_row < newrows; i_row++ ) { 
410           uint32 x;
411           for(x = 0; x<width; x++) {
412             i_color val;
413             uint32 temp = raster[x+width*(newrows-i_row-1)];
414             val.rgba.r = TIFFGetR(temp);
415             val.rgba.g = TIFFGetG(temp);
416             val.rgba.b = TIFFGetB(temp);
417             val.rgba.a = TIFFGetA(temp);
418             i_ppix(im, x, i_row+row, &val);
419           }
420         }
421       }
422     }
423   }
424   if (error) {
425     mm_log((1, "i_readtiff_wiol: error during reading\n"));
426     i_tags_setn(&im->tags, "i_incomplete", 1);
427   }
428   if (raster)
429     _TIFFfree( raster );
430
431   return im;
432 }
433
434 /*
435 =item i_readtiff_wiol(im, ig)
436
437 =cut
438 */
439 i_img*
440 i_readtiff_wiol(io_glue *ig, int allow_partial, int page) {
441   TIFF* tif;
442   TIFFErrorHandler old_handler;
443   TIFFErrorHandler old_warn_handler;
444   i_img *im;
445
446   i_clear_error();
447   old_handler = TIFFSetErrorHandler(error_handler);
448   old_warn_handler = TIFFSetWarningHandler(warn_handler);
449   if (warn_buffer)
450     *warn_buffer = '\0';
451
452   /* Add code to get the filename info from the iolayer */
453   /* Also add code to check for mmapped code */
454
455   io_glue_commit_types(ig);
456   mm_log((1, "i_readtiff_wiol(ig %p, allow_partial %d, page %d)\n", ig, allow_partial, page));
457   
458   tif = TIFFClientOpen("(Iolayer)", 
459                        "rm", 
460                        (thandle_t) ig,
461                        (TIFFReadWriteProc) ig->readcb,
462                        (TIFFReadWriteProc) ig->writecb,
463                        (TIFFSeekProc) comp_seek,
464                        (TIFFCloseProc) ig->closecb,
465                        ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc,
466                        (TIFFMapFileProc) comp_mmap,
467                        (TIFFUnmapFileProc) comp_munmap);
468   
469   if (!tif) {
470     mm_log((1, "i_readtiff_wiol: Unable to open tif file\n"));
471     i_push_error(0, "Error opening file");
472     TIFFSetErrorHandler(old_handler);
473     TIFFSetWarningHandler(old_warn_handler);
474     return NULL;
475   }
476
477   if (page != 0) {
478     if (!TIFFSetDirectory(tif, page)) {
479       mm_log((1, "i_readtiff_wiol: Unable to switch to directory %d\n", page));
480       i_push_errorf(0, "could not switch to page %d", page);
481       TIFFSetErrorHandler(old_handler);
482       TIFFSetWarningHandler(old_warn_handler);
483       TIFFClose(tif);
484       return NULL;
485     }
486   }
487
488   im = read_one_tiff(tif, allow_partial);
489
490   if (TIFFLastDirectory(tif)) mm_log((1, "Last directory of tiff file\n"));
491   TIFFSetErrorHandler(old_handler);
492   TIFFSetWarningHandler(old_warn_handler);
493   TIFFClose(tif);
494   return im;
495 }
496
497 /*
498 =item i_readtiff_multi_wiol(ig, length, *count)
499
500 Reads multiple images from a TIFF.
501
502 =cut
503 */
504 i_img**
505 i_readtiff_multi_wiol(io_glue *ig, int length, int *count) {
506   TIFF* tif;
507   TIFFErrorHandler old_handler;
508   TIFFErrorHandler old_warn_handler;
509   i_img **results = NULL;
510   int result_alloc = 0;
511   int dirnum = 0;
512
513   i_clear_error();
514   old_handler = TIFFSetErrorHandler(error_handler);
515   old_warn_handler = TIFFSetWarningHandler(warn_handler);
516   if (warn_buffer)
517     *warn_buffer = '\0';
518
519   /* Add code to get the filename info from the iolayer */
520   /* Also add code to check for mmapped code */
521
522   io_glue_commit_types(ig);
523   mm_log((1, "i_readtiff_wiol(ig %p, length %d)\n", ig, length));
524   
525   tif = TIFFClientOpen("(Iolayer)", 
526                        "rm", 
527                        (thandle_t) ig,
528                        (TIFFReadWriteProc) ig->readcb,
529                        (TIFFReadWriteProc) ig->writecb,
530                        (TIFFSeekProc) comp_seek,
531                        (TIFFCloseProc) ig->closecb,
532                        ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc,
533                        (TIFFMapFileProc) comp_mmap,
534                        (TIFFUnmapFileProc) comp_munmap);
535   
536   if (!tif) {
537     mm_log((1, "i_readtiff_wiol: Unable to open tif file\n"));
538     i_push_error(0, "Error opening file");
539     TIFFSetErrorHandler(old_handler);
540     TIFFSetWarningHandler(old_warn_handler);
541     return NULL;
542   }
543
544   *count = 0;
545   do {
546     i_img *im = read_one_tiff(tif, 0);
547     if (!im)
548       break;
549     if (++*count > result_alloc) {
550       if (result_alloc == 0) {
551         result_alloc = 5;
552         results = mymalloc(result_alloc * sizeof(i_img *));
553       }
554       else {
555         i_img **newresults;
556         result_alloc *= 2;
557         newresults = myrealloc(results, result_alloc * sizeof(i_img *));
558         if (!newresults) {
559           i_img_destroy(im); /* don't leak it */
560           break;
561         }
562         results = newresults;
563       }
564     }
565     results[*count-1] = im;
566   } while (TIFFSetDirectory(tif, ++dirnum));
567
568   TIFFSetWarningHandler(old_warn_handler);
569   TIFFSetErrorHandler(old_handler);
570   TIFFClose(tif);
571   return results;
572 }
573
574 undef_int
575 i_writetiff_low_faxable(TIFF *tif, i_img *im, int fine) {
576   uint32 width, height;
577   unsigned char *linebuf = NULL;
578   uint32 y;
579   int rc;
580   uint32 x;
581   uint32 rowsperstrip;
582   float vres = fine ? 196 : 98;
583   int luma_chan;
584
585   width    = im->xsize;
586   height   = im->ysize;
587
588   switch (im->channels) {
589   case 1:
590   case 2:
591     luma_chan = 0;
592     break;
593   case 3:
594   case 4:
595     luma_chan = 1;
596     break;
597   default:
598     /* This means a colorspace we don't handle yet */
599     mm_log((1, "i_writetiff_wiol_faxable: don't handle %d channel images.\n", im->channels));
600     return 0;
601   }
602
603   /* Add code to get the filename info from the iolayer */
604   /* Also add code to check for mmapped code */
605
606
607   mm_log((1, "i_writetiff_wiol_faxable: width=%d, height=%d, channels=%d\n", width, height, im->channels));
608   
609   if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH,      width)   )
610     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField width=%d failed\n", width)); return 0; }
611   if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH,     height)  )
612     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField length=%d failed\n", height)); return 0; }
613   if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1))
614     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField samplesperpixel=1 failed\n")); return 0; }
615   if (!TIFFSetField(tif, TIFFTAG_ORIENTATION,  ORIENTATION_TOPLEFT))
616     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField Orientation=topleft\n")); return 0; }
617   if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE,   1)        )
618     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField bitpersample=1\n")); return 0; }
619   if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG))
620     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField planarconfig\n")); return 0; }
621   if (!TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE))
622     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField photometric=%d\n", PHOTOMETRIC_MINISBLACK)); return 0; }
623   if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, 3))
624     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField compression=3\n")); return 0; }
625
626   linebuf = (unsigned char *)_TIFFmalloc( TIFFScanlineSize(tif) );
627   
628   if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(tif, -1))) {
629     mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField rowsperstrip=-1\n")); return 0; }
630
631   TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
632   TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rc);
633
634   mm_log((1, "i_writetiff_wiol_faxable: TIFFGetField rowsperstrip=%d\n", rowsperstrip));
635   mm_log((1, "i_writetiff_wiol_faxable: TIFFGetField scanlinesize=%d\n", TIFFScanlineSize(tif) ));
636   mm_log((1, "i_writetiff_wiol_faxable: TIFFGetField planarconfig=%d == %d\n", rc, PLANARCONFIG_CONTIG));
637
638   if (!TIFFSetField(tif, TIFFTAG_XRESOLUTION, (float)204))
639     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField Xresolution=204\n")); return 0; }
640   if (!TIFFSetField(tif, TIFFTAG_YRESOLUTION, vres))
641     { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField Yresolution=196\n")); return 0; }
642   if (!TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH)) {
643     mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField ResolutionUnit=%d\n", RESUNIT_INCH)); return 0; 
644   }
645
646   if (!save_tiff_tags(tif, im)) {
647     return 0;
648   }
649
650   for (y=0; y<height; y++) {
651     int linebufpos=0;
652     for(x=0; x<width; x+=8) { 
653       int bits;
654       int bitpos;
655       i_sample_t luma[8];
656       uint8 bitval = 128;
657       linebuf[linebufpos]=0;
658       bits = width-x; if(bits>8) bits=8;
659       i_gsamp(im, x, x+8, y, luma, &luma_chan, 1);
660       for(bitpos=0;bitpos<bits;bitpos++) {
661         linebuf[linebufpos] |= ((luma[bitpos] < 128) ? bitval : 0);
662         bitval >>= 1;
663       }
664       linebufpos++;
665     }
666     if (TIFFWriteScanline(tif, linebuf, y, 0) < 0) {
667       mm_log((1, "i_writetiff_wiol_faxable: TIFFWriteScanline failed.\n"));
668       break;
669     }
670   }
671   if (linebuf) _TIFFfree(linebuf);
672
673   return 1;
674 }
675
676 undef_int
677 i_writetiff_low(TIFF *tif, i_img *im) {
678   uint32 width, height;
679   uint16 channels;
680   uint16 predictor = 0;
681   int quality = 75;
682   int jpegcolormode = JPEGCOLORMODE_RGB;
683   uint16 compression = COMPRESSION_PACKBITS;
684   i_color val;
685   uint16 photometric;
686   uint32 rowsperstrip = (uint32) -1;  /* Let library pick default */
687   unsigned char *linebuf = NULL;
688   uint32 y;
689   tsize_t linebytes;
690   int ch, ci, rc;
691   uint32 x;
692   int got_xres, got_yres, aspect_only, resunit;
693   double xres, yres;
694   uint16 bitspersample = 8;
695   uint16 samplesperpixel;
696   uint16 *colors = NULL;
697
698   width    = im->xsize;
699   height   = im->ysize;
700   channels = im->channels;
701
702   switch (channels) {
703   case 1:
704     photometric = PHOTOMETRIC_MINISBLACK;
705     break;
706   case 3:
707     photometric = PHOTOMETRIC_RGB;
708     if (compression == COMPRESSION_JPEG && jpegcolormode == JPEGCOLORMODE_RGB) photometric = PHOTOMETRIC_YCBCR;
709     else if (im->type == i_palette_type) {
710       photometric = PHOTOMETRIC_PALETTE;
711     }
712     break;
713   default:
714     /* This means a colorspace we don't handle yet */
715     mm_log((1, "i_writetiff_wiol: don't handle %d channel images.\n", channels));
716     return 0;
717   }
718
719   /* Add code to get the filename info from the iolayer */
720   /* Also add code to check for mmapped code */
721
722   /*io_glue_commit_types(ig);*/
723   /*mm_log((1, "i_writetiff_wiol(im 0x%p, ig 0x%p)\n", im, ig));*/
724
725   mm_log((1, "i_writetiff_low: width=%d, height=%d, channels=%d\n", width, height, channels));
726   
727   if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH,      width)   ) { 
728     mm_log((1, "i_writetiff_wiol: TIFFSetField width=%d failed\n", width)); 
729     return 0; 
730   }
731   if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH,     height)  ) { 
732     mm_log((1, "i_writetiff_wiol: TIFFSetField length=%d failed\n", height)); 
733     return 0; 
734   }
735   if (!TIFFSetField(tif, TIFFTAG_ORIENTATION,  ORIENTATION_TOPLEFT)) {
736     mm_log((1, "i_writetiff_wiol: TIFFSetField Orientation=topleft\n")); 
737     return 0; 
738   }
739   if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) { 
740     mm_log((1, "i_writetiff_wiol: TIFFSetField planarconfig\n")); 
741     return 0; 
742   }
743   if (!TIFFSetField(tif, TIFFTAG_PHOTOMETRIC,   photometric)) { 
744     mm_log((1, "i_writetiff_wiol: TIFFSetField photometric=%d\n", photometric)); 
745     return 0; 
746   }
747   if (!TIFFSetField(tif, TIFFTAG_COMPRESSION,   compression)) { 
748     mm_log((1, "i_writetiff_wiol: TIFFSetField compression=%d\n", compression)); 
749     return 0; 
750   }
751   samplesperpixel = channels;
752   if (photometric == PHOTOMETRIC_PALETTE) {
753     uint16 *out[3];
754     i_color c;
755     int count = i_colorcount(im);
756     int size;
757     int ch, i;
758     
759     samplesperpixel = 1;
760     if (count > 16)
761       bitspersample = 8;
762     else
763       bitspersample = 4;
764     size = 1 << bitspersample;
765     colors = (uint16 *)_TIFFmalloc(sizeof(uint16) * 3 * size);
766     out[0] = colors;
767     out[1] = colors + size;
768     out[2] = colors + 2 * size;
769     
770     for (i = 0; i < count; ++i) {
771       i_getcolors(im, i, &c, 1);
772       for (ch = 0; ch < 3; ++ch)
773         out[ch][i] = c.channel[ch] * 257;
774     }
775     for (; i < size; ++i) {
776       for (ch = 0; ch < 3; ++ch)
777         out[ch][i] = 0;
778     }
779     if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample)) { 
780       mm_log((1, "i_writetiff_wiol: TIFFSetField bitpersample=%d\n", 
781               bitspersample)); 
782       return 0;
783     }
784     if (!TIFFSetField(tif, TIFFTAG_COLORMAP, out[0], out[1], out[2])) {
785       mm_log((1, "i_writetiff_wiol: TIFFSetField colormap\n")); 
786       return 0;
787     }
788   }
789   else {
790     if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample)) { 
791       mm_log((1, "i_writetiff_wiol: TIFFSetField bitpersample=%d\n", 
792               bitspersample)); 
793       return 0;
794     }
795   }
796   if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel)) { 
797     mm_log((1, "i_writetiff_wiol: TIFFSetField samplesperpixel=%d failed\n", samplesperpixel)); 
798     return 0;
799   }
800
801   switch (compression) {
802   case COMPRESSION_JPEG:
803     mm_log((1, "i_writetiff_wiol: jpeg compression\n"));
804     if (!TIFFSetField(tif, TIFFTAG_JPEGQUALITY, quality)        ) { 
805       mm_log((1, "i_writetiff_wiol: TIFFSetField jpegquality=%d\n", quality));
806       return 0; 
807     }
808     if (!TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, jpegcolormode)) { 
809       mm_log((1, "i_writetiff_wiol: TIFFSetField jpegcolormode=%d\n", jpegcolormode)); 
810       return 0; 
811     }
812     break;
813   case COMPRESSION_LZW:
814     mm_log((1, "i_writetiff_wiol: lzw compression\n"));
815     break;
816   case COMPRESSION_DEFLATE:
817     mm_log((1, "i_writetiff_wiol: deflate compression\n"));
818     if (predictor != 0) 
819       if (!TIFFSetField(tif, TIFFTAG_PREDICTOR, predictor)) { 
820         mm_log((1, "i_writetiff_wiol: TIFFSetField predictor=%d\n", predictor)); 
821         return 0; 
822       }
823     break;
824   case COMPRESSION_PACKBITS:
825     mm_log((1, "i_writetiff_wiol: packbits compression\n"));
826     break;
827   default:
828     mm_log((1, "i_writetiff_wiol: unknown compression %d\n", compression));
829     return 0;
830   }
831   
832   linebytes = channels * width;
833   linebytes = TIFFScanlineSize(tif) > linebytes ? linebytes 
834     : TIFFScanlineSize(tif);
835   /* working space for the scanlines - we go from 8-bit/pixel to 4 */
836   if (photometric == PHOTOMETRIC_PALETTE && bitspersample == 4)
837     linebytes += linebytes + 1;
838   linebuf = (unsigned char *)_TIFFmalloc(linebytes);
839   
840   if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(tif, rowsperstrip))) {
841     mm_log((1, "i_writetiff_wiol: TIFFSetField rowsperstrip=%d\n", rowsperstrip)); return 0; }
842
843   TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
844   TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rc);
845
846   mm_log((1, "i_writetiff_wiol: TIFFGetField rowsperstrip=%d\n", rowsperstrip));
847   mm_log((1, "i_writetiff_wiol: TIFFGetField scanlinesize=%d\n", TIFFScanlineSize(tif) ));
848   mm_log((1, "i_writetiff_wiol: TIFFGetField planarconfig=%d == %d\n", rc, PLANARCONFIG_CONTIG));
849   mm_log((1, "i_writetiff_wiol: bitspersample = %d\n", bitspersample));
850
851   got_xres = i_tags_get_float(&im->tags, "i_xres", 0, &xres);
852   got_yres = i_tags_get_float(&im->tags, "i_yres", 0, &yres);
853   if (!i_tags_get_int(&im->tags, "i_aspect_only", 0,&aspect_only))
854     aspect_only = 0;
855   if (!i_tags_get_int(&im->tags, "tiff_resolutionunit", 0, &resunit))
856     resunit = RESUNIT_INCH;
857   if (got_xres || got_yres) {
858     if (!got_xres)
859       xres = yres;
860     else if (!got_yres)
861       yres = xres;
862     if (aspect_only) {
863       resunit = RESUNIT_NONE;
864     }
865     else {
866       if (resunit == RESUNIT_CENTIMETER) {
867         xres /= 2.54;
868         yres /= 2.54;
869       }
870       else {
871         resunit  = RESUNIT_INCH;
872       }
873     }
874     if (!TIFFSetField(tif, TIFFTAG_XRESOLUTION, (float)xres)) {
875       i_push_error(0, "cannot set TIFFTAG_XRESOLUTION tag");
876       return 0;
877     }
878     if (!TIFFSetField(tif, TIFFTAG_YRESOLUTION, (float)yres)) {
879       i_push_error(0, "cannot set TIFFTAG_YRESOLUTION tag");
880       return 0;
881     }
882     if (!TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, (uint16)resunit)) {
883       i_push_error(0, "cannot set TIFFTAG_RESOLUTIONUNIT tag");
884       return 0;
885     }
886   }
887
888   if (!save_tiff_tags(tif, im)) {
889     return 0;
890   }
891
892   if (photometric == PHOTOMETRIC_PALETTE) {
893     for (y = 0; y < height; ++y) {
894       i_gpal(im, 0, width, y, linebuf);
895       if (bitspersample == 4)
896         pack_4bit_hl(linebuf, width);
897       if (TIFFWriteScanline(tif, linebuf, y, 0) < 0) {
898         mm_log((1, "i_writetiff_wiol: TIFFWriteScanline failed.\n"));
899         if (linebuf) _TIFFfree(linebuf);
900         if (colors) _TIFFfree(colors);
901         return 0;
902       }
903     }
904   }
905   else {
906     for (y=0; y<height; y++) {
907       ci = 0;
908       for(x=0; x<width; x++) { 
909         (void) i_gpix(im, x, y,&val);
910         for(ch=0; ch<channels; ch++) 
911           linebuf[ci++] = val.channel[ch];
912       }
913       if (TIFFWriteScanline(tif, linebuf, y, 0) < 0) {
914         mm_log((1, "i_writetiff_wiol: TIFFWriteScanline failed.\n"));
915         if (linebuf) _TIFFfree(linebuf);
916         if (colors) _TIFFfree(colors);
917         return 0;
918       }
919     }
920   }
921   if (linebuf) _TIFFfree(linebuf);
922   if (colors) _TIFFfree(colors);
923   return 1;
924 }
925
926 /*
927 =item i_writetiff_multi_wiol(ig, imgs, count, fine_mode)
928
929 Stores an image in the iolayer object.
930
931    ig - io_object that defines source to write to 
932    imgs,count - the images to write
933
934 =cut 
935 */
936
937 undef_int
938 i_writetiff_multi_wiol(io_glue *ig, i_img **imgs, int count) {
939   TIFF* tif;
940   TIFFErrorHandler old_handler;
941   int i;
942
943   old_handler = TIFFSetErrorHandler(error_handler);
944
945   io_glue_commit_types(ig);
946   i_clear_error();
947   mm_log((1, "i_writetiff_multi_wiol(ig 0x%p, imgs 0x%p, count %d)\n", 
948           ig, imgs, count));
949
950   /* FIXME: Enable the mmap interface */
951   
952   tif = TIFFClientOpen("No name", 
953                        "wm",
954                        (thandle_t) ig, 
955                        (TIFFReadWriteProc) ig->readcb,
956                        (TIFFReadWriteProc) ig->writecb,
957                        (TIFFSeekProc)      comp_seek,
958                        (TIFFCloseProc)     ig->closecb, 
959                        ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc,
960                        (TIFFMapFileProc)   comp_mmap,
961                        (TIFFUnmapFileProc) comp_munmap);
962   
963
964
965   if (!tif) {
966     mm_log((1, "i_writetiff_multi_wiol: Unable to open tif file for writing\n"));
967     i_push_error(0, "Could not create TIFF object");
968     TIFFSetErrorHandler(old_handler);
969     return 0;
970   }
971
972   for (i = 0; i < count; ++i) {
973     if (!i_writetiff_low(tif, imgs[i])) {
974       TIFFClose(tif);
975       TIFFSetErrorHandler(old_handler);
976       return 0;
977     }
978
979     if (!TIFFWriteDirectory(tif)) {
980       i_push_error(0, "Cannot write TIFF directory");
981       TIFFClose(tif);
982       TIFFSetErrorHandler(old_handler);
983       return 0;
984     }
985   }
986
987   TIFFSetErrorHandler(old_handler);
988   (void) TIFFClose(tif);
989
990   return 1;
991 }
992
993 /*
994 =item i_writetiff_multi_wiol_faxable(ig, imgs, count, fine_mode)
995
996 Stores an image in the iolayer object.
997
998    ig - io_object that defines source to write to 
999    imgs,count - the images to write
1000    fine_mode - select fine or normal mode fax images
1001
1002 =cut 
1003 */
1004
1005
1006 undef_int
1007 i_writetiff_multi_wiol_faxable(io_glue *ig, i_img **imgs, int count, int fine) {
1008   TIFF* tif;
1009   int i;
1010   TIFFErrorHandler old_handler;
1011
1012   old_handler = TIFFSetErrorHandler(error_handler);
1013
1014   io_glue_commit_types(ig);
1015   i_clear_error();
1016   mm_log((1, "i_writetiff_multi_wiol(ig 0x%p, imgs 0x%p, count %d)\n", 
1017           ig, imgs, count));
1018
1019   /* FIXME: Enable the mmap interface */
1020   
1021   tif = TIFFClientOpen("No name", 
1022                        "wm",
1023                        (thandle_t) ig, 
1024                        (TIFFReadWriteProc) ig->readcb,
1025                        (TIFFReadWriteProc) ig->writecb,
1026                        (TIFFSeekProc)      comp_seek,
1027                        (TIFFCloseProc)     ig->closecb, 
1028                        ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc,
1029                        (TIFFMapFileProc)   comp_mmap,
1030                        (TIFFUnmapFileProc) comp_munmap);
1031   
1032
1033
1034   if (!tif) {
1035     mm_log((1, "i_writetiff_mulit_wiol: Unable to open tif file for writing\n"));
1036     i_push_error(0, "Could not create TIFF object");
1037     TIFFSetErrorHandler(old_handler);
1038     return 0;
1039   }
1040
1041   for (i = 0; i < count; ++i) {
1042     if (!i_writetiff_low_faxable(tif, imgs[i], fine)) {
1043       TIFFClose(tif);
1044       TIFFSetErrorHandler(old_handler);
1045       return 0;
1046     }
1047
1048     if (!TIFFWriteDirectory(tif)) {
1049       i_push_error(0, "Cannot write TIFF directory");
1050       TIFFClose(tif);
1051       TIFFSetErrorHandler(old_handler);
1052       return 0;
1053     }
1054   }
1055
1056   (void) TIFFClose(tif);
1057   TIFFSetErrorHandler(old_handler);
1058
1059   return 1;
1060 }
1061
1062 /*
1063 =item i_writetiff_wiol(im, ig)
1064
1065 Stores an image in the iolayer object.
1066
1067    im - image object to write out
1068    ig - io_object that defines source to write to 
1069
1070 =cut 
1071 */
1072 undef_int
1073 i_writetiff_wiol(i_img *img, io_glue *ig) {
1074   TIFF* tif;
1075   TIFFErrorHandler old_handler;
1076
1077   old_handler = TIFFSetErrorHandler(error_handler);
1078
1079   io_glue_commit_types(ig);
1080   i_clear_error();
1081   mm_log((1, "i_writetiff_wiol(img %p, ig 0x%p)\n", img, ig));
1082
1083   /* FIXME: Enable the mmap interface */
1084
1085   tif = TIFFClientOpen("No name", 
1086                        "wm",
1087                        (thandle_t) ig, 
1088                        (TIFFReadWriteProc) ig->readcb,
1089                        (TIFFReadWriteProc) ig->writecb,
1090                        (TIFFSeekProc)      comp_seek,
1091                        (TIFFCloseProc)     ig->closecb, 
1092                        ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc,
1093                        (TIFFMapFileProc)   comp_mmap,
1094                        (TIFFUnmapFileProc) comp_munmap);
1095   
1096
1097
1098   if (!tif) {
1099     mm_log((1, "i_writetiff_wiol: Unable to open tif file for writing\n"));
1100     i_push_error(0, "Could not create TIFF object");
1101     TIFFSetErrorHandler(old_handler);
1102     return 0;
1103   }
1104
1105   if (!i_writetiff_low(tif, img)) {
1106     TIFFClose(tif);
1107     TIFFSetErrorHandler(old_handler);
1108     return 0;
1109   }
1110
1111   (void) TIFFClose(tif);
1112   TIFFSetErrorHandler(old_handler);
1113
1114   return 1;
1115 }
1116
1117
1118
1119 /*
1120 =item i_writetiff_wiol_faxable(i_img *, io_glue *)
1121
1122 Stores an image in the iolayer object in faxable tiff format.
1123
1124    im - image object to write out
1125    ig - io_object that defines source to write to 
1126
1127 Note, this may be rewritten to use to simply be a call to a
1128 lower-level function that gives more options for writing tiff at some
1129 point.
1130
1131 =cut
1132 */
1133
1134 undef_int
1135 i_writetiff_wiol_faxable(i_img *im, io_glue *ig, int fine) {
1136   TIFF* tif;
1137   TIFFErrorHandler old_handler;
1138
1139   old_handler = TIFFSetErrorHandler(error_handler);
1140
1141   io_glue_commit_types(ig);
1142   i_clear_error();
1143   mm_log((1, "i_writetiff_wiol(img %p, ig 0x%p)\n", im, ig));
1144
1145   /* FIXME: Enable the mmap interface */
1146   
1147   tif = TIFFClientOpen("No name", 
1148                        "wm",
1149                        (thandle_t) ig, 
1150                        (TIFFReadWriteProc) ig->readcb,
1151                        (TIFFReadWriteProc) ig->writecb,
1152                        (TIFFSeekProc)      comp_seek,
1153                        (TIFFCloseProc)     ig->closecb, 
1154                        ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc,
1155                        (TIFFMapFileProc)   comp_mmap,
1156                        (TIFFUnmapFileProc) comp_munmap);
1157   
1158
1159
1160   if (!tif) {
1161     mm_log((1, "i_writetiff_wiol: Unable to open tif file for writing\n"));
1162     i_push_error(0, "Could not create TIFF object");
1163     TIFFSetErrorHandler(old_handler);
1164     return 0;
1165   }
1166
1167   if (!i_writetiff_low_faxable(tif, im, fine)) {
1168     TIFFClose(tif);
1169     TIFFSetErrorHandler(old_handler);
1170     return 0;
1171   }
1172
1173   (void) TIFFClose(tif);
1174   TIFFSetErrorHandler(old_handler);
1175
1176   return 1;
1177 }
1178
1179 static int save_tiff_tags(TIFF *tif, i_img *im) {
1180   int i;
1181  
1182   for (i = 0; i < text_tag_count; ++i) {
1183     int entry;
1184     if (i_tags_find(&im->tags, text_tag_names[i].name, 0, &entry)) {
1185       if (!TIFFSetField(tif, text_tag_names[i].tag, 
1186                        im->tags.tags[entry].data)) {
1187        i_push_errorf(0, "cannot save %s to TIFF", text_tag_names[i].name);
1188        return 0;
1189       }
1190     }
1191   }
1192  
1193   return 1;
1194 }
1195
1196
1197 /*
1198 =item expand_4bit_hl(buf, count)
1199
1200 Expands 4-bit/entry packed data into 1 byte/entry.
1201
1202 buf must contain count bytes to be expanded and have 2*count bytes total 
1203 space.
1204
1205 The data is expanded in place.
1206
1207 =cut
1208 */
1209
1210 static void expand_4bit_hl(unsigned char *buf, int count) {
1211   while (--count >= 0) {
1212     buf[count*2+1] = buf[count] & 0xF;
1213     buf[count*2] = buf[count] >> 4;
1214   }
1215 }
1216
1217 static void pack_4bit_hl(unsigned char *buf, int count) {
1218   int i = 0;
1219   while (i < count) {
1220     buf[i/2] = (buf[i] << 4) + buf[i+1];
1221     i += 2;
1222   }
1223 }
1224
1225 /*
1226 =back
1227
1228 =head1 AUTHOR
1229
1230 Arnar M. Hrafnkelsson <addi@umich.edu>
1231
1232 =head1 SEE ALSO
1233
1234 Imager(3)
1235
1236 =cut
1237 */