src/bin/jp2/converttif.c

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