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 #define PUTBITS2(s, nb) \
  60         trailing <<= remaining; \
  61         trailing |= (unsigned int)((s) >> (nb - remaining)); \
  62         *pDst++ = (OPJ_BYTE)trailing; \
  63         trailing = (unsigned int)((s) & ((1U << (nb - remaining)) - 1U)); \
  64         if (nb >= (remaining + 8)) { \
  65                 *pDst++ = (OPJ_BYTE)(trailing >> (nb - (remaining + 8))); \
  66                 trailing &= (unsigned int)((1U << (nb - (remaining + 8))) - 1U); \
  67                 remaining += 16 - nb; \
  68         } else { \
  69                 remaining += 8 - nb; \
  70         }
  71
  72 #define PUTBITS(s, nb) \
  73   if (nb >= remaining) { \
  74                 PUTBITS2(s, nb) \
  75         } else { \
  76                 trailing <<= nb; \
  77                 trailing |= (unsigned int)(s); \
  78                 remaining -= nb; \
  79         }
  80 #define FLUSHBITS() \
  81         if (remaining != 8) { \
  82                 trailing <<= remaining; \
  83                 *pDst++ = (OPJ_BYTE)trailing; \
  84         }
  85
  86 static void tif_32sto3u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
  87 {
  88         OPJ_SIZE_T i;
  89
  90         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
  91                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
  92                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
  93                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
  94                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
  95                 OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i+4];
  96                 OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i+5];
  97                 OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i+6];
  98                 OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i+7];
  99
 100                 *pDst++ = (OPJ_BYTE)((src0 << 5) | (src1 << 2) | (src2 >> 1));
 101                 *pDst++ = (OPJ_BYTE)((src2 << 7) | (src3 << 4) | (src4 << 1) | (src5 >> 2));
 102                 *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 << 3) | (src7));
 103         }
 104
 105         if (length & 7U) {
 106                 unsigned int trailing = 0U;
 107                 int remaining = 8U;
 108                 length &= 7U;
 109                 PUTBITS((OPJ_UINT32)pSrc[i+0], 3)
 110                 if (length > 1U) {
 111                         PUTBITS((OPJ_UINT32)pSrc[i+1], 3)
 112                         if (length > 2U) {
 113                                 PUTBITS((OPJ_UINT32)pSrc[i+2], 3)
 114                                 if (length > 3U) {
 115                                         PUTBITS((OPJ_UINT32)pSrc[i+3], 3)
 116                                         if (length > 4U) {
 117                                                 PUTBITS((OPJ_UINT32)pSrc[i+4], 3)
 118                                                 if (length > 5U) {
 119                                                         PUTBITS((OPJ_UINT32)pSrc[i+5], 3)
 120                                                         if (length > 6U) {
 121                                                                 PUTBITS((OPJ_UINT32)pSrc[i+6], 3)
 122                                                         }
 123                                                 }
 124                                         }
 125                                 }
 126                         }
 127                 }
 128                 FLUSHBITS()
 129         }
 130 }
 131
 132 static void tif_32sto5u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 133 {
 134         OPJ_SIZE_T i;
 135
 136         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 137                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 138                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 139                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 140                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 141                 OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i+4];
 142                 OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i+5];
 143                 OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i+6];
 144                 OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i+7];
 145
 146                 *pDst++ = (OPJ_BYTE)((src0 << 3) | (src1 >> 2));
 147                 *pDst++ = (OPJ_BYTE)((src1 << 6) | (src2 << 1) | (src3 >> 4));
 148                 *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 1));
 149                 *pDst++ = (OPJ_BYTE)((src4 << 7) | (src5 << 2) | (src6 >> 3));
 150                 *pDst++ = (OPJ_BYTE)((src6 << 5) | (src7));
 151
 152         }
 153
 154         if (length & 7U) {
 155                 unsigned int trailing = 0U;
 156                 int remaining = 8U;
 157                 length &= 7U;
 158                 PUTBITS((OPJ_UINT32)pSrc[i+0], 5)
 159                 if (length > 1U) {
 160                         PUTBITS((OPJ_UINT32)pSrc[i+1], 5)
 161                         if (length > 2U) {
 162                                 PUTBITS((OPJ_UINT32)pSrc[i+2], 5)
 163                                 if (length > 3U) {
 164                                         PUTBITS((OPJ_UINT32)pSrc[i+3], 5)
 165                                         if (length > 4U) {
 166                                                 PUTBITS((OPJ_UINT32)pSrc[i+4], 5)
 167                                                 if (length > 5U) {
 168                                                         PUTBITS((OPJ_UINT32)pSrc[i+5], 5)
 169                                                         if (length > 6U) {
 170                                                                 PUTBITS((OPJ_UINT32)pSrc[i+6], 5)
 171                                                         }
 172                                                 }
 173                                         }
 174                                 }
 175                         }
 176                 }
 177                 FLUSHBITS()
 178         }
 179 }
 180
 181 static void tif_32sto7u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 182 {
 183         OPJ_SIZE_T i;
 184
 185         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 186                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 187                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 188                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 189                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 190                 OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i+4];
 191                 OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i+5];
 192                 OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i+6];
 193                 OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i+7];
 194
 195                 *pDst++ = (OPJ_BYTE)((src0 << 1) | (src1 >> 6));
 196                 *pDst++ = (OPJ_BYTE)((src1 << 2) | (src2 >> 5));
 197                 *pDst++ = (OPJ_BYTE)((src2 << 3) | (src3 >> 4));
 198                 *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 3));
 199                 *pDst++ = (OPJ_BYTE)((src4 << 5) | (src5 >> 2));
 200                 *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 >> 1));
 201                 *pDst++ = (OPJ_BYTE)((src6 << 7) | (src7));
 202         }
 203
 204         if (length & 7U) {
 205                 unsigned int trailing = 0U;
 206                 int remaining = 8U;
 207                 length &= 7U;
 208                 PUTBITS((OPJ_UINT32)pSrc[i+0], 7)
 209                 if (length > 1U) {
 210                         PUTBITS((OPJ_UINT32)pSrc[i+1], 7)
 211                         if (length > 2U) {
 212                                 PUTBITS((OPJ_UINT32)pSrc[i+2], 7)
 213                                 if (length > 3U) {
 214                                         PUTBITS((OPJ_UINT32)pSrc[i+3], 7)
 215                                         if (length > 4U) {
 216                                                 PUTBITS((OPJ_UINT32)pSrc[i+4], 7)
 217                                                 if (length > 5U) {
 218                                                         PUTBITS((OPJ_UINT32)pSrc[i+5], 7)
 219                                                         if (length > 6U) {
 220                                                                 PUTBITS((OPJ_UINT32)pSrc[i+6], 7)
 221                                                         }
 222                                                 }
 223                                         }
 224                                 }
 225                         }
 226                 }
 227                 FLUSHBITS()
 228         }
 229 }
 230
 231 static void tif_32sto9u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 232 {
 233         OPJ_SIZE_T i;
 234
 235         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 236                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 237                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 238                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 239                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 240                 OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i+4];
 241                 OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i+5];
 242                 OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i+6];
 243                 OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i+7];
 244
 245                 *pDst++ = (OPJ_BYTE)((src0 >> 1));
 246                 *pDst++ = (OPJ_BYTE)((src0 << 7) | (src1 >> 2));
 247                 *pDst++ = (OPJ_BYTE)((src1 << 6) | (src2 >> 3));
 248                 *pDst++ = (OPJ_BYTE)((src2 << 5) | (src3 >> 4));
 249                 *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 5));
 250                 *pDst++ = (OPJ_BYTE)((src4 << 3) | (src5 >> 6));
 251                 *pDst++ = (OPJ_BYTE)((src5 << 2) | (src6 >> 7));
 252                 *pDst++ = (OPJ_BYTE)((src6 << 1) | (src7 >> 8));
 253                 *pDst++ = (OPJ_BYTE)(src7);
 254         }
 255
 256         if (length & 7U) {
 257                 unsigned int trailing = 0U;
 258                 int remaining = 8U;
 259                 length &= 7U;
 260                 PUTBITS2((OPJ_UINT32)pSrc[i+0], 9)
 261                 if (length > 1U) {
 262                         PUTBITS2((OPJ_UINT32)pSrc[i+1], 9)
 263                         if (length > 2U) {
 264                                 PUTBITS2((OPJ_UINT32)pSrc[i+2], 9)
 265                                 if (length > 3U) {
 266                                         PUTBITS2((OPJ_UINT32)pSrc[i+3], 9)
 267                                         if (length > 4U) {
 268                                                 PUTBITS2((OPJ_UINT32)pSrc[i+4], 9)
 269                                                 if (length > 5U) {
 270                                                         PUTBITS2((OPJ_UINT32)pSrc[i+5], 9)
 271                                                         if (length > 6U) {
 272                                                                 PUTBITS2((OPJ_UINT32)pSrc[i+6], 9)
 273                                                         }
 274                                                 }
 275                                         }
 276                                 }
 277                         }
 278                 }
 279                 FLUSHBITS()
 280         }
 281 }
 282
 283 static void tif_32sto10u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 284 {
 285         OPJ_SIZE_T i;
 286         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
 287                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 288                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 289                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 290                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 291
 292                 *pDst++ = (OPJ_BYTE)(src0 >> 2);
 293                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3U) << 6) | (src1 >> 4));
 294                 *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 6));
 295                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3FU) << 2) | (src3 >> 8));
 296                 *pDst++ = (OPJ_BYTE)(src3);
 297         }
 298
 299         if (length & 3U) {
 300                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 301                 OPJ_UINT32 src1 = 0U;
 302                 OPJ_UINT32 src2 = 0U;
 303                 length = length & 3U;
 304
 305                 if (length > 1U) {
 306                         src1 = (OPJ_UINT32)pSrc[i+1];
 307                         if (length > 2U) {
 308                                 src2 = (OPJ_UINT32)pSrc[i+2];
 309                         }
 310                 }
 311                 *pDst++ = (OPJ_BYTE)(src0 >> 2);
 312                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3U) << 6) | (src1 >> 4));
 313                 if (length > 1U) {
 314                         *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 6));
 315                         if (length > 2U) {
 316                                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3FU) << 2));
 317                         }
 318                 }
 319         }
 320 }
 321 static void tif_32sto11u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 322 {
 323         OPJ_SIZE_T i;
 324
 325         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 326                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 327                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 328                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 329                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 330                 OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i+4];
 331                 OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i+5];
 332                 OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i+6];
 333                 OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i+7];
 334
 335                 *pDst++ = (OPJ_BYTE)((src0 >> 3));
 336                 *pDst++ = (OPJ_BYTE)((src0 << 5) | (src1 >> 6));
 337                 *pDst++ = (OPJ_BYTE)((src1 << 2) | (src2 >> 9));
 338                 *pDst++ = (OPJ_BYTE)((src2 >> 1));
 339                 *pDst++ = (OPJ_BYTE)((src2 << 7) | (src3 >> 4));
 340                 *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 7));
 341                 *pDst++ = (OPJ_BYTE)((src4 << 1) | (src5 >> 10));
 342                 *pDst++ = (OPJ_BYTE)((src5 >> 2));
 343                 *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 >> 5));
 344                 *pDst++ = (OPJ_BYTE)((src6 << 3) | (src7 >> 8));
 345                 *pDst++ = (OPJ_BYTE)(src7);
 346         }
 347
 348         if (length & 7U) {
 349                 unsigned int trailing = 0U;
 350                 int remaining = 8U;
 351                 length &= 7U;
 352                 PUTBITS2((OPJ_UINT32)pSrc[i+0], 11)
 353                 if (length > 1U) {
 354                         PUTBITS2((OPJ_UINT32)pSrc[i+1], 11)
 355                         if (length > 2U) {
 356                                 PUTBITS2((OPJ_UINT32)pSrc[i+2], 11)
 357                                 if (length > 3U) {
 358                                         PUTBITS2((OPJ_UINT32)pSrc[i+3], 11)
 359                                         if (length > 4U) {
 360                                                 PUTBITS2((OPJ_UINT32)pSrc[i+4], 11)
 361                                                 if (length > 5U) {
 362                                                         PUTBITS2((OPJ_UINT32)pSrc[i+5], 11)
 363                                                         if (length > 6U) {
 364                                                                 PUTBITS2((OPJ_UINT32)pSrc[i+6], 11)
 365                                                         }
 366                                                 }
 367                                         }
 368                                 }
 369                         }
 370                 }
 371                 FLUSHBITS()
 372         }
 373 }
 374 static void tif_32sto12u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 375 {
 376         OPJ_SIZE_T i;
 377         for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i+=2U) {
 378                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 379                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 380
 381                 *pDst++ = (OPJ_BYTE)(src0 >> 4);
 382                 *pDst++ = (OPJ_BYTE)(((src0 & 0xFU) << 4) | (src1 >> 8));
 383                 *pDst++ = (OPJ_BYTE)(src1);
 384         }
 385
 386         if (length & 1U) {
 387                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 388                 *pDst++ = (OPJ_BYTE)(src0 >> 4);
 389                 *pDst++ = (OPJ_BYTE)(((src0 & 0xFU) << 4));
 390         }
 391 }
 392 static void tif_32sto13u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 393 {
 394         OPJ_SIZE_T i;
 395
 396         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 397                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 398                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 399                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 400                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 401                 OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i+4];
 402                 OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i+5];
 403                 OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i+6];
 404                 OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i+7];
 405
 406                 *pDst++ = (OPJ_BYTE)((src0 >> 5));
 407                 *pDst++ = (OPJ_BYTE)((src0 << 3) | (src1 >> 10));
 408                 *pDst++ = (OPJ_BYTE)((src1 >> 2));
 409                 *pDst++ = (OPJ_BYTE)((src1 << 6) | (src2 >> 7));
 410                 *pDst++ = (OPJ_BYTE)((src2 << 1) | (src3 >> 12));
 411                 *pDst++ = (OPJ_BYTE)((src3 >> 4));
 412                 *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 9));
 413                 *pDst++ = (OPJ_BYTE)((src4 >> 1));
 414                 *pDst++ = (OPJ_BYTE)((src4 << 7) | (src5 >> 6));
 415                 *pDst++ = (OPJ_BYTE)((src5 << 2) | (src6 >> 11));
 416                 *pDst++ = (OPJ_BYTE)((src6 >> 3));
 417                 *pDst++ = (OPJ_BYTE)((src6 << 5) | (src7 >> 8));
 418                 *pDst++ = (OPJ_BYTE)(src7);
 419         }
 420
 421         if (length & 7U) {
 422                 unsigned int trailing = 0U;
 423                 int remaining = 8U;
 424                 length &= 7U;
 425                 PUTBITS2((OPJ_UINT32)pSrc[i+0], 13)
 426                 if (length > 1U) {
 427                         PUTBITS2((OPJ_UINT32)pSrc[i+1], 13)
 428                         if (length > 2U) {
 429                                 PUTBITS2((OPJ_UINT32)pSrc[i+2], 13)
 430                                 if (length > 3U) {
 431                                         PUTBITS2((OPJ_UINT32)pSrc[i+3], 13)
 432                                         if (length > 4U) {
 433                                                 PUTBITS2((OPJ_UINT32)pSrc[i+4], 13)
 434                                                 if (length > 5U) {
 435                                                         PUTBITS2((OPJ_UINT32)pSrc[i+5], 13)
 436                                                         if (length > 6U) {
 437                                                                 PUTBITS2((OPJ_UINT32)pSrc[i+6], 13)
 438                                                         }
 439                                                 }
 440                                         }
 441                                 }
 442                         }
 443                 }
 444                 FLUSHBITS()
 445         }
 446 }
 447 static void tif_32sto14u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 448 {
 449         OPJ_SIZE_T i;
 450         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
 451                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 452                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 453                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 454                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 455
 456                 *pDst++ = (OPJ_BYTE)(src0 >> 6);
 457                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3FU) << 2) | (src1 >> 12));
 458                 *pDst++ = (OPJ_BYTE)(src1 >> 4);
 459                 *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 10));
 460                 *pDst++ = (OPJ_BYTE)(src2 >> 2);
 461                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6) | (src3 >> 8));
 462                 *pDst++ = (OPJ_BYTE)(src3);
 463         }
 464
 465         if (length & 3U) {
 466                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 467                 OPJ_UINT32 src1 = 0U;
 468                 OPJ_UINT32 src2 = 0U;
 469                 length = length & 3U;
 470
 471                 if (length > 1U) {
 472                         src1 = (OPJ_UINT32)pSrc[i+1];
 473                         if (length > 2U) {
 474                                 src2 = (OPJ_UINT32)pSrc[i+2];
 475                         }
 476                 }
 477                 *pDst++ = (OPJ_BYTE)(src0 >> 6);
 478                 *pDst++ = (OPJ_BYTE)(((src0 & 0x3FU) << 2) | (src1 >> 12));
 479                 if (length > 1U) {
 480                         *pDst++ = (OPJ_BYTE)(src1 >> 4);
 481                         *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 10));
 482                         if (length > 2U) {
 483                                 *pDst++ = (OPJ_BYTE)(src2 >> 2);
 484                                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6));
 485                         }
 486                 }
 487         }
 488 }
 489 static void tif_32sto15u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst, OPJ_SIZE_T length)
 490 {
 491         OPJ_SIZE_T i;
 492
 493         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 494                 OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i+0];
 495                 OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i+1];
 496                 OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i+2];
 497                 OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i+3];
 498                 OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i+4];
 499                 OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i+5];
 500                 OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i+6];
 501                 OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i+7];
 502
 503                 *pDst++ = (OPJ_BYTE)((src0 >> 7));
 504                 *pDst++ = (OPJ_BYTE)((src0 << 1) | (src1 >> 14));
 505                 *pDst++ = (OPJ_BYTE)((src1 >> 6));
 506                 *pDst++ = (OPJ_BYTE)((src1 << 2) | (src2 >> 13));
 507                 *pDst++ = (OPJ_BYTE)((src2 >> 5));
 508                 *pDst++ = (OPJ_BYTE)((src2 << 3) | (src3 >> 12));
 509                 *pDst++ = (OPJ_BYTE)((src3 >> 4));
 510                 *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 11));
 511                 *pDst++ = (OPJ_BYTE)((src4 >> 3));
 512                 *pDst++ = (OPJ_BYTE)((src4 << 5) | (src5 >> 10));
 513                 *pDst++ = (OPJ_BYTE)((src5 >> 2));
 514                 *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 >> 9));
 515                 *pDst++ = (OPJ_BYTE)((src6 >> 1));
 516                 *pDst++ = (OPJ_BYTE)((src6 << 7) | (src7 >> 8));
 517                 *pDst++ = (OPJ_BYTE)(src7);
 518         }
 519
 520         if (length & 7U) {
 521                 unsigned int trailing = 0U;
 522                 int remaining = 8U;
 523                 length &= 7U;
 524                 PUTBITS2((OPJ_UINT32)pSrc[i+0], 15)
 525                 if (length > 1U) {
 526                         PUTBITS2((OPJ_UINT32)pSrc[i+1], 15)
 527                         if (length > 2U) {
 528                                 PUTBITS2((OPJ_UINT32)pSrc[i+2], 15)
 529                                 if (length > 3U) {
 530                                         PUTBITS2((OPJ_UINT32)pSrc[i+3], 15)
 531                                         if (length > 4U) {
 532                                                 PUTBITS2((OPJ_UINT32)pSrc[i+4], 15)
 533                                                 if (length > 5U) {
 534                                                         PUTBITS2((OPJ_UINT32)pSrc[i+5], 15)
 535                                                         if (length > 6U) {
 536                                                                 PUTBITS2((OPJ_UINT32)pSrc[i+6], 15)
 537                                                         }
 538                                                 }
 539                                         }
 540                                 }
 541                         }
 542                 }
 543                 FLUSHBITS()
 544         }
 545 }
 546 static void tif_32sto16u(const OPJ_INT32* pSrc, OPJ_UINT16* pDst, OPJ_SIZE_T length)
 547 {
 548         OPJ_SIZE_T i;
 549         for (i = 0; i < length; ++i) {
 550                 pDst[i] = (OPJ_UINT16)pSrc[i];
 551         }
 552 }
 553
 554 int imagetotif(opj_image_t * image, const char *outfile)
 555 {
 556         int width, height;
 557         int bps,adjust, sgnd;
 558         int tiPhoto;
 559         TIFF *tif;
 560         tdata_t buf;
 561         tsize_t strip_size;
 562         OPJ_UINT32 i, numcomps;
 563         OPJ_SIZE_T rowStride;
 564         OPJ_INT32* buffer32s = NULL;
 565         OPJ_INT32 const* planes[4];
 566         convert_32s_PXCX cvtPxToCx = NULL;
 567         convert_32sXXx_C1R cvt32sToTif = NULL;
 568
 569         bps = (int)image->comps[0].prec;
 570         planes[0] = image->comps[0].data;
 571
 572         numcomps = image->numcomps;
 573
 574         if (image->color_space == OPJ_CLRSPC_CMYK) {
 575                 if (numcomps < 4U) {
 576                         fprintf(stderr,"imagetotif: CMYK images shall be composed of at least 4 planes.\n");
 577                         fprintf(stderr,"\tAborting\n");
 578                         return 1;
 579                 }
 580                 tiPhoto = PHOTOMETRIC_SEPARATED;
 581                 if (numcomps > 4U) {
 582                         numcomps = 4U; /* Alpha not supported */
 583                 }
 584         }
 585         else if (numcomps > 2U) {
 586                 tiPhoto = PHOTOMETRIC_RGB;
 587                 if (numcomps > 4U) {
 588                         numcomps = 4U;
 589                 }
 590         } else {
 591                 tiPhoto = PHOTOMETRIC_MINISBLACK;
 592         }
 593         for (i = 1U; i < numcomps; ++i) {
 594                 if (image->comps[0].dx != image->comps[i].dx) {
 595                         break;
 596                 }
 597                 if (image->comps[0].dy != image->comps[i].dy) {
 598                         break;
 599                 }
 600                 if (image->comps[0].prec != image->comps[i].prec) {
 601                         break;
 602                 }
 603                 if (image->comps[0].sgnd != image->comps[i].sgnd) {
 604                         break;
 605                 }
 606                 planes[i] = image->comps[i].data;
 607         }
 608         if (i != numcomps) {
 609                 fprintf(stderr,"imagetotif: All components shall have the same subsampling, same bit depth.\n");
 610                 fprintf(stderr,"\tAborting\n");
 611                 return 1;
 612         }
 613
 614         if(bps > 16) bps = 0;
 615         if(bps == 0)
 616         {
 617                 fprintf(stderr,"imagetotif: Bits=%d, Only 1 to 16 bits implemented\n",bps);
 618                 fprintf(stderr,"\tAborting\n");
 619                 return 1;
 620         }
 621         tif = TIFFOpen(outfile, "wb");
 622         if (!tif)
 623         {
 624                 fprintf(stderr, "imagetotif:failed to open %s for writing\n", outfile);
 625                 return 1;
 626         }
 627         for (i = 0U; i < numcomps; ++i) {
 628                 clip_component(&(image->comps[i]), image->comps[0].prec);
 629         }
 630         cvtPxToCx = convert_32s_PXCX_LUT[numcomps];
 631         switch (bps) {
 632                 case 1:
 633                 case 2:
 634                 case 4:
 635                 case 6:
 636                 case 8:
 637                         cvt32sToTif = convert_32sXXu_C1R_LUT[bps];
 638                         break;
 639                 case 3:
 640                         cvt32sToTif = tif_32sto3u;
 641                         break;
 642                 case 5:
 643                         cvt32sToTif = tif_32sto5u;
 644                         break;
 645                 case 7:
 646                         cvt32sToTif = tif_32sto7u;
 647                         break;
 648                 case 9:
 649                         cvt32sToTif = tif_32sto9u;
 650                         break;
 651                 case 10:
 652                         cvt32sToTif = tif_32sto10u;
 653                         break;
 654                 case 11:
 655                         cvt32sToTif = tif_32sto11u;
 656                         break;
 657                 case 12:
 658                         cvt32sToTif = tif_32sto12u;
 659                         break;
 660                 case 13:
 661                         cvt32sToTif = tif_32sto13u;
 662                         break;
 663                 case 14:
 664                         cvt32sToTif = tif_32sto14u;
 665                         break;
 666                 case 15:
 667                         cvt32sToTif = tif_32sto15u;
 668                         break;
 669                 case 16:
 670                         cvt32sToTif = (convert_32sXXx_C1R)tif_32sto16u;
 671                         break;
 672                 default:
 673                         /* never here */
 674                         break;
 675         }
 676         sgnd = (int)image->comps[0].sgnd;
 677         adjust = sgnd ? 1 << (image->comps[0].prec - 1) : 0;
 678         width   = (int)image->comps[0].w;
 679         height  = (int)image->comps[0].h;
 680
 681         TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
 682         TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
 683         TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, numcomps);
 684         TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
 685         TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 686         TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 687         TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, tiPhoto);
 688         TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
 689
 690         strip_size = TIFFStripSize(tif);
 691         rowStride = ((OPJ_SIZE_T)width * numcomps * (OPJ_SIZE_T)bps + 7U) / 8U;
 692         if (rowStride != (OPJ_SIZE_T)strip_size) {
 693                 fprintf(stderr, "Invalid TIFF strip size\n");
 694                 TIFFClose(tif);
 695                 return 1;
 696         }
 697         buf = _TIFFmalloc(strip_size);
 698         if (buf == NULL) {
 699                 TIFFClose(tif);
 700                 return 1;
 701         }
 702         buffer32s = (OPJ_INT32 *)malloc((OPJ_SIZE_T)width * numcomps * sizeof(OPJ_INT32));
 703         if (buffer32s == NULL) {
 704                 _TIFFfree(buf);
 705                 TIFFClose(tif);
 706                 return 1;
 707         }
 708
 709         for (i = 0; i < image->comps[0].h; ++i) {
 710                 cvtPxToCx(planes, buffer32s, (OPJ_SIZE_T)width, adjust);
 711                 cvt32sToTif(buffer32s, (OPJ_BYTE *)buf, (OPJ_SIZE_T)width * numcomps);
 712                 (void)TIFFWriteEncodedStrip(tif, i, (void*)buf, strip_size);
 713                 planes[0] += width;
 714                 planes[1] += width;
 715                 planes[2] += width;
 716                 planes[3] += width;
 717         }
 718         _TIFFfree((void*)buf);
 719         TIFFClose(tif);
 720         free(buffer32s);
 721
 722         return 0;
 723 }/* imagetotif() */
 724
 725 #define GETBITS(dest, nb) { \
 726         int needed = (nb); \
 727         unsigned int dst = 0U; \
 728         if (available == 0) { \
 729                 val = *pSrc++; \
 730                 available = 8; \
 731         } \
 732         while (needed > available) { \
 733                 dst |= val & ((1U << available) - 1U); \
 734                 needed -= available; \
 735                 dst <<= needed; \
 736                 val = *pSrc++; \
 737                 available = 8; \
 738         } \
 739         dst |= (val >> (available - needed)) & ((1U << needed) - 1U); \
 740         available -= needed; \
 741         dest = (OPJ_INT32)dst; \
 742 }
 743
 744 static void tif_3uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 745 {
 746         OPJ_SIZE_T i;
 747         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 748                 OPJ_UINT32 val0 = *pSrc++;
 749                 OPJ_UINT32 val1 = *pSrc++;
 750                 OPJ_UINT32 val2 = *pSrc++;
 751
 752                 pDst[i+0] = (OPJ_INT32)((val0 >> 5));
 753                 pDst[i+1] = (OPJ_INT32)(((val0 & 0x1FU) >> 2));
 754                 pDst[i+2] = (OPJ_INT32)(((val0 & 0x3U) << 1) | (val1 >> 7));
 755                 pDst[i+3] = (OPJ_INT32)(((val1 & 0x7FU) >> 4));
 756                 pDst[i+4] = (OPJ_INT32)(((val1 & 0xFU) >> 1));
 757                 pDst[i+5] = (OPJ_INT32)(((val1 & 0x1U) << 2) | (val2 >> 6));
 758                 pDst[i+6] = (OPJ_INT32)(((val2 & 0x3FU) >> 3));
 759                 pDst[i+7] = (OPJ_INT32)(((val2 & 0x7U)));
 760
 761         }
 762         if (length & 7U) {
 763                 unsigned int val;
 764                 int available = 0;
 765
 766                 length = length & 7U;
 767
 768                 GETBITS(pDst[i+0], 3)
 769
 770                 if (length > 1U) {
 771                         GETBITS(pDst[i+1], 3)
 772                         if (length > 2U) {
 773                                 GETBITS(pDst[i+2], 3)
 774                                 if (length > 3U) {
 775                                         GETBITS(pDst[i+3], 3)
 776                                         if (length > 4U) {
 777                                                 GETBITS(pDst[i+4], 3)
 778                                                 if (length > 5U) {
 779                                                         GETBITS(pDst[i+5], 3)
 780                                                         if (length > 6U) {
 781                                                                 GETBITS(pDst[i+6], 3)
 782                                                         }
 783                                                 }
 784                                         }
 785                                 }
 786                         }
 787                 }
 788         }
 789 }
 790 static void tif_5uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 791 {
 792         OPJ_SIZE_T i;
 793         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 794                 OPJ_UINT32 val0 = *pSrc++;
 795                 OPJ_UINT32 val1 = *pSrc++;
 796                 OPJ_UINT32 val2 = *pSrc++;
 797                 OPJ_UINT32 val3 = *pSrc++;
 798                 OPJ_UINT32 val4 = *pSrc++;
 799
 800                 pDst[i+0] = (OPJ_INT32)((val0 >> 3));
 801                 pDst[i+1] = (OPJ_INT32)(((val0 & 0x7U) << 2) | (val1 >> 6));
 802                 pDst[i+2] = (OPJ_INT32)(((val1 & 0x3FU) >> 1));
 803                 pDst[i+3] = (OPJ_INT32)(((val1 & 0x1U) << 4) | (val2 >> 4));
 804                 pDst[i+4] = (OPJ_INT32)(((val2 & 0xFU) << 1) | (val3 >> 7));
 805                 pDst[i+5] = (OPJ_INT32)(((val3 & 0x7FU) >> 2));
 806                 pDst[i+6] = (OPJ_INT32)(((val3 & 0x3U) << 3) | (val4 >> 5));
 807                 pDst[i+7] = (OPJ_INT32)(((val4 & 0x1FU)));
 808
 809         }
 810         if (length & 7U) {
 811                 unsigned int val;
 812                 int available = 0;
 813
 814                 length = length & 7U;
 815
 816                 GETBITS(pDst[i+0], 5)
 817
 818                 if (length > 1U) {
 819                         GETBITS(pDst[i+1], 5)
 820                         if (length > 2U) {
 821                                 GETBITS(pDst[i+2], 5)
 822                                 if (length > 3U) {
 823                                         GETBITS(pDst[i+3], 5)
 824                                         if (length > 4U) {
 825                                                 GETBITS(pDst[i+4], 5)
 826                                                 if (length > 5U) {
 827                                                         GETBITS(pDst[i+5], 5)
 828                                                         if (length > 6U) {
 829                                                                 GETBITS(pDst[i+6], 5)
 830                                                         }
 831                                                 }
 832                                         }
 833                                 }
 834                         }
 835                 }
 836         }
 837 }
 838 static void tif_7uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 839 {
 840         OPJ_SIZE_T i;
 841         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 842                 OPJ_UINT32 val0 = *pSrc++;
 843                 OPJ_UINT32 val1 = *pSrc++;
 844                 OPJ_UINT32 val2 = *pSrc++;
 845                 OPJ_UINT32 val3 = *pSrc++;
 846                 OPJ_UINT32 val4 = *pSrc++;
 847                 OPJ_UINT32 val5 = *pSrc++;
 848                 OPJ_UINT32 val6 = *pSrc++;
 849
 850                 pDst[i+0] = (OPJ_INT32)((val0 >> 1));
 851                 pDst[i+1] = (OPJ_INT32)(((val0 & 0x1U) << 6) | (val1 >> 2));
 852                 pDst[i+2] = (OPJ_INT32)(((val1 & 0x3U) << 5) | (val2 >> 3));
 853                 pDst[i+3] = (OPJ_INT32)(((val2 & 0x7U) << 4) | (val3 >> 4));
 854                 pDst[i+4] = (OPJ_INT32)(((val3 & 0xFU) << 3) | (val4 >> 5));
 855                 pDst[i+5] = (OPJ_INT32)(((val4 & 0x1FU) << 2) | (val5 >> 6));
 856                 pDst[i+6] = (OPJ_INT32)(((val5 & 0x3FU) << 1) | (val6 >> 7));
 857                 pDst[i+7] = (OPJ_INT32)(((val6 & 0x7FU)));
 858
 859         }
 860         if (length & 7U) {
 861                 unsigned int val;
 862                 int available = 0;
 863
 864                 length = length & 7U;
 865
 866                 GETBITS(pDst[i+0], 7)
 867
 868                 if (length > 1U) {
 869                         GETBITS(pDst[i+1], 7)
 870                         if (length > 2U) {
 871                                 GETBITS(pDst[i+2], 7)
 872                                 if (length > 3U) {
 873                                         GETBITS(pDst[i+3], 7)
 874                                         if (length > 4U) {
 875                                                 GETBITS(pDst[i+4], 7)
 876                                                 if (length > 5U) {
 877                                                         GETBITS(pDst[i+5], 7)
 878                                                         if (length > 6U) {
 879                                                                 GETBITS(pDst[i+6], 7)
 880                                                         }
 881                                                 }
 882                                         }
 883                                 }
 884                         }
 885                 }
 886         }
 887 }
 888 static void tif_9uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 889 {
 890         OPJ_SIZE_T i;
 891         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 892                 OPJ_UINT32 val0 = *pSrc++;
 893                 OPJ_UINT32 val1 = *pSrc++;
 894                 OPJ_UINT32 val2 = *pSrc++;
 895                 OPJ_UINT32 val3 = *pSrc++;
 896                 OPJ_UINT32 val4 = *pSrc++;
 897                 OPJ_UINT32 val5 = *pSrc++;
 898                 OPJ_UINT32 val6 = *pSrc++;
 899                 OPJ_UINT32 val7 = *pSrc++;
 900                 OPJ_UINT32 val8 = *pSrc++;
 901
 902                 pDst[i+0] = (OPJ_INT32)((val0 << 1) | (val1 >> 7));
 903                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x7FU) << 2) | (val2 >> 6));
 904                 pDst[i+2] = (OPJ_INT32)(((val2 & 0x3FU) << 3) | (val3 >> 5));
 905                 pDst[i+3] = (OPJ_INT32)(((val3 & 0x1FU) << 4) | (val4 >> 4));
 906                 pDst[i+4] = (OPJ_INT32)(((val4 & 0xFU) << 5) | (val5 >> 3));
 907                 pDst[i+5] = (OPJ_INT32)(((val5 & 0x7U) << 6) | (val6 >> 2));
 908                 pDst[i+6] = (OPJ_INT32)(((val6 & 0x3U) << 7) | (val7 >> 1));
 909                 pDst[i+7] = (OPJ_INT32)(((val7 & 0x1U) << 8) | (val8));
 910
 911         }
 912         if (length & 7U) {
 913                 unsigned int val;
 914                 int available = 0;
 915
 916                 length = length & 7U;
 917
 918                 GETBITS(pDst[i+0], 9)
 919
 920                 if (length > 1U) {
 921                         GETBITS(pDst[i+1], 9)
 922                         if (length > 2U) {
 923                                 GETBITS(pDst[i+2], 9)
 924                                 if (length > 3U) {
 925                                         GETBITS(pDst[i+3], 9)
 926                                         if (length > 4U) {
 927                                                 GETBITS(pDst[i+4], 9)
 928                                                 if (length > 5U) {
 929                                                         GETBITS(pDst[i+5], 9)
 930                                                         if (length > 6U) {
 931                                                                 GETBITS(pDst[i+6], 9)
 932                                                         }
 933                                                 }
 934                                         }
 935                                 }
 936                         }
 937                 }
 938         }
 939 }
 940 static void tif_10uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 941 {
 942         OPJ_SIZE_T i;
 943         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
 944                 OPJ_UINT32 val0 = *pSrc++;
 945                 OPJ_UINT32 val1 = *pSrc++;
 946                 OPJ_UINT32 val2 = *pSrc++;
 947                 OPJ_UINT32 val3 = *pSrc++;
 948                 OPJ_UINT32 val4 = *pSrc++;
 949
 950                 pDst[i+0] = (OPJ_INT32)((val0 << 2) | (val1 >> 6));
 951                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x3FU) << 4) | (val2 >> 4));
 952                 pDst[i+2] = (OPJ_INT32)(((val2 & 0xFU) << 6) | (val3 >> 2));
 953                 pDst[i+3] = (OPJ_INT32)(((val3 & 0x3U) << 8) | val4);
 954
 955         }
 956         if (length & 3U) {
 957                 OPJ_UINT32 val0 = *pSrc++;
 958                 OPJ_UINT32 val1 = *pSrc++;
 959                 length = length & 3U;
 960                 pDst[i+0] = (OPJ_INT32)((val0 << 2) | (val1 >> 6));
 961
 962                 if (length > 1U) {
 963                         OPJ_UINT32 val2 = *pSrc++;
 964                         pDst[i+1] = (OPJ_INT32)(((val1 & 0x3FU) << 4) | (val2 >> 4));
 965                         if (length > 2U) {
 966                                 OPJ_UINT32 val3 = *pSrc++;
 967                                 pDst[i+2] = (OPJ_INT32)(((val2 & 0xFU) << 6) | (val3 >> 2));
 968                         }
 969                 }
 970         }
 971 }
 972 static void tif_11uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
 973 {
 974         OPJ_SIZE_T i;
 975         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
 976                 OPJ_UINT32 val0 = *pSrc++;
 977                 OPJ_UINT32 val1 = *pSrc++;
 978                 OPJ_UINT32 val2 = *pSrc++;
 979                 OPJ_UINT32 val3 = *pSrc++;
 980                 OPJ_UINT32 val4 = *pSrc++;
 981                 OPJ_UINT32 val5 = *pSrc++;
 982                 OPJ_UINT32 val6 = *pSrc++;
 983                 OPJ_UINT32 val7 = *pSrc++;
 984                 OPJ_UINT32 val8 = *pSrc++;
 985                 OPJ_UINT32 val9 = *pSrc++;
 986                 OPJ_UINT32 val10 = *pSrc++;
 987
 988                 pDst[i+0] = (OPJ_INT32)((val0 << 3) | (val1 >> 5));
 989                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x1FU) << 6) | (val2 >> 2));
 990                 pDst[i+2] = (OPJ_INT32)(((val2 & 0x3U) << 9) | (val3 << 1) | (val4 >> 7));
 991                 pDst[i+3] = (OPJ_INT32)(((val4 & 0x7FU) << 4) | (val5 >> 4));
 992                 pDst[i+4] = (OPJ_INT32)(((val5 & 0xFU) << 7) | (val6 >> 1));
 993                 pDst[i+5] = (OPJ_INT32)(((val6 & 0x1U) << 10) | (val7 << 2) | (val8 >> 6));
 994                 pDst[i+6] = (OPJ_INT32)(((val8 & 0x3FU) << 5) | (val9 >> 3));
 995                 pDst[i+7] = (OPJ_INT32)(((val9 & 0x7U) << 8) | (val10));
 996
 997         }
 998         if (length & 7U) {
 999                 unsigned int val;
1000                 int available = 0;
1001
1002                 length = length & 7U;
1003
1004                 GETBITS(pDst[i+0], 11)
1005
1006                 if (length > 1U) {
1007                         GETBITS(pDst[i+1], 11)
1008                         if (length > 2U) {
1009                                 GETBITS(pDst[i+2], 11)
1010                                 if (length > 3U) {
1011                                         GETBITS(pDst[i+3], 11)
1012                                         if (length > 4U) {
1013                                                 GETBITS(pDst[i+4], 11)
1014                                                 if (length > 5U) {
1015                                                         GETBITS(pDst[i+5], 11)
1016                                                         if (length > 6U) {
1017                                                                 GETBITS(pDst[i+6], 11)
1018                                                         }
1019                                                 }
1020                                         }
1021                                 }
1022                         }
1023                 }
1024         }
1025 }
1026 static void tif_12uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
1027 {
1028         OPJ_SIZE_T i;
1029         for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i+=2U) {
1030                 OPJ_UINT32 val0 = *pSrc++;
1031                 OPJ_UINT32 val1 = *pSrc++;
1032                 OPJ_UINT32 val2 = *pSrc++;
1033
1034                 pDst[i+0] = (OPJ_INT32)((val0 << 4) | (val1 >> 4));
1035                 pDst[i+1] = (OPJ_INT32)(((val1 & 0xFU) << 8) | val2);
1036         }
1037         if (length & 1U) {
1038                 OPJ_UINT32 val0 = *pSrc++;
1039                 OPJ_UINT32 val1 = *pSrc++;
1040                 pDst[i+0] = (OPJ_INT32)((val0 << 4) | (val1 >> 4));
1041         }
1042 }
1043 static void tif_13uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
1044 {
1045         OPJ_SIZE_T i;
1046         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
1047                 OPJ_UINT32 val0 = *pSrc++;
1048                 OPJ_UINT32 val1 = *pSrc++;
1049                 OPJ_UINT32 val2 = *pSrc++;
1050                 OPJ_UINT32 val3 = *pSrc++;
1051                 OPJ_UINT32 val4 = *pSrc++;
1052                 OPJ_UINT32 val5 = *pSrc++;
1053                 OPJ_UINT32 val6 = *pSrc++;
1054                 OPJ_UINT32 val7 = *pSrc++;
1055                 OPJ_UINT32 val8 = *pSrc++;
1056                 OPJ_UINT32 val9 = *pSrc++;
1057                 OPJ_UINT32 val10 = *pSrc++;
1058                 OPJ_UINT32 val11 = *pSrc++;
1059                 OPJ_UINT32 val12 = *pSrc++;
1060
1061                 pDst[i+0] = (OPJ_INT32)((val0 << 5) | (val1 >> 3));
1062                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x7U) << 10) | (val2 << 2) | (val3 >> 6));
1063                 pDst[i+2] = (OPJ_INT32)(((val3 & 0x3FU) << 7) | (val4 >> 1));
1064                 pDst[i+3] = (OPJ_INT32)(((val4 & 0x1U) << 12) | (val5 << 4) | (val6 >> 4));
1065                 pDst[i+4] = (OPJ_INT32)(((val6 & 0xFU) << 9) | (val7 << 1) | (val8 >> 7));
1066                 pDst[i+5] = (OPJ_INT32)(((val8 & 0x7FU) << 6) | (val9 >> 2));
1067                 pDst[i+6] = (OPJ_INT32)(((val9 & 0x3U) << 11) | (val10 << 3) | (val11 >> 5));
1068                 pDst[i+7] = (OPJ_INT32)(((val11 & 0x1FU) << 8) | (val12));
1069
1070         }
1071         if (length & 7U) {
1072                 unsigned int val;
1073                 int available = 0;
1074
1075                 length = length & 7U;
1076
1077                 GETBITS(pDst[i+0], 13)
1078
1079                 if (length > 1U) {
1080                         GETBITS(pDst[i+1], 13)
1081                         if (length > 2U) {
1082                                 GETBITS(pDst[i+2], 13)
1083                                 if (length > 3U) {
1084                                         GETBITS(pDst[i+3], 13)
1085                                         if (length > 4U) {
1086                                                 GETBITS(pDst[i+4], 13)
1087                                                 if (length > 5U) {
1088                                                         GETBITS(pDst[i+5], 13)
1089                                                         if (length > 6U) {
1090                                                                 GETBITS(pDst[i+6], 13)
1091                                                         }
1092                                                 }
1093                                         }
1094                                 }
1095                         }
1096                 }
1097         }
1098 }
1099 static void tif_14uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
1100 {
1101         OPJ_SIZE_T i;
1102         for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i+=4U) {
1103                 OPJ_UINT32 val0 = *pSrc++;
1104                 OPJ_UINT32 val1 = *pSrc++;
1105                 OPJ_UINT32 val2 = *pSrc++;
1106                 OPJ_UINT32 val3 = *pSrc++;
1107                 OPJ_UINT32 val4 = *pSrc++;
1108                 OPJ_UINT32 val5 = *pSrc++;
1109                 OPJ_UINT32 val6 = *pSrc++;
1110
1111                 pDst[i+0] = (OPJ_INT32)((val0 << 6) | (val1 >> 2));
1112                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x3U) << 12) | (val2 << 4) | (val3 >> 4));
1113                 pDst[i+2] = (OPJ_INT32)(((val3 & 0xFU) << 10) | (val4 << 2) | (val5 >> 6));
1114                 pDst[i+3] = (OPJ_INT32)(((val5 & 0x3FU) << 8) | val6);
1115
1116         }
1117         if (length & 3U) {
1118                 OPJ_UINT32 val0 = *pSrc++;
1119                 OPJ_UINT32 val1 = *pSrc++;
1120                 length = length & 3U;
1121                 pDst[i+0] = (OPJ_INT32)((val0 << 6) | (val1 >> 2));
1122
1123                 if (length > 1U) {
1124                         OPJ_UINT32 val2 = *pSrc++;
1125                         OPJ_UINT32 val3 = *pSrc++;
1126                         pDst[i+1] = (OPJ_INT32)(((val1 & 0x3U) << 12) | (val2 << 4) | (val3 >> 4));
1127                         if (length > 2U) {
1128                                 OPJ_UINT32 val4 = *pSrc++;
1129                                 OPJ_UINT32 val5 = *pSrc++;
1130                                 pDst[i+2] = (OPJ_INT32)(((val3 & 0xFU) << 10) | (val4 << 2) | (val5 >> 6));
1131                         }
1132                 }
1133         }
1134 }
1135 static void tif_15uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
1136 {
1137         OPJ_SIZE_T i;
1138         for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i+=8U) {
1139                 OPJ_UINT32 val0 = *pSrc++;
1140                 OPJ_UINT32 val1 = *pSrc++;
1141                 OPJ_UINT32 val2 = *pSrc++;
1142                 OPJ_UINT32 val3 = *pSrc++;
1143                 OPJ_UINT32 val4 = *pSrc++;
1144                 OPJ_UINT32 val5 = *pSrc++;
1145                 OPJ_UINT32 val6 = *pSrc++;
1146                 OPJ_UINT32 val7 = *pSrc++;
1147                 OPJ_UINT32 val8 = *pSrc++;
1148                 OPJ_UINT32 val9 = *pSrc++;
1149                 OPJ_UINT32 val10 = *pSrc++;
1150                 OPJ_UINT32 val11 = *pSrc++;
1151                 OPJ_UINT32 val12 = *pSrc++;
1152                 OPJ_UINT32 val13 = *pSrc++;
1153                 OPJ_UINT32 val14 = *pSrc++;
1154
1155                 pDst[i+0] = (OPJ_INT32)((val0 << 7) | (val1 >> 1));
1156                 pDst[i+1] = (OPJ_INT32)(((val1 & 0x1U) << 14) | (val2 << 6) | (val3 >> 2));
1157                 pDst[i+2] = (OPJ_INT32)(((val3 & 0x3U) << 13) | (val4 << 5) | (val5 >> 3));
1158                 pDst[i+3] = (OPJ_INT32)(((val5 & 0x7U) << 12) | (val6 << 4) | (val7 >> 4));
1159                 pDst[i+4] = (OPJ_INT32)(((val7 & 0xFU) << 11) | (val8 << 3) | (val9 >> 5));
1160                 pDst[i+5] = (OPJ_INT32)(((val9 & 0x1FU) << 10) | (val10 << 2) | (val11 >> 6));
1161                 pDst[i+6] = (OPJ_INT32)(((val11 & 0x3FU) << 9) | (val12 << 1) | (val13 >> 7));
1162                 pDst[i+7] = (OPJ_INT32)(((val13 & 0x7FU) << 8) | (val14));
1163
1164         }
1165         if (length & 7U) {
1166                 unsigned int val;
1167                 int available = 0;
1168
1169                 length = length & 7U;
1170
1171                 GETBITS(pDst[i+0], 15)
1172
1173                 if (length > 1U) {
1174                         GETBITS(pDst[i+1], 15)
1175                         if (length > 2U) {
1176                                 GETBITS(pDst[i+2], 15)
1177                                 if (length > 3U) {
1178                                         GETBITS(pDst[i+3], 15)
1179                                         if (length > 4U) {
1180                                                 GETBITS(pDst[i+4], 15)
1181                                                 if (length > 5U) {
1182                                                         GETBITS(pDst[i+5], 15)
1183                                                         if (length > 6U) {
1184                                                                 GETBITS(pDst[i+6], 15)
1185                                                         }
1186                                                 }
1187                                         }
1188                                 }
1189                         }
1190                 }
1191         }
1192 }
1193
1194 /* seems that libtiff decodes this to machine endianness */
1195 static void tif_16uto32s(const OPJ_UINT16* pSrc, OPJ_INT32* pDst, OPJ_SIZE_T length)
1196 {
1197         OPJ_SIZE_T i;
1198         for (i = 0; i < length; i++) {
1199                 pDst[i] = pSrc[i];
1200         }
1201 }
1202
1203 /*
1204  * libtiff/tif_getimage.c : 1,2,4,8,16 bitspersample accepted
1205  * CINEMA                 : 12 bit precision
1206  */
1207 opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters)
1208 {
1209         int subsampling_dx = parameters->subsampling_dx;
1210         int subsampling_dy = parameters->subsampling_dy;
1211         TIFF *tif;
1212         tdata_t buf;
1213         tstrip_t strip;
1214         tsize_t strip_size;
1215         int j, currentPlane, numcomps = 0, w, h;
1216         OPJ_COLOR_SPACE color_space = OPJ_CLRSPC_UNKNOWN;
1217         opj_image_cmptparm_t cmptparm[4]; /* RGBA */
1218         opj_image_t *image = NULL;
1219         int has_alpha = 0;
1220         unsigned short tiBps, tiPhoto, tiSf, tiSpp, tiPC;
1221         unsigned int tiWidth, tiHeight;
1222         OPJ_BOOL is_cinema = OPJ_IS_CINEMA(parameters->rsiz);
1223         convert_XXx32s_C1R cvtTifTo32s = NULL;
1224         convert_32s_CXPX cvtCxToPx = NULL;
1225         OPJ_INT32* buffer32s = NULL;
1226         OPJ_INT32* planes[4];
1227         OPJ_SIZE_T rowStride;
1228
1229         tif = TIFFOpen(filename, "r");
1230
1231         if(!tif)
1232         {
1233                 fprintf(stderr, "tiftoimage:Failed to open %s for reading\n", filename);
1234                 return 0;
1235         }
1236         tiBps = tiPhoto = tiSf = tiSpp = tiPC = 0;
1237         tiWidth = tiHeight = 0;
1238
1239         TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &tiWidth);
1240         TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &tiHeight);
1241         TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &tiBps);
1242         TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &tiSf);
1243         TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &tiSpp);
1244         TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &tiPhoto);
1245         TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &tiPC);
1246         w= (int)tiWidth;
1247         h= (int)tiHeight;
1248
1249         if(tiBps > 16U) {
1250                 fprintf(stderr,"tiftoimage: Bits=%d, Only 1 to 16 bits implemented\n",tiBps);
1251                 fprintf(stderr,"\tAborting\n");
1252                 TIFFClose(tif);
1253                 return NULL;
1254         }
1255         if(tiPhoto != PHOTOMETRIC_MINISBLACK && tiPhoto != PHOTOMETRIC_RGB) {
1256                 fprintf(stderr,"tiftoimage: Bad color format %d.\n\tOnly RGB(A) and GRAY(A) has been implemented\n",(int) tiPhoto);
1257                 fprintf(stderr,"\tAborting\n");
1258                 TIFFClose(tif);
1259                 return NULL;
1260         }
1261
1262         switch (tiBps) {
1263                 case 1:
1264                 case 2:
1265                 case 4:
1266                 case 6:
1267                 case 8:
1268                         cvtTifTo32s = convert_XXu32s_C1R_LUT[tiBps];
1269                         break;
1270                 /* others are specific to TIFF */
1271                 case 3:
1272                         cvtTifTo32s = tif_3uto32s;
1273                         break;
1274                 case 5:
1275                         cvtTifTo32s = tif_5uto32s;
1276                         break;
1277                 case 7:
1278                         cvtTifTo32s = tif_7uto32s;
1279                         break;
1280                 case 9:
1281                         cvtTifTo32s = tif_9uto32s;
1282                         break;
1283                 case 10:
1284                         cvtTifTo32s = tif_10uto32s;
1285                         break;
1286                 case 11:
1287                         cvtTifTo32s = tif_11uto32s;
1288                         break;
1289                 case 12:
1290                         cvtTifTo32s = tif_12uto32s;
1291                         break;
1292                 case 13:
1293                         cvtTifTo32s = tif_13uto32s;
1294                         break;
1295                 case 14:
1296                         cvtTifTo32s = tif_14uto32s;
1297                         break;
1298                 case 15:
1299                         cvtTifTo32s = tif_15uto32s;
1300                         break;
1301                 case 16:
1302                         cvtTifTo32s = (convert_XXx32s_C1R)tif_16uto32s;
1303                         break;
1304                 default:
1305                         /* never here */
1306                         break;
1307         }
1308
1309         {/* From: tiff-4.0.x/libtiff/tif_getimage.c : */
1310                 uint16* sampleinfo;
1311                 uint16 extrasamples;
1312
1313                 TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
1314                                                                                                         &extrasamples, &sampleinfo);
1315
1316                 if(extrasamples >= 1)
1317                 {
1318                         switch(sampleinfo[0])
1319                         {
1320                                 case EXTRASAMPLE_UNSPECIFIED:
1321                                         /* Workaround for some images without correct info about alpha channel
1322                                          */
1323                                         if(tiSpp > 3)
1324                                                 has_alpha = 1;
1325                                         break;
1326
1327                                 case EXTRASAMPLE_ASSOCALPHA: /* data pre-multiplied */
1328                                 case EXTRASAMPLE_UNASSALPHA: /* data not pre-multiplied */
1329                                         has_alpha = 1;
1330                                         break;
1331                         }
1332                 }
1333                 else /* extrasamples == 0 */
1334                         if(tiSpp == 4 || tiSpp == 2) has_alpha = 1;
1335         }
1336
1337         /* initialize image components */
1338         memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
1339
1340         if ((tiPhoto == PHOTOMETRIC_RGB) && (is_cinema) && (tiBps != 12U)) {
1341                 fprintf(stdout,"WARNING:\n"
1342                                                 "Input image bitdepth is %d bits\n"
1343                                                 "TIF conversion has automatically rescaled to 12-bits\n"
1344                                                 "to comply with cinema profiles.\n",
1345                                                 tiBps);
1346         } else {
1347                 is_cinema = 0U;
1348         }
1349
1350         if(tiPhoto == PHOTOMETRIC_RGB) /* RGB(A) */
1351         {
1352                 numcomps = 3 + has_alpha;
1353                 color_space = OPJ_CLRSPC_SRGB;
1354         }
1355         else if (tiPhoto == PHOTOMETRIC_MINISBLACK) /* GRAY(A) */
1356         {
1357                 numcomps = 1 + has_alpha;
1358                 color_space = OPJ_CLRSPC_GRAY;
1359         }
1360
1361         cvtCxToPx = convert_32s_CXPX_LUT[numcomps];
1362         if (tiPC == PLANARCONFIG_SEPARATE) {
1363                 cvtCxToPx = convert_32s_CXPX_LUT[1]; /* override */
1364                 tiSpp = 1U; /* consider only one sample per plane */
1365         }
1366
1367         for(j = 0; j < numcomps; j++)
1368         {
1369                 cmptparm[j].prec = tiBps;
1370                 cmptparm[j].bpp = tiBps;
1371                 cmptparm[j].dx = (OPJ_UINT32)subsampling_dx;
1372                 cmptparm[j].dy = (OPJ_UINT32)subsampling_dy;
1373                 cmptparm[j].w = (OPJ_UINT32)w;
1374                 cmptparm[j].h = (OPJ_UINT32)h;
1375         }
1376
1377         image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
1378         if(!image)
1379         {
1380                 TIFFClose(tif);
1381                 return NULL;
1382         }
1383         /* set image offset and reference grid */
1384         image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
1385         image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
1386         image->x1 =     !image->x0 ? (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1 :
1387         image->x0 + (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1;
1388         image->y1 =     !image->y0 ? (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1 :
1389         image->y0 + (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1;
1390
1391         for(j = 0; j < numcomps; j++)
1392         {
1393                 planes[j] = image->comps[j].data;
1394         }
1395         image->comps[numcomps - 1].alpha = (OPJ_UINT16)(1 - (numcomps & 1));
1396
1397         strip_size = TIFFStripSize(tif);
1398
1399         buf = _TIFFmalloc(strip_size);
1400         if (buf == NULL) {
1401                 TIFFClose(tif);
1402                 opj_image_destroy(image);
1403                 return NULL;
1404         }
1405         rowStride = ((OPJ_SIZE_T)w * tiSpp * tiBps + 7U) / 8U;
1406         buffer32s = (OPJ_INT32 *)malloc((OPJ_SIZE_T)w * tiSpp * sizeof(OPJ_INT32));
1407         if (buffer32s == NULL) {
1408                 _TIFFfree(buf);
1409                 TIFFClose(tif);
1410                 opj_image_destroy(image);
1411                 return NULL;
1412         }
1413
1414         strip = 0;
1415         currentPlane = 0;
1416         do
1417         {
1418                 planes[0] = image->comps[currentPlane].data; /* to manage planar data */
1419                 h= (int)tiHeight;
1420                 /* Read the Image components */
1421                 for(; (h > 0) && (strip < TIFFNumberOfStrips(tif)); strip++)
1422                 {
1423                                 const OPJ_UINT8 *dat8;
1424                                 OPJ_SIZE_T ssize;
1425
1426                                 ssize = (OPJ_SIZE_T)TIFFReadEncodedStrip(tif, strip, buf, strip_size);
1427                                 dat8 = (const OPJ_UINT8*)buf;
1428
1429                                 while (ssize >= rowStride) {
1430                                         cvtTifTo32s(dat8, buffer32s, (OPJ_SIZE_T)w * tiSpp);
1431                                         cvtCxToPx(buffer32s, planes, (OPJ_SIZE_T)w);
1432                                         planes[0] += w;
1433                                         planes[1] += w;
1434                                         planes[2] += w;
1435                                         planes[3] += w;
1436                                         dat8  += rowStride;
1437                                         ssize -= rowStride;
1438                                         h--;
1439                                 }
1440                 }
1441                 currentPlane++;
1442         } while ((tiPC == PLANARCONFIG_SEPARATE) && (currentPlane < numcomps));
1443
1444         free(buffer32s);
1445         _TIFFfree(buf);
1446         TIFFClose(tif);
1447
1448         if (is_cinema) {
1449                 for (j=0; j < numcomps; ++j) {
1450                         scale_component(&(image->comps[j]), 12);
1451                 }
1452
1453         }
1454         return image;
1455
1456 }/* tiftoimage() */
1457