#include <string.h>
#include <stdlib.h>
#include <math.h>
+#include <time.h>
#ifdef _WIN32
#include "windirent.h"
#include "color.h"
#include "format_defs.h"
+#include "opj_string.h"
typedef struct dircnt{
/** Buffer for holding images read from Directory*/
int decod_format;
/** output file format 0: PGX, 1: PxM, 2: BMP */
int cod_format;
+ /** index file name */
+ char indexfilename[OPJ_PATH_LEN];
/** Decoding area left boundary */
OPJ_UINT32 DA_x0;
int force_rgb;
/* upsample components according to their dx/dy values */
int upsample;
+ /* split output components to different files */
+ int split_pnm;
+ /** number of threads */
+ int num_threads;
}opj_decompress_parameters;
/* -------------------------------------------------------------------------- */
char get_next_file(int imageno,dircnt_t *dirptr,img_fol_t *img_fol, opj_decompress_parameters *parameters);
static int infile_format(const char *fname);
-int parse_cmdline_decoder(int argc, char **argv, opj_decompress_parameters *parameters,img_fol_t *img_fol, char *indexfilename);
+int parse_cmdline_decoder(int argc, char **argv, opj_decompress_parameters *parameters,img_fol_t *img_fol);
int parse_DA_values( char* inArg, unsigned int *DA_x0, unsigned int *DA_y0, unsigned int *DA_x1, unsigned int *DA_y1);
static opj_image_t* convert_gray_to_rgb(opj_image_t* original);
" Image file Directory path \n"
" -OutFor <PBM|PGM|PPM|PNM|PAM|PGX|PNG|BMP|TIF|RAW|RAWL|TGA>\n"
" REQUIRED only if -ImgDir is used\n"
- " Output format for decompressed images.\n"
- " -i <compressed file>\n"
+ " Output format for decompressed images.\n");
+ fprintf(stdout," -i <compressed file>\n"
" REQUIRED only if an Input image directory is not specified\n"
" Currently accepts J2K-files, JP2-files and JPT-files. The file type\n"
- " is identified based on its suffix.\n"
- " -o <decompressed file>\n"
+ " is identified based on its suffix.\n");
+ fprintf(stdout," -o <decompressed file>\n"
" REQUIRED\n"
" Currently accepts formats specified above (see OutFor option)\n"
" Binary data is written to the file (not ascii). If a PGX\n"
" components: an indice starting from 0 will then be appended to the\n"
" output filename, just before the \"pgx\" extension. If a PGM filename\n"
" is given and there are more than one component, only the first component\n"
- " will be written to the file.\n"
- " -r <reduce factor>\n"
+ " will be written to the file.\n");
+ fprintf(stdout," -r <reduce factor>\n"
" Set the number of highest resolution levels to be discarded. The\n"
" image resolution is effectively divided by 2 to the power of the\n"
" number of discarded levels. The reduce factor is limited by the\n"
" -l <number of quality layers to decode>\n"
" Set the maximum number of quality layers to decode. If there are\n"
" less quality layers than the specified number, all the quality layers\n"
- " are decoded.\n"
- " -x \n"
+ " are decoded.\n");
+ fprintf(stdout," -x \n"
" Create an index file *.Idx (-x index_name.Idx) \n"
" -d <x0,y0,x1,y1>\n"
" OPTIONAL\n"
" -t <tile_number>\n"
" OPTIONAL\n"
" Set the tile number of the decoded tile. Follow the JPEG2000 convention from left-up to bottom-up\n"
- " By default all tiles are decoded.\n"
- " -p <comp 0 precision>[C|S][,<comp 1 precision>[C|S][,...]]\n"
+ " By default all tiles are decoded.\n");
+ fprintf(stdout," -p <comp 0 precision>[C|S][,<comp 1 precision>[C|S][,...]]\n"
" OPTIONAL\n"
- " Force the precision (bit depth) of components.\n"
- " There shall be at least 1 value. Theres no limit on the number of values (comma separated, last values ignored if too much values).\n"
+ " Force the precision (bit depth) of components.\n");
+ fprintf(stdout," There shall be at least 1 value. Theres no limit on the number of values (comma separated, last values ignored if too much values).\n"
" If there are less values than components, the last value is used for remaining components.\n"
" If 'C' is specified (default), values are clipped.\n"
" If 'S' is specified, values are scaled.\n"
- " A 0 value can be specified (meaning original bit depth).\n"
- " -force-rgb\n"
+ " A 0 value can be specified (meaning original bit depth).\n");
+ fprintf(stdout," -force-rgb\n"
" Force output image colorspace to RGB\n"
" -upsample\n"
" Downsampled components will be upsampled to image size\n"
- "\n");
+ " -split-pnm\n"
+ " Split output components to different files when writing to PNM\n");
+ if( opj_has_thread_support() ) {
+ fprintf(stdout," -threads <num_threads>\n"
+ " Number of threads to use for decoding.\n");
+ }
/* UniPG>> */
#ifdef USE_JPWL
fprintf(stdout," -W <options>\n"
for(;;)
{
- OPJ_UINT32 prec;
+ int prec;
char mode;
char comma;
int count;
count = 3;
}
if (count == 3) {
- if (prec > 32U) {
+ if ((prec < 1) || (prec > 32)) {
fprintf(stderr,"Invalid precision %d in precision option %s\n", prec, option);
l_result = OPJ_FALSE;
break;
if (parameters->precision == NULL) {
/* first one */
- parameters->precision = malloc(sizeof(opj_precision));
+ parameters->precision = (opj_precision *)malloc(sizeof(opj_precision));
if (parameters->precision == NULL) {
fprintf(stderr,"Could not allocate memory for precision option\n");
l_result = OPJ_FALSE;
break;
}
- l_new = realloc(parameters->precision, l_new_size * sizeof(opj_precision));
+ l_new = (opj_precision *)realloc(parameters->precision, l_new_size * sizeof(opj_precision));
if (l_new == NULL) {
fprintf(stderr,"Could not allocate memory for precision option\n");
l_result = OPJ_FALSE;
parameters->precision = l_new;
}
- parameters->precision[parameters->nb_precision].prec = prec;
+ parameters->precision[parameters->nb_precision].prec = (OPJ_UINT32)prec;
switch (mode) {
case 'C':
parameters->precision[parameters->nb_precision].mode = OPJ_PREC_MODE_CLIP;
continue;
num_images++;
}
+ closedir(dir);
return num_images;
}
strcpy(dirptr->filename[i],content->d_name);
i++;
}
+ closedir(dir);
return 0;
}
unsigned int i;
static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp","tif", "raw", "rawl", "tga", "png", "j2k", "jp2", "jpt", "j2c", "jpc" };
static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, RAWL_DFMT, TGA_DFMT, PNG_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT, J2K_CFMT, J2K_CFMT };
- char * ext = strrchr(filename, '.');
+ const char * ext = strrchr(filename, '.');
if (ext == NULL)
return -1;
ext++;
parameters->decod_format = infile_format(infilename);
if (parameters->decod_format == -1)
return 1;
- strncpy(parameters->infile, infilename, sizeof(infilename));
+ if (opj_strcpy_s(parameters->infile, sizeof(parameters->infile), infilename) != 0) {
+ return 1;
+ }
/*Set output file*/
strcpy(temp_ofname,strtok(image_filename,"."));
}
if(img_fol->set_out_format==1){
sprintf(outfilename,"%s/%s.%s",img_fol->imgdirpath,temp_ofname,img_fol->out_format);
- strncpy(parameters->outfile, outfilename, sizeof(outfilename));
+ if (opj_strcpy_s(parameters->outfile, sizeof(parameters->outfile), outfilename) != 0) {
+ return 1;
+ }
}
return 0;
}
* Parse the command line
*/
/* -------------------------------------------------------------------------- */
-int parse_cmdline_decoder(int argc, char **argv, opj_decompress_parameters *parameters,img_fol_t *img_fol, char *indexfilename) {
+int parse_cmdline_decoder(int argc, char **argv, opj_decompress_parameters *parameters,img_fol_t *img_fol) {
/* parse the command line */
int totlen, c;
opj_option_t long_option[]={
- {"ImgDir", REQ_ARG, NULL ,'y'},
- {"OutFor", REQ_ARG, NULL ,'O'},
- {"force-rgb", NO_ARG, &(parameters->force_rgb), 1},
- {"upsample", NO_ARG, &(parameters->upsample), 1}
+ {"ImgDir", REQ_ARG, NULL,'y'},
+ {"OutFor", REQ_ARG, NULL,'O'},
+ {"force-rgb", NO_ARG, NULL, 1},
+ {"upsample", NO_ARG, NULL, 1},
+ {"split-pnm", NO_ARG, NULL, 1},
+ {"threads", REQ_ARG, NULL, 'T'}
};
const char optlist[] = "i:o:r:l:x:d:t:p:"
#endif /* USE_JPWL */
/* <<UniPG */
"h" ;
+
+ long_option[2].flag = &(parameters->force_rgb);
+ long_option[3].flag = &(parameters->upsample);
+ long_option[4].flag = &(parameters->split_pnm);
totlen=sizeof(long_option);
opj_reset_options_reading();
img_fol->set_out_format = 0;
infile);
return 1;
}
- strncpy(parameters->infile, infile, sizeof(parameters->infile)-1);
+ if (opj_strcpy_s(parameters->infile, sizeof(parameters->infile), infile) != 0) {
+ fprintf(stderr, "[ERROR] Path is too long\n");
+ return 1;
+ }
}
break;
case PNG_DFMT:
break;
default:
- fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outfile);
+ fprintf(stderr, "Unknown output format image %s [only *.png, *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!!\n", outfile);
return 1;
}
- strncpy(parameters->outfile, outfile, sizeof(parameters->outfile)-1);
+ if (opj_strcpy_s(parameters->outfile, sizeof(parameters->outfile), outfile) != 0) {
+ fprintf(stderr, "[ERROR] Path is too long\n");
+ return 1;
+ }
}
break;
img_fol->out_format = "png";
break;
default:
- fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outformat);
+ fprintf(stderr, "Unknown output format image %s [only *.png, *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!!\n", outformat);
return 1;
break;
}
case 'y': /* Image Directory path */
{
img_fol->imgdirpath = (char*)malloc(strlen(opj_optarg) + 1);
+ if(img_fol->imgdirpath == NULL){
+ return 1;
+ }
strcpy(img_fol->imgdirpath,opj_optarg);
img_fol->set_imgdir=1;
}
case 'd': /* Input decode ROI */
{
- int size_optarg = (int)strlen(opj_optarg) + 1;
- char *ROI_values = (char*) malloc((size_t)size_optarg);
+ size_t size_optarg = (size_t)strlen(opj_optarg) + 1U;
+ char *ROI_values = (char*) malloc(size_optarg);
+ if (ROI_values == NULL) {
+ fprintf(stderr, "[ERROR] Couldn't allocate memory\n");
+ return 1;
+ }
ROI_values[0] = '\0';
- strncpy(ROI_values, opj_optarg, strlen(opj_optarg));
- ROI_values[strlen(opj_optarg)] = '\0';
+ memcpy(ROI_values, opj_optarg, size_optarg);
/*printf("ROI_values = %s [%d / %d]\n", ROI_values, strlen(ROI_values), size_optarg ); */
parse_DA_values( ROI_values, ¶meters->DA_x0, ¶meters->DA_y0, ¶meters->DA_x1, ¶meters->DA_y1);
case 'x': /* Creation of index file */
{
- char *index = opj_optarg;
- strncpy(indexfilename, index, OPJ_PATH_LEN);
+ if (opj_strcpy_s(parameters->indexfilename, sizeof(parameters->indexfilename), opj_optarg) != 0) {
+ fprintf(stderr, "[ERROR] Path is too long\n");
+ return 1;
+ }
}
break;
break;
#endif /* USE_JPWL */
/* <<UniPG */
+
+ /* ----------------------------------------------------- */
+ case 'T': /* Number of threads */
+ {
+ if( strcmp(opj_optarg, "ALL_CPUS") == 0 )
+ {
+ parameters->num_threads = opj_get_num_cpus();
+ if( parameters->num_threads == 1 )
+ parameters->num_threads = 0;
+ }
+ else
+ {
+ sscanf(opj_optarg, "%d", ¶meters->num_threads);
+ }
+ }
+ break;
/* ----------------------------------------------------- */
/* t is the high resolution performance counter (see MSDN) */
QueryPerformanceCounter ( & t ) ;
return freq.QuadPart ? (t.QuadPart / (OPJ_FLOAT64)freq.QuadPart) : 0;
+#elif defined(__linux)
+ struct timespec ts;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ return( (OPJ_FLOAT64)ts.tv_sec + (OPJ_FLOAT64)ts.tv_nsec * 1e-9 );
#else
- /* Unix or Linux: use resource usage */
- struct rusage t;
- OPJ_FLOAT64 procTime;
- /* (1) Get the rusage data structure at this moment (man getrusage) */
- getrusage(0,&t);
- /* (2) What is the elapsed time ? - CPU time = User time + System time */
+ /* Unix : use resource usage */
+ /* FIXME: this counts the total CPU time, instead of the user perceived time */
+ struct rusage t;
+ OPJ_FLOAT64 procTime;
+ /* (1) Get the rusage data structure at this moment (man getrusage) */
+ getrusage(0,&t);
+ /* (2) What is the elapsed time ? - CPU time = User time + System time */
/* (2a) Get the seconds */
- procTime = (OPJ_FLOAT64)(t.ru_utime.tv_sec + t.ru_stime.tv_sec);
- /* (2b) More precisely! Get the microseconds part ! */
- return ( procTime + (OPJ_FLOAT64)(t.ru_utime.tv_usec + t.ru_stime.tv_usec) * 1e-6 ) ;
+ procTime = (OPJ_FLOAT64)(t.ru_utime.tv_sec + t.ru_stime.tv_sec);
+ /* (2b) More precisely! Get the microseconds part ! */
+ return ( procTime + (OPJ_FLOAT64)(t.ru_utime.tv_usec + t.ru_stime.tv_usec) * 1e-6 ) ;
#endif
}
l_dst += l_new_cmp->w;
}
- if(l_new_cmp->h > (l_org_cmp->dy - 1U)) { /* check substraction overflow for really small images */
+ if(l_new_cmp->h > (l_org_cmp->dy - 1U)) { /* check subtraction overflow for really small images */
for (; y < l_new_cmp->h - (l_org_cmp->dy - 1U); y += l_org_cmp->dy) {
OPJ_UINT32 x, dy;
OPJ_UINT32 xorg;
for (x = 0U; x < xoff; ++x) {
l_dst[x] = 0;
}
- if (l_new_cmp->w > (l_org_cmp->dx - 1U)) { /* check substraction overflow for really small images */
+ if (l_new_cmp->w > (l_org_cmp->dx - 1U)) { /* check subtraction overflow for really small images */
for (; x < l_new_cmp->w - (l_org_cmp->dx - 1U); x += l_org_cmp->dx, ++xorg) {
OPJ_UINT32 dx;
for (dx = 0U; dx < l_org_cmp->dx; ++dx) {
for (x = 0U; x < xoff; ++x) {
l_dst[x] = 0;
}
- if (l_new_cmp->w > (l_org_cmp->dx - 1U)) { /* check substraction overflow for really small images */
+ if (l_new_cmp->w > (l_org_cmp->dx - 1U)) { /* check subtraction overflow for really small images */
for (; x < l_new_cmp->w - (l_org_cmp->dx - 1U); x += l_org_cmp->dx, ++xorg) {
OPJ_UINT32 dx;
for (dx = 0U; dx < l_org_cmp->dx; ++dx) {
opj_codec_t* l_codec = NULL; /* Handle to a decompressor */
opj_codestream_index_t* cstr_index = NULL;
- char indexfilename[OPJ_PATH_LEN]; /* index file name */
-
OPJ_INT32 num_images, imageno;
img_fol_t img_fol;
dircnt_t *dirptr = NULL;
/* set decoding parameters to default values */
set_default_parameters(¶meters);
- /* FIXME Initialize indexfilename and img_fol */
- *indexfilename = 0;
-
/* Initialize img_fol */
memset(&img_fol,0,sizeof(img_fol_t));
/* parse input and get user encoding parameters */
- if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol, indexfilename) == 1) {
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
+ if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol) == 1) {
+ failed = 1; goto fin;
}
/* Initialize reading of directory */
num_images=get_num_images(img_fol.imgdirpath);
dirptr=(dircnt_t*)malloc(sizeof(dircnt_t));
- if(dirptr){
- dirptr->filename_buf = (char*)malloc((size_t)num_images*OPJ_PATH_LEN*sizeof(char)); /* Stores at max 10 image file names*/
- dirptr->filename = (char**) malloc((size_t)num_images*sizeof(char*));
+ if(!dirptr){
+ destroy_parameters(¶meters);
+ return EXIT_FAILURE;
+ }
+ dirptr->filename_buf = (char*)malloc((size_t)num_images*OPJ_PATH_LEN*sizeof(char)); /* Stores at max 10 image file names*/
+ if(!dirptr->filename_buf){
+ failed = 1; goto fin;
+ }
+
+ dirptr->filename = (char**) malloc((size_t)num_images*sizeof(char*));
- if(!dirptr->filename_buf){
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
- }
- for(it_image=0;it_image<num_images;it_image++){
- dirptr->filename[it_image] = dirptr->filename_buf + it_image*OPJ_PATH_LEN;
- }
+ if(!dirptr->filename){
+ failed = 1; goto fin;
}
+ for(it_image=0;it_image<num_images;it_image++){
+ dirptr->filename[it_image] = dirptr->filename_buf + it_image*OPJ_PATH_LEN;
+ }
+
if(load_images(dirptr,img_fol.imgdirpath)==1){
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
if (num_images==0){
fprintf(stdout,"Folder is empty\n");
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
}else{
num_images=1;
l_stream = opj_stream_create_default_file_stream(parameters.infile,1);
if (!l_stream){
fprintf(stderr, "ERROR -> failed to create the stream from the file %s\n", parameters.infile);
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
/* decode the JPEG2000 stream */
/* Setup the decoder decoding parameters using user parameters */
if ( !opj_setup_decoder(l_codec, &(parameters.core)) ){
fprintf(stderr, "ERROR -> opj_decompress: failed to setup the decoder\n");
- destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
+ }
+
+ if( parameters.num_threads >= 1 && !opj_codec_set_threads(l_codec, parameters.num_threads) ) {
+ fprintf(stderr, "ERROR -> opj_decompress: failed to set number of threads\n");
+ opj_stream_destroy(l_stream);
+ opj_destroy_codec(l_codec);
+ failed = 1; goto fin;
}
-
/* Read the main header of the codestream and if necessary the JP2 boxes*/
if(! opj_read_header(l_stream, l_codec, &image)){
fprintf(stderr, "ERROR -> opj_decompress: failed to read the header\n");
- destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
if (!parameters.nb_tile_to_decode) {
if (!opj_set_decode_area(l_codec, image, (OPJ_INT32)parameters.DA_x0,
(OPJ_INT32)parameters.DA_y0, (OPJ_INT32)parameters.DA_x1, (OPJ_INT32)parameters.DA_y1)){
fprintf(stderr, "ERROR -> opj_decompress: failed to set the decoded area\n");
- destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
/* Get the decoded image */
if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) {
fprintf(stderr,"ERROR -> opj_decompress: failed to decode image!\n");
- destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
}
else {
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}*/
if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to decode tile!\n");
- destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
fprintf(stdout, "tile %d is decoded!\n\n", parameters.tile_index);
}
/* Close the byte stream */
opj_stream_destroy(l_stream);
- if(image->color_space == OPJ_CLRSPC_SYCC){
- color_sycc_to_rgb(image); /* FIXME */
- }
-
if( image->color_space != OPJ_CLRSPC_SYCC
&& image->numcomps == 3 && image->comps[0].dx == image->comps[0].dy
&& image->comps[1].dx != 1 )
else if (image->numcomps <= 2)
image->color_space = OPJ_CLRSPC_GRAY;
+ if(image->color_space == OPJ_CLRSPC_SYCC){
+ color_sycc_to_rgb(image);
+ }
+ else if((image->color_space == OPJ_CLRSPC_CMYK) && (parameters.cod_format != TIF_DFMT)){
+ color_cmyk_to_rgb(image);
+ }
+ else if(image->color_space == OPJ_CLRSPC_EYCC){
+ color_esycc_to_rgb(image);
+ }
+
if(image->icc_profile_buf) {
#if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
- color_apply_icc_profile(image); /* FIXME */
+ if(image->icc_profile_len)
+ color_apply_icc_profile(image);
+ else
+ color_cielab_to_rgb(image);
#endif
free(image->icc_profile_buf);
image->icc_profile_buf = NULL; image->icc_profile_len = 0;
image = upsample_image_components(image);
if (image == NULL) {
fprintf(stderr, "ERROR -> opj_decompress: failed to upsample image components!\n");
- destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
}
}
if (image == NULL) {
fprintf(stderr, "ERROR -> opj_decompress: failed to convert to RGB image!\n");
- destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
- return EXIT_FAILURE;
+ failed = 1; goto fin;
}
}
/* ------------------- */
switch (parameters.cod_format) {
case PXM_DFMT: /* PNM PGM PPM */
- if (imagetopnm(image, parameters.outfile)) {
+ if (imagetopnm(image, parameters.outfile, parameters.split_pnm)) {
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
/* destroy the codestream index */
opj_destroy_cstr_index(&cstr_index);
- if(failed) remove(parameters.outfile);
+ if(failed) (void)remove(parameters.outfile); /* ignore return value */
}
+fin:
destroy_parameters(¶meters);
- if (numDecompressedImages)
- fprintf(stdout, "decode time: %d ms \n", (int)( (tCumulative * 1000) / numDecompressedImages));
- //getch();
+ if(failed && img_fol.imgdirpath) free(img_fol.imgdirpath);
+ if(dirptr){
+ if(dirptr->filename) free(dirptr->filename);
+ if(dirptr->filename_buf) free(dirptr->filename_buf);
+ free(dirptr);
+ }
+ if (numDecompressedImages) {
+ fprintf(stdout, "decode time: %d ms\n", (int)( (tCumulative * 1000.0) / (OPJ_FLOAT64)numDecompressedImages));
+ }
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
-/*end main*/
+/*end main()*/
projects / openjpeg.git / blobdiff