src/bin/jpwl/opj_jpwl_decompress.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
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <stdlib.h>
  42 #include <math.h>
  43
  44 #ifdef _WIN32
  45 #include "windirent.h"
  46 #else
  47 #include <dirent.h>
  48 #endif /* _WIN32 */
  49
  50 #ifdef _WIN32
  51 #include <windows.h>
  52 #else
  53 #include <strings.h>
  54 #define _stricmp strcasecmp
  55 #define _strnicmp strncasecmp
  56 #endif /* _WIN32 */
  57
  58 #include "opj_apps_config.h"
  59 #include "openjpeg.h"
  60 #include "opj_getopt.h"
  61 #include "convert.h"
  62 #include "index.h"
  63
  64 #ifdef OPJ_HAVE_LIBLCMS2
  65 #include <lcms2.h>
  66 #endif
  67 #ifdef OPJ_HAVE_LIBLCMS1
  68 #include <lcms.h>
  69 #endif
  70 #include "color.h"
  71
  72 #include "format_defs.h"
  73
  74 typedef struct dircnt {
  75     /** Buffer for holding images read from Directory*/
  76     char *filename_buf;
  77     /** Pointer to the buffer*/
  78     char **filename;
  79 } dircnt_t;
  80
  81
  82 typedef struct img_folder {
  83     /** The directory path of the folder containing input images*/
  84     char *imgdirpath;
  85     /** Output format*/
  86     const char *out_format;
  87     /** Enable option*/
  88     char set_imgdir;
  89     /** Enable Cod Format for output*/
  90     char set_out_format;
  91
  92 } img_fol_t;
  93
  94 void decode_help_display(void)
  95 {
  96     fprintf(stdout, "HELP for j2k_to_image\n----\n\n");
  97     fprintf(stdout, "- the -h option displays this help information on screen\n\n");
  98
  99     /* UniPG>> */
 100     fprintf(stdout, "List of parameters for the JPEG 2000 "
 101 #ifdef USE_JPWL
 102             "+ JPWL "
 103 #endif /* USE_JPWL */
 104             "decoder:\n");
 105     /* <<UniPG */
 106     fprintf(stdout, "\n");
 107     fprintf(stdout, "\n");
 108     fprintf(stdout, "  -ImgDir \n");
 109     fprintf(stdout, "   Image file Directory path \n");
 110     fprintf(stdout, "  -OutFor \n");
 111     fprintf(stdout, "    REQUIRED only if -ImgDir is used\n");
 112     fprintf(stdout, "     Need to specify only format without filename <BMP>  \n");
 113     fprintf(stdout,
 114             "    Currently accepts PGM, PPM, PNM, PGX, PNG, BMP, TIF, RAW and TGA formats\n");
 115     fprintf(stdout, "  -i <compressed file>\n");
 116     fprintf(stdout,
 117             "    REQUIRED only if an Input image directory not specified\n");
 118     fprintf(stdout,
 119             "    Currently accepts J2K-files, JP2-files and JPT-files. The file type\n");
 120     fprintf(stdout, "    is identified based on its suffix.\n");
 121     fprintf(stdout, "  -o <decompressed file>\n");
 122     fprintf(stdout, "    REQUIRED\n");
 123     fprintf(stdout,
 124             "    Currently accepts PGM, PPM, PNM, PGX, PNG, BMP, TIF, RAW and TGA files\n");
 125     fprintf(stdout,
 126             "    Binary data is written to the file (not ascii). If a PGX\n");
 127     fprintf(stdout,
 128             "    filename is given, there will be as many output files as there are\n");
 129     fprintf(stdout,
 130             "    components: an indice starting from 0 will then be appended to the\n");
 131     fprintf(stdout,
 132             "    output filename, just before the \"pgx\" extension. If a PGM filename\n");
 133     fprintf(stdout,
 134             "    is given and there are more than one component, only the first component\n");
 135     fprintf(stdout, "    will be written to the file.\n");
 136     fprintf(stdout, "  -r <reduce factor>\n");
 137     fprintf(stdout,
 138             "    Set the number of highest resolution levels to be discarded. The\n");
 139     fprintf(stdout,
 140             "    image resolution is effectively divided by 2 to the power of the\n");
 141     fprintf(stdout,
 142             "    number of discarded levels. The reduce factor is limited by the\n");
 143     fprintf(stdout,
 144             "    smallest total number of decomposition levels among tiles.\n");
 145     fprintf(stdout, "  -l <number of quality layers to decode>\n");
 146     fprintf(stdout,
 147             "    Set the maximum number of quality layers to decode. If there are\n");
 148     fprintf(stdout,
 149             "    less quality layers than the specified number, all the quality layers\n");
 150     fprintf(stdout, "    are decoded.\n");
 151     fprintf(stdout, "  -x  \n");
 152     fprintf(stdout, "    Create an index file *.Idx (-x index_name.Idx) \n");
 153     fprintf(stdout, "\n");
 154     /* UniPG>> */
 155 #ifdef USE_JPWL
 156     fprintf(stdout, "  -W <options>\n");
 157     fprintf(stdout,
 158             "    Activates the JPWL correction capability, if the codestream complies.\n");
 159     fprintf(stdout,
 160             "    Options can be a comma separated list of <param=val> tokens:\n");
 161     fprintf(stdout, "    c, c=numcomps\n");
 162     fprintf(stdout,
 163             "       numcomps is the number of expected components in the codestream\n");
 164     fprintf(stdout, "       (search of first EPB rely upon this, default is %d)\n",
 165             JPWL_EXPECTED_COMPONENTS);
 166 #endif /* USE_JPWL */
 167     /* <<UniPG */
 168     fprintf(stdout, "\n");
 169 }
 170
 171 /* -------------------------------------------------------------------------- */
 172
 173 int get_num_images(char *imgdirpath)
 174 {
 175     DIR *dir;
 176     struct dirent* content;
 177     int num_images = 0;
 178
 179     /*Reading the input images from given input directory*/
 180
 181     dir = opendir(imgdirpath);
 182     if (!dir) {
 183         fprintf(stderr, "Could not open Folder %s\n", imgdirpath);
 184         return 0;
 185     }
 186
 187     while ((content = readdir(dir)) != NULL) {
 188         if (strcmp(".", content->d_name) == 0 || strcmp("..", content->d_name) == 0) {
 189             continue;
 190         }
 191         num_images++;
 192     }
 193     return num_images;
 194 }
 195
 196 int load_images(dircnt_t *dirptr, char *imgdirpath)
 197 {
 198     DIR *dir;
 199     struct dirent* content;
 200     int i = 0;
 201
 202     /*Reading the input images from given input directory*/
 203
 204     dir = opendir(imgdirpath);
 205     if (!dir) {
 206         fprintf(stderr, "Could not open Folder %s\n", imgdirpath);
 207         return 1;
 208     } else   {
 209         fprintf(stderr, "Folder opened successfully\n");
 210     }
 211
 212     while ((content = readdir(dir)) != NULL) {
 213         if (strcmp(".", content->d_name) == 0 || strcmp("..", content->d_name) == 0) {
 214             continue;
 215         }
 216
 217         strcpy(dirptr->filename[i], content->d_name);
 218         i++;
 219     }
 220     return 0;
 221 }
 222
 223 int get_file_format(char *filename)
 224 {
 225     unsigned int i;
 226     static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp", "tif", "raw", "tga", "png", "j2k", "jp2", "jpt", "j2c", "jpc" };
 227     static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, TGA_DFMT, PNG_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT, J2K_CFMT, J2K_CFMT };
 228     char * ext = strrchr(filename, '.');
 229     if (ext == NULL) {
 230         return -1;
 231     }
 232     ext++;
 233     if (ext) {
 234         for (i = 0; i < sizeof(format) / sizeof(*format); i++) {
 235             if (_strnicmp(ext, extension[i], 3) == 0) {
 236                 return format[i];
 237             }
 238         }
 239     }
 240
 241     return -1;
 242 }
 243
 244 char get_next_file(int imageno, dircnt_t *dirptr, img_fol_t *img_fol,
 245                    opj_dparameters_t *parameters)
 246 {
 247     char image_filename[OPJ_PATH_LEN], infilename[OPJ_PATH_LEN],
 248          outfilename[OPJ_PATH_LEN], temp_ofname[OPJ_PATH_LEN];
 249     char *temp_p, temp1[OPJ_PATH_LEN] = "";
 250
 251     strcpy(image_filename, dirptr->filename[imageno]);
 252     fprintf(stderr, "File Number %d \"%s\"\n", imageno, image_filename);
 253     parameters->decod_format = get_file_format(image_filename);
 254     if (parameters->decod_format == -1) {
 255         return 1;
 256     }
 257     sprintf(infilename, "%s/%s", img_fol->imgdirpath, image_filename);
 258     strncpy(parameters->infile, infilename, sizeof(infilename));
 259
 260     /*Set output file*/
 261     strcpy(temp_ofname, strtok(image_filename, "."));
 262     while ((temp_p = strtok(NULL, ".")) != NULL) {
 263         strcat(temp_ofname, temp1);
 264         sprintf(temp1, ".%s", temp_p);
 265     }
 266     if (img_fol->set_out_format == 1) {
 267         sprintf(outfilename, "%s/%s.%s", img_fol->imgdirpath, temp_ofname,
 268                 img_fol->out_format);
 269         strncpy(parameters->outfile, outfilename, sizeof(outfilename));
 270     }
 271     return 0;
 272 }
 273
 274 /* -------------------------------------------------------------------------- */
 275 int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,
 276                           img_fol_t *img_fol, char *indexfilename)
 277 {
 278     /* parse the command line */
 279     int totlen, c;
 280     opj_option_t long_option[] = {
 281         {"ImgDir", REQ_ARG, NULL, 'y'},
 282         {"OutFor", REQ_ARG, NULL, 'O'},
 283     };
 284
 285     const char optlist[] = "i:o:r:l:x:"
 286
 287                            /* UniPG>> */
 288 #ifdef USE_JPWL
 289                            "W:"
 290 #endif /* USE_JPWL */
 291                            /* <<UniPG */
 292                            "h"     ;
 293     totlen = sizeof(long_option);
 294     img_fol->set_out_format = 0;
 295     do {
 296         c = opj_getopt_long(argc, argv, optlist, long_option, totlen);
 297         if (c == -1) {
 298             break;
 299         }
 300         switch (c) {
 301         case 'i': {         /* input file */
 302             char *infile = opj_optarg;
 303             parameters->decod_format = get_file_format(infile);
 304             switch (parameters->decod_format) {
 305             case J2K_CFMT:
 306             case JP2_CFMT:
 307             case JPT_CFMT:
 308                 break;
 309             default:
 310                 fprintf(stderr,
 311                         "!! Unrecognized format for infile : %s [accept only *.j2k, *.jp2, *.jpc or *.jpt] !!\n\n",
 312                         infile);
 313                 return 1;
 314             }
 315             strncpy(parameters->infile, infile, sizeof(parameters->infile) - 1);
 316         }
 317         break;
 318
 319         /* ----------------------------------------------------- */
 320
 321         case 'o': {         /* output file */
 322             char *outfile = opj_optarg;
 323             parameters->cod_format = get_file_format(outfile);
 324             switch (parameters->cod_format) {
 325             case PGX_DFMT:
 326             case PXM_DFMT:
 327             case BMP_DFMT:
 328             case TIF_DFMT:
 329             case RAW_DFMT:
 330             case TGA_DFMT:
 331             case PNG_DFMT:
 332                 break;
 333             default:
 334                 fprintf(stderr,
 335                         "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n",
 336                         outfile);
 337                 return 1;
 338             }
 339             strncpy(parameters->outfile, outfile, sizeof(parameters->outfile) - 1);
 340         }
 341         break;
 342
 343         /* ----------------------------------------------------- */
 344
 345         case 'O': {         /* output format */
 346             char outformat[50];
 347             char *of = opj_optarg;
 348             sprintf(outformat, ".%s", of);
 349             img_fol->set_out_format = 1;
 350             parameters->cod_format = get_file_format(outformat);
 351             switch (parameters->cod_format) {
 352             case PGX_DFMT:
 353                 img_fol->out_format = "pgx";
 354                 break;
 355             case PXM_DFMT:
 356                 img_fol->out_format = "ppm";
 357                 break;
 358             case BMP_DFMT:
 359                 img_fol->out_format = "bmp";
 360                 break;
 361             case TIF_DFMT:
 362                 img_fol->out_format = "tif";
 363                 break;
 364             case RAW_DFMT:
 365                 img_fol->out_format = "raw";
 366                 break;
 367             case TGA_DFMT:
 368                 img_fol->out_format = "raw";
 369                 break;
 370             case PNG_DFMT:
 371                 img_fol->out_format = "png";
 372                 break;
 373             default:
 374                 fprintf(stderr,
 375                         "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n",
 376                         outformat);
 377                 return 1;
 378                 break;
 379             }
 380         }
 381         break;
 382
 383         /* ----------------------------------------------------- */
 384
 385
 386         case 'r': {     /* reduce option */
 387             sscanf(opj_optarg, "%d", &parameters->cp_reduce);
 388         }
 389         break;
 390
 391         /* ----------------------------------------------------- */
 392
 393
 394         case 'l': {     /* layering option */
 395             sscanf(opj_optarg, "%d", &parameters->cp_layer);
 396         }
 397         break;
 398
 399         /* ----------------------------------------------------- */
 400
 401         case 'h':           /* display an help description */
 402             decode_help_display();
 403             return 1;
 404
 405         /* ------------------------------------------------------ */
 406
 407         case 'y': {         /* Image Directory path */
 408             img_fol->imgdirpath = (char*)malloc(strlen(opj_optarg) + 1);
 409             strcpy(img_fol->imgdirpath, opj_optarg);
 410             img_fol->set_imgdir = 1;
 411         }
 412         break;
 413         /* ----------------------------------------------------- */
 414         case 'x': {         /* Creation of index file */
 415             char *index = opj_optarg;
 416             strncpy(indexfilename, index, OPJ_PATH_LEN);
 417         }
 418         break;
 419             /* ----------------------------------------------------- */
 420             /* UniPG>> */
 421 #ifdef USE_JPWL
 422
 423         case 'W': {         /* activate JPWL correction */
 424             char *token = NULL;
 425
 426             token = strtok(opj_optarg, ",");
 427             while (token != NULL) {
 428
 429                 /* search expected number of components */
 430                 if (*token == 'c') {
 431
 432                     static int compno;
 433
 434                     compno = JPWL_EXPECTED_COMPONENTS; /* predefined no. of components */
 435
 436                     if (sscanf(token, "c=%d", &compno) == 1) {
 437                         /* Specified */
 438                         if ((compno < 1) || (compno > 256)) {
 439                             fprintf(stderr, "ERROR -> invalid number of components c = %d\n", compno);
 440                             return 1;
 441                         }
 442                         parameters->jpwl_exp_comps = compno;
 443
 444                     } else if (!strcmp(token, "c")) {
 445                         /* default */
 446                         parameters->jpwl_exp_comps = compno; /* auto for default size */
 447
 448                     } else {
 449                         fprintf(stderr, "ERROR -> invalid components specified = %s\n", token);
 450                         return 1;
 451                     };
 452                 }
 453
 454                 /* search maximum number of tiles */
 455                 if (*token == 't') {
 456
 457                     static int tileno;
 458
 459                     tileno = JPWL_MAXIMUM_TILES; /* maximum no. of tiles */
 460
 461                     if (sscanf(token, "t=%d", &tileno) == 1) {
 462                         /* Specified */
 463                         if ((tileno < 1) || (tileno > JPWL_MAXIMUM_TILES)) {
 464                             fprintf(stderr, "ERROR -> invalid number of tiles t = %d\n", tileno);
 465                             return 1;
 466                         }
 467                         parameters->jpwl_max_tiles = tileno;
 468
 469                     } else if (!strcmp(token, "t")) {
 470                         /* default */
 471                         parameters->jpwl_max_tiles = tileno; /* auto for default size */
 472
 473                     } else {
 474                         fprintf(stderr, "ERROR -> invalid tiles specified = %s\n", token);
 475                         return 1;
 476                     };
 477                 }
 478
 479                 /* next token or bust */
 480                 token = strtok(NULL, ",");
 481             };
 482             parameters->jpwl_correct = OPJ_TRUE;
 483             fprintf(stdout, "JPWL correction capability activated\n");
 484             fprintf(stdout, "- expecting %d components\n", parameters->jpwl_exp_comps);
 485         }
 486         break;
 487 #endif /* USE_JPWL */
 488         /* <<UniPG */
 489
 490         /* ----------------------------------------------------- */
 491
 492         default:
 493             fprintf(stderr, "WARNING -> this option is not valid \"-%c %s\"\n", c,
 494                     opj_optarg);
 495             break;
 496         }
 497     } while (c != -1);
 498
 499     /* check for possible errors */
 500     if (img_fol->set_imgdir == 1) {
 501         if (!(parameters->infile[0] == 0)) {
 502             fprintf(stderr, "Error: options -ImgDir and -i cannot be used together !!\n");
 503             return 1;
 504         }
 505         if (img_fol->set_out_format == 0) {
 506             fprintf(stderr,
 507                     "Error: When -ImgDir is used, -OutFor <FORMAT> must be used !!\n");
 508             fprintf(stderr,
 509                     "Only one format allowed! Valid format PGM, PPM, PNM, PGX, BMP, TIF, RAW and TGA!!\n");
 510             return 1;
 511         }
 512         if (!((parameters->outfile[0] == 0))) {
 513             fprintf(stderr, "Error: options -ImgDir and -o cannot be used together !!\n");
 514             return 1;
 515         }
 516     } else {
 517         if ((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) {
 518             fprintf(stderr, "Example: %s -i image.j2k -o image.pgm\n", argv[0]);
 519             fprintf(stderr, "    Try: %s -h\n", argv[0]);
 520             return 1;
 521         }
 522     }
 523
 524     return 0;
 525 }
 526
 527 /* -------------------------------------------------------------------------- */
 528
 529 /**
 530 sample error callback expecting a FILE* client object
 531 */
 532 void error_callback(const char *msg, void *client_data)
 533 {
 534     FILE *stream = (FILE*)client_data;
 535     fprintf(stream, "[ERROR] %s", msg);
 536 }
 537 /**
 538 sample warning callback expecting a FILE* client object
 539 */
 540 void warning_callback(const char *msg, void *client_data)
 541 {
 542     FILE *stream = (FILE*)client_data;
 543     fprintf(stream, "[WARNING] %s", msg);
 544 }
 545 /**
 546 sample debug callback expecting no client object
 547 */
 548 void info_callback(const char *msg, void *client_data)
 549 {
 550     (void)client_data;
 551     fprintf(stdout, "[INFO] %s", msg);
 552 }
 553
 554 /* -------------------------------------------------------------------------- */
 555
 556 int main(int argc, char **argv)
 557 {
 558     opj_dparameters_t parameters;   /* decompression parameters */
 559     img_fol_t img_fol;
 560     opj_event_mgr_t event_mgr;      /* event manager */
 561     opj_image_t *image = NULL;
 562     FILE *fsrc = NULL;
 563     unsigned char *src = NULL;
 564     int file_length;
 565     int num_images;
 566     int i, imageno;
 567     dircnt_t *dirptr = NULL;
 568     opj_dinfo_t* dinfo = NULL;  /* handle to a decompressor */
 569     opj_cio_t *cio = NULL;
 570     opj_codestream_info_t cstr_info;  /* Codestream information structure */
 571     char indexfilename[OPJ_PATH_LEN];   /* index file name */
 572
 573     /* configure the event callbacks (not required) */
 574     memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
 575     event_mgr.error_handler = error_callback;
 576     event_mgr.warning_handler = warning_callback;
 577     event_mgr.info_handler = info_callback;
 578
 579     /* set decoding parameters to default values */
 580     opj_set_default_decoder_parameters(&parameters);
 581
 582     /* Initialize indexfilename and img_fol */
 583     *indexfilename = 0;
 584     memset(&img_fol, 0, sizeof(img_fol_t));
 585
 586     /* parse input and get user encoding parameters */
 587     if (parse_cmdline_decoder(argc, argv, &parameters, &img_fol,
 588                               indexfilename) == 1) {
 589         return 1;
 590     }
 591
 592     /* Initialize reading of directory */
 593     if (img_fol.set_imgdir == 1) {
 594         num_images = get_num_images(img_fol.imgdirpath);
 595
 596         dirptr = (dircnt_t*)malloc(sizeof(dircnt_t));
 597         if (dirptr) {
 598             dirptr->filename_buf = (char*)malloc(num_images * OPJ_PATH_LEN * sizeof(
 599                     char)); /* Stores at max 10 image file names*/
 600             if (!dirptr->filename_buf) {
 601                 free(dirptr);
 602                 return 1;
 603             }
 604             dirptr->filename = (char**) malloc(num_images * sizeof(char*));
 605             if (!dirptr->filename) {
 606                 free(dirptr);
 607                 return 1;
 608             }
 609
 610             for (i = 0; i < num_images; i++) {
 611                 dirptr->filename[i] = dirptr->filename_buf + i * OPJ_PATH_LEN;
 612             }
 613         }
 614         if (load_images(dirptr, img_fol.imgdirpath) == 1) {
 615             return 1;
 616         }
 617         if (num_images == 0) {
 618             fprintf(stdout, "Folder is empty\n");
 619             return 1;
 620         }
 621     } else {
 622         num_images = 1;
 623     }
 624
 625     /*Encoding image one by one*/
 626     for (imageno = 0; imageno < num_images ; imageno++)  {
 627         image = NULL;
 628         fprintf(stderr, "\n");
 629
 630         if (img_fol.set_imgdir == 1) {
 631             if (get_next_file(imageno, dirptr, &img_fol, &parameters)) {
 632                 fprintf(stderr, "skipping file...\n");
 633                 continue;
 634             }
 635         }
 636
 637         /* read the input file and put it in memory */
 638         /* ---------------------------------------- */
 639         fsrc = fopen(parameters.infile, "rb");
 640         if (!fsrc) {
 641             fprintf(stderr, "ERROR -> failed to open %s for reading\n", parameters.infile);
 642             return 1;
 643         }
 644         fseek(fsrc, 0, SEEK_END);
 645         file_length = ftell(fsrc);
 646         fseek(fsrc, 0, SEEK_SET);
 647         src = (unsigned char *) malloc(file_length);
 648         if (fread(src, 1, file_length, fsrc) != (size_t)file_length) {
 649             free(src);
 650             fclose(fsrc);
 651             fprintf(stderr,
 652                     "\nERROR: fread return a number of element different from the expected.\n");
 653             return 1;
 654         }
 655         fclose(fsrc);
 656
 657         /* decode the code-stream */
 658         /* ---------------------- */
 659
 660         switch (parameters.decod_format) {
 661         case J2K_CFMT: {
 662             /* JPEG-2000 codestream */
 663
 664             /* get a decoder handle */
 665             dinfo = opj_create_decompress(CODEC_J2K);
 666
 667             /* catch events using our callbacks and give a local context */
 668             opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
 669
 670             /* setup the decoder decoding parameters using user parameters */
 671             opj_setup_decoder(dinfo, &parameters);
 672
 673             /* open a byte stream */
 674             cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
 675
 676             /* decode the stream and fill the image structure */
 677             if (*indexfilename) {           /* If need to extract codestream information*/
 678                 image = opj_decode_with_info(dinfo, cio, &cstr_info);
 679             } else {
 680                 image = opj_decode(dinfo, cio);
 681             }
 682             if (!image) {
 683                 fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
 684                 opj_destroy_decompress(dinfo);
 685                 opj_cio_close(cio);
 686                 free(src);
 687                 return 1;
 688             }
 689
 690             /* close the byte stream */
 691             opj_cio_close(cio);
 692
 693             /* Write the index to disk */
 694             if (*indexfilename) {
 695                 opj_bool bSuccess;
 696                 bSuccess = write_index_file(&cstr_info, indexfilename);
 697                 if (bSuccess) {
 698                     fprintf(stderr, "Failed to output index file\n");
 699                 }
 700             }
 701         }
 702         break;
 703
 704         case JP2_CFMT: {
 705             /* JPEG 2000 compressed image data */
 706
 707             /* get a decoder handle */
 708             dinfo = opj_create_decompress(CODEC_JP2);
 709
 710             /* catch events using our callbacks and give a local context */
 711             opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
 712
 713             /* setup the decoder decoding parameters using the current image and user parameters */
 714             opj_setup_decoder(dinfo, &parameters);
 715
 716             /* open a byte stream */
 717             cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
 718
 719             /* decode the stream and fill the image structure */
 720             if (*indexfilename) {           /* If need to extract codestream information*/
 721                 image = opj_decode_with_info(dinfo, cio, &cstr_info);
 722             } else {
 723                 image = opj_decode(dinfo, cio);
 724             }
 725             if (!image) {
 726                 fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
 727                 opj_destroy_decompress(dinfo);
 728                 opj_cio_close(cio);
 729                 free(src);
 730                 return 1;
 731             }
 732
 733             /* close the byte stream */
 734             opj_cio_close(cio);
 735
 736             /* Write the index to disk */
 737             if (*indexfilename) {
 738                 opj_bool bSuccess;
 739                 bSuccess = write_index_file(&cstr_info, indexfilename);
 740                 if (bSuccess) {
 741                     fprintf(stderr, "Failed to output index file\n");
 742                 }
 743             }
 744         }
 745         break;
 746
 747         case JPT_CFMT: {
 748             /* JPEG 2000, JPIP */
 749
 750             /* get a decoder handle */
 751             dinfo = opj_create_decompress(CODEC_JPT);
 752
 753             /* catch events using our callbacks and give a local context */
 754             opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
 755
 756             /* setup the decoder decoding parameters using user parameters */
 757             opj_setup_decoder(dinfo, &parameters);
 758
 759             /* open a byte stream */
 760             cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
 761
 762             /* decode the stream and fill the image structure */
 763             if (*indexfilename) {           /* If need to extract codestream information*/
 764                 image = opj_decode_with_info(dinfo, cio, &cstr_info);
 765             } else {
 766                 image = opj_decode(dinfo, cio);
 767             }
 768             if (!image) {
 769                 fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
 770                 opj_destroy_decompress(dinfo);
 771                 opj_cio_close(cio);
 772                 free(src);
 773                 return 1;
 774             }
 775
 776             /* close the byte stream */
 777             opj_cio_close(cio);
 778
 779             /* Write the index to disk */
 780             if (*indexfilename) {
 781                 opj_bool bSuccess;
 782                 bSuccess = write_index_file(&cstr_info, indexfilename);
 783                 if (bSuccess) {
 784                     fprintf(stderr, "Failed to output index file\n");
 785                 }
 786             }
 787         }
 788         break;
 789
 790         default:
 791             fprintf(stderr, "skipping file..\n");
 792             continue;
 793         }
 794
 795         /* free the memory containing the code-stream */
 796         free(src);
 797         src = NULL;
 798
 799         if (image->color_space == CLRSPC_SYCC) {
 800             color_sycc_to_rgb(image);
 801         }
 802
 803         if (image->icc_profile_buf) {
 804 #if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
 805             color_apply_icc_profile(image);
 806 #endif
 807
 808             free(image->icc_profile_buf);
 809             image->icc_profile_buf = NULL;
 810             image->icc_profile_len = 0;
 811         }
 812
 813         /* create output image */
 814         /* ------------------- */
 815         switch (parameters.cod_format) {
 816         case PXM_DFMT:          /* PNM PGM PPM */
 817             if (imagetopnm(image, parameters.outfile)) {
 818                 fprintf(stdout, "Outfile %s not generated\n", parameters.outfile);
 819             } else {
 820                 fprintf(stdout, "Generated Outfile %s\n", parameters.outfile);
 821             }
 822             break;
 823
 824         case PGX_DFMT:          /* PGX */
 825             if (imagetopgx(image, parameters.outfile)) {
 826                 fprintf(stdout, "Outfile %s not generated\n", parameters.outfile);
 827             } else {
 828                 fprintf(stdout, "Generated Outfile %s\n", parameters.outfile);
 829             }
 830             break;
 831
 832         case BMP_DFMT:          /* BMP */
 833             if (imagetobmp(image, parameters.outfile)) {
 834                 fprintf(stdout, "Outfile %s not generated\n", parameters.outfile);
 835             } else {
 836                 fprintf(stdout, "Generated Outfile %s\n", parameters.outfile);
 837             }
 838             break;
 839 #ifdef OPJ_HAVE_LIBTIFF
 840         case TIF_DFMT:          /* TIFF */
 841             if (imagetotif(image, parameters.outfile)) {
 842                 fprintf(stdout, "Outfile %s not generated\n", parameters.outfile);
 843             } else {
 844                 fprintf(stdout, "Generated Outfile %s\n", parameters.outfile);
 845             }
 846             break;
 847 #endif /* OPJ_HAVE_LIBTIFF */
 848         case RAW_DFMT:          /* RAW */
 849             if (imagetoraw(image, parameters.outfile)) {
 850                 fprintf(stdout, "Error generating raw file. Outfile %s not generated\n",
 851                         parameters.outfile);
 852             } else {
 853                 fprintf(stdout, "Successfully generated Outfile %s\n", parameters.outfile);
 854             }
 855             break;
 856
 857         case TGA_DFMT:          /* TGA */
 858             if (imagetotga(image, parameters.outfile)) {
 859                 fprintf(stdout, "Error generating tga file. Outfile %s not generated\n",
 860                         parameters.outfile);
 861             } else {
 862                 fprintf(stdout, "Successfully generated Outfile %s\n", parameters.outfile);
 863             }
 864             break;
 865 #ifdef OPJ_HAVE_LIBPNG
 866         case PNG_DFMT:          /* PNG */
 867             if (imagetopng(image, parameters.outfile)) {
 868                 fprintf(stdout, "Error generating png file. Outfile %s not generated\n",
 869                         parameters.outfile);
 870             } else {
 871                 fprintf(stdout, "Successfully generated Outfile %s\n", parameters.outfile);
 872             }
 873             break;
 874 #endif /* OPJ_HAVE_LIBPNG */
 875         /* Can happen if output file is TIFF or PNG
 876          * and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined
 877         */
 878         default:
 879             fprintf(stderr, "Outfile %s not generated\n", parameters.outfile);
 880         }
 881
 882         /* free remaining structures */
 883         if (dinfo) {
 884             opj_destroy_decompress(dinfo);
 885         }
 886         /* free codestream information structure */
 887         if (*indexfilename) {
 888             opj_destroy_cstr_info(&cstr_info);
 889         }
 890         /* free image data structure */
 891         opj_image_destroy(image);
 892
 893     }
 894     return 0;
 895 }
 896 /*end main*/
 897
 898
 899
 900