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