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