Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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