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