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