]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/tif_getimage.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Semi-Blind fixes for trying to handle different versions of MySQL and MySQL windows...
[wxWidgets.git] / src / tiff / tif_getimage.c
1 /* $Header$ */
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 <assert.h>
34 #include <stdio.h>
35
36 static int LINKAGEMODE gtTileContig(TIFFRGBAImage*, uint32*, uint32, uint32);
37 static int LINKAGEMODE gtTileSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
38 static int LINKAGEMODE gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32);
39 static int LINKAGEMODE gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
40 static int LINKAGEMODE pickTileContigCase(TIFFRGBAImage*);
41 static int LINKAGEMODE pickTileSeparateCase(TIFFRGBAImage*);
42
43 static const char photoTag[] = "PhotometricInterpretation";
44
45 /*
46 * Check the image to see if TIFFReadRGBAImage can deal with it.
47 * 1/0 is returned according to whether or not the image can
48 * be handled. If 0 is returned, emsg contains the reason
49 * why it is being rejected.
50 */
51 int
52 TIFFRGBAImageOK(TIFF* tif, char emsg[1024])
53 {
54 TIFFDirectory* td = &tif->tif_dir;
55 uint16 photometric;
56 int colorchannels;
57
58 switch (td->td_bitspersample) {
59 case 1: case 2: case 4:
60 case 8: case 16:
61 break;
62 default:
63 sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
64 td->td_bitspersample);
65 return (0);
66 }
67 colorchannels = td->td_samplesperpixel - td->td_extrasamples;
68 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)) {
69 switch (colorchannels) {
70 case 1:
71 photometric = PHOTOMETRIC_MINISBLACK;
72 break;
73 case 3:
74 photometric = PHOTOMETRIC_RGB;
75 break;
76 default:
77 sprintf(emsg, "Missing needed %s tag", photoTag);
78 return (0);
79 }
80 }
81 switch (photometric) {
82 case PHOTOMETRIC_MINISWHITE:
83 case PHOTOMETRIC_MINISBLACK:
84 case PHOTOMETRIC_PALETTE:
85 if (td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_samplesperpixel != 1) {
86 sprintf(emsg,
87 "Sorry, can not handle contiguous data with %s=%d, and %s=%d",
88 photoTag, photometric,
89 "Samples/pixel", td->td_samplesperpixel);
90 return (0);
91 }
92 break;
93 case PHOTOMETRIC_YCBCR:
94 if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
95 sprintf(emsg, "Sorry, can not handle YCbCr images with %s=%d",
96 "Planarconfiguration", td->td_planarconfig);
97 return (0);
98 }
99 break;
100 case PHOTOMETRIC_RGB:
101 if (colorchannels < 3) {
102 sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
103 "Color channels", colorchannels);
104 return (0);
105 }
106 break;
107 #ifdef CMYK_SUPPORT
108 case PHOTOMETRIC_SEPARATED:
109 if (td->td_inkset != INKSET_CMYK) {
110 sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
111 "InkSet", td->td_inkset);
112 return (0);
113 }
114 if (td->td_samplesperpixel != 4) {
115 sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
116 "Samples/pixel", td->td_samplesperpixel);
117 return (0);
118 }
119 break;
120 #endif
121 case PHOTOMETRIC_LOGL:
122 if (td->td_compression != COMPRESSION_SGILOG) {
123 sprintf(emsg, "Sorry, LogL data must have %s=%d",
124 "Compression", COMPRESSION_SGILOG);
125 return (0);
126 }
127 break;
128 case PHOTOMETRIC_LOGLUV:
129 if (td->td_compression != COMPRESSION_SGILOG &&
130 td->td_compression != COMPRESSION_SGILOG24) {
131 sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
132 "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
133 return (0);
134 }
135 if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
136 sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
137 "Planarconfiguration", td->td_planarconfig);
138 return (0);
139 }
140 break;
141 default:
142 sprintf(emsg, "Sorry, can not handle image with %s=%d",
143 photoTag, photometric);
144 return (0);
145 }
146 return (1);
147 }
148
149 void
150 TIFFRGBAImageEnd(TIFFRGBAImage* img)
151 {
152 if (img->Map)
153 _TIFFfree(img->Map), img->Map = NULL;
154 if (img->BWmap)
155 _TIFFfree(img->BWmap), img->BWmap = NULL;
156 if (img->PALmap)
157 _TIFFfree(img->PALmap), img->PALmap = NULL;
158 if (img->ycbcr)
159 _TIFFfree(img->ycbcr), img->ycbcr = NULL;
160
161 if( img->redcmap ) {
162 _TIFFfree( img->redcmap );
163 _TIFFfree( img->greencmap );
164 _TIFFfree( img->bluecmap );
165 }
166 }
167
168 static int
169 isCCITTCompression(TIFF* tif)
170 {
171 uint16 compress;
172 TIFFGetField(tif, TIFFTAG_COMPRESSION, &compress);
173 return (compress == COMPRESSION_CCITTFAX3 ||
174 compress == COMPRESSION_CCITTFAX4 ||
175 compress == COMPRESSION_CCITTRLE ||
176 compress == COMPRESSION_CCITTRLEW);
177 }
178
179 int
180 TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
181 {
182 uint16* sampleinfo;
183 uint16 extrasamples;
184 uint16 planarconfig;
185 uint16 compress;
186 int colorchannels;
187 uint16 *red_orig, *green_orig, *blue_orig;
188 int n_color;
189
190 /* Initialize to normal values */
191 img->row_offset = 0;
192 img->col_offset = 0;
193 img->redcmap = NULL;
194 img->greencmap = NULL;
195 img->bluecmap = NULL;
196
197 img->tif = tif;
198 img->stoponerr = stop;
199 TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);
200 switch (img->bitspersample) {
201 case 1: case 2: case 4:
202 case 8: case 16:
203 break;
204 default:
205 sprintf(emsg, "Sorry, can not image with %d-bit samples",
206 img->bitspersample);
207 return (0);
208 }
209 img->alpha = 0;
210 TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
211 TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
212 &extrasamples, &sampleinfo);
213 if (extrasamples == 1)
214 switch (sampleinfo[0]) {
215 case EXTRASAMPLE_ASSOCALPHA: /* data is pre-multiplied */
216 case EXTRASAMPLE_UNASSALPHA: /* data is not pre-multiplied */
217 img->alpha = sampleinfo[0];
218 break;
219 }
220 colorchannels = img->samplesperpixel - extrasamples;
221 TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress);
222 TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);
223 if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) {
224 switch (colorchannels) {
225 case 1:
226 if (isCCITTCompression(tif))
227 img->photometric = PHOTOMETRIC_MINISWHITE;
228 else
229 img->photometric = PHOTOMETRIC_MINISBLACK;
230 break;
231 case 3:
232 img->photometric = PHOTOMETRIC_RGB;
233 break;
234 default:
235 sprintf(emsg, "Missing needed %s tag", photoTag);
236 return (0);
237 }
238 }
239 switch (img->photometric) {
240 case PHOTOMETRIC_PALETTE:
241 if (!TIFFGetField(tif, TIFFTAG_COLORMAP,
242 &red_orig, &green_orig, &blue_orig)) {
243 TIFFError(TIFFFileName(tif), "Missing required \"Colormap\" tag");
244 return (0);
245 }
246
247 /* copy the colormaps so we can modify them */
248 n_color = (1L << img->bitspersample);
249 img->redcmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
250 img->greencmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
251 img->bluecmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
252 if( !img->redcmap || !img->greencmap || !img->bluecmap ) {
253 TIFFError(TIFFFileName(tif), "Out of memory for colormap copy");
254 return (0);
255 }
256
257 memcpy( img->redcmap, red_orig, n_color * 2 );
258 memcpy( img->greencmap, green_orig, n_color * 2 );
259 memcpy( img->bluecmap, blue_orig, n_color * 2 );
260
261 /* fall thru... */
262 case PHOTOMETRIC_MINISWHITE:
263 case PHOTOMETRIC_MINISBLACK:
264 if (planarconfig == PLANARCONFIG_CONTIG && img->samplesperpixel != 1) {
265 sprintf(emsg,
266 "Sorry, can not handle contiguous data with %s=%d, and %s=%d",
267 photoTag, img->photometric,
268 "Samples/pixel", img->samplesperpixel);
269 return (0);
270 }
271 break;
272 case PHOTOMETRIC_YCBCR:
273 if (planarconfig != PLANARCONFIG_CONTIG) {
274 sprintf(emsg, "Sorry, can not handle YCbCr images with %s=%d",
275 "Planarconfiguration", planarconfig);
276 return (0);
277 }
278 /* It would probably be nice to have a reality check here. */
279 if (compress == COMPRESSION_JPEG && planarconfig == PLANARCONFIG_CONTIG) {
280 /* can rely on libjpeg to convert to RGB */
281 /* XXX should restore current state on exit */
282 TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
283 img->photometric = PHOTOMETRIC_RGB;
284 }
285 break;
286 case PHOTOMETRIC_RGB:
287 if (colorchannels < 3) {
288 sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
289 "Color channels", colorchannels);
290 return (0);
291 }
292 break;
293 case PHOTOMETRIC_SEPARATED: {
294 uint16 inkset;
295 TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
296 if (inkset != INKSET_CMYK) {
297 sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
298 "InkSet", inkset);
299 return (0);
300 }
301 if (img->samplesperpixel != 4) {
302 sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
303 "Samples/pixel", img->samplesperpixel);
304 return (0);
305 }
306 break;
307 }
308 case PHOTOMETRIC_LOGL:
309 if (compress != COMPRESSION_SGILOG) {
310 sprintf(emsg, "Sorry, LogL data must have %s=%d",
311 "Compression", COMPRESSION_SGILOG);
312 return (0);
313 }
314 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
315 img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */
316 img->bitspersample = 8;
317 break;
318 case PHOTOMETRIC_LOGLUV:
319 if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) {
320 sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
321 "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
322 return (0);
323 }
324 if (planarconfig != PLANARCONFIG_CONTIG) {
325 sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
326 "Planarconfiguration", planarconfig);
327 return (0);
328 }
329 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
330 img->photometric = PHOTOMETRIC_RGB; /* little white lie */
331 img->bitspersample = 8;
332 break;
333 default:
334 sprintf(emsg, "Sorry, can not handle image with %s=%d",
335 photoTag, img->photometric);
336 return (0);
337 }
338 img->Map = NULL;
339 img->BWmap = NULL;
340 img->PALmap = NULL;
341 img->ycbcr = NULL;
342 TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width);
343 TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height);
344 TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation);
345 img->isContig =
346 !(planarconfig == PLANARCONFIG_SEPARATE && colorchannels > 1);
347 if (img->isContig) {
348 img->get = TIFFIsTiled(tif) ? gtTileContig : gtStripContig;
349 (void) pickTileContigCase(img);
350 } else {
351 img->get = TIFFIsTiled(tif) ? gtTileSeparate : gtStripSeparate;
352 (void) pickTileSeparateCase(img);
353 }
354 return (1);
355 }
356
357 int
358 TIFFRGBAImageGet(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
359 {
360 if (img->get == NULL) {
361 TIFFError(TIFFFileName(img->tif), "No \"get\" routine setup");
362 return (0);
363 }
364 if (img->put.any == NULL) {
365 TIFFError(TIFFFileName(img->tif),
366 "No \"put\" routine setupl; probably can not handle image format");
367 return (0);
368 }
369 return (*img->get)(img, raster, w, h);
370 }
371
372 /*
373 * Read the specified image into an ABGR-format raster.
374 */
375 int
376 TIFFReadRGBAImage(TIFF* tif,
377 uint32 rwidth, uint32 rheight, uint32* raster, int stop)
378 {
379 char emsg[1024];
380 TIFFRGBAImage img;
381 int ok;
382
383 if (TIFFRGBAImageBegin(&img, tif, stop, emsg)) {
384 /* XXX verify rwidth and rheight against width and height */
385 ok = TIFFRGBAImageGet(&img, raster+(rheight-img.height)*rwidth,
386 rwidth, img.height);
387 TIFFRGBAImageEnd(&img);
388 } else {
389 TIFFError(TIFFFileName(tif), emsg);
390 ok = 0;
391 }
392 return (ok);
393 }
394
395 static uint32
396 setorientation(TIFFRGBAImage* img, uint32 h)
397 {
398 TIFF* tif = img->tif;
399 uint32 y;
400
401 switch (img->orientation) {
402 case ORIENTATION_BOTRIGHT:
403 case ORIENTATION_RIGHTBOT: /* XXX */
404 case ORIENTATION_LEFTBOT: /* XXX */
405 TIFFWarning(TIFFFileName(tif), "using bottom-left orientation");
406 img->orientation = ORIENTATION_BOTLEFT;
407 /* fall thru... */
408 case ORIENTATION_BOTLEFT:
409 y = 0;
410 break;
411 case ORIENTATION_TOPRIGHT:
412 case ORIENTATION_RIGHTTOP: /* XXX */
413 case ORIENTATION_LEFTTOP: /* XXX */
414 default:
415 TIFFWarning(TIFFFileName(tif), "using top-left orientation");
416 img->orientation = ORIENTATION_TOPLEFT;
417 /* fall thru... */
418 case ORIENTATION_TOPLEFT:
419 y = h-1;
420 break;
421 }
422 return (y);
423 }
424
425 /*
426 * Get an tile-organized image that has
427 * PlanarConfiguration contiguous if SamplesPerPixel > 1
428 * or
429 * SamplesPerPixel == 1
430 */
431 static int
432 gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
433 {
434 TIFF* tif = img->tif;
435 tileContigRoutine put = img->put.contig;
436 uint16 orientation;
437 uint32 col, row, y;
438 uint32 tw, th;
439 u_char* buf;
440 int32 fromskew, toskew;
441 uint32 nrow;
442
443 buf = (u_char*) _TIFFmalloc(TIFFTileSize(tif));
444 if (buf == 0) {
445 TIFFError(TIFFFileName(tif), "No space for tile buffer");
446 return (0);
447 }
448 TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
449 TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
450 y = setorientation(img, h);
451 orientation = img->orientation;
452 toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? tw+w : tw-w);
453 for (row = 0; row < h; row += th) {
454 nrow = (row + th > h ? h - row : th);
455 for (col = 0; col < w; col += tw) {
456 if (TIFFReadTile(tif, buf, col+img->col_offset,
457 row+img->row_offset, 0, 0) < 0 && img->stoponerr)
458 break;
459 if (col + tw > w) {
460 /*
461 * Tile is clipped horizontally. Calculate
462 * visible portion and skewing factors.
463 */
464 uint32 npix = w - col;
465 fromskew = tw - npix;
466 (*put)(img, raster+y*w+col, col, y,
467 npix, nrow, fromskew, toskew + fromskew, buf);
468 } else {
469 (*put)(img, raster+y*w+col, col, y, tw, nrow, 0, toskew, buf);
470 }
471 }
472 y += (orientation == ORIENTATION_TOPLEFT ?
473 -(int32) nrow : (int32) nrow);
474 }
475 _TIFFfree(buf);
476 return (1);
477 }
478
479 /*
480 * Get an tile-organized image that has
481 * SamplesPerPixel > 1
482 * PlanarConfiguration separated
483 * We assume that all such images are RGB.
484 */
485 static int
486 gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
487 {
488 TIFF* tif = img->tif;
489 tileSeparateRoutine put = img->put.separate;
490 uint16 orientation;
491 uint32 col, row, y;
492 uint32 tw, th;
493 u_char* buf;
494 u_char* r;
495 u_char* g;
496 u_char* b;
497 u_char* a;
498 tsize_t tilesize;
499 int32 fromskew, toskew;
500 int alpha = img->alpha;
501 uint32 nrow;
502
503 tilesize = TIFFTileSize(tif);
504 buf = (u_char*) _TIFFmalloc(4*tilesize);
505 if (buf == 0) {
506 TIFFError(TIFFFileName(tif), "No space for tile buffer");
507 return (0);
508 }
509 r = buf;
510 g = r + tilesize;
511 b = g + tilesize;
512 a = b + tilesize;
513 if (!alpha)
514 memset(a, 0xff, tilesize);
515 TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
516 TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
517 y = setorientation(img, h);
518 orientation = img->orientation;
519 toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? tw+w : tw-w);
520 for (row = 0; row < h; row += th) {
521 nrow = (row + th > h ? h - row : th);
522 for (col = 0; col < w; col += tw) {
523 if (TIFFReadTile(tif, r, col+img->col_offset,
524 row+img->row_offset,0,0) < 0 && img->stoponerr)
525 break;
526 if (TIFFReadTile(tif, g, col+img->col_offset,
527 row+img->row_offset,0,1) < 0 && img->stoponerr)
528 break;
529 if (TIFFReadTile(tif, b, col+img->col_offset,
530 row+img->row_offset,0,2) < 0 && img->stoponerr)
531 break;
532 if (alpha && TIFFReadTile(tif,a,col+img->col_offset,
533 row+img->row_offset,0,3) < 0 && img->stoponerr)
534 break;
535 if (col + tw > w) {
536 /*
537 * Tile is clipped horizontally. Calculate
538 * visible portion and skewing factors.
539 */
540 uint32 npix = w - col;
541 fromskew = tw - npix;
542 (*put)(img, raster+y*w+col, col, y,
543 npix, nrow, fromskew, toskew + fromskew, r, g, b, a);
544 } else {
545 (*put)(img, raster+y*w+col, col, y,
546 tw, nrow, 0, toskew, r, g, b, a);
547 }
548 }
549 y += (orientation == ORIENTATION_TOPLEFT ?
550 -(int32) nrow : (int32) nrow);
551 }
552 _TIFFfree(buf);
553 return (1);
554 }
555
556 /*
557 * Get a strip-organized image that has
558 * PlanarConfiguration contiguous if SamplesPerPixel > 1
559 * or
560 * SamplesPerPixel == 1
561 */
562 static int
563 gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
564 {
565 TIFF* tif = img->tif;
566 tileContigRoutine put = img->put.contig;
567 uint16 orientation;
568 uint32 row, y, nrow;
569 u_char* buf;
570 uint32 rowsperstrip;
571 uint32 imagewidth = img->width;
572 tsize_t scanline;
573 int32 fromskew, toskew;
574
575 buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif));
576 if (buf == 0) {
577 TIFFError(TIFFFileName(tif), "No space for strip buffer");
578 return (0);
579 }
580 y = setorientation(img, h);
581 orientation = img->orientation;
582 toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? w+w : w-w);
583 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
584 scanline = TIFFScanlineSize(tif);
585 fromskew = (w < imagewidth ? imagewidth - w : 0);
586 for (row = 0; row < h; row += rowsperstrip) {
587 nrow = (row + rowsperstrip > h ? h - row : rowsperstrip);
588 if (TIFFReadEncodedStrip(tif,
589 TIFFComputeStrip(tif,row+img->row_offset, 0),
590 buf, nrow*scanline) < 0
591 && img->stoponerr)
592 break;
593 (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, buf);
594 y += (orientation == ORIENTATION_TOPLEFT ?
595 -(int32) nrow : (int32) nrow);
596 }
597 _TIFFfree(buf);
598 return (1);
599 }
600
601 /*
602 * Get a strip-organized image with
603 * SamplesPerPixel > 1
604 * PlanarConfiguration separated
605 * We assume that all such images are RGB.
606 */
607 static int
608 gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
609 {
610 TIFF* tif = img->tif;
611 tileSeparateRoutine put = img->put.separate;
612 uint16 orientation;
613 u_char *buf;
614 u_char *r, *g, *b, *a;
615 uint32 row, y, nrow;
616 tsize_t scanline;
617 uint32 rowsperstrip, offset_row;
618 uint32 imagewidth = img->width;
619 tsize_t stripsize;
620 int32 fromskew, toskew;
621 int alpha = img->alpha;
622
623 stripsize = TIFFStripSize(tif);
624 r = buf = (u_char *)_TIFFmalloc(4*stripsize);
625 if (buf == 0) {
626 TIFFError(TIFFFileName(tif), "No space for tile buffer");
627 return (0);
628 }
629 g = r + stripsize;
630 b = g + stripsize;
631 a = b + stripsize;
632 if (!alpha)
633 memset(a, 0xff, stripsize);
634 y = setorientation(img, h);
635 orientation = img->orientation;
636 toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? w+w : w-w);
637 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
638 scanline = TIFFScanlineSize(tif);
639 fromskew = (w < imagewidth ? imagewidth - w : 0);
640 for (row = 0; row < h; row += rowsperstrip) {
641 nrow = (row + rowsperstrip > h ? h - row : rowsperstrip);
642 offset_row = row + img->row_offset;
643 if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),
644 r, nrow*scanline) < 0 && img->stoponerr)
645 break;
646 if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1),
647 g, nrow*scanline) < 0 && img->stoponerr)
648 break;
649 if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2),
650 b, nrow*scanline) < 0 && img->stoponerr)
651 break;
652 if (alpha &&
653 (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 3),
654 a, nrow*scanline) < 0 && img->stoponerr))
655 break;
656 (*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, r, g, b, a);
657 y += (orientation == ORIENTATION_TOPLEFT ?
658 -(int32) nrow : (int32) nrow);
659 }
660 _TIFFfree(buf);
661 return (1);
662 }
663
664 /*
665 * The following routines move decoded data returned
666 * from the TIFF library into rasters filled with packed
667 * ABGR pixels (i.e. suitable for passing to lrecwrite.)
668 *
669 * The routines have been created according to the most
670 * important cases and optimized. pickTileContigCase and
671 * pickTileSeparateCase analyze the parameters and select
672 * the appropriate "put" routine to use.
673 */
674 #define REPEAT8(op) REPEAT4(op); REPEAT4(op)
675 #define REPEAT4(op) REPEAT2(op); REPEAT2(op)
676 #define REPEAT2(op) op; op
677 #define CASE8(x,op) \
678 switch (x) { \
679 case 7: op; case 6: op; case 5: op; \
680 case 4: op; case 3: op; case 2: op; \
681 case 1: op; \
682 }
683 #define CASE4(x,op) switch (x) { case 3: op; case 2: op; case 1: op; }
684 #define NOP
685
686 #define UNROLL8(w, op1, op2) { \
687 uint32 _x; \
688 for (_x = w; _x >= 8; _x -= 8) { \
689 op1; \
690 REPEAT8(op2); \
691 } \
692 if (_x > 0) { \
693 op1; \
694 CASE8(_x,op2); \
695 } \
696 }
697 #define UNROLL4(w, op1, op2) { \
698 uint32 _x; \
699 for (_x = w; _x >= 4; _x -= 4) { \
700 op1; \
701 REPEAT4(op2); \
702 } \
703 if (_x > 0) { \
704 op1; \
705 CASE4(_x,op2); \
706 } \
707 }
708 #define UNROLL2(w, op1, op2) { \
709 uint32 _x; \
710 for (_x = w; _x >= 2; _x -= 2) { \
711 op1; \
712 REPEAT2(op2); \
713 } \
714 if (_x) { \
715 op1; \
716 op2; \
717 } \
718 }
719
720 #define SKEW(r,g,b,skew) { r += skew; g += skew; b += skew; }
721 #define SKEW4(r,g,b,a,skew) { r += skew; g += skew; b += skew; a+= skew; }
722
723 #define A1 ((uint32)(0xffL<<24))
724 #define PACK(r,g,b) \
725 ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|A1)
726 #define PACK4(r,g,b,a) \
727 ((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|((uint32)(a)<<24))
728 #define W2B(v) (((v)>>8)&0xff)
729 #define PACKW(r,g,b) \
730 ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|A1)
731 #define PACKW4(r,g,b,a) \
732 ((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|((uint32)W2B(a)<<24))
733
734 #define DECLAREContigPutFunc(name) \
735 static void LINKAGEMODE name(\
736 TIFFRGBAImage* img, \
737 uint32* cp, \
738 uint32 x, uint32 y, \
739 uint32 w, uint32 h, \
740 int32 fromskew, int32 toskew, \
741 u_char* pp \
742 )
743
744 /*
745 * 8-bit palette => colormap/RGB
746 */
747 DECLAREContigPutFunc(put8bitcmaptile)
748 {
749 uint32** PALmap = img->PALmap;
750
751 (void) x; (void) y;
752 while (h-- > 0) {
753 UNROLL8(w, NOP, *cp++ = PALmap[*pp++][0]);
754 cp += toskew;
755 pp += fromskew;
756 }
757 }
758
759 /*
760 * 4-bit palette => colormap/RGB
761 */
762 DECLAREContigPutFunc(put4bitcmaptile)
763 {
764 uint32** PALmap = img->PALmap;
765
766 (void) x; (void) y;
767 fromskew /= 2;
768 while (h-- > 0) {
769 uint32* bw;
770 UNROLL2(w, bw = PALmap[*pp++], *cp++ = *bw++);
771 cp += toskew;
772 pp += fromskew;
773 }
774 }
775
776 /*
777 * 2-bit palette => colormap/RGB
778 */
779 DECLAREContigPutFunc(put2bitcmaptile)
780 {
781 uint32** PALmap = img->PALmap;
782
783 (void) x; (void) y;
784 fromskew /= 4;
785 while (h-- > 0) {
786 uint32* bw;
787 UNROLL4(w, bw = PALmap[*pp++], *cp++ = *bw++);
788 cp += toskew;
789 pp += fromskew;
790 }
791 }
792
793 /*
794 * 1-bit palette => colormap/RGB
795 */
796 DECLAREContigPutFunc(put1bitcmaptile)
797 {
798 uint32** PALmap = img->PALmap;
799
800 (void) x; (void) y;
801 fromskew /= 8;
802 while (h-- > 0) {
803 uint32* bw;
804 UNROLL8(w, bw = PALmap[*pp++], *cp++ = *bw++);
805 cp += toskew;
806 pp += fromskew;
807 }
808 }
809
810 /*
811 * 8-bit greyscale => colormap/RGB
812 */
813 DECLAREContigPutFunc(putgreytile)
814 {
815 uint32** BWmap = img->BWmap;
816
817 (void) y;
818 while (h-- > 0) {
819 for (x = w; x-- > 0;)
820 *cp++ = BWmap[*pp++][0];
821 cp += toskew;
822 pp += fromskew;
823 }
824 }
825
826 /*
827 * 1-bit bilevel => colormap/RGB
828 */
829 DECLAREContigPutFunc(put1bitbwtile)
830 {
831 uint32** BWmap = img->BWmap;
832
833 (void) x; (void) y;
834 fromskew /= 8;
835 while (h-- > 0) {
836 uint32* bw;
837 UNROLL8(w, bw = BWmap[*pp++], *cp++ = *bw++);
838 cp += toskew;
839 pp += fromskew;
840 }
841 }
842
843 /*
844 * 2-bit greyscale => colormap/RGB
845 */
846 DECLAREContigPutFunc(put2bitbwtile)
847 {
848 uint32** BWmap = img->BWmap;
849
850 (void) x; (void) y;
851 fromskew /= 4;
852 while (h-- > 0) {
853 uint32* bw;
854 UNROLL4(w, bw = BWmap[*pp++], *cp++ = *bw++);
855 cp += toskew;
856 pp += fromskew;
857 }
858 }
859
860 /*
861 * 4-bit greyscale => colormap/RGB
862 */
863 DECLAREContigPutFunc(put4bitbwtile)
864 {
865 uint32** BWmap = img->BWmap;
866
867 (void) x; (void) y;
868 fromskew /= 2;
869 while (h-- > 0) {
870 uint32* bw;
871 UNROLL2(w, bw = BWmap[*pp++], *cp++ = *bw++);
872 cp += toskew;
873 pp += fromskew;
874 }
875 }
876
877 /*
878 * 8-bit packed samples, no Map => RGB
879 */
880 DECLAREContigPutFunc(putRGBcontig8bittile)
881 {
882 int samplesperpixel = img->samplesperpixel;
883
884 (void) x; (void) y;
885 fromskew *= samplesperpixel;
886 while (h-- > 0) {
887 UNROLL8(w, NOP,
888 *cp++ = PACK(pp[0], pp[1], pp[2]);
889 pp += samplesperpixel);
890 cp += toskew;
891 pp += fromskew;
892 }
893 }
894
895 /*
896 * 8-bit packed samples, w/ Map => RGB
897 */
898 DECLAREContigPutFunc(putRGBcontig8bitMaptile)
899 {
900 TIFFRGBValue* Map = img->Map;
901 int samplesperpixel = img->samplesperpixel;
902
903 (void) y;
904 fromskew *= samplesperpixel;
905 while (h-- > 0) {
906 for (x = w; x-- > 0;) {
907 *cp++ = PACK(Map[pp[0]], Map[pp[1]], Map[pp[2]]);
908 pp += samplesperpixel;
909 }
910 pp += fromskew;
911 cp += toskew;
912 }
913 }
914
915 /*
916 * 8-bit packed samples => RGBA w/ associated alpha
917 * (known to have Map == NULL)
918 */
919 DECLAREContigPutFunc(putRGBAAcontig8bittile)
920 {
921 int samplesperpixel = img->samplesperpixel;
922
923 (void) x; (void) y;
924 fromskew *= samplesperpixel;
925 while (h-- > 0) {
926 UNROLL8(w, NOP,
927 *cp++ = PACK4(pp[0], pp[1], pp[2], pp[3]);
928 pp += samplesperpixel);
929 cp += toskew;
930 pp += fromskew;
931 }
932 }
933
934 /*
935 * 8-bit packed samples => RGBA w/ unassociated alpha
936 * (known to have Map == NULL)
937 */
938 DECLAREContigPutFunc(putRGBUAcontig8bittile)
939 {
940 int samplesperpixel = img->samplesperpixel;
941
942 (void) y;
943 fromskew *= samplesperpixel;
944 while (h-- > 0) {
945 uint32 r, g, b, a;
946 for (x = w; x-- > 0;) {
947 a = pp[3];
948 r = (pp[0] * a) / 255;
949 g = (pp[1] * a) / 255;
950 b = (pp[2] * a) / 255;
951 *cp++ = PACK4(r,g,b,a);
952 pp += samplesperpixel;
953 }
954 cp += toskew;
955 pp += fromskew;
956 }
957 }
958
959 /*
960 * 16-bit packed samples => RGB
961 */
962 DECLAREContigPutFunc(putRGBcontig16bittile)
963 {
964 int samplesperpixel = img->samplesperpixel;
965 uint16 *wp = (uint16 *)pp;
966
967 (void) y;
968 fromskew *= samplesperpixel;
969 while (h-- > 0) {
970 for (x = w; x-- > 0;) {
971 *cp++ = PACKW(wp[0], wp[1], wp[2]);
972 wp += samplesperpixel;
973 }
974 cp += toskew;
975 wp += fromskew;
976 }
977 }
978
979 /*
980 * 16-bit packed samples => RGBA w/ associated alpha
981 * (known to have Map == NULL)
982 */
983 DECLAREContigPutFunc(putRGBAAcontig16bittile)
984 {
985 int samplesperpixel = img->samplesperpixel;
986 uint16 *wp = (uint16 *)pp;
987
988 (void) y;
989 fromskew *= samplesperpixel;
990 while (h-- > 0) {
991 for (x = w; x-- > 0;) {
992 *cp++ = PACKW4(wp[0], wp[1], wp[2], wp[3]);
993 wp += samplesperpixel;
994 }
995 cp += toskew;
996 wp += fromskew;
997 }
998 }
999
1000 /*
1001 * 16-bit packed samples => RGBA w/ unassociated alpha
1002 * (known to have Map == NULL)
1003 */
1004 DECLAREContigPutFunc(putRGBUAcontig16bittile)
1005 {
1006 int samplesperpixel = img->samplesperpixel;
1007 uint16 *wp = (uint16 *)pp;
1008
1009 (void) y;
1010 fromskew *= samplesperpixel;
1011 while (h-- > 0) {
1012 uint32 r,g,b,a;
1013 /*
1014 * We shift alpha down four bits just in case unsigned
1015 * arithmetic doesn't handle the full range.
1016 * We still have plenty of accuracy, since the output is 8 bits.
1017 * So we have (r * 0xffff) * (a * 0xfff)) = r*a * (0xffff*0xfff)
1018 * Since we want r*a * 0xff for eight bit output,
1019 * we divide by (0xffff * 0xfff) / 0xff == 0x10eff.
1020 */
1021 for (x = w; x-- > 0;) {
1022 a = wp[3] >> 4;
1023 r = (wp[0] * a) / 0x10eff;
1024 g = (wp[1] * a) / 0x10eff;
1025 b = (wp[2] * a) / 0x10eff;
1026 *cp++ = PACK4(r,g,b,a);
1027 wp += samplesperpixel;
1028 }
1029 cp += toskew;
1030 wp += fromskew;
1031 }
1032 }
1033
1034 /*
1035 * 8-bit packed CMYK samples w/o Map => RGB
1036 *
1037 * NB: The conversion of CMYK->RGB is *very* crude.
1038 */
1039 DECLAREContigPutFunc(putRGBcontig8bitCMYKtile)
1040 {
1041 int samplesperpixel = img->samplesperpixel;
1042 uint16 r, g, b, k;
1043
1044 (void) x; (void) y;
1045 fromskew *= samplesperpixel;
1046 while (h-- > 0) {
1047 UNROLL8(w, NOP,
1048 k = 255 - pp[3];
1049 r = (k*(255-pp[0]))/255;
1050 g = (k*(255-pp[1]))/255;
1051 b = (k*(255-pp[2]))/255;
1052 *cp++ = PACK(r, g, b);
1053 pp += samplesperpixel);
1054 cp += toskew;
1055 pp += fromskew;
1056 }
1057 }
1058
1059 /*
1060 * 8-bit packed CMYK samples w/Map => RGB
1061 *
1062 * NB: The conversion of CMYK->RGB is *very* crude.
1063 */
1064 DECLAREContigPutFunc(putRGBcontig8bitCMYKMaptile)
1065 {
1066 int samplesperpixel = img->samplesperpixel;
1067 TIFFRGBValue* Map = img->Map;
1068 uint16 r, g, b, k;
1069
1070 (void) y;
1071 fromskew *= samplesperpixel;
1072 while (h-- > 0) {
1073 for (x = w; x-- > 0;) {
1074 k = 255 - pp[3];
1075 r = (k*(255-pp[0]))/255;
1076 g = (k*(255-pp[1]))/255;
1077 b = (k*(255-pp[2]))/255;
1078 *cp++ = PACK(Map[r], Map[g], Map[b]);
1079 pp += samplesperpixel;
1080 }
1081 pp += fromskew;
1082 cp += toskew;
1083 }
1084 }
1085
1086 #define DECLARESepPutFunc(name) \
1087 static void LINKAGEMODE name(\
1088 TIFFRGBAImage* img,\
1089 uint32* cp,\
1090 uint32 x, uint32 y, \
1091 uint32 w, uint32 h,\
1092 int32 fromskew, int32 toskew,\
1093 u_char* r, u_char* g, u_char* b, u_char* a\
1094 )
1095
1096 /*
1097 * 8-bit unpacked samples => RGB
1098 */
1099 DECLARESepPutFunc(putRGBseparate8bittile)
1100 {
1101 (void) img; (void) x; (void) y; (void) a;
1102 while (h-- > 0) {
1103 UNROLL8(w, NOP, *cp++ = PACK(*r++, *g++, *b++));
1104 SKEW(r, g, b, fromskew);
1105 cp += toskew;
1106 }
1107 }
1108
1109 /*
1110 * 8-bit unpacked samples => RGB
1111 */
1112 DECLARESepPutFunc(putRGBseparate8bitMaptile)
1113 {
1114 TIFFRGBValue* Map = img->Map;
1115
1116 (void) y; (void) a;
1117 while (h-- > 0) {
1118 for (x = w; x > 0; x--)
1119 *cp++ = PACK(Map[*r++], Map[*g++], Map[*b++]);
1120 SKEW(r, g, b, fromskew);
1121 cp += toskew;
1122 }
1123 }
1124
1125 /*
1126 * 8-bit unpacked samples => RGBA w/ associated alpha
1127 */
1128 DECLARESepPutFunc(putRGBAAseparate8bittile)
1129 {
1130 (void) img; (void) x; (void) y;
1131 while (h-- > 0) {
1132 UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++));
1133 SKEW4(r, g, b, a, fromskew);
1134 cp += toskew;
1135 }
1136 }
1137
1138 /*
1139 * 8-bit unpacked samples => RGBA w/ unassociated alpha
1140 */
1141 DECLARESepPutFunc(putRGBUAseparate8bittile)
1142 {
1143 (void) img; (void) y;
1144 while (h-- > 0) {
1145 uint32 rv, gv, bv, av;
1146 for (x = w; x-- > 0;) {
1147 av = *a++;
1148 rv = (*r++ * av) / 255;
1149 gv = (*g++ * av) / 255;
1150 bv = (*b++ * av) / 255;
1151 *cp++ = PACK4(rv,gv,bv,av);
1152 }
1153 SKEW4(r, g, b, a, fromskew);
1154 cp += toskew;
1155 }
1156 }
1157
1158 /*
1159 * 16-bit unpacked samples => RGB
1160 */
1161 DECLARESepPutFunc(putRGBseparate16bittile)
1162 {
1163 uint16 *wr = (uint16*) r;
1164 uint16 *wg = (uint16*) g;
1165 uint16 *wb = (uint16*) b;
1166
1167 (void) img; (void) y; (void) a;
1168 while (h-- > 0) {
1169 for (x = 0; x < w; x++)
1170 *cp++ = PACKW(*wr++, *wg++, *wb++);
1171 SKEW(wr, wg, wb, fromskew);
1172 cp += toskew;
1173 }
1174 }
1175
1176 /*
1177 * 16-bit unpacked samples => RGBA w/ associated alpha
1178 */
1179 DECLARESepPutFunc(putRGBAAseparate16bittile)
1180 {
1181 uint16 *wr = (uint16*) r;
1182 uint16 *wg = (uint16*) g;
1183 uint16 *wb = (uint16*) b;
1184 uint16 *wa = (uint16*) a;
1185
1186 (void) img; (void) y;
1187 while (h-- > 0) {
1188 for (x = 0; x < w; x++)
1189 *cp++ = PACKW4(*wr++, *wg++, *wb++, *wa++);
1190 SKEW4(wr, wg, wb, wa, fromskew);
1191 cp += toskew;
1192 }
1193 }
1194
1195 /*
1196 * 16-bit unpacked samples => RGBA w/ unassociated alpha
1197 */
1198 DECLARESepPutFunc(putRGBUAseparate16bittile)
1199 {
1200 uint16 *wr = (uint16*) r;
1201 uint16 *wg = (uint16*) g;
1202 uint16 *wb = (uint16*) b;
1203 uint16 *wa = (uint16*) a;
1204
1205 (void) img; (void) y;
1206 while (h-- > 0) {
1207 uint32 r,g,b,a;
1208 /*
1209 * We shift alpha down four bits just in case unsigned
1210 * arithmetic doesn't handle the full range.
1211 * We still have plenty of accuracy, since the output is 8 bits.
1212 * So we have (r * 0xffff) * (a * 0xfff)) = r*a * (0xffff*0xfff)
1213 * Since we want r*a * 0xff for eight bit output,
1214 * we divide by (0xffff * 0xfff) / 0xff == 0x10eff.
1215 */
1216 for (x = w; x-- > 0;) {
1217 a = *wa++ >> 4;
1218 r = (*wr++ * a) / 0x10eff;
1219 g = (*wg++ * a) / 0x10eff;
1220 b = (*wb++ * a) / 0x10eff;
1221 *cp++ = PACK4(r,g,b,a);
1222 }
1223 SKEW4(wr, wg, wb, wa, fromskew);
1224 cp += toskew;
1225 }
1226 }
1227
1228 /*
1229 * YCbCr -> RGB conversion and packing routines. The colorspace
1230 * conversion algorithm comes from the IJG v5a code; see below
1231 * for more information on how it works.
1232 */
1233
1234 #define YCbCrtoRGB(dst, yc) { \
1235 int Y = (yc); \
1236 dst = PACK( \
1237 clamptab[Y+Crrtab[Cr]], \
1238 clamptab[Y + (int)((Cbgtab[Cb]+Crgtab[Cr])>>16)], \
1239 clamptab[Y+Cbbtab[Cb]]); \
1240 }
1241 #define YCbCrSetup \
1242 TIFFYCbCrToRGB* ycbcr = img->ycbcr; \
1243 int* Crrtab = ycbcr->Cr_r_tab; \
1244 int* Cbbtab = ycbcr->Cb_b_tab; \
1245 int32* Crgtab = ycbcr->Cr_g_tab; \
1246 int32* Cbgtab = ycbcr->Cb_g_tab; \
1247 TIFFRGBValue* clamptab = ycbcr->clamptab
1248
1249 /*
1250 * 8-bit packed YCbCr samples w/ 4,4 subsampling => RGB
1251 */
1252 DECLAREContigPutFunc(putcontig8bitYCbCr44tile)
1253 {
1254 YCbCrSetup;
1255 uint32* cp1 = cp+w+toskew;
1256 uint32* cp2 = cp1+w+toskew;
1257 uint32* cp3 = cp2+w+toskew;
1258 int32 incr = 3*w+4*toskew;
1259
1260 (void) y;
1261 /* XXX adjust fromskew */
1262 for (; h >= 4; h -= 4) {
1263 x = w>>2;
1264 do {
1265 int Cb = pp[16];
1266 int Cr = pp[17];
1267
1268 YCbCrtoRGB(cp [0], pp[ 0]);
1269 YCbCrtoRGB(cp [1], pp[ 1]);
1270 YCbCrtoRGB(cp [2], pp[ 2]);
1271 YCbCrtoRGB(cp [3], pp[ 3]);
1272 YCbCrtoRGB(cp1[0], pp[ 4]);
1273 YCbCrtoRGB(cp1[1], pp[ 5]);
1274 YCbCrtoRGB(cp1[2], pp[ 6]);
1275 YCbCrtoRGB(cp1[3], pp[ 7]);
1276 YCbCrtoRGB(cp2[0], pp[ 8]);
1277 YCbCrtoRGB(cp2[1], pp[ 9]);
1278 YCbCrtoRGB(cp2[2], pp[10]);
1279 YCbCrtoRGB(cp2[3], pp[11]);
1280 YCbCrtoRGB(cp3[0], pp[12]);
1281 YCbCrtoRGB(cp3[1], pp[13]);
1282 YCbCrtoRGB(cp3[2], pp[14]);
1283 YCbCrtoRGB(cp3[3], pp[15]);
1284
1285 cp += 4, cp1 += 4, cp2 += 4, cp3 += 4;
1286 pp += 18;
1287 } while (--x);
1288 cp += incr, cp1 += incr, cp2 += incr, cp3 += incr;
1289 pp += fromskew;
1290 }
1291 }
1292
1293 /*
1294 * 8-bit packed YCbCr samples w/ 4,2 subsampling => RGB
1295 */
1296 DECLAREContigPutFunc(putcontig8bitYCbCr42tile)
1297 {
1298 YCbCrSetup;
1299 uint32* cp1 = cp+w+toskew;
1300 int32 incr = 2*toskew+w;
1301
1302 (void) y;
1303 /* XXX adjust fromskew */
1304 for (; h >= 2; h -= 2) {
1305 x = w>>2;
1306 do {
1307 int Cb = pp[8];
1308 int Cr = pp[9];
1309
1310 YCbCrtoRGB(cp [0], pp[0]);
1311 YCbCrtoRGB(cp [1], pp[1]);
1312 YCbCrtoRGB(cp [2], pp[2]);
1313 YCbCrtoRGB(cp [3], pp[3]);
1314 YCbCrtoRGB(cp1[0], pp[4]);
1315 YCbCrtoRGB(cp1[1], pp[5]);
1316 YCbCrtoRGB(cp1[2], pp[6]);
1317 YCbCrtoRGB(cp1[3], pp[7]);
1318
1319 cp += 4, cp1 += 4;
1320 pp += 10;
1321 } while (--x);
1322 cp += incr, cp1 += incr;
1323 pp += fromskew;
1324 }
1325 }
1326
1327 /*
1328 * 8-bit packed YCbCr samples w/ 4,1 subsampling => RGB
1329 */
1330 DECLAREContigPutFunc(putcontig8bitYCbCr41tile)
1331 {
1332 YCbCrSetup;
1333
1334 (void) y;
1335 /* XXX adjust fromskew */
1336 do {
1337 x = w>>2;
1338 do {
1339 int Cb = pp[4];
1340 int Cr = pp[5];
1341
1342 YCbCrtoRGB(cp [0], pp[0]);
1343 YCbCrtoRGB(cp [1], pp[1]);
1344 YCbCrtoRGB(cp [2], pp[2]);
1345 YCbCrtoRGB(cp [3], pp[3]);
1346
1347 cp += 4;
1348 pp += 6;
1349 } while (--x);
1350 cp += toskew;
1351 pp += fromskew;
1352 } while (--h);
1353 }
1354
1355 /*
1356 * 8-bit packed YCbCr samples w/ 2,2 subsampling => RGB
1357 */
1358 DECLAREContigPutFunc(putcontig8bitYCbCr22tile)
1359 {
1360 YCbCrSetup;
1361 uint32* cp1 = cp+w+toskew;
1362 int32 incr = 2*toskew+w;
1363
1364 (void) y;
1365 /* XXX adjust fromskew */
1366 for (; h >= 2; h -= 2) {
1367 x = w>>1;
1368 do {
1369 int Cb = pp[4];
1370 int Cr = pp[5];
1371
1372 YCbCrtoRGB(cp [0], pp[0]);
1373 YCbCrtoRGB(cp [1], pp[1]);
1374 YCbCrtoRGB(cp1[0], pp[2]);
1375 YCbCrtoRGB(cp1[1], pp[3]);
1376
1377 cp += 2, cp1 += 2;
1378 pp += 6;
1379 } while (--x);
1380 cp += incr, cp1 += incr;
1381 pp += fromskew;
1382 }
1383 }
1384
1385 /*
1386 * 8-bit packed YCbCr samples w/ 2,1 subsampling => RGB
1387 */
1388 DECLAREContigPutFunc(putcontig8bitYCbCr21tile)
1389 {
1390 YCbCrSetup;
1391
1392 (void) y;
1393 /* XXX adjust fromskew */
1394 do {
1395 x = w>>1;
1396 do {
1397 int Cb = pp[2];
1398 int Cr = pp[3];
1399
1400 YCbCrtoRGB(cp[0], pp[0]);
1401 YCbCrtoRGB(cp[1], pp[1]);
1402
1403 cp += 2;
1404 pp += 4;
1405 } while (--x);
1406 cp += toskew;
1407 pp += fromskew;
1408 } while (--h);
1409 }
1410
1411 /*
1412 * 8-bit packed YCbCr samples w/ no subsampling => RGB
1413 */
1414 DECLAREContigPutFunc(putcontig8bitYCbCr11tile)
1415 {
1416 YCbCrSetup;
1417
1418 (void) y;
1419 /* XXX adjust fromskew */
1420 do {
1421 x = w>>1;
1422 do {
1423 int Cb = pp[1];
1424 int Cr = pp[2];
1425
1426 YCbCrtoRGB(*cp++, pp[0]);
1427
1428 pp += 3;
1429 } while (--x);
1430 cp += toskew;
1431 pp += fromskew;
1432 } while (--h);
1433 }
1434 #undef YCbCrSetup
1435 #undef YCbCrtoRGB
1436
1437 #define LumaRed coeffs[0]
1438 #define LumaGreen coeffs[1]
1439 #define LumaBlue coeffs[2]
1440 #define SHIFT 16
1441 #define FIX(x) ((int32)((x) * (1L<<SHIFT) + 0.5))
1442 #define ONE_HALF ((int32)(1<<(SHIFT-1)))
1443
1444 /*
1445 * Initialize the YCbCr->RGB conversion tables. The conversion
1446 * is done according to the 6.0 spec:
1447 *
1448 * R = Y + Cr*(2 - 2*LumaRed)
1449 * B = Y + Cb*(2 - 2*LumaBlue)
1450 * G = Y
1451 * - LumaBlue*Cb*(2-2*LumaBlue)/LumaGreen
1452 * - LumaRed*Cr*(2-2*LumaRed)/LumaGreen
1453 *
1454 * To avoid floating point arithmetic the fractional constants that
1455 * come out of the equations are represented as fixed point values
1456 * in the range 0...2^16. We also eliminate multiplications by
1457 * pre-calculating possible values indexed by Cb and Cr (this code
1458 * assumes conversion is being done for 8-bit samples).
1459 */
1460 static void
1461 TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, TIFF* tif)
1462 {
1463 TIFFRGBValue* clamptab;
1464 float* coeffs;
1465 int i;
1466
1467 clamptab = (TIFFRGBValue*)(
1468 (tidata_t) ycbcr+TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long)));
1469 _TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */
1470 ycbcr->clamptab = (clamptab += 256);
1471 for (i = 0; i < 256; i++)
1472 clamptab[i] = i;
1473 _TIFFmemset(clamptab+256, 255, 2*256); /* v > 255 => 255 */
1474 TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRCOEFFICIENTS, &coeffs);
1475 _TIFFmemcpy(ycbcr->coeffs, coeffs, 3*sizeof (float));
1476 { float f1 = 2-2*LumaRed; int32 D1 = FIX(f1);
1477 float f2 = LumaRed*f1/LumaGreen; int32 D2 = -FIX(f2);
1478 float f3 = 2-2*LumaBlue; int32 D3 = FIX(f3);
1479 float f4 = LumaBlue*f3/LumaGreen; int32 D4 = -FIX(f4);
1480 int x;
1481
1482 ycbcr->Cr_r_tab = (int*) (clamptab + 3*256);
1483 ycbcr->Cb_b_tab = ycbcr->Cr_r_tab + 256;
1484 ycbcr->Cr_g_tab = (int32*) (ycbcr->Cb_b_tab + 256);
1485 ycbcr->Cb_g_tab = ycbcr->Cr_g_tab + 256;
1486 /*
1487 * i is the actual input pixel value in the range 0..255
1488 * Cb and Cr values are in the range -128..127 (actually
1489 * they are in a range defined by the ReferenceBlackWhite
1490 * tag) so there is some range shifting to do here when
1491 * constructing tables indexed by the raw pixel data.
1492 *
1493 * XXX handle ReferenceBlackWhite correctly to calculate
1494 * Cb/Cr values to use in constructing the tables.
1495 */
1496 for (i = 0, x = -128; i < 256; i++, x++) {
1497 ycbcr->Cr_r_tab[i] = (int)((D1*x + ONE_HALF)>>SHIFT);
1498 ycbcr->Cb_b_tab[i] = (int)((D3*x + ONE_HALF)>>SHIFT);
1499 ycbcr->Cr_g_tab[i] = D2*x;
1500 ycbcr->Cb_g_tab[i] = D4*x + ONE_HALF;
1501 }
1502 }
1503 }
1504 #undef SHIFT
1505 #undef ONE_HALF
1506 #undef FIX
1507 #undef LumaBlue
1508 #undef LumaGreen
1509 #undef LumaRed
1510
1511 static tileContigRoutine
1512 initYCbCrConversion(TIFFRGBAImage* img)
1513 {
1514 uint16 hs, vs;
1515
1516 if (img->ycbcr == NULL) {
1517 img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc(
1518 TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long))
1519 + 4*256*sizeof (TIFFRGBValue)
1520 + 2*256*sizeof (int)
1521 + 2*256*sizeof (int32)
1522 );
1523 if (img->ycbcr == NULL) {
1524 TIFFError(TIFFFileName(img->tif),
1525 "No space for YCbCr->RGB conversion state");
1526 return (NULL);
1527 }
1528 TIFFYCbCrToRGBInit(img->ycbcr, img->tif);
1529 } else {
1530 float* coeffs;
1531
1532 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRCOEFFICIENTS, &coeffs);
1533 if (_TIFFmemcmp(coeffs, img->ycbcr->coeffs, 3*sizeof (float)) != 0)
1534 TIFFYCbCrToRGBInit(img->ycbcr, img->tif);
1535 }
1536 /*
1537 * The 6.0 spec says that subsampling must be
1538 * one of 1, 2, or 4, and that vertical subsampling
1539 * must always be <= horizontal subsampling; so
1540 * there are only a few possibilities and we just
1541 * enumerate the cases.
1542 */
1543 TIFFGetFieldDefaulted(img->tif, TIFFTAG_YCBCRSUBSAMPLING, &hs, &vs);
1544 switch ((hs<<4)|vs) {
1545 case 0x44: return (putcontig8bitYCbCr44tile);
1546 case 0x42: return (putcontig8bitYCbCr42tile);
1547 case 0x41: return (putcontig8bitYCbCr41tile);
1548 case 0x22: return (putcontig8bitYCbCr22tile);
1549 case 0x21: return (putcontig8bitYCbCr21tile);
1550 case 0x11: return (putcontig8bitYCbCr11tile);
1551 }
1552 return (NULL);
1553 }
1554
1555 /*
1556 * Greyscale images with less than 8 bits/sample are handled
1557 * with a table to avoid lots of shifts and masks. The table
1558 * is setup so that put*bwtile (below) can retrieve 8/bitspersample
1559 * pixel values simply by indexing into the table with one
1560 * number.
1561 */
1562 static int
1563 makebwmap(TIFFRGBAImage* img)
1564 {
1565 TIFFRGBValue* Map = img->Map;
1566 int bitspersample = img->bitspersample;
1567 int nsamples = 8 / bitspersample;
1568 int i;
1569 uint32* p;
1570
1571 img->BWmap = (uint32**) _TIFFmalloc(
1572 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32)));
1573 if (img->BWmap == NULL) {
1574 TIFFError(TIFFFileName(img->tif), "No space for B&W mapping table");
1575 return (0);
1576 }
1577 p = (uint32*)(img->BWmap + 256);
1578 for (i = 0; i < 256; i++) {
1579 TIFFRGBValue c;
1580 img->BWmap[i] = p;
1581 switch (bitspersample) {
1582 #define GREY(x) c = Map[x]; *p++ = PACK(c,c,c);
1583 case 1:
1584 GREY(i>>7);
1585 GREY((i>>6)&1);
1586 GREY((i>>5)&1);
1587 GREY((i>>4)&1);
1588 GREY((i>>3)&1);
1589 GREY((i>>2)&1);
1590 GREY((i>>1)&1);
1591 GREY(i&1);
1592 break;
1593 case 2:
1594 GREY(i>>6);
1595 GREY((i>>4)&3);
1596 GREY((i>>2)&3);
1597 GREY(i&3);
1598 break;
1599 case 4:
1600 GREY(i>>4);
1601 GREY(i&0xf);
1602 break;
1603 case 8:
1604 GREY(i);
1605 break;
1606 }
1607 #undef GREY
1608 }
1609 return (1);
1610 }
1611
1612 /*
1613 * Construct a mapping table to convert from the range
1614 * of the data samples to [0,255] --for display. This
1615 * process also handles inverting B&W images when needed.
1616 */
1617 static int
1618 setupMap(TIFFRGBAImage* img)
1619 {
1620 int32 x, range;
1621
1622 range = (int32)((1L<<img->bitspersample)-1);
1623 img->Map = (TIFFRGBValue*) _TIFFmalloc((range+1) * sizeof (TIFFRGBValue));
1624 if (img->Map == NULL) {
1625 TIFFError(TIFFFileName(img->tif),
1626 "No space for photometric conversion table");
1627 return (0);
1628 }
1629 if (img->photometric == PHOTOMETRIC_MINISWHITE) {
1630 for (x = 0; x <= range; x++)
1631 img->Map[x] = ((range - x) * 255) / range;
1632 } else {
1633 for (x = 0; x <= range; x++)
1634 img->Map[x] = (x * 255) / range;
1635 }
1636 if (img->bitspersample <= 8 &&
1637 (img->photometric == PHOTOMETRIC_MINISBLACK ||
1638 img->photometric == PHOTOMETRIC_MINISWHITE)) {
1639 /*
1640 * Use photometric mapping table to construct
1641 * unpacking tables for samples <= 8 bits.
1642 */
1643 if (!makebwmap(img))
1644 return (0);
1645 /* no longer need Map, free it */
1646 _TIFFfree(img->Map), img->Map = NULL;
1647 }
1648 return (1);
1649 }
1650
1651 static int
1652 checkcmap(TIFFRGBAImage* img)
1653 {
1654 uint16* r = img->redcmap;
1655 uint16* g = img->greencmap;
1656 uint16* b = img->bluecmap;
1657 long n = 1L<<img->bitspersample;
1658
1659 while (n-- > 0)
1660 if (*r++ >= 256 || *g++ >= 256 || *b++ >= 256)
1661 return (16);
1662 return (8);
1663 }
1664
1665 static void
1666 cvtcmap(TIFFRGBAImage* img)
1667 {
1668 uint16* r = img->redcmap;
1669 uint16* g = img->greencmap;
1670 uint16* b = img->bluecmap;
1671 long i;
1672
1673 for (i = (1L<<img->bitspersample)-1; i >= 0; i--) {
1674 #define CVT(x) ((uint16)((x)>>8))
1675 r[i] = CVT(r[i]);
1676 g[i] = CVT(g[i]);
1677 b[i] = CVT(b[i]);
1678 #undef CVT
1679 }
1680 }
1681
1682 /*
1683 * Palette images with <= 8 bits/sample are handled
1684 * with a table to avoid lots of shifts and masks. The table
1685 * is setup so that put*cmaptile (below) can retrieve 8/bitspersample
1686 * pixel values simply by indexing into the table with one
1687 * number.
1688 */
1689 static int
1690 makecmap(TIFFRGBAImage* img)
1691 {
1692 int bitspersample = img->bitspersample;
1693 int nsamples = 8 / bitspersample;
1694 uint16* r = img->redcmap;
1695 uint16* g = img->greencmap;
1696 uint16* b = img->bluecmap;
1697 uint32 *p;
1698 int i;
1699
1700 img->PALmap = (uint32**) _TIFFmalloc(
1701 256*sizeof (uint32 *)+(256*nsamples*sizeof(uint32)));
1702 if (img->PALmap == NULL) {
1703 TIFFError(TIFFFileName(img->tif), "No space for Palette mapping table");
1704 return (0);
1705 }
1706 p = (uint32*)(img->PALmap + 256);
1707 for (i = 0; i < 256; i++) {
1708 TIFFRGBValue c;
1709 img->PALmap[i] = p;
1710 #define CMAP(x) c = x; *p++ = PACK(r[c]&0xff, g[c]&0xff, b[c]&0xff);
1711 switch (bitspersample) {
1712 case 1:
1713 CMAP(i>>7);
1714 CMAP((i>>6)&1);
1715 CMAP((i>>5)&1);
1716 CMAP((i>>4)&1);
1717 CMAP((i>>3)&1);
1718 CMAP((i>>2)&1);
1719 CMAP((i>>1)&1);
1720 CMAP(i&1);
1721 break;
1722 case 2:
1723 CMAP(i>>6);
1724 CMAP((i>>4)&3);
1725 CMAP((i>>2)&3);
1726 CMAP(i&3);
1727 break;
1728 case 4:
1729 CMAP(i>>4);
1730 CMAP(i&0xf);
1731 break;
1732 case 8:
1733 CMAP(i);
1734 break;
1735 }
1736 #undef CMAP
1737 }
1738 return (1);
1739 }
1740
1741 /*
1742 * Construct any mapping table used
1743 * by the associated put routine.
1744 */
1745 static int
1746 buildMap(TIFFRGBAImage* img)
1747 {
1748 switch (img->photometric) {
1749 case PHOTOMETRIC_RGB:
1750 case PHOTOMETRIC_YCBCR:
1751 case PHOTOMETRIC_SEPARATED:
1752 if (img->bitspersample == 8)
1753 break;
1754 /* fall thru... */
1755 case PHOTOMETRIC_MINISBLACK:
1756 case PHOTOMETRIC_MINISWHITE:
1757 if (!setupMap(img))
1758 return (0);
1759 break;
1760 case PHOTOMETRIC_PALETTE:
1761 /*
1762 * Convert 16-bit colormap to 8-bit (unless it looks
1763 * like an old-style 8-bit colormap).
1764 */
1765 if (checkcmap(img) == 16)
1766 cvtcmap(img);
1767 else
1768 TIFFWarning(TIFFFileName(img->tif), "Assuming 8-bit colormap");
1769 /*
1770 * Use mapping table and colormap to construct
1771 * unpacking tables for samples < 8 bits.
1772 */
1773 if (img->bitspersample <= 8 && !makecmap(img))
1774 return (0);
1775 break;
1776 }
1777 return (1);
1778 }
1779
1780 /*
1781 * Select the appropriate conversion routine for packed data.
1782 */
1783 static int
1784 pickTileContigCase(TIFFRGBAImage* img)
1785 {
1786 tileContigRoutine put = 0;
1787
1788 if (buildMap(img)) {
1789 switch (img->photometric) {
1790 case PHOTOMETRIC_RGB:
1791 switch (img->bitspersample) {
1792 case 8:
1793 if (!img->Map) {
1794 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
1795 put = putRGBAAcontig8bittile;
1796 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
1797 put = putRGBUAcontig8bittile;
1798 else
1799 put = putRGBcontig8bittile;
1800 } else
1801 put = putRGBcontig8bitMaptile;
1802 break;
1803 case 16:
1804 put = putRGBcontig16bittile;
1805 if (!img->Map) {
1806 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
1807 put = putRGBAAcontig16bittile;
1808 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
1809 put = putRGBUAcontig16bittile;
1810 }
1811 break;
1812 }
1813 break;
1814 case PHOTOMETRIC_SEPARATED:
1815 if (img->bitspersample == 8) {
1816 if (!img->Map)
1817 put = putRGBcontig8bitCMYKtile;
1818 else
1819 put = putRGBcontig8bitCMYKMaptile;
1820 }
1821 break;
1822 case PHOTOMETRIC_PALETTE:
1823 switch (img->bitspersample) {
1824 case 8: put = put8bitcmaptile; break;
1825 case 4: put = put4bitcmaptile; break;
1826 case 2: put = put2bitcmaptile; break;
1827 case 1: put = put1bitcmaptile; break;
1828 }
1829 break;
1830 case PHOTOMETRIC_MINISWHITE:
1831 case PHOTOMETRIC_MINISBLACK:
1832 switch (img->bitspersample) {
1833 case 8: put = putgreytile; break;
1834 case 4: put = put4bitbwtile; break;
1835 case 2: put = put2bitbwtile; break;
1836 case 1: put = put1bitbwtile; break;
1837 }
1838 break;
1839 case PHOTOMETRIC_YCBCR:
1840 if (img->bitspersample == 8)
1841 put = initYCbCrConversion(img);
1842 break;
1843 }
1844 }
1845 return ((img->put.contig = put) != 0);
1846 }
1847
1848 /*
1849 * Select the appropriate conversion routine for unpacked data.
1850 *
1851 * NB: we assume that unpacked single channel data is directed
1852 * to the "packed routines.
1853 */
1854 static int
1855 pickTileSeparateCase(TIFFRGBAImage* img)
1856 {
1857 tileSeparateRoutine put = 0;
1858
1859 if (buildMap(img)) {
1860 switch (img->photometric) {
1861 case PHOTOMETRIC_RGB:
1862 switch (img->bitspersample) {
1863 case 8:
1864 if (!img->Map) {
1865 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
1866 put = putRGBAAseparate8bittile;
1867 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
1868 put = putRGBUAseparate8bittile;
1869 else
1870 put = putRGBseparate8bittile;
1871 } else
1872 put = putRGBseparate8bitMaptile;
1873 break;
1874 case 16:
1875 put = putRGBseparate16bittile;
1876 if (!img->Map) {
1877 if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
1878 put = putRGBAAseparate16bittile;
1879 else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
1880 put = putRGBUAseparate16bittile;
1881 }
1882 break;
1883 }
1884 break;
1885 }
1886 }
1887 return ((img->put.separate = put) != 0);
1888 }
1889
1890 /*
1891 * Read a whole strip off data from the file, and convert to RGBA form.
1892 * If this is the last strip, then it will only contain the portion of
1893 * the strip that is actually within the image space. The result is
1894 * organized in bottom to top form.
1895 */
1896
1897
1898 int
1899 TIFFReadRGBAStrip(TIFF* tif, uint32 row, uint32 * raster )
1900
1901 {
1902 char emsg[1024];
1903 TIFFRGBAImage img;
1904 int ok;
1905 uint32 rowsperstrip, rows_to_read;
1906
1907 if( TIFFIsTiled( tif ) )
1908 {
1909 TIFFError(TIFFFileName(tif),
1910 "Can't use TIFFReadRGBAStrip() with tiled file.");
1911 return (0);
1912 }
1913
1914 TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
1915 if( (row % rowsperstrip) != 0 )
1916 {
1917 TIFFError(TIFFFileName(tif),
1918 "Row passed to TIFFReadRGBAStrip() must be first in a strip.");
1919 return (0);
1920 }
1921
1922 if (TIFFRGBAImageBegin(&img, tif, 0, emsg)) {
1923
1924 img.row_offset = row;
1925 img.col_offset = 0;
1926
1927 if( row + rowsperstrip > img.height )
1928 rows_to_read = img.height - row;
1929 else
1930 rows_to_read = rowsperstrip;
1931
1932 ok = TIFFRGBAImageGet(&img, raster, img.width, rows_to_read );
1933
1934 TIFFRGBAImageEnd(&img);
1935 } else {
1936 TIFFError(TIFFFileName(tif), emsg);
1937 ok = 0;
1938 }
1939
1940 return (ok);
1941 }
1942
1943 /*
1944 * Read a whole tile off data from the file, and convert to RGBA form.
1945 * The returned RGBA data is organized from bottom to top of tile,
1946 * and may include zeroed areas if the tile extends off the image.
1947 */
1948
1949 int
1950 TIFFReadRGBATile(TIFF* tif, uint32 col, uint32 row, uint32 * raster)
1951
1952 {
1953 char emsg[1024];
1954 TIFFRGBAImage img;
1955 int ok;
1956 uint32 tile_xsize, tile_ysize;
1957 uint32 read_xsize, read_ysize;
1958 int i_row;
1959
1960 /*
1961 * Verify that our request is legal - on a tile file, and on a
1962 * tile boundary.
1963 */
1964
1965 if( !TIFFIsTiled( tif ) )
1966 {
1967 TIFFError(TIFFFileName(tif),
1968 "Can't use TIFFReadRGBATile() with stripped file.");
1969 return (0);
1970 }
1971
1972 TIFFGetFieldDefaulted(tif, TIFFTAG_TILEWIDTH, &tile_xsize);
1973 TIFFGetFieldDefaulted(tif, TIFFTAG_TILELENGTH, &tile_ysize);
1974 if( (col % tile_xsize) != 0 || (row % tile_ysize) != 0 )
1975 {
1976 TIFFError(TIFFFileName(tif),
1977 "Row/col passed to TIFFReadRGBATile() must be top"
1978 "left corner of a tile.");
1979 return (0);
1980 }
1981
1982 /*
1983 * Setup the RGBA reader.
1984 */
1985
1986 if ( !TIFFRGBAImageBegin(&img, tif, 0, emsg)) {
1987 TIFFError(TIFFFileName(tif), emsg);
1988 return( 0 );
1989 }
1990
1991 /*
1992 * The TIFFRGBAImageGet() function doesn't allow us to get off the
1993 * edge of the image, even to fill an otherwise valid tile. So we
1994 * figure out how much we can read, and fix up the tile buffer to
1995 * a full tile configuration afterwards.
1996 */
1997
1998 if( row + tile_ysize > img.height )
1999 read_ysize = img.height - row;
2000 else
2001 read_ysize = tile_ysize;
2002
2003 if( col + tile_xsize > img.width )
2004 read_xsize = img.width - col;
2005 else
2006 read_xsize = tile_xsize;
2007
2008 /*
2009 * Read the chunk of imagery.
2010 */
2011
2012 img.row_offset = row;
2013 img.col_offset = col;
2014
2015 ok = TIFFRGBAImageGet(&img, raster, read_xsize, read_ysize );
2016
2017 TIFFRGBAImageEnd(&img);
2018
2019 /*
2020 * If our read was incomplete we will need to fix up the tile by
2021 * shifting the data around as if a full tile of data is being returned.
2022 *
2023 * This is all the more complicated because the image is organized in
2024 * bottom to top format.
2025 */
2026
2027 if( read_xsize == tile_xsize && read_ysize == tile_ysize )
2028 return( ok );
2029
2030 for( i_row = 0; i_row < read_ysize; i_row++ )
2031 {
2032 _TIFFmemcpy( raster + (tile_ysize - i_row - 1) * tile_xsize,
2033 raster + (read_ysize - i_row - 1) * read_xsize,
2034 read_xsize * sizeof(uint32) );
2035 _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize+read_xsize,
2036 0, sizeof(uint32) * (tile_xsize - read_xsize) );
2037 }
2038
2039 for( i_row = read_ysize; i_row < tile_ysize; i_row++ )
2040 {
2041 _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize,
2042 0, sizeof(uint32) * tile_xsize );
2043 }
2044
2045 return (ok);
2046 }
wxWidgets (Impactor)