src/bin/jp2/converttif.c

   1 /*
   2  * The copyright in this software is being made available under the 2-clauses
   3  * BSD License, included below. This software may be subject to other third
   4  * party and contributor rights, including patent rights, and no such rights
   5  * are granted under this license.
   6  *
   7  * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
   8  * Copyright (c) 2002-2014, Professor Benoit Macq
   9  * Copyright (c) 2001-2003, David Janssens
  10  * Copyright (c) 2002-2003, Yannick Verschueren
  11  * Copyright (c) 2003-2007, Francois-Olivier Devaux
  12  * Copyright (c) 2003-2014, Antonin Descampe
  13  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  14  * Copyright (c) 2006-2007, Parvatha Elangovan
  15  * Copyright (c) 2015, Matthieu Darbois
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGE.
  38  */
  39 #include "opj_apps_config.h"
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45 #include <limits.h>
  46
  47 #ifndef OPJ_HAVE_LIBTIFF
  48 # error OPJ_HAVE_LIBTIFF_NOT_DEFINED
  49 #endif /* OPJ_HAVE_LIBTIFF */
  50
  51 #include <tiffio.h>
  52 #include "openjpeg.h"
  53 #include "convert.h"
  54 #include "opj_inttypes.h"
  55
  56 /* -->> -->> -->> -->>
  57
  58  TIFF IMAGE FORMAT
  59
  60  <<-- <<-- <<-- <<-- */
  61 #define PUTBITS2(s, nb) \
  62     trailing <<= remaining; \
  63     trailing |= (unsigned int)((s) >> (nb - remaining)); \
  64     *pDst++ = (OPJ_BYTE)trailing; \
  65     trailing = (unsigned int)((s) & ((1U << (nb - remaining)) - 1U)); \
  66     if (nb >= (remaining + 8)) { \
  67         *pDst++ = (OPJ_BYTE)(trailing >> (nb - (remaining + 8))); \
  68         trailing &= (unsigned int)((1U << (nb - (remaining + 8))) - 1U); \
  69         remaining += 16 - nb; \
  70     } else { \
  71         remaining += 8 - nb; \
  72     }
  73
  74 #define PUTBITS(s, nb) \
  75   if (nb >= remaining) { \
  76         PUTBITS2(s, nb) \
  77     } else { \
  78         trailing <<= nb; \
  79         trailing |= (unsigned int)(s); \
  80         remaining -= nb; \
  81     }
  82 #define FLUSHBITS() \
  83     if (remaining != 8) { \
  84         trailing <<= remaining; \
  85         *pDst++ = (OPJ_BYTE)trailing; \
  86     }
  87
  88 static void tif_32sto3u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
  89                         OPJ_SIZE_T length)
  90 {
  91     OPJ_SIZE_T i;
  92
  93     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
  94         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
  95         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
  96         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
  97         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
  98         OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i + 4];
  99         OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i + 5];
 100         OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i + 6];
 101         OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i + 7];
 102
 103         *pDst++ = (OPJ_BYTE)((src0 << 5) | (src1 << 2) | (src2 >> 1));
 104         *pDst++ = (OPJ_BYTE)((src2 << 7) | (src3 << 4) | (src4 << 1) | (src5 >> 2));
 105         *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 << 3) | (src7));
 106     }
 107
 108     if (length & 7U) {
 109         unsigned int trailing = 0U;
 110         int remaining = 8U;
 111         length &= 7U;
 112         PUTBITS((OPJ_UINT32)pSrc[i + 0], 3)
 113         if (length > 1U) {
 114             PUTBITS((OPJ_UINT32)pSrc[i + 1], 3)
 115             if (length > 2U) {
 116                 PUTBITS((OPJ_UINT32)pSrc[i + 2], 3)
 117                 if (length > 3U) {
 118                     PUTBITS((OPJ_UINT32)pSrc[i + 3], 3)
 119                     if (length > 4U) {
 120                         PUTBITS((OPJ_UINT32)pSrc[i + 4], 3)
 121                         if (length > 5U) {
 122                             PUTBITS((OPJ_UINT32)pSrc[i + 5], 3)
 123                             if (length > 6U) {
 124                                 PUTBITS((OPJ_UINT32)pSrc[i + 6], 3)
 125                             }
 126                         }
 127                     }
 128                 }
 129             }
 130         }
 131         FLUSHBITS()
 132     }
 133 }
 134
 135 static void tif_32sto5u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 136                         OPJ_SIZE_T length)
 137 {
 138     OPJ_SIZE_T i;
 139
 140     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 141         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 142         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 143         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 144         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 145         OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i + 4];
 146         OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i + 5];
 147         OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i + 6];
 148         OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i + 7];
 149
 150         *pDst++ = (OPJ_BYTE)((src0 << 3) | (src1 >> 2));
 151         *pDst++ = (OPJ_BYTE)((src1 << 6) | (src2 << 1) | (src3 >> 4));
 152         *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 1));
 153         *pDst++ = (OPJ_BYTE)((src4 << 7) | (src5 << 2) | (src6 >> 3));
 154         *pDst++ = (OPJ_BYTE)((src6 << 5) | (src7));
 155
 156     }
 157
 158     if (length & 7U) {
 159         unsigned int trailing = 0U;
 160         int remaining = 8U;
 161         length &= 7U;
 162         PUTBITS((OPJ_UINT32)pSrc[i + 0], 5)
 163         if (length > 1U) {
 164             PUTBITS((OPJ_UINT32)pSrc[i + 1], 5)
 165             if (length > 2U) {
 166                 PUTBITS((OPJ_UINT32)pSrc[i + 2], 5)
 167                 if (length > 3U) {
 168                     PUTBITS((OPJ_UINT32)pSrc[i + 3], 5)
 169                     if (length > 4U) {
 170                         PUTBITS((OPJ_UINT32)pSrc[i + 4], 5)
 171                         if (length > 5U) {
 172                             PUTBITS((OPJ_UINT32)pSrc[i + 5], 5)
 173                             if (length > 6U) {
 174                                 PUTBITS((OPJ_UINT32)pSrc[i + 6], 5)
 175                             }
 176                         }
 177                     }
 178                 }
 179             }
 180         }
 181         FLUSHBITS()
 182     }
 183 }
 184
 185 static void tif_32sto7u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 186                         OPJ_SIZE_T length)
 187 {
 188     OPJ_SIZE_T i;
 189
 190     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 191         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 192         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 193         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 194         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 195         OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i + 4];
 196         OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i + 5];
 197         OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i + 6];
 198         OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i + 7];
 199
 200         *pDst++ = (OPJ_BYTE)((src0 << 1) | (src1 >> 6));
 201         *pDst++ = (OPJ_BYTE)((src1 << 2) | (src2 >> 5));
 202         *pDst++ = (OPJ_BYTE)((src2 << 3) | (src3 >> 4));
 203         *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 3));
 204         *pDst++ = (OPJ_BYTE)((src4 << 5) | (src5 >> 2));
 205         *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 >> 1));
 206         *pDst++ = (OPJ_BYTE)((src6 << 7) | (src7));
 207     }
 208
 209     if (length & 7U) {
 210         unsigned int trailing = 0U;
 211         int remaining = 8U;
 212         length &= 7U;
 213         PUTBITS((OPJ_UINT32)pSrc[i + 0], 7)
 214         if (length > 1U) {
 215             PUTBITS((OPJ_UINT32)pSrc[i + 1], 7)
 216             if (length > 2U) {
 217                 PUTBITS((OPJ_UINT32)pSrc[i + 2], 7)
 218                 if (length > 3U) {
 219                     PUTBITS((OPJ_UINT32)pSrc[i + 3], 7)
 220                     if (length > 4U) {
 221                         PUTBITS((OPJ_UINT32)pSrc[i + 4], 7)
 222                         if (length > 5U) {
 223                             PUTBITS((OPJ_UINT32)pSrc[i + 5], 7)
 224                             if (length > 6U) {
 225                                 PUTBITS((OPJ_UINT32)pSrc[i + 6], 7)
 226                             }
 227                         }
 228                     }
 229                 }
 230             }
 231         }
 232         FLUSHBITS()
 233     }
 234 }
 235
 236 static void tif_32sto9u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 237                         OPJ_SIZE_T length)
 238 {
 239     OPJ_SIZE_T i;
 240
 241     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 242         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 243         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 244         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 245         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 246         OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i + 4];
 247         OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i + 5];
 248         OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i + 6];
 249         OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i + 7];
 250
 251         *pDst++ = (OPJ_BYTE)((src0 >> 1));
 252         *pDst++ = (OPJ_BYTE)((src0 << 7) | (src1 >> 2));
 253         *pDst++ = (OPJ_BYTE)((src1 << 6) | (src2 >> 3));
 254         *pDst++ = (OPJ_BYTE)((src2 << 5) | (src3 >> 4));
 255         *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 5));
 256         *pDst++ = (OPJ_BYTE)((src4 << 3) | (src5 >> 6));
 257         *pDst++ = (OPJ_BYTE)((src5 << 2) | (src6 >> 7));
 258         *pDst++ = (OPJ_BYTE)((src6 << 1) | (src7 >> 8));
 259         *pDst++ = (OPJ_BYTE)(src7);
 260     }
 261
 262     if (length & 7U) {
 263         unsigned int trailing = 0U;
 264         int remaining = 8U;
 265         length &= 7U;
 266         PUTBITS2((OPJ_UINT32)pSrc[i + 0], 9)
 267         if (length > 1U) {
 268             PUTBITS2((OPJ_UINT32)pSrc[i + 1], 9)
 269             if (length > 2U) {
 270                 PUTBITS2((OPJ_UINT32)pSrc[i + 2], 9)
 271                 if (length > 3U) {
 272                     PUTBITS2((OPJ_UINT32)pSrc[i + 3], 9)
 273                     if (length > 4U) {
 274                         PUTBITS2((OPJ_UINT32)pSrc[i + 4], 9)
 275                         if (length > 5U) {
 276                             PUTBITS2((OPJ_UINT32)pSrc[i + 5], 9)
 277                             if (length > 6U) {
 278                                 PUTBITS2((OPJ_UINT32)pSrc[i + 6], 9)
 279                             }
 280                         }
 281                     }
 282                 }
 283             }
 284         }
 285         FLUSHBITS()
 286     }
 287 }
 288
 289 static void tif_32sto10u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 290                          OPJ_SIZE_T length)
 291 {
 292     OPJ_SIZE_T i;
 293     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
 294         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 295         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 296         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 297         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 298
 299         *pDst++ = (OPJ_BYTE)(src0 >> 2);
 300         *pDst++ = (OPJ_BYTE)(((src0 & 0x3U) << 6) | (src1 >> 4));
 301         *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 6));
 302         *pDst++ = (OPJ_BYTE)(((src2 & 0x3FU) << 2) | (src3 >> 8));
 303         *pDst++ = (OPJ_BYTE)(src3);
 304     }
 305
 306     if (length & 3U) {
 307         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 308         OPJ_UINT32 src1 = 0U;
 309         OPJ_UINT32 src2 = 0U;
 310         length = length & 3U;
 311
 312         if (length > 1U) {
 313             src1 = (OPJ_UINT32)pSrc[i + 1];
 314             if (length > 2U) {
 315                 src2 = (OPJ_UINT32)pSrc[i + 2];
 316             }
 317         }
 318         *pDst++ = (OPJ_BYTE)(src0 >> 2);
 319         *pDst++ = (OPJ_BYTE)(((src0 & 0x3U) << 6) | (src1 >> 4));
 320         if (length > 1U) {
 321             *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 6));
 322             if (length > 2U) {
 323                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3FU) << 2));
 324             }
 325         }
 326     }
 327 }
 328 static void tif_32sto11u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 329                          OPJ_SIZE_T length)
 330 {
 331     OPJ_SIZE_T i;
 332
 333     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 334         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 335         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 336         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 337         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 338         OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i + 4];
 339         OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i + 5];
 340         OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i + 6];
 341         OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i + 7];
 342
 343         *pDst++ = (OPJ_BYTE)((src0 >> 3));
 344         *pDst++ = (OPJ_BYTE)((src0 << 5) | (src1 >> 6));
 345         *pDst++ = (OPJ_BYTE)((src1 << 2) | (src2 >> 9));
 346         *pDst++ = (OPJ_BYTE)((src2 >> 1));
 347         *pDst++ = (OPJ_BYTE)((src2 << 7) | (src3 >> 4));
 348         *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 7));
 349         *pDst++ = (OPJ_BYTE)((src4 << 1) | (src5 >> 10));
 350         *pDst++ = (OPJ_BYTE)((src5 >> 2));
 351         *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 >> 5));
 352         *pDst++ = (OPJ_BYTE)((src6 << 3) | (src7 >> 8));
 353         *pDst++ = (OPJ_BYTE)(src7);
 354     }
 355
 356     if (length & 7U) {
 357         unsigned int trailing = 0U;
 358         int remaining = 8U;
 359         length &= 7U;
 360         PUTBITS2((OPJ_UINT32)pSrc[i + 0], 11)
 361         if (length > 1U) {
 362             PUTBITS2((OPJ_UINT32)pSrc[i + 1], 11)
 363             if (length > 2U) {
 364                 PUTBITS2((OPJ_UINT32)pSrc[i + 2], 11)
 365                 if (length > 3U) {
 366                     PUTBITS2((OPJ_UINT32)pSrc[i + 3], 11)
 367                     if (length > 4U) {
 368                         PUTBITS2((OPJ_UINT32)pSrc[i + 4], 11)
 369                         if (length > 5U) {
 370                             PUTBITS2((OPJ_UINT32)pSrc[i + 5], 11)
 371                             if (length > 6U) {
 372                                 PUTBITS2((OPJ_UINT32)pSrc[i + 6], 11)
 373                             }
 374                         }
 375                     }
 376                 }
 377             }
 378         }
 379         FLUSHBITS()
 380     }
 381 }
 382 static void tif_32sto12u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 383                          OPJ_SIZE_T length)
 384 {
 385     OPJ_SIZE_T i;
 386     for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i += 2U) {
 387         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 388         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 389
 390         *pDst++ = (OPJ_BYTE)(src0 >> 4);
 391         *pDst++ = (OPJ_BYTE)(((src0 & 0xFU) << 4) | (src1 >> 8));
 392         *pDst++ = (OPJ_BYTE)(src1);
 393     }
 394
 395     if (length & 1U) {
 396         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 397         *pDst++ = (OPJ_BYTE)(src0 >> 4);
 398         *pDst++ = (OPJ_BYTE)(((src0 & 0xFU) << 4));
 399     }
 400 }
 401 static void tif_32sto13u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 402                          OPJ_SIZE_T length)
 403 {
 404     OPJ_SIZE_T i;
 405
 406     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 407         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 408         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 409         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 410         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 411         OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i + 4];
 412         OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i + 5];
 413         OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i + 6];
 414         OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i + 7];
 415
 416         *pDst++ = (OPJ_BYTE)((src0 >> 5));
 417         *pDst++ = (OPJ_BYTE)((src0 << 3) | (src1 >> 10));
 418         *pDst++ = (OPJ_BYTE)((src1 >> 2));
 419         *pDst++ = (OPJ_BYTE)((src1 << 6) | (src2 >> 7));
 420         *pDst++ = (OPJ_BYTE)((src2 << 1) | (src3 >> 12));
 421         *pDst++ = (OPJ_BYTE)((src3 >> 4));
 422         *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 9));
 423         *pDst++ = (OPJ_BYTE)((src4 >> 1));
 424         *pDst++ = (OPJ_BYTE)((src4 << 7) | (src5 >> 6));
 425         *pDst++ = (OPJ_BYTE)((src5 << 2) | (src6 >> 11));
 426         *pDst++ = (OPJ_BYTE)((src6 >> 3));
 427         *pDst++ = (OPJ_BYTE)((src6 << 5) | (src7 >> 8));
 428         *pDst++ = (OPJ_BYTE)(src7);
 429     }
 430
 431     if (length & 7U) {
 432         unsigned int trailing = 0U;
 433         int remaining = 8U;
 434         length &= 7U;
 435         PUTBITS2((OPJ_UINT32)pSrc[i + 0], 13)
 436         if (length > 1U) {
 437             PUTBITS2((OPJ_UINT32)pSrc[i + 1], 13)
 438             if (length > 2U) {
 439                 PUTBITS2((OPJ_UINT32)pSrc[i + 2], 13)
 440                 if (length > 3U) {
 441                     PUTBITS2((OPJ_UINT32)pSrc[i + 3], 13)
 442                     if (length > 4U) {
 443                         PUTBITS2((OPJ_UINT32)pSrc[i + 4], 13)
 444                         if (length > 5U) {
 445                             PUTBITS2((OPJ_UINT32)pSrc[i + 5], 13)
 446                             if (length > 6U) {
 447                                 PUTBITS2((OPJ_UINT32)pSrc[i + 6], 13)
 448                             }
 449                         }
 450                     }
 451                 }
 452             }
 453         }
 454         FLUSHBITS()
 455     }
 456 }
 457 static void tif_32sto14u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 458                          OPJ_SIZE_T length)
 459 {
 460     OPJ_SIZE_T i;
 461     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
 462         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 463         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 464         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 465         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 466
 467         *pDst++ = (OPJ_BYTE)(src0 >> 6);
 468         *pDst++ = (OPJ_BYTE)(((src0 & 0x3FU) << 2) | (src1 >> 12));
 469         *pDst++ = (OPJ_BYTE)(src1 >> 4);
 470         *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 10));
 471         *pDst++ = (OPJ_BYTE)(src2 >> 2);
 472         *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6) | (src3 >> 8));
 473         *pDst++ = (OPJ_BYTE)(src3);
 474     }
 475
 476     if (length & 3U) {
 477         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 478         OPJ_UINT32 src1 = 0U;
 479         OPJ_UINT32 src2 = 0U;
 480         length = length & 3U;
 481
 482         if (length > 1U) {
 483             src1 = (OPJ_UINT32)pSrc[i + 1];
 484             if (length > 2U) {
 485                 src2 = (OPJ_UINT32)pSrc[i + 2];
 486             }
 487         }
 488         *pDst++ = (OPJ_BYTE)(src0 >> 6);
 489         *pDst++ = (OPJ_BYTE)(((src0 & 0x3FU) << 2) | (src1 >> 12));
 490         if (length > 1U) {
 491             *pDst++ = (OPJ_BYTE)(src1 >> 4);
 492             *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 10));
 493             if (length > 2U) {
 494                 *pDst++ = (OPJ_BYTE)(src2 >> 2);
 495                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6));
 496             }
 497         }
 498     }
 499 }
 500 static void tif_32sto15u(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 501                          OPJ_SIZE_T length)
 502 {
 503     OPJ_SIZE_T i;
 504
 505     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 506         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 507         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 508         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 509         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 510         OPJ_UINT32 src4 = (OPJ_UINT32)pSrc[i + 4];
 511         OPJ_UINT32 src5 = (OPJ_UINT32)pSrc[i + 5];
 512         OPJ_UINT32 src6 = (OPJ_UINT32)pSrc[i + 6];
 513         OPJ_UINT32 src7 = (OPJ_UINT32)pSrc[i + 7];
 514
 515         *pDst++ = (OPJ_BYTE)((src0 >> 7));
 516         *pDst++ = (OPJ_BYTE)((src0 << 1) | (src1 >> 14));
 517         *pDst++ = (OPJ_BYTE)((src1 >> 6));
 518         *pDst++ = (OPJ_BYTE)((src1 << 2) | (src2 >> 13));
 519         *pDst++ = (OPJ_BYTE)((src2 >> 5));
 520         *pDst++ = (OPJ_BYTE)((src2 << 3) | (src3 >> 12));
 521         *pDst++ = (OPJ_BYTE)((src3 >> 4));
 522         *pDst++ = (OPJ_BYTE)((src3 << 4) | (src4 >> 11));
 523         *pDst++ = (OPJ_BYTE)((src4 >> 3));
 524         *pDst++ = (OPJ_BYTE)((src4 << 5) | (src5 >> 10));
 525         *pDst++ = (OPJ_BYTE)((src5 >> 2));
 526         *pDst++ = (OPJ_BYTE)((src5 << 6) | (src6 >> 9));
 527         *pDst++ = (OPJ_BYTE)((src6 >> 1));
 528         *pDst++ = (OPJ_BYTE)((src6 << 7) | (src7 >> 8));
 529         *pDst++ = (OPJ_BYTE)(src7);
 530     }
 531
 532     if (length & 7U) {
 533         unsigned int trailing = 0U;
 534         int remaining = 8U;
 535         length &= 7U;
 536         PUTBITS2((OPJ_UINT32)pSrc[i + 0], 15)
 537         if (length > 1U) {
 538             PUTBITS2((OPJ_UINT32)pSrc[i + 1], 15)
 539             if (length > 2U) {
 540                 PUTBITS2((OPJ_UINT32)pSrc[i + 2], 15)
 541                 if (length > 3U) {
 542                     PUTBITS2((OPJ_UINT32)pSrc[i + 3], 15)
 543                     if (length > 4U) {
 544                         PUTBITS2((OPJ_UINT32)pSrc[i + 4], 15)
 545                         if (length > 5U) {
 546                             PUTBITS2((OPJ_UINT32)pSrc[i + 5], 15)
 547                             if (length > 6U) {
 548                                 PUTBITS2((OPJ_UINT32)pSrc[i + 6], 15)
 549                             }
 550                         }
 551                     }
 552                 }
 553             }
 554         }
 555         FLUSHBITS()
 556     }
 557 }
 558 static void tif_32sto16u(const OPJ_INT32* pSrc, OPJ_UINT16* pDst,
 559                          OPJ_SIZE_T length)
 560 {
 561     OPJ_SIZE_T i;
 562     for (i = 0; i < length; ++i) {
 563         pDst[i] = (OPJ_UINT16)pSrc[i];
 564     }
 565 }
 566
 567 int imagetotif(opj_image_t * image, const char *outfile)
 568 {
 569     TIFF *tif;
 570     tdata_t buf;
 571     uint32 width, height;
 572     uint16 bps, tiPhoto;
 573     int adjust, sgnd;
 574     int64_t strip_size, rowStride, TIFF_MAX;
 575     OPJ_UINT32 i, numcomps;
 576     OPJ_INT32* buffer32s = NULL;
 577     OPJ_INT32 const* planes[4];
 578     convert_32s_PXCX cvtPxToCx = NULL;
 579     convert_32sXXx_C1R cvt32sToTif = NULL;
 580
 581     bps = (uint16)image->comps[0].prec;
 582     planes[0] = image->comps[0].data;
 583
 584     numcomps = image->numcomps;
 585
 586     if (image->color_space == OPJ_CLRSPC_CMYK) {
 587         if (numcomps < 4U) {
 588             fprintf(stderr,
 589                     "imagetotif: CMYK images shall be composed of at least 4 planes.\n");
 590             fprintf(stderr, "\tAborting\n");
 591             return 1;
 592         }
 593         tiPhoto = PHOTOMETRIC_SEPARATED;
 594         if (numcomps > 4U) {
 595             numcomps = 4U; /* Alpha not supported */
 596         }
 597     } else if (numcomps > 2U) {
 598         tiPhoto = PHOTOMETRIC_RGB;
 599         if (numcomps > 4U) {
 600             numcomps = 4U;
 601         }
 602     } else {
 603         tiPhoto = PHOTOMETRIC_MINISBLACK;
 604     }
 605     for (i = 1U; i < numcomps; ++i) {
 606         if (image->comps[0].dx != image->comps[i].dx) {
 607             break;
 608         }
 609         if (image->comps[0].dy != image->comps[i].dy) {
 610             break;
 611         }
 612         if (image->comps[0].prec != image->comps[i].prec) {
 613             break;
 614         }
 615         if (image->comps[0].sgnd != image->comps[i].sgnd) {
 616             break;
 617         }
 618         planes[i] = image->comps[i].data;
 619     }
 620     if (i != numcomps) {
 621         fprintf(stderr,
 622                 "imagetotif: All components shall have the same subsampling, same bit depth.\n");
 623         fprintf(stderr, "\tAborting\n");
 624         return 1;
 625     }
 626
 627     if (bps > 16) {
 628         bps = 0;
 629     }
 630     if (bps == 0) {
 631         fprintf(stderr, "imagetotif: Bits=%d, Only 1 to 16 bits implemented\n", bps);
 632         fprintf(stderr, "\tAborting\n");
 633         return 1;
 634     }
 635     tif = TIFFOpen(outfile, "wb");
 636     if (!tif) {
 637         fprintf(stderr, "imagetotif:failed to open %s for writing\n", outfile);
 638         return 1;
 639     }
 640     for (i = 0U; i < numcomps; ++i) {
 641         clip_component(&(image->comps[i]), image->comps[0].prec);
 642     }
 643     cvtPxToCx = convert_32s_PXCX_LUT[numcomps];
 644     switch (bps) {
 645     case 1:
 646     case 2:
 647     case 4:
 648     case 6:
 649     case 8:
 650         cvt32sToTif = convert_32sXXu_C1R_LUT[bps];
 651         break;
 652     case 3:
 653         cvt32sToTif = tif_32sto3u;
 654         break;
 655     case 5:
 656         cvt32sToTif = tif_32sto5u;
 657         break;
 658     case 7:
 659         cvt32sToTif = tif_32sto7u;
 660         break;
 661     case 9:
 662         cvt32sToTif = tif_32sto9u;
 663         break;
 664     case 10:
 665         cvt32sToTif = tif_32sto10u;
 666         break;
 667     case 11:
 668         cvt32sToTif = tif_32sto11u;
 669         break;
 670     case 12:
 671         cvt32sToTif = tif_32sto12u;
 672         break;
 673     case 13:
 674         cvt32sToTif = tif_32sto13u;
 675         break;
 676     case 14:
 677         cvt32sToTif = tif_32sto14u;
 678         break;
 679     case 15:
 680         cvt32sToTif = tif_32sto15u;
 681         break;
 682     case 16:
 683         cvt32sToTif = (convert_32sXXx_C1R)tif_32sto16u;
 684         break;
 685     default:
 686         /* never here */
 687         break;
 688     }
 689     sgnd = (int)image->comps[0].sgnd;
 690     adjust = sgnd ? (int)(1 << (image->comps[0].prec - 1)) : 0;
 691     width   = (uint32)image->comps[0].w;
 692     height  = (uint32)image->comps[0].h;
 693
 694     TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
 695     TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
 696     TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, (uint16)numcomps);
 697     TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
 698     TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
 699     TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
 700     TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, tiPhoto);
 701     TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
 702     if (sizeof(tsize_t) == 4) {
 703         TIFF_MAX = INT_MAX;
 704     } else {
 705         TIFF_MAX = UINT_MAX;
 706     }
 707     strip_size = (int64_t)TIFFStripSize(tif);
 708
 709     if ((int64_t)width > (int64_t)(TIFF_MAX / numcomps) ||
 710             (int64_t)(width * numcomps) > (int64_t)(TIFF_MAX / bps) ||
 711             (int64_t)(width * numcomps) > (int64_t)(TIFF_MAX / (int64_t)sizeof(
 712                         OPJ_INT32))) {
 713         fprintf(stderr, "Buffer overflow\n");
 714         TIFFClose(tif);
 715         return 1;
 716     }
 717     rowStride = (int64_t)((width * numcomps * bps + 7U) / 8U);
 718     if (rowStride != strip_size) {
 719         fprintf(stderr, "Invalid TIFF strip size\n");
 720         TIFFClose(tif);
 721         return 1;
 722     }
 723     buf = malloc((OPJ_SIZE_T)strip_size);
 724     if (buf == NULL) {
 725         TIFFClose(tif);
 726         return 1;
 727     }
 728     buffer32s = (OPJ_INT32 *)malloc(sizeof(OPJ_INT32) * width * numcomps);
 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     uint16 tiBps, tiPhoto, tiSf, tiSpp, tiPC;
