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