src/bin/jp2/convert.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  * All rights reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions
  19  * are met:
  20  * 1. Redistributions of source code must retain the above copyright
  21  *    notice, this list of conditions and the following disclaimer.
  22  * 2. Redistributions in binary form must reproduce the above copyright
  23  *    notice, this list of conditions and the following disclaimer in the
  24  *    documentation and/or other materials provided with the distribution.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  27  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  30  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGE.
  37  */
  38 #include "opj_apps_config.h"
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <ctype.h>
  44 #include <limits.h>
  45
  46 #include "openjpeg.h"
  47 #include "convert.h"
  48
  49 /*
  50  * Get logarithm of an integer and round downwards.
  51  *
  52  * log2(a)
  53  */
  54 static int int_floorlog2(int a)
  55 {
  56     int l;
  57     for (l = 0; a > 1; l++) {
  58         a >>= 1;
  59     }
  60     return l;
  61 }
  62
  63 /* Component precision scaling */
  64 void clip_component(opj_image_comp_t* component, OPJ_UINT32 precision)
  65 {
  66     OPJ_SIZE_T i;
  67     OPJ_SIZE_T len;
  68     OPJ_UINT32 umax = (OPJ_UINT32)((OPJ_INT32) - 1);
  69
  70     len = (OPJ_SIZE_T)component->w * (OPJ_SIZE_T)component->h;
  71     if (precision < 32) {
  72         umax = (1U << precision) - 1U;
  73     }
  74
  75     if (component->sgnd) {
  76         OPJ_INT32* l_data = component->data;
  77         OPJ_INT32 max = (OPJ_INT32)(umax / 2U);
  78         OPJ_INT32 min = -max - 1;
  79         for (i = 0; i < len; ++i) {
  80             if (l_data[i] > max) {
  81                 l_data[i] = max;
  82             } else if (l_data[i] < min) {
  83                 l_data[i] = min;
  84             }
  85         }
  86     } else {
  87         OPJ_UINT32* l_data = (OPJ_UINT32*)component->data;
  88         for (i = 0; i < len; ++i) {
  89             if (l_data[i] > umax) {
  90                 l_data[i] = umax;
  91             }
  92         }
  93     }
  94     component->prec = precision;
  95 }
  96
  97 /* Component precision scaling */
  98 static void scale_component_up(opj_image_comp_t* component,
  99                                OPJ_UINT32 precision)
 100 {
 101     OPJ_SIZE_T i, len;
 102
 103     len = (OPJ_SIZE_T)component->w * (OPJ_SIZE_T)component->h;
 104     if (component->sgnd) {
 105         OPJ_INT64  newMax = (OPJ_INT64)(1U << (precision - 1));
 106         OPJ_INT64  oldMax = (OPJ_INT64)(1U << (component->prec - 1));
 107         OPJ_INT32* l_data = component->data;
 108         for (i = 0; i < len; ++i) {
 109             l_data[i] = (OPJ_INT32)(((OPJ_INT64)l_data[i] * newMax) / oldMax);
 110         }
 111     } else {
 112         OPJ_UINT64  newMax = (OPJ_UINT64)((1U << precision) - 1U);
 113         OPJ_UINT64  oldMax = (OPJ_UINT64)((1U << component->prec) - 1U);
 114         OPJ_UINT32* l_data = (OPJ_UINT32*)component->data;
 115         for (i = 0; i < len; ++i) {
 116             l_data[i] = (OPJ_UINT32)(((OPJ_UINT64)l_data[i] * newMax) / oldMax);
 117         }
 118     }
 119     component->prec = precision;
 120     component->bpp = precision;
 121 }
 122 void scale_component(opj_image_comp_t* component, OPJ_UINT32 precision)
 123 {
 124     int shift;
 125     OPJ_SIZE_T i, len;
 126
 127     if (component->prec == precision) {
 128         return;
 129     }
 130     if (component->prec < precision) {
 131         scale_component_up(component, precision);
 132         return;
 133     }
 134     shift = (int)(component->prec - precision);
 135     len = (OPJ_SIZE_T)component->w * (OPJ_SIZE_T)component->h;
 136     if (component->sgnd) {
 137         OPJ_INT32* l_data = component->data;
 138         for (i = 0; i < len; ++i) {
 139             l_data[i] >>= shift;
 140         }
 141     } else {
 142         OPJ_UINT32* l_data = (OPJ_UINT32*)component->data;
 143         for (i = 0; i < len; ++i) {
 144             l_data[i] >>= shift;
 145         }
 146     }
 147     component->bpp = precision;
 148     component->prec = precision;
 149 }
 150
 151
 152 /* planar / interleaved conversions */
 153 /* used by PNG/TIFF */
 154 static void convert_32s_C1P1(const OPJ_INT32* pSrc, OPJ_INT32* const* pDst,
 155                              OPJ_SIZE_T length)
 156 {
 157     memcpy(pDst[0], pSrc, length * sizeof(OPJ_INT32));
 158 }
 159 static void convert_32s_C2P2(const OPJ_INT32* pSrc, OPJ_INT32* const* pDst,
 160                              OPJ_SIZE_T length)
 161 {
 162     OPJ_SIZE_T i;
 163     OPJ_INT32* pDst0 = pDst[0];
 164     OPJ_INT32* pDst1 = pDst[1];
 165
 166     for (i = 0; i < length; i++) {
 167         pDst0[i] = pSrc[2 * i + 0];
 168         pDst1[i] = pSrc[2 * i + 1];
 169     }
 170 }
 171 static void convert_32s_C3P3(const OPJ_INT32* pSrc, OPJ_INT32* const* pDst,
 172                              OPJ_SIZE_T length)
 173 {
 174     OPJ_SIZE_T i;
 175     OPJ_INT32* pDst0 = pDst[0];
 176     OPJ_INT32* pDst1 = pDst[1];
 177     OPJ_INT32* pDst2 = pDst[2];
 178
 179     for (i = 0; i < length; i++) {
 180         pDst0[i] = pSrc[3 * i + 0];
 181         pDst1[i] = pSrc[3 * i + 1];
 182         pDst2[i] = pSrc[3 * i + 2];
 183     }
 184 }
 185 static void convert_32s_C4P4(const OPJ_INT32* pSrc, OPJ_INT32* const* pDst,
 186                              OPJ_SIZE_T length)
 187 {
 188     OPJ_SIZE_T i;
 189     OPJ_INT32* pDst0 = pDst[0];
 190     OPJ_INT32* pDst1 = pDst[1];
 191     OPJ_INT32* pDst2 = pDst[2];
 192     OPJ_INT32* pDst3 = pDst[3];
 193
 194     for (i = 0; i < length; i++) {
 195         pDst0[i] = pSrc[4 * i + 0];
 196         pDst1[i] = pSrc[4 * i + 1];
 197         pDst2[i] = pSrc[4 * i + 2];
 198         pDst3[i] = pSrc[4 * i + 3];
 199     }
 200 }
 201 const convert_32s_CXPX convert_32s_CXPX_LUT[5] = {
 202     NULL,
 203     convert_32s_C1P1,
 204     convert_32s_C2P2,
 205     convert_32s_C3P3,
 206     convert_32s_C4P4
 207 };
 208
 209 static void convert_32s_P1C1(OPJ_INT32 const* const* pSrc, OPJ_INT32* pDst,
 210                              OPJ_SIZE_T length, OPJ_INT32 adjust)
 211 {
 212     OPJ_SIZE_T i;
 213     const OPJ_INT32* pSrc0 = pSrc[0];
 214
 215     for (i = 0; i < length; i++) {
 216         pDst[i] = pSrc0[i] + adjust;
 217     }
 218 }
 219 static void convert_32s_P2C2(OPJ_INT32 const* const* pSrc, OPJ_INT32* pDst,
 220                              OPJ_SIZE_T length, OPJ_INT32 adjust)
 221 {
 222     OPJ_SIZE_T i;
 223     const OPJ_INT32* pSrc0 = pSrc[0];
 224     const OPJ_INT32* pSrc1 = pSrc[1];
 225
 226     for (i = 0; i < length; i++) {
 227         pDst[2 * i + 0] = pSrc0[i] + adjust;
 228         pDst[2 * i + 1] = pSrc1[i] + adjust;
 229     }
 230 }
 231 static void convert_32s_P3C3(OPJ_INT32 const* const* pSrc, OPJ_INT32* pDst,
 232                              OPJ_SIZE_T length, OPJ_INT32 adjust)
 233 {
 234     OPJ_SIZE_T i;
 235     const OPJ_INT32* pSrc0 = pSrc[0];
 236     const OPJ_INT32* pSrc1 = pSrc[1];
 237     const OPJ_INT32* pSrc2 = pSrc[2];
 238
 239     for (i = 0; i < length; i++) {
 240         pDst[3 * i + 0] = pSrc0[i] + adjust;
 241         pDst[3 * i + 1] = pSrc1[i] + adjust;
 242         pDst[3 * i + 2] = pSrc2[i] + adjust;
 243     }
 244 }
 245 static void convert_32s_P4C4(OPJ_INT32 const* const* pSrc, OPJ_INT32* pDst,
 246                              OPJ_SIZE_T length, OPJ_INT32 adjust)
 247 {
 248     OPJ_SIZE_T i;
 249     const OPJ_INT32* pSrc0 = pSrc[0];
 250     const OPJ_INT32* pSrc1 = pSrc[1];
 251     const OPJ_INT32* pSrc2 = pSrc[2];
 252     const OPJ_INT32* pSrc3 = pSrc[3];
 253
 254     for (i = 0; i < length; i++) {
 255         pDst[4 * i + 0] = pSrc0[i] + adjust;
 256         pDst[4 * i + 1] = pSrc1[i] + adjust;
 257         pDst[4 * i + 2] = pSrc2[i] + adjust;
 258         pDst[4 * i + 3] = pSrc3[i] + adjust;
 259     }
 260 }
 261 const convert_32s_PXCX convert_32s_PXCX_LUT[5] = {
 262     NULL,
 263     convert_32s_P1C1,
 264     convert_32s_P2C2,
 265     convert_32s_P3C3,
 266     convert_32s_P4C4
 267 };
 268
 269 /* bit depth conversions */
 270 /* used by PNG/TIFF up to 8bpp */
 271 static void convert_1u32s_C1R(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 272                               OPJ_SIZE_T length)
 273 {
 274     OPJ_SIZE_T i;
 275     for (i = 0; i < (length & ~(OPJ_SIZE_T)7U); i += 8U) {
 276         OPJ_UINT32 val = *pSrc++;
 277         pDst[i + 0] = (OPJ_INT32)(val >> 7);
 278         pDst[i + 1] = (OPJ_INT32)((val >> 6) & 0x1U);
 279         pDst[i + 2] = (OPJ_INT32)((val >> 5) & 0x1U);
 280         pDst[i + 3] = (OPJ_INT32)((val >> 4) & 0x1U);
 281         pDst[i + 4] = (OPJ_INT32)((val >> 3) & 0x1U);
 282         pDst[i + 5] = (OPJ_INT32)((val >> 2) & 0x1U);
 283         pDst[i + 6] = (OPJ_INT32)((val >> 1) & 0x1U);
 284         pDst[i + 7] = (OPJ_INT32)(val & 0x1U);
 285     }
 286     if (length & 7U) {
 287         OPJ_UINT32 val = *pSrc++;
 288         length = length & 7U;
 289         pDst[i + 0] = (OPJ_INT32)(val >> 7);
 290
 291         if (length > 1U) {
 292             pDst[i + 1] = (OPJ_INT32)((val >> 6) & 0x1U);
 293             if (length > 2U) {
 294                 pDst[i + 2] = (OPJ_INT32)((val >> 5) & 0x1U);
 295                 if (length > 3U) {
 296                     pDst[i + 3] = (OPJ_INT32)((val >> 4) & 0x1U);
 297                     if (length > 4U) {
 298                         pDst[i + 4] = (OPJ_INT32)((val >> 3) & 0x1U);
 299                         if (length > 5U) {
 300                             pDst[i + 5] = (OPJ_INT32)((val >> 2) & 0x1U);
 301                             if (length > 6U) {
 302                                 pDst[i + 6] = (OPJ_INT32)((val >> 1) & 0x1U);
 303                             }
 304                         }
 305                     }
 306                 }
 307             }
 308         }
 309     }
 310 }
 311 static void convert_2u32s_C1R(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 312                               OPJ_SIZE_T length)
 313 {
 314     OPJ_SIZE_T i;
 315     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
 316         OPJ_UINT32 val = *pSrc++;
 317         pDst[i + 0] = (OPJ_INT32)(val >> 6);
 318         pDst[i + 1] = (OPJ_INT32)((val >> 4) & 0x3U);
 319         pDst[i + 2] = (OPJ_INT32)((val >> 2) & 0x3U);
 320         pDst[i + 3] = (OPJ_INT32)(val & 0x3U);
 321     }
 322     if (length & 3U) {
 323         OPJ_UINT32 val = *pSrc++;
 324         length = length & 3U;
 325         pDst[i + 0] = (OPJ_INT32)(val >> 6);
 326
 327         if (length > 1U) {
 328             pDst[i + 1] = (OPJ_INT32)((val >> 4) & 0x3U);
 329             if (length > 2U) {
 330                 pDst[i + 2] = (OPJ_INT32)((val >> 2) & 0x3U);
 331
 332             }
 333         }
 334     }
 335 }
 336 static void convert_4u32s_C1R(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 337                               OPJ_SIZE_T length)
 338 {
 339     OPJ_SIZE_T i;
 340     for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i += 2U) {
 341         OPJ_UINT32 val = *pSrc++;
 342         pDst[i + 0] = (OPJ_INT32)(val >> 4);
 343         pDst[i + 1] = (OPJ_INT32)(val & 0xFU);
 344     }
 345     if (length & 1U) {
 346         OPJ_UINT8 val = *pSrc++;
 347         pDst[i + 0] = (OPJ_INT32)(val >> 4);
 348     }
 349 }
 350 static void convert_6u32s_C1R(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 351                               OPJ_SIZE_T length)
 352 {
 353     OPJ_SIZE_T i;
 354     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
 355         OPJ_UINT32 val0 = *pSrc++;
 356         OPJ_UINT32 val1 = *pSrc++;
 357         OPJ_UINT32 val2 = *pSrc++;
 358         pDst[i + 0] = (OPJ_INT32)(val0 >> 2);
 359         pDst[i + 1] = (OPJ_INT32)(((val0 & 0x3U) << 4) | (val1 >> 4));
 360         pDst[i + 2] = (OPJ_INT32)(((val1 & 0xFU) << 2) | (val2 >> 6));
 361         pDst[i + 3] = (OPJ_INT32)(val2 & 0x3FU);
 362
 363     }
 364     if (length & 3U) {
 365         OPJ_UINT32 val0 = *pSrc++;
 366         length = length & 3U;
 367         pDst[i + 0] = (OPJ_INT32)(val0 >> 2);
 368
 369         if (length > 1U) {
 370             OPJ_UINT32 val1 = *pSrc++;
 371             pDst[i + 1] = (OPJ_INT32)(((val0 & 0x3U) << 4) | (val1 >> 4));
 372             if (length > 2U) {
 373                 OPJ_UINT32 val2 = *pSrc++;
 374                 pDst[i + 2] = (OPJ_INT32)(((val1 & 0xFU) << 2) | (val2 >> 6));
 375             }
 376         }
 377     }
 378 }
 379 static void convert_8u32s_C1R(const OPJ_BYTE* pSrc, OPJ_INT32* pDst,
 380                               OPJ_SIZE_T length)
 381 {
 382     OPJ_SIZE_T i;
 383     for (i = 0; i < length; i++) {
 384         pDst[i] = pSrc[i];
 385     }
 386 }
 387 const convert_XXx32s_C1R convert_XXu32s_C1R_LUT[9] = {
 388     NULL,
 389     convert_1u32s_C1R,
 390     convert_2u32s_C1R,
 391     NULL,
 392     convert_4u32s_C1R,
 393     NULL,
 394     convert_6u32s_C1R,
 395     NULL,
 396     convert_8u32s_C1R
 397 };
 398
 399
 400 static void convert_32s1u_C1R(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 401                               OPJ_SIZE_T length)
 402 {
 403     OPJ_SIZE_T i;
 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 << 7) | (src1 << 6) | (src2 << 5) | (src3 << 4) |
 415                              (src4 << 3) | (src5 << 2) | (src6 << 1) | src7);
 416     }
 417
 418     if (length & 7U) {
 419         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 420         OPJ_UINT32 src1 = 0U;
 421         OPJ_UINT32 src2 = 0U;
 422         OPJ_UINT32 src3 = 0U;
 423         OPJ_UINT32 src4 = 0U;
 424         OPJ_UINT32 src5 = 0U;
 425         OPJ_UINT32 src6 = 0U;
 426         length = length & 7U;
 427
 428         if (length > 1U) {
 429             src1 = (OPJ_UINT32)pSrc[i + 1];
 430             if (length > 2U) {
 431                 src2 = (OPJ_UINT32)pSrc[i + 2];
 432                 if (length > 3U) {
 433                     src3 = (OPJ_UINT32)pSrc[i + 3];
 434                     if (length > 4U) {
 435                         src4 = (OPJ_UINT32)pSrc[i + 4];
 436                         if (length > 5U) {
 437                             src5 = (OPJ_UINT32)pSrc[i + 5];
 438                             if (length > 6U) {
 439                                 src6 = (OPJ_UINT32)pSrc[i + 6];
 440                             }
 441                         }
 442                     }
 443                 }
 444             }
 445         }
 446         *pDst++ = (OPJ_BYTE)((src0 << 7) | (src1 << 6) | (src2 << 5) | (src3 << 4) |
 447                              (src4 << 3) | (src5 << 2) | (src6 << 1));
 448     }
 449 }
 450
 451 static void convert_32s2u_C1R(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 452                               OPJ_SIZE_T length)
 453 {
 454     OPJ_SIZE_T i;
 455     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
 456         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 457         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 458         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 459         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 460
 461         *pDst++ = (OPJ_BYTE)((src0 << 6) | (src1 << 4) | (src2 << 2) | src3);
 462     }
 463
 464     if (length & 3U) {
 465         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 466         OPJ_UINT32 src1 = 0U;
 467         OPJ_UINT32 src2 = 0U;
 468         length = length & 3U;
 469
 470         if (length > 1U) {
 471             src1 = (OPJ_UINT32)pSrc[i + 1];
 472             if (length > 2U) {
 473                 src2 = (OPJ_UINT32)pSrc[i + 2];
 474             }
 475         }
 476         *pDst++ = (OPJ_BYTE)((src0 << 6) | (src1 << 4) | (src2 << 2));
 477     }
 478 }
 479
 480 static void convert_32s4u_C1R(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 481                               OPJ_SIZE_T length)
 482 {
 483     OPJ_SIZE_T i;
 484     for (i = 0; i < (length & ~(OPJ_SIZE_T)1U); i += 2U) {
 485         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 486         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 487
 488         *pDst++ = (OPJ_BYTE)((src0 << 4) | src1);
 489     }
 490
 491     if (length & 1U) {
 492         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 493         *pDst++ = (OPJ_BYTE)((src0 << 4));
 494     }
 495 }
 496
 497 static void convert_32s6u_C1R(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 498                               OPJ_SIZE_T length)
 499 {
 500     OPJ_SIZE_T i;
 501     for (i = 0; i < (length & ~(OPJ_SIZE_T)3U); i += 4U) {
 502         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 503         OPJ_UINT32 src1 = (OPJ_UINT32)pSrc[i + 1];
 504         OPJ_UINT32 src2 = (OPJ_UINT32)pSrc[i + 2];
 505         OPJ_UINT32 src3 = (OPJ_UINT32)pSrc[i + 3];
 506
 507         *pDst++ = (OPJ_BYTE)((src0 << 2) | (src1 >> 4));
 508         *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 2));
 509         *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6) | src3);
 510     }
 511
 512     if (length & 3U) {
 513         OPJ_UINT32 src0 = (OPJ_UINT32)pSrc[i + 0];
 514         OPJ_UINT32 src1 = 0U;
 515         OPJ_UINT32 src2 = 0U;
 516         length = length & 3U;
 517
 518         if (length > 1U) {
 519             src1 = (OPJ_UINT32)pSrc[i + 1];
 520             if (length > 2U) {
 521                 src2 = (OPJ_UINT32)pSrc[i + 2];
 522             }
 523         }
 524         *pDst++ = (OPJ_BYTE)((src0 << 2) | (src1 >> 4));
 525         if (length > 1U) {
 526             *pDst++ = (OPJ_BYTE)(((src1 & 0xFU) << 4) | (src2 >> 2));
 527             if (length > 2U) {
 528                 *pDst++ = (OPJ_BYTE)(((src2 & 0x3U) << 6));
 529             }
 530         }
 531     }
 532 }
 533 static void convert_32s8u_C1R(const OPJ_INT32* pSrc, OPJ_BYTE* pDst,
 534                               OPJ_SIZE_T length)
 535 {
 536     OPJ_SIZE_T i;
 537     for (i = 0; i < length; ++i) {
 538         pDst[i] = (OPJ_BYTE)pSrc[i];
 539     }
 540 }
 541 const convert_32sXXx_C1R convert_32sXXu_C1R_LUT[9] = {
 542     NULL,
 543     convert_32s1u_C1R,
 544     convert_32s2u_C1R,
 545     NULL,
 546     convert_32s4u_C1R,
 547     NULL,
 548     convert_32s6u_C1R,
 549     NULL,
 550     convert_32s8u_C1R
 551 };
 552
 553 /* -->> -->> -->> -->>
 554
 555   TGA IMAGE FORMAT
 556
 557  <<-- <<-- <<-- <<-- */
 558
 559 #ifdef INFORMATION_ONLY
 560 /* TGA header definition. */
 561 struct tga_header {
 562     unsigned char   id_length;              /* Image id field length    */
 563     unsigned char   colour_map_type;        /* Colour map type          */
 564     unsigned char   image_type;             /* Image type               */
 565     /*
 566     ** Colour map specification
 567     */
 568     unsigned short  colour_map_index;       /* First entry index        */
 569     unsigned short  colour_map_length;      /* Colour map length        */
 570     unsigned char   colour_map_entry_size;  /* Colour map entry size    */
 571     /*
 572     ** Image specification
 573     */
 574     unsigned short  x_origin;               /* x origin of image        */
 575     unsigned short  y_origin;               /* u origin of image        */
 576     unsigned short  image_width;            /* Image width              */
 577     unsigned short  image_height;           /* Image height             */
 578     unsigned char   pixel_depth;            /* Pixel depth              */
 579     unsigned char   image_desc;             /* Image descriptor         */
 580 };
 581 #endif /* INFORMATION_ONLY */
 582
 583 /* Returns a ushort from a little-endian serialized value */
 584 static unsigned short get_tga_ushort(const unsigned char *data)
 585 {
 586     return (unsigned short)(data[0] | (data[1] << 8));
 587 }
 588
 589 #define TGA_HEADER_SIZE 18
 590
 591 static int tga_readheader(FILE *fp, unsigned int *bits_per_pixel,
 592                           unsigned int *width, unsigned int *height, int *flip_image)
 593 {
 594     int palette_size;
 595     unsigned char tga[TGA_HEADER_SIZE];
 596     unsigned char id_len, /*cmap_type,*/ image_type;
 597     unsigned char pixel_depth, image_desc;
 598     unsigned short /*cmap_index,*/ cmap_len, cmap_entry_size;
 599     unsigned short /*x_origin, y_origin,*/ image_w, image_h;
 600
 601     if (!bits_per_pixel || !width || !height || !flip_image) {
 602         return 0;
 603     }
 604
 605     if (fread(tga, TGA_HEADER_SIZE, 1, fp) != 1) {
 606         fprintf(stderr,
 607                 "\nError: fread return a number of element different from the expected.\n");
 608         return 0 ;
 609     }
 610     id_len = tga[0];
 611     /*cmap_type = tga[1];*/
 612     image_type = tga[2];
 613     /*cmap_index = get_tga_ushort(&tga[3]);*/
 614     cmap_len = get_tga_ushort(&tga[5]);
 615     cmap_entry_size = tga[7];
 616
 617
 618 #if 0
 619     x_origin = get_tga_ushort(&tga[8]);
 620     y_origin = get_tga_ushort(&tga[10]);
 621 #endif
 622     image_w = get_tga_ushort(&tga[12]);
 623     image_h = get_tga_ushort(&tga[14]);
 624     pixel_depth = tga[16];
 625     image_desc  = tga[17];
 626
 627     *bits_per_pixel = (unsigned int)pixel_depth;
 628     *width  = (unsigned int)image_w;
 629     *height = (unsigned int)image_h;
 630
 631     /* Ignore tga identifier, if present ... */
 632     if (id_len) {
 633         unsigned char *id = (unsigned char *) malloc(id_len);
 634         if (id == 0) {
 635             fprintf(stderr, "tga_readheader: memory out\n");
 636             return 0;
 637         }
 638         if (!fread(id, id_len, 1, fp)) {
 639             fprintf(stderr,
 640                     "\nError: fread return a number of element different from the expected.\n");
 641             free(id);
 642             return 0 ;
 643         }
 644         free(id);
 645     }
 646
 647     /* Test for compressed formats ... not yet supported ...
 648     // Note :-  9 - RLE encoded palettized.
 649     //         10 - RLE encoded RGB. */
 650     if (image_type > 8) {
 651         fprintf(stderr, "Sorry, compressed tga files are not currently supported.\n");
 652         return 0 ;
 653     }
 654
 655     *flip_image = !(image_desc & 32);
 656
 657     /* Palettized formats are not yet supported, skip over the palette, if present ... */
 658     palette_size = cmap_len * (cmap_entry_size / 8);
 659
 660     if (palette_size > 0) {
 661         fprintf(stderr, "File contains a palette - not yet supported.");
 662         fseek(fp, palette_size, SEEK_CUR);
 663     }
 664     return 1;
 665 }
 666
 667 #ifdef OPJ_BIG_ENDIAN
 668
 669 static INLINE OPJ_UINT16 swap16(OPJ_UINT16 x)
 670 {
 671     return (OPJ_UINT16)(((x & 0x00ffU) <<  8) | ((x & 0xff00U) >>  8));
 672 }
 673
 674 #endif
 675
 676 static int tga_writeheader(FILE *fp, int bits_per_pixel, int width, int height,
 677                            OPJ_BOOL flip_image)
 678 {
 679     OPJ_UINT16 image_w, image_h, us0;
 680     unsigned char uc0, image_type;
 681     unsigned char pixel_depth, image_desc;
 682
 683     if (!bits_per_pixel || !width || !height) {
 684         return 0;
 685     }
 686
 687     pixel_depth = 0;
 688
 689     if (bits_per_pixel < 256) {
 690         pixel_depth = (unsigned char)bits_per_pixel;
 691     } else {
 692         fprintf(stderr, "ERROR: Wrong bits per pixel inside tga_header");
 693         return 0;
 694     }
 695     uc0 = 0;
 696
 697     if (fwrite(&uc0, 1, 1, fp) != 1) {
 698         goto fails;    /* id_length */
 699     }
 700     if (fwrite(&uc0, 1, 1, fp) != 1) {
 701         goto fails;    /* colour_map_type */
 702     }
 703
 704     image_type = 2; /* Uncompressed. */
 705     if (fwrite(&image_type, 1, 1, fp) != 1) {
 706         goto fails;
 707     }
 708
 709     us0 = 0;
 710     if (fwrite(&us0, 2, 1, fp) != 1) {
 711         goto fails;    /* colour_map_index */
 712     }
 713     if (fwrite(&us0, 2, 1, fp) != 1) {
 714         goto fails;    /* colour_map_length */
 715     }
 716     if (fwrite(&uc0, 1, 1, fp) != 1) {
 717         goto fails;    /* colour_map_entry_size */
 718     }
 719
 720     if (fwrite(&us0, 2, 1, fp) != 1) {
 721         goto fails;    /* x_origin */
 722     }
 723     if (fwrite(&us0, 2, 1, fp) != 1) {
 724         goto fails;    /* y_origin */
 725     }
 726
 727     image_w = (unsigned short)width;
 728     image_h = (unsigned short) height;
 729
 730 #ifndef OPJ_BIG_ENDIAN
 731     if (fwrite(&image_w, 2, 1, fp) != 1) {
 732         goto fails;
 733     }
 734     if (fwrite(&image_h, 2, 1, fp) != 1) {
 735         goto fails;
 736     }
 737 #else
 738     image_w = swap16(image_w);
 739     image_h = swap16(image_h);
 740     if (fwrite(&image_w, 2, 1, fp) != 1) {
 741         goto fails;
 742     }
 743     if (fwrite(&image_h, 2, 1, fp) != 1) {
 744         goto fails;
 745     }
 746 #endif
 747
 748     if (fwrite(&pixel_depth, 1, 1, fp) != 1) {
 749         goto fails;
 750     }
 751
 752     image_desc = 8; /* 8 bits per component. */
 753
 754     if (flip_image) {
 755         image_desc |= 32;
 756     }
 757     if (fwrite(&image_desc, 1, 1, fp) != 1) {
 758         goto fails;
 759     }
 760
 761     return 1;
 762
 763 fails:
 764     fputs("\nwrite_tgaheader: write ERROR\n", stderr);
 765     return 0;
 766 }
 767
 768 opj_image_t* tgatoimage(const char *filename, opj_cparameters_t *parameters)
 769 {
 770     FILE *f;
 771     opj_image_t *image;
 772     unsigned int image_width, image_height, pixel_bit_depth;
 773     unsigned int x, y;
 774     int flip_image = 0;
 775     opj_image_cmptparm_t cmptparm[4];   /* maximum 4 components */
 776     int numcomps;
 777     OPJ_COLOR_SPACE color_space;
 778     OPJ_BOOL mono ;
 779     OPJ_BOOL save_alpha;
 780     int subsampling_dx, subsampling_dy;
 781     int i;
 782
 783     f = fopen(filename, "rb");
 784     if (!f) {
 785         fprintf(stderr, "Failed to open %s for reading !!\n", filename);
 786         return 0;
 787     }
 788
 789     if (!tga_readheader(f, &pixel_bit_depth, &image_width, &image_height,
 790                         &flip_image)) {
 791         fclose(f);
 792         return NULL;
 793     }
 794
 795     /* We currently only support 24 & 32 bit tga's ... */
 796     if (!((pixel_bit_depth == 24) || (pixel_bit_depth == 32))) {
 797         fclose(f);
 798         return NULL;
 799     }
 800
 801     /* initialize image components */
 802     memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
 803
 804     mono = (pixel_bit_depth == 8) ||
 805            (pixel_bit_depth == 16);  /* Mono with & without alpha. */
 806     save_alpha = (pixel_bit_depth == 16) ||
 807                  (pixel_bit_depth == 32); /* Mono with alpha, or RGB with alpha */
 808
 809     if (mono) {
 810         color_space = OPJ_CLRSPC_GRAY;
 811         numcomps = save_alpha ? 2 : 1;
 812     } else {
 813         numcomps = save_alpha ? 4 : 3;
 814         color_space = OPJ_CLRSPC_SRGB;
 815     }
 816
 817     /* If the declared file size is > 10 MB, check that the file is big */
 818     /* enough to avoid excessive memory allocations */
 819     if (image_height != 0 &&
 820             image_width > 10000000U / image_height / (OPJ_UINT32)numcomps) {
 821         char ch;
 822         OPJ_UINT64 expected_file_size =
 823             (OPJ_UINT64)image_width * image_height * (OPJ_UINT32)numcomps;
 824         long curpos = ftell(f);
 825         if (expected_file_size > (OPJ_UINT64)INT_MAX) {
 826             expected_file_size = (OPJ_UINT64)INT_MAX;
 827         }
 828         fseek(f, (long)expected_file_size - 1, SEEK_SET);
 829         if (fread(&ch, 1, 1, f) != 1) {
 830             fclose(f);
 831             return NULL;
 832         }
 833         fseek(f, curpos, SEEK_SET);
 834     }
 835
 836     subsampling_dx = parameters->subsampling_dx;
 837     subsampling_dy = parameters->subsampling_dy;
 838
 839     for (i = 0; i < numcomps; i++) {
 840         cmptparm[i].prec = 8;
 841         cmptparm[i].bpp = 8;
 842         cmptparm[i].sgnd = 0;
 843         cmptparm[i].dx = (OPJ_UINT32)subsampling_dx;
 844         cmptparm[i].dy = (OPJ_UINT32)subsampling_dy;
 845         cmptparm[i].w = image_width;
 846         cmptparm[i].h = image_height;
 847     }
 848
 849     /* create the image */
 850     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
 851
 852     if (!image) {
 853         fclose(f);
 854         return NULL;
 855     }
 856
 857
 858     /* set image offset and reference grid */
 859     image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
 860     image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
 861     image->x1 = !image->x0 ? (OPJ_UINT32)(image_width - 1)  *
 862                 (OPJ_UINT32)subsampling_dx + 1 : image->x0 + (OPJ_UINT32)(image_width - 1)  *
 863                 (OPJ_UINT32)subsampling_dx + 1;
 864     image->y1 = !image->y0 ? (OPJ_UINT32)(image_height - 1) *
 865                 (OPJ_UINT32)subsampling_dy + 1 : image->y0 + (OPJ_UINT32)(image_height - 1) *
 866                 (OPJ_UINT32)subsampling_dy + 1;
 867
 868     /* set image data */
 869     for (y = 0; y < image_height; y++) {
 870         int index;
 871
 872         if (flip_image) {
 873             index = (int)((image_height - y - 1) * image_width);
 874         } else {
 875             index = (int)(y * image_width);
 876         }
 877
 878         if (numcomps == 3) {
 879             for (x = 0; x < image_width; x++) {
 880                 unsigned char r, g, b;
 881
 882                 if (!fread(&b, 1, 1, f)) {
 883                     fprintf(stderr,
 884                             "\nError: fread return a number of element different from the expected.\n");
 885                     opj_image_destroy(image);
 886                     fclose(f);
 887                     return NULL;
 888                 }
 889                 if (!fread(&g, 1, 1, f)) {
 890                     fprintf(stderr,
 891                             "\nError: fread return a number of element different from the expected.\n");
 892                     opj_image_destroy(image);
 893                     fclose(f);
 894                     return NULL;
 895                 }
 896                 if (!fread(&r, 1, 1, f)) {
 897                     fprintf(stderr,
 898                             "\nError: fread return a number of element different from the expected.\n");
 899                     opj_image_destroy(image);
 900                     fclose(f);
 901                     return NULL;
 902                 }
 903
 904                 image->comps[0].data[index] = r;
 905                 image->comps[1].data[index] = g;
 906                 image->comps[2].data[index] = b;
 907                 index++;
 908             }
 909         } else if (numcomps == 4) {
 910             for (x = 0; x < image_width; x++) {
 911                 unsigned char r, g, b, a;
 912                 if (!fread(&b, 1, 1, f)) {
 913                     fprintf(stderr,
 914                             "\nError: fread return a number of element different from the expected.\n");
 915                     opj_image_destroy(image);
 916                     fclose(f);
 917                     return NULL;
 918                 }
 919                 if (!fread(&g, 1, 1, f)) {
 920                     fprintf(stderr,
 921                             "\nError: fread return a number of element different from the expected.\n");
 922                     opj_image_destroy(image);
 923                     fclose(f);
 924                     return NULL;
 925                 }
 926                 if (!fread(&r, 1, 1, f)) {
 927                     fprintf(stderr,
 928                             "\nError: fread return a number of element different from the expected.\n");
 929                     opj_image_destroy(image);
 930                     fclose(f);
 931                     return NULL;
 932                 }
 933                 if (!fread(&a, 1, 1, f)) {
 934                     fprintf(stderr,
 935                             "\nError: fread return a number of element different from the expected.\n");
 936                     opj_image_destroy(image);
 937                     fclose(f);
 938                     return NULL;
 939                 }
 940
 941                 image->comps[0].data[index] = r;
 942                 image->comps[1].data[index] = g;
 943                 image->comps[2].data[index] = b;
 944                 image->comps[3].data[index] = a;
 945                 index++;
 946             }
 947         } else {
 948             fprintf(stderr, "Currently unsupported bit depth : %s\n", filename);
 949         }
 950     }
 951     fclose(f);
 952     return image;
 953 }
 954
 955 int imagetotga(opj_image_t * image, const char *outfile)
 956 {
 957     int width, height, bpp, x, y;
 958     OPJ_BOOL write_alpha;
 959     unsigned int i;
 960     int adjustR, adjustG = 0, adjustB = 0, fails;
 961     unsigned int alpha_channel;
 962     float r, g, b, a;
 963     unsigned char value;
 964     float scale;
 965     FILE *fdest;
 966     size_t res;
 967     fails = 1;
 968
 969     fdest = fopen(outfile, "wb");
 970     if (!fdest) {
 971         fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
 972         return 1;
 973     }
 974
 975     for (i = 0; i < image->numcomps - 1; i++) {
 976         if ((image->comps[0].dx != image->comps[i + 1].dx)
 977                 || (image->comps[0].dy != image->comps[i + 1].dy)
 978                 || (image->comps[0].prec != image->comps[i + 1].prec)
 979                 || (image->comps[0].sgnd != image->comps[i + 1].sgnd)) {
 980             fclose(fdest);
 981             fprintf(stderr,
 982                     "Unable to create a tga file with such J2K image charateristics.\n");
 983             return 1;
 984         }
 985     }
 986
 987     width  = (int)image->comps[0].w;
 988     height = (int)image->comps[0].h;
 989
 990     /* Mono with alpha, or RGB with alpha. */
 991     write_alpha = (image->numcomps == 2) || (image->numcomps == 4);
 992
 993     /* Write TGA header  */
 994     bpp = write_alpha ? 32 : 24;
 995
 996     if (!tga_writeheader(fdest, bpp, width, height, OPJ_TRUE)) {
 997         goto fin;
 998     }
 999
1000     alpha_channel = image->numcomps - 1;
1001
1002     scale = 255.0f / (float)((1 << image->comps[0].prec) - 1);
1003
1004     adjustR = (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
1005     if (image->numcomps >= 3) {
1006         adjustG = (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
1007         adjustB = (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
1008     }
1009
1010     for (y = 0; y < height; y++) {
1011         unsigned int index = (unsigned int)(y * width);
1012
1013         for (x = 0; x < width; x++, index++) {
1014             r = (float)(image->comps[0].data[index] + adjustR);
1015
1016             if (image->numcomps > 2) {
1017                 g = (float)(image->comps[1].data[index] + adjustG);
1018                 b = (float)(image->comps[2].data[index] + adjustB);
1019             } else {
1020                 /* Greyscale ... */
1021                 g = r;
1022                 b = r;
1023             }
1024
1025             /* TGA format writes BGR ... */
1026             if (b > 255.) {
1027                 b = 255.;
1028             } else if (b < 0.) {
1029                 b = 0.;
1030             }
1031             value = (unsigned char)(b * scale);
1032             res = fwrite(&value, 1, 1, fdest);
1033
1034             if (res < 1) {
1035                 fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
1036                 goto fin;
1037             }
1038             if (g > 255.) {
1039                 g = 255.;
1040             } else if (g < 0.) {
1041                 g = 0.;
1042             }
1043             value = (unsigned char)(g * scale);
1044             res = fwrite(&value, 1, 1, fdest);
1045
1046             if (res < 1) {
1047                 fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
1048                 goto fin;
1049             }
1050             if (r > 255.) {
1051                 r = 255.;
1052             } else if (r < 0.) {
1053                 r = 0.;
1054             }
1055             value = (unsigned char)(r * scale);
1056             res = fwrite(&value, 1, 1, fdest);
1057
1058             if (res < 1) {
1059                 fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
1060                 goto fin;
1061             }
1062
1063             if (write_alpha) {
1064                 a = (float)(image->comps[alpha_channel].data[index]);
1065                 if (a > 255.) {
1066                     a = 255.;
1067                 } else if (a < 0.) {
1068                     a = 0.;
1069                 }
1070                 value = (unsigned char)(a * scale);
1071                 res = fwrite(&value, 1, 1, fdest);
1072
1073                 if (res < 1) {
1074                     fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
1075                     goto fin;
1076                 }
1077             }
1078         }
1079     }
1080     fails = 0;
1081 fin:
1082     fclose(fdest);
1083
1084     return fails;
1085 }
1086
1087 /* -->> -->> -->> -->>
1088
1089 PGX IMAGE FORMAT
1090
1091 <<-- <<-- <<-- <<-- */
1092
1093
1094 static unsigned char readuchar(FILE * f)
1095 {
1096     unsigned char c1;
1097     if (!fread(&c1, 1, 1, f)) {
1098         fprintf(stderr,
1099                 "\nError: fread return a number of element different from the expected.\n");
1100         return 0;
1101     }
1102     return c1;
1103 }
1104
1105 static unsigned short readushort(FILE * f, int bigendian)
1106 {
1107     unsigned char c1, c2;
1108     if (!fread(&c1, 1, 1, f)) {
1109         fprintf(stderr,
1110                 "\nError: fread return a number of element different from the expected.\n");
1111         return 0;
1112     }
1113     if (!fread(&c2, 1, 1, f)) {
1114         fprintf(stderr,
1115                 "\nError: fread return a number of element different from the expected.\n");
1116         return 0;
1117     }
1118     if (bigendian) {
1119         return (unsigned short)((c1 << 8) + c2);
1120     } else {
1121         return (unsigned short)((c2 << 8) + c1);
1122     }
1123 }
1124
1125 static unsigned int readuint(FILE * f, int bigendian)
1126 {
1127     unsigned char c1, c2, c3, c4;
1128     if (!fread(&c1, 1, 1, f)) {
1129         fprintf(stderr,
1130                 "\nError: fread return a number of element different from the expected.\n");
1131         return 0;
1132     }
1133     if (!fread(&c2, 1, 1, f)) {
1134         fprintf(stderr,
1135                 "\nError: fread return a number of element different from the expected.\n");
1136         return 0;
1137     }
1138     if (!fread(&c3, 1, 1, f)) {
1139         fprintf(stderr,
1140                 "\nError: fread return a number of element different from the expected.\n");
1141         return 0;
1142     }
1143     if (!fread(&c4, 1, 1, f)) {
1144         fprintf(stderr,
1145                 "\nError: fread return a number of element different from the expected.\n");
1146         return 0;
1147     }
1148     if (bigendian) {
1149         return (unsigned int)(c1 << 24) + (unsigned int)(c2 << 16) + (unsigned int)(
1150                    c3 << 8) + c4;
1151     } else {
1152         return (unsigned int)(c4 << 24) + (unsigned int)(c3 << 16) + (unsigned int)(
1153                    c2 << 8) + c1;
1154     }
1155 }
1156
1157 opj_image_t* pgxtoimage(const char *filename, opj_cparameters_t *parameters)
1158 {
1159     FILE *f = NULL;
1160     int w, h, prec;
1161     int i, numcomps, max;
1162     OPJ_COLOR_SPACE color_space;
1163     opj_image_cmptparm_t cmptparm;  /* maximum of 1 component  */
1164     opj_image_t * image = NULL;
1165     int adjustS, ushift, dshift, force8;
1166     OPJ_UINT64 expected_file_size;
1167
1168     char endian1, endian2, sign;
1169     char signtmp[32];
1170
1171     char temp[32];
1172     int bigendian;
1173     opj_image_comp_t *comp = NULL;
1174
1175     numcomps = 1;
1176     color_space = OPJ_CLRSPC_GRAY;
1177
1178     memset(&cmptparm, 0, sizeof(opj_image_cmptparm_t));
1179
1180     max = 0;
1181
1182     f = fopen(filename, "rb");
1183     if (!f) {
1184         fprintf(stderr, "Failed to open %s for reading !\n", filename);
1185         return NULL;
1186     }
1187
1188     fseek(f, 0, SEEK_SET);
1189     if (fscanf(f, "PG%31[ \t]%c%c%31[ \t+-]%d%31[ \t]%d%31[ \t]%d", temp, &endian1,
1190                &endian2, signtmp, &prec, temp, &w, temp, &h) != 9) {
1191         fclose(f);
1192         fprintf(stderr,
1193                 "ERROR: Failed to read the right number of element from the fscanf() function!\n");
1194         return NULL;
1195     }
1196
1197     i = 0;
1198     sign = '+';
1199     while (signtmp[i] != '\0') {
1200         if (signtmp[i] == '-') {
1201             sign = '-';
1202         }
1203         i++;
1204     }
1205
1206     fgetc(f);
1207     if (endian1 == 'M' && endian2 == 'L') {
1208         bigendian = 1;
1209     } else if (endian2 == 'M' && endian1 == 'L') {
1210         bigendian = 0;
1211     } else {
1212         fclose(f);
1213         fprintf(stderr, "Bad pgx header, please check input file\n");
1214         return NULL;
1215     }
1216
1217     if (w < 1 || h < 1 || prec < 1 || prec > 31) {
1218         fclose(f);
1219         fprintf(stderr, "Bad pgx header, please check input file\n");
1220         return NULL;
1221     }
1222
1223     expected_file_size =
1224         (OPJ_UINT64)w * (OPJ_UINT64)h * (prec > 16 ? 4 : prec > 8 ? 2 : 1);
1225     if (expected_file_size > 10000000U) {
1226         char ch;
1227         long curpos = ftell(f);
1228         if (expected_file_size > (OPJ_UINT64)INT_MAX) {
1229             expected_file_size = (OPJ_UINT64)INT_MAX;
1230         }
1231         fseek(f, (long)expected_file_size - 1, SEEK_SET);
1232         if (fread(&ch, 1, 1, f) != 1) {
1233             fprintf(stderr, "File too short\n");
1234             fclose(f);
1235             return NULL;
1236         }
1237         fseek(f, curpos, SEEK_SET);
1238     }
1239
1240     /* initialize image component */
1241
1242     cmptparm.x0 = (OPJ_UINT32)parameters->image_offset_x0;
1243     cmptparm.y0 = (OPJ_UINT32)parameters->image_offset_y0;
1244     cmptparm.w = !cmptparm.x0 ? (OPJ_UINT32)((w - 1) * parameters->subsampling_dx +
1245                  1) : cmptparm.x0 + (OPJ_UINT32)(w - 1) * (OPJ_UINT32)parameters->subsampling_dx
1246                  + 1;
1247     cmptparm.h = !cmptparm.y0 ? (OPJ_UINT32)((h - 1) * parameters->subsampling_dy +
1248                  1) : cmptparm.y0 + (OPJ_UINT32)(h - 1) * (OPJ_UINT32)parameters->subsampling_dy
1249                  + 1;
1250
1251     if (sign == '-') {
1252         cmptparm.sgnd = 1;
1253     } else {
1254         cmptparm.sgnd = 0;
1255     }
1256     if (prec < 8) {
1257         force8 = 1;
1258         ushift = 8 - prec;
1259         dshift = prec - ushift;
1260         if (cmptparm.sgnd) {
1261             adjustS = (1 << (prec - 1));
1262         } else {
1263             adjustS = 0;
1264         }
1265         cmptparm.sgnd = 0;
1266         prec = 8;
1267     } else {
1268         ushift = dshift = force8 = adjustS = 0;
1269     }
1270
1271     cmptparm.prec = (OPJ_UINT32)prec;
1272     cmptparm.bpp = (OPJ_UINT32)prec;
1273     cmptparm.dx = (OPJ_UINT32)parameters->subsampling_dx;
1274     cmptparm.dy = (OPJ_UINT32)parameters->subsampling_dy;
1275
1276     /* create the image */
1277     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm, color_space);
1278     if (!image) {
1279         fclose(f);
1280         return NULL;
1281     }
1282     /* set image offset and reference grid */
1283     image->x0 = cmptparm.x0;
1284     image->y0 = cmptparm.x0;
1285     image->x1 = cmptparm.w;
1286     image->y1 = cmptparm.h;
1287
1288     /* set image data */
1289
1290     comp = &image->comps[0];
1291
1292     for (i = 0; i < w * h; i++) {
1293         int v;
1294         if (force8) {
1295             v = readuchar(f) + adjustS;
1296             v = (v << ushift) + (v >> dshift);
1297             comp->data[i] = (unsigned char)v;
1298
1299             if (v > max) {
1300                 max = v;
1301             }
1302
1303             continue;
1304         }
1305         if (comp->prec == 8) {
1306             if (!comp->sgnd) {
1307                 v = readuchar(f);
1308             } else {
1309                 v = (char) readuchar(f);
1310             }
1311         } else if (comp->prec <= 16) {
1312             if (!comp->sgnd) {
1313                 v = readushort(f, bigendian);
1314             } else {
1315                 v = (short) readushort(f, bigendian);
1316             }
1317         } else {
1318             if (!comp->sgnd) {
1319                 v = (int)readuint(f, bigendian);
1320             } else {
1321                 v = (int) readuint(f, bigendian);
1322             }
1323         }
1324         if (v > max) {
1325             max = v;
1326         }
1327         comp->data[i] = v;
1328     }
1329     fclose(f);
1330     comp->bpp = (OPJ_UINT32)int_floorlog2(max) + 1;
1331
1332     return image;
1333 }
1334
1335 #define CLAMP(x,a,b) x < a ? a : (x > b ? b : x)
1336
1337 static INLINE int clamp(const int value, const int prec, const int sgnd)
1338 {
1339     if (sgnd) {
1340         if (prec <= 8) {
1341             return CLAMP(value, -128, 127);
1342         } else if (prec <= 16) {
1343             return CLAMP(value, -32768, 32767);
1344         } else {
1345             return CLAMP(value, -2147483647 - 1, 2147483647);
1346         }
1347     } else {
1348         if (prec <= 8) {
1349             return CLAMP(value, 0, 255);
1350         } else if (prec <= 16) {
1351             return CLAMP(value, 0, 65535);
1352         } else {
1353             return value;    /*CLAMP(value,0,4294967295);*/
1354         }
1355     }
1356 }
1357
1358 int imagetopgx(opj_image_t * image, const char *outfile)
1359 {
1360     int w, h;
1361     int i, j, fails = 1;
1362     unsigned int compno;
1363     FILE *fdest = NULL;
1364
1365     for (compno = 0; compno < image->numcomps; compno++) {
1366         opj_image_comp_t *comp = &image->comps[compno];
1367         char bname[256]; /* buffer for name */
1368         char *name = bname; /* pointer */
1369         int nbytes = 0;
1370         size_t res;
1371         const size_t olen = strlen(outfile);
1372         const size_t dotpos = olen - 4;
1373         const size_t total = dotpos + 1 + 1 + 4; /* '-' + '[1-3]' + '.pgx' */
1374
1375         if (outfile[dotpos] != '.') {
1376             /* `pgx` was recognized but there is no dot at expected position */
1377             fprintf(stderr, "ERROR -> Impossible happen.");
1378             goto fin;
1379         }
1380         if (total > 256) {
1381             name = (char*)malloc(total + 1);
1382             if (name == NULL) {
1383                 fprintf(stderr, "imagetopgx: memory out\n");
1384                 goto fin;
1385             }
1386         }
1387         strncpy(name, outfile, dotpos);
1388         sprintf(name + dotpos, "_%u.pgx", compno);
1389         fdest = fopen(name, "wb");
1390         /* don't need name anymore */
1391
1392         if (!fdest) {
1393
1394             fprintf(stderr, "ERROR -> failed to open %s for writing\n", name);
1395             if (total > 256) {
1396                 free(name);
1397             }
1398             goto fin;
1399         }
1400
1401         w = (int)image->comps[compno].w;
1402         h = (int)image->comps[compno].h;
1403
1404         fprintf(fdest, "PG ML %c %d %d %d\n", comp->sgnd ? '-' : '+', comp->prec,
1405                 w, h);
1406
1407         if (comp->prec <= 8) {
1408             nbytes = 1;
1409         } else if (comp->prec <= 16) {
1410             nbytes = 2;
1411         } else {
1412             nbytes = 4;
1413         }
1414
1415         for (i = 0; i < w * h; i++) {
1416             /* FIXME: clamp func is being called within a loop */
1417             const int val = clamp(image->comps[compno].data[i],
1418                                   (int)comp->prec, (int)comp->sgnd);
1419
1420             for (j = nbytes - 1; j >= 0; j--) {
1421                 int v = (int)(val >> (j * 8));
1422                 unsigned char byte = (unsigned char)v;
1423                 res = fwrite(&byte, 1, 1, fdest);
1424
1425                 if (res < 1) {
1426                     fprintf(stderr, "failed to write 1 byte for %s\n", name);
1427                     if (total > 256) {
1428                         free(name);
1429                     }
1430                     goto fin;
1431                 }
1432             }
1433         }
1434         if (total > 256) {
1435             free(name);
1436         }
1437         fclose(fdest);
1438         fdest = NULL;
1439     }
1440     fails = 0;
1441 fin:
1442     if (fdest) {
1443         fclose(fdest);
1444     }
1445
1446     return fails;
1447 }
1448
1449 /* -->> -->> -->> -->>
1450
1451 PNM IMAGE FORMAT
1452
1453 <<-- <<-- <<-- <<-- */
1454
1455 struct pnm_header {
1456     int width, height, maxval, depth, format;
1457     char rgb, rgba, gray, graya, bw;
1458     char ok;
1459 };
1460
1461 static char *skip_white(char *s)
1462 {
1463     if (s != NULL) {
1464         while (*s) {
1465             if (*s == '\n' || *s == '\r') {
1466                 return NULL;
1467             }
1468             if (isspace(*s)) {
1469                 ++s;
1470                 continue;
1471             }
1472             return s;
1473         }
1474     }
1475     return NULL;
1476 }
1477
1478 static char *skip_int(char *start, int *out_n)
1479 {
1480     char *s;
1481     char c;
1482
1483     *out_n = 0;
1484
1485     s = skip_white(start);
1486     if (s == NULL) {
1487         return NULL;
1488     }
1489     start = s;
1490
1491     while (*s) {
1492         if (!isdigit(*s)) {
1493             break;
1494         }
1495         ++s;
1496     }
1497     c = *s;
1498     *s = 0;
1499     *out_n = atoi(start);
1500     *s = c;
1501     return s;
1502 }
1503
1504 static char *skip_idf(char *start, char out_idf[256])
1505 {
1506     char *s;
1507     char c;
1508
1509     s = skip_white(start);
1510     if (s == NULL) {
1511         return NULL;
1512     }
1513     start = s;
1514
1515     while (*s) {
1516         if (isalpha(*s) || *s == '_') {
1517             ++s;
1518             continue;
1519         }
1520         break;
1521     }
1522     c = *s;
1523     *s = 0;
1524     strncpy(out_idf, start, 255);
1525     *s = c;
1526     return s;
1527 }
1528
1529 static void read_pnm_header(FILE *reader, struct pnm_header *ph)
1530 {
1531     int format, end, ttype;
1532     char idf[256], type[256];
1533     char line[256];
1534
1535     if (fgets(line, 250, reader) == NULL) {
1536         fprintf(stderr, "\nWARNING: fgets return a NULL value");
1537         return;
1538     }
1539
1540     if (line[0] != 'P') {
1541         fprintf(stderr, "read_pnm_header:PNM:magic P missing\n");
1542         return;
1543     }
1544     format = atoi(line + 1);
1545     if (format < 1 || format > 7) {
1546         fprintf(stderr, "read_pnm_header:magic format %d invalid\n", format);
1547         return;
1548     }
1549     ph->format = format;
1550     ttype = end = 0;
1551
1552     while (fgets(line, 250, reader)) {
1553         char *s;
1554         int allow_null = 0;
1555
1556         if (*line == '#') {
1557             continue;
1558         }
1559
1560         s = line;
1561
1562         if (format == 7) {
1563             s = skip_idf(s, idf);
1564
1565             if (s == NULL || *s == 0) {
1566                 return;
1567             }
1568
1569             if (strcmp(idf, "ENDHDR") == 0) {
1570                 end = 1;
1571                 break;
1572             }
1573             if (strcmp(idf, "WIDTH") == 0) {
1574                 s = skip_int(s, &ph->width);
1575                 if (s == NULL || *s == 0) {
1576                     return;
1577                 }
1578
1579                 continue;
1580             }
1581             if (strcmp(idf, "HEIGHT") == 0) {
1582                 s = skip_int(s, &ph->height);
1583                 if (s == NULL || *s == 0) {
1584                     return;
1585                 }
1586
1587                 continue;
1588             }
1589             if (strcmp(idf, "DEPTH") == 0) {
1590                 s = skip_int(s, &ph->depth);
1591                 if (s == NULL || *s == 0) {
1592                     return;
1593                 }
1594
1595                 continue;
1596             }
1597             if (strcmp(idf, "MAXVAL") == 0) {
1598                 s = skip_int(s, &ph->maxval);
1599                 if (s == NULL || *s == 0) {
1600                     return;
1601                 }
1602
1603                 continue;
1604             }
1605             if (strcmp(idf, "TUPLTYPE") == 0) {
1606                 s = skip_idf(s, type);
1607                 if (s == NULL || *s == 0) {
1608                     return;
1609                 }
1610
1611                 if (strcmp(type, "BLACKANDWHITE") == 0) {
1612                     ph->bw = 1;
1613                     ttype = 1;
1614                     continue;
1615                 }
1616                 if (strcmp(type, "GRAYSCALE") == 0) {
1617                     ph->gray = 1;
1618                     ttype = 1;
1619                     continue;
1620                 }
1621                 if (strcmp(type, "GRAYSCALE_ALPHA") == 0) {
1622                     ph->graya = 1;
1623                     ttype = 1;
1624                     continue;
1625                 }
1626                 if (strcmp(type, "RGB") == 0) {
1627                     ph->rgb = 1;
1628                     ttype = 1;
1629                     continue;
1630                 }
1631                 if (strcmp(type, "RGB_ALPHA") == 0) {
1632                     ph->rgba = 1;
1633                     ttype = 1;
1634                     continue;
1635                 }
1636                 fprintf(stderr, "read_pnm_header:unknown P7 TUPLTYPE %s\n", type);
1637                 return;
1638             }
1639             fprintf(stderr, "read_pnm_header:unknown P7 idf %s\n", idf);
1640             return;
1641         } /* if(format == 7) */
1642
1643         /* Here format is in range [1,6] */
1644         if (ph->width == 0) {
1645             s = skip_int(s, &ph->width);
1646             if ((s == NULL) || (*s == 0) || (ph->width < 1)) {
1647                 return;
1648             }
1649             allow_null = 1;
1650         }
1651         if (ph->height == 0) {
1652             s = skip_int(s, &ph->height);
1653             if ((s == NULL) && allow_null) {
1654                 continue;
1655             }
1656             if ((s == NULL) || (*s == 0) || (ph->height < 1)) {
1657                 return;
1658             }
1659             if (format == 1 || format == 4) {
1660                 break;
1661             }
1662             allow_null = 1;
1663         }
1664         /* here, format is in P2, P3, P5, P6 */
1665         s = skip_int(s, &ph->maxval);
1666         if ((s == NULL) && allow_null) {
1667             continue;
1668         }
1669         if ((s == NULL) || (*s == 0)) {
1670             return;
1671         }
1672         break;
1673     }/* while(fgets( ) */
1674     if (format == 2 || format == 3 || format > 4) {
1675         if (ph->maxval < 1 || ph->maxval > 65535) {
1676             return;
1677         }
1678     }
1679     if (ph->width < 1 || ph->height < 1) {
1680         return;
1681     }
1682
1683     if (format == 7) {
1684         if (!end) {
1685             fprintf(stderr, "read_pnm_header:P7 without ENDHDR\n");
1686             return;
1687         }
1688         if (ph->depth < 1 || ph->depth > 4) {
1689             return;
1690         }
1691
1692         if (ttype) {
1693             ph->ok = 1;
1694         }
1695     } else {
1696         ph->ok = 1;
1697         if (format == 1 || format == 4) {
1698             ph->maxval = 255;
1699         }
1700     }
1701 }
1702
1703 static int has_prec(int val)
1704 {
1705     if (val < 2) {
1706         return 1;
1707     }
1708     if (val < 4) {
1709         return 2;
1710     }
1711     if (val < 8) {
1712         return 3;
1713     }
1714     if (val < 16) {
1715         return 4;
1716     }
1717     if (val < 32) {
1718         return 5;
1719     }
1720     if (val < 64) {
1721         return 6;
1722     }
1723     if (val < 128) {
1724         return 7;
1725     }
1726     if (val < 256) {
1727         return 8;
1728     }
1729     if (val < 512) {
1730         return 9;
1731     }
1732     if (val < 1024) {
1733         return 10;
1734     }
1735     if (val < 2048) {
1736         return 11;
1737     }
1738     if (val < 4096) {
1739         return 12;
1740     }
1741     if (val < 8192) {
1742         return 13;
1743     }
1744     if (val < 16384) {
1745         return 14;
1746     }
1747     if (val < 32768) {
1748         return 15;
1749     }
1750     return 16;
1751 }
1752
1753 opj_image_t* pnmtoimage(const char *filename, opj_cparameters_t *parameters)
1754 {
1755     int subsampling_dx = parameters->subsampling_dx;
1756     int subsampling_dy = parameters->subsampling_dy;
1757
1758     FILE *fp = NULL;
1759     int i, compno, numcomps, w, h, prec, format;
1760     OPJ_COLOR_SPACE color_space;
1761     opj_image_cmptparm_t cmptparm[4]; /* RGBA: max. 4 components */
1762     opj_image_t * image = NULL;
1763     struct pnm_header header_info;
1764
1765     if ((fp = fopen(filename, "rb")) == NULL) {
1766         fprintf(stderr, "pnmtoimage:Failed to open %s for reading!\n", filename);
1767         return NULL;
1768     }
1769     memset(&header_info, 0, sizeof(struct pnm_header));
1770
1771     read_pnm_header(fp, &header_info);
1772
1773     if (!header_info.ok) {
1774         fclose(fp);
1775         return NULL;
1776     }
1777
1778     /* This limitation could be removed by making sure to use size_t below */
1779     if (header_info.height != 0 &&
1780             header_info.width > INT_MAX / header_info.height) {
1781         fprintf(stderr, "pnmtoimage:Image %dx%d too big!\n",
1782                 header_info.width, header_info.height);
1783         fclose(fp);
1784         return NULL;
1785     }
1786
1787     format = header_info.format;
1788
1789     switch (format) {
1790     case 1: /* ascii bitmap */
1791     case 4: /* raw bitmap */
1792         numcomps = 1;
1793         break;
1794
1795     case 2: /* ascii greymap */
1796     case 5: /* raw greymap */
1797         numcomps = 1;
1798         break;
1799
1800     case 3: /* ascii pixmap */
1801     case 6: /* raw pixmap */
1802         numcomps = 3;
1803         break;
1804
1805     case 7: /* arbitrary map */
1806         numcomps = header_info.depth;
1807         break;
1808
1809     default:
1810         fclose(fp);
1811         return NULL;
1812     }
1813     if (numcomps < 3) {
1814         color_space = OPJ_CLRSPC_GRAY;    /* GRAY, GRAYA */
1815     } else {
1816         color_space = OPJ_CLRSPC_SRGB;    /* RGB, RGBA */
1817     }
1818
1819     prec = has_prec(header_info.maxval);
1820
1821     if (prec < 8) {
1822         prec = 8;
1823     }
1824
1825     w = header_info.width;
1826     h = header_info.height;
1827     subsampling_dx = parameters->subsampling_dx;
1828     subsampling_dy = parameters->subsampling_dy;
1829
1830     memset(&cmptparm[0], 0, (size_t)numcomps * sizeof(opj_image_cmptparm_t));
1831
1832     for (i = 0; i < numcomps; i++) {
1833         cmptparm[i].prec = (OPJ_UINT32)prec;
1834         cmptparm[i].bpp = (OPJ_UINT32)prec;
1835         cmptparm[i].sgnd = 0;
1836         cmptparm[i].dx = (OPJ_UINT32)subsampling_dx;
1837         cmptparm[i].dy = (OPJ_UINT32)subsampling_dy;
1838         cmptparm[i].w = (OPJ_UINT32)w;
1839         cmptparm[i].h = (OPJ_UINT32)h;
1840     }
1841     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
1842
1843     if (!image) {
1844         fclose(fp);
1845         return NULL;
1846     }
1847
1848     /* set image offset and reference grid */
1849     image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
1850     image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
1851     image->x1 = (OPJ_UINT32)(parameters->image_offset_x0 + (w - 1) * subsampling_dx
1852                              + 1);
1853     image->y1 = (OPJ_UINT32)(parameters->image_offset_y0 + (h - 1) * subsampling_dy
1854                              + 1);
1855
1856     if ((format == 2) || (format == 3)) { /* ascii pixmap */
1857         unsigned int index;
1858
1859         for (i = 0; i < w * h; i++) {
1860             for (compno = 0; compno < numcomps; compno++) {
1861                 index = 0;
1862                 if (fscanf(fp, "%u", &index) != 1) {
1863                     fprintf(stderr,
1864                             "\nWARNING: fscanf return a number of element different from the expected.\n");
1865                 }
1866
1867                 image->comps[compno].data[i] = (OPJ_INT32)(index * 255) / header_info.maxval;
1868             }
1869         }
1870     } else if ((format == 5)
1871                || (format == 6)
1872                || ((format == 7)
1873                    && (header_info.gray || header_info.graya
1874                        || header_info.rgb || header_info.rgba))) { /* binary pixmap */
1875         unsigned char c0, c1, one;
1876
1877         one = (prec < 9);
1878
1879         for (i = 0; i < w * h; i++) {
1880             for (compno = 0; compno < numcomps; compno++) {
1881                 if (!fread(&c0, 1, 1, fp)) {
1882                     fprintf(stderr,
1883                             "\nError: fread return a number of element different from the expected.\n");
1884                     opj_image_destroy(image);
1885                     fclose(fp);
1886                     return NULL;
1887                 }
1888                 if (one) {
1889                     image->comps[compno].data[i] = c0;
1890                 } else {
1891                     if (!fread(&c1, 1, 1, fp)) {
1892                         fprintf(stderr,
1893                                 "\nError: fread return a number of element different from the expected.\n");
1894                     }
1895                     /* netpbm: */
1896                     image->comps[compno].data[i] = ((c0 << 8) | c1);
1897                 }
1898             }
1899         }
1900     } else if (format == 1) { /* ascii bitmap */
1901         for (i = 0; i < w * h; i++) {
1902             unsigned int index;
1903
1904             if (fscanf(fp, "%u", &index) != 1) {
1905                 fprintf(stderr,
1906                         "\nWARNING: fscanf return a number of element different from the expected.\n");
1907             }
1908
1909             image->comps[0].data[i] = (index ? 0 : 255);
1910         }
1911     } else if (format == 4) {
1912         int x, y, bit;
1913         unsigned char uc;
1914
1915         i = 0;
1916         for (y = 0; y < h; ++y) {
1917             bit = -1;
1918             uc = 0;
1919
1920             for (x = 0; x < w; ++x) {
1921                 if (bit == -1) {
1922                     bit = 7;
1923                     uc = (unsigned char)getc(fp);
1924                 }
1925                 image->comps[0].data[i] = (((uc >> bit) & 1) ? 0 : 255);
1926                 --bit;
1927                 ++i;
1928             }
1929         }
1930     } else if ((format == 7 && header_info.bw)) { /*MONO*/
1931         unsigned char uc;
1932
1933         for (i = 0; i < w * h; ++i) {
1934             if (!fread(&uc, 1, 1, fp)) {
1935                 fprintf(stderr,
1936                         "\nError: fread return a number of element different from the expected.\n");
1937             }
1938             image->comps[0].data[i] = (uc & 1) ? 0 : 255;
1939         }
1940     }
1941     fclose(fp);
1942
1943     return image;
1944 }/* pnmtoimage() */
1945
1946 static int are_comps_similar(opj_image_t * image)
1947 {
1948     unsigned int i;
1949     for (i = 1; i < image->numcomps; i++) {
1950         if (image->comps[0].dx != image->comps[i].dx ||
1951                 image->comps[0].dy != image->comps[i].dy ||
1952                 (i <= 2 &&
1953                  (image->comps[0].prec != image->comps[i].prec ||
1954                   image->comps[0].sgnd != image->comps[i].sgnd))) {
1955             return OPJ_FALSE;
1956         }
1957     }
1958     return OPJ_TRUE;
1959 }
1960
1961
1962 int imagetopnm(opj_image_t * image, const char *outfile, int force_split)
1963 {
1964     int *red, *green, *blue, *alpha;
1965     int wr, hr, max;
1966     int i;
1967     unsigned int compno, ncomp;
1968     int adjustR, adjustG, adjustB, adjustA;
1969     int fails, two, want_gray, has_alpha, triple;
1970     int prec, v;
1971     FILE *fdest = NULL;
1972     const char *tmp = outfile;
1973     char *destname;
1974
1975     alpha = NULL;
1976
1977     if ((prec = (int)image->comps[0].prec) > 16) {
1978         fprintf(stderr, "%s:%d:imagetopnm\n\tprecision %d is larger than 16"
1979                 "\n\t: refused.\n", __FILE__, __LINE__, prec);
1980         return 1;
1981     }
1982     two = has_alpha = 0;
1983     fails = 1;
1984     ncomp = image->numcomps;
1985
1986     while (*tmp) {
1987         ++tmp;
1988     }
1989     tmp -= 2;
1990     want_gray = (*tmp == 'g' || *tmp == 'G');
1991     ncomp = image->numcomps;
1992
1993     if (want_gray) {
1994         ncomp = 1;
1995     }
1996
1997     if ((force_split == 0) && ncomp >= 2 &&
1998             are_comps_similar(image)) {
1999         fdest = fopen(outfile, "wb");
2000
2001         if (!fdest) {
2002             fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
2003             return fails;
2004         }
2005         two = (prec > 8);
2006         triple = (ncomp > 2);
2007         wr = (int)image->comps[0].w;
2008         hr = (int)image->comps[0].h;
2009         max = (1 << prec) - 1;
2010         has_alpha = (ncomp == 4 || ncomp == 2);
2011
2012         red = image->comps[0].data;
2013
2014         if (triple) {
2015             green = image->comps[1].data;
2016             blue = image->comps[2].data;
2017         } else {
2018             green = blue = NULL;
2019         }
2020
2021         if (has_alpha) {
2022             const char *tt = (triple ? "RGB_ALPHA" : "GRAYSCALE_ALPHA");
2023
2024             fprintf(fdest, "P7\n# OpenJPEG-%s\nWIDTH %d\nHEIGHT %d\nDEPTH %u\n"
2025                     "MAXVAL %d\nTUPLTYPE %s\nENDHDR\n", opj_version(),
2026                     wr, hr, ncomp, max, tt);
2027             alpha = image->comps[ncomp - 1].data;
2028             adjustA = (image->comps[ncomp - 1].sgnd ?
2029                        1 << (image->comps[ncomp - 1].prec - 1) : 0);
2030         } else {
2031             fprintf(fdest, "P6\n# OpenJPEG-%s\n%d %d\n%d\n",
2032                     opj_version(), wr, hr, max);
2033             adjustA = 0;
2034         }
2035         adjustR = (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
2036
2037         if (triple) {
2038             adjustG = (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
2039             adjustB = (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
2040         } else {
2041             adjustG = adjustB = 0;
2042         }
2043
2044         for (i = 0; i < wr * hr; ++i) {
2045             if (two) {
2046                 v = *red + adjustR;
2047                 ++red;
2048                 if (v > 65535) {
2049                     v = 65535;
2050                 } else if (v < 0) {
2051                     v = 0;
2052                 }
2053
2054                 /* netpbm: */
2055                 fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2056
2057                 if (triple) {
2058                     v = *green + adjustG;
2059                     ++green;
2060                     if (v > 65535) {
2061                         v = 65535;
2062                     } else if (v < 0) {
2063                         v = 0;
2064                     }
2065
2066                     /* netpbm: */
2067                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2068
2069                     v =  *blue + adjustB;
2070                     ++blue;
2071                     if (v > 65535) {
2072                         v = 65535;
2073                     } else if (v < 0) {
2074                         v = 0;
2075                     }
2076
2077                     /* netpbm: */
2078                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2079
2080                 }/* if(triple) */
2081
2082                 if (has_alpha) {
2083                     v = *alpha + adjustA;
2084                     ++alpha;
2085                     if (v > 65535) {
2086                         v = 65535;
2087                     } else if (v < 0) {
2088                         v = 0;
2089                     }
2090
2091                     /* netpbm: */
2092                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2093                 }
2094                 continue;
2095
2096             }   /* if(two) */
2097
2098             /* prec <= 8: */
2099             v = *red++;
2100             if (v > 255) {
2101                 v = 255;
2102             } else if (v < 0) {
2103                 v = 0;
2104             }
2105
2106             fprintf(fdest, "%c", (unsigned char)v);
2107             if (triple) {
2108                 v = *green++;
2109                 if (v > 255) {
2110                     v = 255;
2111                 } else if (v < 0) {
2112                     v = 0;
2113                 }
2114
2115                 fprintf(fdest, "%c", (unsigned char)v);
2116                 v = *blue++;
2117                 if (v > 255) {
2118                     v = 255;
2119                 } else if (v < 0) {
2120                     v = 0;
2121                 }
2122
2123                 fprintf(fdest, "%c", (unsigned char)v);
2124             }
2125             if (has_alpha) {
2126                 v = *alpha++;
2127                 if (v > 255) {
2128                     v = 255;
2129                 } else if (v < 0) {
2130                     v = 0;
2131                 }
2132
2133                 fprintf(fdest, "%c", (unsigned char)v);
2134             }
2135         }   /* for(i */
2136
2137         fclose(fdest);
2138         return 0;
2139     }
2140
2141     /* YUV or MONO: */
2142
2143     if (image->numcomps > ncomp) {
2144         fprintf(stderr, "WARNING -> [PGM file] Only the first component\n");
2145         fprintf(stderr, "           is written to the file\n");
2146     }
2147     destname = (char*)malloc(strlen(outfile) + 8);
2148     if (destname == NULL) {
2149         fprintf(stderr, "imagetopnm: memory out\n");
2150         return 1;
2151     }
2152     for (compno = 0; compno < ncomp; compno++) {
2153         if (ncomp > 1) {
2154             /*sprintf(destname, "%d.%s", compno, outfile);*/
2155             const size_t olen = strlen(outfile);
2156             const size_t dotpos = olen - 4;
2157
2158             strncpy(destname, outfile, dotpos);
2159             sprintf(destname + dotpos, "_%u.pgm", compno);
2160         } else {
2161             sprintf(destname, "%s", outfile);
2162         }
2163
2164         fdest = fopen(destname, "wb");
2165         if (!fdest) {
2166             fprintf(stderr, "ERROR -> failed to open %s for writing\n", destname);
2167             free(destname);
2168             return 1;
2169         }
2170         wr = (int)image->comps[compno].w;
2171         hr = (int)image->comps[compno].h;
2172         prec = (int)image->comps[compno].prec;
2173         max = (1 << prec) - 1;
2174
2175         fprintf(fdest, "P5\n#OpenJPEG-%s\n%d %d\n%d\n",
2176                 opj_version(), wr, hr, max);
2177
2178         red = image->comps[compno].data;
2179         adjustR =
2180             (image->comps[compno].sgnd ? 1 << (image->comps[compno].prec - 1) : 0);
2181
2182         if (prec > 8) {
2183             for (i = 0; i < wr * hr; i++) {
2184                 v = *red + adjustR;
2185                 ++red;
2186                 if (v > 65535) {
2187                     v = 65535;
2188                 } else if (v < 0) {
2189                     v = 0;
2190                 }
2191
2192                 /* netpbm: */
2193                 fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2194
2195                 if (has_alpha) {
2196                     v = *alpha++;
2197                     if (v > 65535) {
2198                         v = 65535;
2199                     } else if (v < 0) {
2200                         v = 0;
2201                     }
2202
2203                     /* netpbm: */
2204                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2205                 }
2206             }/* for(i */
2207         } else { /* prec <= 8 */
2208             for (i = 0; i < wr * hr; ++i) {
2209                 v = *red + adjustR;
2210                 ++red;
2211                 if (v > 255) {
2212                     v = 255;
2213                 } else if (v < 0) {
2214                     v = 0;
2215                 }
2216
2217                 fprintf(fdest, "%c", (unsigned char)v);
2218             }
2219         }
2220         fclose(fdest);
2221     } /* for (compno */
2222     free(destname);
2223
2224     return 0;
2225 }/* imagetopnm() */
2226
2227 /* -->> -->> -->> -->>
2228
2229     RAW IMAGE FORMAT
2230
2231  <<-- <<-- <<-- <<-- */
2232 static opj_image_t* rawtoimage_common(const char *filename,
2233                                       opj_cparameters_t *parameters, raw_cparameters_t *raw_cp, OPJ_BOOL big_endian)
2234 {
2235     int subsampling_dx = parameters->subsampling_dx;
2236     int subsampling_dy = parameters->subsampling_dy;
2237
2238     FILE *f = NULL;
2239     int i, compno, numcomps, w, h;
2240     OPJ_COLOR_SPACE color_space;
2241     opj_image_cmptparm_t *cmptparm;
2242     opj_image_t * image = NULL;
2243     unsigned short ch;
2244
2245     if ((!(raw_cp->rawWidth & raw_cp->rawHeight & raw_cp->rawComp &
2246             raw_cp->rawBitDepth)) == 0) {
2247         fprintf(stderr, "\nError: invalid raw image parameters\n");
2248         fprintf(stderr, "Please use the Format option -F:\n");
2249         fprintf(stderr,
2250                 "-F <width>,<height>,<ncomp>,<bitdepth>,{s,u}@<dx1>x<dy1>:...:<dxn>x<dyn>\n");
2251         fprintf(stderr,
2252                 "If subsampling is omitted, 1x1 is assumed for all components\n");
2253         fprintf(stderr,
2254                 "Example: -i image.raw -o image.j2k -F 512,512,3,8,u@1x1:2x2:2x2\n");
2255         fprintf(stderr, "         for raw 512x512 image with 4:2:0 subsampling\n");
2256         fprintf(stderr, "Aborting.\n");
2257         return NULL;
2258     }
2259
2260     f = fopen(filename, "rb");
2261     if (!f) {
2262         fprintf(stderr, "Failed to open %s for reading !!\n", filename);
2263         fprintf(stderr, "Aborting\n");
2264         return NULL;
2265     }
2266     numcomps = raw_cp->rawComp;
2267
2268     /* FIXME ADE at this point, tcp_mct has not been properly set in calling function */
2269     if (numcomps == 1) {
2270         color_space = OPJ_CLRSPC_GRAY;
2271     } else if ((numcomps >= 3) && (parameters->tcp_mct == 0)) {
2272         color_space = OPJ_CLRSPC_SYCC;
2273     } else if ((numcomps >= 3) && (parameters->tcp_mct != 2)) {
2274         color_space = OPJ_CLRSPC_SRGB;
2275     } else {
2276         color_space = OPJ_CLRSPC_UNKNOWN;
2277     }
2278     w = raw_cp->rawWidth;
2279     h = raw_cp->rawHeight;
2280     cmptparm = (opj_image_cmptparm_t*) calloc((OPJ_UINT32)numcomps,
2281                sizeof(opj_image_cmptparm_t));
2282     if (!cmptparm) {
2283         fprintf(stderr, "Failed to allocate image components parameters !!\n");
2284         fprintf(stderr, "Aborting\n");
2285         fclose(f);
2286         return NULL;
2287     }
2288     /* initialize image components */
2289     for (i = 0; i < numcomps; i++) {
2290         cmptparm[i].prec = (OPJ_UINT32)raw_cp->rawBitDepth;
2291         cmptparm[i].bpp = (OPJ_UINT32)raw_cp->rawBitDepth;
2292         cmptparm[i].sgnd = (OPJ_UINT32)raw_cp->rawSigned;
2293         cmptparm[i].dx = (OPJ_UINT32)(subsampling_dx * raw_cp->rawComps[i].dx);
2294         cmptparm[i].dy = (OPJ_UINT32)(subsampling_dy * raw_cp->rawComps[i].dy);
2295         cmptparm[i].w = (OPJ_UINT32)w;
2296         cmptparm[i].h = (OPJ_UINT32)h;
2297     }
2298     /* create the image */
2299     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
2300     free(cmptparm);
2301     if (!image) {
2302         fclose(f);
2303         return NULL;
2304     }
2305     /* set image offset and reference grid */
2306     image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
2307     image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
2308     image->x1 = (OPJ_UINT32)parameters->image_offset_x0 + (OPJ_UINT32)(w - 1) *
2309                 (OPJ_UINT32)subsampling_dx + 1;
2310     image->y1 = (OPJ_UINT32)parameters->image_offset_y0 + (OPJ_UINT32)(h - 1) *
2311                 (OPJ_UINT32)subsampling_dy + 1;
2312
2313     if (raw_cp->rawBitDepth <= 8) {
2314         unsigned char value = 0;
2315         for (compno = 0; compno < numcomps; compno++) {
2316             int nloop = (w * h) / (raw_cp->rawComps[compno].dx *
2317                                    raw_cp->rawComps[compno].dy);
2318             for (i = 0; i < nloop; i++) {
2319                 if (!fread(&value, 1, 1, f)) {
2320                     fprintf(stderr, "Error reading raw file. End of file probably reached.\n");
2321                     opj_image_destroy(image);
2322                     fclose(f);
2323                     return NULL;
2324                 }
2325                 image->comps[compno].data[i] = raw_cp->rawSigned ? (char)value : value;
2326             }
2327         }
2328     } else if (raw_cp->rawBitDepth <= 16) {
2329         unsigned short value;
2330         for (compno = 0; compno < numcomps; compno++) {
2331             int nloop = (w * h) / (raw_cp->rawComps[compno].dx *
2332                                    raw_cp->rawComps[compno].dy);
2333             for (i = 0; i < nloop; i++) {
2334                 unsigned char temp1;
2335                 unsigned char temp2;
2336                 if (!fread(&temp1, 1, 1, f)) {
2337                     fprintf(stderr, "Error reading raw file. End of file probably reached.\n");
2338                     opj_image_destroy(image);
2339                     fclose(f);
2340                     return NULL;
2341                 }
2342                 if (!fread(&temp2, 1, 1, f)) {
2343                     fprintf(stderr, "Error reading raw file. End of file probably reached.\n");
2344                     opj_image_destroy(image);
2345                     fclose(f);
2346                     return NULL;
2347                 }
2348                 if (big_endian) {
2349                     value = (unsigned short)((temp1 << 8) + temp2);
2350                 } else {
2351                     value = (unsigned short)((temp2 << 8) + temp1);
2352                 }
2353                 image->comps[compno].data[i] = raw_cp->rawSigned ? (short)value : value;
2354             }
2355         }
2356     } else {
2357         fprintf(stderr,
2358                 "OpenJPEG cannot encode raw components with bit depth higher than 16 bits.\n");
2359         opj_image_destroy(image);
2360         fclose(f);
2361         return NULL;
2362     }
2363
2364     if (fread(&ch, 1, 1, f)) {
2365         fprintf(stderr, "Warning. End of raw file not reached... processing anyway\n");
2366     }
2367     fclose(f);
2368
2369     return image;
2370 }
2371
2372 opj_image_t* rawltoimage(const char *filename, opj_cparameters_t *parameters,
2373                          raw_cparameters_t *raw_cp)
2374 {
2375     return rawtoimage_common(filename, parameters, raw_cp, OPJ_FALSE);
2376 }
2377
2378 opj_image_t* rawtoimage(const char *filename, opj_cparameters_t *parameters,
2379                         raw_cparameters_t *raw_cp)
2380 {
2381     return rawtoimage_common(filename, parameters, raw_cp, OPJ_TRUE);
2382 }
2383
2384 static int imagetoraw_common(opj_image_t * image, const char *outfile,
2385                              OPJ_BOOL big_endian)
2386 {
2387     FILE *rawFile = NULL;
2388     size_t res;
2389     unsigned int compno, numcomps;
2390     int w, h, fails;
2391     int line, row, curr, mask;
2392     int *ptr;
2393     unsigned char uc;
2394     (void)big_endian;
2395
2396     if ((image->numcomps * image->x1 * image->y1) == 0) {
2397         fprintf(stderr, "\nError: invalid raw image parameters\n");
2398         return 1;
2399     }
2400
2401     numcomps = image->numcomps;
2402
2403     if (numcomps > 4) {
2404         numcomps = 4;
2405     }
2406
2407     for (compno = 1; compno < numcomps; ++compno) {
2408         if (image->comps[0].dx != image->comps[compno].dx) {
2409             break;
2410         }
2411         if (image->comps[0].dy != image->comps[compno].dy) {
2412             break;
2413         }
2414         if (image->comps[0].prec != image->comps[compno].prec) {
2415             break;
2416         }
2417         if (image->comps[0].sgnd != image->comps[compno].sgnd) {
2418             break;
2419         }
2420     }
2421     if (compno != numcomps) {
2422         fprintf(stderr,
2423                 "imagetoraw_common: All components shall have the same subsampling, same bit depth, same sign.\n");
2424         fprintf(stderr, "\tAborting\n");
2425         return 1;
2426     }
2427
2428     rawFile = fopen(outfile, "wb");
2429     if (!rawFile) {
2430         fprintf(stderr, "Failed to open %s for writing !!\n", outfile);
2431         return 1;
2432     }
2433
2434     fails = 1;
2435     fprintf(stdout, "Raw image characteristics: %d components\n", image->numcomps);
2436
2437     for (compno = 0; compno < image->numcomps; compno++) {
2438         fprintf(stdout, "Component %u characteristics: %dx%dx%d %s\n", compno,
2439                 image->comps[compno].w,
2440                 image->comps[compno].h, image->comps[compno].prec,
2441                 image->comps[compno].sgnd == 1 ? "signed" : "unsigned");
2442
2443         w = (int)image->comps[compno].w;
2444         h = (int)image->comps[compno].h;
2445
2446         if (image->comps[compno].prec <= 8) {
2447             if (image->comps[compno].sgnd == 1) {
2448                 mask = (1 << image->comps[compno].prec) - 1;
2449                 ptr = image->comps[compno].data;
2450                 for (line = 0; line < h; line++) {
2451                     for (row = 0; row < w; row++)    {
2452                         curr = *ptr;
2453                         if (curr > 127) {
2454                             curr = 127;
2455                         } else if (curr < -128) {
2456                             curr = -128;
2457                         }
2458                         uc = (unsigned char)(curr & mask);
2459                         res = fwrite(&uc, 1, 1, rawFile);
2460                         if (res < 1) {
2461                             fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
2462                             goto fin;
2463                         }
2464                         ptr++;
2465                     }
2466                 }
2467             } else if (image->comps[compno].sgnd == 0) {
2468                 mask = (1 << image->comps[compno].prec) - 1;
2469                 ptr = image->comps[compno].data;
2470                 for (line = 0; line < h; line++) {
2471                     for (row = 0; row < w; row++)    {
2472                         curr = *ptr;
2473                         if (curr > 255) {
2474                             curr = 255;
2475                         } else if (curr < 0) {
2476                             curr = 0;
2477                         }
2478                         uc = (unsigned char)(curr & mask);
2479                         res = fwrite(&uc, 1, 1, rawFile);
2480                         if (res < 1) {
2481                             fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
2482                             goto fin;
2483                         }
2484                         ptr++;
2485                     }
2486                 }
2487             }
2488         } else if (image->comps[compno].prec <= 16) {
2489             if (image->comps[compno].sgnd == 1) {
2490                 union {
2491                     signed short val;
2492                     signed char vals[2];
2493                 } uc16;
2494                 mask = (1 << image->comps[compno].prec) - 1;
2495                 ptr = image->comps[compno].data;
2496                 for (line = 0; line < h; line++) {
2497                     for (row = 0; row < w; row++)    {
2498                         curr = *ptr;
2499                         if (curr > 32767) {
2500                             curr = 32767;
2501                         } else if (curr < -32768) {
2502                             curr = -32768;
2503                         }
2504                         uc16.val = (signed short)(curr & mask);
2505                         res = fwrite(uc16.vals, 1, 2, rawFile);
2506                         if (res < 2) {
2507                             fprintf(stderr, "failed to write 2 byte for %s\n", outfile);
2508                             goto fin;
2509                         }
2510                         ptr++;
2511                     }
2512                 }
2513             } else if (image->comps[compno].sgnd == 0) {
2514                 union {
2515                     unsigned short val;
2516                     unsigned char vals[2];
2517                 } uc16;
2518                 mask = (1 << image->comps[compno].prec) - 1;
2519                 ptr = image->comps[compno].data;
2520                 for (line = 0; line < h; line++) {
2521                     for (row = 0; row < w; row++)    {
2522                         curr = *ptr;
2523                         if (curr > 65535) {
2524                             curr = 65535;
2525                         } else if (curr < 0) {
2526                             curr = 0;
2527                         }
2528                         uc16.val = (unsigned short)(curr & mask);
2529                         res = fwrite(uc16.vals, 1, 2, rawFile);
2530                         if (res < 2) {
2531                             fprintf(stderr, "failed to write 2 byte for %s\n", outfile);
2532                             goto fin;
2533                         }
2534                         ptr++;
2535                     }
2536                 }
2537             }
2538         } else if (image->comps[compno].prec <= 32) {
2539             fprintf(stderr, "More than 16 bits per component not handled yet\n");
2540             goto fin;
2541         } else {
2542             fprintf(stderr, "Error: invalid precision: %d\n", image->comps[compno].prec);
2543             goto fin;
2544         }
2545     }
2546     fails = 0;
2547 fin:
2548     fclose(rawFile);
2549     return fails;
2550 }
2551
2552 int imagetoraw(opj_image_t * image, const char *outfile)
2553 {
2554     return imagetoraw_common(image, outfile, OPJ_TRUE);
2555 }
2556
2557 int imagetorawl(opj_image_t * image, const char *outfile)
2558 {
2559     return imagetoraw_common(image, outfile, OPJ_FALSE);
2560 }
2561