| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

tif_getimage.c
Go to the documentation of this file.
1 /* $Id: tif_getimage.c,v 1.63.2.4 2010-06-08 18:50:42 bfriesen Exp $ */
2
3 /*
4 * Copyright (c) 1991-1997 Sam Leffler
5 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
6 *
7 * Permission to use, copy, modify, distribute, and sell this software and
8 * its documentation for any purpose is hereby granted without fee, provided
9 * that (i) the above copyright notices and this permission notice appear in
10 * all copies of the software and related documentation, and (ii) the names of
11 * Sam Leffler and Silicon Graphics may not be used in any advertising or
12 * publicity relating to the software without the specific, prior written
13 * permission of Sam Leffler and Silicon Graphics.
14 *
15 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
18 *
19 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 * OF THIS SOFTWARE.
25 */
26
27 /*
28 * TIFF Library
29 *
30 * Read and return a packed RGBA image.
31 */
32 #include "tiffiop.h"
33 #include <stdio.h>
34
35 static int gtTileContig(TIFFRGBAImage*, uint32*, uint32, uint32);
36 static int gtTileSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
37 static int gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32);
38 static int gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
39 static int PickContigCase(TIFFRGBAImage*);
40 static int PickSeparateCase(TIFFRGBAImage*);
41 static const char photoTag[] = "PhotometricInterpretation";
42
43 /*
44 * Helper constants used in Orientation tag handling
45 */
46 #define FLIP_VERTICALLY 0x01
47 #define FLIP_HORIZONTALLY 0x02
48
49 /*
50 * Color conversion constants. We will define display types here.
51 */
52
53 TIFFDisplay display_sRGB = {
54 { /* XYZ -> luminance matrix */
55 { 3.2410F, -1.5374F, -0.4986F },
56 { -0.9692F, 1.8760F, 0.0416F },
57 { 0.0556F, -0.2040F, 1.0570F }
58 },
59 100.0F, 100.0F, 100.0F, /* Light o/p for reference white */
60 255, 255, 255, /* Pixel values for ref. white */
61 1.0F, 1.0F, 1.0F, /* Residual light o/p for black pixel */
62 2.4F, 2.4F, 2.4F, /* Gamma values for the three guns */
63 };
64
65 /*
66 * Check the image to see if TIFFReadRGBAImage can deal with it.
67 * 1/0 is returned according to whether or not the image can
68 * be handled. If 0 is returned, emsg contains the reason
69 * why it is being rejected.
70 */
71 int
72 TIFFRGBAImageOK(TIFF* tif, char emsg[1024])
73 {
74 TIFFDirectory* td = &tif->tif_dir;
75 uint16 photometric;
76 int colorchannels;
77
78 if (!tif->tif_decodestatus) {
79 sprintf(emsg, "Sorry, requested compression method is not configured");
80 return (0);
81 }
82 switch (td->td_bitspersample) {
83 case 1:
84 case 2:
85 case 4:
86 case 8:
87 case 16:
88 break;
89 default:
90 sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
91 td->td_bitspersample);
92 return (0);
93 }
94 colorchannels = td->td_samplesperpixel - td->td_extrasamples;
95 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)) {
96 switch (colorchannels) {
97 case 1:
98 photometric = PHOTOMETRIC_MINISBLACK;
99 break;
100 case 3:
101 photometric = PHOTOMETRIC_RGB;
102 break;
103 default:
104 sprintf(emsg, "Missing needed %s tag", photoTag);
105 return (0);
106 }
107 }
108 switch (photometric) {
109 case PHOTOMETRIC_MINISWHITE:
110 case PHOTOMETRIC_MINISBLACK:
111 case PHOTOMETRIC_PALETTE:
112 if (td->td_planarconfig == PLANARCONFIG_CONTIG
113 && td->td_samplesperpixel != 1
114 && td->td_bitspersample < 8 ) {
115 sprintf(emsg,
116 "Sorry, can not handle contiguous data with %s=%d, "
117 "and %s=%d and Bits/Sample=%d",
118 photoTag, photometric,
119 "Samples/pixel", td->td_samplesperpixel,
120 td->td_bitspersample);
121 return (0);
122 }
123 /*
124 * We should likely validate that any extra samples are either
125 * to be ignored, or are alpha, and if alpha we should try to use
126 * them. But for now we won't bother with this.
127 */
128 break;
129 case PHOTOMETRIC_YCBCR:
130 /*
131 * TODO: if at all meaningful and useful, make more complete
132 * support check here, or better still, refactor to let supporting
133 * code decide whether there is support and what meaningfull
134 * error to return
135 */
136 break;
137 case PHOTOMETRIC_RGB:
138 if (colorchannels < 3) {
139 sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
140 "Color channels", colorchannels);
141 return (0);
142 }
143 break;
144 case PHOTOMETRIC_SEPARATED:
145 {
146 uint16 inkset;
147 TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
148 if (inkset != INKSET_CMYK) {
149 sprintf(emsg,
150 "Sorry, can not handle separated image with %s=%d",
151 "InkSet", inkset);
152 return 0;
153 }
154 if (td->td_samplesperpixel < 4) {
155 sprintf(emsg,
156 "Sorry, can not handle separated image with %s=%d",
157 "Samples/pixel", td->td_samplesperpixel);
158 return 0;
159 }
160 break;
161 }
162 case PHOTOMETRIC_LOGL:
163 if (td->td_compression != COMPRESSION_SGILOG) {
164 sprintf(emsg, "Sorry, LogL data must have %s=%d",
165 "Compression", COMPRESSION_SGILOG);
166 return (0);
167 }
168 break;
169 case PHOTOMETRIC_LOGLUV:
170 if (td->td_compression != COMPRESSION_SGILOG &&
171 td->td_compression != COMPRESSION_SGILOG24) {
172 sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
173 "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
174 return (0);
175 }
176 if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
177 sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
178 "Planarconfiguration", td->td_planarconfig);
179 return (0);
180 }
181 break;
182 case PHOTOMETRIC_CIELAB:
183 break;
184 default:
185 sprintf(emsg, "Sorry, can not handle image with %s=%d",
186 photoTag, photometric);
187 return (0);
188 }
189 return (1);
190 }
191
192 void
193 TIFFRGBAImageEnd(TIFFRGBAImage* img)
194 {
195 if (img->Map)
196 _TIFFfree(img->Map), img->Map = NULL;
197 if (img->BWmap)
198 _TIFFfree(img->BWmap), img->BWmap = NULL;
199 if (img->PALmap)
200 _TIFFfree(img->PALmap), img->PALmap = NULL;
201 if (img->ycbcr)
202 _TIFFfree(img->ycbcr), img->ycbcr = NULL;
203 if (img->cielab)
204 _TIFFfree(img->cielab), img->cielab = NULL;
205 if( img->redcmap ) {
206 _TIFFfree( img->redcmap );
207 _TIFFfree( img->greencmap );
208 _TIFFfree( img->bluecmap );
209 }
210 }
211
212 static int
213 isCCITTCompression(TIFF* tif)
214 {
215 uint16 compress;
216 TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress);
217 return (compress == COMPRESSION_CCITTFAX3 ||
218 compress == COMPRESSION_CCITTFAX4 ||
219 compress == COMPRESSION_CCITTRLE ||
220 compress == COMPRESSION_CCITTRLEW);
221 }
222
223 int
224 TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
225 {
226 uint16* sampleinfo;
227 uint16 extrasamples;
228 uint16 planarconfig;
229 uint16 compress;
230 int colorchannels;
231 uint16 *red_orig, *green_orig, *blue_orig;
232 int n_color;
233
234 /* Initialize to normal values */
235 img->row_offset = 0;
236 img->col_offset = 0;
237 img->redcmap = NULL;
238 img->greencmap = NULL;
239 img->bluecmap = NULL;
240 img->req_orientation = ORIENTATION_BOTLEFT; /* It is the default */
241
242 img->tif = tif;
243 img->stoponerr = stop;
244 TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);
245 switch (img->bitspersample) {
246 case 1:
247 case 2:
248 case 4:
249 case 8:
250 case 16:
251 break;
252 default:
253 sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
254 img->bitspersample);
255 return (0);
256 }
257 img->alpha = 0;
258 TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
259 TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
260 &extrasamples, &sampleinfo);
261 if (extrasamples >= 1)
262 {
263 switch (sampleinfo[0]) {
264 case EXTRASAMPLE_UNSPECIFIED: /* Workaround for some images without */
265 if (img->samplesperpixel > 3) /* correct info about alpha channel */
266 img->alpha = EXTRASAMPLE_ASSOCALPHA;
267 break;
268 case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */
269 case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */
270 img->alpha = sampleinfo[0];
271 break;
272 }
273 }
274
275 #ifdef DEFAULT_EXTRASAMPLE_AS_ALPHA
276 if( !TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric))
277 img->photometric = PHOTOMETRIC_MINISWHITE;
278
279 if( extrasamples == 0
280 && img->samplesperpixel == 4
281 && img->photometric == PHOTOMETRIC_RGB )
282 {
283 img->alpha = EXTRASAMPLE_ASSOCALPHA;
284 extrasamples = 1;
285 }
286 #endif
287
288 colorchannels = img->samplesperpixel - extrasamples;
289 TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress);
290 TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);
291 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) {
292 switch (colorchannels) {
293 case 1:
294 if (isCCITTCompression(tif))
295 img->photometric = PHOTOMETRIC_MINISWHITE;
296 else
297 img->photometric = PHOTOMETRIC_MINISBLACK;
298 break;
299 case 3:
300 img->photometric = PHOTOMETRIC_RGB;
301 break;
302 default:
303 sprintf(emsg, "Missing needed %s tag", photoTag);
304 return (0);
305 }
306 }
307 switch (img->photometric) {
308 case PHOTOMETRIC_PALETTE:
309 if (!TIFFGetField(tif, TIFFTAG_COLORMAP,
310 &red_orig, &green_orig, &blue_orig)) {
311 sprintf(emsg, "Missing required \"Colormap\" tag");
312 return (0);
313 }
314
315 /* copy the colormaps so we can modify them */
316 n_color = (1L << img->bitspersample);
317 img->redcmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
318 img->greencmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
319 img->bluecmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
320 if( !img->redcmap || !img->greencmap || !img->bluecmap ) {
321 sprintf(emsg, "Out of memory for colormap copy");
322 return (0);
323 }
324
325 _TIFFmemcpy( img->redcmap, red_orig, n_color * 2 );
326 _TIFFmemcpy( img->greencmap, green_orig, n_color * 2 );
327 _TIFFmemcpy( img->bluecmap, blue_orig, n_color * 2 );
328
329 /* fall thru... */
330 case PHOTOMETRIC_MINISWHITE:
331 case PHOTOMETRIC_MINISBLACK:
332 if (planarconfig == PLANARCONFIG_CONTIG
333 && img->samplesperpixel != 1
334 && img->bitspersample < 8 ) {
335 sprintf(emsg,
336 "Sorry, can not handle contiguous data with %s=%d, "
337 "and %s=%d and Bits/Sample=%d",
338 photoTag, img->photometric,
339 "Samples/pixel", img->samplesperpixel,
340 img->bitspersample);
341 return (0);
342 }
343 break;
344 case PHOTOMETRIC_YCBCR:
345 /* It would probably be nice to have a reality check here. */
346 if (planarconfig == PLANARCONFIG_CONTIG)
347 /* can rely on libjpeg to convert to RGB */
348 /* XXX should restore current state on exit */
349 switch (compress) {
350 case COMPRESSION_JPEG:
351 /*
352 * TODO: when complete tests verify complete desubsampling
353 * and YCbCr handling, remove use of TIFFTAG_JPEGCOLORMODE in
354 * favor of tif_getimage.c native handling
355 */
356 TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
357 img->photometric = PHOTOMETRIC_RGB;
358 break;
359 default:
360 /* do nothing */;
361 break;
362 }
363 /*
364 * TODO: if at all meaningful and useful, make more complete
365 * support check here, or better still, refactor to let supporting
366 * code decide whether there is support and what meaningfull
367 * error to return
368 */
369 break;
370 case PHOTOMETRIC_RGB:
371 if (colorchannels < 3) {
372 sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
373 "Color channels", colorchannels);
374 return (0);
375 }
376 break;
377 case PHOTOMETRIC_SEPARATED:
378 {
379 uint16 inkset;
380 TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
381 if (inkset != INKSET_CMYK) {
382 sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
383 "InkSet", inkset);
384 return (0);
385 }
386 if (img->samplesperpixel < 4) {
387 sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
388 "Samples/pixel", img->samplesperpixel);
389 return (0);
390 }
391 }
392 break;
393 case PHOTOMETRIC_LOGL:
394 if (compress != COMPRESSION_SGILOG) {
395 sprintf(emsg, "Sorry, LogL data must have %s=%d",
396 "Compression", COMPRESSION_SGILOG);
397 return (0);
398 }
399 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
400 img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */
401 img->bitspersample = 8;
402 break;
403 case PHOTOMETRIC_LOGLUV:
404 if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) {
405 sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
406 "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
407 return (0);
408 }
409 if (planarconfig != PLANARCONFIG_CONTIG) {
410 sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
411 "Planarconfiguration", planarconfig);
412 return (0);
413 }
414 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
415 img->photometric = PHOTOMETRIC_RGB; /* little white lie */
416 img->bitspersample = 8;
417 break;
418 case PHOTOMETRIC_CIELAB:
419 break;
420 default:
421 sprintf(emsg, "Sorry, can not handle image with %s=%d",
422 photoTag, img->photometric);
423 return (0);
424 }
425 img->Map = NULL;
426 img->BWmap = NULL;
427 img->PALmap = NULL;
428 img->ycbcr = NULL;
429 img->cielab = NULL;
430 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width);
431 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height);
432 TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation);
433 img->isContig =
434 !(planarconfig == PLANARCONFIG_SEPARATE && colorchannels > 1);
435 if (img->isContig) {
436 if (!PickContigCase(img)) {
437 sprintf(emsg, "Sorry, can not handle image");
438 return 0;
439 }
440 } else {
441 if (!PickSeparateCase(img)) {
442 sprintf(emsg, "Sorry, can not handle image");
443 return 0;
444 }
445 }
446 return 1;
447 }
448
449 int
450 TIFFRGBAImageGet(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
451 {
452 if (img->get == NULL) {
453 TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No \"get\" routine setup");
454 return (0);
455 }
456 if (img->put.any == NULL) {
457 TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif),
458 "No \"put\" routine setupl; probably can not handle image format");
459 return (0);
460 }
461 return (*img->get)(img, raster, w, h);
462 }
463
464 /*
465 * Read the specified image into an ABGR-format rastertaking in account
466 * specified orientation.
467 */
468 int
469 TIFFReadRGBAImageOriented(TIFF* tif,
470 uint32 rwidth, uint32 rheight, uint32* raster,
471 int orientation, int stop)
472 {
473 char emsg[1024] = "";
474 TIFFRGBAImage img;
475 int ok;
476
477 if (TIFFRGBAImageOK(tif, emsg) && TIFFRGBAImageBegin(&img, tif, stop, emsg)) {
478 img.req_orientation = orientation;
479 /* XXX verify rwidth and rheight against width and height */
480 ok = TIFFRGBAImageGet(&img, raster+(rheight-img.height)*rwidth,
481 rwidth, img.height);
482 TIFFRGBAImageEnd(&img);
483 } else {
484 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
485 ok = 0;
486 }
487 return (ok);
488 }
489
490 /*
491 * Read the specified image into an ABGR-format raster. Use bottom left
492 * origin for raster by default.
493 */
494 int
495 TIFFReadRGBAImage(TIFF* tif,
496 uint32 rwidth, uint32 rheight, uint32* raster, int stop)
497 {
498 return TIFFReadRGBAImageOriented(tif, rwidth, rheight, raster,
499 ORIENTATION_BOTLEFT, stop);
500 }
501
502 static int
503 setorientation(TIFFRGBAImage* img)
504 {
505 switch (img->orientation) {
506 case ORIENTATION_TOPLEFT:
507 case ORIENTATION_LEFTTOP:
508 if (img->req_orientation == ORIENTATION_TOPRIGHT ||
509 img->req_orientation == ORIENTATION_RIGHTTOP)
510 return FLIP_HORIZONTALLY;
511 else if (img->req_orientation == ORIENTATION_BOTRIGHT ||
512 img->req_orientation == ORIENTATION_RIGHTBOT)
513 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
514 else if (img->req_orientation == ORIENTATION_BOTLEFT ||
515 img->req_orientation == ORIENTATION_LEFTBOT)
516 return FLIP_VERTICALLY;
517 else
518 return 0;
519 case ORIENTATION_TOPRIGHT:
520 case ORIENTATION_RIGHTTOP:
521 if (img->req_orientation == ORIENTATION_TOPLEFT ||
522 img->req_orientation == ORIENTATION_LEFTTOP)
523 return FLIP_HORIZONTALLY;
524 else if (img->req_orientation == ORIENTATION_BOTRIGHT ||
525 img->req_orientation == ORIENTATION_RIGHTBOT)
526 return FLIP_VERTICALLY;
527 else if (img->req_orientation == ORIENTATION_BOTLEFT ||
528 img->req_orientation == ORIENTATION_LEFTBOT)
529 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
530 else
531 return 0;
532 case ORIENTATION_BOTRIGHT:
533 case ORIENTATION_RIGHTBOT:
534 if (img->req_orientation == ORIENTATION_TOPLEFT ||
535 img->req_orientation == ORIENTATION_LEFTTOP)
536 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
537 else if (img->req_orientation == ORIENTATION_TOPRIGHT ||
538 img->req_orientation == ORIENTATION_RIGHTTOP)
539 return FLIP_VERTICALLY;
540 else if (img->req_orientation == ORIENTATION_BOTLEFT ||
541 img->req_orientation == ORIENTATION_LEFTBOT)
542 return FLIP_HORIZONTALLY;
543 else
544 return 0;
545 case ORIENTATION_BOTLEFT:
546 case ORIENTATION_LEFTBOT:
547 if (img->req_orientation == ORIENTATION_TOPLEFT ||
548 img->req_orientation == ORIENTATION_LEFTTOP)
549 return FLIP_VERTICALLY;
550 else if (img->req_orientation == ORIENTATION_TOPRIGHT ||
551 img->req_orientation == ORIENTATION_RIGHTTOP)
552 return FLIP_HORIZONTALLY | FLIP_VERTICALLY;
553 else if (img->req_orientation == ORIENTATION_BOTRIGHT ||
554 img->req_orientation == ORIENTATION_RIGHTBOT)
555 return FLIP_HORIZONTALLY;
556 else
557 return 0;
558 default: /* NOTREACHED */
559 return 0;
560 }
561 }
562
563 /*
564 * Get an tile-organized image that has
565 * PlanarConfiguration contiguous if SamplesPerPixel > 1
566 * or
567 * SamplesPerPixel == 1
568 */
569 static int
570 gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
571 {
572 TIFF* tif = img->tif;
573 tileContigRoutine put = img->put.contig;
574 uint32 col, row, y, rowstoread;
575 uint32 pos;
576 uint32 tw, th;
577 unsigned char* buf;
578 int32 fromskew, toskew;
579 uint32 nrow;
580 int ret = 1, flip;
581
582 buf = (unsigned char*) _TIFFmalloc(TIFFTileSize(tif));
583 if (buf == 0) {
584 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
585 return (0);
586 }
587 _TIFFmemset(buf, 0, TIFFTileSize(tif));
588 TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
589 TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
590
591 flip = setorientation(img);
592 if (flip & FLIP_VERTICALLY) {
593 y = h - 1;
594 toskew = -(int32)(tw + w);
595 }
596 else {
597 y = 0;
598 toskew = -(int32)(tw - w);
599 }
600
601 for (row = 0; row < h; row += nrow)
602 {
603 rowstoread = th - (row + img->row_offset) % th;
604 nrow = (row + rowstoread > h ? h - row : rowstoread);
605 for (col = 0; col < w; col += tw)
606 {
607 if (TIFFReadTile(tif, buf, col+img->col_offset,
608 row+img->row_offset, 0, 0) < 0 && img->stoponerr)
609 {
610 ret = 0;
611 break;
612 }
613
614 pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
615
616 if (col + tw > w)
617 {
618 /*
619 * Tile is clipped horizontally. Calculate
620 * visible portion and skewing factors.
621 */
622 uint32 npix = w - col;
623 fromskew = tw - npix;
624 (*put)(img, raster+y*w+col, col, y,
625 npix, nrow, fromskew, toskew + fromskew, buf + pos);
626 }
627 else
628 {
629 (*put)(img, raster+y*w+col, col, y, tw, nrow, 0, toskew, buf + pos);
630 }
631 }
632
633 y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
634 }
635 _TIFFfree(buf);
636
637 if (flip & FLIP_HORIZONTALLY) {
638 uint32 line;
639
640 for (line = 0; line < h; line++) {
641 uint32 *left = raster + (line * w);
642 uint32 *right = left + w - 1;
643
644 while ( left < right ) {
645 uint32 temp = *left;
646 *left = *right;
647 *right = temp;
648 left++, right--;
649 }
650 }
651 }
652
653 return (ret);
654 }
655
656 /*
657 * Get an tile-organized image that has
658 * SamplesPerPixel > 1
659 * PlanarConfiguration separated
660 * We assume that all such images are RGB.
661 */
662 static int
663 gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
664 {
665 TIFF* tif = img->tif;
666 tileSeparateRoutine put = img->put.separate;
667 uint32 col, row, y, rowstoread;
668 uint32 pos;
669 uint32 tw, th;
670 unsigned char* buf;
671 unsigned char* p0;
672 unsigned char* p1;
673 unsigned char* p2;
674 unsigned char* pa;
675 tsize_t tilesize;
676 int32 fromskew, toskew;
677 int alpha = img->alpha;
678 uint32 nrow;
679 int ret = 1, flip;
680
681 tilesize = TIFFTileSize(tif);
682 buf = (unsigned char*) _TIFFmalloc((alpha?4:3)*tilesize);
683 if (buf == 0) {
684 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
685 return (0);
686 }
687 _TIFFmemset(buf, 0, (alpha?4:3)*tilesize);
688 p0 = buf;
689 p1 = p0 + tilesize;
690 p2 = p1 + tilesize;
691 pa = (alpha?(p2+tilesize):NULL);
692 TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
693 TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
694
695 flip = setorientation(img);
696 if (flip & FLIP_VERTICALLY) {
697 y = h - 1;
698 toskew = -(int32)(tw + w);
699 }
700 else {
701 y = 0;
702 toskew = -(int32)(tw - w);
703 }
704
705 for (row = 0; row < h; row += nrow)
706 {
707 rowstoread = th - (row + img->row_offset) % th;
708 nrow = (row + rowstoread > h ? h - row : rowstoread);
709 for (col = 0; col < w; col += tw)
710 {
711 if (TIFFReadTile(tif, p0, col+img->col_offset,
712 row+img->row_offset,0,0) < 0 && img->stoponerr)
713 {
714 ret = 0;
715 break;
716 }
717 if (TIFFReadTile(tif, p1, col+img->col_offset,
718 row+img->row_offset,0,1) < 0 && img->stoponerr)
719 {
720 ret = 0;
721 break;
722 }
723 if (TIFFReadTile(tif, p2, col+img->col_offset,
724 row+img->row_offset,0,2) < 0 && img->stoponerr)
725 {
726 ret = 0;
727 break;
728 }
729 if (alpha)
730 {
731 if (TIFFReadTile(tif,pa,col+img->col_offset,
732 row+img->row_offset,0,3) < 0 && img->stoponerr)
733 {
734 ret = 0;
735 break;
736 }
737 }
738
739 pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
740
741 if (col + tw > w)
742 {
743 /*
744 * Tile is clipped horizontally. Calculate
745 * visible portion and skewing factors.
746 */
747 uint32 npix = w - col;
748 fromskew = tw - npix;
749 (*put)(img, raster+y*w+col, col, y,
750 npix, nrow, fromskew, toskew + fromskew,
751 p0 + pos, p1 + pos, p2 + pos, (alpha?(pa+pos):NULL));
752 } else {
753 (*put)(img, raster+y*w+col, col, y,
754 tw, nrow, 0, toskew, p0 + pos, p1 + pos, p2 + pos, (alpha?(pa+pos):NULL));
755 }
756 }
757
758 y += (flip & FLIP_VERTICALLY ?-(int32) nrow : (int32) nrow);
759 }
760
761 if (flip & FLIP_HORIZONTALLY) {
762 uint32 line;
763
764 for (line = 0; line < h; line++) {
765 uint32 *left = raster + (line * w);
766 uint32 *right = left + w - 1;
767
768 while ( left < right ) {
769 uint32 temp = *left;
770 *left = *right;
771 *right = temp;
772 left++, right--;
773 }
774 }
775 }
776
777 _TIFFfree(buf);
778 return (ret);
779 }
780
781 /*
782 * Get a strip-organized image that has
783 * PlanarConfiguration contiguous if SamplesPerPixel > 1
784 * or
785 * SamplesPerPixel == 1
786 */
787 static int
788 gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
789 {
790 TIFF* tif = img->tif;
791 tileContigRoutine put = img->put.contig;
792 uint32 row, y, nrow, nrowsub, rowstoread;
793 uint32 pos;
794 unsigned char* buf;
795 uint32 rowsperstrip;
796 uint16 subsamplinghor,subsamplingver;
797 uint32 imagewidth = img->width;
798 tsize_t scanline;
799 int32 fromskew, toskew;
800 int ret = 1, flip;
801
802 buf = (unsigned char*) _TIFFmalloc(TIFFStripSize(tif));
803 if (buf == 0) {
804 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
805 return (0);
806 }
807 _TIFFmemset(buf, 0, TIFFStripSize(tif));
808
809 flip = setorientation(img);
810 if (flip & FLIP_VERTICALLY) {
811 y = h - 1;
812 toskew = -(int32)(w + w);
813 } else {
814 y = 0;
815 toskew = -(int32)(w - w);
816 }
817
818 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
819 TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, &subsamplingver);
820 scanline = TIFFNewScanlineSize(tif);
821 fromskew = (w < imagewidth ? imagewidth - w : 0);
822 for (row = 0; row < h; row += nrow)
823 {
824 rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
825 nrow = (row + rowstoread > h ? h - row : rowstoread);
826 nrowsub = nrow;
827 if ((nrowsub%subsamplingver)!=0)
828 nrowsub+=subsamplingver-nrowsub%subsamplingver;
829 if (TIFFReadEncodedStrip(tif,
830 TIFFComputeStrip(tif,row+img->row_offset, 0),
831 buf,
832 ((row + img->row_offset)%rowsperstrip + nrowsub) * scanline) < 0
833 && img->stoponerr)
834 {
835 ret = 0;
836 break;
837 }
838
839 pos = ((row + img->row_offset) % rowsperstrip) * scanline;
840 (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, buf + pos);
841 y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
842 }
843
844 if (flip & FLIP_HORIZONTALLY) {
845 uint32 line;
846
847 for (line = 0; line < h; line++) {
848 uint32 *left = raster + (line * w);
849 uint32 *right = left + w - 1;
850
851 while ( left < right ) {
852 uint32 temp = *left;
853 *left = *right;
854 *right = temp;
855 left++, right--;
856 }
857 }
858 }
859
860 _TIFFfree(buf);
861 return (ret);
862 }
863
864 /*
865 * Get a strip-organized image with
866 * SamplesPerPixel > 1
867 * PlanarConfiguration separated
868 * We assume that all such images are RGB.
869 */
870 static int
871 gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
872 {
873 TIFF* tif = img->tif;
874 tileSeparateRoutine put = img->put.separate;
875 unsigned char *buf;
876 unsigned char *p0, *p1, *p2, *pa;
877 uint32 row, y, nrow, rowstoread;
878 uint32 pos;
879 tsize_t scanline;
880 uint32 rowsperstrip, offset_row;
881 uint32 imagewidth = img->width;
882 tsize_t stripsize;
883 int32 fromskew, toskew;
884 int alpha = img->alpha;
885 int ret = 1, flip;
886
887 stripsize = TIFFStripSize(tif);
888 p0 = buf = (unsigned char *)_TIFFmalloc((alpha?4:3)*stripsize);
889 if (buf == 0) {
890 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
891 return (0);
892 }
893 _TIFFmemset(buf, 0, (alpha?4:3)*stripsize);
894 p1 = p0 + stripsize;
895 p2 = p1 + stripsize;
896 pa = (alpha?(p2+stripsize):NULL);
897
898 flip = setorientation(img);
899 if (flip & FLIP_VERTICALLY) {
900 y = h - 1;
901 toskew = -(int32)(w + w);
902 }
903 else {
904 y = 0;
905 toskew = -(int32)(w - w);
906 }
907
908 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
909 scanline = TIFFScanlineSize(tif);
910 fromskew = (w < imagewidth ? imagewidth - w : 0);
911 for (row = 0; row < h; row += nrow)
912 {
913 rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
914 nrow = (row + rowstoread > h ? h - row : rowstoread);
915 offset_row = row + img->row_offset;
916 if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),
917 p0, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
918 && img->stoponerr)
919 {
920 ret = 0;
921 break;
922 }
923 if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1),
924 p1, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
925 && img->stoponerr)
926 {
927 ret = 0;
928 break;
929 }
930 if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2),
931 p2, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
932 && img->stoponerr)
933 {
934 ret = 0;
935 break;
936 }
937 if (alpha)
938 {
939 if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 3),
940 pa, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
941 && img->stoponerr)
942 {
943 ret = 0;
944 break;
945 }
946 }
947
948 pos = ((row + img->row_offset) % rowsperstrip) * scanline;
949 (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, p0 + pos, p1 + pos,
950 p2 + pos, (alpha?(pa+pos):NULL));
951 y += (flip & FLIP_VERTICALLY ? -(int32) nrow : (int32) nrow);
952 }
953
954 if (flip & FLIP_HORIZONTALLY) {
955 uint32 line;
956
957 for (line = 0; line < h; line++) {
958 uint32 *left = raster + (line * w);
959 uint32 *right = left + w - 1;
960
961 while ( left < right ) {
962 uint32 temp = *left;
963 *left = *right;
964 *right = temp;
965 left++, right--;
966 }
967 }
968 }
969
970 _TIFFfree(buf);
971 return (ret);
972 }
973
974 /*
975 * The following routines move decoded data returned
976 * from the TIFF library into rasters filled with packed
977 * ABGR pixels (i.e. suitable for passing to lrecwrite.)
978 *
979 * The routines have been created according to the most
980 * important cases and optimized. PickContigCase and
981 * PickSeparateCase analyze the parameters and select
982 * the appropriate "get" and "put" routine to use.
983 */
984 #define REPEAT8(op) REPEAT4(op); REPEAT4(op)
985 #define REPEAT4(op) REPEAT2(op); REPEAT2(op)
986 #define REPEAT2(op) op; op
987 #define CASE8(x,op) \
988 switch (x) { \
989 case 7: op; case 6: op; case 5: op; \
990 case 4: op; case 3: op; case 2: op; \
991 case 1: op; \
992 }
993 #define CASE4(x,op) switch (x) { case 3: op; case 2: op; case 1: op; }
994 #define NOP
995
996 #define UNROLL8(w, op1, op2) { \
997 uint32 _x; \
998 for (_x = w; _x >= 8; _x -= 8) { \
999 op1; \
1000 REPEAT8(op2); \
1001 } \
1002 if (_x > 0) { \
1003 op1; \
1004 CASE8(_x,op2); \
1005 } \
1006 }
1007 #define UNROLL4(w, op1, op2) { \
1008 uint32 _x; \
1009 for (_x = w; _x >= 4; _x -= 4) { \
1010 op1; \
1011 REPEAT4(op2); \
1012 } \
1013 if (_x > 0) { \
1014 op1; \
1015 CASE4(_x,op2); \
1016 } \
1017 }
1018 #define UNROLL2(w, op1, op2) { \
1019 uint32 _x; \
1020 for (_x = w; _x >= 2; _x -= 2) { \
1021 op1; \
1022 REPEAT2(op2); \
1023 } \
1024 if (_x) { \
1025 op1; \
1026 op2; \
1027 } \
1028 }
1029
1030 #define SKEW(r,g,b,skew) { r += skew; g += skew; b += skew; }
1031 #define SKEW4(r,g,b,a,skew) { r += skew; g += skew; b += skew; a+= skew; }
1032
1033 #define A1 (((uint32)0xffL)<<24)
1034 #define PACK(r,g,b) \
1035 ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|A1)
1036 #define PACK4(r,g,b,a) \
1037 ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|((uint32)(a)<<24))
1038 #define W2B(v) (((v)>>8)&0xff)
1039 #define PACKW(r,g,b) \
1040 ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|A1)
1041 #define PACKW4(r,g,b,a) \
1042 ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|((uint32)W2B(a)<<24))
1043
1044 #define DECLAREContigPutFunc(name) \
1045 static void name(\
1046 TIFFRGBAImage* img, \
1047 uint32* cp, \
1048 uint32 x, uint32 y, \
1049 uint32 w, uint32 h, \
1050 int32 fromskew, int32 toskew, \
1051 unsigned char* pp \
1052 )
1053
1054 /*
1055 * 8-bit palette => colormap/RGB
1056 */
1057 DECLAREContigPutFunc(put8bitcmaptile)
1058 {
1059 uint32** PALmap = img->PALmap;
1060 int samplesperpixel = img->samplesperpixel;
1061
1062 (void) y;
1063 while (h-- > 0) {
1064 for (x = w; x-- > 0;)
1065 {
1066 *cp++ = PALmap[*pp][0];
1067 pp += samplesperpixel;
1068 }
1069 cp += toskew;
1070 pp += fromskew;
1071 }
1072 }
1073
1074 /*
1075 * 4-bit palette => colormap/RGB
1076 */
1077 DECLAREContigPutFunc(put4bitcmaptile)
1078 {
1079 uint32** PALmap = img->PALmap;
1080
1081 (void) x; (void) y;
1082 fromskew /= 2;
1083 while (h-- > 0) {
1084 uint32* bw;
1085 UNROLL2(w, bw = PALmap[*pp++], *cp++ = *bw++);
1086 cp += toskew;
1087 pp += fromskew;
1088 }
1089 }
1090
1091 /*
1092 * 2-bit palette => colormap/RGB
1093 */
1094 DECLAREContigPutFunc(put2bitcmaptile)
1095 {
1096 uint32** PALmap = img->PALmap;
1097
1098 (void) x; (void) y;
1099 fromskew /= 4;
1100 while (h-- > 0) {
1101 uint32* bw;
1102 UNROLL4(w, bw = PALmap[*pp++], *cp++ = *bw++);
1103 cp += toskew;
1104 pp += fromskew;
1105 }
1106 }
1107
1108 /*
1109 * 1-bit palette => colormap/RGB
1110 */
1111 DECLAREContigPutFunc(put1bitcmaptile)
1112 {
1113 uint32** PALmap = img->PALmap;
1114
1115 (void) x; (void) y;
1116 fromskew /= 8;
1117 while (h-- > 0) {
1118 uint32* bw;
1119 UNROLL8(w, bw = PALmap[*pp++], *cp++ = *bw++);
1120 cp += toskew;
1121 pp += fromskew;
1122 }
1123 }
1124
1125 /*
1126 * 8-bit greyscale => colormap/RGB
1127 */
1128 DECLAREContigPutFunc(putgreytile)
1129 {
1130 int samplesperpixel = img->samplesperpixel;
1131 uint32** BWmap = img->BWmap;
1132
1133 (void) y;
1134 while (h-- > 0) {
1135 for (x = w; x-- > 0;)
1136 {
1137 *cp++ = BWmap[*pp][0];
1138 pp += samplesperpixel;
1139 }
1140 cp += toskew;
1141 pp += fromskew;
1142 }
1143 }
1144
1145 /*
1146 * 16-bit greyscale => colormap/RGB
1147 */
1148 DECLAREContigPutFunc(put16bitbwtile)
1149 {
1150 int samplesperpixel = img->samplesperpixel;
1151 uint32** BWmap = img->BWmap;
1152
1153 (void) y;
1154 while (h-- > 0) {
1155 uint16 *wp = (uint16 *) pp;
1156
1157 for (x = w; x-- > 0;)
1158 {
1159 /* use high order byte of 16bit value */
1160
1161 *cp++ = BWmap[*wp >> 8][0];
1162 pp += 2 * samplesperpixel;
1163 wp += samplesperpixel;
1164 }
1165 cp += toskew;
1166 pp += fromskew;
1167 }
1168 }
1169
1170 /*
1171 * 1-bit bilevel => colormap/RGB
1172 */
1173 DECLAREContigPutFunc(put1bitbwtile)
1174 {
1175 uint32** BWmap = img->BWmap;
1176
1177 (void) x; (void) y;
1178 fromskew /= 8;
1179 while (h-- > 0) {
1180 uint32* bw;
1181 UNROLL8(w, bw = BWmap[*pp++], *cp++ = *bw++);
1182 cp += toskew;
1183 pp += fromskew;
1184 }
1185 }
1186
1187 /*
1188 * 2-bit greyscale => colormap/RGB
1189 */
1190 DECLAREContigPutFunc(put2bitbwtile)
1191 {
1192 uint32** BWmap = img->BWmap;
1193
1194 (void) x; (void) y;
1195 fromskew /= 4;
1196 while (h-- > 0) {
1197 uint32* bw;
1198 UNROLL4(w, bw = BWmap[*pp++], *cp++ = *bw++);
1199 cp += toskew;
1200 pp += fromskew;
1201 }
1202 }
1203
1204 /*
1205 * 4-bit greyscale => colormap/RGB
1206 */
1207 DECLAREContigPutFunc(put4bitbwtile)
1208 {
1209 uint32** BWmap = img->BWmap;
1210
1211 (void) x; (void) y;
1212 fromskew /= 2;
1213 while (h-- > 0) {
1214 uint32* bw;
1215 UNROLL2(w, bw = BWmap[*pp++], *cp++ = *bw++);
1216 cp += toskew;
1217 pp += fromskew;
1218 }
1219 }
1220
1221 /*
1222 * 8-bit packed samples, no Map => RGB
1223 */
1224 DECLAREContigPutFunc(putRGBcontig8bittile)
1225 {
1226 int samplesperpixel = img->samplesperpixel;
1227
1228 (void) x; (void) y;
1229 fromskew *= samplesperpixel;
1230 while (h-- > 0) {
1231 UNROLL8(w, NOP,
1232 *cp++ = PACK(pp[0], pp[1], pp[2]);
1233 pp += samplesperpixel);
1234 cp += toskew;
1235 pp += fromskew;
1236 }
1237 }
1238
1239 /*
1240 * 8-bit packed samples => RGBA w/ associated alpha
1241 * (known to have Map == NULL)
1242 */
1243 DECLAREContigPutFunc(putRGBAAcontig8bittile)
1244 {
1245 int samplesperpixel = img->samplesperpixel;
1246
1247 (void) x; (void) y;
1248 fromskew *= samplesperpixel;
1249 while (h-- > 0) {
1250 UNROLL8(w, NOP,
1251 *cp++ = PACK4(pp[0], pp[1], pp[2], pp[3]);
1252 pp += samplesperpixel);
1253 cp += toskew;
1254 pp += fromskew;
1255 }
1256 }
1257
1258 /*
1259 * 8-bit packed samples => RGBA w/ unassociated alpha
1260 * (known to have Map == NULL)
1261 */
1262 DECLAREContigPutFunc(putRGBUAcontig8bittile)
1263 {
1264 int samplesperpixel = img->samplesperpixel;
1265 (void) y;
1266 fromskew *= samplesperpixel;
1267 while (h-- > 0) {
1268 uint32 r, g, b, a;
1269 for (x = w; x-- > 0;) {
1270 a = pp[3];
1271 r = (a*pp[0] + 127) / 255;
1272 g = (a*pp[1] + 127) / 255;
1273 b = (a*pp[2] + 127) / 255;
1274 *cp++ = PACK4(r,g,b,a);
1275 pp += samplesperpixel;
1276 }
1277 cp += toskew;
1278 pp += fromskew;
1279 }
1280 }
1281
1282 /*
1283 * 16-bit packed samples => RGB
1284 */
1285 DECLAREContigPutFunc(putRGBcontig16bittile)
1286 {
1287 int samplesperpixel = img->samplesperpixel;
1288 uint16 *wp = (uint16 *)pp;
1289 (void) y;
1290 fromskew *= samplesperpixel;
1291 while (h-- > 0) {
1292 for (x = w; x-- > 0;) {
1293 *cp++ = PACKW(wp[0],wp[1],wp[2]);
1294 wp += samplesperpixel;
1295 }
1296 cp += toskew;
1297 wp += fromskew;
1298 }
1299 }
1300
1301 /*
1302 * 16-bit packed samples => RGBA w/ associated alpha
1303 * (known to have Map == NULL)
1304 */
1305 DECLAREContigPutFunc(putRGBAAcontig16bittile)
1306 {
1307 int samplesperpixel = img->samplesperpixel;
1308 uint16 *wp = (uint16 *)pp;
1309 (void) y;
1310 fromskew *= samplesperpixel;
1311 while (h-- > 0) {
1312 for (x = w; x-- > 0;) {
1313 *cp++ = PACKW4(wp[0],wp[1],wp[2],wp[3]);
1314 wp += samplesperpixel;
1315 }
1316 cp += toskew;
1317 wp += fromskew;
1318 }
1319 }
1320
1321 /*
1322 * 16-bit packed samples => RGBA w/ unassociated alpha
1323 * (known to have Map == NULL)
1324 */
1325 DECLAREContigPutFunc(putRGBUAcontig16bittile)
1326 {
1327 int samplesperpixel = img->samplesperpixel;
1328 uint16 *wp = (uint16 *)pp;
1329 (void) y;
1330 fromskew *= samplesperpixel;
1331 while (h-- > 0) {
1332 uint32 r,g,b,a;
1333 for (x = w; x-- > 0;) {
1334 a = W2B(wp[3]);
1335 r = (a*W2B(wp[0]) + 127) / 255;
1336 g = (a*W2B(wp[1]) + 127) / 255;
1337 b = (a*W2B(wp[2]) + 127) / 255;
1338 *cp++ = PACK4(r,g,b,a);
1339 wp += samplesperpixel;
1340 }
1341 cp += toskew;
1342 wp += fromskew;
1343 }
1344 }
1345
1346 /*
1347 * 8-bit packed CMYK samples w/o Map => RGB
1348 *
1349 * NB: The conversion of CMYK->RGB is *very* crude.
1350 */
1351 DECLAREContigPutFunc(putRGBcontig8bitCMYKtile)
1352 {
1353 int samplesperpixel = img->samplesperpixel;
1354 uint16 r, g, b, k;
1355
1356 (void) x; (void) y;
1357 fromskew *= samplesperpixel;
1358 while (h-- > 0) {
1359 UNROLL8(w, NOP,
1360 k = 255 - pp[3];
1361 r = (k*(255-pp[0]))/255;
1362 g = (k*(255-pp[1]))/255;
1363 b = (k*(255-pp[2]))/255;
1364 *cp++ = PACK(r, g, b);
1365 pp += samplesperpixel);
1366 cp += toskew;
1367 pp += fromskew;
1368 }
1369 }
1370
1371 /*
1372 * 8-bit packed CMYK samples w/Map => RGB
1373 *
1374 * NB: The conversion of CMYK->RGB is *very* crude.
1375 */
1376 DECLAREContigPutFunc(putRGBcontig8bitCMYKMaptile)
1377 {
1378 int samplesperpixel = img->samplesperpixel;
1379 TIFFRGBValue* Map = img->Map;
1380 uint16 r, g, b, k;
1381
1382 (void) y;
1383 fromskew *= samplesperpixel;
1384 while (h-- > 0) {
1385 for (x = w; x-- > 0;) {
1386 k = 255 - pp[3];
1387 r = (k*(255-pp[0]))/255;
1388 g = (k*(255-pp[1]))/255;
1389 b = (k*(255-pp[2]))/255;
1390 *cp++ = PACK(Map[r], Map[g], Map[b]);
1391 pp += samplesperpixel;
1392 }
1393 pp += fromskew;
1394 cp += toskew;
1395 }
1396 }
1397
1398 #define DECLARESepPutFunc(name) \
1399 static void name(\
1400 TIFFRGBAImage* img,\
1401 uint32* cp,\
1402 uint32 x, uint32 y, \
1403 uint32 w, uint32 h,\
1404 int32 fromskew, int32 toskew,\
1405 unsigned char* r, unsigned char* g, unsigned char* b, unsigned char* a\
1406 )
1407
1408 /*
1409 * 8-bit unpacked samples => RGB
1410 */
1411 DECLARESepPutFunc(putRGBseparate8bittile)
1412 {
1413 (void) img; (void) x; (void) y; (void) a;
1414 while (h-- > 0) {
1415 UNROLL8(w, NOP, *cp++ = PACK(*r++, *g++, *b++));
1416 SKEW(r, g, b, fromskew);
1417 cp += toskew;
1418 }
1419 }
1420
1421 /*
1422 * 8-bit unpacked samples => RGBA w/ associated alpha
1423 */
1424 DECLARESepPutFunc(putRGBAAseparate8bittile)
1425 {
1426 (void) img; (void) x; (void) y;
1427 while (h-- > 0) {
1428 UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++));
1429 SKEW4(r, g, b, a, fromskew);
1430 cp += toskew;
1431 }
1432 }
1433
1434 /*
1435 * 8-bit unpacked samples => RGBA w/ unassociated alpha
1436 */
1437 DECLARESepPutFunc(putRGBUAseparate8bittile)
1438 {
1439 (void) img; (void) y;
1440 while (h-- > 0) {
1441 uint32 rv, gv, bv, av;
1442 for (x = w; x-- > 0;) {
1443 av = *a++;
1444 rv = (av* *r++ + 127) / 255;
1445 gv = (av* *g++ + 127) / 255;
1446 bv = (av* *b++ + 127) / 255;
1447 *cp++ = PACK4(rv,gv,bv,av);
1448 }
1449 SKEW4(r, g, b, a, fromskew);
1450 cp += toskew;
1451 }
1452 }
1453
1454 /*
1455 * 16-bit unpacked samples => RGB
1456 */
1457 DECLARESepPutFunc(putRGBseparate16bittile)
1458 {
1459 uint16 *wr = (uint16*) r;
1460 uint16 *wg = (uint16*) g;
1461 uint16 *wb = (uint16*) b;
1462 (void) img; (void) y; (void) a;
1463 while (h-- > 0) {
1464 for (x = 0; x < w; x++)
1465 *cp++ = PACKW(*wr++,*wg++,*wb++);
1466 SKEW(wr, wg, wb, fromskew);
1467 cp += toskew;
1468 }
1469 }
1470
1471 /*
1472 * 16-bit unpacked samples => RGBA w/ associated alpha
1473 */
1474 DECLARESepPutFunc(putRGBAAseparate16bittile)
1475 {
1476 uint16 *wr = (uint16*) r;
1477 uint16 *wg = (uint16*) g;
1478 uint16 *wb = (uint16*) b;
1479 uint16 *wa = (uint16*) a;
1480 (void) img; (void) y;
1481 while (h-- > 0) {
1482 for (x = 0; x < w; x++)
1483 *cp++ = PACKW4(*wr++,*wg++,*wb++,*wa++);
1484 SKEW4(wr, wg, wb, wa, fromskew);
1485 cp += toskew;
1486 }
1487 }
1488
1489 /*
1490 * 16-bit unpacked samples => RGBA w/ unassociated alpha
1491 */
1492 DECLARESepPutFunc(putRGBUAseparate16bittile)
1493 {
1494 uint16 *wr = (uint16*) r;
1495 uint16 *wg = (uint16*) g;
1496 uint16 *wb = (uint16*) b;
1497 uint16 *wa = (uint16*) a;
1498 (void) img; (void) y;
1499 while (h-- > 0) {
1500 uint32 r,g,b,a;
1501 for (x = w; x-- > 0;) {
1502 a = W2B(*wa++);
1503 r = (a*W2B(*wr++) + 127) / 255;
1504 g = (a*W2B(*wg++) + 127) / 255;
1505 b = (a*W2B(*wb++) + 127) / 255;
1506 *cp++ = PACK4(r,g,b,a);
1507 }
1508 SKEW4(wr, wg, wb, wa, fromskew);
1509 cp += toskew;
1510 }
1511 }
1512
1513 /*
1514 * 8-bit packed CIE L*a*b 1976 samples => RGB
1515 */
1516 DECLAREContigPutFunc(putcontig8bitCIELab)
1517 {
1518 float X, Y, Z;
1519 uint32 r, g, b;
1520 (void) y;
1521 fromskew *= 3;
1522 while (h-- > 0) {
1523 for (x = w; x-- > 0;) {
1524 TIFFCIELabToXYZ(img->cielab,
1525 (unsigned char)pp[0],
1526 (signed char)pp[1],
1527 (signed char)pp[2],
1528 &X, &Y, &Z);
1529 TIFFXYZToRGB(img->cielab, X, Y, Z, &r, &g, &b);
1530 *cp++ = PACK(r, g, b);
1531 pp += 3;
1532 }
1533 cp += toskew;
1534 pp += fromskew;
1535 }
1536 }
1537
1538 /*
1539 * YCbCr -> RGB conversion and packing routines.
1540 */
1541
1542 #define YCbCrtoRGB(dst, Y) { \
1543 uint32 r, g, b; \
1544 TIFFYCbCrtoRGB(img->ycbcr, (Y), Cb, Cr, &r, &g, &b); \
1545 dst = PACK(r, g, b); \
1546 }
1547
1548 /*
1549 * 8-bit packed YCbCr samples => RGB
1550 * This function is generic for different sampling sizes,
1551 * and can handle blocks sizes that aren't multiples of the
1552 * sampling size. However, it is substantially less optimized
1553 * than the specific sampling cases. It is used as a fallback
1554 * for difficult blocks.
1555 */
1556 #ifdef notdef
1557 static void putcontig8bitYCbCrGenericTile(
1558 TIFFRGBAImage* img,
1559 uint32* cp,
1560 uint32 x, uint32 y,
1561 uint32 w, uint32 h,
1562 int32 fromskew, int32 toskew,
1563 unsigned char* pp,
1564 int h_group,
1565 int v_group )
1566
1567 {
1568 uint32* cp1 = cp+w+toskew;
1569 uint32* cp2 = cp1+w+toskew;
1570 uint32* cp3 = cp2+w+toskew;
1571 int32 incr = 3*w+4*toskew;
1572 int32 Cb, Cr;
1573 int group_size = v_group * h_group + 2;
1574
1575 (void) y;
1576 fromskew = (fromskew * group_size) / h_group;
1577
1578 for( yy = 0; yy < h; yy++ )
1579 {
1580 unsigned char *pp_line;
1581 int y_line_group = yy / v_group;
1582 int y_remainder = yy - y_line_group * v_group;
1583
1584 pp_line = pp + v_line_group *
1585
1586
1587 for( xx = 0; xx < w; xx++ )
1588 {
1589 Cb = pp
1590 }
1591 }
1592 for (; h >= 4; h -= 4) {
1593 x = w>>2;
1594 do {
1595 Cb = pp[16];
1596 Cr = pp[17];
1597
1598 YCbCrtoRGB(cp [0], pp[ 0]);
1599 YCbCrtoRGB(cp [1], pp[ 1]);
1600 YCbCrtoRGB(cp [2], pp[ 2]);
1601 YCbCrtoRGB(cp [3], pp[ 3]);
1602 YCbCrtoRGB(cp1[0], pp[ 4]);
1603 YCbCrtoRGB(cp1[1], pp[ 5]);
1604 YCbCrtoRGB(cp1[2], pp[ 6]);
1605 YCbCrtoRGB(cp1[3], pp[ 7]);
1606 YCbCrtoRGB(cp2[0], pp[ 8]);
1607 YCbCrtoRGB(cp2[1], pp[ 9]);
1608 YCbCrtoRGB(cp2[2], pp[10]);
1609 YCbCrtoRGB(cp2[3], pp[11]);
1610 YCbCrtoRGB(cp3[0], pp[12]);
1611 YCbCrtoRGB(cp3[1], pp[13]);
1612 YCbCrtoRGB(cp3[2], pp[14]);
1613 YCbCrtoRGB(cp3[3], pp[15]);
1614
1615 cp += 4, cp1 += 4, cp2 += 4, cp3 += 4;
1616 pp += 18;
1617 } while (--x);
1618 cp += incr, cp1 += incr, cp2 += incr, cp3 += incr;
1619 pp += fromskew;
1620 }
1621 }
1622 #endif
1623
1624 /*
1625 * 8-bit packed YCbCr samples w/ 4,4 subsampling => RGB
1626 */
1627 DECLAREContigPutFunc(putcontig8bitYCbCr44tile)
1628 {
1629 uint32* cp1 = cp+w+toskew;
1630 uint32* cp2 = cp1+w+toskew;
1631 uint32* cp3 = cp2+w+toskew;
1632 int32 incr = 3*w+4*toskew;
1633
1634 (void) y;
1635 /* adjust fromskew */
1636 fromskew = (fromskew * 18) / 4;
1637 if ((h & 3) == 0 && (w & 3) == 0) {
1638 for (; h >= 4; h -= 4) {
1639 x = w>>2;
1640 do {
1641 int32 Cb = pp[16];
1642 int32 Cr = pp[17];
1643
1644 YCbCrtoRGB(cp [0], pp[ 0]);
1645 YCbCrtoRGB(cp [1], pp[ 1]);
1646 YCbCrtoRGB(cp [2], pp[ 2]);
1647 YCbCrtoRGB(cp [3], pp[ 3]);
1648 YCbCrtoRGB(cp1[0], pp[ 4]);
1649 YCbCrtoRGB(cp1[1], pp[ 5]);
1650 YCbCrtoRGB(cp1[2], pp[ 6]);
1651 YCbCrtoRGB(cp1[3], pp[ 7]);
1652 YCbCrtoRGB(cp2[0], pp[ 8]);
1653 YCbCrtoRGB(cp2[1], pp[ 9]);
1654 YCbCrtoRGB(cp2[2], pp[10]);
1655 YCbCrtoRGB(cp2[3], pp[11]);
1656 YCbCrtoRGB(cp3[0], pp[12]);
1657 YCbCrtoRGB(cp3[1], pp[13]);
1658 YCbCrtoRGB(cp3[2], pp[14]);
1659 YCbCrtoRGB(cp3[3], pp[15]);
1660
1661 cp += 4, cp1 += 4, cp2 += 4, cp3 += 4;
1662 pp += 18;
1663 } while (--x);
1664 cp += incr, cp1 += incr, cp2 += incr, cp3 += incr;
1665 pp += fromskew;
1666 }
1667 } else {
1668 while (h > 0) {
1669 for (x = w; x > 0;) {
1670 int32 Cb = pp[16];
1671 int32 Cr = pp[17];
1672 switch (x) {
1673 default:
1674 switch (h) {
1675 default: YCbCrtoRGB(cp3[3], pp[15]); /* FALLTHROUGH */
1676 case 3: YCbCrtoRGB(cp2[3], pp[11]); /* FALLTHROUGH */
1677 case 2: YCbCrtoRGB(cp1[3], pp[ 7]); /* FALLTHROUGH */
1678 case 1: YCbCrtoRGB(cp [3], pp[ 3]); /* FALLTHROUGH */
1679 } /* FALLTHROUGH */
1680 case 3:
1681 switch (h) {
1682 default: YCbCrtoRGB(cp3[2], pp[14]); /* FALLTHROUGH */
1683 case 3: YCbCrtoRGB(cp2[2], pp[10]); /* FALLTHROUGH */
1684 case 2: YCbCrtoRGB(cp1[2], pp[ 6]); /* FALLTHROUGH */
1685 case 1: YCbCrtoRGB(cp [2], pp[ 2]); /* FALLTHROUGH */
1686 } /* FALLTHROUGH */
1687 case 2:
1688 switch (h) {
1689 default: YCbCrtoRGB(cp3[1], pp[13]); /* FALLTHROUGH */
1690 case 3: YCbCrtoRGB(cp2[1], pp[ 9]); /* FALLTHROUGH */
1691 case 2: YCbCrtoRGB(cp1[1], pp[ 5]); /* FALLTHROUGH */
1692 case 1: YCbCrtoRGB(cp [1], pp[ 1]); /* FALLTHROUGH */
1693 } /* FALLTHROUGH */
1694 case 1:
1695 switch (h) {
1696 default: YCbCrtoRGB(cp3[0], pp[12]); /* FALLTHROUGH */
1697 case 3: YCbCrtoRGB(cp2[0], pp[ 8]); /* FALLTHROUGH */
1698 case 2: YCbCrtoRGB(cp1[0], pp[ 4]); /* FALLTHROUGH */
1699 case 1: YCbCrtoRGB(cp [0], pp[ 0]); /* FALLTHROUGH */
1700 } /* FALLTHROUGH */
1701 }
1702 if (x < 4) {
1703 cp += x; cp1 += x; cp2 += x; cp3 += x;
1704 x = 0;
1705 }
1706 else {
1707 cp += 4; cp1 += 4; cp2 += 4; cp3 += 4;
1708 x -= 4;
1709 }
1710 pp += 18;
1711 }
1712 if (h <= 4)
1713 break;
1714 h -= 4;
1715 cp += incr, cp1 += incr, cp2 += incr, cp3 += incr;
1716 pp += fromskew;
1717 }
1718 }
1719 }
1720
1721 /*
1722 * 8-bit packed YCbCr samples w/ 4,2 subsampling => RGB
1723 */
1724 DECLAREContigPutFunc(putcontig8bitYCbCr42tile)
1725 {
1726 uint32* cp1 = cp+w+toskew;
1727 int32 incr = 2*toskew+w;
1728
1729 (void) y;
1730 fromskew = (fromskew * 10) / 4;
1731 if ((h & 3) == 0 && (w & 1) == 0) {
1732 for (; h >= 2; h -= 2) {
1733 x = w>>2;
1734 do {
1735 int32 Cb = pp[8];
1736 int32 Cr = pp[9];
1737
1738 YCbCrtoRGB(cp [0], pp[0]);
1739 YCbCrtoRGB(cp [1], pp[1]);
1740 YCbCrtoRGB(cp [2], pp[2]);
1741 YCbCrtoRGB(cp [3], pp[3]);
1742 YCbCrtoRGB(cp1[0], pp[4]);
1743 YCbCrtoRGB(cp1[1], pp[5]);
1744 YCbCrtoRGB(cp1[2], pp[6]);
1745 YCbCrtoRGB(cp1[3], pp[7]);
1746
1747 cp += 4, cp1 += 4;
1748 pp += 10;
1749 } while (--x);
1750 cp += incr, cp1 += incr;
1751 pp += fromskew;
1752 }
1753 } else {
1754 while (h > 0) {
1755 for (x = w; x > 0;) {
1756 int32 Cb = pp[8];
1757 int32 Cr = pp[9];
1758 switch (x) {
1759 default:
1760 switch (h) {
1761 default: YCbCrtoRGB(cp1[3], pp[ 7]); /* FALLTHROUGH */
1762 case 1: YCbCrtoRGB(cp [3], pp[ 3]); /* FALLTHROUGH */
1763 } /* FALLTHROUGH */
1764 case 3:
1765 switch (h) {
1766 default: YCbCrtoRGB(cp1[2], pp[ 6]); /* FALLTHROUGH */
1767 case 1: YCbCrtoRGB(cp [2], pp[ 2]); /* FALLTHROUGH */
1768 } /* FALLTHROUGH */
1769 case 2:
1770 switch (h) {
1771 default: YCbCrtoRGB(cp1[1], pp[ 5]); /* FALLTHROUGH */
1772 case 1: YCbCrtoRGB(cp [1], pp[ 1]); /* FALLTHROUGH */
1773 } /* FALLTHROUGH */
1774 case 1:
1775 switch (h) {
1776 default: YCbCrtoRGB(cp1[0], pp[ 4]); /* FALLTHROUGH */
1777 case 1: YCbCrtoRGB(cp [0], pp[ 0]); /* FALLTHROUGH */
1778 } /* FALLTHROUGH */
1779 }
1780 if (x < 4) {
1781 cp += x; cp1 += x;
1782 x = 0;
1783 }
1784 else {
1785 cp += 4; cp1 += 4;
1786 x -= 4;
1787 }
1788 pp += 10;
1789 }
1790 if (h <= 2)
1791 break;
1792 h -= 2;
1793 cp += incr, cp1 += incr;
1794 pp += fromskew;
1795 }
1796 }
1797 }
1798
1799 /*
1800 * 8-bit packed YCbCr samples w/ 4,1 subsampling => RGB
1801 */
1802 DECLAREContigPutFunc(putcontig8bitYCbCr41tile)
1803 {
1804 (void) y;
1805 /* XXX adjust fromskew */
1806 do {
1807 x = w>>2;
1808 do {
1809 int32 Cb = pp[4];
1810 int32 Cr = pp[5];
1811
1812 YCbCrtoRGB(cp [0], pp[0]);
1813 YCbCrtoRGB(cp [1], pp[1]);
1814 YCbCrtoRGB(cp [2], pp[2]);
1815 YCbCrtoRGB(cp [3], pp[3]);
1816
1817 cp += 4;
1818 pp += 6;
1819 } while (--x);
1820
1821 if( (w&3) != 0 )
1822 {
1823 int32 Cb = pp[4];
1824 int32 Cr = pp[5];
1825
1826 switch( (w&3) ) {
1827 case 3: YCbCrtoRGB(cp [2], pp[2]);
1828 case 2: YCbCrtoRGB(cp [1], pp[1]);
1829 case 1: YCbCrtoRGB(cp [0], pp[0]);
1830 case 0: break;
1831 }
1832
1833 cp += (w&3);
1834 pp += 6;
1835 }
1836
1837 cp += toskew;
1838 pp += fromskew;
1839 } while (--h);
1840
1841 }
1842
1843 /*
1844 * 8-bit packed YCbCr samples w/ 2,2 subsampling => RGB
1845 */
1846 DECLAREContigPutFunc(putcontig8bitYCbCr22tile)
1847 {
1848 uint32* cp2;
1849 (void) y;
1850 fromskew = (fromskew / 2) * 6;
1851 cp2 = cp+w+toskew;
1852 while (h>=2) {
1853 x = w;
1854 while (x>=2) {
1855 uint32 Cb = pp[4];
1856 uint32 Cr = pp[5];
1857 YCbCrtoRGB(cp[0], pp[0]);
1858 YCbCrtoRGB(cp[1], pp[1]);
1859 YCbCrtoRGB(cp2[0], pp[2]);
1860 YCbCrtoRGB(cp2[1], pp[3]);
1861 cp += 2;
1862 cp2 += 2;
1863 pp += 6;
1864 x -= 2;
1865 }
1866 if (x==1) {
1867 uint32 Cb = pp[4];
1868 uint32 Cr = pp[5];
1869 YCbCrtoRGB(cp[0], pp[0]);
1870 YCbCrtoRGB(cp2[0], pp[2]);
1871 cp ++ ;
1872 cp2 ++ ;
1873 pp += 6;
1874 }
1875 cp += toskew*2+w;
1876 cp2 += toskew*2+w;
1877 pp += fromskew;
1878 h-=2;
1879 }
1880 if (h==1) {
1881 x = w;
1882 while (x>=2) {
1883 uint32 Cb = pp[4];
1884 uint32 Cr = pp[5];
1885 YCbCrtoRGB(cp[0], pp[0]);
1886 YCbCrtoRGB(cp[1], pp[1]);
1887 cp += 2;
1888 cp2 += 2;
1889 pp += 6;
1890 x -= 2;
1891 }
1892 if (x==1) {
1893 uint32 Cb = pp[4];
1894 uint32 Cr = pp[5];
1895 YCbCrtoRGB(cp[0], pp[0]);
1896 }
1897 }
1898 }
1899
1900 /*
1901 * 8-bit packed YCbCr samples w/ 2,1 subsampling => RGB
1902 */
1903 DECLAREContigPutFunc(putcontig8bitYCbCr21tile)
1904 {
1905 (void) y;
1906 fromskew = (fromskew * 4) / 2;
1907 do {
1908 x = w>>1;
1909 do {
1910 int32 Cb = pp[2];
1911 int32 Cr = pp[3];
1912
1913 YCbCrtoRGB(cp[0], pp[0]);
1914 YCbCrtoRGB(cp[1], pp[1]);
1915
1916 cp += 2;
1917 pp += 4;
1918 } while (--x);
1919
1920 if( (w&1) != 0 )
1921 {
1922 int32 Cb = pp[2];
1923 int32 Cr = pp[3];
1924
1925 YCbCrtoRGB(cp[0], pp[0]);
1926
1927 cp += 1;
1928 pp += 4;
1929 }
1930
1931 cp += toskew;
1932 pp += fromskew;
1933 } while (--h);
1934 }
1935
1936 /*
1937 * 8-bit packed YCbCr samples w/ 1,2 subsampling => RGB
1938 */
1939 DECLAREContigPutFunc(putcontig8bitYCbCr12tile)
1940 {
1941 uint32* cp2;
1942 (void) y;
1943 fromskew = (fromskew / 2) * 4;
1944 cp2 = cp+w+toskew;
1945 while (h>=2) {
1946 x = w;
1947 do {
1948 uint32 Cb = pp[2];
1949 uint32 Cr = pp[3];
1950 YCbCrtoRGB(cp[0], pp[0]);
1951 YCbCrtoRGB(cp2[0], pp[1]);
1952 cp ++;
1953 cp2 ++;
1954 pp += 4;
1955 } while (--x);
1956 cp += toskew*2+w;
1957 cp2 += toskew*2+w;
1958 pp += fromskew;
1959 h-=2;
1960 }
1961 if (h==1) {
1962 x = w;
1963 do {
1964 uint32 Cb = pp[2];
1965 uint32 Cr = pp[3];
1966 YCbCrtoRGB(cp[0], pp[0]);
1967 cp ++;
1968 pp += 4;
1969 } while (--x);
1970 }
1971 }
1972
1973 /*
1974 * 8-bit packed YCbCr samples w/ no subsampling => RGB
1975 */
1976 DECLAREContigPutFunc(putcontig8bitYCbCr11tile)
1977 {
1978 (void) y;
1979 fromskew *= 3;
1980 do {
1981 x = w; /* was x = w>>1; patched 2000/09/25 warmerda@home.com */
1982 do {
1983 int32 Cb = pp[1];
1984 int32 Cr = pp[2];
1985
1986 YCbCrtoRGB(*cp++, pp[0]);
1987
1988 pp += 3;
1989 } while (--x);
1990 cp += toskew;
1991 pp += fromskew;
1992 } while (--h);
1993 }
1994
1995 /*
1996 * 8-bit packed YCbCr samples w/ no subsampling => RGB
1997 */
1998 DECLARESepPutFunc(putseparate8bitYCbCr11tile)
1999 {
2000 (void) y;
2001 (void) a;
2002 /* TODO: naming of input vars is still off, change obfuscating declaration inside define, or resolve obfuscation */
2003 while (h-- > 0) {
2004 x = w;
2005 do {
2006 uint32 dr, dg, db;
2007 TIFFYCbCrtoRGB(img->ycbcr,*r++,*g++,*b++,&dr,&dg,&db);
2008 *cp++ = PACK(dr,dg,db);
2009 } while (--x);
2010 SKEW(r, g, b, fromskew);
2011 cp += toskew;
2012 }
2013 }
2014 #undef YCbCrtoRGB
2015
2016 static int
2017 initYCbCrConversion(TIFFRGBAImage* img)
2018 {
2019 static char module[] = "initYCbCrConversion";
2020
2021 float *luma, *refBlackWhite;
2022
2023 if (img->ycbcr == NULL) {
2024 img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc(
2025 TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long))
2026 + 4*256*sizeof (TIFFRGBValue)
2027 + 2*256*sizeof (int)
2028 + 3*256*sizeof (int32)
2029 );
2030 if (img->ycbcr == NULL) {
2031 TIFFErrorExt(img->tif->tif_clientdata, module,
2032 "No space for YCbCr->RGB conversion state");
2033 return (0);
2034 }
2035 }
2036
2037 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRCOEFFICIENTS, &luma);
2038 TIFFGetFieldDefaulted(img->tif, TIFFTAG_REFERENCEBLACKWHITE,
2039 &refBlackWhite);
2040 if (TIFFYCbCrToRGBInit(img->ycbcr, luma, refBlackWhite) < 0)
2041 return(0);
2042 return (1);
2043 }
2044
2045 static tileContigRoutine
2046 initCIELabConversion(TIFFRGBAImage* img)
2047 {
2048 static char module[] = "initCIELabConversion";
2049
2050 float *whitePoint;
2051 float refWhite[3];
2052
2053 if (!img->cielab) {
2054 img->cielab = (TIFFCIELabToRGB *)
2055 _TIFFmalloc(sizeof(TIFFCIELabToRGB));
2056 if (!img->cielab) {
2057 TIFFErrorExt(img->tif->tif_clientdata, module,
2058 "No space for CIE L*a*b*->RGB conversion state.");
2059 return NULL;
2060 }
2061 }
2062
2063 TIFFGetFieldDefaulted(img->tif, TIFFTAG_WHITEPOINT, &whitePoint);
2064 refWhite[1] = 100.0F;
2065 refWhite[0] = whitePoint[0] / whitePoint[1] * refWhite[1];
2066 refWhite[2] = (1.0F - whitePoint[0] - whitePoint[1])
2067 / whitePoint[1] * refWhite[1];
2068 if (TIFFCIELabToRGBInit(img->cielab, &display_sRGB, refWhite) < 0) {
2069 TIFFErrorExt(img->tif->tif_clientdata, module,
2070 "Failed to initialize CIE L*a*b*->RGB conversion state.");
2071 _TIFFfree(img->cielab);
2072 return NULL;
2073 }
2074
2075 return putcontig8bitCIELab;
2076 }
2077
2078 /*
2079 * Greyscale images with less than 8 bits/sample are handled
2080 * with a table to avoid lots of shifts and masks. The table
2081 * is setup so that put*bwtile (below) can retrieve 8/bitspersample
2082 * pixel values simply by indexing into the table with one
2083 * number.
2084 */
2085 static int
2086 makebwmap(TIFFRGBAImage* img)
2087 {
2088 TIFFRGBValue* Map = img->Map;
2089 int bitspersample = img->bitspersample;
2090 int nsamples = 8 / bitspersample;
2091 int i;
2092 uint32* p;
2093
2094 if( nsamples == 0 )
2095 nsamples = 1;
2096
2097 img->BWmap = (uint32**) _TIFFmalloc(
2098 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32)));
2099 if (img->BWmap == NULL) {
2100 TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No space for B&W mapping table");
2101 return (0);
2102 }
2103 p = (uint32*)(img->BWmap + 256);
2104 for (i = 0; i < 256; i++) {
2105 TIFFRGBValue c;
2106 img->BWmap[i] = p;
2107 switch (bitspersample) {
2108 #define GREY(x) c = Map[x]; *p++ = PACK(c,c,c);
2109 case 1:
2110 GREY(i>>7);
2111 GREY((i>>6)&1);
2112 GREY((i>>5)&1);
2113 GREY((i>>4)&1);
2114 GREY((i>>3)&1);
2115 GREY((i>>2)&1);
2116 GREY((i>>1)&1);
2117 GREY(i&1);
2118 break;
2119 case 2:
2120 GREY(i>>6);
2121 GREY((i>>4)&3);
2122 GREY((i>>2)&3);
2123 GREY(i&3);
2124 break;
2125 case 4:
2126 GREY(i>>4);
2127 GREY(i&0xf);
2128 break;
2129 case 8:
2130 case 16:
2131 GREY(i);
2132 break;
2133 }
2134 #undef GREY
2135 }
2136 return (1);
2137 }
2138
2139 /*
2140 * Construct a mapping table to convert from the range
2141 * of the data samples to [0,255] --for display. This
2142 * process also handles inverting B&W images when needed.
2143 */
2144 static int
2145 setupMap(TIFFRGBAImage* img)
2146 {
2147 int32 x, range;
2148
2149 range = (int32)((1L<<img->bitspersample)-1);
2150
2151 /* treat 16 bit the same as eight bit */
2152 if( img->bitspersample == 16 )
2153 range = (int32) 255;
2154
2155 img->Map = (TIFFRGBValue*) _TIFFmalloc((range+1) * sizeof (TIFFRGBValue));
2156 if (img->Map == NULL) {
2157 TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif),
2158 "No space for photometric conversion table");
2159 return (0);
2160 }
2161 if (img->photometric == PHOTOMETRIC_MINISWHITE) {
2162 for (x = 0; x <= range; x++)
2163 img->Map[x] = (TIFFRGBValue) (((range - x) * 255) / range);
2164 } else {
2165 for (x = 0; x <= range; x++)
2166 img->Map[x] = (TIFFRGBValue) ((x * 255) / range);
2167 }
2168 if (img->bitspersample <= 16 &&
2169 (img->photometric == PHOTOMETRIC_MINISBLACK ||
2170 img->photometric == PHOTOMETRIC_MINISWHITE)) {
2171 /*
2172 * Use photometric mapping table to construct
2173 * unpacking tables for samples <= 8 bits.
2174 */
2175 if (!makebwmap(img))
2176 return (0);
2177 /* no longer need Map, free it */
2178 _TIFFfree(img->Map), img->Map = NULL;
2179 }
2180 return (1);
2181 }
2182
2183 static int
2184 checkcmap(TIFFRGBAImage* img)
2185 {
2186 uint16* r = img->redcmap;
2187 uint16* g = img->greencmap;
2188 uint16* b = img->bluecmap;
2189 long n = 1L<<img->bitspersample;
2190
2191 while (n-- > 0)
2192 if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
2193 return (16);
2194 return (8);
2195 }
2196
2197 static void
2198 cvtcmap(TIFFRGBAImage* img)
2199 {
2200 uint16* r = img->redcmap;
2201 uint16* g = img->greencmap;
2202 uint16* b = img->bluecmap;
2203 long i;
2204
2205 for (i = (1L<<img->bitspersample)-1; i >= 0; i--) {
2206 #define CVT(x) ((uint16)((x)>>8))
2207 r[i] = CVT(r[i]);
2208 g[i] = CVT(g[i]);
2209 b[i] = CVT(b[i]);
2210 #undef CVT
2211 }
2212 }
2213
2214 /*
2215 * Palette images with <= 8 bits/sample are handled
2216 * with a table to avoid lots of shifts and masks. The table
2217 * is setup so that put*cmaptile (below) can retrieve 8/bitspersample
2218 * pixel values simply by indexing into the table with one
2219 * number.
2220 */
2221 static int
2222 makecmap(TIFFRGBAImage* img)
2223 {
2224 int bitspersample = img->bitspersample;
2225 int nsamples = 8 / bitspersample;
2226 uint16* r = img->redcmap;
2227 uint16* g = img->greencmap;
2228 uint16* b = img->bluecmap;
2229 uint32 *p;
2230 int i;
2231
2232 img->PALmap = (uint32**) _TIFFmalloc(
2233 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32)));
2234 if (img->PALmap == NULL) {
2235 TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No space for Palette mapping table");
2236 return (0);
2237 }
2238 p = (uint32*)(img->PALmap + 256);
2239 for (i = 0; i < 256; i++) {
2240 TIFFRGBValue c;
2241 img->PALmap[i] = p;
2242 #define CMAP(x) c = (TIFFRGBValue) x; *p++ = PACK(r[c]&0xff, g[c]&0xff, b[c]&0xff);
2243 switch (bitspersample) {
2244 case 1:
2245 CMAP(i>>7);
2246 CMAP((i>>6)&1);
2247 CMAP((i>>5)&1);
2248 CMAP((i>>4)&1);
2249 CMAP((i>>3)&1);
2250 CMAP((i>>2)&1);
2251 CMAP((i>>1)&1);
2252 CMAP(i&1);
2253 break;
2254 case 2:
2255 CMAP(i>>6);
2256 CMAP((i>>4)&3);
2257 CMAP((i>>2)&3);
2258 CMAP(i&3);
2259 break;
2260 case 4:
2261 CMAP(i>>4);
2262 CMAP(i&0xf);
2263 break;
2264 case 8:
2265 CMAP(i);
2266 break;
2267 }
2268 #undef CMAP
2269 }
2270 return (1);
2271 }
2272
2273 /*
2274 * Construct any mapping table used
2275 * by the associated put routine.
2276 */
2277 static int
2278 buildMap(TIFFRGBAImage* img)
2279 {
2280 switch (img->photometric) {
2281 case PHOTOMETRIC_RGB:
2282 case PHOTOMETRIC_YCBCR:
2283 case PHOTOMETRIC_SEPARATED:
2284 if (img->bitspersample == 8)
2285 break;
2286 /* fall thru... */
2287 case PHOTOMETRIC_MINISBLACK:
2288 case PHOTOMETRIC_MINISWHITE:
2289 if (!setupMap(img))
2290 return (0);
2291 break;
2292 case PHOTOMETRIC_PALETTE:
2293 /*
2294 * Convert 16-bit colormap to 8-bit (unless it looks
2295 * like an old-style 8-bit colormap).
2296 */
2297 if (checkcmap(img) == 16)
2298 cvtcmap(img);
2299 else
2300 TIFFWarningExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "Assuming 8-bit colormap");
2301 /*
2302 * Use mapping table and colormap to construct
2303 * unpacking tables for samples < 8 bits.
2304 */
2305 if (img->bitspersample <= 8 && !makecmap(img))
2306 return (0);
2307 break;
2308 }
2309 return (1);
2310 }
2311
2312 /*
2313 * Select the appropriate conversion routine for packed data.
2314 */
2315 static int
2316 PickContigCase(TIFFRGBAImage* img)
2317 {
2318 img->get = TIFFIsTiled(img->tif) ? gtTileContig : gtStripContig;
2319 img->put.contig = NULL;
2320 switch (img->photometric) {
2321 case PHOTOMETRIC_RGB:
2322 switch (img->bitspersample) {
2323 case 8:
2324 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
2325 img->put.contig = putRGBAAcontig8bittile;
2326 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
2327 {
2328 img->put.contig = putRGBUAcontig8bittile;
2329 }
2330 else
2331 img->put.contig = putRGBcontig8bittile;
2332 break;
2333 case 16:
2334 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
2335 {
2336 img->put.contig = putRGBAAcontig16bittile;
2337 }
2338 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
2339 {
2340 img->put.contig = putRGBUAcontig16bittile;
2341 }
2342 else
2343 {
2344 img->put.contig = putRGBcontig16bittile;
2345 }
2346 break;
2347 }
2348 break;
2349 case PHOTOMETRIC_SEPARATED:
2350 if (buildMap(img)) {
2351 if (img->bitspersample == 8) {
2352 if (!img->Map)
2353 img->put.contig = putRGBcontig8bitCMYKtile;
2354 else
2355 img->put.contig = putRGBcontig8bitCMYKMaptile;
2356 }
2357 }
2358 break;
2359 case PHOTOMETRIC_PALETTE:
2360 if (buildMap(img)) {
2361 switch (img->bitspersample) {
2362 case 8:
2363 img->put.contig = put8bitcmaptile;
2364 break;
2365 case 4:
2366 img->put.contig = put4bitcmaptile;
2367 break;
2368 case 2:
2369 img->put.contig = put2bitcmaptile;
2370 break;
2371 case 1:
2372 img->put.contig = put1bitcmaptile;
2373 break;
2374 }
2375 }
2376 break;
2377 case PHOTOMETRIC_MINISWHITE:
2378 case PHOTOMETRIC_MINISBLACK:
2379 if (buildMap(img)) {
2380 switch (img->bitspersample) {
2381 case 16:
2382 img->put.contig = put16bitbwtile;
2383 break;
2384 case 8:
2385 img->put.contig = putgreytile;
2386 break;
2387 case 4:
2388 img->put.contig = put4bitbwtile;
2389 break;
2390 case 2:
2391 img->put.contig = put2bitbwtile;
2392 break;
2393 case 1:
2394 img->put.contig = put1bitbwtile;
2395 break;
2396 }
2397 }
2398 break;
2399 case PHOTOMETRIC_YCBCR:
2400 if (img->bitspersample == 8)
2401 {
2402 if (initYCbCrConversion(img)!=0)
2403 {
2404 /*
2405 * The 6.0 spec says that subsampling must be
2406 * one of 1, 2, or 4, and that vertical subsampling
2407 * must always be <= horizontal subsampling; so
2408 * there are only a few possibilities and we just
2409 * enumerate the cases.
2410 * Joris: added support for the [1,2] case, nonetheless, to accomodate
2411 * some OJPEG files
2412 */
2413 uint16 SubsamplingHor;
2414 uint16 SubsamplingVer;
2415 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &SubsamplingHor, &SubsamplingVer);
2416 switch ((SubsamplingHor<<4)|SubsamplingVer) {
2417 case 0x44:
2418 img->put.contig = putcontig8bitYCbCr44tile;
2419 break;
2420 case 0x42:
2421 img->put.contig = putcontig8bitYCbCr42tile;
2422 break;
2423 case 0x41:
2424 img->put.contig = putcontig8bitYCbCr41tile;
2425 break;
2426 case 0x22:
2427 img->put.contig = putcontig8bitYCbCr22tile;
2428 break;
2429 case 0x21:
2430 img->put.contig = putcontig8bitYCbCr21tile;
2431 break;
2432 case 0x12:
2433 img->put.contig = putcontig8bitYCbCr12tile;
2434 break;
2435 case 0x11:
2436 img->put.contig = putcontig8bitYCbCr11tile;
2437 break;
2438 }
2439 }
2440 }
2441 break;
2442 case PHOTOMETRIC_CIELAB:
2443 if (buildMap(img)) {
2444 if (img->bitspersample == 8)
2445 img->put.contig = initCIELabConversion(img);
2446 break;
2447 }
2448 }
2449 return ((img->get!=NULL) && (img->put.contig!=NULL));
2450 }
2451
2452 /*
2453 * Select the appropriate conversion routine for unpacked data.
2454 *
2455 * NB: we assume that unpacked single channel data is directed
2456 * to the "packed routines.
2457 */
2458 static int
2459 PickSeparateCase(TIFFRGBAImage* img)
2460 {
2461 img->get = TIFFIsTiled(img->tif) ? gtTileSeparate : gtStripSeparate;
2462 img->put.separate = NULL;
2463 switch (img->photometric) {
2464 case PHOTOMETRIC_RGB:
2465 switch (img->bitspersample) {
2466 case 8:
2467 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
2468 img->put.separate = putRGBAAseparate8bittile;
2469 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
2470 {
2471 img->put.separate = putRGBUAseparate8bittile;
2472 }
2473 else
2474 img->put.separate = putRGBseparate8bittile;
2475 break;
2476 case 16:
2477 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
2478 {
2479 img->put.separate = putRGBAAseparate16bittile;
2480 }
2481 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
2482 {
2483 img->put.separate = putRGBUAseparate16bittile;
2484 }
2485 else
2486 {
2487 img->put.separate = putRGBseparate16bittile;
2488 }
2489 break;
2490 }
2491 break;
2492 case PHOTOMETRIC_YCBCR:
2493 if ((img->bitspersample==8) && (img->samplesperpixel==3))
2494 {
2495 if (initYCbCrConversion(img)!=0)
2496 {
2497 uint16 hs, vs;
2498 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs);
2499 switch ((hs<<4)|vs) {
2500 case 0x11:
2501 img->put.separate = putseparate8bitYCbCr11tile;
2502 break;
2503 /* TODO: add other cases here */
2504 }
2505 }
2506 }
2507 break;
2508 }
2509 return ((img->get!=NULL) && (img->put.separate!=NULL));
2510 }
2511
2512 /*
2513 * Read a whole strip off data from the file, and convert to RGBA form.
2514 * If this is the last strip, then it will only contain the portion of
2515 * the strip that is actually within the image space. The result is
2516 * organized in bottom to top form.
2517 */
2518
2519
2520 int
2521 TIFFReadRGBAStrip(TIFF* tif, uint32 row, uint32 * raster )
2522
2523 {
2524 char emsg[1024] = "";
2525 TIFFRGBAImage img;
2526 int ok;
2527 uint32 rowsperstrip, rows_to_read;
2528
2529 if( TIFFIsTiled( tif ) )
2530 {
2531 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
2532 "Can't use TIFFReadRGBAStrip() with tiled file.");
2533 return (0);
2534 }
2535
2536 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
2537 if( (row % rowsperstrip) != 0 )
2538 {
2539 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
2540 "Row passed to TIFFReadRGBAStrip() must be first in a strip.");
2541 return (0);
2542 }
2543
2544 if (TIFFRGBAImageOK(tif, emsg) && TIFFRGBAImageBegin(&img, tif, 0, emsg)) {
2545
2546 img.row_offset = row;
2547 img.col_offset = 0;
2548
2549 if( row + rowsperstrip > img.height )
2550 rows_to_read = img.height - row;
2551 else
2552 rows_to_read = rowsperstrip;
2553
2554 ok = TIFFRGBAImageGet(&img, raster, img.width, rows_to_read );
2555
2556 TIFFRGBAImageEnd(&img);
2557 } else {
2558 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
2559 ok = 0;
2560 }
2561
2562 return (ok);
2563 }
2564
2565 /*
2566 * Read a whole tile off data from the file, and convert to RGBA form.
2567 * The returned RGBA data is organized from bottom to top of tile,
2568 * and may include zeroed areas if the tile extends off the image.
2569 */
2570
2571 int
2572 TIFFReadRGBATile(TIFF* tif, uint32 col, uint32 row, uint32 * raster)
2573
2574 {
2575 char emsg[1024] = "";
2576 TIFFRGBAImage img;
2577 int ok;
2578 uint32 tile_xsize, tile_ysize;
2579 uint32 read_xsize, read_ysize;
2580 uint32 i_row;
2581
2582 /*
2583 * Verify that our request is legal - on a tile file, and on a
2584 * tile boundary.
2585 */
2586
2587 if( !TIFFIsTiled( tif ) )
2588 {
2589 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
2590 "Can't use TIFFReadRGBATile() with stripped file.");
2591 return (0);
2592 }
2593
2594 TIFFGetFieldDefaulted(tif, TIFFTAG_TILEWIDTH, &tile_xsize);
2595 TIFFGetFieldDefaulted(tif, TIFFTAG_TILELENGTH, &tile_ysize);
2596 if( (col % tile_xsize) != 0 || (row % tile_ysize) != 0 )
2597 {
2598 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
2599 "Row/col passed to TIFFReadRGBATile() must be top"
2600 "left corner of a tile.");
2601 return (0);
2602 }
2603
2604 /*
2605 * Setup the RGBA reader.
2606 */
2607
2608 if (!TIFFRGBAImageOK(tif, emsg)
2609 || !TIFFRGBAImageBegin(&img, tif, 0, emsg)) {
2610 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
2611 return( 0 );
2612 }
2613
2614 /*
2615 * The TIFFRGBAImageGet() function doesn't allow us to get off the
2616 * edge of the image, even to fill an otherwise valid tile. So we
2617 * figure out how much we can read, and fix up the tile buffer to
2618 * a full tile configuration afterwards.
2619 */
2620
2621 if( row + tile_ysize > img.height )
2622 read_ysize = img.height - row;
2623 else
2624 read_ysize = tile_ysize;
2625
2626 if( col + tile_xsize > img.width )
2627 read_xsize = img.width - col;
2628 else
2629 read_xsize = tile_xsize;
2630
2631 /*
2632 * Read the chunk of imagery.
2633 */
2634
2635 img.row_offset = row;
2636 img.col_offset = col;
2637
2638 ok = TIFFRGBAImageGet(&img, raster, read_xsize, read_ysize );
2639
2640 TIFFRGBAImageEnd(&img);
2641
2642 /*
2643 * If our read was incomplete we will need to fix up the tile by
2644 * shifting the data around as if a full tile of data is being returned.
2645 *
2646 * This is all the more complicated because the image is organized in
2647 * bottom to top format.
2648 */
2649
2650 if( read_xsize == tile_xsize && read_ysize == tile_ysize )
2651 return( ok );
2652
2653 for( i_row = 0; i_row < read_ysize; i_row++ ) {
2654 memmove( raster + (tile_ysize - i_row - 1) * tile_xsize,
2655 raster + (read_ysize - i_row - 1) * read_xsize,
2656 read_xsize * sizeof(uint32) );
2657 _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize+read_xsize,
2658 0, sizeof(uint32) * (tile_xsize - read_xsize) );
2659 }
2660
2661 for( i_row = read_ysize; i_row < tile_ysize; i_row++ ) {
2662 _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize,
2663 0, sizeof(uint32) * tile_xsize );
2664 }
2665
2666 return (ok);
2667 }
2668
2669 /* vim: set ts=8 sts=8 sw=8 noet: */
2670 /*
2671 * Local Variables:
2672 * mode: c
2673 * c-basic-offset: 8
2674 * fill-column: 78
2675 * End:
2676 */
DECLARESepPutFunc
#define DECLARESepPutFunc(name)
Definition: tif_getimage.c:1398
tsize_t
int32 tsize_t
Definition: tiffio.h:67
GREY
#define GREY(x)
TIFFTileRowSize
tsize_t TIFFTileRowSize(TIFF *tif)
Definition: tif_tile.c:174
SKEW
#define SKEW(r, g, b, skew)
Definition: tif_getimage.c:1030
_TIFFRGBAImage::PALmap
uint32 ** PALmap
Definition: tiffio.h:215
DECLAREContigPutFunc
#define DECLAREContigPutFunc(name)
Definition: tif_getimage.c:1044
TIFFXYZToRGB
void TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z, uint32 *r, uint32 *g, uint32 *b)
Definition: tif_color.c:78
PACKW4
#define PACKW4(r, g, b, a)
Definition: tif_getimage.c:1041
W2B
#define W2B(v)
Definition: tif_getimage.c:1038
PHOTOMETRIC_YCBCR
#define PHOTOMETRIC_YCBCR
Definition: tiff.h:206
UNROLL8
#define UNROLL8(w, op1, op2)
Definition: tif_getimage.c:996
TIFFTAG_BITSPERSAMPLE
#define TIFFTAG_BITSPERSAMPLE
Definition: tiff.h:167
TIFFWarningExt
void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_warning.c:63
UNROLL2
#define UNROLL2(w, op1, op2)
Definition: tif_getimage.c:1018
TIFFTAG_ROWSPERSTRIP
#define TIFFTAG_ROWSPERSTRIP
Definition: tiff.h:236
TIFFDirectory::td_bitspersample
uint16 td_bitspersample
Definition: tif_dir.h:44
TIFFTAG_COLORMAP
#define TIFFTAG_COLORMAP
Definition: tiff.h:287
PHOTOMETRIC_SEPARATED
#define PHOTOMETRIC_SEPARATED
Definition: tiff.h:205
TIFFTAG_EXTRASAMPLES
#define TIFFTAG_EXTRASAMPLES
Definition: tiff.h:307
TIFFTAG_ORIENTATION
#define TIFFTAG_ORIENTATION
Definition: tiff.h:226
PHOTOMETRIC_CIELAB
#define PHOTOMETRIC_CIELAB
Definition: tiff.h:207
TIFFTAG_IMAGEWIDTH
#define TIFFTAG_IMAGEWIDTH
Definition: tiff.h:165
PHOTOMETRIC_LOGL
#define PHOTOMETRIC_LOGL
Definition: tiff.h:210
COMPRESSION_CCITTFAX3
#define COMPRESSION_CCITTFAX3
Definition: tiff.h:171
COMPRESSION_SGILOG24
#define COMPRESSION_SGILOG24
Definition: tiff.h:197
display_sRGB
TIFFDisplay display_sRGB
Definition: tif_getimage.c:53
TIFFCIELabToRGBInit
int TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, TIFFDisplay *display, float *refWhite)
Definition: tif_color.c:125
TIFFTAG_SGILOGDATAFMT
#define TIFFTAG_SGILOGDATAFMT
Definition: tiff.h:571
_TIFFRGBAImage::greencmap
uint16 * greencmap
Definition: tiffio.h:203
TIFFScanlineSize
tsize_t TIFFScanlineSize(TIFF *tif)
Definition: tif_strip.c:227
PHOTOMETRIC_LOGLUV
#define PHOTOMETRIC_LOGLUV
Definition: tiff.h:211
ORIENTATION_RIGHTTOP
#define ORIENTATION_RIGHTTOP
Definition: tiff.h:232
COMPRESSION_CCITTRLE
#define COMPRESSION_CCITTRLE
Definition: tiff.h:170
TIFFTAG_YCBCRSUBSAMPLING
#define TIFFTAG_YCBCRSUBSAMPLING
Definition: tiff.h:346
tiff::tif_clientdata
thandle_t tif_clientdata
Definition: tiffiop.h:185
TIFFRGBValue
unsigned char TIFFRGBValue
Definition: tiffio.h:129
TIFFTAG_REFERENCEBLACKWHITE
#define TIFFTAG_REFERENCEBLACKWHITE
Definition: tiff.h:350
tiffiop.h
NOP
#define NOP
Definition: tif_getimage.c:994
TIFFTAG_PLANARCONFIG
#define TIFFTAG_PLANARCONFIG
Definition: tiff.h:242
ORIENTATION_TOPLEFT
#define ORIENTATION_TOPLEFT
Definition: tiff.h:227
tileContigRoutine
void(* tileContigRoutine)(TIFFRGBAImage *, uint32 *, uint32, uint32, uint32, uint32, int32, int32, unsigned char *)
Definition: tiffio.h:182
tiff
Definition: tiffiop.h:102
TIFFTAG_JPEGCOLORMODE
#define TIFFTAG_JPEGCOLORMODE
Definition: tiff.h:534
TIFFReadRGBATile
int TIFFReadRGBATile(TIFF *tif, uint32 col, uint32 row, uint32 *raster)
Definition: tif_getimage.c:2572
TIFFTAG_YCBCRCOEFFICIENTS
#define TIFFTAG_YCBCRCOEFFICIENTS
Definition: tiff.h:345
TIFFDirectory::td_extrasamples
uint16 td_extrasamples
Definition: tif_dir.h:62
TIFFRGBAImageBegin
int TIFFRGBAImageBegin(TIFFRGBAImage *img, TIFF *tif, int stop, char emsg[1024])
Definition: tif_getimage.c:224
b
long b
Definition: jpegint.h:371
_TIFFmemcpy
void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
Definition: tif_acorn.c:485
PHOTOMETRIC_RGB
#define PHOTOMETRIC_RGB
Definition: tiff.h:202
JPEGCOLORMODE_RGB
#define JPEGCOLORMODE_RGB
Definition: tiff.h:536
INKSET_CMYK
#define INKSET_CMYK
Definition: tiff.h:301
ORIENTATION_RIGHTBOT
#define ORIENTATION_RIGHTBOT
Definition: tiff.h:233
FLIP_HORIZONTALLY
#define FLIP_HORIZONTALLY
Definition: tif_getimage.c:47
TIFFTAG_TILEWIDTH
#define TIFFTAG_TILEWIDTH
Definition: tiff.h:289
COMPRESSION_CCITTFAX4
#define COMPRESSION_CCITTFAX4
Definition: tiff.h:173
TIFFTAG_TILELENGTH
#define TIFFTAG_TILELENGTH
Definition: tiff.h:290
PHOTOMETRIC_MINISWHITE
#define PHOTOMETRIC_MINISWHITE
Definition: tiff.h:200
_TIFFRGBAImage::redcmap
uint16 * redcmap
Definition: tiffio.h:202
SKEW4
#define SKEW4(r, g, b, a, skew)
Definition: tif_getimage.c:1031
TIFFTAG_IMAGELENGTH
#define TIFFTAG_IMAGELENGTH
Definition: tiff.h:166
TIFFTAG_SAMPLESPERPIXEL
#define TIFFTAG_SAMPLESPERPIXEL
Definition: tiff.h:235
_TIFFRGBAImage::Map
TIFFRGBValue * Map
Definition: tiffio.h:213
PACK
#define PACK(r, g, b)
Definition: tif_getimage.c:1034
PHOTOMETRIC_PALETTE
#define PHOTOMETRIC_PALETTE
Definition: tiff.h:203
ORIENTATION_LEFTTOP
#define ORIENTATION_LEFTTOP
Definition: tiff.h:231
_TIFFRGBAImage
Definition: tiffio.h:190
TIFFRGBAImageEnd
void TIFFRGBAImageEnd(TIFFRGBAImage *img)
Definition: tif_getimage.c:193
PHOTOMETRIC_MINISBLACK
#define PHOTOMETRIC_MINISBLACK
Definition: tiff.h:201
COMPRESSION_CCITTRLEW
#define COMPRESSION_CCITTRLEW
Definition: tiff.h:179
uint16
unsigned short uint16
Definition: tiff.h:71
TIFFComputeStrip
tstrip_t TIFFComputeStrip(TIFF *tif, uint32 row, tsample_t sample)
Definition: tif_strip.c:68
TIFFDisplay
Definition: tiffio.h:131
_TIFFRGBAImage::cielab
TIFFCIELabToRGB * cielab
Definition: tiffio.h:217
_TIFFRGBAImage::samplesperpixel
uint16 samplesperpixel
Definition: tiffio.h:198
TIFFCIELabToXYZ
void TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32 l, int32 a, int32 b, float *X, float *Y, float *Z)
Definition: tif_color.c:46
TIFFRGBAImageGet
int TIFFRGBAImageGet(TIFFRGBAImage *img, uint32 *raster, uint32 w, uint32 h)
Definition: tif_getimage.c:450
_TIFFRGBAImage::put
union _TIFFRGBAImage::@12 put
UNROLL4
#define UNROLL4(w, op1, op2)
Definition: tif_getimage.c:1007
_TIFFRGBAImage::BWmap
uint32 ** BWmap
Definition: tiffio.h:214
TIFFGetFieldDefaulted
int TIFFGetFieldDefaulted(TIFF *tif, ttag_t tag,...)
Definition: tif_aux.c:272
TIFFDirectory
Definition: tif_dir.h:36
_TIFFRGBAImage::contig
tileContigRoutine contig
Definition: tiffio.h:210
TIFFDirectory::td_planarconfig
uint16 td_planarconfig
Definition: tif_dir.h:57
TIFFErrorExt
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:63
TIFFTAG_PHOTOMETRIC
#define TIFFTAG_PHOTOMETRIC
Definition: tiff.h:199
EXTRASAMPLE_UNASSALPHA
#define EXTRASAMPLE_UNASSALPHA
Definition: tiff.h:310
TIFFroundup
#define TIFFroundup(x, y)
Definition: tiffiop.h:243
_TIFFRGBAImage::alpha
int alpha
Definition: tiffio.h:194
TIFFYCbCrToRGBInit
int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
Definition: tif_color.c:212
TIFFTAG_WHITEPOINT
#define TIFFTAG_WHITEPOINT
Definition: tiff.h:285
ORIENTATION_TOPRIGHT
#define ORIENTATION_TOPRIGHT
Definition: tiff.h:228
TIFFYCbCrToRGB
Definition: tiffio.h:147
COMPRESSION_SGILOG
#define COMPRESSION_SGILOG
Definition: tiff.h:196
TIFFTAG_COMPRESSION
#define TIFFTAG_COMPRESSION
Definition: tiff.h:168
COMPRESSION_JPEG
#define COMPRESSION_JPEG
Definition: tiff.h:177
TIFFTAG_INKSET
#define TIFFTAG_INKSET
Definition: tiff.h:300
PLANARCONFIG_SEPARATE
#define PLANARCONFIG_SEPARATE
Definition: tiff.h:244
TIFFNewScanlineSize
tsize_t TIFFNewScanlineSize(TIFF *tif)
Definition: tif_strip.c:301
_TIFFmemset
void _TIFFmemset(tdata_t p, int v, tsize_t c)
Definition: tif_acorn.c:479
_TIFFRGBAImage::height
uint32 height
Definition: tiffio.h:196
_TIFFRGBAImage::bitspersample
uint16 bitspersample
Definition: tiffio.h:197
_TIFFRGBAImage::col_offset
int col_offset
Definition: tiffio.h:220
_TIFFRGBAImage::get
int(* get)(TIFFRGBAImage *, uint32 *, uint32, uint32)
Definition: tiffio.h:206
SGILOGDATAFMT_8BIT
#define SGILOGDATAFMT_8BIT
Definition: tiff.h:575
_TIFFRGBAImage::row_offset
int row_offset
Definition: tiffio.h:219
TIFFRGBAImageOK
int TIFFRGBAImageOK(TIFF *tif, char emsg[1024])
Definition: tif_getimage.c:72
TIFFYCbCrtoRGB
void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr, uint32 *r, uint32 *g, uint32 *b)
Definition: tif_color.c:183
TIFFDirectory::td_samplesperpixel
uint16 td_samplesperpixel
Definition: tif_dir.h:51
TIFFReadRGBAImage
int TIFFReadRGBAImage(TIFF *tif, uint32 rwidth, uint32 rheight, uint32 *raster, int stop)
Definition: tif_getimage.c:495
PACKW
#define PACKW(r, g, b)
Definition: tif_getimage.c:1039
TIFFReadRGBAImageOriented
int TIFFReadRGBAImageOriented(TIFF *tif, uint32 rwidth, uint32 rheight, uint32 *raster, int orientation, int stop)
Definition: tif_getimage.c:469
tiff::tif_decodestatus
int tif_decodestatus
Definition: tiffiop.h:152
_TIFFRGBAImage::orientation
uint16 orientation
Definition: tiffio.h:199
compress
int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
Definition: compress.c:62
TIFFTileSize
tsize_t TIFFTileSize(TIFF *tif)
Definition: tif_tile.c:241
_TIFFRGBAImage::separate
tileSeparateRoutine separate
Definition: tiffio.h:211
_TIFFRGBAImage::stoponerr
int stoponerr
Definition: tiffio.h:192
tiff::tif_dir
TIFFDirectory tif_dir
Definition: tiffiop.h:133
EXTRASAMPLE_UNSPECIFIED
#define EXTRASAMPLE_UNSPECIFIED
Definition: tiff.h:308
YCbCrtoRGB
#define YCbCrtoRGB(dst, Y)
Definition: tif_getimage.c:1542
TIFFReadEncodedStrip
tsize_t TIFFReadEncodedStrip(TIFF *tif, tstrip_t strip, tdata_t buf, tsize_t size)
Definition: tif_read.c:124
TIFFFileName
const char * TIFFFileName(TIFF *tif)
Definition: tif_open.c:458
TIFFSetField
int TIFFSetField(TIFF *tif, ttag_t tag,...)
Definition: tif_dir.c:649
TIFFDirectory::td_compression
uint16 td_compression
Definition: tif_dir.h:46
_TIFFmalloc
void * _TIFFmalloc(tsize_t s)
Definition: tif_acorn.c:461
_TIFFRGBAImage::req_orientation
uint16 req_orientation
Definition: tiffio.h:200
TIFFStripSize
tsize_t TIFFStripSize(TIFF *tif)
Definition: tif_strip.c:182
tileSeparateRoutine
void(* tileSeparateRoutine)(TIFFRGBAImage *, uint32 *, uint32, uint32, uint32, uint32, int32, int32, unsigned char *, unsigned char *, unsigned char *, unsigned char *)
Definition: tiffio.h:185
TIFFIsTiled
int TIFFIsTiled(TIFF *tif)
Definition: tif_open.c:539
PACK4
#define PACK4(r, g, b, a)
Definition: tif_getimage.c:1036
TIFFGetField
int TIFFGetField(TIFF *tif, ttag_t tag,...)
Definition: tif_dir.c:951
CVT
#define CVT(x)
_TIFFRGBAImage::tif
TIFF * tif
Definition: tiffio.h:191
_TIFFfree
void _TIFFfree(tdata_t p)
Definition: tif_acorn.c:467
_TIFFRGBAImage::ycbcr
TIFFYCbCrToRGB * ycbcr
Definition: tiffio.h:216
_TIFFRGBAImage::photometric
uint16 photometric
Definition: tiffio.h:201
TIFFCIELabToRGB
Definition: tiffio.h:156
_TIFFRGBAImage::width
uint32 width
Definition: tiffio.h:195
FLIP_VERTICALLY
#define FLIP_VERTICALLY
Definition: tif_getimage.c:46
_TIFFRGBAImage::bluecmap
uint16 * bluecmap
Definition: tiffio.h:204
EXTRASAMPLE_ASSOCALPHA
#define EXTRASAMPLE_ASSOCALPHA
Definition: tiff.h:309
_TIFFRGBAImage::any
void(* any)(TIFFRGBAImage *)
Definition: tiffio.h:209
ORIENTATION_LEFTBOT
#define ORIENTATION_LEFTBOT
Definition: tiff.h:234
ORIENTATION_BOTLEFT
#define ORIENTATION_BOTLEFT
Definition: tiff.h:230
CMAP
#define CMAP(x)
ORIENTATION_BOTRIGHT
#define ORIENTATION_BOTRIGHT
Definition: tiff.h:229
_TIFFRGBAImage::isContig
int isContig
Definition: tiffio.h:193
TIFFReadTile
tsize_t TIFFReadTile(TIFF *tif, tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
Definition: tif_read.c:370
TIFFReadRGBAStrip
int TIFFReadRGBAStrip(TIFF *tif, uint32 row, uint32 *raster)
Definition: tif_getimage.c:2521
PLANARCONFIG_CONTIG
#define PLANARCONFIG_CONTIG
Definition: tiff.h:243