/* * The copyright in this software is being made available under the 2-clauses * BSD License, included below. This software may be subject to other third * party and contributor rights, including patent rights, and no such rights * are granted under this license. * * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2002-2014, Professor Benoit Macq * Copyright (c) 2001-2003, David Janssens * Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2003-2007, Francois-Olivier Devaux * Copyright (c) 2003-2014, Antonin Descampe * Copyright (c) 2005, Herve Drolon, FreeImage Team * Copyright (c) 2006-2007, Parvatha Elangovan * Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR * Copyright (c) 2012, CS Systemes d'Information, France * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include "opj_apps_config.h" #include #include #include #include #include #ifdef _WIN32 #include "windirent.h" #else #include #endif /* _WIN32 */ #ifdef _WIN32 #include #define strcasecmp _stricmp #define strncasecmp _strnicmp #else #include #include #include #include #endif /* _WIN32 */ #include "openjpeg.h" #include "opj_getopt.h" #include "convert.h" #include "index.h" #ifdef OPJ_HAVE_LIBLCMS2 #include #endif #ifdef OPJ_HAVE_LIBLCMS1 #include #endif #include "color.h" #include "format_defs.h" #include "opj_string.h" typedef struct dircnt { /** Buffer for holding images read from Directory*/ char *filename_buf; /** Pointer to the buffer*/ char **filename; } dircnt_t; typedef struct img_folder { /** The directory path of the folder containing input images*/ char *imgdirpath; /** Output format*/ const char *out_format; /** Enable option*/ char set_imgdir; /** Enable Cod Format for output*/ char set_out_format; } img_fol_t; typedef enum opj_prec_mode { OPJ_PREC_MODE_CLIP, OPJ_PREC_MODE_SCALE } opj_precision_mode; typedef struct opj_prec { OPJ_UINT32 prec; opj_precision_mode mode; } opj_precision; typedef struct opj_decompress_params { /** core library parameters */ opj_dparameters_t core; /** input file name */ char infile[OPJ_PATH_LEN]; /** output file name */ char outfile[OPJ_PATH_LEN]; /** input file format 0: J2K, 1: JP2, 2: JPT */ 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; /** Decoding area right boundary */ OPJ_UINT32 DA_x1; /** Decoding area up boundary */ OPJ_UINT32 DA_y0; /** Decoding area bottom boundary */ OPJ_UINT32 DA_y1; /** Verbose mode */ OPJ_BOOL m_verbose; /** tile number of the decoded tile */ OPJ_UINT32 tile_index; /** Nb of tile to decode */ OPJ_UINT32 nb_tile_to_decode; opj_precision* precision; OPJ_UINT32 nb_precision; /* force output colorspace to RGB */ 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; /* Quiet */ int quiet; /** number of components to decode */ OPJ_UINT32 numcomps; /** indices of components to decode */ OPJ_UINT32* comps_indices; } opj_decompress_parameters; /* -------------------------------------------------------------------------- */ /* Declarations */ int get_num_images(char *imgdirpath); int load_images(dircnt_t *dirptr, char *imgdirpath); int get_file_format(const char *filename); 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); 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); /* -------------------------------------------------------------------------- */ static void decode_help_display(void) { fprintf(stdout, "\nThis is the opj_decompress utility from the OpenJPEG project.\n" "It decompresses JPEG 2000 codestreams to various image formats.\n" "It has been compiled against openjp2 library v%s.\n\n", opj_version()); fprintf(stdout, "Parameters:\n" "-----------\n" "\n" " -ImgDir \n" " Image file Directory path \n" " -OutFor \n" " REQUIRED only if -ImgDir is used\n" " Output format for decompressed images.\n"); fprintf(stdout, " -i \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"); fprintf(stdout, " -o \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" " filename is given, there will be as many output files as there are\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"); fprintf(stdout, " -r \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" " smallest total number of decomposition levels among tiles.\n" " -l \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"); fprintf(stdout, " -x \n" " Create an index file *.Idx (-x index_name.Idx) \n" " -d \n" " OPTIONAL\n" " Decoding area\n" " By default all the image is decoded.\n" " -t \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"); fprintf(stdout, " -p [C|S][,[C|S][,...]]\n" " OPTIONAL\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"); fprintf(stdout, " -c first_comp_index[,second_comp_index][,...]\n" " OPTIONAL\n" " To limit the number of components to decoded.\n" " Component indices are numbered starting at 0.\n"); fprintf(stdout, " -force-rgb\n" " Force output image colorspace to RGB\n" " -upsample\n" " Downsampled components will be upsampled to image size\n" " -split-pnm\n" " Split output components to different files when writing to PNM\n"); if (opj_has_thread_support()) { fprintf(stdout, " -threads \n" " Number of threads to use for decoding or ALL_CPUS for all available cores.\n"); } fprintf(stdout, " -quiet\n" " Disable output from the library and other output.\n"); /* UniPG>> */ #ifdef USE_JPWL fprintf(stdout, " -W \n" " Activates the JPWL correction capability, if the codestream complies.\n" " Options can be a comma separated list of tokens:\n" " c, c=numcomps\n" " numcomps is the number of expected components in the codestream\n" " (search of first EPB rely upon this, default is %d)\n", JPWL_EXPECTED_COMPONENTS); #endif /* USE_JPWL */ /* <precision) { free(parameters->precision); parameters->precision = NULL; } parameters->nb_precision = 0U; for (;;) { int prec; char mode; char comma; int count; count = sscanf(l_remaining, "%d%c%c", &prec, &mode, &comma); if (count == 1) { mode = 'C'; count++; } if ((count == 2) || (mode == ',')) { if (mode == ',') { mode = 'C'; } comma = ','; count = 3; } if (count == 3) { if ((prec < 1) || (prec > 32)) { fprintf(stderr, "Invalid precision %d in precision option %s\n", prec, option); l_result = OPJ_FALSE; break; } if ((mode != 'C') && (mode != 'S')) { fprintf(stderr, "Invalid precision mode %c in precision option %s\n", mode, option); l_result = OPJ_FALSE; break; } if (comma != ',') { fprintf(stderr, "Invalid character %c in precision option %s\n", comma, option); l_result = OPJ_FALSE; break; } if (parameters->precision == NULL) { /* first one */ 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; } } else { OPJ_UINT32 l_new_size = parameters->nb_precision + 1U; opj_precision* l_new; if (l_new_size == 0U) { fprintf(stderr, "Could not allocate memory for precision option\n"); l_result = OPJ_FALSE; break; } 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; break; } parameters->precision = l_new; } parameters->precision[parameters->nb_precision].prec = (OPJ_UINT32)prec; switch (mode) { case 'C': parameters->precision[parameters->nb_precision].mode = OPJ_PREC_MODE_CLIP; break; case 'S': parameters->precision[parameters->nb_precision].mode = OPJ_PREC_MODE_SCALE; break; default: break; } parameters->nb_precision++; l_remaining = strchr(l_remaining, ','); if (l_remaining == NULL) { break; } l_remaining += 1; } else { fprintf(stderr, "Could not parse precision option %s\n", option); l_result = OPJ_FALSE; break; } } return l_result; } /* -------------------------------------------------------------------------- */ int get_num_images(char *imgdirpath) { DIR *dir; struct dirent* content; int num_images = 0; /*Reading the input images from given input directory*/ dir = opendir(imgdirpath); if (!dir) { fprintf(stderr, "Could not open Folder %s\n", imgdirpath); return 0; } while ((content = readdir(dir)) != NULL) { if (strcmp(".", content->d_name) == 0 || strcmp("..", content->d_name) == 0) { continue; } num_images++; } closedir(dir); return num_images; } /* -------------------------------------------------------------------------- */ int load_images(dircnt_t *dirptr, char *imgdirpath) { DIR *dir; struct dirent* content; int i = 0; /*Reading the input images from given input directory*/ dir = opendir(imgdirpath); if (!dir) { fprintf(stderr, "Could not open Folder %s\n", imgdirpath); return 1; } else { fprintf(stderr, "Folder opened successfully\n"); } while ((content = readdir(dir)) != NULL) { if (strcmp(".", content->d_name) == 0 || strcmp("..", content->d_name) == 0) { continue; } strcpy(dirptr->filename[i], content->d_name); i++; } closedir(dir); return 0; } /* -------------------------------------------------------------------------- */ int get_file_format(const char *filename) { 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 }; const char * ext = strrchr(filename, '.'); if (ext == NULL) { return -1; } ext++; if (*ext) { for (i = 0; i < sizeof(format) / sizeof(*format); i++) { if (strcasecmp(ext, extension[i]) == 0) { return format[i]; } } } return -1; } #ifdef _WIN32 const char* path_separator = "\\"; #else const char* path_separator = "/"; #endif /* -------------------------------------------------------------------------- */ char get_next_file(int imageno, dircnt_t *dirptr, img_fol_t *img_fol, opj_decompress_parameters *parameters) { char image_filename[OPJ_PATH_LEN], infilename[OPJ_PATH_LEN], outfilename[OPJ_PATH_LEN], temp_ofname[OPJ_PATH_LEN]; char *temp_p, temp1[OPJ_PATH_LEN] = ""; strcpy(image_filename, dirptr->filename[imageno]); fprintf(stderr, "File Number %d \"%s\"\n", imageno, image_filename); sprintf(infilename, "%s%s%s", img_fol->imgdirpath, path_separator, image_filename); parameters->decod_format = infile_format(infilename); if (parameters->decod_format == -1) { return 1; } if (opj_strcpy_s(parameters->infile, sizeof(parameters->infile), infilename) != 0) { return 1; } /*Set output file*/ strcpy(temp_ofname, strtok(image_filename, ".")); while ((temp_p = strtok(NULL, ".")) != NULL) { strcat(temp_ofname, temp1); sprintf(temp1, ".%s", temp_p); } if (img_fol->set_out_format == 1) { sprintf(outfilename, "%s/%s.%s", img_fol->imgdirpath, temp_ofname, img_fol->out_format); if (opj_strcpy_s(parameters->outfile, sizeof(parameters->outfile), outfilename) != 0) { return 1; } } return 0; } /* -------------------------------------------------------------------------- */ #define JP2_RFC3745_MAGIC "\x00\x00\x00\x0c\x6a\x50\x20\x20\x0d\x0a\x87\x0a" #define JP2_MAGIC "\x0d\x0a\x87\x0a" /* position 45: "\xff\x52" */ #define J2K_CODESTREAM_MAGIC "\xff\x4f\xff\x51" static int infile_format(const char *fname) { FILE *reader; const char *s, *magic_s; int ext_format, magic_format; unsigned char buf[12]; OPJ_SIZE_T l_nb_read; reader = fopen(fname, "rb"); if (reader == NULL) { return -2; } memset(buf, 0, 12); l_nb_read = fread(buf, 1, 12, reader); fclose(reader); if (l_nb_read != 12) { return -1; } ext_format = get_file_format(fname); if (ext_format == JPT_CFMT) { return JPT_CFMT; } if (memcmp(buf, JP2_RFC3745_MAGIC, 12) == 0 || memcmp(buf, JP2_MAGIC, 4) == 0) { magic_format = JP2_CFMT; magic_s = ".jp2"; } else if (memcmp(buf, J2K_CODESTREAM_MAGIC, 4) == 0) { magic_format = J2K_CFMT; magic_s = ".j2k or .jpc or .j2c"; } else { return -1; } if (magic_format == ext_format) { return ext_format; } s = fname + strlen(fname) - 4; fputs("\n===========================================\n", stderr); fprintf(stderr, "The extension of this file is incorrect.\n" "FOUND %s. SHOULD BE %s\n", s, magic_s); fputs("===========================================\n", stderr); return magic_format; } /* -------------------------------------------------------------------------- */ /** * Parse the command line */ /* -------------------------------------------------------------------------- */ 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, NULL, 1}, {"upsample", NO_ARG, NULL, 1}, {"split-pnm", NO_ARG, NULL, 1}, {"threads", REQ_ARG, NULL, 'T'}, {"quiet", NO_ARG, NULL, 1}, }; const char optlist[] = "i:o:r:l:x:d:t:p:c:" /* UniPG>> */ #ifdef USE_JPWL "W:" #endif /* USE_JPWL */ /* <force_rgb); long_option[3].flag = &(parameters->upsample); long_option[4].flag = &(parameters->split_pnm); long_option[6].flag = &(parameters->quiet); totlen = sizeof(long_option); opj_reset_options_reading(); img_fol->set_out_format = 0; do { c = opj_getopt_long(argc, argv, optlist, long_option, totlen); if (c == -1) { break; } switch (c) { case 0: /* long opt with flag */ break; case 'i': { /* input file */ char *infile = opj_optarg; parameters->decod_format = infile_format(infile); switch (parameters->decod_format) { case J2K_CFMT: break; case JP2_CFMT: break; case JPT_CFMT: break; case -2: fprintf(stderr, "!! infile cannot be read: %s !!\n\n", infile); return 1; default: fprintf(stderr, "[ERROR] Unknown input file format: %s \n" " Known file formats are *.j2k, *.jp2, *.jpc or *.jpt\n", infile); return 1; } if (opj_strcpy_s(parameters->infile, sizeof(parameters->infile), infile) != 0) { fprintf(stderr, "[ERROR] Path is too long\n"); return 1; } } break; /* ----------------------------------------------------- */ case 'o': { /* output file */ char *outfile = opj_optarg; parameters->cod_format = get_file_format(outfile); switch (parameters->cod_format) { case PGX_DFMT: break; case PXM_DFMT: break; case BMP_DFMT: break; case TIF_DFMT: break; case RAW_DFMT: break; case RAWL_DFMT: break; case TGA_DFMT: break; case PNG_DFMT: break; default: fprintf(stderr, "Unknown output format image %s [only *.png, *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!!\n", outfile); return 1; } if (opj_strcpy_s(parameters->outfile, sizeof(parameters->outfile), outfile) != 0) { fprintf(stderr, "[ERROR] Path is too long\n"); return 1; } } break; /* ----------------------------------------------------- */ case 'O': { /* output format */ char outformat[50]; char *of = opj_optarg; sprintf(outformat, ".%s", of); img_fol->set_out_format = 1; parameters->cod_format = get_file_format(outformat); switch (parameters->cod_format) { case PGX_DFMT: img_fol->out_format = "pgx"; break; case PXM_DFMT: img_fol->out_format = "ppm"; break; case BMP_DFMT: img_fol->out_format = "bmp"; break; case TIF_DFMT: img_fol->out_format = "tif"; break; case RAW_DFMT: img_fol->out_format = "raw"; break; case RAWL_DFMT: img_fol->out_format = "rawl"; break; case TGA_DFMT: img_fol->out_format = "raw"; break; case PNG_DFMT: img_fol->out_format = "png"; break; default: fprintf(stderr, "Unknown output format image %s [only *.png, *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!!\n", outformat); return 1; break; } } break; /* ----------------------------------------------------- */ case 'r': { /* reduce option */ sscanf(opj_optarg, "%u", &(parameters->core.cp_reduce)); } break; /* ----------------------------------------------------- */ case 'l': { /* layering option */ sscanf(opj_optarg, "%u", &(parameters->core.cp_layer)); } break; /* ----------------------------------------------------- */ case 'h': /* display an help description */ decode_help_display(); return 1; /* ----------------------------------------------------- */ 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; } break; /* ----------------------------------------------------- */ case 'd': { /* Input decode ROI */ 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'; 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); free(ROI_values); } break; /* ----------------------------------------------------- */ case 't': { /* Input tile index */ sscanf(opj_optarg, "%u", ¶meters->tile_index); parameters->nb_tile_to_decode = 1; } break; /* ----------------------------------------------------- */ case 'x': { /* Creation of index file */ if (opj_strcpy_s(parameters->indexfilename, sizeof(parameters->indexfilename), opj_optarg) != 0) { fprintf(stderr, "[ERROR] Path is too long\n"); return 1; } } break; /* ----------------------------------------------------- */ case 'p': { /* Force precision */ if (!parse_precision(opj_optarg, parameters)) { return 1; } } break; /* ----------------------------------------------------- */ case 'c': { /* Componenets */ const char* iter = opj_optarg; while (1) { parameters->numcomps ++; parameters->comps_indices = (OPJ_UINT32*) realloc( parameters->comps_indices, parameters->numcomps * sizeof(OPJ_UINT32)); parameters->comps_indices[parameters->numcomps - 1] = (OPJ_UINT32) atoi(iter); iter = strchr(iter, ','); if (iter == NULL) { break; } iter ++; } } break; /* ----------------------------------------------------- */ /* UniPG>> */ #ifdef USE_JPWL case 'W': { /* activate JPWL correction */ char *token = NULL; token = strtok(opj_optarg, ","); while (token != NULL) { /* search expected number of components */ if (*token == 'c') { static int compno; compno = JPWL_EXPECTED_COMPONENTS; /* predefined no. of components */ if (sscanf(token, "c=%d", &compno) == 1) { /* Specified */ if ((compno < 1) || (compno > 256)) { fprintf(stderr, "ERROR -> invalid number of components c = %d\n", compno); return 1; } parameters->jpwl_exp_comps = compno; } else if (!strcmp(token, "c")) { /* default */ parameters->jpwl_exp_comps = compno; /* auto for default size */ } else { fprintf(stderr, "ERROR -> invalid components specified = %s\n", token); return 1; }; } /* search maximum number of tiles */ if (*token == 't') { static int tileno; tileno = JPWL_MAXIMUM_TILES; /* maximum no. of tiles */ if (sscanf(token, "t=%d", &tileno) == 1) { /* Specified */ if ((tileno < 1) || (tileno > JPWL_MAXIMUM_TILES)) { fprintf(stderr, "ERROR -> invalid number of tiles t = %d\n", tileno); return 1; } parameters->jpwl_max_tiles = tileno; } else if (!strcmp(token, "t")) { /* default */ parameters->jpwl_max_tiles = tileno; /* auto for default size */ } else { fprintf(stderr, "ERROR -> invalid tiles specified = %s\n", token); return 1; }; } /* next token or bust */ token = strtok(NULL, ","); }; parameters->jpwl_correct = OPJ_TRUE; if (!(parameter->quiet)) { fprintf(stdout, "JPWL correction capability activated\n"); fprintf(stdout, "- expecting %d components\n", parameters->jpwl_exp_comps); } } break; #endif /* USE_JPWL */ /* <num_threads = opj_get_num_cpus(); if (parameters->num_threads == 1) { parameters->num_threads = 0; } } else { sscanf(opj_optarg, "%d", ¶meters->num_threads); } } break; /* ----------------------------------------------------- */ default: fprintf(stderr, "[WARNING] An invalid option has been ignored.\n"); break; } } while (c != -1); /* check for possible errors */ if (img_fol->set_imgdir == 1) { if (!(parameters->infile[0] == 0)) { fprintf(stderr, "[ERROR] options -ImgDir and -i cannot be used together.\n"); return 1; } if (img_fol->set_out_format == 0) { fprintf(stderr, "[ERROR] When -ImgDir is used, -OutFor must be used.\n"); fprintf(stderr, "Only one format allowed.\n" "Valid format are PGM, PPM, PNM, PGX, BMP, TIF, RAW and TGA.\n"); return 1; } if (!((parameters->outfile[0] == 0))) { fprintf(stderr, "[ERROR] options -ImgDir and -o cannot be used together.\n"); return 1; } } else { if ((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) { fprintf(stderr, "[ERROR] Required parameters are missing\n" "Example: %s -i image.j2k -o image.pgm\n", argv[0]); fprintf(stderr, " Help: %s -h\n", argv[0]); return 1; } } return 0; } /* -------------------------------------------------------------------------- */ /** * Parse decoding area input values * separator = "," */ /* -------------------------------------------------------------------------- */ int parse_DA_values(char* inArg, unsigned int *DA_x0, unsigned int *DA_y0, unsigned int *DA_x1, unsigned int *DA_y1) { int it = 0; int values[4]; char delims[] = ","; char *result = NULL; result = strtok(inArg, delims); while ((result != NULL) && (it < 4)) { values[it] = atoi(result); result = strtok(NULL, delims); it++; } if (it != 4) { return EXIT_FAILURE; } else { *DA_x0 = (OPJ_UINT32)values[0]; *DA_y0 = (OPJ_UINT32)values[1]; *DA_x1 = (OPJ_UINT32)values[2]; *DA_y1 = (OPJ_UINT32)values[3]; return EXIT_SUCCESS; } } OPJ_FLOAT64 opj_clock(void) { #ifdef _WIN32 /* _WIN32: use QueryPerformance (very accurate) */ LARGE_INTEGER freq, t ; /* freq is the clock speed of the CPU */ QueryPerformanceFrequency(&freq) ; /* cout << "freq = " << ((double) freq.QuadPart) << endl; */ /* t is the high resolution performance counter (see MSDN) */ QueryPerformanceCounter(& t) ; return freq.QuadPart ? ((OPJ_FLOAT64)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 : 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) ; #endif } /* -------------------------------------------------------------------------- */ /** sample error callback expecting a FILE* client object */ static void error_callback(const char *msg, void *client_data) { (void)client_data; fprintf(stdout, "[ERROR] %s", msg); } /** sample warning callback expecting a FILE* client object */ static void warning_callback(const char *msg, void *client_data) { (void)client_data; fprintf(stdout, "[WARNING] %s", msg); } /** sample debug callback expecting no client object */ static void info_callback(const char *msg, void *client_data) { (void)client_data; fprintf(stdout, "[INFO] %s", msg); } /** sample quiet callback expecting no client object */ static void quiet_callback(const char *msg, void *client_data) { (void)msg; (void)client_data; } static void set_default_parameters(opj_decompress_parameters* parameters) { if (parameters) { memset(parameters, 0, sizeof(opj_decompress_parameters)); /* default decoding parameters (command line specific) */ parameters->decod_format = -1; parameters->cod_format = -1; /* default decoding parameters (core) */ opj_set_default_decoder_parameters(&(parameters->core)); } } static void destroy_parameters(opj_decompress_parameters* parameters) { if (parameters) { if (parameters->precision) { free(parameters->precision); parameters->precision = NULL; } free(parameters->comps_indices); parameters->comps_indices = NULL; } } /* -------------------------------------------------------------------------- */ static opj_image_t* convert_gray_to_rgb(opj_image_t* original) { OPJ_UINT32 compno; opj_image_t* l_new_image = NULL; opj_image_cmptparm_t* l_new_components = NULL; l_new_components = (opj_image_cmptparm_t*)malloc((original->numcomps + 2U) * sizeof(opj_image_cmptparm_t)); if (l_new_components == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for RGB image!\n"); opj_image_destroy(original); return NULL; } l_new_components[0].bpp = l_new_components[1].bpp = l_new_components[2].bpp = original->comps[0].bpp; l_new_components[0].dx = l_new_components[1].dx = l_new_components[2].dx = original->comps[0].dx; l_new_components[0].dy = l_new_components[1].dy = l_new_components[2].dy = original->comps[0].dy; l_new_components[0].h = l_new_components[1].h = l_new_components[2].h = original->comps[0].h; l_new_components[0].w = l_new_components[1].w = l_new_components[2].w = original->comps[0].w; l_new_components[0].prec = l_new_components[1].prec = l_new_components[2].prec = original->comps[0].prec; l_new_components[0].sgnd = l_new_components[1].sgnd = l_new_components[2].sgnd = original->comps[0].sgnd; l_new_components[0].x0 = l_new_components[1].x0 = l_new_components[2].x0 = original->comps[0].x0; l_new_components[0].y0 = l_new_components[1].y0 = l_new_components[2].y0 = original->comps[0].y0; for (compno = 1U; compno < original->numcomps; ++compno) { l_new_components[compno + 2U].bpp = original->comps[compno].bpp; l_new_components[compno + 2U].dx = original->comps[compno].dx; l_new_components[compno + 2U].dy = original->comps[compno].dy; l_new_components[compno + 2U].h = original->comps[compno].h; l_new_components[compno + 2U].w = original->comps[compno].w; l_new_components[compno + 2U].prec = original->comps[compno].prec; l_new_components[compno + 2U].sgnd = original->comps[compno].sgnd; l_new_components[compno + 2U].x0 = original->comps[compno].x0; l_new_components[compno + 2U].y0 = original->comps[compno].y0; } l_new_image = opj_image_create(original->numcomps + 2U, l_new_components, OPJ_CLRSPC_SRGB); free(l_new_components); if (l_new_image == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for RGB image!\n"); opj_image_destroy(original); return NULL; } l_new_image->x0 = original->x0; l_new_image->x1 = original->x1; l_new_image->y0 = original->y0; l_new_image->y1 = original->y1; l_new_image->comps[0].factor = l_new_image->comps[1].factor = l_new_image->comps[2].factor = original->comps[0].factor; l_new_image->comps[0].alpha = l_new_image->comps[1].alpha = l_new_image->comps[2].alpha = original->comps[0].alpha; l_new_image->comps[0].resno_decoded = l_new_image->comps[1].resno_decoded = l_new_image->comps[2].resno_decoded = original->comps[0].resno_decoded; memcpy(l_new_image->comps[0].data, original->comps[0].data, sizeof(OPJ_INT32) * original->comps[0].w * original->comps[0].h); memcpy(l_new_image->comps[1].data, original->comps[0].data, sizeof(OPJ_INT32) * original->comps[0].w * original->comps[0].h); memcpy(l_new_image->comps[2].data, original->comps[0].data, sizeof(OPJ_INT32) * original->comps[0].w * original->comps[0].h); for (compno = 1U; compno < original->numcomps; ++compno) { l_new_image->comps[compno + 2U].factor = original->comps[compno].factor; l_new_image->comps[compno + 2U].alpha = original->comps[compno].alpha; l_new_image->comps[compno + 2U].resno_decoded = original->comps[compno].resno_decoded; memcpy(l_new_image->comps[compno + 2U].data, original->comps[compno].data, sizeof(OPJ_INT32) * original->comps[compno].w * original->comps[compno].h); } opj_image_destroy(original); return l_new_image; } /* -------------------------------------------------------------------------- */ static opj_image_t* upsample_image_components(opj_image_t* original) { opj_image_t* l_new_image = NULL; opj_image_cmptparm_t* l_new_components = NULL; OPJ_BOOL l_upsample_need = OPJ_FALSE; OPJ_UINT32 compno; for (compno = 0U; compno < original->numcomps; ++compno) { if (original->comps[compno].factor > 0U) { fprintf(stderr, "ERROR -> opj_decompress: -upsample not supported with reduction\n"); opj_image_destroy(original); return NULL; } if ((original->comps[compno].dx > 1U) || (original->comps[compno].dy > 1U)) { l_upsample_need = OPJ_TRUE; break; } } if (!l_upsample_need) { return original; } /* Upsample is needed */ l_new_components = (opj_image_cmptparm_t*)malloc(original->numcomps * sizeof( opj_image_cmptparm_t)); if (l_new_components == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for upsampled components!\n"); opj_image_destroy(original); return NULL; } for (compno = 0U; compno < original->numcomps; ++compno) { opj_image_cmptparm_t* l_new_cmp = &(l_new_components[compno]); opj_image_comp_t* l_org_cmp = &(original->comps[compno]); l_new_cmp->bpp = l_org_cmp->bpp; l_new_cmp->prec = l_org_cmp->prec; l_new_cmp->sgnd = l_org_cmp->sgnd; l_new_cmp->x0 = original->x0; l_new_cmp->y0 = original->y0; l_new_cmp->dx = 1; l_new_cmp->dy = 1; l_new_cmp->w = l_org_cmp->w; /* should be original->x1 - original->x0 for dx==1 */ l_new_cmp->h = l_org_cmp->h; /* should be original->y1 - original->y0 for dy==0 */ if (l_org_cmp->dx > 1U) { l_new_cmp->w = original->x1 - original->x0; } if (l_org_cmp->dy > 1U) { l_new_cmp->h = original->y1 - original->y0; } } l_new_image = opj_image_create(original->numcomps, l_new_components, original->color_space); free(l_new_components); if (l_new_image == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to allocate memory for upsampled components!\n"); opj_image_destroy(original); return NULL; } l_new_image->x0 = original->x0; l_new_image->x1 = original->x1; l_new_image->y0 = original->y0; l_new_image->y1 = original->y1; for (compno = 0U; compno < original->numcomps; ++compno) { opj_image_comp_t* l_new_cmp = &(l_new_image->comps[compno]); opj_image_comp_t* l_org_cmp = &(original->comps[compno]); l_new_cmp->factor = l_org_cmp->factor; l_new_cmp->alpha = l_org_cmp->alpha; l_new_cmp->resno_decoded = l_org_cmp->resno_decoded; if ((l_org_cmp->dx > 1U) || (l_org_cmp->dy > 1U)) { const OPJ_INT32* l_src = l_org_cmp->data; OPJ_INT32* l_dst = l_new_cmp->data; OPJ_UINT32 y; OPJ_UINT32 xoff, yoff; /* need to take into account dx & dy */ xoff = l_org_cmp->dx * l_org_cmp->x0 - original->x0; yoff = l_org_cmp->dy * l_org_cmp->y0 - original->y0; if ((xoff >= l_org_cmp->dx) || (yoff >= l_org_cmp->dy)) { fprintf(stderr, "ERROR -> opj_decompress: Invalid image/component parameters found when upsampling\n"); opj_image_destroy(original); opj_image_destroy(l_new_image); return NULL; } for (y = 0U; y < yoff; ++y) { memset(l_dst, 0U, l_new_cmp->w * sizeof(OPJ_INT32)); l_dst += l_new_cmp->w; } 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; xorg = 0U; for (x = 0U; x < xoff; ++x) { l_dst[x] = 0; } 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) { l_dst[x + dx] = l_src[xorg]; } } } for (; x < l_new_cmp->w; ++x) { l_dst[x] = l_src[xorg]; } l_dst += l_new_cmp->w; for (dy = 1U; dy < l_org_cmp->dy; ++dy) { memcpy(l_dst, l_dst - l_new_cmp->w, l_new_cmp->w * sizeof(OPJ_INT32)); l_dst += l_new_cmp->w; } l_src += l_org_cmp->w; } } if (y < l_new_cmp->h) { OPJ_UINT32 x; OPJ_UINT32 xorg; xorg = 0U; for (x = 0U; x < xoff; ++x) { l_dst[x] = 0; } 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) { l_dst[x + dx] = l_src[xorg]; } } } for (; x < l_new_cmp->w; ++x) { l_dst[x] = l_src[xorg]; } l_dst += l_new_cmp->w; ++y; for (; y < l_new_cmp->h; ++y) { memcpy(l_dst, l_dst - l_new_cmp->w, l_new_cmp->w * sizeof(OPJ_INT32)); l_dst += l_new_cmp->w; } } } else { memcpy(l_new_cmp->data, l_org_cmp->data, sizeof(OPJ_INT32) * l_org_cmp->w * l_org_cmp->h); } } opj_image_destroy(original); return l_new_image; } /* -------------------------------------------------------------------------- */ /** * OPJ_DECOMPRESS MAIN */ /* -------------------------------------------------------------------------- */ int main(int argc, char **argv) { opj_decompress_parameters parameters; /* decompression parameters */ OPJ_INT32 num_images, imageno; img_fol_t img_fol; dircnt_t *dirptr = NULL; int failed = 0; OPJ_FLOAT64 t, tCumulative = 0; OPJ_UINT32 numDecompressedImages = 0; OPJ_UINT32 cp_reduce; /* set decoding parameters to default values */ set_default_parameters(¶meters); /* 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) == 1) { failed = 1; goto fin; } cp_reduce = parameters.core.cp_reduce; if (getenv("USE_OPJ_SET_DECODED_RESOLUTION_FACTOR") != NULL) { /* For debugging/testing purposes, do not set the cp_reduce member */ /* if USE_OPJ_SET_DECODED_RESOLUTION_FACTOR is defined, but used */ /* the opj_set_decoded_resolution_factor() API instead */ parameters.core.cp_reduce = 0; } /* Initialize reading of directory */ if (img_fol.set_imgdir == 1) { int it_image; num_images = get_num_images(img_fol.imgdirpath); dirptr = (dircnt_t*)malloc(sizeof(dircnt_t)); if (!dirptr) { destroy_parameters(¶meters); return EXIT_FAILURE; } /* Stores at max 10 image file names */ dirptr->filename_buf = (char*)malloc(sizeof(char) * (size_t)num_images * OPJ_PATH_LEN); if (!dirptr->filename_buf) { failed = 1; goto fin; } dirptr->filename = (char**) malloc((size_t)num_images * sizeof(char*)); 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) { failed = 1; goto fin; } if (num_images == 0) { fprintf(stderr, "Folder is empty\n"); failed = 1; goto fin; } } else { num_images = 1; } /*Decoding image one by one*/ for (imageno = 0; imageno < num_images ; imageno++) { opj_image_t* image = NULL; opj_stream_t *l_stream = NULL; /* Stream */ opj_codec_t* l_codec = NULL; /* Handle to a decompressor */ opj_codestream_index_t* cstr_index = NULL; if (!parameters.quiet) { fprintf(stderr, "\n"); } if (img_fol.set_imgdir == 1) { if (get_next_file(imageno, dirptr, &img_fol, ¶meters)) { fprintf(stderr, "skipping file...\n"); destroy_parameters(¶meters); continue; } } /* read the input file and put it in memory */ /* ---------------------------------------- */ 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); failed = 1; goto fin; } /* decode the JPEG2000 stream */ /* ---------------------- */ switch (parameters.decod_format) { case J2K_CFMT: { /* JPEG-2000 codestream */ /* Get a decoder handle */ l_codec = opj_create_decompress(OPJ_CODEC_J2K); break; } case JP2_CFMT: { /* JPEG 2000 compressed image data */ /* Get a decoder handle */ l_codec = opj_create_decompress(OPJ_CODEC_JP2); break; } case JPT_CFMT: { /* JPEG 2000, JPIP */ /* Get a decoder handle */ l_codec = opj_create_decompress(OPJ_CODEC_JPT); break; } default: fprintf(stderr, "skipping file..\n"); destroy_parameters(¶meters); opj_stream_destroy(l_stream); continue; } if (parameters.quiet) { /* Set all callbacks to quiet */ opj_set_info_handler(l_codec, quiet_callback, 00); opj_set_warning_handler(l_codec, quiet_callback, 00); opj_set_error_handler(l_codec, quiet_callback, 00); } else { /* catch events using our callbacks and give a local context */ opj_set_info_handler(l_codec, info_callback, 00); opj_set_warning_handler(l_codec, warning_callback, 00); opj_set_error_handler(l_codec, error_callback, 00); } t = opj_clock(); /* 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"); opj_stream_destroy(l_stream); opj_destroy_codec(l_codec); 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"); opj_stream_destroy(l_stream); opj_destroy_codec(l_codec); opj_image_destroy(image); failed = 1; goto fin; } if (parameters.numcomps) { if (! opj_set_decoded_components(l_codec, parameters.numcomps, parameters.comps_indices, OPJ_FALSE)) { fprintf(stderr, "ERROR -> opj_decompress: failed to set the component indices!\n"); opj_destroy_codec(l_codec); opj_stream_destroy(l_stream); opj_image_destroy(image); failed = 1; goto fin; } } if (getenv("USE_OPJ_SET_DECODED_RESOLUTION_FACTOR") != NULL) { /* For debugging/testing purposes, and also an illustration on how to */ /* use the alternative API opj_set_decoded_resolution_factor() instead */ /* of setting parameters.cp_reduce */ if (! opj_set_decoded_resolution_factor(l_codec, cp_reduce)) { fprintf(stderr, "ERROR -> opj_decompress: failed to set the resolution factor tile!\n"); opj_destroy_codec(l_codec); opj_stream_destroy(l_stream); opj_image_destroy(image); failed = 1; goto fin; } } if (!parameters.nb_tile_to_decode) { if (getenv("SKIP_OPJ_SET_DECODE_AREA") != NULL && parameters.DA_x0 == 0 && parameters.DA_y0 == 0 && parameters.DA_x1 == 0 && parameters.DA_y1 == 0) { /* For debugging/testing purposes, */ /* do nothing if SKIP_OPJ_SET_DECODE_AREA env variable */ /* is defined and no decoded area has been set */ } /* Optional if you want decode the entire image */ else 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"); opj_stream_destroy(l_stream); opj_destroy_codec(l_codec); opj_image_destroy(image); 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"); opj_destroy_codec(l_codec); opj_stream_destroy(l_stream); opj_image_destroy(image); failed = 1; goto fin; } } else { if (!(parameters.DA_x0 == 0 && parameters.DA_y0 == 0 && parameters.DA_x1 == 0 && parameters.DA_y1 == 0)) { if (!(parameters.quiet)) { fprintf(stderr, "WARNING: -d option ignored when used together with -t\n"); } } if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) { fprintf(stderr, "ERROR -> opj_decompress: failed to decode tile!\n"); opj_destroy_codec(l_codec); opj_stream_destroy(l_stream); opj_image_destroy(image); failed = 1; goto fin; } if (!(parameters.quiet)) { fprintf(stdout, "tile %d is decoded!\n\n", parameters.tile_index); } } tCumulative += opj_clock() - t; numDecompressedImages++; /* Close the byte stream */ opj_stream_destroy(l_stream); if (image->color_space != OPJ_CLRSPC_SYCC && image->numcomps == 3 && image->comps[0].dx == image->comps[0].dy && image->comps[1].dx != 1) { image->color_space = OPJ_CLRSPC_SYCC; } 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) 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; } /* Force output precision */ /* ---------------------- */ if (parameters.precision != NULL) { OPJ_UINT32 compno; for (compno = 0; compno < image->numcomps; ++compno) { OPJ_UINT32 precno = compno; OPJ_UINT32 prec; if (precno >= parameters.nb_precision) { precno = parameters.nb_precision - 1U; } prec = parameters.precision[precno].prec; if (prec == 0) { prec = image->comps[compno].prec; } switch (parameters.precision[precno].mode) { case OPJ_PREC_MODE_CLIP: clip_component(&(image->comps[compno]), prec); break; case OPJ_PREC_MODE_SCALE: scale_component(&(image->comps[compno]), prec); break; default: break; } } } /* Upsample components */ /* ------------------- */ if (parameters.upsample) { image = upsample_image_components(image); if (image == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to upsample image components!\n"); opj_destroy_codec(l_codec); failed = 1; goto fin; } } /* Force RGB output */ /* ---------------- */ if (parameters.force_rgb) { switch (image->color_space) { case OPJ_CLRSPC_SRGB: break; case OPJ_CLRSPC_GRAY: image = convert_gray_to_rgb(image); break; default: fprintf(stderr, "ERROR -> opj_decompress: don't know how to convert image to RGB colorspace!\n"); opj_image_destroy(image); image = NULL; break; } if (image == NULL) { fprintf(stderr, "ERROR -> opj_decompress: failed to convert to RGB image!\n"); opj_destroy_codec(l_codec); failed = 1; goto fin; } } /* create output image */ /* ------------------- */ switch (parameters.cod_format) { case PXM_DFMT: /* PNM PGM PPM */ if (imagetopnm(image, parameters.outfile, parameters.split_pnm)) { fprintf(stderr, "[ERROR] Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; case PGX_DFMT: /* PGX */ if (imagetopgx(image, parameters.outfile)) { fprintf(stderr, "[ERROR] Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; case BMP_DFMT: /* BMP */ if (imagetobmp(image, parameters.outfile)) { fprintf(stderr, "[ERROR] Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; #ifdef OPJ_HAVE_LIBTIFF case TIF_DFMT: /* TIFF */ if (imagetotif(image, parameters.outfile)) { fprintf(stderr, "[ERROR] Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; #endif /* OPJ_HAVE_LIBTIFF */ case RAW_DFMT: /* RAW */ if (imagetoraw(image, parameters.outfile)) { fprintf(stderr, "[ERROR] Error generating raw file. Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; case RAWL_DFMT: /* RAWL */ if (imagetorawl(image, parameters.outfile)) { fprintf(stderr, "[ERROR] Error generating rawl file. Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; case TGA_DFMT: /* TGA */ if (imagetotga(image, parameters.outfile)) { fprintf(stderr, "[ERROR] Error generating tga file. Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; #ifdef OPJ_HAVE_LIBPNG case PNG_DFMT: /* PNG */ if (imagetopng(image, parameters.outfile)) { fprintf(stderr, "[ERROR] Error generating png file. Outfile %s not generated\n", parameters.outfile); failed = 1; } else if (!(parameters.quiet)) { fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile); } break; #endif /* OPJ_HAVE_LIBPNG */ /* Can happen if output file is TIFF or PNG * and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined */ default: fprintf(stderr, "[ERROR] Outfile %s not generated\n", parameters.outfile); failed = 1; } /* free remaining structures */ if (l_codec) { opj_destroy_codec(l_codec); } /* free image data structure */ opj_image_destroy(image); /* destroy the codestream index */ opj_destroy_cstr_index(&cstr_index); if (failed) { (void)remove(parameters.outfile); /* ignore return value */ } } fin: destroy_parameters(¶meters); 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 && !failed && !(parameters.quiet)) { fprintf(stdout, "decode time: %d ms\n", (int)((tCumulative * 1000.0) / (OPJ_FLOAT64)numDecompressedImages)); } return failed ? EXIT_FAILURE : EXIT_SUCCESS; } /*end main()*/