]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/libtiff/tif_getimage.c
projects / wxWidgets.git / blob
? search:


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