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         if (nbytes == 1) {
1416             unsigned char* line_buffer = malloc((size_t)w);
1417             if (line_buffer == NULL) {
1418                 fprintf(stderr, "Out of memory");
1419                 goto fin;
1420             }
1421             for (j = 0; j < h; j++) {
1422                 if (comp->prec == 8 && comp->sgnd == 0) {
1423                     for (i = 0; i < w; i++) {
1424                         line_buffer[i] = (unsigned char)CLAMP(image->comps[compno].data[j * w + i], 0,
1425                                                               255);
1426                     }
1427                 } else {
1428                     for (i = 0; i < w; i++) {
1429                         line_buffer[i] = (unsigned char)
1430                                          clamp(image->comps[compno].data[j * w + i],
1431                                                (int)comp->prec, (int)comp->sgnd);
1432                     }
1433                 }
1434                 res = fwrite(line_buffer, 1, (size_t)w, fdest);
1435                 if (res != (size_t)w) {
1436                     fprintf(stderr, "failed to write %d bytes for %s\n", w, name);
1437                     if (total > 256) {
1438                         free(name);
1439                     }
1440                     free(line_buffer);
1441                     goto fin;
1442                 }
1443             }
1444             free(line_buffer);
1445         } else {
1446
1447             for (i = 0; i < w * h; i++) {
1448                 /* FIXME: clamp func is being called within a loop */
1449                 const int val = clamp(image->comps[compno].data[i],
1450                                       (int)comp->prec, (int)comp->sgnd);
1451
1452                 for (j = nbytes - 1; j >= 0; j--) {
1453                     int v = (int)(val >> (j * 8));
1454                     unsigned char byte = (unsigned char)v;
1455                     res = fwrite(&byte, 1, 1, fdest);
1456
1457                     if (res < 1) {
1458                         fprintf(stderr, "failed to write 1 byte for %s\n", name);
1459                         if (total > 256) {
1460                             free(name);
1461                         }
1462                         goto fin;
1463                     }
1464                 }
1465             }
1466         }
1467
1468         if (total > 256) {
1469             free(name);
1470         }
1471         fclose(fdest);
1472         fdest = NULL;
1473     }
1474     fails = 0;
1475 fin:
1476     if (fdest) {
1477         fclose(fdest);
1478     }
1479
1480     return fails;
1481 }
1482
1483 /* -->> -->> -->> -->>
1484
1485 PNM IMAGE FORMAT
1486
1487 <<-- <<-- <<-- <<-- */
1488
1489 struct pnm_header {
1490     int width, height, maxval, depth, format;
1491     char rgb, rgba, gray, graya, bw;
1492     char ok;
1493 };
1494
1495 static char *skip_white(char *s)
1496 {
1497     if (s != NULL) {
1498         while (*s) {
1499             if (*s == '\n' || *s == '\r') {
1500                 return NULL;
1501             }
1502             if (isspace(*s)) {
1503                 ++s;
1504                 continue;
1505             }
1506             return s;
1507         }
1508     }
1509     return NULL;
1510 }
1511
1512 static char *skip_int(char *start, int *out_n)
1513 {
1514     char *s;
1515     char c;
1516
1517     *out_n = 0;
1518
1519     s = skip_white(start);
1520     if (s == NULL) {
1521         return NULL;
1522     }
1523     start = s;
1524
1525     while (*s) {
1526         if (!isdigit(*s)) {
1527             break;
1528         }
1529         ++s;
1530     }
1531     c = *s;
1532     *s = 0;
1533     *out_n = atoi(start);
1534     *s = c;
1535     return s;
1536 }
1537
1538 static char *skip_idf(char *start, char out_idf[256])
1539 {
1540     char *s;
1541     char c;
1542
1543     s = skip_white(start);
1544     if (s == NULL) {
1545         return NULL;
1546     }
1547     start = s;
1548
1549     while (*s) {
1550         if (isalpha(*s) || *s == '_') {
1551             ++s;
1552             continue;
1553         }
1554         break;
1555     }
1556     c = *s;
1557     *s = 0;
1558     strncpy(out_idf, start, 255);
1559     *s = c;
1560     return s;
1561 }
1562
1563 static void read_pnm_header(FILE *reader, struct pnm_header *ph)
1564 {
1565     int format, end, ttype;
1566     char idf[256], type[256];
1567     char line[256];
1568
1569     if (fgets(line, 250, reader) == NULL) {
1570         fprintf(stderr, "\nWARNING: fgets return a NULL value");
1571         return;
1572     }
1573
1574     if (line[0] != 'P') {
1575         fprintf(stderr, "read_pnm_header:PNM:magic P missing\n");
1576         return;
1577     }
1578     format = atoi(line + 1);
1579     if (format < 1 || format > 7) {
1580         fprintf(stderr, "read_pnm_header:magic format %d invalid\n", format);
1581         return;
1582     }
1583     ph->format = format;
1584     ttype = end = 0;
1585
1586     while (fgets(line, 250, reader)) {
1587         char *s;
1588         int allow_null = 0;
1589
1590         if (*line == '#') {
1591             continue;
1592         }
1593
1594         s = line;
1595
1596         if (format == 7) {
1597             s = skip_idf(s, idf);
1598
1599             if (s == NULL || *s == 0) {
1600                 return;
1601             }
1602
1603             if (strcmp(idf, "ENDHDR") == 0) {
1604                 end = 1;
1605                 break;
1606             }
1607             if (strcmp(idf, "WIDTH") == 0) {
1608                 s = skip_int(s, &ph->width);
1609                 if (s == NULL || *s == 0) {
1610                     return;
1611                 }
1612
1613                 continue;
1614             }
1615             if (strcmp(idf, "HEIGHT") == 0) {
1616                 s = skip_int(s, &ph->height);
1617                 if (s == NULL || *s == 0) {
1618                     return;
1619                 }
1620
1621                 continue;
1622             }
1623             if (strcmp(idf, "DEPTH") == 0) {
1624                 s = skip_int(s, &ph->depth);
1625                 if (s == NULL || *s == 0) {
1626                     return;
1627                 }
1628
1629                 continue;
1630             }
1631             if (strcmp(idf, "MAXVAL") == 0) {
1632                 s = skip_int(s, &ph->maxval);
1633                 if (s == NULL || *s == 0) {
1634                     return;
1635                 }
1636
1637                 continue;
1638             }
1639             if (strcmp(idf, "TUPLTYPE") == 0) {
1640                 s = skip_idf(s, type);
1641                 if (s == NULL || *s == 0) {
1642                     return;
1643                 }
1644
1645                 if (strcmp(type, "BLACKANDWHITE") == 0) {
1646                     ph->bw = 1;
1647                     ttype = 1;
1648                     continue;
1649                 }
1650                 if (strcmp(type, "GRAYSCALE") == 0) {
1651                     ph->gray = 1;
1652                     ttype = 1;
1653                     continue;
1654                 }
1655                 if (strcmp(type, "GRAYSCALE_ALPHA") == 0) {
1656                     ph->graya = 1;
1657                     ttype = 1;
1658                     continue;
1659                 }
1660                 if (strcmp(type, "RGB") == 0) {
1661                     ph->rgb = 1;
1662                     ttype = 1;
1663                     continue;
1664                 }
1665                 if (strcmp(type, "RGB_ALPHA") == 0) {
1666                     ph->rgba = 1;
1667                     ttype = 1;
1668                     continue;
1669                 }
1670                 fprintf(stderr, "read_pnm_header:unknown P7 TUPLTYPE %s\n", type);
1671                 return;
1672             }
1673             fprintf(stderr, "read_pnm_header:unknown P7 idf %s\n", idf);
1674             return;
1675         } /* if(format == 7) */
1676
1677         /* Here format is in range [1,6] */
1678         if (ph->width == 0) {
1679             s = skip_int(s, &ph->width);
1680             if ((s == NULL) || (*s == 0) || (ph->width < 1)) {
1681                 return;
1682             }
1683             allow_null = 1;
1684         }
1685         if (ph->height == 0) {
1686             s = skip_int(s, &ph->height);
1687             if ((s == NULL) && allow_null) {
1688                 continue;
1689             }
1690             if ((s == NULL) || (*s == 0) || (ph->height < 1)) {
1691                 return;
1692             }
1693             if (format == 1 || format == 4) {
1694                 break;
1695             }
1696             allow_null = 1;
1697         }
1698         /* here, format is in P2, P3, P5, P6 */
1699         s = skip_int(s, &ph->maxval);
1700         if ((s == NULL) && allow_null) {
1701             continue;
1702         }
1703         if ((s == NULL) || (*s == 0)) {
1704             return;
1705         }
1706         break;
1707     }/* while(fgets( ) */
1708     if (format == 2 || format == 3 || format > 4) {
1709         if (ph->maxval < 1 || ph->maxval > 65535) {
1710             return;
1711         }
1712     }
1713     if (ph->width < 1 || ph->height < 1) {
1714         return;
1715     }
1716
1717     if (format == 7) {
1718         if (!end) {
1719             fprintf(stderr, "read_pnm_header:P7 without ENDHDR\n");
1720             return;
1721         }
1722         if (ph->depth < 1 || ph->depth > 4) {
1723             return;
1724         }
1725
1726         if (ttype) {
1727             ph->ok = 1;
1728         }
1729     } else {
1730         ph->ok = 1;
1731         if (format == 1 || format == 4) {
1732             ph->maxval = 255;
1733         }
1734     }
1735 }
1736
1737 static int has_prec(int val)
1738 {
1739     if (val < 2) {
1740         return 1;
1741     }
1742     if (val < 4) {
1743         return 2;
1744     }
1745     if (val < 8) {
1746         return 3;
1747     }
1748     if (val < 16) {
1749         return 4;
1750     }
1751     if (val < 32) {
1752         return 5;
1753     }
1754     if (val < 64) {
1755         return 6;
1756     }
1757     if (val < 128) {
1758         return 7;
1759     }
1760     if (val < 256) {
1761         return 8;
1762     }
1763     if (val < 512) {
1764         return 9;
1765     }
1766     if (val < 1024) {
1767         return 10;
1768     }
1769     if (val < 2048) {
1770         return 11;
1771     }
1772     if (val < 4096) {
1773         return 12;
1774     }
1775     if (val < 8192) {
1776         return 13;
1777     }
1778     if (val < 16384) {
1779         return 14;
1780     }
1781     if (val < 32768) {
1782         return 15;
1783     }
1784     return 16;
1785 }
1786
1787 opj_image_t* pnmtoimage(const char *filename, opj_cparameters_t *parameters)
1788 {
1789     int subsampling_dx = parameters->subsampling_dx;
1790     int subsampling_dy = parameters->subsampling_dy;
1791
1792     FILE *fp = NULL;
1793     int i, compno, numcomps, w, h, prec, format;
1794     OPJ_COLOR_SPACE color_space;
1795     opj_image_cmptparm_t cmptparm[4]; /* RGBA: max. 4 components */
1796     opj_image_t * image = NULL;
1797     struct pnm_header header_info;
1798
1799     if ((fp = fopen(filename, "rb")) == NULL) {
1800         fprintf(stderr, "pnmtoimage:Failed to open %s for reading!\n", filename);
1801         return NULL;
1802     }
1803     memset(&header_info, 0, sizeof(struct pnm_header));
1804
1805     read_pnm_header(fp, &header_info);
1806
1807     if (!header_info.ok) {
1808         fclose(fp);
1809         return NULL;
1810     }
1811
1812     /* This limitation could be removed by making sure to use size_t below */
1813     if (header_info.height != 0 &&
1814             header_info.width > INT_MAX / header_info.height) {
1815         fprintf(stderr, "pnmtoimage:Image %dx%d too big!\n",
1816                 header_info.width, header_info.height);
1817         fclose(fp);
1818         return NULL;
1819     }
1820
1821     format = header_info.format;
1822
1823     switch (format) {
1824     case 1: /* ascii bitmap */
1825     case 4: /* raw bitmap */
1826         numcomps = 1;
1827         break;
1828
1829     case 2: /* ascii greymap */
1830     case 5: /* raw greymap */
1831         numcomps = 1;
1832         break;
1833
1834     case 3: /* ascii pixmap */
1835     case 6: /* raw pixmap */
1836         numcomps = 3;
1837         break;
1838
1839     case 7: /* arbitrary map */
1840         numcomps = header_info.depth;
1841         break;
1842
1843     default:
1844         fclose(fp);
1845         return NULL;
1846     }
1847     if (numcomps < 3) {
1848         color_space = OPJ_CLRSPC_GRAY;    /* GRAY, GRAYA */
1849     } else {
1850         color_space = OPJ_CLRSPC_SRGB;    /* RGB, RGBA */
1851     }
1852
1853     prec = has_prec(header_info.maxval);
1854
1855     if (prec < 8) {
1856         prec = 8;
1857     }
1858
1859     w = header_info.width;
1860     h = header_info.height;
1861     subsampling_dx = parameters->subsampling_dx;
1862     subsampling_dy = parameters->subsampling_dy;
1863
1864     memset(&cmptparm[0], 0, (size_t)numcomps * sizeof(opj_image_cmptparm_t));
1865
1866     for (i = 0; i < numcomps; i++) {
1867         cmptparm[i].prec = (OPJ_UINT32)prec;
1868         cmptparm[i].bpp = (OPJ_UINT32)prec;
1869         cmptparm[i].sgnd = 0;
1870         cmptparm[i].dx = (OPJ_UINT32)subsampling_dx;
1871         cmptparm[i].dy = (OPJ_UINT32)subsampling_dy;
1872         cmptparm[i].w = (OPJ_UINT32)w;
1873         cmptparm[i].h = (OPJ_UINT32)h;
1874     }
1875     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
1876
1877     if (!image) {
1878         fclose(fp);
1879         return NULL;
1880     }
1881
1882     /* set image offset and reference grid */
1883     image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
1884     image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
1885     image->x1 = (OPJ_UINT32)(parameters->image_offset_x0 + (w - 1) * subsampling_dx
1886                              + 1);
1887     image->y1 = (OPJ_UINT32)(parameters->image_offset_y0 + (h - 1) * subsampling_dy
1888                              + 1);
1889
1890     if ((format == 2) || (format == 3)) { /* ascii pixmap */
1891         unsigned int index;
1892
1893         for (i = 0; i < w * h; i++) {
1894             for (compno = 0; compno < numcomps; compno++) {
1895                 index = 0;
1896                 if (fscanf(fp, "%u", &index) != 1) {
1897                     fprintf(stderr,
1898                             "\nWARNING: fscanf return a number of element different from the expected.\n");
1899                 }
1900
1901                 image->comps[compno].data[i] = (OPJ_INT32)(index * 255) / header_info.maxval;
1902             }
1903         }
1904     } else if ((format == 5)
1905                || (format == 6)
1906                || ((format == 7)
1907                    && (header_info.gray || header_info.graya
1908                        || header_info.rgb || header_info.rgba))) { /* binary pixmap */
1909         unsigned char c0, c1, one;
1910
1911         one = (prec < 9);
1912
1913         for (i = 0; i < w * h; i++) {
1914             for (compno = 0; compno < numcomps; compno++) {
1915                 if (!fread(&c0, 1, 1, fp)) {
1916                     fprintf(stderr,
1917                             "\nError: fread return a number of element different from the expected.\n");
1918                     opj_image_destroy(image);
1919                     fclose(fp);
1920                     return NULL;
1921                 }
1922                 if (one) {
1923                     image->comps[compno].data[i] = c0;
1924                 } else {
1925                     if (!fread(&c1, 1, 1, fp)) {
1926                         fprintf(stderr,
1927                                 "\nError: fread return a number of element different from the expected.\n");
1928                     }
1929                     /* netpbm: */
1930                     image->comps[compno].data[i] = ((c0 << 8) | c1);
1931                 }
1932             }
1933         }
1934     } else if (format == 1) { /* ascii bitmap */
1935         for (i = 0; i < w * h; i++) {
1936             unsigned int index;
1937
1938             if (fscanf(fp, "%u", &index) != 1) {
1939                 fprintf(stderr,
1940                         "\nWARNING: fscanf return a number of element different from the expected.\n");
1941             }
1942
1943             image->comps[0].data[i] = (index ? 0 : 255);
1944         }
1945     } else if (format == 4) {
1946         int x, y, bit;
1947         unsigned char uc;
1948
1949         i = 0;
1950         for (y = 0; y < h; ++y) {
1951             bit = -1;
1952             uc = 0;
1953
1954             for (x = 0; x < w; ++x) {
1955                 if (bit == -1) {
1956                     bit = 7;
1957                     uc = (unsigned char)getc(fp);
1958                 }
1959                 image->comps[0].data[i] = (((uc >> bit) & 1) ? 0 : 255);
1960                 --bit;
1961                 ++i;
1962             }
1963         }
1964     } else if ((format == 7 && header_info.bw)) { /*MONO*/
1965         unsigned char uc;
1966
1967         for (i = 0; i < w * h; ++i) {
1968             if (!fread(&uc, 1, 1, fp)) {
1969                 fprintf(stderr,
1970                         "\nError: fread return a number of element different from the expected.\n");
1971             }
1972             image->comps[0].data[i] = (uc & 1) ? 0 : 255;
1973         }
1974     }
1975     fclose(fp);
1976
1977     return image;
1978 }/* pnmtoimage() */
1979
1980 static int are_comps_similar(opj_image_t * image)
1981 {
1982     unsigned int i;
1983     for (i = 1; i < image->numcomps; i++) {
1984         if (image->comps[0].dx != image->comps[i].dx ||
1985                 image->comps[0].dy != image->comps[i].dy ||
1986                 (i <= 2 &&
1987                  (image->comps[0].prec != image->comps[i].prec ||
1988                   image->comps[0].sgnd != image->comps[i].sgnd))) {
1989             return OPJ_FALSE;
1990         }
1991     }
1992     return OPJ_TRUE;
1993 }
1994
1995
1996 int imagetopnm(opj_image_t * image, const char *outfile, int force_split)
1997 {
1998     int *red, *green, *blue, *alpha;
1999     int wr, hr, max;
2000     int i;
2001     unsigned int compno, ncomp;
2002     int adjustR, adjustG, adjustB, adjustA;
2003     int fails, two, want_gray, has_alpha, triple;
2004     int prec, v;
2005     FILE *fdest = NULL;
2006     const char *tmp = outfile;
2007     char *destname;
2008
2009     alpha = NULL;
2010
2011     if ((prec = (int)image->comps[0].prec) > 16) {
2012         fprintf(stderr, "%s:%d:imagetopnm\n\tprecision %d is larger than 16"
2013                 "\n\t: refused.\n", __FILE__, __LINE__, prec);
2014         return 1;
2015     }
2016     two = has_alpha = 0;
2017     fails = 1;
2018     ncomp = image->numcomps;
2019
2020     while (*tmp) {
2021         ++tmp;
2022     }
2023     tmp -= 2;
2024     want_gray = (*tmp == 'g' || *tmp == 'G');
2025     ncomp = image->numcomps;
2026
2027     if (want_gray) {
2028         ncomp = 1;
2029     }
2030
2031     if ((force_split == 0) && ncomp >= 2 &&
2032             are_comps_similar(image)) {
2033         fdest = fopen(outfile, "wb");
2034
2035         if (!fdest) {
2036             fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
2037             return fails;
2038         }
2039         two = (prec > 8);
2040         triple = (ncomp > 2);
2041         wr = (int)image->comps[0].w;
2042         hr = (int)image->comps[0].h;
2043         max = (1 << prec) - 1;
2044         has_alpha = (ncomp == 4 || ncomp == 2);
2045
2046         red = image->comps[0].data;
2047
2048         if (triple) {
2049             green = image->comps[1].data;
2050             blue = image->comps[2].data;
2051         } else {
2052             green = blue = NULL;
2053         }
2054
2055         if (has_alpha) {
2056             const char *tt = (triple ? "RGB_ALPHA" : "GRAYSCALE_ALPHA");
2057
2058             fprintf(fdest, "P7\n# OpenJPEG-%s\nWIDTH %d\nHEIGHT %d\nDEPTH %u\n"
2059                     "MAXVAL %d\nTUPLTYPE %s\nENDHDR\n", opj_version(),
2060                     wr, hr, ncomp, max, tt);
2061             alpha = image->comps[ncomp - 1].data;
2062             adjustA = (image->comps[ncomp - 1].sgnd ?
2063                        1 << (image->comps[ncomp - 1].prec - 1) : 0);
2064         } else {
2065             fprintf(fdest, "P6\n# OpenJPEG-%s\n%d %d\n%d\n",
2066                     opj_version(), wr, hr, max);
2067             adjustA = 0;
2068         }
2069         adjustR = (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
2070
2071         if (triple) {
2072             adjustG = (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
2073             adjustB = (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
2074         } else {
2075             adjustG = adjustB = 0;
2076         }
2077
2078         for (i = 0; i < wr * hr; ++i) {
2079             if (two) {
2080                 v = *red + adjustR;
2081                 ++red;
2082                 if (v > 65535) {
2083                     v = 65535;
2084                 } else if (v < 0) {
2085                     v = 0;
2086                 }
2087
2088                 /* netpbm: */
2089                 fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2090
2091                 if (triple) {
2092                     v = *green + adjustG;
2093                     ++green;
2094                     if (v > 65535) {
2095                         v = 65535;
2096                     } else if (v < 0) {
2097                         v = 0;
2098                     }
2099
2100                     /* netpbm: */
2101                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2102
2103                     v =  *blue + adjustB;
2104                     ++blue;
2105                     if (v > 65535) {
2106                         v = 65535;
2107                     } else if (v < 0) {
2108                         v = 0;
2109                     }
2110
2111                     /* netpbm: */
2112                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2113
2114                 }/* if(triple) */
2115
2116                 if (has_alpha) {
2117                     v = *alpha + adjustA;
2118                     ++alpha;
2119                     if (v > 65535) {
2120                         v = 65535;
2121                     } else if (v < 0) {
2122                         v = 0;
2123                     }
2124
2125                     /* netpbm: */
2126                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2127                 }
2128                 continue;
2129
2130             }   /* if(two) */
2131
2132             /* prec <= 8: */
2133             v = *red++;
2134             if (v > 255) {
2135                 v = 255;
2136             } else if (v < 0) {
2137                 v = 0;
2138             }
2139
2140             fprintf(fdest, "%c", (unsigned char)v);
2141             if (triple) {
2142                 v = *green++;
2143                 if (v > 255) {
2144                     v = 255;
2145                 } else if (v < 0) {
2146                     v = 0;
2147                 }
2148
2149                 fprintf(fdest, "%c", (unsigned char)v);
2150                 v = *blue++;
2151                 if (v > 255) {
2152                     v = 255;
2153                 } else if (v < 0) {
2154                     v = 0;
2155                 }
2156
2157                 fprintf(fdest, "%c", (unsigned char)v);
2158             }
2159             if (has_alpha) {
2160                 v = *alpha++;
2161                 if (v > 255) {
2162                     v = 255;
2163                 } else if (v < 0) {
2164                     v = 0;
2165                 }
2166
2167                 fprintf(fdest, "%c", (unsigned char)v);
2168             }
2169         }   /* for(i */
2170
2171         fclose(fdest);
2172         return 0;
2173     }
2174
2175     /* YUV or MONO: */
2176
2177     if (image->numcomps > ncomp) {
2178         fprintf(stderr, "WARNING -> [PGM file] Only the first component\n");
2179         fprintf(stderr, "           is written to the file\n");
2180     }
2181     destname = (char*)malloc(strlen(outfile) + 8);
2182     if (destname == NULL) {
2183         fprintf(stderr, "imagetopnm: memory out\n");
2184         return 1;
2185     }
2186     for (compno = 0; compno < ncomp; compno++) {
2187         if (ncomp > 1) {
2188             /*sprintf(destname, "%d.%s", compno, outfile);*/
2189             const size_t olen = strlen(outfile);
2190             const size_t dotpos = olen - 4;
2191
2192             strncpy(destname, outfile, dotpos);
2193             sprintf(destname + dotpos, "_%u.pgm", compno);
2194         } else {
2195             sprintf(destname, "%s", outfile);
2196         }
2197
2198         fdest = fopen(destname, "wb");
2199         if (!fdest) {
2200             fprintf(stderr, "ERROR -> failed to open %s for writing\n", destname);
2201             free(destname);
2202             return 1;
2203         }
2204         wr = (int)image->comps[compno].w;
2205         hr = (int)image->comps[compno].h;
2206         prec = (int)image->comps[compno].prec;
2207         max = (1 << prec) - 1;
2208
2209         fprintf(fdest, "P5\n#OpenJPEG-%s\n%d %d\n%d\n",
2210                 opj_version(), wr, hr, max);
2211
2212         red = image->comps[compno].data;
2213         adjustR =
2214             (image->comps[compno].sgnd ? 1 << (image->comps[compno].prec - 1) : 0);
2215
2216         if (prec > 8) {
2217             for (i = 0; i < wr * hr; i++) {
2218                 v = *red + adjustR;
2219                 ++red;
2220                 if (v > 65535) {
2221                     v = 65535;
2222                 } else if (v < 0) {
2223                     v = 0;
2224                 }
2225
2226                 /* netpbm: */
2227                 fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2228
2229                 if (has_alpha) {
2230                     v = *alpha++;
2231                     if (v > 65535) {
2232                         v = 65535;
2233                     } else if (v < 0) {
2234                         v = 0;
2235                     }
2236
2237                     /* netpbm: */
2238                     fprintf(fdest, "%c%c", (unsigned char)(v >> 8), (unsigned char)v);
2239                 }
2240             }/* for(i */
2241         } else { /* prec <= 8 */
2242             for (i = 0; i < wr * hr; ++i) {
2243                 v = *red + adjustR;
2244                 ++red;
2245                 if (v > 255) {
2246                     v = 255;
2247                 } else if (v < 0) {
2248                     v = 0;
2249                 }
2250
2251                 fprintf(fdest, "%c", (unsigned char)v);
2252             }
2253         }
2254         fclose(fdest);
2255     } /* for (compno */
2256     free(destname);
2257
2258     return 0;
2259 }/* imagetopnm() */
2260
2261 /* -->> -->> -->> -->>
2262
2263     RAW IMAGE FORMAT
2264
2265  <<-- <<-- <<-- <<-- */
2266 static opj_image_t* rawtoimage_common(const char *filename,
2267                                       opj_cparameters_t *parameters, raw_cparameters_t *raw_cp, OPJ_BOOL big_endian)
2268 {
2269     int subsampling_dx = parameters->subsampling_dx;
2270     int subsampling_dy = parameters->subsampling_dy;
2271
2272     FILE *f = NULL;
2273     int i, compno, numcomps, w, h;
2274     OPJ_COLOR_SPACE color_space;
2275     opj_image_cmptparm_t *cmptparm;
2276     opj_image_t * image = NULL;
2277     unsigned short ch;
2278
2279     if ((!(raw_cp->rawWidth & raw_cp->rawHeight & raw_cp->rawComp &
2280             raw_cp->rawBitDepth)) == 0) {
2281         fprintf(stderr, "\nError: invalid raw image parameters\n");
2282         fprintf(stderr, "Please use the Format option -F:\n");
2283         fprintf(stderr,
2284                 "-F <width>,<height>,<ncomp>,<bitdepth>,{s,u}@<dx1>x<dy1>:...:<dxn>x<dyn>\n");
2285         fprintf(stderr,
2286                 "If subsampling is omitted, 1x1 is assumed for all components\n");
2287         fprintf(stderr,
2288                 "Example: -i image.raw -o image.j2k -F 512,512,3,8,u@1x1:2x2:2x2\n");
2289         fprintf(stderr, "         for raw 512x512 image with 4:2:0 subsampling\n");
2290         fprintf(stderr, "Aborting.\n");
2291         return NULL;
2292     }
2293
2294     f = fopen(filename, "rb");
2295     if (!f) {
2296         fprintf(stderr, "Failed to open %s for reading !!\n", filename);
2297         fprintf(stderr, "Aborting\n");
2298         return NULL;
2299     }
2300     numcomps = raw_cp->rawComp;
2301
2302     /* FIXME ADE at this point, tcp_mct has not been properly set in calling function */
2303     if (numcomps == 1) {
2304         color_space = OPJ_CLRSPC_GRAY;
2305     } else if ((numcomps >= 3) && (parameters->tcp_mct == 0)) {
2306         color_space = OPJ_CLRSPC_SYCC;
2307     } else if ((numcomps >= 3) && (parameters->tcp_mct != 2)) {
2308         color_space = OPJ_CLRSPC_SRGB;
2309     } else {
2310         color_space = OPJ_CLRSPC_UNKNOWN;
2311     }
2312     w = raw_cp->rawWidth;
2313     h = raw_cp->rawHeight;
2314     cmptparm = (opj_image_cmptparm_t*) calloc((OPJ_UINT32)numcomps,
2315                sizeof(opj_image_cmptparm_t));
2316     if (!cmptparm) {
2317         fprintf(stderr, "Failed to allocate image components parameters !!\n");
2318         fprintf(stderr, "Aborting\n");
2319         fclose(f);
2320         return NULL;
2321     }
2322     /* initialize image components */
2323     for (i = 0; i < numcomps; i++) {
2324         cmptparm[i].prec = (OPJ_UINT32)raw_cp->rawBitDepth;
2325         cmptparm[i].bpp = (OPJ_UINT32)raw_cp->rawBitDepth;
2326         cmptparm[i].sgnd = (OPJ_UINT32)raw_cp->rawSigned;
2327         cmptparm[i].dx = (OPJ_UINT32)(subsampling_dx * raw_cp->rawComps[i].dx);
2328         cmptparm[i].dy = (OPJ_UINT32)(subsampling_dy * raw_cp->rawComps[i].dy);
2329         cmptparm[i].w = (OPJ_UINT32)w;
2330         cmptparm[i].h = (OPJ_UINT32)h;
2331     }
2332     /* create the image */
2333     image = opj_image_create((OPJ_UINT32)numcomps, &cmptparm[0], color_space);
2334     free(cmptparm);
2335     if (!image) {
2336         fclose(f);
2337         return NULL;
2338     }
2339     /* set image offset and reference grid */
2340     image->x0 = (OPJ_UINT32)parameters->image_offset_x0;
2341     image->y0 = (OPJ_UINT32)parameters->image_offset_y0;
2342     image->x1 = (OPJ_UINT32)parameters->image_offset_x0 + (OPJ_UINT32)(w - 1) *
2343                 (OPJ_UINT32)subsampling_dx + 1;
2344     image->y1 = (OPJ_UINT32)parameters->image_offset_y0 + (OPJ_UINT32)(h - 1) *
2345                 (OPJ_UINT32)subsampling_dy + 1;
2346
2347     if (raw_cp->rawBitDepth <= 8) {
2348         unsigned char value = 0;
2349         for (compno = 0; compno < numcomps; compno++) {
2350             int nloop = (w * h) / (raw_cp->rawComps[compno].dx *
2351                                    raw_cp->rawComps[compno].dy);
2352             for (i = 0; i < nloop; i++) {
2353                 if (!fread(&value, 1, 1, f)) {
2354                     fprintf(stderr, "Error reading raw file. End of file probably reached.\n");
2355                     opj_image_destroy(image);
2356                     fclose(f);
2357                     return NULL;
2358                 }
2359                 image->comps[compno].data[i] = raw_cp->rawSigned ? (char)value : value;
2360             }
2361         }
2362     } else if (raw_cp->rawBitDepth <= 16) {
2363         unsigned short value;
2364         for (compno = 0; compno < numcomps; compno++) {
2365             int nloop = (w * h) / (raw_cp->rawComps[compno].dx *
2366                                    raw_cp->rawComps[compno].dy);
2367             for (i = 0; i < nloop; i++) {
2368                 unsigned char temp1;
2369                 unsigned char temp2;
2370                 if (!fread(&temp1, 1, 1, f)) {
2371                     fprintf(stderr, "Error reading raw file. End of file probably reached.\n");
2372                     opj_image_destroy(image);
2373                     fclose(f);
2374                     return NULL;
2375                 }
2376                 if (!fread(&temp2, 1, 1, f)) {
2377                     fprintf(stderr, "Error reading raw file. End of file probably reached.\n");
2378                     opj_image_destroy(image);
2379                     fclose(f);
2380                     return NULL;
2381                 }
2382                 if (big_endian) {
2383                     value = (unsigned short)((temp1 << 8) + temp2);
2384                 } else {
2385                     value = (unsigned short)((temp2 << 8) + temp1);
2386                 }
2387                 image->comps[compno].data[i] = raw_cp->rawSigned ? (short)value : value;
2388             }
2389         }
2390     } else {
2391         fprintf(stderr,
2392                 "OpenJPEG cannot encode raw components with bit depth higher than 16 bits.\n");
2393         opj_image_destroy(image);
2394         fclose(f);
2395         return NULL;
2396     }
2397
2398     if (fread(&ch, 1, 1, f)) {
2399         fprintf(stderr, "Warning. End of raw file not reached... processing anyway\n");
2400     }
2401     fclose(f);
2402
2403     return image;
2404 }
2405
2406 opj_image_t* rawltoimage(const char *filename, opj_cparameters_t *parameters,
2407                          raw_cparameters_t *raw_cp)
2408 {
2409     return rawtoimage_common(filename, parameters, raw_cp, OPJ_FALSE);
2410 }
2411
2412 opj_image_t* rawtoimage(const char *filename, opj_cparameters_t *parameters,
2413                         raw_cparameters_t *raw_cp)
2414 {
2415     return rawtoimage_common(filename, parameters, raw_cp, OPJ_TRUE);
2416 }
2417
2418 static int imagetoraw_common(opj_image_t * image, const char *outfile,
2419                              OPJ_BOOL big_endian)
2420 {
2421     FILE *rawFile = NULL;
2422     size_t res;
2423     unsigned int compno, numcomps;
2424     int w, h, fails;
2425     int line, row, curr, mask;
2426     int *ptr;
2427     unsigned char uc;
2428     (void)big_endian;
2429
2430     if ((image->numcomps * image->x1 * image->y1) == 0) {
2431         fprintf(stderr, "\nError: invalid raw image parameters\n");
2432         return 1;
2433     }
2434
2435     numcomps = image->numcomps;
2436
2437     if (numcomps > 4) {
2438         numcomps = 4;
2439     }
2440
2441     for (compno = 1; compno < numcomps; ++compno) {
2442         if (image->comps[0].dx != image->comps[compno].dx) {
2443             break;
2444         }
2445         if (image->comps[0].dy != image->comps[compno].dy) {
2446             break;
2447         }
2448         if (image->comps[0].prec != image->comps[compno].prec) {
2449             break;
2450         }
2451         if (image->comps[0].sgnd != image->comps[compno].sgnd) {
2452             break;
2453         }
2454     }
2455     if (compno != numcomps) {
2456         fprintf(stderr,
2457                 "imagetoraw_common: All components shall have the same subsampling, same bit depth, same sign.\n");
2458         fprintf(stderr, "\tAborting\n");
2459         return 1;
2460     }
2461
2462     rawFile = fopen(outfile, "wb");
2463     if (!rawFile) {
2464         fprintf(stderr, "Failed to open %s for writing !!\n", outfile);
2465         return 1;
2466     }
2467
2468     fails = 1;
2469     fprintf(stdout, "Raw image characteristics: %d components\n", image->numcomps);
2470
2471     for (compno = 0; compno < image->numcomps; compno++) {
2472         fprintf(stdout, "Component %u characteristics: %dx%dx%d %s\n", compno,
2473                 image->comps[compno].w,
2474                 image->comps[compno].h, image->comps[compno].prec,
2475                 image->comps[compno].sgnd == 1 ? "signed" : "unsigned");
2476
2477         w = (int)image->comps[compno].w;
2478         h = (int)image->comps[compno].h;
2479
2480         if (image->comps[compno].prec <= 8) {
2481             if (image->comps[compno].sgnd == 1) {
2482                 mask = (1 << image->comps[compno].prec) - 1;
2483                 ptr = image->comps[compno].data;
2484                 for (line = 0; line < h; line++) {
2485                     for (row = 0; row < w; row++)    {
2486                         curr = *ptr;
2487                         if (curr > 127) {
2488                             curr = 127;
2489                         } else if (curr < -128) {
2490                             curr = -128;
2491                         }
2492                         uc = (unsigned char)(curr & mask);
2493                         res = fwrite(&uc, 1, 1, rawFile);
2494                         if (res < 1) {
2495                             fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
2496                             goto fin;
2497                         }
2498                         ptr++;
2499                     }
2500                 }
2501             } else if (image->comps[compno].sgnd == 0) {
2502                 mask = (1 << image->comps[compno].prec) - 1;
2503                 ptr = image->comps[compno].data;
2504                 for (line = 0; line < h; line++) {
2505                     for (row = 0; row < w; row++)    {
2506                         curr = *ptr;
2507                         if (curr > 255) {
2508                             curr = 255;
2509                         } else if (curr < 0) {
2510                             curr = 0;
2511                         }
2512                         uc = (unsigned char)(curr & mask);
2513                         res = fwrite(&uc, 1, 1, rawFile);
2514                         if (res < 1) {
2515                             fprintf(stderr, "failed to write 1 byte for %s\n", outfile);
2516                             goto fin;
2517                         }
2518                         ptr++;
2519                     }
2520                 }
2521             }
2522         } else if (image->comps[compno].prec <= 16) {
2523             if (image->comps[compno].sgnd == 1) {
2524                 union {
2525                     signed short val;
2526                     signed char vals[2];
2527                 } uc16;
2528                 mask = (1 << image->comps[compno].prec) - 1;
2529                 ptr = image->comps[compno].data;
2530                 for (line = 0; line < h; line++) {
2531                     for (row = 0; row < w; row++)    {
2532                         curr = *ptr;
2533                         if (curr > 32767) {
2534                             curr = 32767;
2535                         } else if (curr < -32768) {
2536                             curr = -32768;
2537                         }
2538                         uc16.val = (signed short)(curr & mask);
2539                         res = fwrite(uc16.vals, 1, 2, rawFile);
2540                         if (res < 2) {
2541                             fprintf(stderr, "failed to write 2 byte for %s\n", outfile);
2542                             goto fin;
2543                         }
2544                         ptr++;
2545                     }
2546                 }
2547             } else if (image->comps[compno].sgnd == 0) {
2548                 union {
2549                     unsigned short val;
2550                     unsigned char vals[2];
2551                 } uc16;
2552                 mask = (1 << image->comps[compno].prec) - 1;
2553                 ptr = image->comps[compno].data;
2554                 for (line = 0; line < h; line++) {
2555                     for (row = 0; row < w; row++)    {
2556                         curr = *ptr;
2557                         if (curr > 65535) {
2558                             curr = 65535;
2559                         } else if (curr < 0) {
2560                             curr = 0;
2561                         }
2562                         uc16.val = (unsigned short)(curr & mask);
2563                         res = fwrite(uc16.vals, 1, 2, rawFile);
2564                         if (res < 2) {
2565                             fprintf(stderr, "failed to write 2 byte for %s\n", outfile);
2566                             goto fin;
2567                         }
2568                         ptr++;
2569                     }
2570                 }
2571             }
2572         } else if (image->comps[compno].prec <= 32) {
2573             fprintf(stderr, "More than 16 bits per component not handled yet\n");
2574             goto fin;
2575         } else {
2576             fprintf(stderr, "Error: invalid precision: %d\n", image->comps[compno].prec);
2577             goto fin;
2578         }
2579     }
2580     fails = 0;
2581 fin:
2582     fclose(rawFile);
2583     return fails;
2584 }
2585
2586 int imagetoraw(opj_image_t * image, const char *outfile)
2587 {
2588     return imagetoraw_common(image, outfile, OPJ_TRUE);
2589 }
2590
2591 int imagetorawl(opj_image_t * image, const char *outfile)
2592 {
2593     return imagetoraw_common(image, outfile, OPJ_FALSE);
2594 }
2595