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