src/bin/jp2/converttif.c

   1 /*
   2  * The copyright in this software is being made available under the 2-clauses
   3  * BSD License, included below. This software may be subject to other third
   4  * party and contributor rights, including patent rights, and no such rights
   5  * are granted under this license.
   6  *
   7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   8  * Copyright (c) 2002-2014, Professor Benoit Macq
   9  * Copyright (c) 2001-2003, David Janssens
  10  * Copyright (c) 2002-2003, Yannick Verschueren
  11  * Copyright (c) 2003-2007, Francois-Olivier Devaux
  12  * Copyright (c) 2003-2014, Antonin Descampe
  13  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  14  * Copyright (c) 2006-2007, Parvatha Elangovan
  15  * Copyright (c) 2015, Matthieu Darbois
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGE.
  38  */
  39 #include "opj_apps_config.h"
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45
  46 #ifndef OPJ_HAVE_LIBTIFF
  47 # error OPJ_HAVE_LIBTIFF_NOT_DEFINED
  48 #endif /* OPJ_HAVE_LIBTIFF */
  49
  50 #include <tiffio.h>
  51 #include "openjpeg.h"
  52 #include "convert.h"
  53
  54 /* -->> -->> -->> -->>
  55
  56  TIFF IMAGE FORMAT
  57
  58  <<-- <<-- <<-- <<-- */
  59
  60 static void tif_32sto10u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
  61 {
  62         OPJ_SIZE_T i;
  63         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
  64                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
  65                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
  66                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
  67                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
  68
  69                 *pDst++ = (OPJ_BYTE)(src0 >> 2);
  70                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3U) << 6) | (src1 >> 4));
  71                 *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 6));
  72                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3FU) << 2) | (src3 >> 8));
  73                 *pDst++ = (OPJ_BYTE)(src3);
  74         }
  75
  76         if (length & 3U) {
  77                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
  78                 OPJ_UINT32 src1 = 0U;
  79                 OPJ_UINT32 src2 = 0U;
  80                 length = length & 3U;
  81
  82                 if (length > 1U) {
  83                         src1 = (OPJ_UINT32)pSrc[i+1];
  84                         if (length > 2U) {
  85                                 src2 = (OPJ_UINT32)pSrc[i+2];
  86                         }
  87                 }
  88                 *pDst++ = (OPJ_BYTE)(src0 >> 2);
  89                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3U) << 6) | (src1 >> 4));
  90                 if (length > 1U) {
  91                         *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 6));
  92                         if (length > 2U) {
  93                                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3FU) << 2));
  94                         }
  95                 }
  96         }
  97 }
  98 static void tif_32sto12u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
  99 {
 100         OPJ_SIZE_T i;
 101         for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i+=2U) {
 102                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 103                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 104
 105                 *pDst++ = (OPJ_BYTE)(src0 >> 4);
 106                 *pDst++ = (OPJ_BYTE)(((src0 & 0xFU) << 4) | (src1 >> 8));
 107                 *pDst++ = (OPJ_BYTE)(src1);
 108         }
 109
 110         if (length & 1U) {
 111                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 112                 *pDst++ = (OPJ_BYTE)(src0 >> 4);
 113                 *pDst++ = (OPJ_BYTE)(((src0 & 0xFU) << 4));
 114         }
 115 }
 116 static void tif_32sto14u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 117 {
 118         OPJ_SIZE_T i;
 119         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
 120                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 121                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 122                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 123                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 124
 125                 *pDst++ = (OPJ_BYTE)(src0 >> 6);
 126                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3FU) << 2) | (src1 >> 12));
 127                 *pDst++ = (OPJ_BYTE)(src1 >> 4);
 128                 *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 10));
 129                 *pDst++ = (OPJ_BYTE)(src2 >> 2);
 130                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6) | (src3 >> 8));
 131                 *pDst++ = (OPJ_BYTE)(src3);
 132         }
 133
 134         if (length & 3U) {
 135                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 136                 OPJ_UINT32 src1 = 0U;
 137                 OPJ_UINT32 src2 = 0U;
 138                 length = length & 3U;
 139
 140                 if (length > 1U) {
 141                         src1 = (OPJ_UINT32)pSrc[i+1];
 142                         if (length > 2U) {
 143                                 src2 = (OPJ_UINT32)pSrc[i+2];
 144                         }
 145                 }
 146                 *pDst++ = (OPJ_BYTE)(src0 >> 6);
 147                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3FU) << 2) | (src1 >> 12));
 148                 if (length > 1U) {
 149                         *pDst++ = (OPJ_BYTE)(src1 >> 4);
 150                         *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 10));
 151                         if (length > 2U) {
 152                                 *pDst++ = (OPJ_BYTE)(src2 >> 2);
 153                                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6));
 154                         }
 155                 }
 156         }
 157 }
 158 static void tif_32sto16u(const OPJ_INT32* pSrc, OPJ_UINT16* pDst, OPJ_SIZE_T length)
 159 {
 160         OPJ_SIZE_T i;
 161         for (i = 0; i < length; ++i) {
 162                 pDst[i] = (OPJ_UINT16)pSrc[i];
 163         }
 164 }
 165
 166 int imagetotif(opj_image_t * image, const char *outfile)
 167 {
 168         int width, height;
 169         int bps,adjust, sgnd;
 170         int tiPhoto;
 171         TIFF *tif;
 172         tdata_t buf;
 173         tsize_t strip_size;
 174         OPJ_UINT32 i, numcomps;
 175         OPJ_SIZE_T rowStride;
 176         OPJ_INT32* buffer32s = NULL;
 177         OPJ_INT32 const* planes[4];
 178         convert_32s_PXCX cvtPxToCx = NULL;
 179         convert_32sXXx_C1R cvt32sToTif = NULL;
 180
 181         bps = (int)image->comps[0].prec;
 182         planes[0] = image->comps[0].data;
 183
 184         numcomps = image->numcomps;
 185
 186         if (image->color_space == OPJ_CLRSPC_CMYK) {
 187                 if (numcomps < 4U) {
 188                         fprintf(stderr,"imagetotif: CMYK images shall be composed of at least 4 planes.\n");
 189                         fprintf(stderr,"\tAborting\n");
 190                         return 1;
 191                 }
 192                 tiPhoto = PHOTOMETRIC_SEPARATED;
 193                 if (numcomps > 4U) {
 194                         numcomps = 4U; /* Alpha not supported */
 195                 }
 196         }
 197         else if (numcomps > 2U) {
 198                 tiPhoto = PHOTOMETRIC_RGB;
 199                 if (numcomps > 4U) {
 200                         numcomps = 4U;
 201                 }
 202         } else {
 203                 tiPhoto = PHOTOMETRIC_MINISBLACK;
 204         }
 205         for (i = 1U; i < numcomps; ++i) {
 206                 if (image->comps[0].dx != image->comps[i].dx) {
 207                         break;
 208                 }
 209                 if (image->comps[0].dy != image->comps[i].dy) {
 210                         break;
 211                 }
 212                 if (image->comps[0].prec != image->comps[i].prec) {
 213                         break;
 214                 }
 215                 if (image->comps[0].sgnd != image->comps[i].sgnd) {
 216                         break;
 217                 }
 218                 planes[i] = image->comps[i].data;
 219         }
 220         if (i != numcomps) {
 221                 fprintf(stderr,"imagetotif: All components shall have the same subsampling, same bit depth.\n");
 222                 fprintf(stderr,"\tAborting\n");
 223                 return 1;
 224         }
 225
 226         if((bps > 16) || ((bps != 1) && (bps & 1))) bps = 0;
 227         if(bps == 0)
 228         {
 229                 fprintf(stderr,"imagetotif: Bits=%d, Only 1, 2, 4, 6, 8, 10, 12, 14 and 16 bits implemented\n",bps);
 230                 fprintf(stderr,"\tAborting\n");
 231                 return 1;
 232         }
 233         tif = TIFFOpen(outfile, "wb");
 234         if (!tif)
 235         {
 236                 fprintf(stderr, "imagetotif:failed to open %s for writing\n", outfile);
 237                 return 1;
 238         }
 239         for (i = 0U; i < numcomps; ++i) {
 240                 clip_component(&(image->comps[i]), image->comps[0].prec);
 241         }
 242         cvtPxToCx = convert_32s_PXCX_LUT[numcomps];
 243         switch (bps) {
 244                 case 1:
 245                 case 2:
 246                 case 4:
 247                 case 6:
 248                 case 8:
 249                         cvt32sToTif = convert_32sXXu_C1R_LUT[bps];
 250                         break;
 251                 case 10:
 252                         cvt32sToTif = tif_32sto10u;
 253                         break;
 254                 case 12:
 255                         cvt32sToTif = tif_32sto12u;
 256                         break;
 257                 case 14:
 258                         cvt32sToTif = tif_32sto14u;
 259                         break;
 260                 case 16:
 261                         cvt32sToTif = (convert_32sXXx_C1R)tif_32sto16u;
 262                         break;
 263                 default:
 264                         /* never here */
 265                         break;
 266         }
 267         sgnd = (int)image->comps[0].sgnd;
 268         adjust = sgnd ? 1 << (image->comps[0].prec - 1) : 0;
 269         width   = (int)image->comps[0].w;
 270         height  = (int)image->comps[0].h;
 271
 272         TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
 273         TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
 274         TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, numcomps);
 275         TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
 276         TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 277         TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 278         TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, tiPhoto);
 279         TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
 280
 281         strip_size = TIFFStripSize(tif);
 282         rowStride = ((OPJ_SIZE_T)width * numcomps * (OPJ_SIZE_T)bps + 7U) / 8U;
 283         if (rowStride != (OPJ_SIZE_T)strip_size) {
 284                 fprintf(stderr, "Invalid TIFF strip size\n");
 285                 TIFFClose(tif);
 286                 return 1;
 287         }
 288         buf = _TIFFmalloc(strip_size);
 289         if (buf == NULL) {
 290                 TIFFClose(tif);
 291                 return 1;
 292         }
 293         buffer32s = (OPJ_INT32 *)malloc((OPJ_SIZE_T)width * numcomps * sizeof(OPJ_INT32));
 294         if (buffer32s == NULL) {
 295                 _TIFFfree(buf);
 296                 TIFFClose(tif);
 297                 return 1;
 298         }
 299
 300         for (i = 0; i < image->comps[0].h; ++i) {
 301                 cvtPxToCx(planes, buffer32s, (OPJ_SIZE_T)width, adjust);
 302                 cvt32sToTif(buffer32s, (OPJ_BYTE *)buf, (OPJ_SIZE_T)width * numcomps);
 303                 (void)TIFFWriteEncodedStrip(tif, i, (void*)buf, strip_size);
 304                 planes[0] += width;
 305                 planes[1] += width;
 306                 planes[2] += width;
 307                 planes[3] += width;
 308         }
 309         _TIFFfree((void*)buf);
 310         TIFFClose(tif);
 311         free(buffer32s);
 312
 313         return 0;
 314 }/* imagetotif() */
 315
 316 #define GETBITS(dest, nb) { \
 317         int needed = (nb); \
 318         unsigned int dst = 0U; \
 319         if (available == 0) { \
 320                 val = *pSrc++; \
 321                 available = 8; \
 322         } \
 323         while (needed > available) { \
 324                 dst |= val & ((1U << available) - 1U); \
 325                 needed -= available; \
 326                 dst <<= needed; \
 327                 val = *pSrc++; \
 328                 available = 8; \
 329         } \
 330         dst |= (val >> (available - needed)) & ((1U << needed) - 1U); \
 331         available -= needed; \
 332         dest = (OPJ_INT32)dst; \
 333 }
 334
 335 static void tif_3uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 336 {
 337         OPJ_SIZE_T i;
 338         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 339                 OPJ_UINT32 val0 = *pSrc++;
 340                 OPJ_UINT32 val1 = *pSrc++;
 341                 OPJ_UINT32 val2 = *pSrc++;
 342
 343                 pDst[i+0] = (OPJ_INT32)((val0 >> 5));
 344                 pDst[i+1] = (OPJ_INT32)(((val0 & 0x1FU) >> 2));
 345                 pDst[i+2] = (OPJ_INT32)(((val0 & 0x3U) << 1) | (val1 >> 7));
 346                 pDst[i+3] = (OPJ_INT32)(((val1 & 0x7FU) >> 4));
 347                 pDst[i+4] = (OPJ_INT32)(((val1 & 0xFU) >> 1));
 348                 pDst[i+5] = (OPJ_INT32)(((val1 & 0x1U) << 2) | (val2 >> 6));
 349                 pDst[i+6] = (OPJ_INT32)(((val2 & 0x3FU) >> 3));
 350                 pDst[i+7] = (OPJ_INT32)(((val2 & 0x7U)));
 351
 352         }
 353         if (length & 7U) {
 354                 unsigned int val;
 355                 int available = 0;
 356
 357                 length = length & 7U;
 358
 359                 GETBITS(pDst[i+0], 3)
 360
 361                 if (length > 1U) {
 362                         GETBITS(pDst[i+1], 3)
 363                         if (length > 2U) {
 364                                 GETBITS(pDst[i+2], 3)
 365                                 if (length > 3U) {
 366                                         GETBITS(pDst[i+3], 3)
 367                                         if (length > 4U) {
 368                                                 GETBITS(pDst[i+4], 3)
 369                                                 if (length > 5U) {
 370                                                         GETBITS(pDst[i+5], 3)
 371                                                         if (length > 6U) {
 372                                                                 GETBITS(pDst[i+6], 3)
 373                                                         }
 374                                                 }
 375                                         }
 376                                 }
 377                         }
 378                 }
 379         }
 380 }
 381 static void tif_5uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 382 {
 383         OPJ_SIZE_T i;
 384         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 385                 OPJ_UINT32 val0 = *pSrc++;
 386                 OPJ_UINT32 val1 = *pSrc++;
 387                 OPJ_UINT32 val2 = *pSrc++;
 388                 OPJ_UINT32 val3 = *pSrc++;
 389                 OPJ_UINT32 val4 = *pSrc++;
 390
 391                 pDst[i+0] = (OPJ_INT32)((val0 >> 3));
 392                 pDst[i+1] = (OPJ_INT32)(((val0 & 0x7U) << 2) | (val1 >> 6));
 393                 pDst[i+2] = (OPJ_INT32)(((val1 & 0x3FU) >> 1));
 394                 pDst[i+3] = (OPJ_INT32)(((val1 & 0x1U) << 4) | (val2 >> 4));
 395                 pDst[i+4] = (OPJ_INT32)(((val2 & 0xFU) << 1) | (val3 >> 7));
 396                 pDst[i+5] = (OPJ_INT32)(((val3 & 0x7FU) >> 2));
 397                 pDst[i+6] = (OPJ_INT32)(((val3 & 0x3U) << 3) | (val4 >> 5));
 398                 pDst[i+7] = (OPJ_INT32)(((val4 & 0x1FU)));
 399
 400         }
 401         if (length & 7U) {
 402                 unsigned int val;
 403                 int available = 0;
 404
 405                 length = length & 7U;
 406
 407                 GETBITS(pDst[i+0], 5)
 408
 409                 if (length > 1U) {
 410                         GETBITS(pDst[i+1], 5)
 411                         if (length > 2U) {
 412                                 GETBITS(pDst[i+2], 5)
 413                                 if (length > 3U) {
 414                                         GETBITS(pDst[i+3], 5)
 415                                         if (length > 4U) {
 416                                                 GETBITS(pDst[i+4], 5)
 417                                                 if (length > 5U) {
 418                                                         GETBITS(pDst[i+5], 5)
 419                                                         if (length > 6U) {
 420                                                                 GETBITS(pDst[i+6], 5)
 421                                                         }
 422                                                 }
 423                                         }
 424                                 }
 425                         }
 426                 }
 427         }
 428 }
 429 static void tif_7uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 430 {
 431         OPJ_SIZE_T i;
 432         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 433                 OPJ_UINT32 val0 = *pSrc++;
 434                 OPJ_UINT32 val1 = *pSrc++;
 435                 OPJ_UINT32 val2 = *pSrc++;
 436                 OPJ_UINT32 val3 = *pSrc++;
 437                 OPJ_UINT32 val4 = *pSrc++;
 438                 OPJ_UINT32 val5 = *pSrc++;
 439                 OPJ_UINT32 val6 = *pSrc++;
 440
 441                 pDst[i+0] = (OPJ_INT32)((val0 >> 1));
 442                 pDst[i+1] = (OPJ_INT32)(((val0 & 0x1U) << 6) | (val1 >> 2));
 443                 pDst[i+2] = (OPJ_INT32)(((val1 & 0x3U) << 5) | (val2 >> 3));
 444                 pDst[i+3] = (OPJ_INT32)(((val2 & 0x7U) << 4) | (val3 >> 4));
 445                 pDst[i+4] = (OPJ_INT32)(((val3 & 0xFU) << 3) | (val4 >> 5));
 446                 pDst[i+5] = (OPJ_INT32)(((val4 & 0x1FU) << 2) | (val5 >> 6));
 447                 pDst[i+6] = (OPJ_INT32)(((val5 & 0x3FU) << 1) | (val6 >> 7));
 448                 pDst[i+7] = (OPJ_INT32)(((val6 & 0x7FU)));
 449
 450         }
 451         if (length & 7U) {
 452                 unsigned int val;
 453                 int available = 0;
 454
 455                 length = length & 7U;
 456
 457                 GETBITS(pDst[i+0], 7)
 458
 459                 if (length > 1U) {
 460                         GETBITS(pDst[i+1], 7)
 461                         if (length > 2U) {
 462                                 GETBITS(pDst[i+2], 7)
 463                                 if (length > 3U) {
 464                                         GETBITS(pDst[i+3], 7)
 465                                         if (length > 4U) {
 466                                                 GETBITS(pDst[i+4], 7)
 467                                                 if (length > 5U) {
 468                                                         GETBITS(pDst[i+5], 7)
 469                                                         if (length > 6U) {
 470                                                                 GETBITS(pDst[i+6], 7)
 471                                                         }
 472                                                 }
 473                                         }
 474                                 }
 475                         }
 476                 }
 477         }
 478 }
 479 static void tif_9uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 480 {
 481         OPJ_SIZE_T i;
 482         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 483                 OPJ_UINT32 val0 = *pSrc++;
 484                 OPJ_UINT32 val1 = *pSrc++;
 485                 OPJ_UINT32 val2 = *pSrc++;
 486                 OPJ_UINT32 val3 = *pSrc++;
 487                 OPJ_UINT32 val4 = *pSrc++;
 488                 OPJ_UINT32 val5 = *pSrc++;
 489                 OPJ_UINT32 val6 = *pSrc++;
 490                 OPJ_UINT32 val7 = *pSrc++;
 491                 OPJ_UINT32 val8 = *pSrc++;
 492
 493                 pDst[i+0] = (OPJ_INT32)((val0 << 1) | (val1 >> 7));
 494                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x7FU) << 2) | (val2 >> 6));
 495                 pDst[i+2] = (OPJ_INT32)(((val2 & 0x3FU) << 3) | (val3 >> 5));
 496                 pDst[i+3] = (OPJ_INT32)(((val3 & 0x1FU) << 4) | (val4 >> 4));
 497                 pDst[i+4] = (OPJ_INT32)(((val4 & 0xFU) << 5) | (val5 >> 3));
 498                 pDst[i+5] = (OPJ_INT32)(((val5 & 0x7U) << 6) | (val6 >> 2));
 499                 pDst[i+6] = (OPJ_INT32)(((val6 & 0x3U) << 7) | (val7 >> 1));
 500                 pDst[i+7] = (OPJ_INT32)(((val7 & 0x1U) << 8) | (val8));
 501
 502         }
 503         if (length & 7U) {
 504                 unsigned int val;
 505                 int available = 0;
 506
 507                 length = length & 7U;
 508
 509                 GETBITS(pDst[i+0], 9)
 510
 511                 if (length > 1U) {
 512                         GETBITS(pDst[i+1], 9)
 513                         if (length > 2U) {
 514                                 GETBITS(pDst[i+2], 9)
 515                                 if (length > 3U) {
 516                                         GETBITS(pDst[i+3], 9)
 517                                         if (length > 4U) {
 518                                                 GETBITS(pDst[i+4], 9)
 519                                                 if (length > 5U) {
 520                                                         GETBITS(pDst[i+5], 9)
 521                                                         if (length > 6U) {
 522                                                                 GETBITS(pDst[i+6], 9)
 523                                                         }
 524                                                 }
 525                                         }
 526                                 }
 527                         }
 528                 }
 529         }
 530 }
 531 static void tif_10uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 532 {
 533         OPJ_SIZE_T i;
 534         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
 535                 OPJ_UINT32 val0 = *pSrc++;
 536                 OPJ_UINT32 val1 = *pSrc++;
 537                 OPJ_UINT32 val2 = *pSrc++;
 538                 OPJ_UINT32 val3 = *pSrc++;
 539                 OPJ_UINT32 val4 = *pSrc++;
 540
 541                 pDst[i+0] = (OPJ_INT32)((val0 << 2) | (val1 >> 6));
 542                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x3FU) << 4) | (val2 >> 4));
 543                 pDst[i+2] = (OPJ_INT32)(((val2 & 0xFU) << 6) | (val3 >> 2));
 544                 pDst[i+3] = (OPJ_INT32)(((val3 & 0x3U) << 8) | val4);
 545
 546         }
 547         if (length & 3U) {
 548                 OPJ_UINT32 val0 = *pSrc++;
 549                 OPJ_UINT32 val1 = *pSrc++;
 550                 length = length & 3U;
 551                 pDst[i+0] = (OPJ_INT32)((val0 << 2) | (val1 >> 6));
 552
 553                 if (length > 1U) {
 554                         OPJ_UINT32 val2 = *pSrc++;
 555                         pDst[i+1] = (OPJ_INT32)(((val1 & 0x3FU) << 4) | (val2 >> 4));
 556                         if (length > 2U) {
 557                                 OPJ_UINT32 val3 = *pSrc++;
 558                                 pDst[i+2] = (OPJ_INT32)(((val2 & 0xFU) << 6) | (val3 >> 2));
 559                         }
 560                 }
 561         }
 562 }
 563 static void tif_11uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 564 {
 565         OPJ_SIZE_T i;
 566         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 567                 OPJ_UINT32 val0 = *pSrc++;
 568                 OPJ_UINT32 val1 = *pSrc++;
 569                 OPJ_UINT32 val2 = *pSrc++;
 570                 OPJ_UINT32 val3 = *pSrc++;
 571                 OPJ_UINT32 val4 = *pSrc++;
 572                 OPJ_UINT32 val5 = *pSrc++;
 573                 OPJ_UINT32 val6 = *pSrc++;
 574                 OPJ_UINT32 val7 = *pSrc++;
 575                 OPJ_UINT32 val8 = *pSrc++;
 576                 OPJ_UINT32 val9 = *pSrc++;
 577                 OPJ_UINT32 val10 = *pSrc++;
 578
 579                 pDst[i+0] = (OPJ_INT32)((val0 << 3) | (val1 >> 5));
 580                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x1FU) << 6) | (val2 >> 2));
 581                 pDst[i+2] = (OPJ_INT32)(((val2 & 0x3U) << 9) | (val3 << 1) | (val4 >> 7));
 582                 pDst[i+3] = (OPJ_INT32)(((val4 & 0x7FU) << 4) | (val5 >> 4));
 583                 pDst[i+4] = (OPJ_INT32)(((val5 & 0xFU) << 7) | (val6 >> 1));
 584                 pDst[i+5] = (OPJ_INT32)(((val6 & 0x1U) << 10) | (val7 << 2) | (val8 >> 6));
 585                 pDst[i+6] = (OPJ_INT32)(((val8 & 0x3FU) << 5) | (val9 >> 3));
 586                 pDst[i+7] = (OPJ_INT32)(((val9 & 0x7U) << 8) | (val10));
 587
 588         }
 589         if (length & 7U) {
 590                 unsigned int val;
 591                 int available = 0;
 592
 593                 length = length & 7U;
 594
 595                 GETBITS(pDst[i+0], 11)
 596
 597                 if (length > 1U) {
 598                         GETBITS(pDst[i+1], 11)
 599                         if (length > 2U) {
 600                                 GETBITS(pDst[i+2], 11)
 601                                 if (length > 3U) {
 602                                         GETBITS(pDst[i+3], 11)
 603                                         if (length > 4U) {
 604                                                 GETBITS(pDst[i+4], 11)
 605                                                 if (length > 5U) {
 606                                                         GETBITS(pDst[i+5], 11)
 607                                                         if (length > 6U) {
 608                                                                 GETBITS(pDst[i+6], 11)
 609                                                         }
 610                                                 }
 611                                         }
 612                                 }
 613                         }
 614                 }
 615         }
 616 }
 617 static void tif_12uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 618 {
 619         OPJ_SIZE_T i;
 620         for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i+=2U) {
 621                 OPJ_UINT32 val0 = *pSrc++;
 622                 OPJ_UINT32 val1 = *pSrc++;
 623                 OPJ_UINT32 val2 = *pSrc++;
 624
 625                 pDst[i+0] = (OPJ_INT32)((val0 << 4) | (val1 >> 4));
 626                 pDst[i+1] = (OPJ_INT32)(((val1 & 0xFU) << 8) | val2);
 627         }
 628         if (length & 1U) {
 629                 OPJ_UINT32 val0 = *pSrc++;
 630                 OPJ_UINT32 val1 = *pSrc++;
 631                 pDst[i+0] = (OPJ_INT32)((val0 << 4) | (val1 >> 4));
 632         }
 633 }
 634 static void tif_13uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 635 {
 636         OPJ_SIZE_T i;
 637         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 638                 OPJ_UINT32 val0 = *pSrc++;
 639                 OPJ_UINT32 val1 = *pSrc++;
 640                 OPJ_UINT32 val2 = *pSrc++;
 641                 OPJ_UINT32 val3 = *pSrc++;
 642                 OPJ_UINT32 val4 = *pSrc++;
 643                 OPJ_UINT32 val5 = *pSrc++;
 644                 OPJ_UINT32 val6 = *pSrc++;
 645                 OPJ_UINT32 val7 = *pSrc++;
 646                 OPJ_UINT32 val8 = *pSrc++;
 647                 OPJ_UINT32 val9 = *pSrc++;
 648                 OPJ_UINT32 val10 = *pSrc++;
 649                 OPJ_UINT32 val11 = *pSrc++;
 650                 OPJ_UINT32 val12 = *pSrc++;
 651
 652                 pDst[i+0] = (OPJ_INT32)((val0 << 5) | (val1 >> 3));
 653                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x7U) << 10) | (val2 << 2) | (val3 >> 6));
 654                 pDst[i+2] = (OPJ_INT32)(((val3 & 0x3FU) << 7) | (val4 >> 1));
 655                 pDst[i+3] = (OPJ_INT32)(((val4 & 0x1U) << 12) | (val5 << 4) | (val6 >> 4));
 656                 pDst[i+4] = (OPJ_INT32)(((val6 & 0xFU) << 9) | (val7 << 1) | (val8 >> 7));
 657                 pDst[i+5] = (OPJ_INT32)(((val8 & 0x7FU) << 6) | (val9 >> 2));
 658                 pDst[i+6] = (OPJ_INT32)(((val9 & 0x3U) << 11) | (val10 << 3) | (val11 >> 5));
 659                 pDst[i+7] = (OPJ_INT32)(((val11 & 0x1FU) << 8) | (val12));
 660
 661         }
 662         if (length & 7U) {
 663                 unsigned int val;
 664                 int available = 0;
 665
 666                 length = length & 7U;
 667
 668                 GETBITS(pDst[i+0], 13)
 669
 670                 if (length > 1U) {
 671                         GETBITS(pDst[i+1], 13)
 672                         if (length > 2U) {
 673                                 GETBITS(pDst[i+2], 13)
 674                                 if (length > 3U) {
 675                                         GETBITS(pDst[i+3], 13)
 676                                         if (length > 4U) {
 677                                                 GETBITS(pDst[i+4], 13)
 678                                                 if (length > 5U) {
 679                                                         GETBITS(pDst[i+5], 13)
 680                                                         if (length > 6U) {
 681                                                                 GETBITS(pDst[i+6], 13)
 682                                                         }
 683                                                 }
 684                                         }
 685                                 }
 686                         }
 687                 }
 688         }
 689 }
 690 static void tif_14uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 691 {
 692         OPJ_SIZE_T i;
 693         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
 694                 OPJ_UINT32 val0 = *pSrc++;
 695                 OPJ_UINT32 val1 = *pSrc++;
 696                 OPJ_UINT32 val2 = *pSrc++;
 697                 OPJ_UINT32 val3 = *pSrc++;
 698                 OPJ_UINT32 val4 = *pSrc++;
 699                 OPJ_UINT32 val5 = *pSrc++;
 700                 OPJ_UINT32 val6 = *pSrc++;
 701
 702                 pDst[i+0] = (OPJ_INT32)((val0 << 6) | (val1 >> 2));
 703                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x3U) << 12) | (val2 << 4) | (val3 >> 4));
 704                 pDst[i+2] = (OPJ_INT32)(((val3 & 0xFU) << 10) | (val4 << 2) | (val5 >> 6));
 705                 pDst[i+3] = (OPJ_INT32)(((val5 & 0x3FU) << 8) | val6);
 706
 707         }
 708         if (length & 3U) {
 709                 OPJ_UINT32 val0 = *pSrc++;
 710                 OPJ_UINT32 val1 = *pSrc++;
 711                 length = length & 3U;
 712                 pDst[i+0] = (OPJ_INT32)((val0 << 6) | (val1 >> 2));
 713
 714                 if (length > 1U) {
 715                         OPJ_UINT32 val2 = *pSrc++;
 716                         OPJ_UINT32 val3 = *pSrc++;
 717                         pDst[i+1] = (OPJ_INT32)(((val1 & 0x3U) << 12) | (val2 << 4) | (val3 >> 4));
 718                         if (length > 2U) {
 719                                 OPJ_UINT32 val4 = *pSrc++;
 720                                 OPJ_UINT32 val5 = *pSrc++;
 721                                 pDst[i+2] = (OPJ_INT32)(((val3 & 0xFU) << 10) | (val4 << 2) | (val5 >> 6));
 722                         }
 723                 }
 724         }
 725 }
 726 static void tif_15uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 727 {
 728         OPJ_SIZE_T i;
 729         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 730                 OPJ_UINT32 val0 = *pSrc++;
 731                 OPJ_UINT32 val1 = *pSrc++;
 732                 OPJ_UINT32 val2 = *pSrc++;
 733                 OPJ_UINT32 val3 = *pSrc++;
 734                 OPJ_UINT32 val4 = *pSrc++;
 735                 OPJ_UINT32 val5 = *pSrc++;
 736                 OPJ_UINT32 val6 = *pSrc++;
 737                 OPJ_UINT32 val7 = *pSrc++;
 738                 OPJ_UINT32 val8 = *pSrc++;
 739                 OPJ_UINT32 val9 = *pSrc++;
 740                 OPJ_UINT32 val10 = *pSrc++;
 741                 OPJ_UINT32 val11 = *pSrc++;
 742                 OPJ_UINT32 val12 = *pSrc++;
 743                 OPJ_UINT32 val13 = *pSrc++;
 744                 OPJ_UINT32 val14 = *pSrc++;
 745
 746                 pDst[i+0] = (OPJ_INT32)((val0 << 7) | (val1 >> 1));
 747                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x1U) << 14) | (val2 << 6) | (val3 >> 2));
 748                 pDst[i+2] = (OPJ_INT32)(((val3 & 0x3U) << 13) | (val4 << 5) | (val5 >> 3));
 749                 pDst[i+3] = (OPJ_INT32)(((val5 & 0x7U) << 12) | (val6 << 4) | (val7 >> 4));
 750                 pDst[i+4] = (OPJ_INT32)(((val7 & 0xFU) << 11) | (val8 << 3) | (val9 >> 5));
 751                 pDst[i+5] = (OPJ_INT32)(((val9 & 0x1FU) << 10) | (val10 << 2) | (val11 >> 6));
 752                 pDst[i+6] = (OPJ_INT32)(((val11 & 0x3FU) << 9) | (val12 << 1) | (val13 >> 7));
 753                 pDst[i+7] = (OPJ_INT32)(((val13 & 0x7FU) << 8) | (val14));
 754
 755         }
 756         if (length & 7U) {
 757                 unsigned int val;
 758                 int available = 0;
 759
 760                 length = length & 7U;
 761
 762                 GETBITS(pDst[i+0], 15)
 763
 764                 if (length > 1U) {
 765                         GETBITS(pDst[i+1], 15)
 766                         if (length > 2U) {
 767                                 GETBITS(pDst[i+2], 15)
 768                                 if (length > 3U) {
 769                                         GETBITS(pDst[i+3], 15)
 770                                         if (length > 4U) {
 771                                                 GETBITS(pDst[i+4], 15)
 772                                                 if (length > 5U) {
 773                                                         GETBITS(pDst[i+5], 15)
 774                                                         if (length > 6U) {
 775                                                                 GETBITS(pDst[i+6], 15)
 776                                                         }
 777                                                 }
 778                                         }
 779                                 }
 780                         }
 781                 }
 782         }
 783 }
 784
 785 /* seems that libtiff decodes this to machine endianness */
 786 static void tif_16uto32s(const OPJ_UINT16* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 787 {
 788         OPJ_SIZE_T i;
 789         for (i = 0; i < length; i++) {
 790                 pDst[i] = pSrc[i];
 791         }
 792 }
 793
 794 /*
 795  * libtiff/tif_getimage.c : 1,2,4,8,16 bitspersample accepted
 796  * CINEMA                 : 12 bit precision
 797  */
 798 opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters)
 799 {
 800         int subsampling_dx = parameters->subsampling_dx;
 801         int subsampling_dy = parameters->subsampling_dy;
 802         TIFF *tif;
 803         tdata_t buf;
 804         tstrip_t strip;
 805         tsize_t strip_size;
 806         int j, currentPlane, numcomps = 0, w, h;
 807         OPJ_COLOR_SPACE color_space = OPJ_CLRSPC_UNKNOWN;
 808         opj_image_cmptparm_t cmptparm[4]; /* RGBA */
 809         opj_image_t *image = NULL;
 810         int has_alpha = 0;
 811         unsigned short tiBps, tiPhoto, tiSf, tiSpp, tiPC;
 812         unsigned int tiWidth, tiHeight;
 813         OPJ_BOOL is_cinema = OPJ_IS_CINEMA(parameters->rsiz);
 814         convert_XXx32s_C1R cvtTifTo32s = NULL;
 815         convert_32s_CXPX cvtCxToPx = NULL;
 816         OPJ_INT32* buffer32s = NULL;
 817         OPJ_INT32* planes[4];
 818         OPJ_SIZE_T rowStride;
 819
 820         tif = TIFFOpen(filename, "r");
 821
 822         if(!tif)
 823         {
 824                 fprintf(stderr, "tiftoimage:Failed to open %s for reading\n", filename);
 825                 return 0;
 826         }
 827         tiBps = tiPhoto = tiSf = tiSpp = tiPC = 0;
 828         tiWidth = tiHeight = 0;
 829
 830         TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &tiWidth);
 831         TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &tiHeight);
 832         TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &tiBps);
 833         TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &tiSf);
 834         TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &tiSpp);
 835         TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &tiPhoto);
 836         TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &tiPC);
 837         w= (int)tiWidth;
 838         h= (int)tiHeight;
 839
 840         if(tiBps > 16U) {
 841                 fprintf(stderr,"tiftoimage: Bits=%d, Only 1 to 16 bits implemented\n",tiBps);
 842                 fprintf(stderr,"\tAborting\n");
 843                 TIFFClose(tif);
 844                 return NULL;
 845         }
 846         if(tiPhoto != PHOTOMETRIC_MINISBLACK && tiPhoto != PHOTOMETRIC_RGB) {
 847                 fprintf(stderr,"tiftoimage: Bad color format %d.\n\tOnly RGB(A) and GRAY(A) has been implemented\n",(int) tiPhoto);
 848                 fprintf(stderr,"\tAborting\n");
 849                 TIFFClose(tif);
 850                 return NULL;
 851         }
 852
 853         switch (tiBps) {
 854                 case 1:
 855                 case 2:
 856                 case 4:
 857                 case 6:
 858                 case 8:
 859                         cvtTifTo32s = convert_XXu32s_C1R_LUT[tiBps];
 860                         break;
 861                 /* others are specific to TIFF */
 862                 case 3:
 863                         cvtTifTo32s = tif_3uto32s;
 864                         break;
 865                 case 5:
 866                         cvtTifTo32s = tif_5uto32s;
 867                         break;
 868                 case 7:
 869                         cvtTifTo32s = tif_7uto32s;
 870                         break;
 871                 case 9:
 872                         cvtTifTo32s = tif_9uto32s;
 873                         break;
 874                 case 10:
 875                         cvtTifTo32s = tif_10uto32s;
 876                         break;
 877                 case 11:
 878                         cvtTifTo32s = tif_11uto32s;
 879                         break;
 880                 case 12:
 881                         cvtTifTo32s = tif_12uto32s;
 882                         break;
 883                 case 13:
 884                         cvtTifTo32s = tif_13uto32s;
 885                         break;
 886                 case 14:
 887                         cvtTifTo32s = tif_14uto32s;
 888                         break;
 889                 case 15:
 890                         cvtTifTo32s = tif_15uto32s;
 891                         break;
 892                 case 16:
 893                         cvtTifTo32s = (convert_XXx32s_C1R)tif_16uto32s;
 894                         break;
 895                 default:
 896                         /* never here */
 897                         break;
 898         }
 899
 900         {/* From: tiff-4.0.x/libtiff/tif_getimage.c : */
 901                 uint16* sampleinfo;
 902                 uint16 extrasamples;
 903
 904                 TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
 905                                                                                                         &extrasamples, &sampleinfo);
 906
 907                 if(extrasamples >= 1)
 908                 {
 909                         switch(sampleinfo[0])
 910                         {
 911                                 case EXTRASAMPLE_UNSPECIFIED:
 912                                         /* Workaround for some images without correct info about alpha channel
 913                                          */
 914                                         if(tiSpp > 3)
 915                                                 has_alpha = 1;
 916                                         break;
 917
 918                                 case EXTRASAMPLE_ASSOCALPHA: /* data pre-multiplied */
 919                                 case EXTRASAMPLE_UNASSALPHA: /* data not pre-multiplied */
 920                                         has_alpha = 1;
 921                                         break;
 922                         }
 923                 }
 924                 else /* extrasamples == 0 */
 925                         if(tiSpp == 4 || tiSpp == 2) has_alpha = 1;
 926         }
 927
 928         /* initialize image components */
 929         memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
 930
 931         if ((tiPhoto == PHOTOMETRIC_RGB) && (is_cinema) && (tiBps != 12U)) {
 932                 fprintf(stdout,"WARNING:\n"
 933                                                 "Input image bitdepth is %d bits\n"
 934                                                 "TIF conversion has automatically rescaled to 12-bits\n"
 935                                                 "to comply with cinema profiles.\n",
 936                                                 tiBps);
 937         } else {
 938                 is_cinema = 0U;
 939         }
 940
 941         if(tiPhoto == PHOTOMETRIC_RGB) /* RGB(A) */
 942         {
 943                 numcomps = 3 + has_alpha;
 944                 color_space = OPJ_CLRSPC_SRGB;
 945         }
 946         else if (tiPhoto == PHOTOMETRIC_MINISBLACK) /* GRAY(A) */
 947         {
 948                 numcomps = 1 + has_alpha;
 949                 color_space = OPJ_CLRSPC_GRAY;
 950         }
 951
 952         cvtCxToPx = convert_32s_CXPX_LUT[numcomps];
 953         if (tiPC == PLANARCONFIG_SEPARATE) {
 954                 cvtCxToPx = convert_32s_CXPX_LUT[1]; /* override */
 955                 tiSpp = 1U; /* consider only one sample per plane */
 956         }
 957
 958         for(j = 0; j < numcomps; j++)
 959         {
 960                 cmptparm[j].prec = tiBps;
 961                 cmptparm[j].bpp = tiBps;
 962                 cmptparm[j].dx = (OPJ_UINT32)subsampling_dx;
 963                 cmptparm[j].dy = (OPJ_UINT32)subsampling_dy;
 964                 cmptparm[j].w = (OPJ_UINT32)w;
 965                 cmptparm[j].h = (OPJ_UINT32)h;
 966         }
 967
 968         image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
 969         if(!image)
 970         {
 971                 TIFFClose(tif);
 972                 return NULL;
 973         }
 974         /* set image offset and reference grid */
 975         image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
 976         image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
 977         image->x1 =     !image->x0 ? (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1 :
 978         image->x0 + (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1;
 979         image->y1 =     !image->y0 ? (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1 :
 980         image->y0 + (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1;
 981
 982         for(j = 0; j < numcomps; j++)
 983         {
 984                 planes[j] = image->comps[j].data;
 985         }
 986         image->comps[numcomps - 1].alpha = (OPJ_UINT16)(1 - (numcomps & 1));
 987
 988         strip_size = TIFFStripSize(tif);
 989
 990         buf = _TIFFmalloc(strip_size);
 991         if (buf == NULL) {
 992                 TIFFClose(tif);
 993                 opj_image_destroy(image);
 994                 return NULL;
 995         }
 996         rowStride = ((OPJ_SIZE_T)w * tiSpp * tiBps + 7U) / 8U;
 997         buffer32s = (OPJ_INT32 *)malloc((OPJ_SIZE_T)w * tiSpp * sizeof(OPJ_INT32));
 998         if (buffer32s == NULL) {
 999                 _TIFFfree(buf);
1000                 TIFFClose(tif);
1001                 opj_image_destroy(image);
1002                 return NULL;
1003         }
1004
1005         strip = 0;
1006         currentPlane = 0;
1007         do
1008         {
1009                 planes[0] = image->comps[currentPlane].data; /* to manage planar data */
1010                 h= (int)tiHeight;
1011                 /* Read the Image components */
1012                 for(; (h > 0) && (strip < TIFFNumberOfStrips(tif)); strip++)
1013                 {
1014                                 const OPJ_UINT8 *dat8;
1015                                 OPJ_SIZE_T ssize;
1016
1017                                 ssize = (OPJ_SIZE_T)TIFFReadEncodedStrip(tif, strip, buf, strip_size);
1018                                 dat8 = (const OPJ_UINT8*)buf;
1019
1020                                 while (ssize >= rowStride) {
1021                                         cvtTifTo32s(dat8, buffer32s, (OPJ_SIZE_T)w * tiSpp);
1022                                         cvtCxToPx(buffer32s, planes, (OPJ_SIZE_T)w);
1023                                         planes[0] += w;
1024                                         planes[1] += w;
1025                                         planes[2] += w;
1026                                         planes[3] += w;
1027                                         dat8  += rowStride;
1028                                         ssize -= rowStride;
1029                                         h--;
1030                                 }
1031                 }
1032                 currentPlane++;
1033         } while ((tiPC == PLANARCONFIG_SEPARATE) && (currentPlane < numcomps));
1034
1035         free(buffer32s);
1036         _TIFFfree(buf);
1037         TIFFClose(tif);
1038
1039         if (is_cinema) {
1040                 for (j=0; j < numcomps; ++j) {
1041                         scale_component(&(image->comps[j]), 12);
1042                 }
1043
1044         }
1045         return image;
1046
1047 }/* tiftoimage() */
1048