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         if (planes[i] == NULL) {
 620             fprintf(stderr,
 621                     "imagetotif: planes[%d] == NULL.\n", i);
 622             fprintf(stderr, "\tAborting\n");
 623             return 1;
 624         }
 625     }
 626     if (i != numcomps) {
 627         fprintf(stderr,
 628                 "imagetotif: All components shall have the same subsampling, same bit depth.\n");
 629         fprintf(stderr, "\tAborting\n");
 630         return 1;
 631     }
 632
 633     if (bps > 16) {
 634         bps = 0;
 635     }
 636     if (bps == 0) {
 637         fprintf(stderr, "imagetotif: Bits=%d, Only 1 to 16 bits implemented\n", bps);
 638         fprintf(stderr, "\tAborting\n");
 639         return 1;
 640     }
 641     tif = TIFFOpen(outfile, "wb");
 642     if (!tif) {
 643         fprintf(stderr, "imagetotif:failed to open %s for writing\n", outfile);
 644         return 1;
 645     }
 646     for (i = 0U; i < numcomps; ++i) {
 647         clip_component(&(image->comps[i]), image->comps[0].prec);
 648     }
 649     cvtPxToCx = convert_32s_PXCX_LUT[numcomps];
 650     switch (bps) {
 651     case 1:
 652     case 2:
 653     case 4:
 654     case 6:
 655     case 8:
 656         cvt32sToTif = convert_32sXXu_C1R_LUT[bps];
 657         break;
 658     case 3:
 659         cvt32sToTif = tif_32sto3u;
 660         break;
 661     case 5:
 662         cvt32sToTif = tif_32sto5u;
 663         break;
 664     case 7:
 665         cvt32sToTif = tif_32sto7u;
 666         break;
 667     case 9:
 668         cvt32sToTif = tif_32sto9u;
 669         break;
 670     case 10:
 671         cvt32sToTif = tif_32sto10u;
 672         break;
 673     case 11:
 674         cvt32sToTif = tif_32sto11u;
 675         break;
 676     case 12:
 677         cvt32sToTif = tif_32sto12u;
 678         break;
 679     case 13:
 680         cvt32sToTif = tif_32sto13u;
 681         break;
 682     case 14:
 683         cvt32sToTif = tif_32sto14u;
 684         break;
 685     case 15:
 686         cvt32sToTif = tif_32sto15u;
 687         break;
 688     case 16:
 689         cvt32sToTif = (convert_32sXXx_C1R)tif_32sto16u;
 690         break;
 691     default:
 692         /* never here */
 693         break;
 694     }
 695     sgnd = (int)image->comps[0].sgnd;
 696     adjust = sgnd ? (int)(1 << (image->comps[0].prec - 1)) : 0;
 697     width   = (uint32)image->comps[0].w;
 698     height  = (uint32)image->comps[0].h;
 699
 700     TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
 701     TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
 702     TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, (uint16)numcomps);
 703     TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
 704     TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 705     TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 706     TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, tiPhoto);
 707     TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
 708     if (sizeof(tsize_t) == 4) {
 709         TIFF_MAX = INT_MAX;
 710     } else {
 711         TIFF_MAX = UINT_MAX;
 712     }
 713     strip_size = (int64_t)TIFFStripSize(tif);
 714
 715     if ((int64_t)width > (int64_t)(TIFF_MAX / numcomps) ||
 716             (int64_t)(width * numcomps) > (int64_t)(TIFF_MAX / bps) ||
 717             (int64_t)(width * numcomps) > (int64_t)(TIFF_MAX / (int64_t)sizeof(
 718                         OPJ_INT32))) {
 719         fprintf(stderr, "Buffer overflow\n");
 720         TIFFClose(tif);
 721         return 1;
 722     }
 723     rowStride = (int64_t)((width * numcomps * bps + 7U) / 8U);
 724     if (rowStride != strip_size) {
 725         fprintf(stderr, "Invalid TIFF strip size\n");
 726         TIFFClose(tif);
 727         return 1;
 728     }
 729     buf = malloc((OPJ_SIZE_T)strip_size);
 730     if (buf == NULL) {
 731         TIFFClose(tif);
 732         return 1;
 733     }
 734     buffer32s = (OPJ_INT32 *)malloc(sizeof(OPJ_INT32) * width * numcomps);
 735     if (buffer32s == NULL) {
 736         _TIFFfree(buf);
 737         TIFFClose(tif);
 738         return 1;
 739     }
 740
 741     for (i = 0; i < image->comps[0].h; ++i) {
 742         cvtPxToCx(planes, buffer32s, (OPJ_SIZE_T)width, adjust);
 743         cvt32sToTif(buffer32s, (OPJ_BYTE *)buf, (OPJ_SIZE_T)width * numcomps);
 744         (void)TIFFWriteEncodedStrip(tif, i, (void*)buf, (tsize_t)strip_size);
 745         planes[0] += width;
 746         planes[1] += width;
 747         planes[2] += width;
 748         planes[3] += width;
 749     }
 750     _TIFFfree((void*)buf);
 751     TIFFClose(tif);
 752     free(buffer32s);
 753
 754     return 0;
 755 }/* imagetotif() */
 756
 757 #define GETBITS(dest, nb) { \
 758     int needed = (nb); \
 759     unsigned int dst = 0U; \
 760     if (available == 0) { \
 761         val = *pSrc++; \
 762         available = 8; \
 763     } \
 764     while (needed > available) { \
 765         dst |= val & ((1U << available) - 1U); \
 766         needed -= available; \
 767         dst <<= needed; \
 768         val = *pSrc++; \
 769         available = 8; \
 770     } \
 771     dst |= (val >> (available - needed)) & ((1U << needed) - 1U); \
 772     available -= needed; \
 773     dest = (OPJ_INT32)dst; \
 774 }
 775
 776 static void tif_3uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 777                         OPJ_SIZE_T length)
 778 {
 779     OPJ_SIZE_T i;
 780     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 781         OPJ_UINT32 val0 = *pSrc++;
 782         OPJ_UINT32 val1 = *pSrc++;
 783         OPJ_UINT32 val2 = *pSrc++;
 784
 785         pDst[i + 0] = (OPJ_INT32)((val0 >> 5));
 786         pDst[i + 1] = (OPJ_INT32)(((val0 & 0x1FU) >> 2));
 787         pDst[i + 2] = (OPJ_INT32)(((val0 & 0x3U) << 1) | (val1 >> 7));
 788         pDst[i + 3] = (OPJ_INT32)(((val1 & 0x7FU) >> 4));
 789         pDst[i + 4] = (OPJ_INT32)(((val1 & 0xFU) >> 1));
 790         pDst[i + 5] = (OPJ_INT32)(((val1 & 0x1U) << 2) | (val2 >> 6));
 791         pDst[i + 6] = (OPJ_INT32)(((val2 & 0x3FU) >> 3));
 792         pDst[i + 7] = (OPJ_INT32)(((val2 & 0x7U)));
 793
 794     }
 795     if (length & 7U) {
 796         unsigned int val;
 797         int available = 0;
 798
 799         length = length & 7U;
 800
 801         GETBITS(pDst[i + 0], 3)
 802
 803         if (length > 1U) {
 804             GETBITS(pDst[i + 1], 3)
 805             if (length > 2U) {
 806                 GETBITS(pDst[i + 2], 3)
 807                 if (length > 3U) {
 808                     GETBITS(pDst[i + 3], 3)
 809                     if (length > 4U) {
 810                         GETBITS(pDst[i + 4], 3)
 811                         if (length > 5U) {
 812                             GETBITS(pDst[i + 5], 3)
 813                             if (length > 6U) {
 814                                 GETBITS(pDst[i + 6], 3)
 815                             }
 816                         }
 817                     }
 818                 }
 819             }
 820         }
 821     }
 822 }
 823 static void tif_5uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 824                         OPJ_SIZE_T length)
 825 {
 826     OPJ_SIZE_T i;
 827     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 828         OPJ_UINT32 val0 = *pSrc++;
 829         OPJ_UINT32 val1 = *pSrc++;
 830         OPJ_UINT32 val2 = *pSrc++;
 831         OPJ_UINT32 val3 = *pSrc++;
 832         OPJ_UINT32 val4 = *pSrc++;
 833
 834         pDst[i + 0] = (OPJ_INT32)((val0 >> 3));
 835         pDst[i + 1] = (OPJ_INT32)(((val0 & 0x7U) << 2) | (val1 >> 6));
 836         pDst[i + 2] = (OPJ_INT32)(((val1 & 0x3FU) >> 1));
 837         pDst[i + 3] = (OPJ_INT32)(((val1 & 0x1U) << 4) | (val2 >> 4));
 838         pDst[i + 4] = (OPJ_INT32)(((val2 & 0xFU) << 1) | (val3 >> 7));
 839         pDst[i + 5] = (OPJ_INT32)(((val3 & 0x7FU) >> 2));
 840         pDst[i + 6] = (OPJ_INT32)(((val3 & 0x3U) << 3) | (val4 >> 5));
 841         pDst[i + 7] = (OPJ_INT32)(((val4 & 0x1FU)));
 842
 843     }
 844     if (length & 7U) {
 845         unsigned int val;
 846         int available = 0;
 847
 848         length = length & 7U;
 849
 850         GETBITS(pDst[i + 0], 5)
 851
 852         if (length > 1U) {
 853             GETBITS(pDst[i + 1], 5)
 854             if (length > 2U) {
 855                 GETBITS(pDst[i + 2], 5)
 856                 if (length > 3U) {
 857                     GETBITS(pDst[i + 3], 5)
 858                     if (length > 4U) {
 859                         GETBITS(pDst[i + 4], 5)
 860                         if (length > 5U) {
 861                             GETBITS(pDst[i + 5], 5)
 862                             if (length > 6U) {
 863                                 GETBITS(pDst[i + 6], 5)
 864                             }
 865                         }
 866                     }
 867                 }
 868             }
 869         }
 870     }
 871 }
 872 static void tif_7uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 873                         OPJ_SIZE_T length)
 874 {
 875     OPJ_SIZE_T i;
 876     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 877         OPJ_UINT32 val0 = *pSrc++;
 878         OPJ_UINT32 val1 = *pSrc++;
 879         OPJ_UINT32 val2 = *pSrc++;
 880         OPJ_UINT32 val3 = *pSrc++;
 881         OPJ_UINT32 val4 = *pSrc++;
 882         OPJ_UINT32 val5 = *pSrc++;
 883         OPJ_UINT32 val6 = *pSrc++;
 884
 885         pDst[i + 0] = (OPJ_INT32)((val0 >> 1));
 886         pDst[i + 1] = (OPJ_INT32)(((val0 & 0x1U) << 6) | (val1 >> 2));
 887         pDst[i + 2] = (OPJ_INT32)(((val1 & 0x3U) << 5) | (val2 >> 3));
 888         pDst[i + 3] = (OPJ_INT32)(((val2 & 0x7U) << 4) | (val3 >> 4));
 889         pDst[i + 4] = (OPJ_INT32)(((val3 & 0xFU) << 3) | (val4 >> 5));
 890         pDst[i + 5] = (OPJ_INT32)(((val4 & 0x1FU) << 2) | (val5 >> 6));
 891         pDst[i + 6] = (OPJ_INT32)(((val5 & 0x3FU) << 1) | (val6 >> 7));
 892         pDst[i + 7] = (OPJ_INT32)(((val6 & 0x7FU)));
 893
 894     }
 895     if (length & 7U) {
 896         unsigned int val;
 897         int available = 0;
 898
 899         length = length & 7U;
 900
 901         GETBITS(pDst[i + 0], 7)
 902
 903         if (length > 1U) {
 904             GETBITS(pDst[i + 1], 7)
 905             if (length > 2U) {
 906                 GETBITS(pDst[i + 2], 7)
 907                 if (length > 3U) {
 908                     GETBITS(pDst[i + 3], 7)
 909                     if (length > 4U) {
 910                         GETBITS(pDst[i + 4], 7)
 911                         if (length > 5U) {
 912                             GETBITS(pDst[i + 5], 7)
 913                             if (length > 6U) {
 914                                 GETBITS(pDst[i + 6], 7)
 915                             }
 916                         }
 917                     }
 918                 }
 919             }
 920         }
 921     }
 922 }
 923 static void tif_9uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 924                         OPJ_SIZE_T length)
 925 {
 926     OPJ_SIZE_T i;
 927     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 928         OPJ_UINT32 val0 = *pSrc++;
 929         OPJ_UINT32 val1 = *pSrc++;
 930         OPJ_UINT32 val2 = *pSrc++;
 931         OPJ_UINT32 val3 = *pSrc++;
 932         OPJ_UINT32 val4 = *pSrc++;
 933         OPJ_UINT32 val5 = *pSrc++;
 934         OPJ_UINT32 val6 = *pSrc++;
 935         OPJ_UINT32 val7 = *pSrc++;
 936         OPJ_UINT32 val8 = *pSrc++;
 937
 938         pDst[i + 0] = (OPJ_INT32)((val0 << 1) | (val1 >> 7));
 939         pDst[i + 1] = (OPJ_INT32)(((val1 & 0x7FU) << 2) | (val2 >> 6));
 940         pDst[i + 2] = (OPJ_INT32)(((val2 & 0x3FU) << 3) | (val3 >> 5));
 941         pDst[i + 3] = (OPJ_INT32)(((val3 & 0x1FU) << 4) | (val4 >> 4));
 942         pDst[i + 4] = (OPJ_INT32)(((val4 & 0xFU) << 5) | (val5 >> 3));
 943         pDst[i + 5] = (OPJ_INT32)(((val5 & 0x7U) << 6) | (val6 >> 2));
 944         pDst[i + 6] = (OPJ_INT32)(((val6 & 0x3U) << 7) | (val7 >> 1));
 945         pDst[i + 7] = (OPJ_INT32)(((val7 & 0x1U) << 8) | (val8));
 946
 947     }
 948     if (length & 7U) {
 949         unsigned int val;
 950         int available = 0;
 951
 952         length = length & 7U;
 953
 954         GETBITS(pDst[i + 0], 9)
 955
 956         if (length > 1U) {
 957             GETBITS(pDst[i + 1], 9)
 958             if (length > 2U) {
 959                 GETBITS(pDst[i + 2], 9)
 960                 if (length > 3U) {
 961                     GETBITS(pDst[i + 3], 9)
 962                     if (length > 4U) {
 963                         GETBITS(pDst[i + 4], 9)
 964                         if (length > 5U) {
 965                             GETBITS(pDst[i + 5], 9)
 966                             if (length > 6U) {
 967                                 GETBITS(pDst[i + 6], 9)
 968                             }
 969                         }
 970                     }
 971                 }
 972             }
 973         }
 974     }
 975 }
 976 static void tif_10uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 977                          OPJ_SIZE_T length)
 978 {
 979     OPJ_SIZE_T i;
 980     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
 981         OPJ_UINT32 val0 = *pSrc++;
 982         OPJ_UINT32 val1 = *pSrc++;
 983         OPJ_UINT32 val2 = *pSrc++;
 984         OPJ_UINT32 val3 = *pSrc++;
 985         OPJ_UINT32 val4 = *pSrc++;
 986
 987         pDst[i + 0] = (OPJ_INT32)((val0 << 2) | (val1 >> 6));
 988         pDst[i + 1] = (OPJ_INT32)(((val1 & 0x3FU) << 4) | (val2 >> 4));
 989         pDst[i + 2] = (OPJ_INT32)(((val2 & 0xFU) << 6) | (val3 >> 2));
 990         pDst[i + 3] = (OPJ_INT32)(((val3 & 0x3U) << 8) | val4);
 991
 992     }
 993     if (length & 3U) {
 994         OPJ_UINT32 val0 = *pSrc++;
 995         OPJ_UINT32 val1 = *pSrc++;
 996         length = length & 3U;
 997         pDst[i + 0] = (OPJ_INT32)((val0 << 2) | (val1 >> 6));
 998
 999         if (length > 1U) {
1000             OPJ_UINT32 val2 = *pSrc++;
1001             pDst[i + 1] = (OPJ_INT32)(((val1 & 0x3FU) << 4) | (val2 >> 4));
1002             if (length > 2U) {
1003                 OPJ_UINT32 val3 = *pSrc++;
1004                 pDst[i + 2] = (OPJ_INT32)(((val2 & 0xFU) << 6) | (val3 >> 2));
1005             }
1006         }
1007     }
1008 }
1009 static void tif_11uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
1010                          OPJ_SIZE_T length)
1011 {
1012     OPJ_SIZE_T i;
1013     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
1014         OPJ_UINT32 val0 = *pSrc++;
1015         OPJ_UINT32 val1 = *pSrc++;
1016         OPJ_UINT32 val2 = *pSrc++;
1017         OPJ_UINT32 val3 = *pSrc++;
1018         OPJ_UINT32 val4 = *pSrc++;
1019         OPJ_UINT32 val5 = *pSrc++;
1020         OPJ_UINT32 val6 = *pSrc++;
1021         OPJ_UINT32 val7 = *pSrc++;
1022         OPJ_UINT32 val8 = *pSrc++;
1023         OPJ_UINT32 val9 = *pSrc++;
1024         OPJ_UINT32 val10 = *pSrc++;
1025
1026         pDst[i + 0] = (OPJ_INT32)((val0 << 3) | (val1 >> 5));
1027         pDst[i + 1] = (OPJ_INT32)(((val1 & 0x1FU) << 6) | (val2 >> 2));
1028         pDst[i + 2] = (OPJ_INT32)(((val2 & 0x3U) << 9) | (val3 << 1) | (val4 >> 7));
1029         pDst[i + 3] = (OPJ_INT32)(((val4 & 0x7FU) << 4) | (val5 >> 4));
1030         pDst[i + 4] = (OPJ_INT32)(((val5 & 0xFU) << 7) | (val6 >> 1));
1031         pDst[i + 5] = (OPJ_INT32)(((val6 & 0x1U) << 10) | (val7 << 2) | (val8 >> 6));
1032         pDst[i + 6] = (OPJ_INT32)(((val8 & 0x3FU) << 5) | (val9 >> 3));
1033         pDst[i + 7] = (OPJ_INT32)(((val9 & 0x7U) << 8) | (val10));
1034
1035     }
1036     if (length & 7U) {
1037         unsigned int val;
1038         int available = 0;
1039
1040         length = length & 7U;
1041
1042         GETBITS(pDst[i + 0], 11)
1043
1044         if (length > 1U) {
1045             GETBITS(pDst[i + 1], 11)
1046             if (length > 2U) {
1047                 GETBITS(pDst[i + 2], 11)
1048                 if (length > 3U) {
1049                     GETBITS(pDst[i + 3], 11)
1050                     if (length > 4U) {
1051                         GETBITS(pDst[i + 4], 11)
1052                         if (length > 5U) {
1053                             GETBITS(pDst[i + 5], 11)
1054                             if (length > 6U) {
1055                                 GETBITS(pDst[i + 6], 11)
1056                             }
1057                         }
1058                     }
1059                 }
1060             }
1061         }
1062     }
1063 }
1064 static void tif_12uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
1065                          OPJ_SIZE_T length)
1066 {
1067     OPJ_SIZE_T i;
1068     for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i += 2U) {
1069         OPJ_UINT32 val0 = *pSrc++;
1070         OPJ_UINT32 val1 = *pSrc++;
1071         OPJ_UINT32 val2 = *pSrc++;
1072
1073         pDst[i + 0] = (OPJ_INT32)((val0 << 4) | (val1 >> 4));
1074         pDst[i + 1] = (OPJ_INT32)(((val1 & 0xFU) << 8) | val2);
1075     }
1076     if (length & 1U) {
1077         OPJ_UINT32 val0 = *pSrc++;
1078         OPJ_UINT32 val1 = *pSrc++;
1079         pDst[i + 0] = (OPJ_INT32)((val0 << 4) | (val1 >> 4));
1080     }
1081 }
1082 static void tif_13uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
1083                          OPJ_SIZE_T length)
1084 {
1085     OPJ_SIZE_T i;
1086     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
1087         OPJ_UINT32 val0 = *pSrc++;
1088         OPJ_UINT32 val1 = *pSrc++;
1089         OPJ_UINT32 val2 = *pSrc++;
1090         OPJ_UINT32 val3 = *pSrc++;
1091         OPJ_UINT32 val4 = *pSrc++;
1092         OPJ_UINT32 val5 = *pSrc++;
1093         OPJ_UINT32 val6 = *pSrc++;
1094         OPJ_UINT32 val7 = *pSrc++;
1095         OPJ_UINT32 val8 = *pSrc++;
1096         OPJ_UINT32 val9 = *pSrc++;
1097         OPJ_UINT32 val10 = *pSrc++;
1098         OPJ_UINT32 val11 = *pSrc++;
1099         OPJ_UINT32 val12 = *pSrc++;
1100
1101         pDst[i + 0] = (OPJ_INT32)((val0 << 5) | (val1 >> 3));
1102         pDst[i + 1] = (OPJ_INT32)(((val1 & 0x7U) << 10) | (val2 << 2) | (val3 >> 6));
1103         pDst[i + 2] = (OPJ_INT32)(((val3 & 0x3FU) << 7) | (val4 >> 1));
1104         pDst[i + 3] = (OPJ_INT32)(((val4 & 0x1U) << 12) | (val5 << 4) | (val6 >> 4));
1105         pDst[i + 4] = (OPJ_INT32)(((val6 & 0xFU) << 9) | (val7 << 1) | (val8 >> 7));
1106         pDst[i + 5] = (OPJ_INT32)(((val8 & 0x7FU) << 6) | (val9 >> 2));
1107         pDst[i + 6] = (OPJ_INT32)(((val9 & 0x3U) << 11) | (val10 << 3) | (val11 >> 5));
1108         pDst[i + 7] = (OPJ_INT32)(((val11 & 0x1FU) << 8) | (val12));
1109
1110     }
1111     if (length & 7U) {
1112         unsigned int val;
1113         int available = 0;
1114
1115         length = length & 7U;
1116
1117         GETBITS(pDst[i + 0], 13)
1118
1119         if (length > 1U) {
1120             GETBITS(pDst[i + 1], 13)
1121             if (length > 2U) {
1122                 GETBITS(pDst[i + 2], 13)
1123                 if (length > 3U) {
1124                     GETBITS(pDst[i + 3], 13)
1125                     if (length > 4U) {
1126                         GETBITS(pDst[i + 4], 13)
1127                         if (length > 5U) {
1128                             GETBITS(pDst[i + 5], 13)
1129                             if (length > 6U) {
1130                                 GETBITS(pDst[i + 6], 13)
1131                             }
1132                         }
1133                     }
1134                 }
1135             }
1136         }
1137     }
1138 }
1139 static void tif_14uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
1140                          OPJ_SIZE_T length)
1141 {
1142     OPJ_SIZE_T i;
1143     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
1144         OPJ_UINT32 val0 = *pSrc++;
1145         OPJ_UINT32 val1 = *pSrc++;
1146         OPJ_UINT32 val2 = *pSrc++;
1147         OPJ_UINT32 val3 = *pSrc++;
1148         OPJ_UINT32 val4 = *pSrc++;
1149         OPJ_UINT32 val5 = *pSrc++;
1150         OPJ_UINT32 val6 = *pSrc++;
1151
1152         pDst[i + 0] = (OPJ_INT32)((val0 << 6) | (val1 >> 2));
1153         pDst[i + 1] = (OPJ_INT32)(((val1 & 0x3U) << 12) | (val2 << 4) | (val3 >> 4));
1154         pDst[i + 2] = (OPJ_INT32)(((val3 & 0xFU) << 10) | (val4 << 2) | (val5 >> 6));
1155         pDst[i + 3] = (OPJ_INT32)(((val5 & 0x3FU) << 8) | val6);
1156
1157     }
1158     if (length & 3U) {
1159         OPJ_UINT32 val0 = *pSrc++;
1160         OPJ_UINT32 val1 = *pSrc++;
1161         length = length & 3U;
1162         pDst[i + 0] = (OPJ_INT32)((val0 << 6) | (val1 >> 2));
1163
1164         if (length > 1U) {
1165             OPJ_UINT32 val2 = *pSrc++;
1166             OPJ_UINT32 val3 = *pSrc++;
1167             pDst[i + 1] = (OPJ_INT32)(((val1 & 0x3U) << 12) | (val2 << 4) | (val3 >> 4));
1168             if (length > 2U) {
1169                 OPJ_UINT32 val4 = *pSrc++;
1170                 OPJ_UINT32 val5 = *pSrc++;
1171                 pDst[i + 2] = (OPJ_INT32)(((val3 & 0xFU) << 10) | (val4 << 2) | (val5 >> 6));
1172             }
1173         }
1174     }
1175 }
1176 static void tif_15uto32s(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
1177                          OPJ_SIZE_T length)
1178 {
1179     OPJ_SIZE_T i;
1180     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
1181         OPJ_UINT32 val0 = *pSrc++;
1182         OPJ_UINT32 val1 = *pSrc++;
1183         OPJ_UINT32 val2 = *pSrc++;
1184         OPJ_UINT32 val3 = *pSrc++;
1185         OPJ_UINT32 val4 = *pSrc++;
1186         OPJ_UINT32 val5 = *pSrc++;
1187         OPJ_UINT32 val6 = *pSrc++;
1188         OPJ_UINT32 val7 = *pSrc++;
1189         OPJ_UINT32 val8 = *pSrc++;
1190         OPJ_UINT32 val9 = *pSrc++;
1191         OPJ_UINT32 val10 = *pSrc++;
1192         OPJ_UINT32 val11 = *pSrc++;
1193         OPJ_UINT32 val12 = *pSrc++;
1194         OPJ_UINT32 val13 = *pSrc++;
1195         OPJ_UINT32 val14 = *pSrc++;
1196
1197         pDst[i + 0] = (OPJ_INT32)((val0 << 7) | (val1 >> 1));
1198         pDst[i + 1] = (OPJ_INT32)(((val1 & 0x1U) << 14) | (val2 << 6) | (val3 >> 2));
1199         pDst[i + 2] = (OPJ_INT32)(((val3 & 0x3U) << 13) | (val4 << 5) | (val5 >> 3));
1200         pDst[i + 3] = (OPJ_INT32)(((val5 & 0x7U) << 12) | (val6 << 4) | (val7 >> 4));
1201         pDst[i + 4] = (OPJ_INT32)(((val7 & 0xFU) << 11) | (val8 << 3) | (val9 >> 5));
1202         pDst[i + 5] = (OPJ_INT32)(((val9 & 0x1FU) << 10) | (val10 << 2) | (val11 >> 6));
1203         pDst[i + 6] = (OPJ_INT32)(((val11 & 0x3FU) << 9) | (val12 << 1) | (val13 >> 7));
1204         pDst[i + 7] = (OPJ_INT32)(((val13 & 0x7FU) << 8) | (val14));
1205
1206     }
1207     if (length & 7U) {
1208         unsigned int val;
1209         int available = 0;
1210
1211         length = length & 7U;
1212
1213         GETBITS(pDst[i + 0], 15)
1214
1215         if (length > 1U) {
1216             GETBITS(pDst[i + 1], 15)
1217             if (length > 2U) {
1218                 GETBITS(pDst[i + 2], 15)
1219                 if (length > 3U) {
1220                     GETBITS(pDst[i + 3], 15)
1221                     if (length > 4U) {
1222                         GETBITS(pDst[i + 4], 15)
1223                         if (length > 5U) {
1224                             GETBITS(pDst[i + 5], 15)
1225                             if (length > 6U) {
1226                                 GETBITS(pDst[i + 6], 15)
1227                             }
1228                         }
1229                     }
1230                 }
1231             }
1232         }
1233     }
1234 }
1235
1236 /* seems that libtiff decodes this to machine endianness */
1237 static void tif_16uto32s(const OPJ_UINT16* pSrc, OPJ_INT32* pDst,
1238                          OPJ_SIZE_T length)
1239 {
1240     OPJ_SIZE_T i;
1241     for (i = 0; i < length; i++) {
1242         pDst[i] = pSrc[i];
1243     }
1244 }
1245
1246 /*
1247  * libtiff/tif_getimage.c : 1,2,4,8,16 bitspersample accepted
1248  * CINEMA                 : 12 bit precision
1249  */
1250 opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters)
1251 {
1252     int subsampling_dx = parameters->subsampling_dx;
1253     int subsampling_dy = parameters->subsampling_dy;
1254     TIFF *tif;
1255     tdata_t buf;
1256     tstrip_t strip;
1257     int64_t strip_size, rowStride, TIFF_MAX;
1258     int j, currentPlane, numcomps = 0, w, h;
1259     OPJ_COLOR_SPACE color_space = OPJ_CLRSPC_UNKNOWN;
1260     opj_image_cmptparm_t cmptparm[4]; /* RGBA */
1261     opj_image_t *image = NULL;
1262     uint16 tiBps, tiPhoto, tiSf, tiSpp, tiPC;
1263     uint32 tiWidth, tiHeight;
1264     OPJ_BOOL is_cinema = OPJ_IS_CINEMA(parameters->rsiz);
1265     convert_XXx32s_C1R cvtTifTo32s = NULL;
1266     convert_32s_CXPX cvtCxToPx = NULL;
1267     OPJ_INT32* buffer32s = NULL;
1268     OPJ_INT32* planes[4];
1269
1270     tif = TIFFOpen(filename, "r");
1271
1272     if (!tif) {
1273         fprintf(stderr, "tiftoimage:Failed to open %s for reading\n", filename);
1274         return 0;
1275     }
1276     tiBps = tiPhoto = tiSf = tiSpp = tiPC = 0;
1277     tiWidth = tiHeight = 0;
1278
1279     TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &tiWidth);
1280     TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &tiHeight);
1281     TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &tiBps);
1282     TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &tiSf);
1283     TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &tiSpp);
1284     TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &tiPhoto);
1285     TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &tiPC);
1286     w = (int)tiWidth;
1287     h = (int)tiHeight;
1288
1289     if (tiSpp == 0 || tiSpp > 4) { /* should be 1 ... 4 */
1290         fprintf(stderr, "tiftoimage: Bad value for samples per pixel == %d.\n"
1291                 "\tAborting.\n", tiSpp);
1292         TIFFClose(tif);
1293         return NULL;
1294     }
1295     if (tiBps > 16U || tiBps == 0) {
1296         fprintf(stderr, "tiftoimage: Bad values for Bits == %d.\n"
1297                 "\tMax. 16 Bits are allowed here.\n\tAborting.\n", tiBps);
1298         TIFFClose(tif);
1299         return NULL;
1300     }
1301     if (tiPhoto != PHOTOMETRIC_MINISBLACK && tiPhoto != PHOTOMETRIC_RGB) {
1302         fprintf(stderr,
1303                 "tiftoimage: Bad color format %d.\n\tOnly RGB(A) and GRAY(A) has been implemented\n\tAborting.\n",
1304                 (int) tiPhoto);
1305         TIFFClose(tif);
1306         return NULL;
1307     }
1308     if (tiWidth == 0 || tiHeight == 0) {
1309         fprintf(stderr, "tiftoimage: Bad values for width(%u) "
1310                 "and/or height(%u)\n\tAborting.\n", tiWidth, tiHeight);
1311         TIFFClose(tif);
1312         return NULL;
1313     }
1314     w = (int)tiWidth;
1315     h = (int)tiHeight;
1316
1317     switch (tiBps) {
1318     case 1:
1319     case 2:
1320     case 4:
1321     case 6:
1322     case 8:
1323         cvtTifTo32s = convert_XXu32s_C1R_LUT[tiBps];
1324         break;
1325     /* others are specific to TIFF */
1326     case 3:
1327         cvtTifTo32s = tif_3uto32s;
1328         break;
1329     case 5:
1330         cvtTifTo32s = tif_5uto32s;
1331         break;
1332     case 7:
1333         cvtTifTo32s = tif_7uto32s;
1334         break;
1335     case 9:
1336         cvtTifTo32s = tif_9uto32s;
1337         break;
1338     case 10:
1339         cvtTifTo32s = tif_10uto32s;
1340         break;
1341     case 11:
1342         cvtTifTo32s = tif_11uto32s;
1343         break;
1344     case 12:
1345         cvtTifTo32s = tif_12uto32s;
1346         break;
1347     case 13:
1348         cvtTifTo32s = tif_13uto32s;
1349         break;
1350     case 14:
1351         cvtTifTo32s = tif_14uto32s;
1352         break;
1353     case 15:
1354         cvtTifTo32s = tif_15uto32s;
1355         break;
1356     case 16:
1357         cvtTifTo32s = (convert_XXx32s_C1R)tif_16uto32s;
1358         break;
1359     default:
1360         /* never here */
1361         break;
1362     }
1363
1364     /* initialize image components */
1365     memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
1366
1367     if ((tiPhoto == PHOTOMETRIC_RGB) && (is_cinema) && (tiBps != 12U)) {
1368         fprintf(stdout, "WARNING:\n"
1369                 "Input image bitdepth is %d bits\n"
1370                 "TIF conversion has automatically rescaled to 12-bits\n"
1371                 "to comply with cinema profiles.\n",
1372                 tiBps);
1373     } else {
1374         is_cinema = 0U;
1375     }
1376
1377     numcomps = tiSpp;
1378     if (tiPhoto == PHOTOMETRIC_RGB) { /* RGB(A) */
1379         color_space = OPJ_CLRSPC_SRGB;
1380     } else if (tiPhoto == PHOTOMETRIC_MINISBLACK) { /* GRAY(A) */
1381         color_space = OPJ_CLRSPC_GRAY;
1382     }
1383
1384     cvtCxToPx = convert_32s_CXPX_LUT[numcomps];
1385     if (tiPC == PLANARCONFIG_SEPARATE) {
1386         cvtCxToPx = convert_32s_CXPX_LUT[1]; /* override */
1387         tiSpp = 1U; /* consider only one sample per plane */
1388     }
1389
1390     for (j = 0; j < numcomps; j++) {
1391         cmptparm[j].prec = tiBps;
1392         cmptparm[j].bpp = tiBps;
1393         cmptparm[j].dx = (OPJ_UINT32)subsampling_dx;
1394         cmptparm[j].dy = (OPJ_UINT32)subsampling_dy;
1395         cmptparm[j].w = (OPJ_UINT32)w;
1396         cmptparm[j].h = (OPJ_UINT32)h;
1397     }
1398
1399     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
1400     if (!image) {
1401         TIFFClose(tif);
1402         return NULL;
1403     }
1404     /* set image offset and reference grid */
1405     image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
1406     image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
1407     image->x1 = !image->x0 ? (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1 :
1408                 image->x0 + (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1;
1409     if (image->x1 <= image->x0) {
1410         fprintf(stderr, "tiftoimage: Bad value for image->x1(%d) vs. "
1411                 "image->x0(%d)\n\tAborting.\n", image->x1, image->x0);
1412         TIFFClose(tif);
1413         opj_image_destroy(image);
1414         return NULL;
1415     }
1416     image->y1 = !image->y0 ? (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1 :
1417                 image->y0 + (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1;
1418     if (image->y1 <= image->y0) {
1419         fprintf(stderr, "tiftoimage: Bad value for image->y1(%d) vs. "
1420                 "image->y0(%d)\n\tAborting.\n", image->y1, image->y0);
1421         TIFFClose(tif);
1422         opj_image_destroy(image);
1423         return NULL;
1424     }
1425
1426     for (j = 0; j < numcomps; j++) {
1427         planes[j] = image->comps[j].data;
1428     }
1429     image->comps[numcomps - 1].alpha = (OPJ_UINT16)(1 - (numcomps & 1));
1430
1431     strip_size = (int64_t)TIFFStripSize(tif);
1432
1433     buf = malloc((OPJ_SIZE_T)strip_size);
1434     if (buf == NULL) {
1435         TIFFClose(tif);
1436         opj_image_destroy(image);
1437         return NULL;
1438     }
1439     if (sizeof(tsize_t) == 4) {
1440         TIFF_MAX = INT_MAX;
1441     } else {
1442         TIFF_MAX = UINT_MAX;
1443     }
1444     if ((int64_t)tiWidth > (int64_t)(TIFF_MAX / tiSpp) ||
1445             (int64_t)(tiWidth * tiSpp) > (int64_t)(TIFF_MAX / tiBps) ||
1446             (int64_t)(tiWidth * tiSpp) > (int64_t)(TIFF_MAX / (int64_t)sizeof(OPJ_INT32))) {
1447         fprintf(stderr, "Buffer overflow\n");
1448         _TIFFfree(buf);
1449         TIFFClose(tif);
1450         opj_image_destroy(image);
1451         return NULL;
1452     }
1453
1454     rowStride = (int64_t)((tiWidth * tiSpp * tiBps + 7U) / 8U);
1455     buffer32s = (OPJ_INT32 *)malloc(sizeof(OPJ_INT32) * tiWidth * tiSpp);
1456     if (buffer32s == NULL) {
1457         _TIFFfree(buf);
1458         TIFFClose(tif);
1459         opj_image_destroy(image);
1460         return NULL;
1461     }
1462
1463     strip = 0;
1464     currentPlane = 0;
1465     do {
1466         planes[0] = image->comps[currentPlane].data; /* to manage planar data */
1467         h = (int)tiHeight;
1468         /* Read the Image components */
1469         for (; (h > 0) && (strip < TIFFNumberOfStrips(tif)); strip++) {
1470             const OPJ_UINT8 *dat8;
1471             int64_t ssize;
1472
1473             ssize = (int64_t)TIFFReadEncodedStrip(tif, strip, buf, (tsize_t)strip_size);
1474
1475             if (ssize < 1 || ssize > strip_size) {
1476                 fprintf(stderr, "tiftoimage: Bad value for ssize(%" PRId64 ") "
1477                         "vs. strip_size(%" PRId64 ").\n\tAborting.\n", ssize, strip_size);
1478                 _TIFFfree(buf);
1479                 _TIFFfree(buffer32s);
1480                 TIFFClose(tif);
1481                 opj_image_destroy(image);
1482                 return NULL;
1483             }
1484             dat8 = (const OPJ_UINT8*)buf;
1485
1486             while (ssize >= rowStride) {
1487                 cvtTifTo32s(dat8, buffer32s, (OPJ_SIZE_T)w * tiSpp);
1488                 cvtCxToPx(buffer32s, planes, (OPJ_SIZE_T)w);
1489                 planes[0] += w;
1490                 planes[1] += w;
1491                 planes[2] += w;
1492                 planes[3] += w;
1493                 dat8  += rowStride;
1494                 ssize -= rowStride;
1495                 h--;
1496             }
1497         }
1498         currentPlane++;
1499     } while ((tiPC == PLANARCONFIG_SEPARATE) && (currentPlane < numcomps));
1500
1501     free(buffer32s);
1502     _TIFFfree(buf);
1503     TIFFClose(tif);
1504
1505     if (is_cinema) {
1506         for (j = 0; j < numcomps; ++j) {
1507             scale_component(&(image->comps[j]), 12);
1508         }
1509
1510     }
1511     return image;
1512
1513 }/* tiftoimage() */
1514