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. #include "format_defs.h"
  59.  
  60. #define CINEMA_24_CS 1302083    /*Codestream length for 24fps*/
  61. #define CINEMA_48_CS 651041             /*Codestream length for 48fps*/
  62. #define COMP_24_CS 1041666              /*Maximum size per color component for 2K & 4K @ 24fps*/
  63. #define COMP_48_CS 520833               /*Maximum size per color component for 2K @ 48fps*/
  64.  
  65. typedef struct dircnt{
  66.         /** Buffer for holding images read from Directory*/
  67.         char *filename_buf;
  68.         /** Pointer to the buffer*/
  69.         char **filename;
  70. }dircnt_t;
  71.  
  72. typedef struct img_folder{
  73.         /** The directory path of the folder containing input images*/
  74.         char *imgdirpath;
  75.         /** Output format*/
  76.         char *out_format;
  77.         /** Enable option*/
  78.         char set_imgdir;
  79.         /** Enable Cod Format for output*/
  80.         char set_out_format;
  81.         /** User specified rate stored in case of cinema option*/
  82.         float *rates;
  83. }img_fol_t;
  84.  
  85. void encode_help_display() {
  86.         fprintf(stdout,"HELP for image_to_j2k\n----\n\n");
  87.         fprintf(stdout,"- the -h option displays this help information on screen\n\n");
  88.  
  89. /* UniPG>> */
  90.         fprintf(stdout,"List of parameters for the JPEG 2000 "
  91. #ifdef USE_JPWL
  92.                 "+ JPWL "
  93. #endif /* USE_JPWL */
  94.                 "encoder:\n");
  95. /* <<UniPG */
  96.         fprintf(stdout,"\n");
  97.         fprintf(stdout,"REMARKS:\n");
  98.         fprintf(stdout,"---------\n");
  99.         fprintf(stdout,"\n");
  100.         fprintf(stdout,"The markers written to the main_header are : SOC SIZ COD QCD COM.\n");
  101.         fprintf(stdout,"COD and QCD never appear in the tile_header.\n");
  102.         fprintf(stdout,"\n");
  103.         fprintf(stdout,"By default:\n");
  104.         fprintf(stdout,"------------\n");
  105.         fprintf(stdout,"\n");
  106.         fprintf(stdout," * Lossless\n");
  107.         fprintf(stdout," * 1 tile\n");
  108.         fprintf(stdout," * Size of precinct : 2^15 x 2^15 (means 1 precinct)\n");
  109.         fprintf(stdout," * Size of code-block : 64 x 64\n");
  110.         fprintf(stdout," * Number of resolutions: 6\n");
  111.         fprintf(stdout," * No SOP marker in the codestream\n");
  112.         fprintf(stdout," * No EPH marker in the codestream\n");
  113.         fprintf(stdout," * No sub-sampling in x or y direction\n");
  114.         fprintf(stdout," * No mode switch activated\n");
  115.         fprintf(stdout," * Progression order: LRCP\n");
  116.         fprintf(stdout," * No index file\n");
  117.         fprintf(stdout," * No ROI upshifted\n");
  118.         fprintf(stdout," * No offset of the origin of the image\n");
  119.         fprintf(stdout," * No offset of the origin of the tiles\n");
  120.         fprintf(stdout," * Reversible DWT 5-3\n");
  121. /* UniPG>> */
  122. #ifdef USE_JPWL
  123.         fprintf(stdout," * No JPWL protection\n");
  124. #endif /* USE_JPWL */
  125. /* <<UniPG */
  126.         fprintf(stdout,"\n");
  127.         fprintf(stdout,"Parameters:\n");
  128.         fprintf(stdout,"------------\n");
  129.         fprintf(stdout,"\n");
  130.         fprintf(stdout,"Required Parameters (except with -h):\n");
  131.         fprintf(stdout,"One of the two options -ImgDir or -i must be used\n");
  132.         fprintf(stdout,"\n");
  133.         fprintf(stdout,"-ImgDir      : Image file Directory path (example ../Images) \n");
  134.         fprintf(stdout,"    When using this option -OutFor must be used\n");
  135.         fprintf(stdout,"\n");
  136.         fprintf(stdout,"-OutFor \n");
  137.         fprintf(stdout,"    REQUIRED only if -ImgDir is used\n");
  138.         fprintf(stdout,"          Need to specify only format without filename <BMP>  \n");
  139.         fprintf(stdout,"    Currently accepts PGM, PPM, PNM, PGX, PNG, BMP, TIF, RAW and TGA formats\n");
  140.         fprintf(stdout,"\n");
  141.         fprintf(stdout,"-i           : source file  (-i source.pnm also *.pgm, *.ppm, *.pgx, *png, *.bmp, *.tif, *.raw, *.tga) \n");
  142.         fprintf(stdout,"    When using this option -o must be used\n");
  143.         fprintf(stdout,"\n");
  144.         fprintf(stdout,"-o           : destination file (-o dest.j2k or .jp2) \n");
  145.         fprintf(stdout,"\n");
  146.         fprintf(stdout,"Optional Parameters:\n");
  147.         fprintf(stdout,"\n");
  148.         fprintf(stdout,"-h           : display the help information \n ");
  149.         fprintf(stdout,"\n");
  150.         fprintf(stdout,"-cinema2K    : Digital Cinema 2K profile compliant codestream for 2K resolution.(-cinema2k 24 or 48) \n");
  151.   fprintf(stdout,"        Need to specify the frames per second for a 2K resolution. Only 24 or 48 fps is allowed\n");
  152.         fprintf(stdout,"\n");
  153.         fprintf(stdout,"-cinema4K    : Digital Cinema 4K profile compliant codestream for 4K resolution \n");
  154.         fprintf(stdout,"          Frames per second not required. Default value is 24fps\n");
  155.         fprintf(stdout,"\n");
  156.         fprintf(stdout,"-r           : different compression ratios for successive layers (-r 20,10,5)\n ");
  157.         fprintf(stdout,"                 - The rate specified for each quality level is the desired \n");
  158.         fprintf(stdout,"                   compression factor.\n");
  159.         fprintf(stdout,"                   Example: -r 20,10,1 means quality 1: compress 20x, \n");
  160.         fprintf(stdout,"                     quality 2: compress 10x and quality 3: compress lossless\n");
  161.         fprintf(stdout,"\n");
  162.         fprintf(stdout,"               (options -r and -q cannot be used together)\n ");
  163.         fprintf(stdout,"\n");
  164.  
  165.         fprintf(stdout,"-q           : different psnr for successive layers (-q 30,40,50) \n ");
  166.  
  167.         fprintf(stdout,"               (options -r and -q cannot be used together)\n ");
  168.  
  169.         fprintf(stdout,"\n");
  170.         fprintf(stdout,"-n           : number of resolutions (-n 3) \n");
  171.         fprintf(stdout,"\n");
  172.         fprintf(stdout,"-b           : size of code block (-b 32,32) \n");
  173.         fprintf(stdout,"\n");
  174.         fprintf(stdout,"-c           : size of precinct (-c 128,128) \n");
  175.         fprintf(stdout,"\n");
  176.         fprintf(stdout,"-t           : size of tile (-t 512,512) \n");
  177.         fprintf(stdout,"\n");
  178.         fprintf(stdout,"-p           : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] \n");
  179.         fprintf(stdout,"\n");
  180.         fprintf(stdout,"-s           : subsampling factor (-s 2,2) [-s X,Y] \n");
  181.         fprintf(stdout,"             Remark: subsampling bigger than 2 can produce error\n");
  182.         fprintf(stdout,"\n");
  183.         fprintf(stdout,"-POC         : Progression order change (-POC T1=0,0,1,5,3,CPRL/T1=5,0,1,6,3,CPRL) \n");
  184.         fprintf(stdout,"      Example: T1=0,0,1,5,3,CPRL \n");
  185.         fprintf(stdout,"                         : Ttilenumber=Resolution num start,Component num start,Layer num end,Resolution num end,Component num end,Progression order\n");
  186.         fprintf(stdout,"\n");
  187.         fprintf(stdout,"-SOP         : write SOP marker before each packet \n");
  188.         fprintf(stdout,"\n");
  189.         fprintf(stdout,"-EPH         : write EPH marker after each header packet \n");
  190.         fprintf(stdout,"\n");
  191.         fprintf(stdout,"-M           : mode switch (-M 3) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL)\n");
  192.         fprintf(stdout,"                 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)] \n");
  193.         fprintf(stdout,"                 Indicate multiple modes by adding their values. \n");
  194.         fprintf(stdout,"                 ex: RESTART(4) + RESET(2) + SEGMARK(32) = -M 38\n");
  195.         fprintf(stdout,"\n");
  196.         fprintf(stdout,"-x           : create an index file *.Idx (-x index_name.Idx) \n");
  197.         fprintf(stdout,"\n");
  198.         fprintf(stdout,"-ROI         : c=%%d,U=%%d : quantization indices upshifted \n");
  199.         fprintf(stdout,"               for component c=%%d [%%d = 0,1,2]\n");
  200.         fprintf(stdout,"               with a value of U=%%d [0 <= %%d <= 37] (i.e. -ROI c=0,U=25) \n");
  201.         fprintf(stdout,"\n");
  202.         fprintf(stdout,"-d           : offset of the origin of the image (-d 150,300) \n");
  203.         fprintf(stdout,"\n");
  204.         fprintf(stdout,"-T           : offset of the origin of the tiles (-T 100,75) \n");
  205.         fprintf(stdout,"\n");
  206.         fprintf(stdout,"-I           : use the irreversible DWT 9-7 (-I) \n");
  207.         fprintf(stdout,"\n");
  208.         fprintf(stdout,"-F           : characteristics of the raw input image\n");
  209.         fprintf(stdout,"               -F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
  210.         fprintf(stdout,"               Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
  211.         fprintf(stdout,"\n");
  212. /* UniPG>> */
  213. #ifdef USE_JPWL
  214.         fprintf(stdout,"-W           : adoption of JPWL (Part 11) capabilities (-W params)\n");
  215.         fprintf(stdout,"               The parameters can be written and repeated in any order:\n");
  216.         fprintf(stdout,"               [h<tilepart><=type>,s<tilepart><=method>,a=<addr>,...\n");
  217.         fprintf(stdout,"                ...,z=<size>,g=<range>,p<tilepart:pack><=type>]\n");
  218.         fprintf(stdout,"\n");
  219.         fprintf(stdout,"                 h selects the header error protection (EPB): 'type' can be\n");
  220.         fprintf(stdout,"                   [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS]\n");
  221.         fprintf(stdout,"                   if 'tilepart' is absent, it is for main and tile headers\n");
  222.         fprintf(stdout,"                   if 'tilepart' is present, it applies from that tile\n");
  223.         fprintf(stdout,"                     onwards, up to the next h<> spec, or to the last tilepart\n");
  224.         fprintf(stdout,"                     in the codestream (max. %d specs)\n", JPWL_MAX_NO_TILESPECS);
  225.         fprintf(stdout,"\n");
  226.         fprintf(stdout,"                 p selects the packet error protection (EEP/UEP with EPBs)\n");
  227.         fprintf(stdout,"                  to be applied to raw data: 'type' can be\n");
  228.         fprintf(stdout,"                   [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS]\n");
  229.         fprintf(stdout,"                   if 'tilepart:pack' is absent, it is from tile 0, packet 0\n");
  230.         fprintf(stdout,"                   if 'tilepart:pack' is present, it applies from that tile\n");
  231.         fprintf(stdout,"                     and that packet onwards, up to the next packet spec\n");
  232.         fprintf(stdout,"                     or to the last packet in the last tilepart in the stream\n");
  233.         fprintf(stdout,"                     (max. %d specs)\n", JPWL_MAX_NO_PACKSPECS);
  234.         fprintf(stdout,"\n");
  235.         fprintf(stdout,"                 s enables sensitivity data insertion (ESD): 'method' can be\n");
  236.         fprintf(stdout,"                   [-1=NO ESD 0=RELATIVE ERROR 1=MSE 2=MSE REDUCTION 3=PSNR\n");
  237.         fprintf(stdout,"                    4=PSNR INCREMENT 5=MAXERR 6=TSE 7=RESERVED]\n");
  238.         fprintf(stdout,"                   if 'tilepart' is absent, it is for main header only\n");
  239.         fprintf(stdout,"                   if 'tilepart' is present, it applies from that tile\n");
  240.         fprintf(stdout,"                     onwards, up to the next s<> spec, or to the last tilepart\n");
  241.         fprintf(stdout,"                     in the codestream (max. %d specs)\n", JPWL_MAX_NO_TILESPECS);
  242.         fprintf(stdout,"\n");
  243.         fprintf(stdout,"                 g determines the addressing mode: <range> can be\n");
  244.         fprintf(stdout,"                   [0=PACKET 1=BYTE RANGE 2=PACKET RANGE]\n");
  245.         fprintf(stdout,"\n");
  246.         fprintf(stdout,"                 a determines the size of data addressing: <addr> can be\n");
  247.         fprintf(stdout,"                   2/4 bytes (small/large codestreams). If not set, auto-mode\n");
  248.         fprintf(stdout,"\n");
  249.         fprintf(stdout,"                 z determines the size of sensitivity values: <size> can be\n");
  250.         fprintf(stdout,"                   1/2 bytes, for the transformed pseudo-floating point value\n");
  251.         fprintf(stdout,"\n");
  252.         fprintf(stdout,"                 ex.:\n");
  253.         fprintf(stdout,"                   h,h0=64,h3=16,h5=32,p0=78,p0:24=56,p1,p3:0=0,p3:20=32,s=0,\n");
  254.         fprintf(stdout,"                     s0=6,s3=-1,a=0,g=1,z=1\n");
  255.         fprintf(stdout,"                 means\n");
  256.         fprintf(stdout,"                   predefined EPB in MH, rs(64,32) from TPH 0 to TPH 2,\n");
  257.         fprintf(stdout,"                   CRC-16 in TPH 3 and TPH 4, CRC-32 in remaining TPHs,\n");
  258.         fprintf(stdout,"                   UEP rs(78,32) for packets 0 to 23 of tile 0,\n");
  259.         fprintf(stdout,"                   UEP rs(56,32) for packs. 24 to the last of tilepart 0,\n");
  260.         fprintf(stdout,"                   UEP rs default for packets of tilepart 1,\n");
  261.         fprintf(stdout,"                   no UEP for packets 0 to 19 of tilepart 3,\n");
  262.         fprintf(stdout,"                   UEP CRC-32 for packs. 20 of tilepart 3 to last tilepart,\n");
  263.         fprintf(stdout,"                   relative sensitivity ESD for MH,\n");
  264.         fprintf(stdout,"                   TSE ESD from TPH 0 to TPH 2, byte range with automatic\n");
  265.         fprintf(stdout,"                   size of addresses and 1 byte for each sensitivity value\n");
  266.         fprintf(stdout,"\n");
  267.         fprintf(stdout,"                 ex.:\n");
  268.         fprintf(stdout,"                       h,s,p\n");
  269.         fprintf(stdout,"                 means\n");
  270.         fprintf(stdout,"                   default protection to headers (MH and TPHs) as well as\n");
  271.         fprintf(stdout,"                   data packets, one ESD in MH\n");
  272.         fprintf(stdout,"\n");
  273.         fprintf(stdout,"                 N.B.: use the following recommendations when specifying\n");
  274.         fprintf(stdout,"                       the JPWL parameters list\n");
  275.         fprintf(stdout,"                   - when you use UEP, always pair the 'p' option with 'h'\n");
  276.         fprintf(stdout,"                 \n");
  277. #endif /* USE_JPWL */
  278. /* <<UniPG */
  279.         fprintf(stdout,"IMPORTANT:\n");
  280.         fprintf(stdout,"-----------\n");
  281.         fprintf(stdout,"\n");
  282.         fprintf(stdout,"The index file has the structure below:\n");
  283.         fprintf(stdout,"---------------------------------------\n");
  284.         fprintf(stdout,"\n");
  285.         fprintf(stdout,"Image_height Image_width\n");
  286.         fprintf(stdout,"progression order\n");
  287.         fprintf(stdout,"Tiles_size_X Tiles_size_Y\n");
  288.         fprintf(stdout,"Tiles_nb_X Tiles_nb_Y\n");
  289.         fprintf(stdout,"Components_nb\n");
  290.         fprintf(stdout,"Layers_nb\n");
  291.         fprintf(stdout,"decomposition_levels\n");
  292.         fprintf(stdout,"[Precincts_size_X_res_Nr Precincts_size_Y_res_Nr]...\n");
  293.         fprintf(stdout,"   [Precincts_size_X_res_0 Precincts_size_Y_res_0]\n");
  294.         fprintf(stdout,"Main_header_start_position\n");
  295.         fprintf(stdout,"Main_header_end_position\n");
  296.         fprintf(stdout,"Codestream_size\n");
  297.         fprintf(stdout,"\n");
  298.         fprintf(stdout,"INFO ON TILES\n");
  299.         fprintf(stdout,"tileno start_pos end_hd end_tile nbparts disto nbpix disto/nbpix\n");
  300.         fprintf(stdout,"Tile_0 start_pos end_Theader end_pos NumParts TotalDisto NumPix MaxMSE\n");
  301.         fprintf(stdout,"Tile_1   ''           ''        ''        ''       ''    ''      ''\n");
  302.         fprintf(stdout,"...\n");
  303.         fprintf(stdout,"Tile_Nt   ''           ''        ''        ''       ''    ''     ''\n");
  304.         fprintf(stdout,"...\n");
  305.         fprintf(stdout,"TILE 0 DETAILS\n");
  306.         fprintf(stdout,"part_nb tileno num_packs start_pos end_tph_pos end_pos\n");
  307.         fprintf(stdout,"...\n");
  308.         fprintf(stdout,"Progression_string\n");
  309.         fprintf(stdout,"pack_nb tileno layno resno compno precno start_pos end_ph_pos end_pos disto\n");
  310.         fprintf(stdout,"Tpacket_0 Tile layer res. comp. prec. start_pos end_pos disto\n");
  311.         fprintf(stdout,"...\n");
  312.         fprintf(stdout,"Tpacket_Np ''   ''    ''   ''    ''       ''       ''     ''\n");
  313.  
  314.         fprintf(stdout,"MaxDisto\n");
  315.  
  316.         fprintf(stdout,"TotalDisto\n\n");
  317. }
  318.  
  319. OPJ_PROG_ORDER give_progression(char progression[4]) {
  320.         if(strncmp(progression, "LRCP", 4) == 0) {
  321.                 return LRCP;
  322.         }
  323.         if(strncmp(progression, "RLCP", 4) == 0) {
  324.                 return RLCP;
  325.         }
  326.         if(strncmp(progression, "RPCL", 4) == 0) {
  327.                 return RPCL;
  328.         }
  329.         if(strncmp(progression, "PCRL", 4) == 0) {
  330.                 return PCRL;
  331.         }
  332.         if(strncmp(progression, "CPRL", 4) == 0) {
  333.                 return CPRL;
  334.         }
  335.  
  336.         return PROG_UNKNOWN;
  337. }
  338.  
  339. int get_num_images(char *imgdirpath){
  340.         DIR *dir;
  341.         struct dirent* content;
  342.         int num_images = 0;
  343.  
  344.         /*Reading the input images from given input directory*/
  345.  
  346.         dir= opendir(imgdirpath);
  347.         if(!dir){
  348.                 fprintf(stderr,"Could not open Folder %s\n",imgdirpath);
  349.                 return 0;
  350.         }
  351.  
  352.         num_images=0;
  353.         while((content=readdir(dir))!=NULL){
  354.                 if(strcmp(".",content->d_name)==0 || strcmp("..",content->d_name)==0 )
  355.                         continue;
  356.                 num_images++;
  357.         }
  358.         return num_images;
  359. }
  360.  
  361. int load_images(dircnt_t *dirptr, char *imgdirpath){
  362.         DIR *dir;
  363.         struct dirent* content;
  364.         int i = 0;
  365.  
  366.         /*Reading the input images from given input directory*/
  367.  
  368.         dir= opendir(imgdirpath);
  369.         if(!dir){
  370.                 fprintf(stderr,"Could not open Folder %s\n",imgdirpath);
  371.                 return 1;
  372.         }else   {
  373.                 fprintf(stderr,"Folder opened successfully\n");
  374.         }
  375.  
  376.         while((content=readdir(dir))!=NULL){
  377.                 if(strcmp(".",content->d_name)==0 || strcmp("..",content->d_name)==0 )
  378.                         continue;
  379.  
  380.                 strcpy(dirptr->filename[i],content->d_name);
  381.                 i++;
  382.         }
  383.         return 0;
  384. }
  385.  
  386. int get_file_format(char *filename) {
  387.         unsigned int i;
  388.         static const char *extension[] = {
  389.     "pgx", "pnm", "pgm", "ppm", "bmp", "tif", "raw", "tga", "png", "j2k", "jp2", "j2c", "jpc"
  390.     };
  391.         static const int format[] = {
  392.     PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, TGA_DFMT, PNG_DFMT, J2K_CFMT, JP2_CFMT, J2K_CFMT, J2K_CFMT
  393.     };
  394.         char * ext = strrchr(filename, '.');
  395.         if (ext == NULL)
  396.                 return -1;
  397.         ext++;
  398.         for(i = 0; i < sizeof(format)/sizeof(*format); i++) {
  399.                 if(_strnicmp(ext, extension[i], 3) == 0) {
  400.                         return format[i];
  401.                 }
  402.         }
  403.         return -1;
  404. }
  405.  
  406. char * get_file_name(char *name){
  407.         char *fname;
  408.         fname= (char*)malloc(OPJ_PATH_LEN*sizeof(char));
  409.         fname= strtok(name,".");
  410.         return fname;
  411. }
  412.  
  413. char get_next_file(int imageno,dircnt_t *dirptr,img_fol_t *img_fol, opj_cparameters_t *parameters){
  414.         char image_filename[OPJ_PATH_LEN], infilename[OPJ_PATH_LEN],outfilename[OPJ_PATH_LEN],temp_ofname[OPJ_PATH_LEN];
  415.   char *temp_p, temp1[OPJ_PATH_LEN]="";
  416.  
  417.         strcpy(image_filename,dirptr->filename[imageno]);
  418.         fprintf(stderr,"File Number %d \"%s\"\n",imageno,image_filename);
  419.         parameters->decod_format = get_file_format(image_filename);
  420.         if (parameters->decod_format == -1)
  421.                 return 1;
  422.         sprintf(infilename,"%s/%s",img_fol->imgdirpath,image_filename);
  423.         strncpy(parameters->infile, infilename, sizeof(infilename));
  424.  
  425.         //Set output file
  426.         strcpy(temp_ofname,get_file_name(image_filename));
  427.         while((temp_p = strtok(NULL,".")) != NULL){
  428.                 strcat(temp_ofname,temp1);
  429.                 sprintf(temp1,".%s",temp_p);
  430.         }
  431.         if(img_fol->set_out_format==1){
  432.                 sprintf(outfilename,"%s/%s.%s",img_fol->imgdirpath,temp_ofname,img_fol->out_format);
  433.                 strncpy(parameters->outfile, outfilename, sizeof(outfilename));
  434.         }
  435.  return 0;
  436. }
  437.  
  438. static int initialise_4K_poc(opj_poc_t *POC, int numres){
  439.         POC[0].tile  = 1;
  440.         POC[0].resno0  = 0;
  441.         POC[0].compno0 = 0;
  442.         POC[0].layno1  = 1;
  443.         POC[0].resno1  = numres-1;
  444.         POC[0].compno1 = 3;
  445.         POC[0].prg1 = CPRL;
  446.         POC[1].tile  = 1;
  447.         POC[1].resno0  = numres-1;
  448.         POC[1].compno0 = 0;
  449.         POC[1].layno1  = 1;
  450.         POC[1].resno1  = numres;
  451.         POC[1].compno1 = 3;
  452.         POC[1].prg1 = CPRL;
  453.         return 2;
  454. }
  455.  
  456. void cinema_parameters(opj_cparameters_t *parameters){
  457.         parameters->tile_size_on = false;
  458.         parameters->cp_tdx=1;
  459.         parameters->cp_tdy=1;
  460.  
  461.         /*Tile part*/
  462.         parameters->tp_flag = 'C';
  463.         parameters->tp_on = 1;
  464.  
  465.         /*Tile and Image shall be at (0,0)*/
  466.         parameters->cp_tx0 = 0;
  467.         parameters->cp_ty0 = 0;
  468.         parameters->image_offset_x0 = 0;
  469.         parameters->image_offset_y0 = 0;
  470.  
  471.         /*Codeblock size= 32*32*/
  472.         parameters->cblockw_init = 32;
  473.         parameters->cblockh_init = 32;
  474.         parameters->csty |= 0x01;
  475.  
  476.         /*The progression order shall be CPRL*/
  477.         parameters->prog_order = CPRL;
  478.  
  479.         /* No ROI */
  480.         parameters->roi_compno = -1;
  481.  
  482.         parameters->subsampling_dx = 1;         parameters->subsampling_dy = 1;
  483.  
  484.         /* 9-7 transform */
  485.         parameters->irreversible = 1;
  486.  
  487. }
  488.  
  489. void cinema_setup_encoder(opj_cparameters_t *parameters,opj_image_t *image, img_fol_t *img_fol){
  490.         int i;
  491.         float temp_rate;
  492.  
  493.         switch (parameters->cp_cinema){
  494.         case CINEMA2K_24:
  495.         case CINEMA2K_48:
  496.                 if(parameters->numresolution > 6){
  497.                         parameters->numresolution = 6;
  498.                 }
  499.                 if (!((image->comps[0].w == 2048) | (image->comps[0].h == 1080))){
  500.                         fprintf(stdout,"Image coordinates %d x %d is not 2K compliant.\nJPEG Digital Cinema Profile-3 "
  501.                                 "(2K profile) compliance requires that at least one of coordinates match 2048 x 1080\n",
  502.                                 image->comps[0].w,image->comps[0].h);
  503.                         parameters->cp_rsiz = STD_RSIZ;
  504.                 }
  505.         break;
  506.  
  507.         case CINEMA4K_24:
  508.                 if(parameters->numresolution < 1){
  509.                                 parameters->numresolution = 1;
  510.                         }else if(parameters->numresolution > 7){
  511.                                 parameters->numresolution = 7;
  512.                         }
  513.                 if (!((image->comps[0].w == 4096) | (image->comps[0].h == 2160))){
  514.                         fprintf(stdout,"Image coordinates %d x %d is not 4K compliant.\nJPEG Digital Cinema Profile-4"
  515.                                 "(4K profile) compliance requires that at least one of coordinates match 4096 x 2160\n",
  516.                                 image->comps[0].w,image->comps[0].h);
  517.                         parameters->cp_rsiz = STD_RSIZ;
  518.                 }
  519.                 parameters->numpocs = initialise_4K_poc(parameters->POC,parameters->numresolution);
  520.                 break;
  521.         default :
  522.                 break;
  523.         }
  524.  
  525.         switch (parameters->cp_cinema){
  526.                 case CINEMA2K_24:
  527.                 case CINEMA4K_24:
  528.                         for(i=0 ; i<parameters->tcp_numlayers ; i++){
  529.                                 temp_rate = 0 ;
  530.                                 if (img_fol->rates[i]== 0){
  531.                                         parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
  532.                                         (CINEMA_24_CS * 8 * image->comps[0].dx * image->comps[0].dy);
  533.                                 }else{
  534.                                         temp_rate =((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
  535.                                                 (img_fol->rates[i] * 8 * image->comps[0].dx * image->comps[0].dy);
  536.                                         if (temp_rate > CINEMA_24_CS ){
  537.                                                 parameters->tcp_rates[i]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
  538.                                                 (CINEMA_24_CS * 8 * image->comps[0].dx * image->comps[0].dy);
  539.                                         }else{
  540.                                                 parameters->tcp_rates[i]= img_fol->rates[i];
  541.                                         }
  542.                                 }
  543.                         }
  544.                         parameters->max_comp_size = COMP_24_CS;
  545.                         break;
  546.  
  547.                 case CINEMA2K_48:
  548.                         for(i=0 ; i<parameters->tcp_numlayers ; i++){
  549.                                 temp_rate = 0 ;
  550.                                 if (img_fol->rates[i]== 0){
  551.                                         parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
  552.                                         (CINEMA_48_CS * 8 * image->comps[0].dx * image->comps[0].dy);
  553.                                 }else{
  554.                                         temp_rate =((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
  555.                                                 (img_fol->rates[i] * 8 * image->comps[0].dx * image->comps[0].dy);
  556.                                         if (temp_rate > CINEMA_48_CS ){
  557.                                                 parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
  558.                                                 (CINEMA_48_CS * 8 * image->comps[0].dx * image->comps[0].dy);
  559.                                         }else{
  560.                                                 parameters->tcp_rates[i]= img_fol->rates[i];
  561.                                         }
  562.                                 }
  563.                         }
  564.                         parameters->max_comp_size = COMP_48_CS;
  565.                         break;
  566.                 default:
  567.                         break;
  568.         }
  569.         parameters->cp_disto_alloc = 1;
  570. }
  571.  
  572. /* ------------------------------------------------------------------------------------ */
  573.  
  574. int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters,
  575.                                                                                                         img_fol_t *img_fol, raw_cparameters_t *raw_cp, char *indexfilename) {
  576.         int i, j,totlen;
  577.         option_t long_option[]={
  578.                 {"cinema2K",REQ_ARG, NULL ,'w'},
  579.                 {"cinema4K",NO_ARG, NULL ,'y'},
  580.                 {"ImgDir",REQ_ARG, NULL ,'z'},
  581.                 {"TP",REQ_ARG, NULL ,'v'},
  582.                 {"SOP",NO_ARG, NULL ,'S'},
  583.                 {"EPH",NO_ARG, NULL ,'E'},
  584.                 {"OutFor",REQ_ARG, NULL ,'O'},
  585.                 {"POC",REQ_ARG, NULL ,'P'},
  586.                 {"ROI",REQ_ARG, NULL ,'R'},
  587.         };
  588.  
  589.         /* parse the command line */
  590.         const char optlist[] = "i:o:r:q:n:b:c:t:p:s:SEM:x:R:d:T:If:P:C:F:"
  591. #ifdef USE_JPWL
  592.                 "W:"
  593. #endif /* USE_JPWL */
  594.                 "h";
  595.  
  596.         totlen=sizeof(long_option);
  597.         img_fol->set_out_format=0;
  598.         raw_cp->rawWidth = 0;
  599.  
  600.         while (1) {
  601.     int c = getopt_long(argc, argv, optlist,long_option,totlen);
  602.                 if (c == -1)
  603.                         break;
  604.                 switch (c) {
  605.                         case 'i':                       /* input file */
  606.                         {
  607.                                 char *infile = optarg;
  608.                                 parameters->decod_format = get_file_format(infile);
  609.                                 switch(parameters->decod_format) {
  610.                                         case PGX_DFMT:
  611.                                         case PXM_DFMT:
  612.                                         case BMP_DFMT:
  613.                                         case TIF_DFMT:
  614.                                         case RAW_DFMT:
  615.                                         case TGA_DFMT:
  616.                                         case PNG_DFMT:
  617.                                                 break;
  618.                                         default:
  619.                                                 fprintf(stderr,
  620.                                                         "!! Unrecognized format for infile : %s "
  621.               "[accept only *.pnm, *.pgm, *.ppm, *.pgx, *png, *.bmp, *.tif, *.raw or *.tga] !!\n\n",
  622.                                                         infile);
  623.                                                 return 1;
  624.                                 }
  625.                                 strncpy(parameters->infile, infile, sizeof(parameters->infile)-1);
  626.                         }
  627.                         break;
  628.  
  629.                                 /* ----------------------------------------------------- */
  630.  
  631.                         case 'o':                       /* output file */
  632.                         {
  633.                                 char *outfile = optarg;
  634.                                 parameters->cod_format = get_file_format(outfile);
  635.                                 switch(parameters->cod_format) {
  636.                                         case J2K_CFMT:
  637.                                         case JP2_CFMT:
  638.                                                 break;
  639.                                         default:
  640.                                                 fprintf(stderr, "Unknown output format image %s [only *.j2k, *.j2c or *.jp2]!! \n", outfile);
  641.                                                 return 1;
  642.                                 }
  643.                                 strncpy(parameters->outfile, outfile, sizeof(parameters->outfile)-1);
  644.                         }
  645.                         break;
  646.  
  647.                                 /* ----------------------------------------------------- */
  648.                         case 'O':                       /* output format */
  649.                                 {
  650.                                         char outformat[50];
  651.                                         char *of = optarg;
  652.                                         sprintf(outformat,".%s",of);
  653.                                         img_fol->set_out_format = 1;
  654.                                         parameters->cod_format = get_file_format(outformat);
  655.                                         switch(parameters->cod_format) {
  656.                                                 case J2K_CFMT:
  657.                                                 case JP2_CFMT:
  658.                                                         img_fol->out_format = optarg;
  659.                                                         break;
  660.                                                 default:
  661.                                                         fprintf(stderr, "Unknown output format image [only j2k, j2c, jp2]!! \n");
  662.                                                         return 1;
  663.                                         }
  664.                                 }
  665.                                 break;
  666.  
  667.  
  668.                                 /* ----------------------------------------------------- */
  669.  
  670.  
  671.                         case 'r':                       /* rates rates/distorsion */
  672.                         {
  673.                                 char *s = optarg;
  674.                                 parameters->tcp_numlayers = 0;
  675.                                 while (sscanf(s, "%f", &parameters->tcp_rates[parameters->tcp_numlayers]) == 1) {
  676.                                         parameters->tcp_numlayers++;
  677.                                         while (*s && *s != ',') {
  678.                                                 s++;
  679.                                         }
  680.                                         if (!*s)
  681.                                                 break;
  682.                                         s++;
  683.                                 }
  684.                                 parameters->cp_disto_alloc = 1;
  685.                         }
  686.                         break;
  687.  
  688.                                 /* ----------------------------------------------------- */
  689.  
  690.  
  691.                         case 'F':                       /* Raw image format parameters */
  692.                         {
  693.                                 char signo;
  694.                                 char *s = optarg;
  695.                                 if (sscanf(s, "%d,%d,%d,%d,%c", &raw_cp->rawWidth, &raw_cp->rawHeight, &raw_cp->rawComp, &raw_cp->rawBitDepth, &signo) == 5) {
  696.                                         if (signo == 's') {
  697.                                                 raw_cp->rawSigned = true;
  698.                                                 fprintf(stdout,"\nRaw file parameters: %d,%d,%d,%d Signed\n", raw_cp->rawWidth, raw_cp->rawHeight, raw_cp->rawComp, raw_cp->rawBitDepth);
  699.                                         }
  700.                                         else if (signo == 'u') {
  701.                                                 raw_cp->rawSigned = false;
  702.                                                 fprintf(stdout,"\nRaw file parameters: %d,%d,%d,%d Unsigned\n", raw_cp->rawWidth, raw_cp->rawHeight, raw_cp->rawComp, raw_cp->rawBitDepth);
  703.                                         }
  704.                                         else {
  705.                                                 fprintf(stderr,"\nError: invalid raw image parameters: Unknown sign of raw file\n");
  706.                                                 fprintf(stderr,"Please use the Format option -F:\n");
  707.                                                 fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
  708.                                                 fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
  709.                                                 fprintf(stderr,"Aborting\n");
  710.                                         }
  711.                                 }
  712.                                 else {
  713.                                         fprintf(stderr,"\nError: invalid raw image parameters\n");
  714.                                         fprintf(stderr,"Please use the Format option -F:\n");
  715.                                         fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
  716.                                                 fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
  717.                                         fprintf(stderr,"Aborting\n");
  718.                                         return 1;
  719.                                 }
  720.                         }
  721.                         break;
  722.  
  723.                                 /* ----------------------------------------------------- */
  724.  
  725.                         case 'q':                       /* add fixed_quality */
  726.                         {
  727.                                 char *s = optarg;
  728.                                 while (sscanf(s, "%f", &parameters->tcp_distoratio[parameters->tcp_numlayers]) == 1) {
  729.                                         parameters->tcp_numlayers++;
  730.                                         while (*s && *s != ',') {
  731.                                                 s++;
  732.                                         }
  733.                                         if (!*s)
  734.                                                 break;
  735.                                         s++;
  736.                                 }
  737.                                 parameters->cp_fixed_quality = 1;
  738.                         }
  739.                         break;
  740.  
  741.                                 /* dda */
  742.                                 /* ----------------------------------------------------- */
  743.  
  744.                         case 'f':                       /* mod fixed_quality (before : -q) */
  745.                         {
  746.                                 int *row = NULL, *col = NULL;
  747.                                 int numlayers = 0, numresolution = 0, matrix_width = 0;
  748.  
  749.                                 char *s = optarg;
  750.                                 sscanf(s, "%d", &numlayers);
  751.                                 s++;
  752.                                 if (numlayers > 9)
  753.                                         s++;
  754.  
  755.                                 parameters->tcp_numlayers = numlayers;
  756.                                 numresolution = parameters->numresolution;
  757.                                 matrix_width = numresolution * 3;
  758.                                 parameters->cp_matrice = (int *) malloc(numlayers * matrix_width * sizeof(int));
  759.                                 s = s + 2;
  760.  
  761.                                 for (i = 0; i < numlayers; i++) {
  762.                                         row = &parameters->cp_matrice[i * matrix_width];
  763.                                         col = row;
  764.                                         parameters->tcp_rates[i] = 1;
  765.                                         sscanf(s, "%d,", &col[0]);
  766.                                         s += 2;
  767.                                         if (col[0] > 9)
  768.                                                 s++;
  769.                                         col[1] = 0;
  770.                                         col[2] = 0;
  771.                                         for (j = 1; j < numresolution; j++) {
  772.                                                 col += 3;
  773.                                                 sscanf(s, "%d,%d,%d", &col[0], &col[1], &col[2]);
  774.                                                 s += 6;
  775.                                                 if (col[0] > 9)
  776.                                                         s++;
  777.                                                 if (col[1] > 9)
  778.                                                         s++;
  779.                                                 if (col[2] > 9)
  780.                                                         s++;
  781.                                         }
  782.                                         if (i < numlayers - 1)
  783.                                                 s++;
  784.                                 }
  785.                                 parameters->cp_fixed_alloc = 1;
  786.                         }
  787.                         break;
  788.  
  789.                                 /* ----------------------------------------------------- */
  790.  
  791.                         case 't':                       /* tiles */
  792.                         {
  793.                                 sscanf(optarg, "%d,%d", &parameters->cp_tdx, &parameters->cp_tdy);
  794.                                 parameters->tile_size_on = true;
  795.                         }
  796.                         break;
  797.  
  798.                                 /* ----------------------------------------------------- */
  799.  
  800.                         case 'n':                       /* resolution */
  801.                         {
  802.                                 sscanf(optarg, "%d", &parameters->numresolution);
  803.                         }
  804.                         break;
  805.  
  806.                                 /* ----------------------------------------------------- */
  807.                         case 'c':                       /* precinct dimension */
  808.                         {
  809.                                 char sep;
  810.                                 int res_spec = 0;
  811.  
  812.                                 char *s = optarg;
  813.                                 do {
  814.                                         sep = 0;
  815.                                         sscanf(s, "[%d,%d]%c", &parameters->prcw_init[res_spec],
  816.                                  &parameters->prch_init[res_spec], &sep);
  817.                                         parameters->csty |= 0x01;
  818.                                         res_spec++;
  819.                                         s = strpbrk(s, "]") + 2;
  820.                                 }
  821.                                 while (sep == ',');
  822.                                 parameters->res_spec = res_spec;
  823.                         }
  824.                         break;
  825.  
  826.                                 /* ----------------------------------------------------- */
  827.  
  828.                         case 'b':                       /* code-block dimension */
  829.                         {
  830.                                 int cblockw_init = 0, cblockh_init = 0;
  831.                                 sscanf(optarg, "%d,%d", &cblockw_init, &cblockh_init);
  832.                                 if (cblockw_init * cblockh_init > 4096 || cblockw_init > 1024
  833.                                         || cblockw_init < 4 || cblockh_init > 1024 || cblockh_init < 4) {
  834.                                         fprintf(stderr,
  835.                                                 "!! Size of code_block error (option -b) !!\n\nRestriction :\n"
  836.             "    * width*height<=4096\n    * 4<=width,height<= 1024\n\n");
  837.                                         return 1;
  838.                                 }
  839.                                 parameters->cblockw_init = cblockw_init;
  840.                                 parameters->cblockh_init = cblockh_init;
  841.                         }
  842.                         break;
  843.  
  844.                                 /* ----------------------------------------------------- */
  845.  
  846.                         case 'x':                       /* creation of index file */
  847.                         {
  848.                                 char *index = optarg;
  849.                                 strncpy(indexfilename, index, OPJ_PATH_LEN);
  850.                         }
  851.                         break;
  852.  
  853.                                 /* ----------------------------------------------------- */
  854.  
  855.                         case 'p':                       /* progression order */
  856.                         {
  857.                                 char progression[4];
  858.  
  859.                                 strncpy(progression, optarg, 4);
  860.                                 parameters->prog_order = give_progression(progression);
  861.                                 if (parameters->prog_order == -1) {
  862.                                         fprintf(stderr, "Unrecognized progression order "
  863.             "[LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");
  864.                                         return 1;
  865.                                 }
  866.                         }
  867.                         break;
  868.  
  869.                                 /* ----------------------------------------------------- */
  870.  
  871.                         case 's':                       /* subsampling factor */
  872.                         {
  873.                                 if (sscanf(optarg, "%d,%d", &parameters->subsampling_dx,
  874.                                     &parameters->subsampling_dy) != 2) {
  875.                                         fprintf(stderr, "'-s' sub-sampling argument error !  [-s dx,dy]\n");
  876.                                         return 1;
  877.                                 }
  878.                         }
  879.                         break;
  880.  
  881.                                 /* ----------------------------------------------------- */
  882.  
  883.                         case 'd':                       /* coordonnate of the reference grid */
  884.                         {
  885.                                 if (sscanf(optarg, "%d,%d", &parameters->image_offset_x0,
  886.                                     &parameters->image_offset_y0) != 2) {
  887.                                         fprintf(stderr, "-d 'coordonnate of the reference grid' argument "
  888.             "error !! [-d x0,y0]\n");
  889.                                         return 1;
  890.                                 }
  891.                         }
  892.                         break;
  893.  
  894.                                 /* ----------------------------------------------------- */
  895.  
  896.                         case 'h':                       /* display an help description */
  897.                                 encode_help_display();
  898.                                 return 1;
  899.  
  900.                                 /* ----------------------------------------------------- */
  901.  
  902.                         case 'P':                       /* POC */
  903.                         {
  904.                                 int numpocs = 0;                /* number of progression order change (POC) default 0 */
  905.                                 opj_poc_t *POC = NULL;  /* POC : used in case of Progression order change */
  906.  
  907.                                 char *s = optarg;
  908.                                 POC = parameters->POC;
  909.  
  910.                                 while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%4s", &POC[numpocs].tile,
  911.                                         &POC[numpocs].resno0, &POC[numpocs].compno0,
  912.                                         &POC[numpocs].layno1, &POC[numpocs].resno1,
  913.                                         &POC[numpocs].compno1, POC[numpocs].progorder) == 7) {
  914.                                         POC[numpocs].prg1 = give_progression(POC[numpocs].progorder);
  915.                                         numpocs++;
  916.                                         while (*s && *s != '/') {
  917.                                                 s++;
  918.                                         }
  919.                                         if (!*s) {
  920.                                                 break;
  921.                                         }
  922.                                         s++;
  923.                                 }
  924.                                 parameters->numpocs = numpocs;
  925.                         }
  926.                         break;
  927.  
  928.                                 /* ------------------------------------------------------ */
  929.  
  930.                         case 'S':                       /* SOP marker */
  931.                         {
  932.                                 parameters->csty |= 0x02;
  933.                         }
  934.                         break;
  935.  
  936.                                 /* ------------------------------------------------------ */
  937.  
  938.                         case 'E':                       /* EPH marker */
  939.                         {
  940.                                 parameters->csty |= 0x04;
  941.                         }
  942.                         break;
  943.  
  944.                                 /* ------------------------------------------------------ */
  945.  
  946.                         case 'M':                       /* Mode switch pas tous au point !! */
  947.                         {
  948.                                 int value = 0;
  949.                                 if (sscanf(optarg, "%d", &value) == 1) {
  950.                                         for (i = 0; i <= 5; i++) {
  951.                                                 int cache = value & (1 << i);
  952.                                                 if (cache)
  953.                                                         parameters->mode |= (1 << i);
  954.                                         }
  955.                                 }
  956.                         }
  957.                         break;
  958.  
  959.                                 /* ------------------------------------------------------ */
  960.  
  961.                         case 'R':                       /* ROI */
  962.                         {
  963.                                 if (sscanf(optarg, "c=%d,U=%d", &parameters->roi_compno,
  964.                                            &parameters->roi_shift) != 2) {
  965.                                         fprintf(stderr, "ROI error !! [-ROI c='compno',U='shift']\n");
  966.                                         return 1;
  967.                                 }
  968.                         }
  969.                         break;
  970.  
  971.                                 /* ------------------------------------------------------ */
  972.  
  973.                         case 'T':                       /* Tile offset */
  974.                         {
  975.                                 if (sscanf(optarg, "%d,%d", &parameters->cp_tx0, &parameters->cp_ty0) != 2) {
  976.                                         fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]");
  977.                                         return 1;
  978.                                 }
  979.                         }
  980.                         break;
  981.  
  982.                                 /* ------------------------------------------------------ */
  983.  
  984.                         case 'C':                       /* add a comment */
  985.                         {
  986.                                 parameters->cp_comment = (char*)malloc(strlen(optarg) + 1);
  987.                                 if(parameters->cp_comment) {
  988.                                         strcpy(parameters->cp_comment, optarg);
  989.                                 }
  990.                         }
  991.                         break;
  992.  
  993.  
  994.                                 /* ------------------------------------------------------ */
  995.  
  996.                         case 'I':                       /* reversible or not */
  997.                         {
  998.                                 parameters->irreversible = 1;
  999.                         }
  1000.                         break;
  1001.  
  1002.                         /* ------------------------------------------------------ */
  1003.  
  1004.                         case 'v':                       /* Tile part generation*/
  1005.                         {
  1006.                                 parameters->tp_flag = optarg[0];
  1007.                                 parameters->tp_on = 1;
  1008.                         }
  1009.                         break;
  1010.  
  1011.                                 /* ------------------------------------------------------ */
  1012.  
  1013.                         case 'z':                       /* Image Directory path */
  1014.                         {
  1015.                                 img_fol->imgdirpath = (char*)malloc(strlen(optarg) + 1);
  1016.                                 strcpy(img_fol->imgdirpath,optarg);
  1017.                                 img_fol->set_imgdir=1;
  1018.                         }
  1019.                         break;
  1020.  
  1021.                                 /* ------------------------------------------------------ */
  1022.  
  1023.                         case 'w':                       /* Digital Cinema 2K profile compliance*/
  1024.                         {
  1025.                                 int fps=0;
  1026.                                 sscanf(optarg,"%d",&fps);
  1027.                                 if(fps == 24){
  1028.                                         parameters->cp_cinema = CINEMA2K_24;
  1029.                                 }else if(fps == 48 ){
  1030.                                         parameters->cp_cinema = CINEMA2K_48;
  1031.                                 }else {
  1032.                                         fprintf(stderr,"Incorrect value!! must be 24 or 48\n");
  1033.                                         return 1;
  1034.                                 }
  1035.                                 fprintf(stdout,"CINEMA 2K compliant codestream\n");
  1036.                                 parameters->cp_rsiz = CINEMA2K;
  1037.  
  1038.                         }
  1039.                         break;
  1040.  
  1041.                                 /* ------------------------------------------------------ */
  1042.  
  1043.                         case 'y':                       /* Digital Cinema 4K profile compliance*/
  1044.                         {
  1045.                                 parameters->cp_cinema = CINEMA4K_24;
  1046.                                 fprintf(stdout,"CINEMA 4K compliant codestream\n");
  1047.                                 parameters->cp_rsiz = CINEMA4K;
  1048.                         }
  1049.                         break;
  1050.  
  1051.                                 /* ------------------------------------------------------ */
  1052.  
  1053. /* UniPG>> */
  1054. #ifdef USE_JPWL
  1055.                                 /* ------------------------------------------------------ */
  1056.  
  1057.                         case 'W':                       /* JPWL capabilities switched on */
  1058.                         {
  1059.                                 char *token = NULL;
  1060.                                 int hprot, pprot, sens, addr, size, range;
  1061.  
  1062.                                 /* we need to enable indexing */
  1063.                                 if (!indexfilename || !*indexfilename) {
  1064.                                         strncpy(indexfilename, JPWL_PRIVATEINDEX_NAME, OPJ_PATH_LEN);
  1065.                                 }
  1066.  
  1067.                                 /* search for different protection methods */
  1068.  
  1069.                                 /* break the option in comma points and parse the result */
  1070.                                 token = strtok(optarg, ",");
  1071.                                 while(token != NULL) {
  1072.  
  1073.                                         /* search header error protection method */
  1074.                                         if (*token == 'h') {
  1075.  
  1076.                                                 static int tile = 0, tilespec = 0, lasttileno = 0;
  1077.  
  1078.                                                 hprot = 1; /* predefined method */
  1079.  
  1080.                                                 if(sscanf(token, "h=%d", &hprot) == 1) {
  1081.                                                         /* Main header, specified */
  1082.                                                         if (!((hprot == 0) || (hprot == 1) || (hprot == 16) || (hprot == 32) ||
  1083.                                                                 ((hprot >= 37) && (hprot <= 128)))) {
  1084.                                                                 fprintf(stderr, "ERROR -> invalid main header protection method h = %d\n", hprot);
  1085.                                                                 return 1;
  1086.                                                         }
  1087.                                                         parameters->jpwl_hprot_MH = hprot;
  1088.  
  1089.                                                 } else if(sscanf(token, "h%d=%d", &tile, &hprot) == 2) {
  1090.                                                         /* Tile part header, specified */
  1091.                                                         if (!((hprot == 0) || (hprot == 1) || (hprot == 16) || (hprot == 32) ||
  1092.                                                                 ((hprot >= 37) && (hprot <= 128)))) {
  1093.                                                                 fprintf(stderr, "ERROR -> invalid tile part header protection method h = %d\n", hprot);
  1094.                                                                 return 1;
  1095.                                                         }
  1096.                                                         if (tile < 0) {
  1097.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on protection method t = %d\n", tile);
  1098.                                                                 return 1;
  1099.                                                         }
  1100.                                                         if (tilespec < JPWL_MAX_NO_TILESPECS) {
  1101.                                                                 parameters->jpwl_hprot_TPH_tileno[tilespec] = lasttileno = tile;
  1102.                                                                 parameters->jpwl_hprot_TPH[tilespec++] = hprot;
  1103.                                                         }
  1104.  
  1105.                                                 } else if(sscanf(token, "h%d", &tile) == 1) {
  1106.                                                         /* Tile part header, unspecified */
  1107.                                                         if (tile < 0) {
  1108.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on protection method t = %d\n", tile);
  1109.                                                                 return 1;
  1110.                                                         }
  1111.                                                         if (tilespec < JPWL_MAX_NO_TILESPECS) {
  1112.                                                                 parameters->jpwl_hprot_TPH_tileno[tilespec] = lasttileno = tile;
  1113.                                                                 parameters->jpwl_hprot_TPH[tilespec++] = hprot;
  1114.                                                         }
  1115.  
  1116.  
  1117.                                                 } else if (!strcmp(token, "h")) {
  1118.                                                         /* Main header, unspecified */
  1119.                                                         parameters->jpwl_hprot_MH = hprot;
  1120.  
  1121.                                                 } else {
  1122.                                                         fprintf(stderr, "ERROR -> invalid protection method selection = %s\n", token);
  1123.                                                         return 1;
  1124.                                                 };
  1125.  
  1126.                                         }
  1127.  
  1128.                                         /* search packet error protection method */
  1129.                                         if (*token == 'p') {
  1130.  
  1131.                                                 static int pack = 0, tile = 0, packspec = 0;
  1132.  
  1133.                                                 pprot = 1; /* predefined method */
  1134.  
  1135.                                                 if (sscanf(token, "p=%d", &pprot) == 1) {
  1136.                                                         /* Method for all tiles and all packets */
  1137.                                                         if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
  1138.                                                                 ((pprot >= 37) && (pprot <= 128)))) {
  1139.                                                                 fprintf(stderr, "ERROR -> invalid default packet protection method p = %d\n", pprot);
  1140.                                                                 return 1;
  1141.                                                         }
  1142.                                                         parameters->jpwl_pprot_tileno[0] = 0;
  1143.                                                         parameters->jpwl_pprot_packno[0] = 0;
  1144.                                                         parameters->jpwl_pprot[0] = pprot;
  1145.  
  1146.                                                 } else if (sscanf(token, "p%d=%d", &tile, &pprot) == 2) {
  1147.                                                         /* method specified from that tile on */
  1148.                                                         if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
  1149.                                                                 ((pprot >= 37) && (pprot <= 128)))) {
  1150.                                                                 fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
  1151.                                                                 return 1;
  1152.                                                         }
  1153.                                                         if (tile < 0) {
  1154.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
  1155.                                                                 return 1;
  1156.                                                         }
  1157.                                                         if (packspec < JPWL_MAX_NO_PACKSPECS) {
  1158.                                                                 parameters->jpwl_pprot_tileno[packspec] = tile;
  1159.                                                                 parameters->jpwl_pprot_packno[packspec] = 0;
  1160.                                                                 parameters->jpwl_pprot[packspec++] = pprot;
  1161.                                                         }
  1162.  
  1163.                                                 } else if (sscanf(token, "p%d:%d=%d", &tile, &pack, &pprot) == 3) {
  1164.                                                         /* method fully specified from that tile and that packet on */
  1165.                                                         if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
  1166.                                                                 ((pprot >= 37) && (pprot <= 128)))) {
  1167.                                                                 fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
  1168.                                                                 return 1;
  1169.                                                         }
  1170.                                                         if (tile < 0) {
  1171.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
  1172.                                                                 return 1;
  1173.                                                         }
  1174.                                                         if (pack < 0) {
  1175.                                                                 fprintf(stderr, "ERROR -> invalid packet number on protection method p = %d\n", pack);
  1176.                                                                 return 1;
  1177.                                                         }
  1178.                                                         if (packspec < JPWL_MAX_NO_PACKSPECS) {
  1179.                                                                 parameters->jpwl_pprot_tileno[packspec] = tile;
  1180.                                                                 parameters->jpwl_pprot_packno[packspec] = pack;
  1181.                                                                 parameters->jpwl_pprot[packspec++] = pprot;
  1182.                                                         }
  1183.  
  1184.                                                 } else if (sscanf(token, "p%d:%d", &tile, &pack) == 2) {
  1185.                                                         /* default method from that tile and that packet on */
  1186.                                                         if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
  1187.                                                                 ((pprot >= 37) && (pprot <= 128)))) {
  1188.                                                                 fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
  1189.                                                                 return 1;
  1190.                                                         }
  1191.                                                         if (tile < 0) {
  1192.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
  1193.                                                                 return 1;
  1194.                                                         }
  1195.                                                         if (pack < 0) {
  1196.                                                                 fprintf(stderr, "ERROR -> invalid packet number on protection method p = %d\n", pack);
  1197.                                                                 return 1;
  1198.                                                         }
  1199.                                                         if (packspec < JPWL_MAX_NO_PACKSPECS) {
  1200.                                                                 parameters->jpwl_pprot_tileno[packspec] = tile;
  1201.                                                                 parameters->jpwl_pprot_packno[packspec] = pack;
  1202.                                                                 parameters->jpwl_pprot[packspec++] = pprot;
  1203.                                                         }
  1204.  
  1205.                                                 } else if (sscanf(token, "p%d", &tile) == 1) {
  1206.                                                         /* default from a tile on */
  1207.                                                         if (tile < 0) {
  1208.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
  1209.                                                                 return 1;
  1210.                                                         }
  1211.                                                         if (packspec < JPWL_MAX_NO_PACKSPECS) {
  1212.                                                                 parameters->jpwl_pprot_tileno[packspec] = tile;
  1213.                                                                 parameters->jpwl_pprot_packno[packspec] = 0;
  1214.                                                                 parameters->jpwl_pprot[packspec++] = pprot;
  1215.                                                         }
  1216.  
  1217.  
  1218.                                                 } else if (!strcmp(token, "p")) {
  1219.                                                         /* all default */
  1220.                                                         parameters->jpwl_pprot_tileno[0] = 0;
  1221.                                                         parameters->jpwl_pprot_packno[0] = 0;
  1222.                                                         parameters->jpwl_pprot[0] = pprot;
  1223.  
  1224.                                                 } else {
  1225.                                                         fprintf(stderr, "ERROR -> invalid protection method selection = %s\n", token);
  1226.                                                         return 1;
  1227.                                                 };
  1228.  
  1229.                                         }
  1230.  
  1231.                                         /* search sensitivity method */
  1232.                                         if (*token == 's') {
  1233.  
  1234.                                                 static int tile = 0, tilespec = 0, lasttileno = 0;
  1235.  
  1236.                                                 sens = 0; /* predefined: relative error */
  1237.  
  1238.                                                 if(sscanf(token, "s=%d", &sens) == 1) {
  1239.                                                         /* Main header, specified */
  1240.                                                         if ((sens < -1) || (sens > 7)) {
  1241.                                                                 fprintf(stderr, "ERROR -> invalid main header sensitivity method s = %d\n", sens);
  1242.                                                                 return 1;
  1243.                                                         }
  1244.                                                         parameters->jpwl_sens_MH = sens;
  1245.  
  1246.                                                 } else if(sscanf(token, "s%d=%d", &tile, &sens) == 2) {
  1247.                                                         /* Tile part header, specified */
  1248.                                                         if ((sens < -1) || (sens > 7)) {
  1249.                                                                 fprintf(stderr, "ERROR -> invalid tile part header sensitivity method s = %d\n", sens);
  1250.                                                                 return 1;
  1251.                                                         }
  1252.                                                         if (tile < 0) {
  1253.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on sensitivity method t = %d\n", tile);
  1254.                                                                 return 1;
  1255.                                                         }
  1256.                                                         if (tilespec < JPWL_MAX_NO_TILESPECS) {
  1257.                                                                 parameters->jpwl_sens_TPH_tileno[tilespec] = lasttileno = tile;
  1258.                                                                 parameters->jpwl_sens_TPH[tilespec++] = sens;
  1259.                                                         }
  1260.  
  1261.                                                 } else if(sscanf(token, "s%d", &tile) == 1) {
  1262.                                                         /* Tile part header, unspecified */
  1263.                                                         if (tile < 0) {
  1264.                                                                 fprintf(stderr, "ERROR -> invalid tile part number on sensitivity method t = %d\n", tile);
  1265.                                                                 return 1;
  1266.                                                         }
  1267.                                                         if (tilespec < JPWL_MAX_NO_TILESPECS) {
  1268.                                                                 parameters->jpwl_sens_TPH_tileno[tilespec] = lasttileno = tile;
  1269.                                                                 parameters->jpwl_sens_TPH[tilespec++] = hprot;
  1270.                                                         }
  1271.  
  1272.                                                 } else if (!strcmp(token, "s")) {
  1273.                                                         /* Main header, unspecified */
  1274.                                                         parameters->jpwl_sens_MH = sens;
  1275.  
  1276.                                                 } else {
  1277.                                                         fprintf(stderr, "ERROR -> invalid sensitivity method selection = %s\n", token);
  1278.                                                         return 1;
  1279.                                                 };
  1280.  
  1281.                                                 parameters->jpwl_sens_size = 2; /* 2 bytes for default size */
  1282.                                         }
  1283.  
  1284.                                         /* search addressing size */
  1285.                                         if (*token == 'a') {
  1286.  
  1287.  
  1288.                                                 addr = 0; /* predefined: auto */
  1289.  
  1290.                                                 if(sscanf(token, "a=%d", &addr) == 1) {
  1291.                                                         /* Specified */
  1292.                                                         if ((addr != 0) && (addr != 2) && (addr != 4)) {
  1293.                                                                 fprintf(stderr, "ERROR -> invalid addressing size a = %d\n", addr);
  1294.                                                                 return 1;
  1295.                                                         }
  1296.                                                         parameters->jpwl_sens_addr = addr;
  1297.  
  1298.                                                 } else if (!strcmp(token, "a")) {
  1299.                                                         /* default */
  1300.                                                         parameters->jpwl_sens_addr = addr; /* auto for default size */
  1301.  
  1302.                                                 } else {
  1303.                                                         fprintf(stderr, "ERROR -> invalid addressing selection = %s\n", token);
  1304.                                                         return 1;
  1305.                                                 };
  1306.  
  1307.                                         }
  1308.  
  1309.                                         /* search sensitivity size */
  1310.                                         if (*token == 'z') {
  1311.  
  1312.  
  1313.                                                 size = 1; /* predefined: 1 byte */
  1314.  
  1315.                                                 if(sscanf(token, "z=%d", &size) == 1) {
  1316.                                                         /* Specified */
  1317.                                                         if ((size != 0) && (size != 1) && (size != 2)) {
  1318.                                                                 fprintf(stderr, "ERROR -> invalid sensitivity size z = %d\n", size);
  1319.                                                                 return 1;
  1320.                                                         }
  1321.                                                         parameters->jpwl_sens_size = size;
  1322.  
  1323.                                                 } else if (!strcmp(token, "a")) {
  1324.                                                         /* default */
  1325.                                                         parameters->jpwl_sens_size = size; /* 1 for default size */
  1326.  
  1327.                                                 } else {
  1328.                                                         fprintf(stderr, "ERROR -> invalid size selection = %s\n", token);
  1329.                                                         return 1;
  1330.                                                 };
  1331.  
  1332.                                         }
  1333.  
  1334.                                         /* search range method */
  1335.                                         if (*token == 'g') {
  1336.  
  1337.  
  1338.                                                 range = 0; /* predefined: 0 (packet) */
  1339.  
  1340.                                                 if(sscanf(token, "g=%d", &range) == 1) {
  1341.                                                         /* Specified */
  1342.                                                         if ((range < 0) || (range > 3)) {
  1343.                                                                 fprintf(stderr, "ERROR -> invalid sensitivity range method g = %d\n", range);
  1344.                                                                 return 1;
  1345.                                                         }
  1346.                                                         parameters->jpwl_sens_range = range;
  1347.  
  1348.                                                 } else if (!strcmp(token, "g")) {
  1349.                                                         /* default */
  1350.                                                         parameters->jpwl_sens_range = range;
  1351.  
  1352.                                                 } else {
  1353.                                                         fprintf(stderr, "ERROR -> invalid range selection = %s\n", token);
  1354.                                                         return 1;
  1355.                                                 };
  1356.  
  1357.                                         }
  1358.  
  1359.                                         /* next token or bust */
  1360.                                         token = strtok(NULL, ",");
  1361.                                 };
  1362.  
  1363.  
  1364.                                 /* some info */
  1365.                                 fprintf(stdout, "Info: JPWL capabilities enabled\n");
  1366.                                 parameters->jpwl_epc_on = true;
  1367.  
  1368.                         }
  1369.                         break;
  1370. #endif /* USE_JPWL */
  1371. /* <<UniPG */
  1372.  
  1373.                                 /* ------------------------------------------------------ */
  1374.  
  1375.                         default:
  1376.                                 fprintf(stderr, "ERROR -> Command line not valid\n");
  1377.                                 return 1;
  1378.                 }
  1379.         }
  1380.  
  1381.         /* check for possible errors */
  1382.         if (parameters->cp_cinema){
  1383.                 if(parameters->tcp_numlayers > 1){
  1384.                         parameters->cp_rsiz = STD_RSIZ;
  1385.         fprintf(stdout,"Warning: DC profiles do not allow more than one quality layer. The codestream created will not be compliant with the DC profile\n");
  1386.                 }
  1387.         }
  1388.         if(img_fol->set_imgdir == 1){
  1389.                 if(!(parameters->infile[0] == 0)){
  1390.                         fprintf(stderr, "Error: options -ImgDir and -i cannot be used together !!\n");
  1391.                         return 1;
  1392.                 }
  1393.                 if(img_fol->set_out_format == 0){
  1394.                         fprintf(stderr, "Error: When -ImgDir is used, -OutFor <FORMAT> must be used !!\n");
  1395.                         fprintf(stderr, "Only one format allowed! Valid formats are j2k and jp2!!\n");
  1396.                         return 1;
  1397.                 }
  1398.                 if(!((parameters->outfile[0] == 0))){
  1399.                         fprintf(stderr, "Error: options -ImgDir and -o cannot be used together !!\n");
  1400.                         fprintf(stderr, "Specify OutputFormat using -OutFor<FORMAT> !!\n");
  1401.                         return 1;
  1402.                 }
  1403.         }else{
  1404.                 if((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) {
  1405.                         fprintf(stderr, "Example: %s -i image.ppm  -o image.j2k\n",argv[0]);
  1406.                         fprintf(stderr, "    Try: %s -h\n",argv[0]);
  1407.                         return 1;
  1408.                 }
  1409.         }
  1410.  
  1411.         if (parameters->decod_format == RAW_DFMT && raw_cp->rawWidth == 0) {
  1412.                         fprintf(stderr,"\nError: invalid raw image parameters\n");
  1413.                         fprintf(stderr,"Please use the Format option -F:\n");
  1414.                         fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
  1415.                                                 fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
  1416.                         fprintf(stderr,"Aborting\n");
  1417.                         return 1;
  1418.         }
  1419.  
  1420.         if ((parameters->cp_disto_alloc || parameters->cp_fixed_alloc || parameters->cp_fixed_quality)
  1421.                 && (!(parameters->cp_disto_alloc ^ parameters->cp_fixed_alloc ^ parameters->cp_fixed_quality))) {
  1422.                 fprintf(stderr, "Error: options -r -q and -f cannot be used together !!\n");
  1423.                 return 1;
  1424.         }                               /* mod fixed_quality */
  1425.  
  1426.         /* if no rate entered, lossless by default */
  1427.         if (parameters->tcp_numlayers == 0) {
  1428.                 parameters->tcp_rates[0] = 0;   /* MOD antonin : losslessbug */
  1429.                 parameters->tcp_numlayers++;
  1430.                 parameters->cp_disto_alloc = 1;
  1431.         }
  1432.  
  1433.         if((parameters->cp_tx0 > parameters->image_offset_x0) || (parameters->cp_ty0 > parameters->image_offset_y0)) {
  1434.                 fprintf(stderr,
  1435.                         "Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
  1436.                         parameters->cp_tx0, parameters->image_offset_x0, parameters->cp_ty0, parameters->image_offset_y0);
  1437.                 return 1;
  1438.         }
  1439.  
  1440.         for (i = 0; i < parameters->numpocs; i++) {
  1441.                 if (parameters->POC[i].prg == -1) {
  1442.                         fprintf(stderr,
  1443.                                 "Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",
  1444.                                 i + 1);
  1445.                 }
  1446.         }
  1447.  
  1448.         return 0;
  1449. }
  1450.  
  1451. /* -------------------------------------------------------------------------- */
  1452.  
  1453. /**
  1454. sample error callback expecting a FILE* client object
  1455. */
  1456. void error_callback(const char *msg, void *client_data) {
  1457.         FILE *stream = (FILE*)client_data;
  1458.         fprintf(stream, "[ERROR] %s", msg);
  1459. }
  1460. /**
  1461. sample warning callback expecting a FILE* client object
  1462. */
  1463. void warning_callback(const char *msg, void *client_data) {
  1464.         FILE *stream = (FILE*)client_data;
  1465.         fprintf(stream, "[WARNING] %s", msg);
  1466. }
  1467. /**
  1468. sample debug callback expecting a FILE* client object
  1469. */
  1470. void info_callback(const char *msg, void *client_data) {
  1471.         FILE *stream = (FILE*)client_data;
  1472.         fprintf(stream, "[INFO] %s", msg);
  1473. }
  1474.  
  1475. /* -------------------------------------------------------------------------- */
  1476.  
  1477. int main(int argc, char **argv) {
  1478.         bool bSuccess;
  1479.         opj_cparameters_t parameters;   /* compression parameters */
  1480.         img_fol_t img_fol;
  1481.         opj_event_mgr_t event_mgr;              /* event manager */
  1482.         opj_image_t *image = NULL;
  1483.         int i,num_images;
  1484.         int imageno;
  1485.         dircnt_t *dirptr;
  1486.         raw_cparameters_t raw_cp;
  1487.         opj_codestream_info_t cstr_info;                /* Codestream information structure */
  1488.         char indexfilename[OPJ_PATH_LEN];       /* index file name */
  1489.  
  1490.         /*
  1491.         configure the event callbacks (not required)
  1492.         setting of each callback is optionnal
  1493.         */
  1494.         memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
  1495.         event_mgr.error_handler = error_callback;
  1496.         event_mgr.warning_handler = warning_callback;
  1497.         event_mgr.info_handler = info_callback;
  1498.  
  1499.         /* set encoding parameters to default values */
  1500.         opj_set_default_encoder_parameters(&parameters);
  1501.  
  1502.         /* Initialize indexfilename and img_fol */
  1503.         *indexfilename = 0;
  1504.         memset(&img_fol,0,sizeof(img_fol_t));
  1505.  
  1506.         /* parse input and get user encoding parameters */
  1507.         if(parse_cmdline_encoder(argc, argv, &parameters,&img_fol, &raw_cp, indexfilename) == 1) {
  1508.                 return 1;
  1509.         }
  1510.  
  1511.         if (parameters.cp_cinema){
  1512.                 img_fol.rates = (float*)malloc(parameters.tcp_numlayers * sizeof(float));
  1513.                 for(i=0; i< parameters.tcp_numlayers; i++){
  1514.                         img_fol.rates[i] = parameters.tcp_rates[i];
  1515.                 }
  1516.                 cinema_parameters(&parameters);
  1517.         }
  1518.  
  1519.         /* Create comment for codestream */
  1520.         if(parameters.cp_comment == NULL) {
  1521.     const char comment[] = "Created by OpenJPEG version ";
  1522.                 const size_t clen = strlen(comment);
  1523.     const char *version = opj_version();
  1524. /* UniPG>> */
  1525. #ifdef USE_JPWL
  1526.                 parameters.cp_comment = (char*)malloc(clen+strlen(version)+11);
  1527.                 sprintf(parameters.cp_comment,"%s%s with JPWL", comment, version);
  1528. #else
  1529.                 parameters.cp_comment = (char*)malloc(clen+strlen(version)+1);
  1530.                 sprintf(parameters.cp_comment,"%s%s", comment, version);
  1531. #endif
  1532. /* <<UniPG */
  1533.         }
  1534.  
  1535.         /* Read directory if necessary */
  1536.         if(img_fol.set_imgdir==1){
  1537.                 num_images=get_num_images(img_fol.imgdirpath);
  1538.                 dirptr=(dircnt_t*)malloc(sizeof(dircnt_t));
  1539.                 if(dirptr){
  1540.                         dirptr->filename_buf = (char*)malloc(num_images*OPJ_PATH_LEN*sizeof(char));     // Stores at max 10 image file names
  1541.                         dirptr->filename = (char**) malloc(num_images*sizeof(char*));
  1542.                         if(!dirptr->filename_buf){
  1543.                                 return 0;
  1544.                         }
  1545.                         for(i=0;i<num_images;i++){
  1546.                                 dirptr->filename[i] = dirptr->filename_buf + i*OPJ_PATH_LEN;
  1547.                         }
  1548.                 }
  1549.                 if(load_images(dirptr,img_fol.imgdirpath)==1){
  1550.                         return 0;
  1551.                 }
  1552.                 if (num_images==0){
  1553.                         fprintf(stdout,"Folder is empty\n");
  1554.                         return 0;
  1555.                 }
  1556.         }else{
  1557.                 num_images=1;
  1558.         }
  1559.         /*Encoding image one by one*/
  1560.         for(imageno=0;imageno<num_images;imageno++)     {
  1561.                 image = NULL;
  1562.                 fprintf(stderr,"\n");
  1563.  
  1564.                 if(img_fol.set_imgdir==1){
  1565.                         if (get_next_file(imageno, dirptr,&img_fol, &parameters)) {
  1566.                                 fprintf(stderr,"skipping file...\n");
  1567.                                 continue;
  1568.                         }
  1569.                 }
  1570.                 switch(parameters.decod_format) {
  1571.                         case PGX_DFMT:
  1572.                                 break;
  1573.                         case PXM_DFMT:
  1574.                                 break;
  1575.                         case BMP_DFMT:
  1576.                                 break;
  1577.                         case TIF_DFMT:
  1578.                                 break;
  1579.                         case RAW_DFMT:
  1580.                                 break;
  1581.                         case TGA_DFMT:
  1582.                                 break;
  1583.                         case PNG_DFMT:
  1584.                                 break;
  1585.                         default:
  1586.                                 fprintf(stderr,"skipping file...\n");
  1587.                                 continue;
  1588.                 }
  1589.  
  1590.                         /* decode the source image */
  1591.                         /* ----------------------- */
  1592.  
  1593.                         switch (parameters.decod_format) {
  1594.                                 case PGX_DFMT:
  1595.                                         image = pgxtoimage(parameters.infile, &parameters);
  1596.                                         if (!image) {
  1597.                                                 fprintf(stderr, "Unable to load pgx file\n");
  1598.                                                 return 1;
  1599.                                         }
  1600.                                         break;
  1601.  
  1602.                                 case PXM_DFMT:
  1603.                                         image = pnmtoimage(parameters.infile, &parameters);
  1604.                                         if (!image) {
  1605.                                                 fprintf(stderr, "Unable to load pnm file\n");
  1606.                                                 return 1;
  1607.                                         }
  1608.                                         break;
  1609.  
  1610.                                 case BMP_DFMT:
  1611.                                         image = bmptoimage(parameters.infile, &parameters);
  1612.                                         if (!image) {
  1613.                                                 fprintf(stderr, "Unable to load bmp file\n");
  1614.                                                 return 1;
  1615.                                         }
  1616.                                         break;
  1617. #ifdef HAVE_LIBTIFF
  1618.                                 case TIF_DFMT:
  1619.                                         image = tiftoimage(parameters.infile, &parameters);
  1620.                                         if (!image) {
  1621.                                                 fprintf(stderr, "Unable to load tiff file\n");
  1622.                                                 return 1;
  1623.                                         }
  1624.                                 break;
  1625. #endif /* HAVE_LIBTIFF */
  1626.                                 case RAW_DFMT:
  1627.                                         image = rawtoimage(parameters.infile, &parameters, &raw_cp);
  1628.                                         if (!image) {
  1629.                                                 fprintf(stderr, "Unable to load raw file\n");
  1630.                                                 return 1;
  1631.                                         }
  1632.                                 break;
  1633.  
  1634.                                 case TGA_DFMT:
  1635.                                         image = tgatoimage(parameters.infile, &parameters);
  1636.                                         if (!image) {
  1637.                                                 fprintf(stderr, "Unable to load tga file\n");
  1638.                                                 return 1;
  1639.                                         }
  1640.                                 break;
  1641. #ifdef HAVE_LIBPNG
  1642.                                 case PNG_DFMT:
  1643.                                         image = pngtoimage(parameters.infile, &parameters);
  1644.                                         if (!image) {
  1645.                                                 fprintf(stderr, "Unable to load png file\n");
  1646.                                                 return 1;
  1647.                                         }
  1648.                                         break;
  1649. #endif /* HAVE_LIBPNG */
  1650.                 }
  1651. /* Can happen if input file is TIFF or PNG
  1652.  * and HAVE_LIBTIF or HAVE_LIBPNG is undefined
  1653. */
  1654.                         if( !image)
  1655.                    {
  1656.                         fprintf(stderr, "Unable to load file: got no image\n");
  1657.                         return 1;
  1658.                    }
  1659.                         /* Decide if MCT should be used */
  1660.                         parameters.tcp_mct = image->numcomps == 3 ? 1 : 0;
  1661.  
  1662.                         if(parameters.cp_cinema){
  1663.                                 cinema_setup_encoder(&parameters,image,&img_fol);
  1664.                         }
  1665.  
  1666.                         /* encode the destination image */
  1667.                         /* ---------------------------- */
  1668.  
  1669.                         if (parameters.cod_format == J2K_CFMT) {        /* J2K format output */
  1670.                                 int codestream_length;
  1671.                                 opj_cio_t *cio = NULL;
  1672.                                 FILE *f = NULL;
  1673.  
  1674.                                 /* get a J2K compressor handle */
  1675.                                 opj_cinfo_t* cinfo = opj_create_compress(CODEC_J2K);
  1676.  
  1677.                                 /* catch events using our callbacks and give a local context */
  1678.                                 opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
  1679.  
  1680.                                 /* setup the encoder parameters using the current image and user parameters */
  1681.                                 opj_setup_encoder(cinfo, &parameters, image);
  1682.  
  1683.                                 /* open a byte stream for writing */
  1684.                                 /* allocate memory for all tiles */
  1685.                                 cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
  1686.  
  1687.                                 /* encode the image */
  1688.                                 if (*indexfilename)                                     // If need to extract codestream information
  1689.                                         bSuccess = opj_encode_with_info(cinfo, cio, image, &cstr_info);
  1690.                                 else
  1691.                                         bSuccess = opj_encode(cinfo, cio, image, NULL);
  1692.                                 if (!bSuccess) {
  1693.                                         opj_cio_close(cio);
  1694.                                         fprintf(stderr, "failed to encode image\n");
  1695.                                         return 1;
  1696.                                 }
  1697.                                 codestream_length = cio_tell(cio);
  1698.  
  1699.                                 /* write the buffer to disk */
  1700.                                 f = fopen(parameters.outfile, "wb");
  1701.                                 if (!f) {
  1702.                                         fprintf(stderr, "failed to open %s for writing\n", parameters.outfile);
  1703.                                         return 1;
  1704.                                 }
  1705.                                 fwrite(cio->buffer, 1, codestream_length, f);
  1706.                                 fclose(f);
  1707.  
  1708.                                 fprintf(stderr,"Generated outfile %s\n",parameters.outfile);
  1709.                                 /* close and free the byte stream */
  1710.                                 opj_cio_close(cio);
  1711.  
  1712.                                 /* Write the index to disk */
  1713.                                 if (*indexfilename) {
  1714.                                         bSuccess = write_index_file(&cstr_info, indexfilename);
  1715.                                         if (bSuccess) {
  1716.                                                 fprintf(stderr, "Failed to output index file into [%s]\n", indexfilename);
  1717.                                         }
  1718.                                 }
  1719.  
  1720.                                 /* free remaining compression structures */
  1721.                                 opj_destroy_compress(cinfo);
  1722.                                 if (*indexfilename)
  1723.                                         opj_destroy_cstr_info(&cstr_info);
  1724.                         } else {                        /* JP2 format output */
  1725.                                 int codestream_length;
  1726.                                 opj_cio_t *cio = NULL;
  1727.                                 FILE *f = NULL;
  1728.  
  1729.                                 /* get a JP2 compressor handle */
  1730.                                 opj_cinfo_t* cinfo = opj_create_compress(CODEC_JP2);
  1731.  
  1732.                                 /* catch events using our callbacks and give a local context */
  1733.                                 opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
  1734.  
  1735.                                 /* setup the encoder parameters using the current image and using user parameters */
  1736.                                 opj_setup_encoder(cinfo, &parameters, image);
  1737.  
  1738.                                 /* open a byte stream for writing */
  1739.                                 /* allocate memory for all tiles */
  1740.                                 cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
  1741.  
  1742.                                 /* encode the image */
  1743.                                 if (*indexfilename)                                     // If need to extract codestream information
  1744.                                         bSuccess = opj_encode_with_info(cinfo, cio, image, &cstr_info);
  1745.                                 else
  1746.                                         bSuccess = opj_encode(cinfo, cio, image, NULL);
  1747.                                 if (!bSuccess) {
  1748.                                         opj_cio_close(cio);
  1749.                                         fprintf(stderr, "failed to encode image\n");
  1750.                                         return 1;
  1751.                                 }
  1752.                                 codestream_length = cio_tell(cio);
  1753.  
  1754.                                 /* write the buffer to disk */
  1755.                                 f = fopen(parameters.outfile, "wb");
  1756.                                 if (!f) {
  1757.                                         fprintf(stderr, "failed to open %s for writing\n", parameters.outfile);
  1758.                                         return 1;
  1759.                                 }
  1760.                                 fwrite(cio->buffer, 1, codestream_length, f);
  1761.                                 fclose(f);
  1762.                                 fprintf(stderr,"Generated outfile %s\n",parameters.outfile);
  1763.                                 /* close and free the byte stream */
  1764.                                 opj_cio_close(cio);
  1765.  
  1766.                                 /* Write the index to disk */
  1767.                                 if (*indexfilename) {
  1768.                                         bSuccess = write_index_file(&cstr_info, indexfilename);
  1769.                                         if (bSuccess) {
  1770.                                                 fprintf(stderr, "Failed to output index file\n");
  1771.                                         }
  1772.                                 }
  1773.  
  1774.                                 /* free remaining compression structures */
  1775.                                 opj_destroy_compress(cinfo);
  1776.                                 if (*indexfilename)
  1777.                                         opj_destroy_cstr_info(&cstr_info);
  1778.                         }
  1779.  
  1780.                         /* free image data */
  1781.                         opj_image_destroy(image);
  1782.         }
  1783.  
  1784.         /* free user parameters structure */
  1785.   if(parameters.cp_comment) free(parameters.cp_comment);
  1786.         if(parameters.cp_matrice) free(parameters.cp_matrice);
  1787.  
  1788.         return 0;
  1789. }
  1790.