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