ReactOS 0.4.16-dev-2636-g02c744d
tif_getimage.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 1991-1997 Sam Leffler
3 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
4 *
5 * Permission to use, copy, modify, distribute, and sell this software and
6 * its documentation for any purpose is hereby granted without fee, provided
7 * that (i) the above copyright notices and this permission notice appear in
8 * all copies of the software and related documentation, and (ii) the names of
9 * Sam Leffler and Silicon Graphics may not be used in any advertising or
10 * publicity relating to the software without the specific, prior written
11 * permission of Sam Leffler and Silicon Graphics.
12 *
13 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16 *
17 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
18 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22 * OF THIS SOFTWARE.
23 */
24
25/*
26 * TIFF Library
27 *
28 * Read and return a packed RGBA image.
29 */
30#include "tiffiop.h"
31#include <limits.h>
32#include <stdio.h>
33
34static int gtTileContig(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t);
35static int gtTileSeparate(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t);
36static int gtStripContig(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t);
37static int gtStripSeparate(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t);
38static int PickContigCase(TIFFRGBAImage *);
39static int PickSeparateCase(TIFFRGBAImage *);
40
41static int BuildMapUaToAa(TIFFRGBAImage *img);
42static int BuildMapBitdepth16To8(TIFFRGBAImage *img);
43
44static const char photoTag[] = "PhotometricInterpretation";
45
46/*
47 * Helper constants used in Orientation tag handling
48 */
49#define FLIP_VERTICALLY 0x01
50#define FLIP_HORIZONTALLY 0x02
51
52#define EMSG_BUF_SIZE 1024
53
54/*
55 * Color conversion constants. We will define display types here.
56 */
57
58static const TIFFDisplay display_sRGB = {
59 {/* XYZ -> luminance matrix */
60 {3.2410F, -1.5374F, -0.4986F},
61 {-0.9692F, 1.8760F, 0.0416F},
62 {0.0556F, -0.2040F, 1.0570F}},
63 100.0F,
64 100.0F,
65 100.0F, /* Light o/p for reference white */
66 255,
67 255,
68 255, /* Pixel values for ref. white */
69 1.0F,
70 1.0F,
71 1.0F, /* Residual light o/p for black pixel */
72 2.4F,
73 2.4F,
74 2.4F, /* Gamma values for the three guns */
75};
76
77/*
78 * Check the image to see if TIFFReadRGBAImage can deal with it.
79 * 1/0 is returned according to whether or not the image can
80 * be handled. If 0 is returned, emsg contains the reason
81 * why it is being rejected.
82 */
83int TIFFRGBAImageOK(TIFF *tif, char emsg[EMSG_BUF_SIZE])
84{
85 TIFFDirectory *td = &tif->tif_dir;
86 uint16_t photometric;
87 int colorchannels;
88
89 if (!tif->tif_decodestatus)
90 {
91 snprintf(emsg, EMSG_BUF_SIZE,
92 "Sorry, requested compression method is not configured");
93 return (0);
94 }
95 switch (td->td_bitspersample)
96 {
97 case 1:
98 case 2:
99 case 4:
100 case 8:
101 case 16:
102 break;
103 default:
104 snprintf(emsg, EMSG_BUF_SIZE,
105 "Sorry, can not handle images with %" PRIu16
106 "-bit samples",
107 td->td_bitspersample);
108 return (0);
109 }
110 if (td->td_sampleformat == SAMPLEFORMAT_IEEEFP)
111 {
112 snprintf(
113 emsg, EMSG_BUF_SIZE,
114 "Sorry, can not handle images with IEEE floating-point samples");
115 return (0);
116 }
117 colorchannels = td->td_samplesperpixel - td->td_extrasamples;
118 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric))
119 {
120 switch (colorchannels)
121 {
122 case 1:
123 photometric = PHOTOMETRIC_MINISBLACK;
124 break;
125 case 3:
126 photometric = PHOTOMETRIC_RGB;
127 break;
128 default:
129 snprintf(emsg, EMSG_BUF_SIZE, "Missing needed %s tag",
130 photoTag);
131 return (0);
132 }
133 }
134 switch (photometric)
135 {
136 case PHOTOMETRIC_MINISWHITE:
137 case PHOTOMETRIC_MINISBLACK:
138 case PHOTOMETRIC_PALETTE:
139 if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
140 td->td_samplesperpixel != 1 && td->td_bitspersample < 8)
141 {
142 snprintf(
143 emsg, EMSG_BUF_SIZE,
144 "Sorry, can not handle contiguous data with %s=%" PRIu16
145 ", "
146 "and %s=%" PRIu16 " and Bits/Sample=%" PRIu16 "",
147 photoTag, photometric, "Samples/pixel",
148 td->td_samplesperpixel, td->td_bitspersample);
149 return (0);
150 }
151 /*
152 * We should likely validate that any extra samples are either
153 * to be ignored, or are alpha, and if alpha we should try to use
154 * them. But for now we won't bother with this.
155 */
156 break;
157 case PHOTOMETRIC_YCBCR:
158 /*
159 * TODO: if at all meaningful and useful, make more complete
160 * support check here, or better still, refactor to let supporting
161 * code decide whether there is support and what meaningful
162 * error to return
163 */
164 break;
165 case PHOTOMETRIC_RGB:
166 if (colorchannels < 3)
167 {
168 snprintf(emsg, EMSG_BUF_SIZE,
169 "Sorry, can not handle RGB image with %s=%d",
170 "Color channels", colorchannels);
171 return (0);
172 }
173 break;
174 case PHOTOMETRIC_SEPARATED:
175 {
176 uint16_t inkset;
177 TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
178 if (inkset != INKSET_CMYK)
179 {
180 snprintf(emsg, EMSG_BUF_SIZE,
181 "Sorry, can not handle separated image with %s=%d",
182 "InkSet", inkset);
183 return 0;
184 }
185 if (td->td_samplesperpixel < 4)
186 {
187 snprintf(
188 emsg, EMSG_BUF_SIZE,
189 "Sorry, can not handle separated image with %s=%" PRIu16,
190 "Samples/pixel", td->td_samplesperpixel);
191 return 0;
192 }
193 break;
194 }
195 case PHOTOMETRIC_LOGL:
196 if (td->td_compression != COMPRESSION_SGILOG)
197 {
198 snprintf(emsg, EMSG_BUF_SIZE,
199 "Sorry, LogL data must have %s=%d", "Compression",
200 COMPRESSION_SGILOG);
201 return (0);
202 }
203 break;
204 case PHOTOMETRIC_LOGLUV:
205 if (td->td_compression != COMPRESSION_SGILOG &&
206 td->td_compression != COMPRESSION_SGILOG24)
207 {
208 snprintf(emsg, EMSG_BUF_SIZE,
209 "Sorry, LogLuv data must have %s=%d or %d",
210 "Compression", COMPRESSION_SGILOG,
211 COMPRESSION_SGILOG24);
212 return (0);
213 }
214 if (td->td_planarconfig != PLANARCONFIG_CONTIG)
215 {
216 snprintf(emsg, EMSG_BUF_SIZE,
217 "Sorry, can not handle LogLuv images with %s=%" PRIu16,
218 "Planarconfiguration", td->td_planarconfig);
219 return (0);
220 }
221 if (td->td_samplesperpixel != 3 || colorchannels != 3)
222 {
223 snprintf(emsg, EMSG_BUF_SIZE,
224 "Sorry, can not handle image with %s=%" PRIu16
225 ", %s=%d",
226 "Samples/pixel", td->td_samplesperpixel,
227 "colorchannels", colorchannels);
228 return 0;
229 }
230 break;
231 case PHOTOMETRIC_CIELAB:
232 if (td->td_samplesperpixel != 3 || colorchannels != 3 ||
233 (td->td_bitspersample != 8 && td->td_bitspersample != 16))
234 {
235 snprintf(emsg, EMSG_BUF_SIZE,
236 "Sorry, can not handle image with %s=%" PRIu16
237 ", %s=%d and %s=%" PRIu16,
238 "Samples/pixel", td->td_samplesperpixel,
239 "colorchannels", colorchannels, "Bits/sample",
240 td->td_bitspersample);
241 return 0;
242 }
243 break;
244 default:
245 snprintf(emsg, EMSG_BUF_SIZE,
246 "Sorry, can not handle image with %s=%" PRIu16, photoTag,
247 photometric);
248 return (0);
249 }
250 return (1);
251}
252
253void TIFFRGBAImageEnd(TIFFRGBAImage *img)
254{
255 if (img->Map)
256 {
257 _TIFFfreeExt(img->tif, img->Map);
258 img->Map = NULL;
259 }
260 if (img->BWmap)
261 {
262 _TIFFfreeExt(img->tif, img->BWmap);
263 img->BWmap = NULL;
264 }
265 if (img->PALmap)
266 {
267 _TIFFfreeExt(img->tif, img->PALmap);
268 img->PALmap = NULL;
269 }
270 if (img->ycbcr)
271 {
272 _TIFFfreeExt(img->tif, img->ycbcr);
273 img->ycbcr = NULL;
274 }
275 if (img->cielab)
276 {
277 _TIFFfreeExt(img->tif, img->cielab);
278 img->cielab = NULL;
279 }
280 if (img->UaToAa)
281 {
282 _TIFFfreeExt(img->tif, img->UaToAa);
283 img->UaToAa = NULL;
284 }
285 if (img->Bitdepth16To8)
286 {
287 _TIFFfreeExt(img->tif, img->Bitdepth16To8);
288 img->Bitdepth16To8 = NULL;
289 }
290
291 if (img->redcmap)
292 {
293 _TIFFfreeExt(img->tif, img->redcmap);
294 _TIFFfreeExt(img->tif, img->greencmap);
295 _TIFFfreeExt(img->tif, img->bluecmap);
296 img->redcmap = img->greencmap = img->bluecmap = NULL;
297 }
298}
299
300static int isCCITTCompression(TIFF *tif)
301{
302 uint16_t compress;
303 TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress);
304 return (compress == COMPRESSION_CCITTFAX3 ||
305 compress == COMPRESSION_CCITTFAX4 ||
306 compress == COMPRESSION_CCITTRLE ||
307 compress == COMPRESSION_CCITTRLEW);
308}
309
310int TIFFRGBAImageBegin(TIFFRGBAImage *img, TIFF *tif, int stop,
311 char emsg[EMSG_BUF_SIZE])
312{
313 uint16_t *sampleinfo;
314 uint16_t extrasamples;
315 uint16_t planarconfig;
316 uint16_t compress;
317 int colorchannels;
318 uint16_t *red_orig, *green_orig, *blue_orig;
319 int n_color;
320
321 if (!TIFFRGBAImageOK(tif, emsg))
322 return 0;
323
324 /* Initialize to normal values */
325 img->row_offset = 0;
326 img->col_offset = 0;
327 img->redcmap = NULL;
328 img->greencmap = NULL;
329 img->bluecmap = NULL;
330 img->Map = NULL;
331 img->BWmap = NULL;
332 img->PALmap = NULL;
333 img->ycbcr = NULL;
334 img->cielab = NULL;
335 img->UaToAa = NULL;
336 img->Bitdepth16To8 = NULL;
337 img->req_orientation = ORIENTATION_BOTLEFT; /* It is the default */
338
339 img->tif = tif;
340 img->stoponerr = stop;
341 TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);
342 switch (img->bitspersample)
343 {
344 case 1:
345 case 2:
346 case 4:
347 case 8:
348 case 16:
349 break;
350 default:
351 snprintf(emsg, EMSG_BUF_SIZE,
352 "Sorry, can not handle images with %" PRIu16
353 "-bit samples",
354 img->bitspersample);
355 goto fail_return;
356 }
357 img->alpha = 0;
358 TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
359 TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES, &extrasamples,
360 &sampleinfo);
361 if (extrasamples >= 1)
362 {
363 switch (sampleinfo[0])
364 {
365 case EXTRASAMPLE_UNSPECIFIED: /* Workaround for some images without
366 */
367 if (img->samplesperpixel >
368 3) /* correct info about alpha channel */
369 img->alpha = EXTRASAMPLE_ASSOCALPHA;
370 break;
371 case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */
372 case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */
373 img->alpha = sampleinfo[0];
374 break;
375 }
376 }
377
378#ifdef DEFAULT_EXTRASAMPLE_AS_ALPHA
379 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric))
380 img->photometric = PHOTOMETRIC_MINISWHITE;
381
382 if (extrasamples == 0 && img->samplesperpixel == 4 &&
383 img->photometric == PHOTOMETRIC_RGB)
384 {
385 img->alpha = EXTRASAMPLE_ASSOCALPHA;
386 extrasamples = 1;
387 }
388#endif
389
390 colorchannels = img->samplesperpixel - extrasamples;
391 TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress);
392 TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);
393 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric))
394 {
395 switch (colorchannels)
396 {
397 case 1:
398 if (isCCITTCompression(tif))
399 img->photometric = PHOTOMETRIC_MINISWHITE;
400 else
401 img->photometric = PHOTOMETRIC_MINISBLACK;
402 break;
403 case 3:
404 img->photometric = PHOTOMETRIC_RGB;
405 break;
406 default:
407 snprintf(emsg, EMSG_BUF_SIZE, "Missing needed %s tag",
408 photoTag);
409 goto fail_return;
410 }
411 }
412 switch (img->photometric)
413 {
414 case PHOTOMETRIC_PALETTE:
415 if (!TIFFGetField(tif, TIFFTAG_COLORMAP, &red_orig, &green_orig,
416 &blue_orig))
417 {
418 snprintf(emsg, EMSG_BUF_SIZE,
419 "Missing required \"Colormap\" tag");
420 goto fail_return;
421 }
422
423 /* copy the colormaps so we can modify them */
424 n_color = (1U << img->bitspersample);
425 img->redcmap =
426 (uint16_t *)_TIFFmallocExt(tif, sizeof(uint16_t) * n_color);
427 img->greencmap =
428 (uint16_t *)_TIFFmallocExt(tif, sizeof(uint16_t) * n_color);
429 img->bluecmap =
430 (uint16_t *)_TIFFmallocExt(tif, sizeof(uint16_t) * n_color);
431 if (!img->redcmap || !img->greencmap || !img->bluecmap)
432 {
433 snprintf(emsg, EMSG_BUF_SIZE,
434 "Out of memory for colormap copy");
435 goto fail_return;
436 }
437
438 _TIFFmemcpy(img->redcmap, red_orig, n_color * 2);
439 _TIFFmemcpy(img->greencmap, green_orig, n_color * 2);
440 _TIFFmemcpy(img->bluecmap, blue_orig, n_color * 2);
441
442 /* fall through... */
443 case PHOTOMETRIC_MINISWHITE:
444 case PHOTOMETRIC_MINISBLACK:
445 if (planarconfig == PLANARCONFIG_CONTIG &&
446 img->samplesperpixel != 1 && img->bitspersample < 8)
447 {
448 snprintf(
449 emsg, EMSG_BUF_SIZE,
450 "Sorry, can not handle contiguous data with %s=%" PRIu16
451 ", "
452 "and %s=%" PRIu16 " and Bits/Sample=%" PRIu16,
453 photoTag, img->photometric, "Samples/pixel",
454 img->samplesperpixel, img->bitspersample);
455 goto fail_return;
456 }
457 break;
458 case PHOTOMETRIC_YCBCR:
459 /* It would probably be nice to have a reality check here. */
460 if (planarconfig == PLANARCONFIG_CONTIG)
461 /* can rely on libjpeg to convert to RGB */
462 /* XXX should restore current state on exit */
463 switch (compress)
464 {
465 case COMPRESSION_JPEG:
466 /*
467 * TODO: when complete tests verify complete
468 * desubsampling and YCbCr handling, remove use of
469 * TIFFTAG_JPEGCOLORMODE in favor of tif_getimage.c
470 * native handling
471 */
472 TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE,
473 JPEGCOLORMODE_RGB);
474 img->photometric = PHOTOMETRIC_RGB;
475 break;
476 default:
477 /* do nothing */;
478 break;
479 }
480 /*
481 * TODO: if at all meaningful and useful, make more complete
482 * support check here, or better still, refactor to let supporting
483 * code decide whether there is support and what meaningful
484 * error to return
485 */
486 break;
487 case PHOTOMETRIC_RGB:
488 if (colorchannels < 3)
489 {
490 snprintf(emsg, EMSG_BUF_SIZE,
491 "Sorry, can not handle RGB image with %s=%d",
492 "Color channels", colorchannels);
493 goto fail_return;
494 }
495 break;
496 case PHOTOMETRIC_SEPARATED:
497 {
498 uint16_t inkset;
499 TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
500 if (inkset != INKSET_CMYK)
501 {
502 snprintf(
503 emsg, EMSG_BUF_SIZE,
504 "Sorry, can not handle separated image with %s=%" PRIu16,
505 "InkSet", inkset);
506 goto fail_return;
507 }
508 if (img->samplesperpixel < 4)
509 {
510 snprintf(
511 emsg, EMSG_BUF_SIZE,
512 "Sorry, can not handle separated image with %s=%" PRIu16,
513 "Samples/pixel", img->samplesperpixel);
514 goto fail_return;
515 }
516 }
517 break;
518 case PHOTOMETRIC_LOGL:
519 if (compress != COMPRESSION_SGILOG)
520 {
521 snprintf(emsg, EMSG_BUF_SIZE,
522 "Sorry, LogL data must have %s=%d", "Compression",
523 COMPRESSION_SGILOG);
524 goto fail_return;
525 }
526 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
527 img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */
528 img->bitspersample = 8;
529 break;
530 case PHOTOMETRIC_LOGLUV:
531 if (compress != COMPRESSION_SGILOG &&
532 compress != COMPRESSION_SGILOG24)
533 {
534 snprintf(emsg, EMSG_BUF_SIZE,
535 "Sorry, LogLuv data must have %s=%d or %d",
536 "Compression", COMPRESSION_SGILOG,
537 COMPRESSION_SGILOG24);
538 goto fail_return;
539 }
540 if (planarconfig != PLANARCONFIG_CONTIG)
541 {
542 snprintf(emsg, EMSG_BUF_SIZE,
543 "Sorry, can not handle LogLuv images with %s=%" PRIu16,
544 "Planarconfiguration", planarconfig);
545 return (0);
546 }
547 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
548 img->photometric = PHOTOMETRIC_RGB; /* little white lie */
549 img->bitspersample = 8;
550 break;
551 case PHOTOMETRIC_CIELAB:
552 break;
553 default:
554 snprintf(emsg, EMSG_BUF_SIZE,
555 "Sorry, can not handle image with %s=%" PRIu16, photoTag,
556 img->photometric);
557 goto fail_return;
558 }
559 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width);
560 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height);
561 TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation);
562 img->isContig =
563 !(planarconfig == PLANARCONFIG_SEPARATE && img->samplesperpixel > 1);
564 if (img->isContig)
565 {
566 if (!PickContigCase(img))
567 {
568 snprintf(emsg, EMSG_BUF_SIZE, "Sorry, can not handle image");
569 goto fail_return;
570 }
571 }
572 else
573 {
574 if (!PickSeparateCase(img))
575 {
576 snprintf(emsg, EMSG_BUF_SIZE, "Sorry, can not handle image");
577 goto fail_return;
578 }
579 }
580 return 1;
581
582fail_return:
583 TIFFRGBAImageEnd(img);
584 return 0;
585}
586
587int TIFFRGBAImageGet(TIFFRGBAImage *img, uint32_t *raster, uint32_t w,
588 uint32_t h)
589{
590 if (img->get == NULL)
591 {
592 TIFFErrorExtR(img->tif, TIFFFileName(img->tif),
593 "No \"get\" routine setup");
594 return (0);
595 }
596 if (img->put.any == NULL)
597 {
598 TIFFErrorExtR(
599 img->tif, TIFFFileName(img->tif),
600 "No \"put\" routine setupl; probably can not handle image format");
601 return (0);
602 }
603 /* Verify raster height against image height.
604 * Width is checked in img->get() function individually. */
605 if (0 <= img->row_offset && (uint32_t)img->row_offset < img->height)
606 {
607 uint32_t hx = img->height - img->row_offset;
608 if (h > hx)
609 {
610 /* Adapt parameters to read only available lines and put image
611 * at the bottom of the raster. */
612 raster += (size_t)(h - hx) * w;
613 h = hx;
614 }
615 }
616 else
617 {
618 TIFFErrorExtR(img->tif, TIFFFileName(img->tif),
619 "Error in TIFFRGBAImageGet: row offset %d exceeds "
620 "image height %d",
621 img->row_offset, img->height);
622 return 0;
623 }
624 return (*img->get)(img, raster, w, h);
625}
626
627/*
628 * Read the specified image into an ABGR-format rastertaking in account
629 * specified orientation.
630 */
631int TIFFReadRGBAImageOriented(TIFF *tif, uint32_t rwidth, uint32_t rheight,
632 uint32_t *raster, int orientation, int stop)
633{
634 char emsg[EMSG_BUF_SIZE] = "";
635 TIFFRGBAImage img;
636 int ok;
637
638 if (TIFFRGBAImageBegin(&img, tif, stop, emsg))
639 {
640 img.req_orientation = (uint16_t)orientation;
641 ok = TIFFRGBAImageGet(&img, raster, rwidth, rheight);
642 TIFFRGBAImageEnd(&img);
643 }
644 else
645 {
646 TIFFErrorExtR(tif, TIFFFileName(tif), "%s", emsg);
647 ok = 0;
648 }
649 return (ok);
650}
651
652/*
653 * Read the specified image into an ABGR-format raster. Use bottom left
654 * origin for raster by default.
655 */
656int TIFFReadRGBAImage(TIFF *tif, uint32_t rwidth, uint32_t rheight,
657 uint32_t *raster, int stop)
658{
659 return TIFFReadRGBAImageOriented(tif, rwidth, rheight, raster,
660 ORIENTATION_BOTLEFT, stop);
661}
662
663static int setorientation(TIFFRGBAImage *img)
664{
665 switch (img->orientation)
666 {
667 case ORIENTATION_TOPLEFT:
668 case ORIENTATION_LEFTTOP:
669 if (img->req_orientation == ORIENTATION_TOPRIGHT ||
670 img->req_orientation == ORIENTATION_RIGHTTOP)
671 return FLIP_HORIZONTALLY;
672 else if (img->req_orientation == ORIENTATION_BOTRIGHT ||
673 img->req_orientation == ORIENTATION_RIGHTBOT)
674 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
675 else if (img->req_orientation == ORIENTATION_BOTLEFT ||
676 img->req_orientation == ORIENTATION_LEFTBOT)
677 return FLIP_VERTICALLY;
678 else
679 return 0;
680 case ORIENTATION_TOPRIGHT:
681 case ORIENTATION_RIGHTTOP:
682 if (img->req_orientation == ORIENTATION_TOPLEFT ||
683 img->req_orientation == ORIENTATION_LEFTTOP)
684 return FLIP_HORIZONTALLY;
685 else if (img->req_orientation == ORIENTATION_BOTRIGHT ||
686 img->req_orientation == ORIENTATION_RIGHTBOT)
687 return FLIP_VERTICALLY;
688 else if (img->req_orientation == ORIENTATION_BOTLEFT ||
689 img->req_orientation == ORIENTATION_LEFTBOT)
690 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
691 else
692 return 0;
693 case ORIENTATION_BOTRIGHT:
694 case ORIENTATION_RIGHTBOT:
695 if (img->req_orientation == ORIENTATION_TOPLEFT ||
696 img->req_orientation == ORIENTATION_LEFTTOP)
697 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
698 else if (img->req_orientation == ORIENTATION_TOPRIGHT ||
699 img->req_orientation == ORIENTATION_RIGHTTOP)
700 return FLIP_VERTICALLY;
701 else if (img->req_orientation == ORIENTATION_BOTLEFT ||
702 img->req_orientation == ORIENTATION_LEFTBOT)
703 return FLIP_HORIZONTALLY;
704 else
705 return 0;
706 case ORIENTATION_BOTLEFT:
707 case ORIENTATION_LEFTBOT:
708 if (img->req_orientation == ORIENTATION_TOPLEFT ||
709 img->req_orientation == ORIENTATION_LEFTTOP)
710 return FLIP_VERTICALLY;
711 else if (img->req_orientation == ORIENTATION_TOPRIGHT ||
712 img->req_orientation == ORIENTATION_RIGHTTOP)
713 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
714 else if (img->req_orientation == ORIENTATION_BOTRIGHT ||
715 img->req_orientation == ORIENTATION_RIGHTBOT)
716 return FLIP_HORIZONTALLY;
717 else
718 return 0;
719 default: /* NOTREACHED */
720 return 0;
721 }
722}
723
724/*
725 * Get an tile-organized image that has
726 * PlanarConfiguration contiguous if SamplesPerPixel > 1
727 * or
728 * SamplesPerPixel == 1
729 */
730static int gtTileContig(TIFFRGBAImage *img, uint32_t *raster, uint32_t w,
731 uint32_t h)
732{
733 TIFF *tif = img->tif;
734 tileContigRoutine put = img->put.contig;
735 uint32_t col, row, y, rowstoread;
736 tmsize_t pos;
737 uint32_t tw, th;
738 unsigned char *buf = NULL;
739 int32_t fromskew, toskew;
740 uint32_t nrow;
741 int ret = 1, flip;
742 uint32_t this_tw, tocol;
743 int32_t this_toskew, leftmost_toskew;
744 int32_t leftmost_fromskew;
745 uint32_t leftmost_tw;
746 tmsize_t bufsize;
747
748 /* If the raster is smaller than the image,
749 * or if there is a col_offset, adapt the samples to be copied per row. */
750 uint32_t wmin;
751
752 if (0 <= img->col_offset && (uint32_t)img->col_offset < img->width)
753 {
754 wmin = TIFFmin(w, img->width - img->col_offset);
755 }
756 else
757 {
758 TIFFErrorExtR(tif, TIFFFileName(tif),
759 "Error in gtTileContig: column offset %d exceeds "
760 "image width %d",
761 img->col_offset, img->width);
762 return 0;
763 }
764 bufsize = TIFFTileSize(tif);
765 if (bufsize == 0)
766 {
767 TIFFErrorExtR(tif, TIFFFileName(tif), "%s", "No space for tile buffer");
768 return (0);
769 }
770
771 TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
772 TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
773
774 flip = setorientation(img);
775 if (flip & FLIP_VERTICALLY)
776 {
777 if (((int64_t)tw + w) > INT_MAX)
778 {
779 TIFFErrorExtR(tif, TIFFFileName(tif), "%s",
780 "unsupported tile size (too wide)");
781 return (0);
782 }
783 y = h - 1;
784 toskew = -(int32_t)(tw + w);
785 }
786 else
787 {
788 if (tw > ((int64_t)INT_MAX + w))
789 {
790 TIFFErrorExtR(tif, TIFFFileName(tif), "%s",
791 "unsupported tile size (too wide)");
792 return (0);
793 }
794 y = 0;
795 toskew = -(int32_t)(tw - w);
796 }
797
798 if (tw == 0 || th == 0)
799 {
800 TIFFErrorExtR(tif, TIFFFileName(tif), "tile width or height is zero");
801 return (0);
802 }
803
804 /*
805 * Leftmost tile is clipped on left side if col_offset > 0.
806 */
807 leftmost_fromskew = img->col_offset % tw;
808 leftmost_tw = tw - leftmost_fromskew;
809 int64_t skew_i64 = (int64_t)toskew + leftmost_fromskew;
810 if (skew_i64 > INT_MAX || skew_i64 < INT_MIN)
811 {
812 TIFFErrorExtR(tif, TIFFFileName(tif), "%s %" PRId64, "Invalid skew",
813 skew_i64);
814 return (0);
815 }
816 leftmost_toskew = (int32_t)skew_i64;
817 for (row = 0; ret != 0 && row < h; row += nrow)
818 {
819 rowstoread = th - (row + img->row_offset) % th;
820 nrow = (row + rowstoread > h ? h - row : rowstoread);
821 fromskew = leftmost_fromskew;
822 this_tw = leftmost_tw;
823 this_toskew = leftmost_toskew;
824 tocol = 0;
825 col = img->col_offset;
826 /* wmin: only write imagewidth if raster is bigger. */
827 while (tocol < wmin)
828 {
829 if (_TIFFReadTileAndAllocBuffer(tif, (void **)&buf, bufsize, col,
830 row + img->row_offset, 0,
831 0) == (tmsize_t)(-1) &&
832 (buf == NULL || img->stoponerr))
833 {
834 ret = 0;
835 break;
836 }
837 pos = ((row + img->row_offset) % th) * TIFFTileRowSize(tif) +
838 ((tmsize_t)fromskew * img->samplesperpixel);
839 if (tocol + this_tw > wmin)
840 {
841 /*
842 * Rightmost tile is clipped on right side.
843 */
844 fromskew = tw - (wmin - tocol);
845 this_tw = tw - fromskew;
846 this_toskew = toskew + fromskew;
847 }
848 tmsize_t roffset = (tmsize_t)y * w + tocol;
849 (*put)(img, raster + roffset, tocol, y, this_tw, nrow, fromskew,
850 this_toskew, buf + pos);
851 tocol += this_tw;
852 col += this_tw;
853 /*
854 * After the leftmost tile, tiles are no longer clipped on left
855 * side.
856 */
857 fromskew = 0;
858 this_tw = tw;
859 this_toskew = toskew;
860 }
861
862 y += ((flip & FLIP_VERTICALLY) ? -(int32_t)nrow : (int32_t)nrow);
863 }
864 _TIFFfreeExt(img->tif, buf);
865
866 if (flip & FLIP_HORIZONTALLY)
867 {
868 uint32_t line;
869
870 for (line = 0; line < h; line++)
871 {
872 uint32_t *left = raster + (line * w);
873 /* Use wmin to only flip horizontally data in place and not complete
874 * raster-row. */
875 uint32_t *right = left + wmin - 1;
876
877 while (left < right)
878 {
879 uint32_t temp = *left;
880 *left = *right;
881 *right = temp;
882 left++;
883 right--;
884 }
885 }
886 }
887
888 return (ret);
889}
890
891/*
892 * Get an tile-organized image that has
893 * SamplesPerPixel > 1
894 * PlanarConfiguration separated
895 * We assume that all such images are RGB.
896 */
897static int gtTileSeparate(TIFFRGBAImage *img, uint32_t *raster, uint32_t w,
898 uint32_t h)
899{
900 TIFF *tif = img->tif;
901 tileSeparateRoutine put = img->put.separate;
902 uint32_t col, row, y, rowstoread;
903 tmsize_t pos;
904 uint32_t tw, th;
905 unsigned char *buf = NULL;
906 unsigned char *p0 = NULL;
907 unsigned char *p1 = NULL;
908 unsigned char *p2 = NULL;
909 unsigned char *pa = NULL;
910 tmsize_t tilesize;
911 tmsize_t bufsize;
912 int32_t fromskew, toskew;
913 int alpha = img->alpha;
914 uint32_t nrow;
915 int ret = 1, flip;
916 uint16_t colorchannels;
917 uint32_t this_tw, tocol;
918 int32_t this_toskew, leftmost_toskew;
919 int32_t leftmost_fromskew;
920 uint32_t leftmost_tw;
921
922 /* If the raster is smaller than the image,
923 * or if there is a col_offset, adapt the samples to be copied per row. */
924 uint32_t wmin;
925 if (0 <= img->col_offset && (uint32_t)img->col_offset < img->width)
926 {
927 wmin = TIFFmin(w, img->width - img->col_offset);
928 }
929 else
930 {
931 TIFFErrorExtR(tif, TIFFFileName(tif),
932 "Error in gtTileSeparate: column offset %d exceeds "
933 "image width %d",
934 img->col_offset, img->width);
935 return 0;
936 }
937
938 tilesize = TIFFTileSize(tif);
939 bufsize =
940 _TIFFMultiplySSize(tif, alpha ? 4 : 3, tilesize, "gtTileSeparate");
941 if (bufsize == 0)
942 {
943 return (0);
944 }
945
946 TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
947 TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
948
949 flip = setorientation(img);
950 if (flip & FLIP_VERTICALLY)
951 {
952 if (((int64_t)tw + w) > INT_MAX)
953 {
954 TIFFErrorExtR(tif, TIFFFileName(tif), "%s",
955 "unsupported tile size (too wide)");
956 return (0);
957 }
958 y = h - 1;
959 toskew = -(int32_t)(tw + w);
960 }
961 else
962 {
963 if (tw > ((int64_t)INT_MAX + w))
964 {
965 TIFFErrorExtR(tif, TIFFFileName(tif), "%s",
966 "unsupported tile size (too wide)");
967 return (0);
968 }
969 y = 0;
970 toskew = -(int32_t)(tw - w);
971 }
972
973 switch (img->photometric)
974 {
975 case PHOTOMETRIC_MINISWHITE:
976 case PHOTOMETRIC_MINISBLACK:
977 case PHOTOMETRIC_PALETTE:
978 colorchannels = 1;
979 break;
980
981 default:
982 colorchannels = 3;
983 break;
984 }
985
986 if (tw == 0 || th == 0)
987 {
988 TIFFErrorExtR(tif, TIFFFileName(tif), "tile width or height is zero");
989 return (0);
990 }
991
992 /*
993 * Leftmost tile is clipped on left side if col_offset > 0.
994 */
995 leftmost_fromskew = img->col_offset % tw;
996 leftmost_tw = tw - leftmost_fromskew;
997 int64_t skew_i64 = (int64_t)toskew + leftmost_fromskew;
998 if (skew_i64 > INT_MAX || skew_i64 < INT_MIN)
999 {
1000 TIFFErrorExtR(tif, TIFFFileName(tif), "%s %" PRId64, "Invalid skew",
1001 skew_i64);
1002 return (0);
1003 }
1004 leftmost_toskew = (int32_t)skew_i64;
1005 for (row = 0; ret != 0 && row < h; row += nrow)
1006 {
1007 rowstoread = th - (row + img->row_offset) % th;
1008 nrow = (row + rowstoread > h ? h - row : rowstoread);
1009 fromskew = leftmost_fromskew;
1010 this_tw = leftmost_tw;
1011 this_toskew = leftmost_toskew;
1012 tocol = 0;
1013 col = img->col_offset;
1014 /* wmin: only write imagewidth if raster is bigger. */
1015 while (tocol < wmin)
1016 {
1017 if (buf == NULL)
1018 {
1019 if (_TIFFReadTileAndAllocBuffer(tif, (void **)&buf, bufsize,
1020 col, row + img->row_offset, 0,
1021 0) == (tmsize_t)(-1) &&
1022 (buf == NULL || img->stoponerr))
1023 {
1024 ret = 0;
1025 break;
1026 }
1027 p0 = buf;
1028 if (colorchannels == 1)
1029 {
1030 p2 = p1 = p0;
1031 pa = (alpha ? (p0 + 3 * tilesize) : NULL);
1032 }
1033 else
1034 {
1035 p1 = p0 + tilesize;
1036 p2 = p1 + tilesize;
1037 pa = (alpha ? (p2 + tilesize) : NULL);
1038 }
1039 }
1040 else if (TIFFReadTile(tif, p0, col, row + img->row_offset, 0, 0) ==
1041 (tmsize_t)(-1) &&
1042 img->stoponerr)
1043 {
1044 ret = 0;
1045 break;
1046 }
1047 if (colorchannels > 1 &&
1048 TIFFReadTile(tif, p1, col, row + img->row_offset, 0, 1) ==
1049 (tmsize_t)(-1) &&
1050 img->stoponerr)
1051 {
1052 ret = 0;
1053 break;
1054 }
1055 if (colorchannels > 1 &&
1056 TIFFReadTile(tif, p2, col, row + img->row_offset, 0, 2) ==
1057 (tmsize_t)(-1) &&
1058 img->stoponerr)
1059 {
1060 ret = 0;
1061 break;
1062 }
1063 if (alpha &&
1064 TIFFReadTile(tif, pa, col, row + img->row_offset, 0,
1065 colorchannels) == (tmsize_t)(-1) &&
1066 img->stoponerr)
1067 {
1068 ret = 0;
1069 break;
1070 }
1071
1072 /* For SEPARATE the pos-offset is per sample and should not be
1073 * multiplied by img->samplesperpixel. */
1074 pos = ((row + img->row_offset) % th) * TIFFTileRowSize(tif) +
1075 (tmsize_t)fromskew;
1076 if (tocol + this_tw > wmin)
1077 {
1078 /*
1079 * Rightmost tile is clipped on right side.
1080 */
1081 fromskew = tw - (wmin - tocol);
1082 this_tw = tw - fromskew;
1083 this_toskew = toskew + fromskew;
1084 }
1085 tmsize_t roffset = (tmsize_t)y * w + tocol;
1086 (*put)(img, raster + roffset, tocol, y, this_tw, nrow, fromskew,
1087 this_toskew, p0 + pos, p1 + pos, p2 + pos,
1088 (alpha ? (pa + pos) : NULL));
1089 tocol += this_tw;
1090 col += this_tw;
1091 /*
1092 * After the leftmost tile, tiles are no longer clipped on left
1093 * side.
1094 */
1095 fromskew = 0;
1096 this_tw = tw;
1097 this_toskew = toskew;
1098 }
1099
1100 y += ((flip & FLIP_VERTICALLY) ? -(int32_t)nrow : (int32_t)nrow);
1101 }
1102
1103 if (flip & FLIP_HORIZONTALLY)
1104 {
1105 uint32_t line;
1106
1107 for (line = 0; line < h; line++)
1108 {
1109 uint32_t *left = raster + (line * w);
1110 /* Use wmin to only flip horizontally data in place and not complete
1111 * raster-row. */
1112 uint32_t *right = left + wmin - 1;
1113
1114 while (left < right)
1115 {
1116 uint32_t temp = *left;
1117 *left = *right;
1118 *right = temp;
1119 left++;
1120 right--;
1121 }
1122 }
1123 }
1124
1125 _TIFFfreeExt(img->tif, buf);
1126 return (ret);
1127}
1128
1129/*
1130 * Get a strip-organized image that has
1131 * PlanarConfiguration contiguous if SamplesPerPixel > 1
1132 * or
1133 * SamplesPerPixel == 1
1134 */
1135static int gtStripContig(TIFFRGBAImage *img, uint32_t *raster, uint32_t w,
1136 uint32_t h)
1137{
1138 TIFF *tif = img->tif;
1139 tileContigRoutine put = img->put.contig;
1140 uint32_t row, y, nrow, nrowsub, rowstoread;
1141 tmsize_t pos;
1142 unsigned char *buf = NULL;
1143 uint32_t rowsperstrip;
1144 uint16_t subsamplinghor, subsamplingver;
1145 uint32_t imagewidth = img->width;
1146 tmsize_t scanline;
1147 /* fromskew, toskew are the increments within the input image or the raster
1148 * from the end of a line to the start of the next line to read or write. */
1149 int32_t fromskew, toskew;
1150 int ret = 1, flip;
1151 tmsize_t maxstripsize;
1152
1153 /* If the raster is smaller than the image,
1154 * or if there is a col_offset, adapt the samples to be copied per row. */
1155 uint32_t wmin;
1156 if (0 <= img->col_offset && (uint32_t)img->col_offset < imagewidth)
1157 {
1158 wmin = TIFFmin(w, imagewidth - img->col_offset);
1159 }
1160 else
1161 {
1162 TIFFErrorExtR(tif, TIFFFileName(tif),
1163 "Error in gtStripContig: column offset %d exceeds "
1164 "image width %d",
1165 img->col_offset, imagewidth);
1166 return 0;
1167 }
1168
1169 TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor,
1170 &subsamplingver);
1171 if (subsamplingver == 0)
1172 {
1173 TIFFErrorExtR(tif, TIFFFileName(tif),
1174 "Invalid vertical YCbCr subsampling");
1175 return (0);
1176 }
1177
1178 maxstripsize = TIFFStripSize(tif);
1179
1180 flip = setorientation(img);
1181 if (flip & FLIP_VERTICALLY)
1182 {
1183 if (w > INT_MAX / 2)
1184 {
1185 TIFFErrorExtR(tif, TIFFFileName(tif), "Width overflow");
1186 return (0);
1187 }
1188 y = h - 1;
1189 /* Skew back to the raster row before the currently written row
1190 * -> one raster width plus copied image pixels. */
1191 toskew = -(int32_t)(w + wmin);
1192 }
1193 else
1194 {
1195 y = 0;
1196 /* Skew forward to the end of the raster width of the row currently
1197 * copied. */
1198 toskew = w - wmin;
1199 }
1200
1201 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
1202 if (rowsperstrip == 0)
1203 {
1204 TIFFErrorExtR(tif, TIFFFileName(tif), "rowsperstrip is zero");
1205 return (0);
1206 }
1207
1208 scanline = TIFFScanlineSize(tif);
1209 fromskew = (w < imagewidth ? imagewidth - w : 0);
1210 for (row = 0; row < h; row += nrow)
1211 {
1212 uint32_t temp;
1213 rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
1214 nrow = (row + rowstoread > h ? h - row : rowstoread);
1215 nrowsub = nrow;
1216 if ((nrowsub % subsamplingver) != 0)
1217 nrowsub += subsamplingver - nrowsub % subsamplingver;
1218 temp = (row + img->row_offset) % rowsperstrip + nrowsub;
1219 if (scanline > 0 && temp > (size_t)(TIFF_TMSIZE_T_MAX / scanline))
1220 {
1221 TIFFErrorExtR(tif, TIFFFileName(tif),
1222 "Integer overflow in gtStripContig");
1223 return 0;
1224 }
1225 if (_TIFFReadEncodedStripAndAllocBuffer(
1226 tif, TIFFComputeStrip(tif, row + img->row_offset, 0),
1227 (void **)(&buf), maxstripsize,
1228 temp * scanline) == (tmsize_t)(-1) &&
1229 (buf == NULL || img->stoponerr))
1230 {
1231 ret = 0;
1232 break;
1233 }
1234
1235 pos = ((row + img->row_offset) % rowsperstrip) * scanline +
1236 ((tmsize_t)img->col_offset * img->samplesperpixel);
1237 tmsize_t roffset = (tmsize_t)y * w;
1238 (*put)(img, raster + roffset, 0, y, wmin, nrow, fromskew, toskew,
1239 buf + pos);
1240 y += ((flip & FLIP_VERTICALLY) ? -(int32_t)nrow : (int32_t)nrow);
1241 }
1242
1243 if (flip & FLIP_HORIZONTALLY)
1244 {
1245 /* Flips the complete raster matrix horizontally. If raster width is
1246 * larger than image width, data are moved horizontally to the right
1247 * side.
1248 * Use wmin to only flip data in place. */
1249 uint32_t line;
1250
1251 for (line = 0; line < h; line++)
1252 {
1253 uint32_t *left = raster + (line * w);
1254 /* Use wmin to only flip horizontally data in place and not complete
1255 * raster-row. */
1256 uint32_t *right = left + wmin - 1;
1257
1258 while (left < right)
1259 {
1260 uint32_t temp = *left;
1261 *left = *right;
1262 *right = temp;
1263 left++;
1264 right--;
1265 }
1266 }
1267 }
1268
1269 _TIFFfreeExt(img->tif, buf);
1270 return (ret);
1271}
1272
1273/*
1274 * Get a strip-organized image with
1275 * SamplesPerPixel > 1
1276 * PlanarConfiguration separated
1277 * We assume that all such images are RGB.
1278 */
1279static int gtStripSeparate(TIFFRGBAImage *img, uint32_t *raster, uint32_t w,
1280 uint32_t h)
1281{
1282 TIFF *tif = img->tif;
1283 tileSeparateRoutine put = img->put.separate;
1284 unsigned char *buf = NULL;
1285 unsigned char *p0 = NULL, *p1 = NULL, *p2 = NULL, *pa = NULL;
1286 uint32_t row, y, nrow, rowstoread;
1287 tmsize_t pos;
1288 tmsize_t scanline;
1289 uint32_t rowsperstrip, offset_row;
1290 uint32_t imagewidth = img->width;
1291 tmsize_t stripsize;
1292 tmsize_t bufsize;
1293 int32_t fromskew, toskew;
1294 int alpha = img->alpha;
1295 int ret = 1, flip;
1296 uint16_t colorchannels;
1297
1298 /* If the raster is smaller than the image,
1299 * or if there is a col_offset, adapt the samples to be copied per row. */
1300 uint32_t wmin;
1301 if (0 <= img->col_offset && (uint32_t)img->col_offset < imagewidth)
1302 {
1303 wmin = TIFFmin(w, imagewidth - img->col_offset);
1304 }
1305 else
1306 {
1307 TIFFErrorExtR(tif, TIFFFileName(tif),
1308 "Error in gtStripSeparate: column offset %d exceeds "
1309 "image width %d",
1310 img->col_offset, imagewidth);
1311 return 0;
1312 }
1313
1314 stripsize = TIFFStripSize(tif);
1315 bufsize =
1316 _TIFFMultiplySSize(tif, alpha ? 4 : 3, stripsize, "gtStripSeparate");
1317 if (bufsize == 0)
1318 {
1319 return (0);
1320 }
1321
1322 flip = setorientation(img);
1323 if (flip & FLIP_VERTICALLY)
1324 {
1325 if (w > INT_MAX / 2)
1326 {
1327 TIFFErrorExtR(tif, TIFFFileName(tif), "Width overflow");
1328 return (0);
1329 }
1330 y = h - 1;
1331 /* Skew back to the raster row before the currently written row
1332 * -> one raster width plus one image width. */
1333 toskew = -(int32_t)(w + wmin);
1334 }
1335 else
1336 {
1337 y = 0;
1338 /* Skew forward to the end of the raster width of the row currently
1339 * written. */
1340 toskew = w - wmin;
1341 }
1342
1343 switch (img->photometric)
1344 {
1345 case PHOTOMETRIC_MINISWHITE:
1346 case PHOTOMETRIC_MINISBLACK:
1347 case PHOTOMETRIC_PALETTE:
1348 colorchannels = 1;
1349 break;
1350
1351 default:
1352 colorchannels = 3;
1353 break;
1354 }
1355
1356 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
1357 if (rowsperstrip == 0)
1358 {
1359 TIFFErrorExtR(tif, TIFFFileName(tif), "rowsperstrip is zero");
1360 return (0);
1361 }
1362
1363 scanline = TIFFScanlineSize(tif);
1364 fromskew = (w < imagewidth ? imagewidth - w : 0);
1365 for (row = 0; row < h; row += nrow)
1366 {
1367 uint32_t temp;
1368 rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
1369 nrow = (row + rowstoread > h ? h - row : rowstoread);
1370 offset_row = row + img->row_offset;
1371 temp = (row + img->row_offset) % rowsperstrip + nrow;
1372 if (scanline > 0 && temp > (size_t)(TIFF_TMSIZE_T_MAX / scanline))
1373 {
1374 TIFFErrorExtR(tif, TIFFFileName(tif),
1375 "Integer overflow in gtStripSeparate");
1376 return 0;
1377 }
1378 if (buf == NULL)
1379 {
1380 if (_TIFFReadEncodedStripAndAllocBuffer(
1381 tif, TIFFComputeStrip(tif, offset_row, 0), (void **)&buf,
1382 bufsize, temp * scanline) == (tmsize_t)(-1) &&
1383 (buf == NULL || img->stoponerr))
1384 {
1385 ret = 0;
1386 break;
1387 }
1388 p0 = buf;
1389 if (colorchannels == 1)
1390 {
1391 p2 = p1 = p0;
1392 pa = (alpha ? (p0 + 3 * stripsize) : NULL);
1393 }
1394 else
1395 {
1396 p1 = p0 + stripsize;
1397 p2 = p1 + stripsize;
1398 pa = (alpha ? (p2 + stripsize) : NULL);
1399 }
1400 }
1401 else if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),
1402 p0, temp * scanline) == (tmsize_t)(-1) &&
1403 img->stoponerr)
1404 {
1405 ret = 0;
1406 break;
1407 }
1408 if (colorchannels > 1 &&
1409 TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1), p1,
1410 temp * scanline) == (tmsize_t)(-1) &&
1411 img->stoponerr)
1412 {
1413 ret = 0;
1414 break;
1415 }
1416 if (colorchannels > 1 &&
1417 TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2), p2,
1418 temp * scanline) == (tmsize_t)(-1) &&
1419 img->stoponerr)
1420 {
1421 ret = 0;
1422 break;
1423 }
1424 if (alpha)
1425 {
1426 if (TIFFReadEncodedStrip(
1427 tif, TIFFComputeStrip(tif, offset_row, colorchannels), pa,
1428 temp * scanline) == (tmsize_t)(-1) &&
1429 img->stoponerr)
1430 {
1431 ret = 0;
1432 break;
1433 }
1434 }
1435
1436 /* For SEPARATE the pos-offset is per sample and should not be
1437 * multiplied by img->samplesperpixel. */
1438 pos = ((row + img->row_offset) % rowsperstrip) * scanline +
1439 (tmsize_t)img->col_offset;
1440 tmsize_t roffset = (tmsize_t)y * w;
1441 (*put)(img, raster + roffset, 0, y, wmin, nrow, fromskew, toskew,
1442 p0 + pos, p1 + pos, p2 + pos, (alpha ? (pa + pos) : NULL));
1443 y += ((flip & FLIP_VERTICALLY) ? -(int32_t)nrow : (int32_t)nrow);
1444 }
1445
1446 if (flip & FLIP_HORIZONTALLY)
1447 {
1448 uint32_t line;
1449
1450 for (line = 0; line < h; line++)
1451 {
1452 uint32_t *left = raster + (line * w);
1453 /* Use wmin to only flip horizontally data in place and not complete
1454 * raster-row. */
1455 uint32_t *right = left + wmin - 1;
1456
1457 while (left < right)
1458 {
1459 uint32_t temp = *left;
1460 *left = *right;
1461 *right = temp;
1462 left++;
1463 right--;
1464 }
1465 }
1466 }
1467
1468 _TIFFfreeExt(img->tif, buf);
1469 return (ret);
1470}
1471
1472/*
1473 * The following routines move decoded data returned
1474 * from the TIFF library into rasters filled with packed
1475 * ABGR pixels (i.e. suitable for passing to lrecwrite.)
1476 *
1477 * The routines have been created according to the most
1478 * important cases and optimized. PickContigCase and
1479 * PickSeparateCase analyze the parameters and select
1480 * the appropriate "get" and "put" routine to use.
1481 */
1482#define REPEAT8(op) \
1483 REPEAT4(op); \
1484 REPEAT4(op)
1485#define REPEAT4(op) \
1486 REPEAT2(op); \
1487 REPEAT2(op)
1488#define REPEAT2(op) \
1489 op; \
1490 op
1491#define CASE8(x, op) \
1492 switch (x) \
1493 { \
1494 case 7: \
1495 op; /*-fallthrough*/ \
1496 case 6: \
1497 op; /*-fallthrough*/ \
1498 case 5: \
1499 op; /*-fallthrough*/ \
1500 case 4: \
1501 op; /*-fallthrough*/ \
1502 case 3: \
1503 op; /*-fallthrough*/ \
1504 case 2: \
1505 op; /*-fallthrough*/ \
1506 case 1: \
1507 op; \
1508 }
1509#define CASE4(x, op) \
1510 switch (x) \
1511 { \
1512 case 3: \
1513 op; /*-fallthrough*/ \
1514 case 2: \
1515 op; /*-fallthrough*/ \
1516 case 1: \
1517 op; \
1518 }
1519#define NOP
1520
1521#define UNROLL8(w, op1, op2) \
1522 { \
1523 uint32_t _x; \
1524 for (_x = w; _x >= 8; _x -= 8) \
1525 { \
1526 op1; \
1527 REPEAT8(op2); \
1528 } \
1529 if (_x > 0) \
1530 { \
1531 op1; \
1532 CASE8(_x, op2); \
1533 } \
1534 }
1535#define UNROLL4(w, op1, op2) \
1536 { \
1537 uint32_t _x; \
1538 for (_x = w; _x >= 4; _x -= 4) \
1539 { \
1540 op1; \
1541 REPEAT4(op2); \
1542 } \
1543 if (_x > 0) \
1544 { \
1545 op1; \
1546 CASE4(_x, op2); \
1547 } \
1548 }
1549#define UNROLL2(w, op1, op2) \
1550 { \
1551 uint32_t _x; \
1552 for (_x = w; _x >= 2; _x -= 2) \
1553 { \
1554 op1; \
1555 REPEAT2(op2); \
1556 } \
1557 if (_x) \
1558 { \
1559 op1; \
1560 op2; \
1561 } \
1562 }
1563
1564#define SKEW(r, g, b, skew) \
1565 { \
1566 r += skew; \
1567 g += skew; \
1568 b += skew; \
1569 }
1570#define SKEW4(r, g, b, a, skew) \
1571 { \
1572 r += skew; \
1573 g += skew; \
1574 b += skew; \
1575 a += skew; \
1576 }
1577
1578#define A1 (((uint32_t)0xffL) << 24)
1579#define PACK(r, g, b) \
1580 ((uint32_t)(r) | ((uint32_t)(g) << 8) | ((uint32_t)(b) << 16) | A1)
1581#define PACK4(r, g, b, a) \
1582 ((uint32_t)(r) | ((uint32_t)(g) << 8) | ((uint32_t)(b) << 16) | \
1583 ((uint32_t)(a) << 24))
1584#define W2B(v) (((v) >> 8) & 0xff)
1585/* TODO: PACKW should have be made redundant in favor of Bitdepth16To8 LUT */
1586#define PACKW(r, g, b) \
1587 ((uint32_t)W2B(r) | ((uint32_t)W2B(g) << 8) | ((uint32_t)W2B(b) << 16) | A1)
1588#define PACKW4(r, g, b, a) \
1589 ((uint32_t)W2B(r) | ((uint32_t)W2B(g) << 8) | ((uint32_t)W2B(b) << 16) | \
1590 ((uint32_t)W2B(a) << 24))
1591
1592#define DECLAREContigPutFunc(name) \
1593 static void name(TIFFRGBAImage *img, uint32_t *cp, uint32_t x, uint32_t y, \
1594 uint32_t w, uint32_t h, int32_t fromskew, int32_t toskew, \
1595 unsigned char *pp)
1596
1597/*
1598 * 8-bit palette => colormap/RGB
1599 */
1600DECLAREContigPutFunc(put8bitcmaptile)
1601{
1602 uint32_t **PALmap = img->PALmap;
1603 int samplesperpixel = img->samplesperpixel;
1604
1605 (void)y;
1606 for (; h > 0; --h)
1607 {
1608 for (x = w; x > 0; --x)
1609 {
1610 *cp++ = PALmap[*pp][0];
1611 pp += samplesperpixel;
1612 }
1613 cp += toskew;
1614 pp += fromskew;
1615 }
1616}
1617
1618/*
1619 * 4-bit palette => colormap/RGB
1620 */
1621DECLAREContigPutFunc(put4bitcmaptile)
1622{
1623 uint32_t **PALmap = img->PALmap;
1624
1625 (void)x;
1626 (void)y;
1627 fromskew /= 2;
1628 for (; h > 0; --h)
1629 {
1630 uint32_t *bw;
1631 UNROLL2(w, bw = PALmap[*pp++], *cp++ = *bw++);
1632 cp += toskew;
1633 pp += fromskew;
1634 }
1635}
1636
1637/*
1638 * 2-bit palette => colormap/RGB
1639 */
1640DECLAREContigPutFunc(put2bitcmaptile)
1641{
1642 uint32_t **PALmap = img->PALmap;
1643
1644 (void)x;
1645 (void)y;
1646 fromskew /= 4;
1647 for (; h > 0; --h)
1648 {
1649 uint32_t *bw;
1650 UNROLL4(w, bw = PALmap[*pp++], *cp++ = *bw++);
1651 cp += toskew;
1652 pp += fromskew;
1653 }
1654}
1655
1656/*
1657 * 1-bit palette => colormap/RGB
1658 */
1659DECLAREContigPutFunc(put1bitcmaptile)
1660{
1661 uint32_t **PALmap = img->PALmap;
1662
1663 (void)x;
1664 (void)y;
1665 fromskew /= 8;
1666 for (; h > 0; --h)
1667 {
1668 uint32_t *bw;
1669 UNROLL8(w, bw = PALmap[*pp++], *cp++ = *bw++);
1670 cp += toskew;
1671 pp += fromskew;
1672 }
1673}
1674
1675/*
1676 * 8-bit greyscale => colormap/RGB
1677 */
1678DECLAREContigPutFunc(putgreytile)
1679{
1680 int samplesperpixel = img->samplesperpixel;
1681 uint32_t **BWmap = img->BWmap;
1682
1683 (void)y;
1684 for (; h > 0; --h)
1685 {
1686 for (x = w; x > 0; --x)
1687 {
1688 *cp++ = BWmap[*pp][0];
1689 pp += samplesperpixel;
1690 }
1691 cp += toskew;
1692 pp += fromskew;
1693 }
1694}
1695
1696/*
1697 * 8-bit greyscale with associated alpha => colormap/RGBA
1698 */
1699DECLAREContigPutFunc(putagreytile)
1700{
1701 int samplesperpixel = img->samplesperpixel;
1702 uint32_t **BWmap = img->BWmap;
1703
1704 (void)y;
1705 for (; h > 0; --h)
1706 {
1707 for (x = w; x > 0; --x)
1708 {
1709 *cp++ = BWmap[*pp][0] & ((uint32_t) * (pp + 1) << 24 | ~A1);
1710 pp += samplesperpixel;
1711 }
1712 cp += toskew;
1713 pp += fromskew;
1714 }
1715}
1716
1717/*
1718 * 16-bit greyscale => colormap/RGB
1719 */
1720DECLAREContigPutFunc(put16bitbwtile)
1721{
1722 int samplesperpixel = img->samplesperpixel;
1723 uint32_t **BWmap = img->BWmap;
1724
1725 (void)y;
1726 for (; h > 0; --h)
1727 {
1728 uint16_t *wp = (uint16_t *)pp;
1729
1730 for (x = w; x > 0; --x)
1731 {
1732 /* use high order byte of 16bit value */
1733
1734 *cp++ = BWmap[*wp >> 8][0];
1735 pp += 2 * samplesperpixel;
1736 wp += samplesperpixel;
1737 }
1738 cp += toskew;
1739 pp += fromskew;
1740 }
1741}
1742
1743/*
1744 * 1-bit bilevel => colormap/RGB
1745 */
1746DECLAREContigPutFunc(put1bitbwtile)
1747{
1748 uint32_t **BWmap = img->BWmap;
1749
1750 (void)x;
1751 (void)y;
1752 fromskew /= 8;
1753 for (; h > 0; --h)
1754 {
1755 uint32_t *bw;
1756 UNROLL8(w, bw = BWmap[*pp++], *cp++ = *bw++);
1757 cp += toskew;
1758 pp += fromskew;
1759 }
1760}
1761
1762/*
1763 * 2-bit greyscale => colormap/RGB
1764 */
1765DECLAREContigPutFunc(put2bitbwtile)
1766{
1767 uint32_t **BWmap = img->BWmap;
1768
1769 (void)x;
1770 (void)y;
1771 fromskew /= 4;
1772 for (; h > 0; --h)
1773 {
1774 uint32_t *bw;
1775 UNROLL4(w, bw = BWmap[*pp++], *cp++ = *bw++);
1776 cp += toskew;
1777 pp += fromskew;
1778 }
1779}
1780
1781/*
1782 * 4-bit greyscale => colormap/RGB
1783 */
1784DECLAREContigPutFunc(put4bitbwtile)
1785{
1786 uint32_t **BWmap = img->BWmap;
1787
1788 (void)x;
1789 (void)y;
1790 fromskew /= 2;
1791 for (; h > 0; --h)
1792 {
1793 uint32_t *bw;
1794 UNROLL2(w, bw = BWmap[*pp++], *cp++ = *bw++);
1795 cp += toskew;
1796 pp += fromskew;
1797 }
1798}
1799
1800/*
1801 * 8-bit packed samples, no Map => RGB
1802 */
1803DECLAREContigPutFunc(putRGBcontig8bittile)
1804{
1805 int samplesperpixel = img->samplesperpixel;
1806
1807 (void)x;
1808 (void)y;
1809 fromskew *= samplesperpixel;
1810 for (; h > 0; --h)
1811 {
1812 UNROLL8(w, NOP, *cp++ = PACK(pp[0], pp[1], pp[2]);
1813 pp += samplesperpixel);
1814 cp += toskew;
1815 pp += fromskew;
1816 }
1817}
1818
1819/*
1820 * 8-bit packed samples => RGBA w/ associated alpha
1821 * (known to have Map == NULL)
1822 */
1823DECLAREContigPutFunc(putRGBAAcontig8bittile)
1824{
1825 int samplesperpixel = img->samplesperpixel;
1826
1827 (void)x;
1828 (void)y;
1829 fromskew *= samplesperpixel;
1830 for (; h > 0; --h)
1831 {
1832 UNROLL8(w, NOP, *cp++ = PACK4(pp[0], pp[1], pp[2], pp[3]);
1833 pp += samplesperpixel);
1834 cp += toskew;
1835 pp += fromskew;
1836 }
1837}
1838
1839/*
1840 * 8-bit packed samples => RGBA w/ unassociated alpha
1841 * (known to have Map == NULL)
1842 */
1843DECLAREContigPutFunc(putRGBUAcontig8bittile)
1844{
1845 int samplesperpixel = img->samplesperpixel;
1846 (void)y;
1847 fromskew *= samplesperpixel;
1848 for (; h > 0; --h)
1849 {
1850 uint32_t r, g, b, a;
1851 uint8_t *m;
1852 for (x = w; x > 0; --x)
1853 {
1854 a = pp[3];
1855 m = img->UaToAa + ((size_t)a << 8);
1856 r = m[pp[0]];
1857 g = m[pp[1]];
1858 b = m[pp[2]];
1859 *cp++ = PACK4(r, g, b, a);
1860 pp += samplesperpixel;
1861 }
1862 cp += toskew;
1863 pp += fromskew;
1864 }
1865}
1866
1867/*
1868 * 16-bit packed samples => RGB
1869 */
1870DECLAREContigPutFunc(putRGBcontig16bittile)
1871{
1872 int samplesperpixel = img->samplesperpixel;
1873 uint16_t *wp = (uint16_t *)pp;
1874 (void)y;
1875 fromskew *= samplesperpixel;
1876 for (; h > 0; --h)
1877 {
1878 for (x = w; x > 0; --x)
1879 {
1880 *cp++ = PACK(img->Bitdepth16To8[wp[0]], img->Bitdepth16To8[wp[1]],
1881 img->Bitdepth16To8[wp[2]]);
1882 wp += samplesperpixel;
1883 }
1884 cp += toskew;
1885 wp += fromskew;
1886 }
1887}
1888
1889/*
1890 * 16-bit packed samples => RGBA w/ associated alpha
1891 * (known to have Map == NULL)
1892 */
1893DECLAREContigPutFunc(putRGBAAcontig16bittile)
1894{
1895 int samplesperpixel = img->samplesperpixel;
1896 uint16_t *wp = (uint16_t *)pp;
1897 (void)y;
1898 fromskew *= samplesperpixel;
1899 for (; h > 0; --h)
1900 {
1901 for (x = w; x > 0; --x)
1902 {
1903 *cp++ = PACK4(img->Bitdepth16To8[wp[0]], img->Bitdepth16To8[wp[1]],
1904 img->Bitdepth16To8[wp[2]], img->Bitdepth16To8[wp[3]]);
1905 wp += samplesperpixel;
1906 }
1907 cp += toskew;
1908 wp += fromskew;
1909 }
1910}
1911
1912/*
1913 * 16-bit packed samples => RGBA w/ unassociated alpha
1914 * (known to have Map == NULL)
1915 */
1916DECLAREContigPutFunc(putRGBUAcontig16bittile)
1917{
1918 int samplesperpixel = img->samplesperpixel;
1919 uint16_t *wp = (uint16_t *)pp;
1920 (void)y;
1921 fromskew *= samplesperpixel;
1922 for (; h > 0; --h)
1923 {
1924 uint32_t r, g, b, a;
1925 uint8_t *m;
1926 for (x = w; x > 0; --x)
1927 {
1928 a = img->Bitdepth16To8[wp[3]];
1929 m = img->UaToAa + ((size_t)a << 8);
1930 r = m[img->Bitdepth16To8[wp[0]]];
1931 g = m[img->Bitdepth16To8[wp[1]]];
1932 b = m[img->Bitdepth16To8[wp[2]]];
1933 *cp++ = PACK4(r, g, b, a);
1934 wp += samplesperpixel;
1935 }
1936 cp += toskew;
1937 wp += fromskew;
1938 }
1939}
1940
1941/*
1942 * 8-bit packed CMYK samples w/o Map => RGB
1943 *
1944 * NB: The conversion of CMYK->RGB is *very* crude.
1945 */
1946DECLAREContigPutFunc(putRGBcontig8bitCMYKtile)
1947{
1948 int samplesperpixel = img->samplesperpixel;
1949 uint16_t r, g, b, k;
1950
1951 (void)x;
1952 (void)y;
1953 fromskew *= samplesperpixel;
1954 for (; h > 0; --h)
1955 {
1956 UNROLL8(w, NOP, k = 255 - pp[3]; r = (k * (255 - pp[0])) / 255;
1957 g = (k * (255 - pp[1])) / 255; b = (k * (255 - pp[2])) / 255;
1958 *cp++ = PACK(r, g, b); pp += samplesperpixel);
1959 cp += toskew;
1960 pp += fromskew;
1961 }
1962}
1963
1964/*
1965 * 8-bit packed CMYK samples w/Map => RGB
1966 *
1967 * NB: The conversion of CMYK->RGB is *very* crude.
1968 */
1969DECLAREContigPutFunc(putRGBcontig8bitCMYKMaptile)
1970{
1971 int samplesperpixel = img->samplesperpixel;
1972 TIFFRGBValue *Map = img->Map;
1973 uint16_t r, g, b, k;
1974
1975 (void)y;
1976 fromskew *= samplesperpixel;
1977 for (; h > 0; --h)
1978 {
1979 for (x = w; x > 0; --x)
1980 {
1981 k = 255 - pp[3];
1982 r = (k * (255 - pp[0])) / 255;
1983 g = (k * (255 - pp[1])) / 255;
1984 b = (k * (255 - pp[2])) / 255;
1985 *cp++ = PACK(Map[r], Map[g], Map[b]);
1986 pp += samplesperpixel;
1987 }
1988 pp += fromskew;
1989 cp += toskew;
1990 }
1991}
1992
1993#define DECLARESepPutFunc(name) \
1994 static void name(TIFFRGBAImage *img, uint32_t *cp, uint32_t x, uint32_t y, \
1995 uint32_t w, uint32_t h, int32_t fromskew, int32_t toskew, \
1996 unsigned char *r, unsigned char *g, unsigned char *b, \
1997 unsigned char *a)
1998
1999/*
2000 * 8-bit unpacked samples => RGB
2001 */
2002DECLARESepPutFunc(putRGBseparate8bittile)
2003{
2004 (void)img;
2005 (void)x;
2006 (void)y;
2007 (void)a;
2008 for (; h > 0; --h)
2009 {
2010 UNROLL8(w, NOP, *cp++ = PACK(*r++, *g++, *b++));
2011 SKEW(r, g, b, fromskew);
2012 cp += toskew;
2013 }
2014}
2015
2016/*
2017 * 8-bit unpacked samples => RGBA w/ associated alpha
2018 */
2019DECLARESepPutFunc(putRGBAAseparate8bittile)
2020{
2021 (void)img;
2022 (void)x;
2023 (void)y;
2024 for (; h > 0; --h)
2025 {
2026 UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++));
2027 SKEW4(r, g, b, a, fromskew);
2028 cp += toskew;
2029 }
2030}
2031
2032/*
2033 * 8-bit unpacked CMYK samples => RGBA
2034 */
2035DECLARESepPutFunc(putCMYKseparate8bittile)
2036{
2037 (void)img;
2038 (void)y;
2039 for (; h > 0; --h)
2040 {
2041 uint32_t rv, gv, bv, kv;
2042 for (x = w; x > 0; --x)
2043 {
2044 kv = 255 - *a++;
2045 rv = (kv * (255 - *r++)) / 255;
2046 gv = (kv * (255 - *g++)) / 255;
2047 bv = (kv * (255 - *b++)) / 255;
2048 *cp++ = PACK4(rv, gv, bv, 255);
2049 }
2050 SKEW4(r, g, b, a, fromskew);
2051 cp += toskew;
2052 }
2053}
2054
2055/*
2056 * 8-bit unpacked samples => RGBA w/ unassociated alpha
2057 */
2058DECLARESepPutFunc(putRGBUAseparate8bittile)
2059{
2060 (void)img;
2061 (void)y;
2062 for (; h > 0; --h)
2063 {
2064 uint32_t rv, gv, bv, av;
2065 uint8_t *m;
2066 for (x = w; x > 0; --x)
2067 {
2068 av = *a++;
2069 m = img->UaToAa + ((size_t)av << 8);
2070 rv = m[*r++];
2071 gv = m[*g++];
2072 bv = m[*b++];
2073 *cp++ = PACK4(rv, gv, bv, av);
2074 }
2075 SKEW4(r, g, b, a, fromskew);
2076 cp += toskew;
2077 }
2078}
2079
2080/*
2081 * 16-bit unpacked samples => RGB
2082 */
2083DECLARESepPutFunc(putRGBseparate16bittile)
2084{
2085 uint16_t *wr = (uint16_t *)r;
2086 uint16_t *wg = (uint16_t *)g;
2087 uint16_t *wb = (uint16_t *)b;
2088 (void)img;
2089 (void)y;
2090 (void)a;
2091 for (; h > 0; --h)
2092 {
2093 for (x = 0; x < w; x++)
2094 *cp++ = PACK(img->Bitdepth16To8[*wr++], img->Bitdepth16To8[*wg++],
2095 img->Bitdepth16To8[*wb++]);
2096 SKEW(wr, wg, wb, fromskew);
2097 cp += toskew;
2098 }
2099}
2100
2101/*
2102 * 16-bit unpacked samples => RGBA w/ associated alpha
2103 */
2104DECLARESepPutFunc(putRGBAAseparate16bittile)
2105{
2106 uint16_t *wr = (uint16_t *)r;
2107 uint16_t *wg = (uint16_t *)g;
2108 uint16_t *wb = (uint16_t *)b;
2109 uint16_t *wa = (uint16_t *)a;
2110 (void)img;
2111 (void)y;
2112 for (; h > 0; --h)
2113 {
2114 for (x = 0; x < w; x++)
2115 *cp++ = PACK4(img->Bitdepth16To8[*wr++], img->Bitdepth16To8[*wg++],
2116 img->Bitdepth16To8[*wb++], img->Bitdepth16To8[*wa++]);
2117 SKEW4(wr, wg, wb, wa, fromskew);
2118 cp += toskew;
2119 }
2120}
2121
2122/*
2123 * 16-bit unpacked samples => RGBA w/ unassociated alpha
2124 */
2125DECLARESepPutFunc(putRGBUAseparate16bittile)
2126{
2127 uint16_t *wr = (uint16_t *)r;
2128 uint16_t *wg = (uint16_t *)g;
2129 uint16_t *wb = (uint16_t *)b;
2130 uint16_t *wa = (uint16_t *)a;
2131 (void)img;
2132 (void)y;
2133 for (; h > 0; --h)
2134 {
2135 uint32_t r2, g2, b2, a2;
2136 uint8_t *m;
2137 for (x = w; x > 0; --x)
2138 {
2139 a2 = img->Bitdepth16To8[*wa++];
2140 m = img->UaToAa + ((size_t)a2 << 8);
2141 r2 = m[img->Bitdepth16To8[*wr++]];
2142 g2 = m[img->Bitdepth16To8[*wg++]];
2143 b2 = m[img->Bitdepth16To8[*wb++]];
2144 *cp++ = PACK4(r2, g2, b2, a2);
2145 }
2146 SKEW4(wr, wg, wb, wa, fromskew);
2147 cp += toskew;
2148 }
2149}
2150
2151/*
2152 * 8-bit packed CIE L*a*b 1976 samples => RGB
2153 */
2154DECLAREContigPutFunc(putcontig8bitCIELab8)
2155{
2156 float X, Y, Z;
2157 uint32_t r, g, b;
2158 (void)y;
2159 fromskew *= 3;
2160 for (; h > 0; --h)
2161 {
2162 for (x = w; x > 0; --x)
2163 {
2164 TIFFCIELabToXYZ(img->cielab, (unsigned char)pp[0],
2165 (signed char)pp[1], (signed char)pp[2], &X, &Y, &Z);
2166 TIFFXYZToRGB(img->cielab, X, Y, Z, &r, &g, &b);
2167 *cp++ = PACK(r, g, b);
2168 pp += 3;
2169 }
2170 cp += toskew;
2171 pp += fromskew;
2172 }
2173}
2174
2175/*
2176 * 16-bit packed CIE L*a*b 1976 samples => RGB
2177 */
2178DECLAREContigPutFunc(putcontig8bitCIELab16)
2179{
2180 float X, Y, Z;
2181 uint32_t r, g, b;
2182 uint16_t *wp = (uint16_t *)pp;
2183 (void)y;
2184 fromskew *= 3;
2185 for (; h > 0; --h)
2186 {
2187 for (x = w; x > 0; --x)
2188 {
2189 TIFFCIELab16ToXYZ(img->cielab, (uint16_t)wp[0], (int16_t)wp[1],
2190 (int16_t)wp[2], &X, &Y, &Z);
2191 TIFFXYZToRGB(img->cielab, X, Y, Z, &r, &g, &b);
2192 *cp++ = PACK(r, g, b);
2193 wp += 3;
2194 }
2195 cp += toskew;
2196 wp += fromskew;
2197 }
2198}
2199
2200/*
2201 * YCbCr -> RGB conversion and packing routines.
2202 */
2203
2204#define YCbCrtoRGB(dst, Y) \
2205 { \
2206 uint32_t r, g, b; \
2207 TIFFYCbCrtoRGB(img->ycbcr, (Y), Cb, Cr, &r, &g, &b); \
2208 dst = PACK(r, g, b); \
2209 }
2210
2211/*
2212 * 8-bit packed YCbCr samples w/ 4,4 subsampling => RGB
2213 */
2214DECLAREContigPutFunc(putcontig8bitYCbCr44tile)
2215{
2216 uint32_t *cp1 = cp + w + toskew;
2217 uint32_t *cp2 = cp1 + w + toskew;
2218 uint32_t *cp3 = cp2 + w + toskew;
2219 int32_t incr = 3 * w + 4 * toskew;
2220
2221 (void)y;
2222 /* adjust fromskew */
2223 fromskew = (fromskew / 4) * (4 * 2 + 2);
2224 if ((h & 3) == 0 && (w & 3) == 0)
2225 {
2226 for (; h >= 4; h -= 4)
2227 {
2228 x = w >> 2;
2229 do
2230 {
2231 int32_t Cb = pp[16];
2232 int32_t Cr = pp[17];
2233
2234 YCbCrtoRGB(cp[0], pp[0]);
2235 YCbCrtoRGB(cp[1], pp[1]);
2236 YCbCrtoRGB(cp[2], pp[2]);
2237 YCbCrtoRGB(cp[3], pp[3]);
2238 YCbCrtoRGB(cp1[0], pp[4]);
2239 YCbCrtoRGB(cp1[1], pp[5]);
2240 YCbCrtoRGB(cp1[2], pp[6]);
2241 YCbCrtoRGB(cp1[3], pp[7]);
2242 YCbCrtoRGB(cp2[0], pp[8]);
2243 YCbCrtoRGB(cp2[1], pp[9]);
2244 YCbCrtoRGB(cp2[2], pp[10]);
2245 YCbCrtoRGB(cp2[3], pp[11]);
2246 YCbCrtoRGB(cp3[0], pp[12]);
2247 YCbCrtoRGB(cp3[1], pp[13]);
2248 YCbCrtoRGB(cp3[2], pp[14]);
2249 YCbCrtoRGB(cp3[3], pp[15]);
2250
2251 cp += 4;
2252 cp1 += 4;
2253 cp2 += 4;
2254 cp3 += 4;
2255 pp += 18;
2256 } while (--x);
2257 cp += incr;
2258 cp1 += incr;
2259 cp2 += incr;
2260 cp3 += incr;
2261 pp += fromskew;
2262 }
2263 }
2264 else
2265 {
2266 while (h > 0)
2267 {
2268 for (x = w; x > 0;)
2269 {
2270 int32_t Cb = pp[16];
2271 int32_t Cr = pp[17];
2272 switch (x)
2273 {
2274 default:
2275 switch (h)
2276 {
2277 default:
2278 YCbCrtoRGB(cp3[3], pp[15]); /* FALLTHROUGH */
2279 case 3:
2280 YCbCrtoRGB(cp2[3], pp[11]); /* FALLTHROUGH */
2281 case 2:
2282 YCbCrtoRGB(cp1[3], pp[7]); /* FALLTHROUGH */
2283 case 1:
2284 YCbCrtoRGB(cp[3], pp[3]); /* FALLTHROUGH */
2285 } /* FALLTHROUGH */
2286 case 3:
2287 switch (h)
2288 {
2289 default:
2290 YCbCrtoRGB(cp3[2], pp[14]); /* FALLTHROUGH */
2291 case 3:
2292 YCbCrtoRGB(cp2[2], pp[10]); /* FALLTHROUGH */
2293 case 2:
2294 YCbCrtoRGB(cp1[2], pp[6]); /* FALLTHROUGH */
2295 case 1:
2296 YCbCrtoRGB(cp[2], pp[2]); /* FALLTHROUGH */
2297 } /* FALLTHROUGH */
2298 case 2:
2299 switch (h)
2300 {
2301 default:
2302 YCbCrtoRGB(cp3[1], pp[13]); /* FALLTHROUGH */
2303 case 3:
2304 YCbCrtoRGB(cp2[1], pp[9]); /* FALLTHROUGH */
2305 case 2:
2306 YCbCrtoRGB(cp1[1], pp[5]); /* FALLTHROUGH */
2307 case 1:
2308 YCbCrtoRGB(cp[1], pp[1]); /* FALLTHROUGH */
2309 } /* FALLTHROUGH */
2310 case 1:
2311 switch (h)
2312 {
2313 default:
2314 YCbCrtoRGB(cp3[0], pp[12]); /* FALLTHROUGH */
2315 case 3:
2316 YCbCrtoRGB(cp2[0], pp[8]); /* FALLTHROUGH */
2317 case 2:
2318 YCbCrtoRGB(cp1[0], pp[4]); /* FALLTHROUGH */
2319 case 1:
2320 YCbCrtoRGB(cp[0], pp[0]); /* FALLTHROUGH */
2321 } /* FALLTHROUGH */
2322 }
2323 if (x < 4)
2324 {
2325 cp += x;
2326 cp1 += x;
2327 cp2 += x;
2328 cp3 += x;
2329 x = 0;
2330 }
2331 else
2332 {
2333 cp += 4;
2334 cp1 += 4;
2335 cp2 += 4;
2336 cp3 += 4;
2337 x -= 4;
2338 }
2339 pp += 18;
2340 }
2341 if (h <= 4)
2342 break;
2343 h -= 4;
2344 cp += incr;
2345 cp1 += incr;
2346 cp2 += incr;
2347 cp3 += incr;
2348 pp += fromskew;
2349 }
2350 }
2351}
2352
2353/*
2354 * 8-bit packed YCbCr samples w/ 4,2 subsampling => RGB
2355 */
2356DECLAREContigPutFunc(putcontig8bitYCbCr42tile)
2357{
2358 uint32_t *cp1 = cp + w + toskew;
2359 int32_t incr = 2 * toskew + w;
2360
2361 (void)y;
2362 fromskew = (fromskew / 4) * (4 * 2 + 2);
2363 if ((w & 3) == 0 && (h & 1) == 0)
2364 {
2365 for (; h >= 2; h -= 2)
2366 {
2367 x = w >> 2;
2368 do
2369 {
2370 int32_t Cb = pp[8];
2371 int32_t Cr = pp[9];
2372
2373 YCbCrtoRGB(cp[0], pp[0]);
2374 YCbCrtoRGB(cp[1], pp[1]);
2375 YCbCrtoRGB(cp[2], pp[2]);
2376 YCbCrtoRGB(cp[3], pp[3]);
2377 YCbCrtoRGB(cp1[0], pp[4]);
2378 YCbCrtoRGB(cp1[1], pp[5]);
2379 YCbCrtoRGB(cp1[2], pp[6]);
2380 YCbCrtoRGB(cp1[3], pp[7]);
2381
2382 cp += 4;
2383 cp1 += 4;
2384 pp += 10;
2385 } while (--x);
2386 cp += incr;
2387 cp1 += incr;
2388 pp += fromskew;
2389 }
2390 }
2391 else
2392 {
2393 while (h > 0)
2394 {
2395 for (x = w; x > 0;)
2396 {
2397 int32_t Cb = pp[8];
2398 int32_t Cr = pp[9];
2399 switch (x)
2400 {
2401 default:
2402 switch (h)
2403 {
2404 default:
2405 YCbCrtoRGB(cp1[3], pp[7]); /* FALLTHROUGH */
2406 case 1:
2407 YCbCrtoRGB(cp[3], pp[3]); /* FALLTHROUGH */
2408 } /* FALLTHROUGH */
2409 case 3:
2410 switch (h)
2411 {
2412 default:
2413 YCbCrtoRGB(cp1[2], pp[6]); /* FALLTHROUGH */
2414 case 1:
2415 YCbCrtoRGB(cp[2], pp[2]); /* FALLTHROUGH */
2416 } /* FALLTHROUGH */
2417 case 2:
2418 switch (h)
2419 {
2420 default:
2421 YCbCrtoRGB(cp1[1], pp[5]); /* FALLTHROUGH */
2422 case 1:
2423 YCbCrtoRGB(cp[1], pp[1]); /* FALLTHROUGH */
2424 } /* FALLTHROUGH */
2425 case 1:
2426 switch (h)
2427 {
2428 default:
2429 YCbCrtoRGB(cp1[0], pp[4]); /* FALLTHROUGH */
2430 case 1:
2431 YCbCrtoRGB(cp[0], pp[0]); /* FALLTHROUGH */
2432 } /* FALLTHROUGH */
2433 }
2434 if (x < 4)
2435 {
2436 cp += x;
2437 cp1 += x;
2438 x = 0;
2439 }
2440 else
2441 {
2442 cp += 4;
2443 cp1 += 4;
2444 x -= 4;
2445 }
2446 pp += 10;
2447 }
2448 if (h <= 2)
2449 break;
2450 h -= 2;
2451 cp += incr;
2452 cp1 += incr;
2453 pp += fromskew;
2454 }
2455 }
2456}
2457
2458/*
2459 * 8-bit packed YCbCr samples w/ 4,1 subsampling => RGB
2460 */
2461DECLAREContigPutFunc(putcontig8bitYCbCr41tile)
2462{
2463 (void)y;
2464 fromskew = (fromskew / 4) * (4 * 1 + 2);
2465 do
2466 {
2467 x = w >> 2;
2468 while (x > 0)
2469 {
2470 int32_t Cb = pp[4];
2471 int32_t Cr = pp[5];
2472
2473 YCbCrtoRGB(cp[0], pp[0]);
2474 YCbCrtoRGB(cp[1], pp[1]);
2475 YCbCrtoRGB(cp[2], pp[2]);
2476 YCbCrtoRGB(cp[3], pp[3]);
2477
2478 cp += 4;
2479 pp += 6;
2480 x--;
2481 }
2482
2483 if ((w & 3) != 0)
2484 {
2485 int32_t Cb = pp[4];
2486 int32_t Cr = pp[5];
2487
2488 switch ((w & 3))
2489 {
2490 case 3:
2491 YCbCrtoRGB(cp[2], pp[2]); /*-fallthrough*/
2492 case 2:
2493 YCbCrtoRGB(cp[1], pp[1]); /*-fallthrough*/
2494 case 1:
2495 YCbCrtoRGB(cp[0], pp[0]); /*-fallthrough*/
2496 case 0:
2497 break;
2498 }
2499
2500 cp += (w & 3);
2501 pp += 6;
2502 }
2503
2504 cp += toskew;
2505 pp += fromskew;
2506 } while (--h);
2507}
2508
2509/*
2510 * 8-bit packed YCbCr samples w/ 2,2 subsampling => RGB
2511 */
2512DECLAREContigPutFunc(putcontig8bitYCbCr22tile)
2513{
2514 uint32_t *cp2;
2515 int32_t incr = 2 * toskew + w;
2516 (void)y;
2517 fromskew = (fromskew / 2) * (2 * 2 + 2);
2518 cp2 = cp + w + toskew;
2519 while (h >= 2)
2520 {
2521 x = w;
2522 while (x >= 2)
2523 {
2524 uint32_t Cb = pp[4];
2525 uint32_t Cr = pp[5];
2526 YCbCrtoRGB(cp[0], pp[0]);
2527 YCbCrtoRGB(cp[1], pp[1]);
2528 YCbCrtoRGB(cp2[0], pp[2]);
2529 YCbCrtoRGB(cp2[1], pp[3]);
2530 cp += 2;
2531 cp2 += 2;
2532 pp += 6;
2533 x -= 2;
2534 }
2535 if (x == 1)
2536 {
2537 uint32_t Cb = pp[4];
2538 uint32_t Cr = pp[5];
2539 YCbCrtoRGB(cp[0], pp[0]);
2540 YCbCrtoRGB(cp2[0], pp[2]);
2541 cp++;
2542 cp2++;
2543 pp += 6;
2544 }
2545 cp += incr;
2546 cp2 += incr;
2547 pp += fromskew;
2548 h -= 2;
2549 }
2550 if (h == 1)
2551 {
2552 x = w;
2553 while (x >= 2)
2554 {
2555 uint32_t Cb = pp[4];
2556 uint32_t Cr = pp[5];
2557 YCbCrtoRGB(cp[0], pp[0]);
2558 YCbCrtoRGB(cp[1], pp[1]);
2559 cp += 2;
2560 cp2 += 2;
2561 pp += 6;
2562 x -= 2;
2563 }
2564 if (x == 1)
2565 {
2566 uint32_t Cb = pp[4];
2567 uint32_t Cr = pp[5];
2568 YCbCrtoRGB(cp[0], pp[0]);
2569 }
2570 }
2571}
2572
2573/*
2574 * 8-bit packed YCbCr samples w/ 2,1 subsampling => RGB
2575 */
2576DECLAREContigPutFunc(putcontig8bitYCbCr21tile)
2577{
2578 (void)y;
2579 fromskew = (fromskew / 2) * (2 * 1 + 2);
2580 do
2581 {
2582 x = w >> 1;
2583 while (x > 0)
2584 {
2585 int32_t Cb = pp[2];
2586 int32_t Cr = pp[3];
2587
2588 YCbCrtoRGB(cp[0], pp[0]);
2589 YCbCrtoRGB(cp[1], pp[1]);
2590
2591 cp += 2;
2592 pp += 4;
2593 x--;
2594 }
2595
2596 if ((w & 1) != 0)
2597 {
2598 int32_t Cb = pp[2];
2599 int32_t Cr = pp[3];
2600
2601 YCbCrtoRGB(cp[0], pp[0]);
2602
2603 cp += 1;
2604 pp += 4;
2605 }
2606
2607 cp += toskew;
2608 pp += fromskew;
2609 } while (--h);
2610}
2611
2612/*
2613 * 8-bit packed YCbCr samples w/ 1,2 subsampling => RGB
2614 */
2615DECLAREContigPutFunc(putcontig8bitYCbCr12tile)
2616{
2617 uint32_t *cp2;
2618 int32_t incr = 2 * toskew + w;
2619 (void)y;
2620 fromskew = (fromskew / 1) * (1 * 2 + 2);
2621 cp2 = cp + w + toskew;
2622 while (h >= 2)
2623 {
2624 x = w;
2625 do
2626 {
2627 uint32_t Cb = pp[2];
2628 uint32_t Cr = pp[3];
2629 YCbCrtoRGB(cp[0], pp[0]);
2630 YCbCrtoRGB(cp2[0], pp[1]);
2631 cp++;
2632 cp2++;
2633 pp += 4;
2634 } while (--x);
2635 cp += incr;
2636 cp2 += incr;
2637 pp += fromskew;
2638 h -= 2;
2639 }
2640 if (h == 1)
2641 {
2642 x = w;
2643 do
2644 {
2645 uint32_t Cb = pp[2];
2646 uint32_t Cr = pp[3];
2647 YCbCrtoRGB(cp[0], pp[0]);
2648 cp++;
2649 pp += 4;
2650 } while (--x);
2651 }
2652}
2653
2654/*
2655 * 8-bit packed YCbCr samples w/ no subsampling => RGB
2656 */
2657DECLAREContigPutFunc(putcontig8bitYCbCr11tile)
2658{
2659 (void)y;
2660 fromskew = (fromskew / 1) * (1 * 1 + 2);
2661 do
2662 {
2663 x = w; /* was x = w>>1; patched 2000/09/25 warmerda@home.com */
2664 do
2665 {
2666 int32_t Cb = pp[1];
2667 int32_t Cr = pp[2];
2668
2669 YCbCrtoRGB(*cp++, pp[0]);
2670
2671 pp += 3;
2672 } while (--x);
2673 cp += toskew;
2674 pp += fromskew;
2675 } while (--h);
2676}
2677
2678/*
2679 * 8-bit packed YCbCr samples w/ no subsampling => RGB
2680 */
2681DECLARESepPutFunc(putseparate8bitYCbCr11tile)
2682{
2683 (void)y;
2684 (void)a;
2685 /* TODO: naming of input vars is still off, change obfuscating declaration
2686 * inside define, or resolve obfuscation */
2687 for (; h > 0; --h)
2688 {
2689 x = w;
2690 do
2691 {
2692 uint32_t dr, dg, db;
2693 TIFFYCbCrtoRGB(img->ycbcr, *r++, *g++, *b++, &dr, &dg, &db);
2694 *cp++ = PACK(dr, dg, db);
2695 } while (--x);
2696 SKEW(r, g, b, fromskew);
2697 cp += toskew;
2698 }
2699}
2700#undef YCbCrtoRGB
2701
2702static int isInRefBlackWhiteRange(float f)
2703{
2704 return f > (float)(-0x7FFFFFFF + 128) && f < (float)0x7FFFFFFF;
2705}
2706
2707static int initYCbCrConversion(TIFFRGBAImage *img)
2708{
2709 static const char module[] = "initYCbCrConversion";
2710
2711 float *luma, *refBlackWhite;
2712
2713 if (img->ycbcr == NULL)
2714 {
2715 img->ycbcr = (TIFFYCbCrToRGB *)_TIFFmallocExt(
2716 img->tif, TIFFroundup_32(sizeof(TIFFYCbCrToRGB), sizeof(long)) +
2717 4 * 256 * sizeof(TIFFRGBValue) +
2718 2 * 256 * sizeof(int) + 3 * 256 * sizeof(int32_t));
2719 if (img->ycbcr == NULL)
2720 {
2721 TIFFErrorExtR(img->tif, module,
2722 "No space for YCbCr->RGB conversion state");
2723 return (0);
2724 }
2725 }
2726
2727 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma);
2728 TIFFGetFieldDefaulted(img->tif, TIFFTAG_REFERENCEBLACKWHITE,
2729 &refBlackWhite);
2730
2731 /* Do some validation to avoid later issues. Detect NaN for now */
2732 /* and also if lumaGreen is zero since we divide by it later */
2733 if (luma[0] != luma[0] || luma[1] != luma[1] || luma[1] == 0.0 ||
2734 luma[2] != luma[2])
2735 {
2736 TIFFErrorExtR(img->tif, module,
2737 "Invalid values for YCbCrCoefficients tag");
2738 return (0);
2739 }
2740
2741 if (!isInRefBlackWhiteRange(refBlackWhite[0]) ||
2742 !isInRefBlackWhiteRange(refBlackWhite[1]) ||
2743 !isInRefBlackWhiteRange(refBlackWhite[2]) ||
2744 !isInRefBlackWhiteRange(refBlackWhite[3]) ||
2745 !isInRefBlackWhiteRange(refBlackWhite[4]) ||
2746 !isInRefBlackWhiteRange(refBlackWhite[5]))
2747 {
2748 TIFFErrorExtR(img->tif, module,
2749 "Invalid values for ReferenceBlackWhite tag");
2750 return (0);
2751 }
2752
2753 if (TIFFYCbCrToRGBInit(img->ycbcr, luma, refBlackWhite) < 0)
2754 return (0);
2755 return (1);
2756}
2757
2758static tileContigRoutine initCIELabConversion(TIFFRGBAImage *img)
2759{
2760 static const char module[] = "initCIELabConversion";
2761
2762 float *whitePoint;
2763 float refWhite[3];
2764
2765 TIFFGetFieldDefaulted(img->tif, TIFFTAG_WHITEPOINT, &whitePoint);
2766 if (whitePoint[1] == 0.0f)
2767 {
2768 TIFFErrorExtR(img->tif, module, "Invalid value for WhitePoint tag.");
2769 return NULL;
2770 }
2771
2772 if (!img->cielab)
2773 {
2774 img->cielab = (TIFFCIELabToRGB *)_TIFFmallocExt(
2775 img->tif, sizeof(TIFFCIELabToRGB));
2776 if (!img->cielab)
2777 {
2778 TIFFErrorExtR(img->tif, module,
2779 "No space for CIE L*a*b*->RGB conversion state.");
2780 return NULL;
2781 }
2782 }
2783
2784 refWhite[1] = 100.0F;
2785 refWhite[0] = whitePoint[0] / whitePoint[1] * refWhite[1];
2786 refWhite[2] =
2787 (1.0F - whitePoint[0] - whitePoint[1]) / whitePoint[1] * refWhite[1];
2788 if (TIFFCIELabToRGBInit(img->cielab, &display_sRGB, refWhite) < 0)
2789 {
2790 TIFFErrorExtR(img->tif, module,
2791 "Failed to initialize CIE L*a*b*->RGB conversion state.");
2792 _TIFFfreeExt(img->tif, img->cielab);
2793 return NULL;
2794 }
2795
2796 if (img->bitspersample == 8)
2797 return putcontig8bitCIELab8;
2798 else if (img->bitspersample == 16)
2799 return putcontig8bitCIELab16;
2800 return NULL;
2801}
2802
2803/*
2804 * Greyscale images with less than 8 bits/sample are handled
2805 * with a table to avoid lots of shifts and masks. The table
2806 * is setup so that put*bwtile (below) can retrieve 8/bitspersample
2807 * pixel values simply by indexing into the table with one
2808 * number.
2809 */
2810static int makebwmap(TIFFRGBAImage *img)
2811{
2812 TIFFRGBValue *Map = img->Map;
2813 int bitspersample = img->bitspersample;
2814 int nsamples = 8 / bitspersample;
2815 int i;
2816 uint32_t *p;
2817
2818 if (nsamples == 0)
2819 nsamples = 1;
2820
2821 img->BWmap = (uint32_t **)_TIFFmallocExt(
2822 img->tif,
2823 256 * sizeof(uint32_t *) + (256 * nsamples * sizeof(uint32_t)));
2824 if (img->BWmap == NULL)
2825 {
2826 TIFFErrorExtR(img->tif, TIFFFileName(img->tif),
2827 "No space for B&W mapping table");
2828 return (0);
2829 }
2830 p = (uint32_t *)(img->BWmap + 256);
2831 for (i = 0; i < 256; i++)
2832 {
2833 TIFFRGBValue c;
2834 img->BWmap[i] = p;
2835 switch (bitspersample)
2836 {
2837#define GREY(x) \
2838 c = Map[x]; \
2839 *p++ = PACK(c, c, c);
2840 case 1:
2841 GREY(i >> 7);
2842 GREY((i >> 6) & 1);
2843 GREY((i >> 5) & 1);
2844 GREY((i >> 4) & 1);
2845 GREY((i >> 3) & 1);
2846 GREY((i >> 2) & 1);
2847 GREY((i >> 1) & 1);
2848 GREY(i & 1);
2849 break;
2850 case 2:
2851 GREY(i >> 6);
2852 GREY((i >> 4) & 3);
2853 GREY((i >> 2) & 3);
2854 GREY(i & 3);
2855 break;
2856 case 4:
2857 GREY(i >> 4);
2858 GREY(i & 0xf);
2859 break;
2860 case 8:
2861 case 16:
2862 GREY(i);
2863 break;
2864 }
2865#undef GREY
2866 }
2867 return (1);
2868}
2869
2870/*
2871 * Construct a mapping table to convert from the range
2872 * of the data samples to [0,255] --for display. This
2873 * process also handles inverting B&W images when needed.
2874 */
2875static int setupMap(TIFFRGBAImage *img)
2876{
2877 int32_t x, range;
2878
2879 range = (int32_t)((1L << img->bitspersample) - 1);
2880
2881 /* treat 16 bit the same as eight bit */
2882 if (img->bitspersample == 16)
2883 range = (int32_t)255;
2884
2885 img->Map = (TIFFRGBValue *)_TIFFmallocExt(
2886 img->tif, (range + 1) * sizeof(TIFFRGBValue));
2887 if (img->Map == NULL)
2888 {
2889 TIFFErrorExtR(img->tif, TIFFFileName(img->tif),
2890 "No space for photometric conversion table");
2891 return (0);
2892 }
2893 if (img->photometric == PHOTOMETRIC_MINISWHITE)
2894 {
2895 for (x = 0; x <= range; x++)
2896 img->Map[x] = (TIFFRGBValue)(((range - x) * 255) / range);
2897 }
2898 else
2899 {
2900 for (x = 0; x <= range; x++)
2901 img->Map[x] = (TIFFRGBValue)((x * 255) / range);
2902 }
2903 if (img->bitspersample <= 16 &&
2904 (img->photometric == PHOTOMETRIC_MINISBLACK ||
2905 img->photometric == PHOTOMETRIC_MINISWHITE))
2906 {
2907 /*
2908 * Use photometric mapping table to construct
2909 * unpacking tables for samples <= 8 bits.
2910 */
2911 if (!makebwmap(img))
2912 return (0);
2913 /* no longer need Map, free it */
2914 _TIFFfreeExt(img->tif, img->Map);
2915 img->Map = NULL;
2916 }
2917 return (1);
2918}
2919
2920static int checkcmap(TIFFRGBAImage *img)
2921{
2922 uint16_t *r = img->redcmap;
2923 uint16_t *g = img->greencmap;
2924 uint16_t *b = img->bluecmap;
2925 long n = 1L << img->bitspersample;
2926
2927 while (n-- > 0)
2928 if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
2929 return (16);
2930 return (8);
2931}
2932
2933static void cvtcmap(TIFFRGBAImage *img)
2934{
2935 uint16_t *r = img->redcmap;
2936 uint16_t *g = img->greencmap;
2937 uint16_t *b = img->bluecmap;
2938 long i;
2939
2940 for (i = (1L << img->bitspersample) - 1; i >= 0; i--)
2941 {
2942#define CVT(x) ((uint16_t)((x) >> 8))
2943 r[i] = CVT(r[i]);
2944 g[i] = CVT(g[i]);
2945 b[i] = CVT(b[i]);
2946#undef CVT
2947 }
2948}
2949
2950/*
2951 * Palette images with <= 8 bits/sample are handled
2952 * with a table to avoid lots of shifts and masks. The table
2953 * is setup so that put*cmaptile (below) can retrieve 8/bitspersample
2954 * pixel values simply by indexing into the table with one
2955 * number.
2956 */
2957static int makecmap(TIFFRGBAImage *img)
2958{
2959 int bitspersample = img->bitspersample;
2960 int nsamples = 8 / bitspersample;
2961 uint16_t *r = img->redcmap;
2962 uint16_t *g = img->greencmap;
2963 uint16_t *b = img->bluecmap;
2964 uint32_t *p;
2965 int i;
2966
2967 img->PALmap = (uint32_t **)_TIFFmallocExt(
2968 img->tif,
2969 256 * sizeof(uint32_t *) + (256 * nsamples * sizeof(uint32_t)));
2970 if (img->PALmap == NULL)
2971 {
2972 TIFFErrorExtR(img->tif, TIFFFileName(img->tif),
2973 "No space for Palette mapping table");
2974 return (0);
2975 }
2976 p = (uint32_t *)(img->PALmap + 256);
2977 for (i = 0; i < 256; i++)
2978 {
2979 TIFFRGBValue c;
2980 img->PALmap[i] = p;
2981#define CMAP(x) \
2982 c = (TIFFRGBValue)x; \
2983 *p++ = PACK(r[c] & 0xff, g[c] & 0xff, b[c] & 0xff);
2984 switch (bitspersample)
2985 {
2986 case 1:
2987 CMAP(i >> 7);
2988 CMAP((i >> 6) & 1);
2989 CMAP((i >> 5) & 1);
2990 CMAP((i >> 4) & 1);
2991 CMAP((i >> 3) & 1);
2992 CMAP((i >> 2) & 1);
2993 CMAP((i >> 1) & 1);
2994 CMAP(i & 1);
2995 break;
2996 case 2:
2997 CMAP(i >> 6);
2998 CMAP((i >> 4) & 3);
2999 CMAP((i >> 2) & 3);
3000 CMAP(i & 3);
3001 break;
3002 case 4:
3003 CMAP(i >> 4);
3004 CMAP(i & 0xf);
3005 break;
3006 case 8:
3007 CMAP(i);
3008 break;
3009 }
3010#undef CMAP
3011 }
3012 return (1);
3013}
3014
3015/*
3016 * Construct any mapping table used
3017 * by the associated put routine.
3018 */
3019static int buildMap(TIFFRGBAImage *img)
3020{
3021 switch (img->photometric)
3022 {
3023 case PHOTOMETRIC_RGB:
3024 case PHOTOMETRIC_YCBCR:
3025 case PHOTOMETRIC_SEPARATED:
3026 if (img->bitspersample == 8)
3027 break;
3028 /* fall through... */
3029 case PHOTOMETRIC_MINISBLACK:
3030 case PHOTOMETRIC_MINISWHITE:
3031 if (!setupMap(img))
3032 return (0);
3033 break;
3034 case PHOTOMETRIC_PALETTE:
3035 /*
3036 * Convert 16-bit colormap to 8-bit (unless it looks
3037 * like an old-style 8-bit colormap).
3038 */
3039 if (checkcmap(img) == 16)
3040 cvtcmap(img);
3041 else
3042 TIFFWarningExtR(img->tif, TIFFFileName(img->tif),
3043 "Assuming 8-bit colormap");
3044 /*
3045 * Use mapping table and colormap to construct
3046 * unpacking tables for samples < 8 bits.
3047 */
3048 if (img->bitspersample <= 8 && !makecmap(img))
3049 return (0);
3050 break;
3051 }
3052 return (1);
3053}
3054
3055/*
3056 * Select the appropriate conversion routine for packed data.
3057 */
3058static int PickContigCase(TIFFRGBAImage *img)
3059{
3060 img->get = TIFFIsTiled(img->tif) ? gtTileContig : gtStripContig;
3061 img->put.contig = NULL;
3062 switch (img->photometric)
3063 {
3064 case PHOTOMETRIC_RGB:
3065 switch (img->bitspersample)
3066 {
3067 case 8:
3068 if (img->alpha == EXTRASAMPLE_ASSOCALPHA &&
3069 img->samplesperpixel >= 4)
3070 img->put.contig = putRGBAAcontig8bittile;
3071 else if (img->alpha == EXTRASAMPLE_UNASSALPHA &&
3072 img->samplesperpixel >= 4)
3073 {
3074 if (BuildMapUaToAa(img))
3075 img->put.contig = putRGBUAcontig8bittile;
3076 }
3077 else if (img->samplesperpixel >= 3)
3078 img->put.contig = putRGBcontig8bittile;
3079 break;
3080 case 16:
3081 if (img->alpha == EXTRASAMPLE_ASSOCALPHA &&
3082 img->samplesperpixel >= 4)
3083 {
3084 if (BuildMapBitdepth16To8(img))
3085 img->put.contig = putRGBAAcontig16bittile;
3086 }
3087 else if (img->alpha == EXTRASAMPLE_UNASSALPHA &&
3088 img->samplesperpixel >= 4)
3089 {
3090 if (BuildMapBitdepth16To8(img) && BuildMapUaToAa(img))
3091 img->put.contig = putRGBUAcontig16bittile;
3092 }
3093 else if (img->samplesperpixel >= 3)
3094 {
3095 if (BuildMapBitdepth16To8(img))
3096 img->put.contig = putRGBcontig16bittile;
3097 }
3098 break;
3099 }
3100 break;
3101 case PHOTOMETRIC_SEPARATED:
3102 if (img->samplesperpixel >= 4 && buildMap(img))
3103 {
3104 if (img->bitspersample == 8)
3105 {
3106 if (!img->Map)
3107 img->put.contig = putRGBcontig8bitCMYKtile;
3108 else
3109 img->put.contig = putRGBcontig8bitCMYKMaptile;
3110 }
3111 }
3112 break;
3113 case PHOTOMETRIC_PALETTE:
3114 if (buildMap(img))
3115 {
3116 switch (img->bitspersample)
3117 {
3118 case 8:
3119 img->put.contig = put8bitcmaptile;
3120 break;
3121 case 4:
3122 img->put.contig = put4bitcmaptile;
3123 break;
3124 case 2:
3125 img->put.contig = put2bitcmaptile;
3126 break;
3127 case 1:
3128 img->put.contig = put1bitcmaptile;
3129 break;
3130 }
3131 }
3132 break;
3133 case PHOTOMETRIC_MINISWHITE:
3134 case PHOTOMETRIC_MINISBLACK:
3135 if (buildMap(img))
3136 {
3137 switch (img->bitspersample)
3138 {
3139 case 16:
3140 img->put.contig = put16bitbwtile;
3141 break;
3142 case 8:
3143 if (img->alpha && img->samplesperpixel == 2)
3144 img->put.contig = putagreytile;
3145 else
3146 img->put.contig = putgreytile;
3147 break;
3148 case 4:
3149 img->put.contig = put4bitbwtile;
3150 break;
3151 case 2:
3152 img->put.contig = put2bitbwtile;
3153 break;
3154 case 1:
3155 img->put.contig = put1bitbwtile;
3156 break;
3157 }
3158 }
3159 break;
3160 case PHOTOMETRIC_YCBCR:
3161 if ((img->bitspersample == 8) && (img->samplesperpixel == 3))
3162 {
3163 if (initYCbCrConversion(img) != 0)
3164 {
3165 /*
3166 * The 6.0 spec says that subsampling must be
3167 * one of 1, 2, or 4, and that vertical subsampling
3168 * must always be <= horizontal subsampling; so
3169 * there are only a few possibilities and we just
3170 * enumerate the cases.
3171 * Joris: added support for the [1,2] case, nonetheless, to
3172 * accommodate some OJPEG files
3173 */
3174 uint16_t SubsamplingHor;
3175 uint16_t SubsamplingVer;
3176 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING,
3177 &SubsamplingHor, &SubsamplingVer);
3178 switch ((SubsamplingHor << 4) | SubsamplingVer)
3179 {
3180 case 0x44:
3181 img->put.contig = putcontig8bitYCbCr44tile;
3182 break;
3183 case 0x42:
3184 img->put.contig = putcontig8bitYCbCr42tile;
3185 break;
3186 case 0x41:
3187 img->put.contig = putcontig8bitYCbCr41tile;
3188 break;
3189 case 0x22:
3190 img->put.contig = putcontig8bitYCbCr22tile;
3191 break;
3192 case 0x21:
3193 img->put.contig = putcontig8bitYCbCr21tile;
3194 break;
3195 case 0x12:
3196 img->put.contig = putcontig8bitYCbCr12tile;
3197 break;
3198 case 0x11:
3199 img->put.contig = putcontig8bitYCbCr11tile;
3200 break;
3201 }
3202 }
3203 }
3204 break;
3205 case PHOTOMETRIC_CIELAB:
3206 if (img->samplesperpixel == 3 && buildMap(img))
3207 {
3208 if (img->bitspersample == 8 || img->bitspersample == 16)
3209 img->put.contig = initCIELabConversion(img);
3210 break;
3211 }
3212 }
3213 return ((img->get != NULL) && (img->put.contig != NULL));
3214}
3215
3216/*
3217 * Select the appropriate conversion routine for unpacked data.
3218 *
3219 * NB: we assume that unpacked single channel data is directed
3220 * to the "packed routines.
3221 */
3222static int PickSeparateCase(TIFFRGBAImage *img)
3223{
3224 img->get = TIFFIsTiled(img->tif) ? gtTileSeparate : gtStripSeparate;
3225 img->put.separate = NULL;
3226 switch (img->photometric)
3227 {
3228 case PHOTOMETRIC_MINISWHITE:
3229 case PHOTOMETRIC_MINISBLACK:
3230 /* greyscale images processed pretty much as RGB by gtTileSeparate
3231 */
3232 case PHOTOMETRIC_RGB:
3233 switch (img->bitspersample)
3234 {
3235 case 8:
3236 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
3237 img->put.separate = putRGBAAseparate8bittile;
3238 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
3239 {
3240 if (BuildMapUaToAa(img))
3241 img->put.separate = putRGBUAseparate8bittile;
3242 }
3243 else
3244 img->put.separate = putRGBseparate8bittile;
3245 break;
3246 case 16:
3247 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
3248 {
3249 if (BuildMapBitdepth16To8(img))
3250 img->put.separate = putRGBAAseparate16bittile;
3251 }
3252 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
3253 {
3254 if (BuildMapBitdepth16To8(img) && BuildMapUaToAa(img))
3255 img->put.separate = putRGBUAseparate16bittile;
3256 }
3257 else
3258 {
3259 if (BuildMapBitdepth16To8(img))
3260 img->put.separate = putRGBseparate16bittile;
3261 }
3262 break;
3263 }
3264 break;
3265 case PHOTOMETRIC_SEPARATED:
3266 if (img->bitspersample == 8 && img->samplesperpixel == 4)
3267 {
3268 /* Not alpha, but seems like the only way to get 4th band */
3269 img->alpha = 1;
3270 img->put.separate = putCMYKseparate8bittile;
3271 }
3272 break;
3273 case PHOTOMETRIC_YCBCR:
3274 if ((img->bitspersample == 8) && (img->samplesperpixel == 3))
3275 {
3276 if (initYCbCrConversion(img) != 0)
3277 {
3278 uint16_t hs, vs;
3279 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING,
3280 &hs, &vs);
3281 switch ((hs << 4) | vs)
3282 {
3283 case 0x11:
3284 img->put.separate = putseparate8bitYCbCr11tile;
3285 break;
3286 /* TODO: add other cases here */
3287 }
3288 }
3289 }
3290 break;
3291 }
3292 return ((img->get != NULL) && (img->put.separate != NULL));
3293}
3294
3295static int BuildMapUaToAa(TIFFRGBAImage *img)
3296{
3297 static const char module[] = "BuildMapUaToAa";
3298 uint8_t *m;
3299 uint16_t na, nv;
3300 assert(img->UaToAa == NULL);
3301 img->UaToAa = _TIFFmallocExt(img->tif, 65536);
3302 if (img->UaToAa == NULL)
3303 {
3304 TIFFErrorExtR(img->tif, module, "Out of memory");
3305 return (0);
3306 }
3307 m = img->UaToAa;
3308 for (na = 0; na < 256; na++)
3309 {
3310 for (nv = 0; nv < 256; nv++)
3311 *m++ = (uint8_t)((nv * na + 127) / 255);
3312 }
3313 return (1);
3314}
3315
3316static int BuildMapBitdepth16To8(TIFFRGBAImage *img)
3317{
3318 static const char module[] = "BuildMapBitdepth16To8";
3319 uint8_t *m;
3320 uint32_t n;
3321 assert(img->Bitdepth16To8 == NULL);
3322 img->Bitdepth16To8 = _TIFFmallocExt(img->tif, 65536);
3323 if (img->Bitdepth16To8 == NULL)
3324 {
3325 TIFFErrorExtR(img->tif, module, "Out of memory");
3326 return (0);
3327 }
3328 m = img->Bitdepth16To8;
3329 for (n = 0; n < 65536; n++)
3330 *m++ = (uint8_t)((n + 128) / 257);
3331 return (1);
3332}
3333
3334/*
3335 * Read a whole strip off data from the file, and convert to RGBA form.
3336 * If this is the last strip, then it will only contain the portion of
3337 * the strip that is actually within the image space. The result is
3338 * organized in bottom to top form.
3339 */
3340
3341int TIFFReadRGBAStrip(TIFF *tif, uint32_t row, uint32_t *raster)
3342
3343{
3344 return TIFFReadRGBAStripExt(tif, row, raster, 0);
3345}
3346
3347int TIFFReadRGBAStripExt(TIFF *tif, uint32_t row, uint32_t *raster,
3348 int stop_on_error)
3349
3350{
3351 char emsg[EMSG_BUF_SIZE] = "";
3352 TIFFRGBAImage img;
3353 int ok;
3354 uint32_t rowsperstrip, rows_to_read;
3355
3356 if (TIFFIsTiled(tif))
3357 {
3358 TIFFErrorExtR(tif, TIFFFileName(tif),
3359 "Can't use TIFFReadRGBAStrip() with tiled file.");
3360 return (0);
3361 }
3362
3363 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
3364
3365 if (rowsperstrip == 0)
3366 {
3367 TIFFErrorExtR(tif, TIFFFileName(tif), "rowsperstrip is zero");
3368 return (0);
3369 }
3370
3371 if ((row % rowsperstrip) != 0)
3372 {
3373 TIFFErrorExtR(
3374 tif, TIFFFileName(tif),
3375 "Row passed to TIFFReadRGBAStrip() must be first in a strip.");
3376 return (0);
3377 }
3378
3379 if (TIFFRGBAImageBegin(&img, tif, stop_on_error, emsg))
3380 {
3381 if (row >= img.height)
3382 {
3383 TIFFErrorExtR(tif, TIFFFileName(tif),
3384 "Invalid row passed to TIFFReadRGBAStrip().");
3385 TIFFRGBAImageEnd(&img);
3386 return (0);
3387 }
3388
3389 img.row_offset = row;
3390 img.col_offset = 0;
3391
3392 if (row + rowsperstrip > img.height)
3393 rows_to_read = img.height - row;
3394 else
3395 rows_to_read = rowsperstrip;
3396
3397 ok = TIFFRGBAImageGet(&img, raster, img.width, rows_to_read);
3398
3399 TIFFRGBAImageEnd(&img);
3400 }
3401 else
3402 {
3403 TIFFErrorExtR(tif, TIFFFileName(tif), "%s", emsg);
3404 ok = 0;
3405 }
3406
3407 return (ok);
3408}
3409
3410/*
3411 * Read a whole tile off data from the file, and convert to RGBA form.
3412 * The returned RGBA data is organized from bottom to top of tile,
3413 * and may include zeroed areas if the tile extends off the image.
3414 */
3415
3416int TIFFReadRGBATile(TIFF *tif, uint32_t col, uint32_t row, uint32_t *raster)
3417
3418{
3419 return TIFFReadRGBATileExt(tif, col, row, raster, 0);
3420}
3421
3422int TIFFReadRGBATileExt(TIFF *tif, uint32_t col, uint32_t row, uint32_t *raster,
3423 int stop_on_error)
3424{
3425 char emsg[EMSG_BUF_SIZE] = "";
3426 TIFFRGBAImage img;
3427 int ok;
3428 uint32_t tile_xsize, tile_ysize;
3429 uint32_t read_xsize, read_ysize;
3430 uint32_t i_row;
3431
3432 /*
3433 * Verify that our request is legal - on a tile file, and on a
3434 * tile boundary.
3435 */
3436
3437 if (!TIFFIsTiled(tif))
3438 {
3439 TIFFErrorExtR(tif, TIFFFileName(tif),
3440 "Can't use TIFFReadRGBATile() with striped file.");
3441 return (0);
3442 }
3443
3444 TIFFGetFieldDefaulted(tif, TIFFTAG_TILEWIDTH, &tile_xsize);
3445 TIFFGetFieldDefaulted(tif, TIFFTAG_TILELENGTH, &tile_ysize);
3446 if (tile_xsize == 0 || tile_ysize == 0)
3447 {
3448 TIFFErrorExtR(tif, TIFFFileName(tif),
3449 "tile_xsize or tile_ysize is zero");
3450 return (0);
3451 }
3452
3453 if ((col % tile_xsize) != 0 || (row % tile_ysize) != 0)
3454 {
3455 TIFFErrorExtR(tif, TIFFFileName(tif),
3456 "Row/col passed to TIFFReadRGBATile() must be top"
3457 "left corner of a tile.");
3458 return (0);
3459 }
3460
3461 /*
3462 * Setup the RGBA reader.
3463 */
3464
3465 if (!TIFFRGBAImageBegin(&img, tif, stop_on_error, emsg))
3466 {
3467 TIFFErrorExtR(tif, TIFFFileName(tif), "%s", emsg);
3468 return (0);
3469 }
3470
3471 if (col >= img.width || row >= img.height)
3472 {
3473 TIFFErrorExtR(tif, TIFFFileName(tif),
3474 "Invalid row/col passed to TIFFReadRGBATile().");
3475 TIFFRGBAImageEnd(&img);
3476 return (0);
3477 }
3478
3479 /*
3480 * The TIFFRGBAImageGet() function doesn't allow us to get off the
3481 * edge of the image, even to fill an otherwise valid tile. So we
3482 * figure out how much we can read, and fix up the tile buffer to
3483 * a full tile configuration afterwards.
3484 */
3485
3486 if (row + tile_ysize > img.height)
3487 read_ysize = img.height - row;
3488 else
3489 read_ysize = tile_ysize;
3490
3491 if (col + tile_xsize > img.width)
3492 read_xsize = img.width - col;
3493 else
3494 read_xsize = tile_xsize;
3495
3496 /*
3497 * Read the chunk of imagery.
3498 */
3499
3500 img.row_offset = row;
3501 img.col_offset = col;
3502
3503 ok = TIFFRGBAImageGet(&img, raster, read_xsize, read_ysize);
3504
3505 TIFFRGBAImageEnd(&img);
3506
3507 /*
3508 * If our read was incomplete we will need to fix up the tile by
3509 * shifting the data around as if a full tile of data is being returned.
3510 *
3511 * This is all the more complicated because the image is organized in
3512 * bottom to top format.
3513 */
3514
3515 if (read_xsize == tile_xsize && read_ysize == tile_ysize)
3516 return (ok);
3517
3518 for (i_row = 0; i_row < read_ysize; i_row++)
3519 {
3520 memmove(raster + (size_t)(tile_ysize - i_row - 1) * tile_xsize,
3521 raster + (size_t)(read_ysize - i_row - 1) * read_xsize,
3522 read_xsize * sizeof(uint32_t));
3523 _TIFFmemset(raster + (size_t)(tile_ysize - i_row - 1) * tile_xsize +
3524 read_xsize,
3525 0, sizeof(uint32_t) * (tile_xsize - read_xsize));
3526 }
3527
3528 for (i_row = read_ysize; i_row < tile_ysize; i_row++)
3529 {
3530 _TIFFmemset(raster + (size_t)(tile_ysize - i_row - 1) * tile_xsize, 0,
3531 sizeof(uint32_t) * tile_xsize);
3532 }
3533
3534 return (ok);
3535}
bw
static int bw
Definition: maze.c:120
ok
#define ok(value,...)
Definition: atltest.h:57
NULL
#define NULL
Definition: types.h:112
int32_t
INT32 int32_t
Definition: types.h:71
uint32_t
UINT32 uint32_t
Definition: types.h:75
int16_t
INT16 int16_t
Definition: types.h:70
int64_t
INT64 int64_t
Definition: types.h:72
Z
#define Z(I)
Y
#define Y(I)
assert
#define assert(_expr)
Definition: assert.h:32
size_t
unsigned int size_t
Definition: corecrt.h:203
PRIu16
#define PRIu16
Definition: inttypes.h:83
PRId64
#define PRId64
Definition: inttypes.h:25
INT_MIN
#define INT_MIN
Definition: limits.h:25
INT_MAX
#define INT_MAX
Definition: limits.h:26
uint16_t
unsigned short uint16_t
Definition: stdint.h:35
uint8_t
unsigned char uint8_t
Definition: stdint.h:33
row
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
ret
return ret
Definition: mutex.c:146
img
GLint GLvoid * img
Definition: gl.h:1956
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
alpha
GLclampf GLclampf GLclampf alpha
Definition: gl.h:1740
y
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
n
GLdouble n
Definition: glext.h:7729
right
GLdouble GLdouble right
Definition: glext.h:10859
f
GLfloat f
Definition: glext.h:7540
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
range
GLenum GLint * range
Definition: glext.h:7539
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
left
GLint left
Definition: glext.h:7726
g
GLboolean GLboolean g
Definition: glext.h:6204
p
GLfloat GLfloat p
Definition: glext.h:8902
bufsize
GLenum GLuint GLsizei bufsize
Definition: glext.h:7473
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
m
const GLfloat * m
Definition: glext.h:10848
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
X
#define X(b, s)
a
#define a
Definition: ke_i.h:78
c
#define c
Definition: ke_i.h:80
b
#define b
Definition: ke_i.h:79
cp
POINT cp
Definition: magnifier.c:59
put
#define put(ret, state, sp, n)
Definition: match.c:105
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
a2
static const struct update_accum a2
Definition: msg.c:542
b2
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:538
r2
static DNS_RECORDW r2
Definition: record.c:38
vs
static vector_t * vs
Definition: server.c:146
pa
static int ** pa
Definition: server.c:145
float
static float(__cdecl *square_half_float)(float x
k
int k
Definition: mpi.c:3369
uint32_t
#define uint32_t
Definition: nsiface.idl:61
int32_t
#define int32_t
Definition: nsiface.idl:56
uint16_t
#define uint16_t
Definition: nsiface.idl:60
int64_t
#define int64_t
Definition: nsiface.idl:57
temp
static calc_node_t temp
Definition: rpn_ieee.c:38
compress
int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
Definition: compress.c:68
TIFFDirectory::td_compression
uint16_t td_compression
Definition: tif_dir.h:88
TIFFDirectory::td_extrasamples
uint16_t td_extrasamples
Definition: tif_dir.h:105
TIFFDirectory::td_bitspersample
uint16_t td_bitspersample
Definition: tif_dir.h:86
TIFFDirectory::td_planarconfig
uint16_t td_planarconfig
Definition: tif_dir.h:100
TIFFDirectory::td_sampleformat
uint16_t td_sampleformat
Definition: tif_dir.h:87
TIFFDirectory::td_samplesperpixel
uint16_t td_samplesperpixel
Definition: tif_dir.h:93
_TIFFRGBAImage
Definition: tiffio.h:216
line
Definition: parser.c:49
tiff
Definition: tiffiop.h:113
tiff::tif_dir
TIFFDirectory tif_dir
Definition: tiffiop.h:157
tiff::tif_decodestatus
int tif_decodestatus
Definition: tiffiop.h:197
TIFFGetFieldDefaulted
int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag,...)
Definition: tif_aux.c:380
_TIFFMultiplySSize
tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second, const char *where)
Definition: tif_aux.c:59
TIFFCIELabToXYZ
void TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a, int32_t b, float *X, float *Y, float *Z)
Definition: tif_color.c:43
TIFFCIELab16ToXYZ
void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a, int32_t b, float *X, float *Y, float *Z)
Definition: tif_color.c:55
TIFFYCbCrtoRGB
void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32_t Y, int32_t Cb, int32_t Cr, uint32_t *r, uint32_t *g, uint32_t *b)
Definition: tif_color.c:199
TIFFYCbCrToRGBInit
int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
Definition: tif_color.c:251
TIFFCIELabToRGBInit
int TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, const TIFFDisplay *display, float *refWhite)
Definition: tif_color.c:135
TIFFXYZToRGB
void TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z, uint32_t *r, uint32_t *g, uint32_t *b)
Definition: tif_color.c:89
TIFFSetField
int TIFFSetField(TIFF *tif, uint32_t tag,...)
Definition: tif_dir.c:1146
TIFFGetField
int TIFFGetField(TIFF *tif, uint32_t tag,...)
Definition: tif_dir.c:1582
TIFFErrorExtR
void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_error.c:107
FLIP_VERTICALLY
#define FLIP_VERTICALLY
Definition: tif_getimage.c:49
EMSG_BUF_SIZE
#define EMSG_BUF_SIZE
Definition: tif_getimage.c:52
gtTileSeparate
static int gtTileSeparate(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t)
Definition: tif_getimage.c:897
isInRefBlackWhiteRange
static int isInRefBlackWhiteRange(float f)
Definition: tif_getimage.c:2702
SKEW4
#define SKEW4(r, g, b, a, skew)
Definition: tif_getimage.c:1570
display_sRGB
static const TIFFDisplay display_sRGB
Definition: tif_getimage.c:58
gtStripContig
static int gtStripContig(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t)
Definition: tif_getimage.c:1135
TIFFReadRGBAImage
int TIFFReadRGBAImage(TIFF *tif, uint32_t rwidth, uint32_t rheight, uint32_t *raster, int stop)
Definition: tif_getimage.c:656
UNROLL8
#define UNROLL8(w, op1, op2)
Definition: tif_getimage.c:1521
TIFFReadRGBAStrip
int TIFFReadRGBAStrip(TIFF *tif, uint32_t row, uint32_t *raster)
Definition: tif_getimage.c:3341
gtStripSeparate
static int gtStripSeparate(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t)
Definition: tif_getimage.c:1279
setupMap
static int setupMap(TIFFRGBAImage *img)
Definition: tif_getimage.c:2875
GREY
#define GREY(x)
setorientation
static int setorientation(TIFFRGBAImage *img)
Definition: tif_getimage.c:663
YCbCrtoRGB
#define YCbCrtoRGB(dst, Y)
Definition: tif_getimage.c:2204
TIFFReadRGBATile
int TIFFReadRGBATile(TIFF *tif, uint32_t col, uint32_t row, uint32_t *raster)
Definition: tif_getimage.c:3416
buildMap
static int buildMap(TIFFRGBAImage *img)
Definition: tif_getimage.c:3019
NOP
#define NOP
Definition: tif_getimage.c:1519
TIFFRGBAImageGet
int TIFFRGBAImageGet(TIFFRGBAImage *img, uint32_t *raster, uint32_t w, uint32_t h)
Definition: tif_getimage.c:587
PACK4
#define PACK4(r, g, b, a)
Definition: tif_getimage.c:1581
UNROLL4
#define UNROLL4(w, op1, op2)
Definition: tif_getimage.c:1535
PickContigCase
static int PickContigCase(TIFFRGBAImage *)
Definition: tif_getimage.c:3058
initCIELabConversion
static tileContigRoutine initCIELabConversion(TIFFRGBAImage *img)
Definition: tif_getimage.c:2758
PACK
#define PACK(r, g, b)
Definition: tif_getimage.c:1579
DECLAREContigPutFunc
#define DECLAREContigPutFunc(name)
Definition: tif_getimage.c:1592
gtTileContig
static int gtTileContig(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t)
Definition: tif_getimage.c:730
isCCITTCompression
static int isCCITTCompression(TIFF *tif)
Definition: tif_getimage.c:300
TIFFRGBAImageEnd
void TIFFRGBAImageEnd(TIFFRGBAImage *img)
Definition: tif_getimage.c:253
TIFFReadRGBAStripExt
int TIFFReadRGBAStripExt(TIFF *tif, uint32_t row, uint32_t *raster, int stop_on_error)
Definition: tif_getimage.c:3347
SKEW
#define SKEW(r, g, b, skew)
Definition: tif_getimage.c:1564
makebwmap
static int makebwmap(TIFFRGBAImage *img)
Definition: tif_getimage.c:2810
TIFFReadRGBATileExt
int TIFFReadRGBATileExt(TIFF *tif, uint32_t col, uint32_t row, uint32_t *raster, int stop_on_error)
Definition: tif_getimage.c:3422
initYCbCrConversion
static int initYCbCrConversion(TIFFRGBAImage *img)
Definition: tif_getimage.c:2707
BuildMapUaToAa
static int BuildMapUaToAa(TIFFRGBAImage *img)
Definition: tif_getimage.c:3295
cvtcmap
static void cvtcmap(TIFFRGBAImage *img)
Definition: tif_getimage.c:2933
UNROLL2
#define UNROLL2(w, op1, op2)
Definition: tif_getimage.c:1549
checkcmap
static int checkcmap(TIFFRGBAImage *img)
Definition: tif_getimage.c:2920
FLIP_HORIZONTALLY
#define FLIP_HORIZONTALLY
Definition: tif_getimage.c:50
makecmap
static int makecmap(TIFFRGBAImage *img)
Definition: tif_getimage.c:2957
DECLARESepPutFunc
#define DECLARESepPutFunc(name)
Definition: tif_getimage.c:1993
CMAP
#define CMAP(x)
CVT
#define CVT(x)
BuildMapBitdepth16To8
static int BuildMapBitdepth16To8(TIFFRGBAImage *img)
Definition: tif_getimage.c:3316
TIFFRGBAImageOK
int TIFFRGBAImageOK(TIFF *tif, char emsg[EMSG_BUF_SIZE])
Definition: tif_getimage.c:83
TIFFReadRGBAImageOriented
int TIFFReadRGBAImageOriented(TIFF *tif, uint32_t rwidth, uint32_t rheight, uint32_t *raster, int orientation, int stop)
Definition: tif_getimage.c:631
TIFFRGBAImageBegin
int TIFFRGBAImageBegin(TIFFRGBAImage *img, TIFF *tif, int stop, char emsg[EMSG_BUF_SIZE])
Definition: tif_getimage.c:310
PickSeparateCase
static int PickSeparateCase(TIFFRGBAImage *)
Definition: tif_getimage.c:3222
photoTag
static const char photoTag[]
Definition: tif_getimage.c:44
_TIFFfreeExt
void _TIFFfreeExt(TIFF *tif, void *p)
Definition: tif_open.c:275
TIFFFileName
const char * TIFFFileName(TIFF *tif)
Definition: tif_open.c:798
TIFFIsTiled
int TIFFIsTiled(TIFF *tif)
Definition: tif_open.c:859
_TIFFmallocExt
void * _TIFFmallocExt(TIFF *tif, tmsize_t s)
Definition: tif_open.c:173
_TIFFReadEncodedStripAndAllocBuffer
tmsize_t _TIFFReadEncodedStripAndAllocBuffer(TIFF *tif, uint32_t strip, void **buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)
Definition: tif_read.c:584
_TIFFReadTileAndAllocBuffer
tmsize_t _TIFFReadTileAndAllocBuffer(TIFF *tif, void **buf, tmsize_t bufsizetoalloc, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
Definition: tif_read.c:1012
TIFFReadEncodedStrip
tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32_t strip, void *buf, tmsize_t size)
Definition: tif_read.c:534
TIFFReadTile
tmsize_t TIFFReadTile(TIFF *tif, void *buf, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
Definition: tif_read.c:940
TIFFStripSize
tmsize_t TIFFStripSize(TIFF *tif)
Definition: tif_strip.c:204
TIFFScanlineSize
tmsize_t TIFFScanlineSize(TIFF *tif)
Definition: tif_strip.c:343
TIFFComputeStrip
uint32_t TIFFComputeStrip(TIFF *tif, uint32_t row, uint16_t sample)
Definition: tif_strip.c:35
TIFFTileSize
tmsize_t TIFFTileSize(TIFF *tif)
Definition: tif_tile.c:253
TIFFTileRowSize
tmsize_t TIFFTileRowSize(TIFF *tif)
Definition: tif_tile.c:177
_TIFFmemset
void _TIFFmemset(void *p, int v, tmsize_t c)
Definition: tif_unix.c:353
_TIFFmemcpy
void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
Definition: tif_unix.c:355
TIFFWarningExtR
void TIFFWarningExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_warning.c:80
TIFFTAG_BITSPERSAMPLE
#define TIFFTAG_BITSPERSAMPLE
Definition: tiff.h:180
ORIENTATION_BOTRIGHT
#define ORIENTATION_BOTRIGHT
Definition: tiff.h:251
PLANARCONFIG_SEPARATE
#define PLANARCONFIG_SEPARATE
Definition: tiff.h:266
ORIENTATION_LEFTTOP
#define ORIENTATION_LEFTTOP
Definition: tiff.h:253
ORIENTATION_BOTLEFT
#define ORIENTATION_BOTLEFT
Definition: tiff.h:252
TIFFTAG_WHITEPOINT
#define TIFFTAG_WHITEPOINT
Definition: tiff.h:307
EXTRASAMPLE_UNASSALPHA
#define EXTRASAMPLE_UNASSALPHA
Definition: tiff.h:332
COMPRESSION_CCITTFAX3
#define COMPRESSION_CCITTFAX3
Definition: tiff.h:184
COMPRESSION_CCITTRLE
#define COMPRESSION_CCITTRLE
Definition: tiff.h:183
EXTRASAMPLE_ASSOCALPHA
#define EXTRASAMPLE_ASSOCALPHA
Definition: tiff.h:331
ORIENTATION_TOPLEFT
#define ORIENTATION_TOPLEFT
Definition: tiff.h:249
ORIENTATION_RIGHTBOT
#define ORIENTATION_RIGHTBOT
Definition: tiff.h:255
ORIENTATION_RIGHTTOP
#define ORIENTATION_RIGHTTOP
Definition: tiff.h:254
TIFFTAG_SAMPLESPERPIXEL
#define TIFFTAG_SAMPLESPERPIXEL
Definition: tiff.h:257
PHOTOMETRIC_LOGL
#define PHOTOMETRIC_LOGL
Definition: tiff.h:232
TIFFTAG_INKSET
#define TIFFTAG_INKSET
Definition: tiff.h:322
COMPRESSION_SGILOG
#define COMPRESSION_SGILOG
Definition: tiff.h:210
COMPRESSION_CCITTRLEW
#define COMPRESSION_CCITTRLEW
Definition: tiff.h:194
TIFFTAG_COLORMAP
#define TIFFTAG_COLORMAP
Definition: tiff.h:309
PHOTOMETRIC_CIELAB
#define PHOTOMETRIC_CIELAB
Definition: tiff.h:228
EXTRASAMPLE_UNSPECIFIED
#define EXTRASAMPLE_UNSPECIFIED
Definition: tiff.h:330
TIFFTAG_PHOTOMETRIC
#define TIFFTAG_PHOTOMETRIC
Definition: tiff.h:220
TIFFTAG_TILELENGTH
#define TIFFTAG_TILELENGTH
Definition: tiff.h:312
PHOTOMETRIC_PALETTE
#define PHOTOMETRIC_PALETTE
Definition: tiff.h:224
TIFFTAG_EXTRASAMPLES
#define TIFFTAG_EXTRASAMPLES
Definition: tiff.h:329
TIFFTAG_IMAGEWIDTH
#define TIFFTAG_IMAGEWIDTH
Definition: tiff.h:178
PHOTOMETRIC_SEPARATED
#define PHOTOMETRIC_SEPARATED
Definition: tiff.h:226
TIFFTAG_YCBCRCOEFFICIENTS
#define TIFFTAG_YCBCRCOEFFICIENTS
Definition: tiff.h:387
TIFFTAG_ORIENTATION
#define TIFFTAG_ORIENTATION
Definition: tiff.h:248
PHOTOMETRIC_LOGLUV
#define PHOTOMETRIC_LOGLUV
Definition: tiff.h:233
SAMPLEFORMAT_IEEEFP
#define SAMPLEFORMAT_IEEEFP
Definition: tiff.h:336
PHOTOMETRIC_YCBCR
#define PHOTOMETRIC_YCBCR
Definition: tiff.h:227
SGILOGDATAFMT_8BIT
#define SGILOGDATAFMT_8BIT
Definition: tiff.h:747
ORIENTATION_TOPRIGHT
#define ORIENTATION_TOPRIGHT
Definition: tiff.h:250
INKSET_CMYK
#define INKSET_CMYK
Definition: tiff.h:323
PHOTOMETRIC_MINISWHITE
#define PHOTOMETRIC_MINISWHITE
Definition: tiff.h:221
TIFFTAG_YCBCRSUBSAMPLING
#define TIFFTAG_YCBCRSUBSAMPLING
Definition: tiff.h:388
TIFFTAG_SGILOGDATAFMT
#define TIFFTAG_SGILOGDATAFMT
Definition: tiff.h:743
TIFFTAG_ROWSPERSTRIP
#define TIFFTAG_ROWSPERSTRIP
Definition: tiff.h:258
ORIENTATION_LEFTBOT
#define ORIENTATION_LEFTBOT
Definition: tiff.h:256
COMPRESSION_SGILOG24
#define COMPRESSION_SGILOG24
Definition: tiff.h:211
TIFFTAG_REFERENCEBLACKWHITE
#define TIFFTAG_REFERENCEBLACKWHITE
Definition: tiff.h:392
TIFFTAG_TILEWIDTH
#define TIFFTAG_TILEWIDTH
Definition: tiff.h:311
TIFFTAG_IMAGELENGTH
#define TIFFTAG_IMAGELENGTH
Definition: tiff.h:179
TIFFTAG_COMPRESSION
#define TIFFTAG_COMPRESSION
Definition: tiff.h:181
PHOTOMETRIC_MINISBLACK
#define PHOTOMETRIC_MINISBLACK
Definition: tiff.h:222
PHOTOMETRIC_RGB
#define PHOTOMETRIC_RGB
Definition: tiff.h:223
TIFFTAG_PLANARCONFIG
#define TIFFTAG_PLANARCONFIG
Definition: tiff.h:264
COMPRESSION_CCITTFAX4
#define COMPRESSION_CCITTFAX4
Definition: tiff.h:186
TIFFTAG_JPEGCOLORMODE
#define TIFFTAG_JPEGCOLORMODE
Definition: tiff.h:706
JPEGCOLORMODE_RGB
#define JPEGCOLORMODE_RGB
Definition: tiff.h:708
COMPRESSION_JPEG
#define COMPRESSION_JPEG
Definition: tiff.h:190
PLANARCONFIG_CONTIG
#define PLANARCONFIG_CONTIG
Definition: tiff.h:265
tmsize_t
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:67
TIFFRGBValue
unsigned char TIFFRGBValue
Definition: tiffio.h:138
tileSeparateRoutine
void(* tileSeparateRoutine)(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t, uint32_t, uint32_t, int32_t, int32_t, unsigned char *, unsigned char *, unsigned char *, unsigned char *)
Definition: tiffio.h:208
tileContigRoutine
void(* tileContigRoutine)(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t, uint32_t, uint32_t, int32_t, int32_t, unsigned char *)
Definition: tiffio.h:205
TIFF_TMSIZE_T_MAX
#define TIFF_TMSIZE_T_MAX
Definition: tiffio.h:68
TIFFroundup_32
#define TIFFroundup_32(x, y)
Definition: tiffiop.h:316
TIFFmin
#define TIFFmin(A, B)
Definition: tiffiop.h:331
snprintf
#define snprintf
Definition: wintirpc.h:48