]>
Commit | Line | Data |
---|---|---|
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) { | |
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 | if (photometric == PHOTOMETRIC_PALETTE && bits_per_sample <= 8) { | |
182 | channels = 3; | |
183 | im = i_img_pal_new(width, height, channels, 256); | |
184 | } | |
185 | else { | |
186 | im = i_img_empty_ch(NULL, width, height, channels); | |
187 | } | |
188 | ||
189 | if (!im) | |
190 | return NULL; | |
191 | ||
192 | /* general metadata */ | |
193 | i_tags_addn(&im->tags, "tiff_bitspersample", 0, bits_per_sample); | |
194 | i_tags_addn(&im->tags, "tiff_photometric", 0, photometric); | |
195 | ||
196 | /* resolution tags */ | |
197 | TIFFGetFieldDefaulted(tif, TIFFTAG_RESOLUTIONUNIT, &resunit); | |
198 | gotXres = TIFFGetField(tif, TIFFTAG_XRESOLUTION, &xres); | |
199 | gotYres = TIFFGetField(tif, TIFFTAG_YRESOLUTION, &yres); | |
200 | if (gotXres || gotYres) { | |
201 | if (!gotXres) | |
202 | xres = yres; | |
203 | else if (!gotYres) | |
204 | yres = xres; | |
205 | i_tags_addn(&im->tags, "tiff_resolutionunit", 0, resunit); | |
206 | if (resunit == RESUNIT_CENTIMETER) { | |
207 | /* from dots per cm to dpi */ | |
208 | xres *= 2.54; | |
209 | yres *= 2.54; | |
210 | i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "centimeter", -1, 0); | |
211 | } | |
212 | else if (resunit == RESUNIT_NONE) { | |
213 | i_tags_addn(&im->tags, "i_aspect_only", 0, 1); | |
214 | i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "none", -1, 0); | |
215 | } | |
216 | else if (resunit == RESUNIT_INCH) { | |
217 | i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "inch", -1, 0); | |
218 | } | |
219 | else { | |
220 | i_tags_add(&im->tags, "tiff_resolutionunit_name", 0, "unknown", -1, 0); | |
221 | } | |
222 | /* tifflib doesn't seem to provide a way to get to the original rational | |
223 | value of these, which would let me provide a more reasonable | |
224 | precision. So make up a number. */ | |
225 | i_tags_set_float2(&im->tags, "i_xres", 0, xres, 6); | |
226 | i_tags_set_float2(&im->tags, "i_yres", 0, yres, 6); | |
227 | } | |
228 | ||
229 | /* Text tags */ | |
230 | for (i = 0; i < text_tag_count; ++i) { | |
231 | char *data; | |
232 | if (TIFFGetField(tif, text_tag_names[i].tag, &data)) { | |
233 | mm_log((1, "i_readtiff_wiol: tag %d has value %s\n", | |
234 | text_tag_names[i].tag, data)); | |
235 | i_tags_add(&im->tags, text_tag_names[i].name, 0, data, | |
236 | strlen(data), 0); | |
237 | } | |
238 | } | |
239 | ||
240 | i_tags_add(&im->tags, "i_format", 0, "tiff", -1, 0); | |
241 | if (warn_buffer && *warn_buffer) { | |
242 | i_tags_add(&im->tags, "i_warning", 0, warn_buffer, -1, 0); | |
243 | *warn_buffer = '\0'; | |
244 | } | |
245 | ||
246 | /* TIFFPrintDirectory(tif, stdout, 0); good for debugging */ | |
247 | ||
248 | if (photometric == PHOTOMETRIC_PALETTE && | |
249 | (bits_per_sample == 4 || bits_per_sample == 8)) { | |
250 | uint16 *maps[3]; | |
251 | char used[256]; | |
252 | int maxused; | |
253 | uint32 row, col; | |
254 | unsigned char *buffer; | |
255 | ||
256 | if (!TIFFGetField(tif, TIFFTAG_COLORMAP, maps+0, maps+1, maps+2)) { | |
257 | i_push_error(0, "Cannot get colormap for paletted image"); | |
258 | i_img_destroy(im); | |
259 | return NULL; | |
260 | } | |
261 | buffer = (unsigned char *)_TIFFmalloc(width+2); | |
262 | if (!buffer) { | |
263 | i_push_error(0, "out of memory"); | |
264 | i_img_destroy(im); | |
265 | return NULL; | |
266 | } | |
267 | row = 0; | |
268 | memset(used, 0, sizeof(used)); | |
269 | while (row < height && TIFFReadScanline(tif, buffer, row, 0) > 0) { | |
270 | if (bits_per_sample == 4) | |
271 | expand_4bit_hl(buffer, (width+1)/2); | |
272 | for (col = 0; col < width; ++col) { | |
273 | used[buffer[col]] = 1; | |
274 | } | |
275 | i_ppal(im, 0, width, row, buffer); | |
276 | ++row; | |
277 | } | |
278 | if (row < height) { | |
279 | error = 1; | |
280 | } | |
281 | /* Ideally we'd optimize the palette, but that could be expensive | |
282 | since we'd have to re-index every pixel. | |
283 | ||
284 | Optimizing the palette (even at this level) might not | |
285 | be what the user wants, so I don't do it. | |
286 | ||
287 | We'll add a function to optimize a paletted image instead. | |
288 | */ | |
289 | maxused = (1 << bits_per_sample)-1; | |
290 | if (!error) { | |
291 | while (maxused >= 0 && !used[maxused]) | |
292 | --maxused; | |
293 | } | |
294 | for (i = 0; i < 1 << bits_per_sample; ++i) { | |
295 | i_color c; | |
296 | for (ch = 0; ch < 3; ++ch) { | |
297 | c.channel[ch] = Sample16To8(maps[ch][i]); | |
298 | } | |
299 | i_addcolors(im, &c, 1); | |
300 | } | |
301 | _TIFFfree(buffer); | |
302 | } | |
303 | else { | |
304 | if (tiled) { | |
305 | int ok = 1; | |
306 | uint32 row, col; | |
307 | uint32 tile_width, tile_height; | |
308 | ||
309 | TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tile_width); | |
310 | TIFFGetField(tif, TIFFTAG_TILELENGTH, &tile_height); | |
311 | mm_log((1, "i_readtiff_wiol: tile_width=%d, tile_height=%d\n", tile_width, tile_height)); | |
312 | ||
313 | raster = (uint32*)_TIFFmalloc(tile_width * tile_height * sizeof (uint32)); | |
314 | if (!raster) { | |
315 | i_img_destroy(im); | |
316 | i_push_error(0, "No space for raster buffer"); | |
317 | return NULL; | |
318 | } | |
319 | ||
320 | for( row = 0; row < height; row += tile_height ) { | |
321 | for( col = 0; ok && col < width; col += tile_width ) { | |
322 | uint32 i_row, x, newrows, newcols; | |
323 | ||
324 | /* Read the tile into an RGBA array */ | |
325 | if (!TIFFReadRGBATile(tif, col, row, raster)) { | |
326 | ok = 0; | |
327 | break; | |
328 | } | |
329 | newrows = (row+tile_height > height) ? height-row : tile_height; | |
330 | mm_log((1, "i_readtiff_wiol: newrows=%d\n", newrows)); | |
331 | newcols = (col+tile_width > width ) ? width-row : tile_width; | |
332 | for( i_row = 0; i_row < tile_height; i_row++ ) { | |
333 | for(x = 0; x < newcols; x++) { | |
334 | i_color val; | |
335 | uint32 temp = raster[x+tile_width*(tile_height-i_row-1)]; | |
336 | val.rgba.r = TIFFGetR(temp); | |
337 | val.rgba.g = TIFFGetG(temp); | |
338 | val.rgba.b = TIFFGetB(temp); | |
339 | val.rgba.a = TIFFGetA(temp); | |
340 | i_ppix(im, col+x, row+i_row, &val); | |
341 | } | |
342 | } | |
343 | } | |
344 | } | |
345 | } else { | |
346 | uint32 rowsperstrip, row; | |
347 | int rc = TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); | |
348 | mm_log((1, "i_readtiff_wiol: rowsperstrip=%d rc = %d\n", rowsperstrip, rc)); | |
349 | ||
350 | if (rc != 1 || rowsperstrip==-1) { | |
351 | rowsperstrip = height; | |
352 | } | |
353 | ||
354 | raster = (uint32*)_TIFFmalloc(width * rowsperstrip * sizeof (uint32)); | |
355 | if (!raster) { | |
356 | i_img_destroy(im); | |
357 | i_push_error(0, "No space for raster buffer"); | |
358 | return NULL; | |
359 | } | |
360 | ||
361 | for( row = 0; row < height; row += rowsperstrip ) { | |
362 | uint32 newrows, i_row; | |
363 | ||
364 | if (!TIFFReadRGBAStrip(tif, row, raster)) { | |
365 | error++; | |
366 | break; | |
367 | } | |
368 | ||
369 | newrows = (row+rowsperstrip > height) ? height-row : rowsperstrip; | |
370 | mm_log((1, "newrows=%d\n", newrows)); | |
371 | ||
372 | for( i_row = 0; i_row < newrows; i_row++ ) { | |
373 | uint32 x; | |
374 | for(x = 0; x<width; x++) { | |
375 | i_color val; | |
376 | uint32 temp = raster[x+width*(newrows-i_row-1)]; | |
377 | val.rgba.r = TIFFGetR(temp); | |
378 | val.rgba.g = TIFFGetG(temp); | |
379 | val.rgba.b = TIFFGetB(temp); | |
380 | val.rgba.a = TIFFGetA(temp); | |
381 | i_ppix(im, x, i_row+row, &val); | |
382 | } | |
383 | } | |
384 | } | |
385 | } | |
386 | } | |
387 | if (error) { | |
388 | mm_log((1, "i_readtiff_wiol: error during reading\n")); | |
389 | i_tags_addn(&im->tags, "i_incomplete", 0, 1); | |
390 | } | |
391 | if (raster) | |
392 | _TIFFfree( raster ); | |
393 | ||
394 | return im; | |
395 | } | |
396 | ||
397 | /* | |
398 | =item i_readtiff_wiol(im, ig) | |
399 | ||
400 | =cut | |
401 | */ | |
402 | i_img* | |
403 | i_readtiff_wiol(io_glue *ig, int length, int page) { | |
404 | TIFF* tif; | |
405 | TIFFErrorHandler old_handler; | |
406 | TIFFErrorHandler old_warn_handler; | |
407 | i_img *im; | |
408 | ||
409 | i_clear_error(); | |
410 | old_handler = TIFFSetErrorHandler(error_handler); | |
411 | old_warn_handler = TIFFSetWarningHandler(warn_handler); | |
412 | if (warn_buffer) | |
413 | *warn_buffer = '\0'; | |
414 | ||
415 | /* Add code to get the filename info from the iolayer */ | |
416 | /* Also add code to check for mmapped code */ | |
417 | ||
418 | io_glue_commit_types(ig); | |
419 | mm_log((1, "i_readtiff_wiol(ig %p, length %d)\n", ig, length)); | |
420 | ||
421 | tif = TIFFClientOpen("(Iolayer)", | |
422 | "rm", | |
423 | (thandle_t) ig, | |
424 | (TIFFReadWriteProc) ig->readcb, | |
425 | (TIFFReadWriteProc) ig->writecb, | |
426 | (TIFFSeekProc) comp_seek, | |
427 | (TIFFCloseProc) ig->closecb, | |
428 | ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc, | |
429 | (TIFFMapFileProc) comp_mmap, | |
430 | (TIFFUnmapFileProc) comp_munmap); | |
431 | ||
432 | if (!tif) { | |
433 | mm_log((1, "i_readtiff_wiol: Unable to open tif file\n")); | |
434 | i_push_error(0, "opening file"); | |
435 | TIFFSetErrorHandler(old_handler); | |
436 | TIFFSetWarningHandler(old_warn_handler); | |
437 | return NULL; | |
438 | } | |
439 | ||
440 | if (page != 0) { | |
441 | if (!TIFFSetDirectory(tif, page)) { | |
442 | mm_log((1, "i_readtiff_wiol: Unable to switch to directory %d\n", page)); | |
443 | i_push_errorf(0, "could not switch to page %d", page); | |
444 | TIFFSetErrorHandler(old_handler); | |
445 | TIFFSetWarningHandler(old_warn_handler); | |
446 | return NULL; | |
447 | } | |
448 | } | |
449 | ||
450 | im = read_one_tiff(tif); | |
451 | ||
452 | if (TIFFLastDirectory(tif)) mm_log((1, "Last directory of tiff file\n")); | |
453 | TIFFSetErrorHandler(old_handler); | |
454 | TIFFSetWarningHandler(old_warn_handler); | |
455 | TIFFClose(tif); | |
456 | return im; | |
457 | } | |
458 | ||
459 | /* | |
460 | =item i_readtiff_multi_wiol(ig, length, *count) | |
461 | ||
462 | Reads multiple images from a TIFF. | |
463 | ||
464 | =cut | |
465 | */ | |
466 | i_img** | |
467 | i_readtiff_multi_wiol(io_glue *ig, int length, int *count) { | |
468 | TIFF* tif; | |
469 | TIFFErrorHandler old_handler; | |
470 | TIFFErrorHandler old_warn_handler; | |
471 | i_img **results = NULL; | |
472 | int result_alloc = 0; | |
473 | int dirnum = 0; | |
474 | ||
475 | i_clear_error(); | |
476 | old_handler = TIFFSetErrorHandler(error_handler); | |
477 | old_warn_handler = TIFFSetWarningHandler(warn_handler); | |
478 | if (warn_buffer) | |
479 | *warn_buffer = '\0'; | |
480 | ||
481 | /* Add code to get the filename info from the iolayer */ | |
482 | /* Also add code to check for mmapped code */ | |
483 | ||
484 | io_glue_commit_types(ig); | |
485 | mm_log((1, "i_readtiff_wiol(ig %p, length %d)\n", ig, length)); | |
486 | ||
487 | tif = TIFFClientOpen("(Iolayer)", | |
488 | "rm", | |
489 | (thandle_t) ig, | |
490 | (TIFFReadWriteProc) ig->readcb, | |
491 | (TIFFReadWriteProc) ig->writecb, | |
492 | (TIFFSeekProc) comp_seek, | |
493 | (TIFFCloseProc) ig->closecb, | |
494 | ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc, | |
495 | (TIFFMapFileProc) comp_mmap, | |
496 | (TIFFUnmapFileProc) comp_munmap); | |
497 | ||
498 | if (!tif) { | |
499 | mm_log((1, "i_readtiff_wiol: Unable to open tif file\n")); | |
500 | i_push_error(0, "opening file"); | |
501 | TIFFSetErrorHandler(old_handler); | |
502 | TIFFSetWarningHandler(old_warn_handler); | |
503 | return NULL; | |
504 | } | |
505 | ||
506 | *count = 0; | |
507 | do { | |
508 | i_img *im = read_one_tiff(tif); | |
509 | if (!im) | |
510 | break; | |
511 | if (++*count > result_alloc) { | |
512 | if (result_alloc == 0) { | |
513 | result_alloc = 5; | |
514 | results = mymalloc(result_alloc * sizeof(i_img *)); | |
515 | } | |
516 | else { | |
517 | i_img **newresults; | |
518 | result_alloc *= 2; | |
519 | newresults = myrealloc(results, result_alloc * sizeof(i_img *)); | |
520 | if (!newresults) { | |
521 | i_img_destroy(im); /* don't leak it */ | |
522 | break; | |
523 | } | |
524 | results = newresults; | |
525 | } | |
526 | } | |
527 | results[*count-1] = im; | |
528 | } while (TIFFSetDirectory(tif, ++dirnum)); | |
529 | ||
530 | TIFFSetWarningHandler(old_warn_handler); | |
531 | TIFFSetErrorHandler(old_handler); | |
532 | TIFFClose(tif); | |
533 | return results; | |
534 | } | |
535 | ||
536 | undef_int | |
537 | i_writetiff_low_faxable(TIFF *tif, i_img *im, int fine) { | |
538 | uint32 width, height; | |
539 | unsigned char *linebuf = NULL; | |
540 | uint32 y; | |
541 | int rc; | |
542 | uint32 x; | |
543 | uint32 rowsperstrip; | |
544 | float vres = fine ? 196 : 98; | |
545 | int luma_chan; | |
546 | ||
547 | width = im->xsize; | |
548 | height = im->ysize; | |
549 | ||
550 | switch (im->channels) { | |
551 | case 1: | |
552 | case 2: | |
553 | luma_chan = 0; | |
554 | break; | |
555 | case 3: | |
556 | case 4: | |
557 | luma_chan = 1; | |
558 | break; | |
559 | default: | |
560 | /* This means a colorspace we don't handle yet */ | |
561 | mm_log((1, "i_writetiff_wiol_faxable: don't handle %d channel images.\n", im->channels)); | |
562 | return 0; | |
563 | } | |
564 | ||
565 | /* Add code to get the filename info from the iolayer */ | |
566 | /* Also add code to check for mmapped code */ | |
567 | ||
568 | ||
569 | mm_log((1, "i_writetiff_wiol_faxable: width=%d, height=%d, channels=%d\n", width, height, im->channels)); | |
570 | ||
571 | if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width) ) | |
572 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField width=%d failed\n", width)); return 0; } | |
573 | if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height) ) | |
574 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField length=%d failed\n", height)); return 0; } | |
575 | if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1)) | |
576 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField samplesperpixel=1 failed\n")); return 0; } | |
577 | if (!TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT)) | |
578 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField Orientation=topleft\n")); return 0; } | |
579 | if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 1) ) | |
580 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField bitpersample=1\n")); return 0; } | |
581 | if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) | |
582 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField planarconfig\n")); return 0; } | |
583 | if (!TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK)) | |
584 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField photometric=%d\n", PHOTOMETRIC_MINISBLACK)); return 0; } | |
585 | if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, 3)) | |
586 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField compression=3\n")); return 0; } | |
587 | ||
588 | linebuf = (unsigned char *)_TIFFmalloc( TIFFScanlineSize(tif) ); | |
589 | ||
590 | if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(tif, -1))) { | |
591 | mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField rowsperstrip=-1\n")); return 0; } | |
592 | ||
593 | TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); | |
594 | TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rc); | |
595 | ||
596 | mm_log((1, "i_writetiff_wiol_faxable: TIFFGetField rowsperstrip=%d\n", rowsperstrip)); | |
597 | mm_log((1, "i_writetiff_wiol_faxable: TIFFGetField scanlinesize=%d\n", TIFFScanlineSize(tif) )); | |
598 | mm_log((1, "i_writetiff_wiol_faxable: TIFFGetField planarconfig=%d == %d\n", rc, PLANARCONFIG_CONTIG)); | |
599 | ||
600 | if (!TIFFSetField(tif, TIFFTAG_XRESOLUTION, (float)204)) | |
601 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField Xresolution=204\n")); return 0; } | |
602 | if (!TIFFSetField(tif, TIFFTAG_YRESOLUTION, vres)) | |
603 | { mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField Yresolution=196\n")); return 0; } | |
604 | if (!TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH)) { | |
605 | mm_log((1, "i_writetiff_wiol_faxable: TIFFSetField ResolutionUnit=%d\n", RESUNIT_INCH)); return 0; | |
606 | } | |
607 | ||
608 | if (!save_tiff_tags(tif, im)) { | |
609 | return 0; | |
610 | } | |
611 | ||
612 | for (y=0; y<height; y++) { | |
613 | int linebufpos=0; | |
614 | for(x=0; x<width; x+=8) { | |
615 | int bits; | |
616 | int bitpos; | |
617 | i_sample_t luma[8]; | |
618 | uint8 bitval = 128; | |
619 | linebuf[linebufpos]=0; | |
620 | bits = width-x; if(bits>8) bits=8; | |
621 | i_gsamp(im, x, x+8, y, luma, &luma_chan, 1); | |
622 | for(bitpos=0;bitpos<bits;bitpos++) { | |
623 | linebuf[linebufpos] |= ((luma[bitpos]>=128)?bitval:0); | |
624 | bitval >>= 1; | |
625 | } | |
626 | linebufpos++; | |
627 | } | |
628 | if (TIFFWriteScanline(tif, linebuf, y, 0) < 0) { | |
629 | mm_log((1, "i_writetiff_wiol_faxable: TIFFWriteScanline failed.\n")); | |
630 | break; | |
631 | } | |
632 | } | |
633 | if (linebuf) _TIFFfree(linebuf); | |
634 | ||
635 | return 1; | |
636 | } | |
637 | ||
638 | undef_int | |
639 | i_writetiff_low(TIFF *tif, i_img *im) { | |
640 | uint32 width, height; | |
641 | uint16 channels; | |
642 | uint16 predictor = 0; | |
643 | int quality = 75; | |
644 | int jpegcolormode = JPEGCOLORMODE_RGB; | |
645 | uint16 compression = COMPRESSION_PACKBITS; | |
646 | i_color val; | |
647 | uint16 photometric; | |
648 | uint32 rowsperstrip = (uint32) -1; /* Let library pick default */ | |
649 | unsigned char *linebuf = NULL; | |
650 | uint32 y; | |
651 | tsize_t linebytes; | |
652 | int ch, ci, rc; | |
653 | uint32 x; | |
654 | int got_xres, got_yres, aspect_only, resunit; | |
655 | double xres, yres; | |
656 | uint16 bitspersample = 8; | |
657 | uint16 samplesperpixel; | |
658 | uint16 *colors = NULL; | |
659 | ||
660 | width = im->xsize; | |
661 | height = im->ysize; | |
662 | channels = im->channels; | |
663 | ||
664 | switch (channels) { | |
665 | case 1: | |
666 | photometric = PHOTOMETRIC_MINISBLACK; | |
667 | break; | |
668 | case 3: | |
669 | photometric = PHOTOMETRIC_RGB; | |
670 | if (compression == COMPRESSION_JPEG && jpegcolormode == JPEGCOLORMODE_RGB) photometric = PHOTOMETRIC_YCBCR; | |
671 | else if (im->type == i_palette_type) { | |
672 | photometric = PHOTOMETRIC_PALETTE; | |
673 | } | |
674 | break; | |
675 | default: | |
676 | /* This means a colorspace we don't handle yet */ | |
677 | mm_log((1, "i_writetiff_wiol: don't handle %d channel images.\n", channels)); | |
678 | return 0; | |
679 | } | |
680 | ||
681 | /* Add code to get the filename info from the iolayer */ | |
682 | /* Also add code to check for mmapped code */ | |
683 | ||
684 | /*io_glue_commit_types(ig);*/ | |
685 | /*mm_log((1, "i_writetiff_wiol(im 0x%p, ig 0x%p)\n", im, ig));*/ | |
686 | ||
687 | mm_log((1, "i_writetiff_low: width=%d, height=%d, channels=%d\n", width, height, channels)); | |
688 | ||
689 | if (!TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width) ) { | |
690 | mm_log((1, "i_writetiff_wiol: TIFFSetField width=%d failed\n", width)); | |
691 | return 0; | |
692 | } | |
693 | if (!TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height) ) { | |
694 | mm_log((1, "i_writetiff_wiol: TIFFSetField length=%d failed\n", height)); | |
695 | return 0; | |
696 | } | |
697 | if (!TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT)) { | |
698 | mm_log((1, "i_writetiff_wiol: TIFFSetField Orientation=topleft\n")); | |
699 | return 0; | |
700 | } | |
701 | if (!TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) { | |
702 | mm_log((1, "i_writetiff_wiol: TIFFSetField planarconfig\n")); | |
703 | return 0; | |
704 | } | |
705 | if (!TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, photometric)) { | |
706 | mm_log((1, "i_writetiff_wiol: TIFFSetField photometric=%d\n", photometric)); | |
707 | return 0; | |
708 | } | |
709 | if (!TIFFSetField(tif, TIFFTAG_COMPRESSION, compression)) { | |
710 | mm_log((1, "i_writetiff_wiol: TIFFSetField compression=%d\n", compression)); | |
711 | return 0; | |
712 | } | |
713 | samplesperpixel = channels; | |
714 | if (photometric == PHOTOMETRIC_PALETTE) { | |
715 | uint16 *out[3]; | |
716 | i_color c; | |
717 | int count = i_colorcount(im); | |
718 | int size; | |
719 | int ch, i; | |
720 | ||
721 | samplesperpixel = 1; | |
722 | if (count > 16) | |
723 | bitspersample = 8; | |
724 | else | |
725 | bitspersample = 4; | |
726 | size = 1 << bitspersample; | |
727 | colors = (uint16 *)_TIFFmalloc(sizeof(uint16) * 3 * size); | |
728 | out[0] = colors; | |
729 | out[1] = colors + size; | |
730 | out[2] = colors + 2 * size; | |
731 | ||
732 | for (i = 0; i < count; ++i) { | |
733 | i_getcolors(im, i, &c, 1); | |
734 | for (ch = 0; ch < 3; ++ch) | |
735 | out[ch][i] = c.channel[ch] * 257; | |
736 | } | |
737 | for (; i < size; ++i) { | |
738 | for (ch = 0; ch < 3; ++ch) | |
739 | out[ch][i] = 0; | |
740 | } | |
741 | if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample)) { | |
742 | mm_log((1, "i_writetiff_wiol: TIFFSetField bitpersample=%d\n", | |
743 | bitspersample)); | |
744 | return 0; | |
745 | } | |
746 | if (!TIFFSetField(tif, TIFFTAG_COLORMAP, out[0], out[1], out[2])) { | |
747 | mm_log((1, "i_writetiff_wiol: TIFFSetField colormap\n")); | |
748 | return 0; | |
749 | } | |
750 | } | |
751 | else { | |
752 | if (!TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample)) { | |
753 | mm_log((1, "i_writetiff_wiol: TIFFSetField bitpersample=%d\n", | |
754 | bitspersample)); | |
755 | return 0; | |
756 | } | |
757 | } | |
758 | if (!TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samplesperpixel)) { | |
759 | mm_log((1, "i_writetiff_wiol: TIFFSetField samplesperpixel=%d failed\n", samplesperpixel)); | |
760 | return 0; | |
761 | } | |
762 | ||
763 | switch (compression) { | |
764 | case COMPRESSION_JPEG: | |
765 | mm_log((1, "i_writetiff_wiol: jpeg compression\n")); | |
766 | if (!TIFFSetField(tif, TIFFTAG_JPEGQUALITY, quality) ) { | |
767 | mm_log((1, "i_writetiff_wiol: TIFFSetField jpegquality=%d\n", quality)); | |
768 | return 0; | |
769 | } | |
770 | if (!TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, jpegcolormode)) { | |
771 | mm_log((1, "i_writetiff_wiol: TIFFSetField jpegcolormode=%d\n", jpegcolormode)); | |
772 | return 0; | |
773 | } | |
774 | break; | |
775 | case COMPRESSION_LZW: | |
776 | mm_log((1, "i_writetiff_wiol: lzw compression\n")); | |
777 | break; | |
778 | case COMPRESSION_DEFLATE: | |
779 | mm_log((1, "i_writetiff_wiol: deflate compression\n")); | |
780 | if (predictor != 0) | |
781 | if (!TIFFSetField(tif, TIFFTAG_PREDICTOR, predictor)) { | |
782 | mm_log((1, "i_writetiff_wiol: TIFFSetField predictor=%d\n", predictor)); | |
783 | return 0; | |
784 | } | |
785 | break; | |
786 | case COMPRESSION_PACKBITS: | |
787 | mm_log((1, "i_writetiff_wiol: packbits compression\n")); | |
788 | break; | |
789 | default: | |
790 | mm_log((1, "i_writetiff_wiol: unknown compression %d\n", compression)); | |
791 | return 0; | |
792 | } | |
793 | ||
794 | linebytes = channels * width; | |
795 | linebytes = TIFFScanlineSize(tif) > linebytes ? linebytes | |
796 | : TIFFScanlineSize(tif); | |
797 | /* working space for the scanlines - we go from 8-bit/pixel to 4 */ | |
798 | if (photometric == PHOTOMETRIC_PALETTE && bitspersample == 4) | |
799 | linebytes += linebytes + 1; | |
800 | linebuf = (unsigned char *)_TIFFmalloc(linebytes); | |
801 | ||
802 | if (!TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(tif, rowsperstrip))) { | |
803 | mm_log((1, "i_writetiff_wiol: TIFFSetField rowsperstrip=%d\n", rowsperstrip)); return 0; } | |
804 | ||
805 | TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip); | |
806 | TIFFGetField(tif, TIFFTAG_ROWSPERSTRIP, &rc); | |
807 | ||
808 | mm_log((1, "i_writetiff_wiol: TIFFGetField rowsperstrip=%d\n", rowsperstrip)); | |
809 | mm_log((1, "i_writetiff_wiol: TIFFGetField scanlinesize=%d\n", TIFFScanlineSize(tif) )); | |
810 | mm_log((1, "i_writetiff_wiol: TIFFGetField planarconfig=%d == %d\n", rc, PLANARCONFIG_CONTIG)); | |
811 | mm_log((1, "i_writetiff_wiol: bitspersample = %d\n", bitspersample)); | |
812 | ||
813 | got_xres = i_tags_get_float(&im->tags, "i_xres", 0, &xres); | |
814 | got_yres = i_tags_get_float(&im->tags, "i_yres", 0, &yres); | |
815 | if (!i_tags_get_int(&im->tags, "i_aspect_only", 0,&aspect_only)) | |
816 | aspect_only = 0; | |
817 | if (!i_tags_get_int(&im->tags, "tiff_resolutionunit", 0, &resunit)) | |
818 | resunit = RESUNIT_INCH; | |
819 | if (got_xres || got_yres) { | |
820 | if (!got_xres) | |
821 | xres = yres; | |
822 | else if (!got_yres) | |
823 | yres = xres; | |
824 | if (aspect_only) { | |
825 | resunit = RESUNIT_NONE; | |
826 | } | |
827 | else { | |
828 | if (resunit == RESUNIT_CENTIMETER) { | |
829 | xres /= 2.54; | |
830 | yres /= 2.54; | |
831 | } | |
832 | else { | |
833 | resunit = RESUNIT_INCH; | |
834 | } | |
835 | } | |
836 | if (!TIFFSetField(tif, TIFFTAG_XRESOLUTION, (float)xres)) { | |
837 | i_push_error(0, "cannot set TIFFTAG_XRESOLUTION tag"); | |
838 | return 0; | |
839 | } | |
840 | if (!TIFFSetField(tif, TIFFTAG_YRESOLUTION, (float)yres)) { | |
841 | i_push_error(0, "cannot set TIFFTAG_YRESOLUTION tag"); | |
842 | return 0; | |
843 | } | |
844 | if (!TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, (uint16)resunit)) { | |
845 | i_push_error(0, "cannot set TIFFTAG_RESOLUTIONUNIT tag"); | |
846 | return 0; | |
847 | } | |
848 | } | |
849 | ||
850 | if (!save_tiff_tags(tif, im)) { | |
851 | return 0; | |
852 | } | |
853 | ||
854 | if (photometric == PHOTOMETRIC_PALETTE) { | |
855 | for (y = 0; y < height; ++y) { | |
856 | i_gpal(im, 0, width, y, linebuf); | |
857 | if (bitspersample == 4) | |
858 | pack_4bit_hl(linebuf, width); | |
859 | if (TIFFWriteScanline(tif, linebuf, y, 0) < 0) { | |
860 | mm_log((1, "i_writetiff_wiol: TIFFWriteScanline failed.\n")); | |
861 | if (linebuf) _TIFFfree(linebuf); | |
862 | if (colors) _TIFFfree(colors); | |
863 | return 0; | |
864 | } | |
865 | } | |
866 | } | |
867 | else { | |
868 | for (y=0; y<height; y++) { | |
869 | ci = 0; | |
870 | for(x=0; x<width; x++) { | |
871 | (void) i_gpix(im, x, y,&val); | |
872 | for(ch=0; ch<channels; ch++) | |
873 | linebuf[ci++] = val.channel[ch]; | |
874 | } | |
875 | if (TIFFWriteScanline(tif, linebuf, y, 0) < 0) { | |
876 | mm_log((1, "i_writetiff_wiol: TIFFWriteScanline failed.\n")); | |
877 | if (linebuf) _TIFFfree(linebuf); | |
878 | if (colors) _TIFFfree(colors); | |
879 | return 0; | |
880 | } | |
881 | } | |
882 | } | |
883 | if (linebuf) _TIFFfree(linebuf); | |
884 | if (colors) _TIFFfree(colors); | |
885 | return 1; | |
886 | } | |
887 | ||
888 | /* | |
889 | =item i_writetiff_multi_wiol(ig, imgs, count, fine_mode) | |
890 | ||
891 | Stores an image in the iolayer object. | |
892 | ||
893 | ig - io_object that defines source to write to | |
894 | imgs,count - the images to write | |
895 | ||
896 | =cut | |
897 | */ | |
898 | ||
899 | undef_int | |
900 | i_writetiff_multi_wiol(io_glue *ig, i_img **imgs, int count) { | |
901 | TIFF* tif; | |
902 | int i; | |
903 | ||
904 | io_glue_commit_types(ig); | |
905 | i_clear_error(); | |
906 | mm_log((1, "i_writetiff_multi_wiol(ig 0x%p, imgs 0x%p, count %d)\n", | |
907 | ig, imgs, count)); | |
908 | ||
909 | /* FIXME: Enable the mmap interface */ | |
910 | ||
911 | tif = TIFFClientOpen("No name", | |
912 | "wm", | |
913 | (thandle_t) ig, | |
914 | (TIFFReadWriteProc) ig->readcb, | |
915 | (TIFFReadWriteProc) ig->writecb, | |
916 | (TIFFSeekProc) comp_seek, | |
917 | (TIFFCloseProc) ig->closecb, | |
918 | ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc, | |
919 | (TIFFMapFileProc) comp_mmap, | |
920 | (TIFFUnmapFileProc) comp_munmap); | |
921 | ||
922 | ||
923 | ||
924 | if (!tif) { | |
925 | mm_log((1, "i_writetiff_mulit_wiol: Unable to open tif file for writing\n")); | |
926 | return 0; | |
927 | } | |
928 | ||
929 | for (i = 0; i < count; ++i) { | |
930 | if (!i_writetiff_low(tif, imgs[i])) { | |
931 | TIFFClose(tif); | |
932 | return 0; | |
933 | } | |
934 | ||
935 | if (!TIFFWriteDirectory(tif)) { | |
936 | i_push_error(0, "Cannot write TIFF directory"); | |
937 | TIFFClose(tif); | |
938 | return 0; | |
939 | } | |
940 | } | |
941 | ||
942 | (void) TIFFClose(tif); | |
943 | return 1; | |
944 | } | |
945 | ||
946 | /* | |
947 | =item i_writetiff_multi_wiol_faxable(ig, imgs, count, fine_mode) | |
948 | ||
949 | Stores an image in the iolayer object. | |
950 | ||
951 | ig - io_object that defines source to write to | |
952 | imgs,count - the images to write | |
953 | fine_mode - select fine or normal mode fax images | |
954 | ||
955 | =cut | |
956 | */ | |
957 | ||
958 | ||
959 | undef_int | |
960 | i_writetiff_multi_wiol_faxable(io_glue *ig, i_img **imgs, int count, int fine) { | |
961 | TIFF* tif; | |
962 | int i; | |
963 | ||
964 | io_glue_commit_types(ig); | |
965 | i_clear_error(); | |
966 | mm_log((1, "i_writetiff_multi_wiol(ig 0x%p, imgs 0x%p, count %d)\n", | |
967 | ig, imgs, count)); | |
968 | ||
969 | /* FIXME: Enable the mmap interface */ | |
970 | ||
971 | tif = TIFFClientOpen("No name", | |
972 | "wm", | |
973 | (thandle_t) ig, | |
974 | (TIFFReadWriteProc) ig->readcb, | |
975 | (TIFFReadWriteProc) ig->writecb, | |
976 | (TIFFSeekProc) comp_seek, | |
977 | (TIFFCloseProc) ig->closecb, | |
978 | ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc, | |
979 | (TIFFMapFileProc) comp_mmap, | |
980 | (TIFFUnmapFileProc) comp_munmap); | |
981 | ||
982 | ||
983 | ||
984 | if (!tif) { | |
985 | mm_log((1, "i_writetiff_mulit_wiol: Unable to open tif file for writing\n")); | |
986 | return 0; | |
987 | } | |
988 | ||
989 | for (i = 0; i < count; ++i) { | |
990 | if (!i_writetiff_low_faxable(tif, imgs[i], fine)) { | |
991 | TIFFClose(tif); | |
992 | return 0; | |
993 | } | |
994 | ||
995 | if (!TIFFWriteDirectory(tif)) { | |
996 | i_push_error(0, "Cannot write TIFF directory"); | |
997 | TIFFClose(tif); | |
998 | return 0; | |
999 | } | |
1000 | } | |
1001 | ||
1002 | (void) TIFFClose(tif); | |
1003 | return 1; | |
1004 | } | |
1005 | ||
1006 | /* | |
1007 | =item i_writetiff_wiol(im, ig) | |
1008 | ||
1009 | Stores an image in the iolayer object. | |
1010 | ||
1011 | im - image object to write out | |
1012 | ig - io_object that defines source to write to | |
1013 | ||
1014 | =cut | |
1015 | */ | |
1016 | undef_int | |
1017 | i_writetiff_wiol(i_img *img, io_glue *ig) { | |
1018 | TIFF* tif; | |
1019 | ||
1020 | io_glue_commit_types(ig); | |
1021 | i_clear_error(); | |
1022 | mm_log((1, "i_writetiff_wiol(img %p, ig 0x%p)\n", img, ig)); | |
1023 | ||
1024 | /* FIXME: Enable the mmap interface */ | |
1025 | ||
1026 | tif = TIFFClientOpen("No name", | |
1027 | "wm", | |
1028 | (thandle_t) ig, | |
1029 | (TIFFReadWriteProc) ig->readcb, | |
1030 | (TIFFReadWriteProc) ig->writecb, | |
1031 | (TIFFSeekProc) comp_seek, | |
1032 | (TIFFCloseProc) ig->closecb, | |
1033 | ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc, | |
1034 | (TIFFMapFileProc) comp_mmap, | |
1035 | (TIFFUnmapFileProc) comp_munmap); | |
1036 | ||
1037 | ||
1038 | ||
1039 | if (!tif) { | |
1040 | mm_log((1, "i_writetiff_wiol: Unable to open tif file for writing\n")); | |
1041 | return 0; | |
1042 | } | |
1043 | ||
1044 | if (!i_writetiff_low(tif, img)) { | |
1045 | TIFFClose(tif); | |
1046 | return 0; | |
1047 | } | |
1048 | ||
1049 | (void) TIFFClose(tif); | |
1050 | return 1; | |
1051 | } | |
1052 | ||
1053 | ||
1054 | ||
1055 | /* | |
1056 | =item i_writetiff_wiol_faxable(i_img *, io_glue *) | |
1057 | ||
1058 | Stores an image in the iolayer object in faxable tiff format. | |
1059 | ||
1060 | im - image object to write out | |
1061 | ig - io_object that defines source to write to | |
1062 | ||
1063 | Note, this may be rewritten to use to simply be a call to a | |
1064 | lower-level function that gives more options for writing tiff at some | |
1065 | point. | |
1066 | ||
1067 | =cut | |
1068 | */ | |
1069 | ||
1070 | undef_int | |
1071 | i_writetiff_wiol_faxable(i_img *im, io_glue *ig, int fine) { | |
1072 | TIFF* tif; | |
1073 | ||
1074 | io_glue_commit_types(ig); | |
1075 | i_clear_error(); | |
1076 | mm_log((1, "i_writetiff_wiol(img %p, ig 0x%p)\n", im, ig)); | |
1077 | ||
1078 | /* FIXME: Enable the mmap interface */ | |
1079 | ||
1080 | tif = TIFFClientOpen("No name", | |
1081 | "wm", | |
1082 | (thandle_t) ig, | |
1083 | (TIFFReadWriteProc) ig->readcb, | |
1084 | (TIFFReadWriteProc) ig->writecb, | |
1085 | (TIFFSeekProc) comp_seek, | |
1086 | (TIFFCloseProc) ig->closecb, | |
1087 | ig->sizecb ? (TIFFSizeProc) ig->sizecb : (TIFFSizeProc) sizeproc, | |
1088 | (TIFFMapFileProc) comp_mmap, | |
1089 | (TIFFUnmapFileProc) comp_munmap); | |
1090 | ||
1091 | ||
1092 | ||
1093 | if (!tif) { | |
1094 | mm_log((1, "i_writetiff_wiol: Unable to open tif file for writing\n")); | |
1095 | return 0; | |
1096 | } | |
1097 | ||
1098 | if (!i_writetiff_low_faxable(tif, im, fine)) { | |
1099 | TIFFClose(tif); | |
1100 | return 0; | |
1101 | } | |
1102 | ||
1103 | (void) TIFFClose(tif); | |
1104 | return 1; | |
1105 | } | |
1106 | ||
1107 | static int save_tiff_tags(TIFF *tif, i_img *im) { | |
1108 | int i; | |
1109 | ||
1110 | for (i = 0; i < text_tag_count; ++i) { | |
1111 | int entry; | |
1112 | if (i_tags_find(&im->tags, text_tag_names[i].name, 0, &entry)) { | |
1113 | if (!TIFFSetField(tif, text_tag_names[i].tag, | |
1114 | im->tags.tags[entry].data)) { | |
1115 | i_push_errorf(0, "cannot save %s to TIFF", text_tag_names[i].name); | |
1116 | return 0; | |
1117 | } | |
1118 | } | |
1119 | } | |
1120 | ||
1121 | return 1; | |
1122 | } | |
1123 | ||
1124 | ||
1125 | /* | |
1126 | =item expand_4bit_hl(buf, count) | |
1127 | ||
1128 | Expands 4-bit/entry packed data into 1 byte/entry. | |
1129 | ||
1130 | buf must contain count bytes to be expanded and have 2*count bytes total | |
1131 | space. | |
1132 | ||
1133 | The data is expanded in place. | |
1134 | ||
1135 | =cut | |
1136 | */ | |
1137 | ||
1138 | static void expand_4bit_hl(unsigned char *buf, int count) { | |
1139 | while (--count >= 0) { | |
1140 | buf[count*2+1] = buf[count] & 0xF; | |
1141 | buf[count*2] = buf[count] >> 4; | |
1142 | } | |
1143 | } | |
1144 | ||
1145 | static void pack_4bit_hl(unsigned char *buf, int count) { | |
1146 | int i = 0; | |
1147 | while (i < count) { | |
1148 | buf[i/2] = (buf[i] << 4) + buf[i+1]; | |
1149 | i += 2; | |
1150 | } | |
1151 | } | |
1152 | ||
1153 | /* | |
1154 | =back | |
1155 | ||
1156 | =head1 AUTHOR | |
1157 | ||
1158 | Arnar M. Hrafnkelsson <addi@umich.edu> | |
1159 | ||
1160 | =head1 SEE ALSO | |
1161 | ||
1162 | Imager(3) | |
1163 | ||
1164 | =cut | |
1165 | */ |