thirdparty/libtiff/tif_getimage.c

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