1257     uint32 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     /* initialize image components */
1359     memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
1360
1361     if ((tiPhoto == PHOTOMETRIC_RGB) && (is_cinema) && (tiBps != 12U)) {
1362         fprintf(stdout, "WARNING:\n"
1363                 "Input image bitdepth is %d bits\n"
1364                 "TIF conversion has automatically rescaled to 12-bits\n"
1365                 "to comply with cinema profiles.\n",
1366                 tiBps);
1367     } else {
1368         is_cinema = 0U;
1369     }
1370
1371     numcomps = tiSpp;
1372     if (tiPhoto == PHOTOMETRIC_RGB) { /* RGB(A) */
1373         color_space = OPJ_CLRSPC_SRGB;
1374     } else if (tiPhoto == PHOTOMETRIC_MINISBLACK) { /* GRAY(A) */
1375         color_space = OPJ_CLRSPC_GRAY;
1376     }
1377
1378     cvtCxToPx = convert_32s_CXPX_LUT[numcomps];
1379     if (tiPC == PLANARCONFIG_SEPARATE) {
1380         cvtCxToPx = convert_32s_CXPX_LUT[1]; /* override */
1381         tiSpp = 1U; /* consider only one sample per plane */
1382     }
1383
1384     for (j = 0; j < numcomps; j++) {
1385         cmptparm[j].prec = tiBps;
1386         cmptparm[j].bpp = tiBps;
1387         cmptparm[j].dx = (OPJ_UINT32)subsampling_dx;
1388         cmptparm[j].dy = (OPJ_UINT32)subsampling_dy;
1389         cmptparm[j].w = (OPJ_UINT32)w;
1390         cmptparm[j].h = (OPJ_UINT32)h;
1391     }
1392
1393     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
1394     if (!image) {
1395         TIFFClose(tif);
1396         return NULL;
1397     }
1398     /* set image offset and reference grid */
1399     image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
1400     image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
1401     image->x1 = !image->x0 ? (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1 :
1402                 image->x0 + (OPJ_UINT32)(w - 1) * (OPJ_UINT32)subsampling_dx + 1;
1403     if (image->x1 <= image->x0) {
1404         fprintf(stderr, "tiftoimage: Bad value for image->x1(%d) vs. "
1405                 "image->x0(%d)\n\tAborting.\n", image->x1, image->x0);
1406         TIFFClose(tif);
1407         opj_image_destroy(image);
1408         return NULL;
1409     }
1410     image->y1 = !image->y0 ? (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1 :
1411                 image->y0 + (OPJ_UINT32)(h - 1) * (OPJ_UINT32)subsampling_dy + 1;
1412     if (image->y1 <= image->y0) {
1413         fprintf(stderr, "tiftoimage: Bad value for image->y1(%d) vs. "
1414                 "image->y0(%d)\n\tAborting.\n", image->y1, image->y0);
1415         TIFFClose(tif);
1416         opj_image_destroy(image);
1417         return NULL;
1418     }
1419
1420     for (j = 0; j < numcomps; j++) {
1421         planes[j] = image->comps[j].data;
1422     }
1423     image->comps[numcomps - 1].alpha = (OPJ_UINT16)(1 - (numcomps & 1));
1424
1425     strip_size = (int64_t)TIFFStripSize(tif);
1426
1427     buf = malloc((OPJ_SIZE_T)strip_size);
1428     if (buf == NULL) {
1429         TIFFClose(tif);
1430         opj_image_destroy(image);
1431         return NULL;
1432     }
1433     if (sizeof(tsize_t) == 4) {
1434         TIFF_MAX = INT_MAX;
1435     } else {
1436         TIFF_MAX = UINT_MAX;
1437     }
1438     if ((int64_t)tiWidth > (int64_t)(TIFF_MAX / tiSpp) ||
1439             (int64_t)(tiWidth * tiSpp) > (int64_t)(TIFF_MAX / tiBps) ||
1440             (int64_t)(tiWidth * tiSpp) > (int64_t)(TIFF_MAX / (int64_t)sizeof(OPJ_INT32))) {
1441         fprintf(stderr, "Buffer overflow\n");
1442         _TIFFfree(buf);
1443         TIFFClose(tif);
1444         opj_image_destroy(image);
1445         return NULL;
1446     }
1447
1448     rowStride = (int64_t)((tiWidth * tiSpp * tiBps + 7U) / 8U);
1449     buffer32s = (OPJ_INT32 *)malloc(sizeof(OPJ_INT32) * tiWidth * tiSpp);
1450     if (buffer32s == NULL) {
1451         _TIFFfree(buf);
1452         TIFFClose(tif);
1453         opj_image_destroy(image);
1454         return NULL;
1455     }
1456
1457     strip = 0;
1458     currentPlane = 0;
1459     do {
1460         planes[0] = image->comps[currentPlane].data; /* to manage planar data */
1461         h = (int)tiHeight;
1462         /* Read the Image components */
1463         for (; (h > 0) && (strip < TIFFNumberOfStrips(tif)); strip++) {
1464             const OPJ_UINT8 *dat8;
1465             int64_t ssize;
1466
1467             ssize = (int64_t)TIFFReadEncodedStrip(tif, strip, buf, (tsize_t)strip_size);
1468
1469             if (ssize < 1 || ssize > strip_size) {
1470                 fprintf(stderr, "tiftoimage: Bad value for ssize(%" PRId64 ") "
1471                         "vs. strip_size(%" PRId64 ").\n\tAborting.\n", ssize, strip_size);
1472                 _TIFFfree(buf);
1473                 _TIFFfree(buffer32s);
1474                 TIFFClose(tif);
1475                 opj_image_destroy(image);
1476                 return NULL;
1477             }
1478             dat8 = (const OPJ_UINT8*)buf;
1479
1480             while (ssize >= rowStride) {
1481                 cvtTifTo32s(dat8, buffer32s, (OPJ_SIZE_T)w * tiSpp);
1482                 cvtCxToPx(buffer32s, planes, (OPJ_SIZE_T)w);
1483                 planes[0] += w;
1484                 planes[1] += w;
1485                 planes[2] += w;
1486                 planes[3] += w;
1487                 dat8  += rowStride;
1488                 ssize -= rowStride;
1489                 h--;
1490             }
1491         }
1492         currentPlane++;
1493     } while ((tiPC == PLANARCONFIG_SEPARATE) && (currentPlane < numcomps));
1494
1495     free(buffer32s);
1496     _TIFFfree(buf);
1497     TIFFClose(tif);
1498
1499     if (is_cinema) {
1500         for (j = 0; j < numcomps; ++j) {
1501             scale_component(&(image->comps[j]), 12);
1502         }
1503
1504     }
1505     return image;
1506
1507 }/* tiftoimage() */
1508