/*
- * 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
+ * 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, 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-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) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR
* Copyright (c) 2012, CS Systemes d'Information, France
* All rights reserved.
*
#include <string.h>
#include <stdlib.h>
#include <math.h>
+#include <time.h>
#ifdef _WIN32
#include "windirent.h"
#define strncasecmp _strnicmp
#else
#include <strings.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/times.h>
#endif /* _WIN32 */
#include "openjpeg.h"
#include "color.h"
#include "format_defs.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
+#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;
-
- /** 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 ot 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 */
- OPJ_BOOL force_rgb;
-}opj_decompress_parameters;
+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);
+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_DA_values( char* inArg, unsigned int *DA_x0, unsigned int *DA_y0, unsigned int *DA_x1, unsigned int *DA_y1);
+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 <directory> \n"
- " 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"
- " 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"
- " 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"
- " -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"
- " smallest total number of decomposition levels among tiles.\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"
- " Create an index file *.Idx (-x index_name.Idx) \n"
- " -d <x0,y0,x1,y1>\n"
- " OPTIONAL\n"
- " Decoding area\n"
- " By default all the image is decoded.\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"
- " 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"
- " 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"
- " Force output image colorspace to RGB\n"
- "\n");
-/* UniPG>> */
+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 <directory> \n"
+ " Image file Directory path \n"
+ " -OutFor <PBM|PGM|PPM|PNM|PAM|PGX|PNG|BMP|TIF|TIFF|RAW|YUV|RAWL|TGA>\n"
+ " REQUIRED only if -ImgDir is used\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");
+ 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"
+ " 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 <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"
+ " smallest total number of decomposition levels among tiles.\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");
+ fprintf(stdout, " -x \n"
+ " Create an index file *.Idx (-x index_name.Idx) \n"
+ " -d <x0,y0,x1,y1>\n"
+ " OPTIONAL\n"
+ " Decoding area\n"
+ " By default all the image is decoded.\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");
+ fprintf(stdout, " -p <comp 0 precision>[C|S][,<comp 1 precision>[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 <num_threads|ALL_CPUS>\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 <options>\n"
- " Activates the JPWL correction capability, if the codestream complies.\n"
- " Options can be a comma separated list of <param=val> 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);
+ fprintf(stdout, " -W <options>\n"
+ " Activates the JPWL correction capability, if the codestream complies.\n"
+ " Options can be a comma separated list of <param=val> 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 */
-/* <<UniPG */
- fprintf(stdout,"\n");
+ /* <<UniPG */
+ fprintf(stdout, "\n");
}
/* -------------------------------------------------------------------------- */
-static OPJ_BOOL parse_precision(const char* option, opj_decompress_parameters* parameters)
+static OPJ_BOOL parse_precision(const char* option,
+ opj_decompress_parameters* parameters)
{
- const char* l_remaining = option;
- OPJ_BOOL l_result = OPJ_TRUE;
-
- /* reset */
- if (parameters->precision) {
- free(parameters->precision);
- parameters->precision = NULL;
- }
- parameters->nb_precision = 0U;
-
- for(;;)
- {
- OPJ_UINT32 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 > 32U) {
- 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 = 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 = 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 = 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;
+ const char* l_remaining = option;
+ OPJ_BOOL l_result = OPJ_TRUE;
+
+ /* reset */
+ if (parameters->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++;
- }
- return num_images;
+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++;
- }
- return 0;
+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 };
- 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;
+int get_file_format(const char *filename)
+{
+ unsigned int i;
+ static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp", "tif", "tiff", "raw", "yuv", "rawl", "tga", "png", "j2k", "jp2", "jpt", "j2c", "jpc" };
+ static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, TIF_DFMT, RAW_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);
- parameters->decod_format = infile_format(image_filename);
- if (parameters->decod_format == -1)
- return 1;
- sprintf(infilename,"%s/%s",img_fol->imgdirpath,image_filename);
- strncpy(parameters->infile, infilename, sizeof(infilename));
-
- /*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);
- strncpy(parameters->outfile, outfilename, sizeof(outfilename));
- }
- return 0;
+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;
}
/* -------------------------------------------------------------------------- */
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;
+ 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");
+ reader = fopen(fname, "rb");
- if (reader == NULL)
- return -2;
+ 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;
+ 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);
+ ext_format = get_file_format(fname);
- if (ext_format == JPT_CFMT)
- return JPT_CFMT;
+ 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 (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;
+ if (magic_format == ext_format) {
+ return ext_format;
+ }
- s = fname + strlen(fname) - 4;
+ 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);
+ 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;
+ return magic_format;
}
/* -------------------------------------------------------------------------- */
* Parse the command line
*/
/* -------------------------------------------------------------------------- */
-int parse_cmdline_decoder(int argc, char **argv, opj_decompress_parameters *parameters,img_fol_t *img_fol, char *indexfilename) {
- /* 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 ,'FRGB'}
- };
-
- const char optlist[] = "i:o:r:l:x:d:t:p:"
-
-/* UniPG>> */
+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:"
+ "W:"
#endif /* USE_JPWL */
-/* <<UniPG */
- "h" ;
- 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 '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;
- }
- strncpy(parameters->infile, infile, sizeof(parameters->infile)-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 *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outfile);
- return 1;
- }
- strncpy(parameters->outfile, outfile, sizeof(parameters->outfile)-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 *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outformat);
- return 1;
- break;
- }
- }
- break;
-
- /* ----------------------------------------------------- */
-
-
- case 'r': /* reduce option */
- {
- sscanf(opj_optarg, "%ud", &(parameters->core.cp_reduce));
- }
- break;
-
- /* ----------------------------------------------------- */
-
-
- case 'l': /* layering option */
- {
- sscanf(opj_optarg, "%ud", &(parameters->core.cp_layer));
- }
- break;
-
- /* ----------------------------------------------------- */
-
- case 'h': /* display an help description */
- decode_help_display();
- return 1;
-
+ /* <<UniPG */
+ "h" ;
+
+ long_option[2].flag = &(parameters->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:
+ case PXM_DFMT:
+ case BMP_DFMT:
+ case TIF_DFMT:
+ case RAW_DFMT:
+ case RAWL_DFMT:
+ case TGA_DFMT:
+ case PNG_DFMT:
+ break;
+ default:
+ fprintf(stderr,
+ "Unknown output format image %s [only *.png, *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif(f), *.raw, *.yuv 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(f), *.raw, *.yuv 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;
/* ----------------------------------------------------- */
- case 'y': /* Image Directory path */
- {
- img_fol->imgdirpath = (char*)malloc(strlen(opj_optarg) + 1);
- strcpy(img_fol->imgdirpath,opj_optarg);
- img_fol->set_imgdir=1;
- }
- break;
-
- /* ----------------------------------------------------- */
-
- case 'd': /* Input decode ROI */
- {
- int size_optarg = (int)strlen(opj_optarg) + 1;
- char *ROI_values = (char*) malloc((size_t)size_optarg);
- ROI_values[0] = '\0';
- strncpy(ROI_values, opj_optarg, strlen(opj_optarg));
- ROI_values[strlen(opj_optarg)] = '\0';
- /*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, "%ud", ¶meters->tile_index);
- parameters->nb_tile_to_decode = 1;
- }
- break;
-
- /* ----------------------------------------------------- */
-
- case 'x': /* Creation of index file */
- {
- char *index = opj_optarg;
- strncpy(indexfilename, index, OPJ_PATH_LEN);
- }
- break;
-
- /* ----------------------------------------------------- */
- case 'p': /* Force precision */
- {
- if (!parse_precision(opj_optarg, parameters))
- {
- return 1;
- }
- }
- break;
- /* ----------------------------------------------------- */
- case 'FRGB': /* Force RGB output */
- {
- parameters->force_rgb = OPJ_TRUE;
- }
- break;
- /* ----------------------------------------------------- */
-
- /* UniPG>> */
+ /* 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;
- fprintf(stdout, "JPWL correction capability activated\n");
- fprintf(stdout, "- expecting %d components\n", parameters->jpwl_exp_comps);
- }
- break;
+
+ 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 */
-/* <<UniPG */
+ /* <<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;
+
+ /* ----------------------------------------------------- */
- /* ----------------------------------------------------- */
-
default:
fprintf(stderr, "[WARNING] An invalid option has been ignored.\n");
break;
- }
- }while(c != -1);
+ }
+ } while (c != -1);
- /* check for possible errors */
- if(img_fol->set_imgdir==1){
- if(!(parameters->infile[0]==0)){
+ /* 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 <FORMAT> must be used.\n");
+ return 1;
+ }
+ if (img_fol->set_out_format == 0) {
+ fprintf(stderr,
+ "[ERROR] When -ImgDir is used, -OutFor <FORMAT> 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))){
+ "Valid format are PGM, PPM, PNM, PGX, BMP, TIF, TIFF, RAW, YUV, 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)) {
+ 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;
- }
- }
+ "Example: %s -i image.j2k -o image.pgm\n", argv[0]);
+ fprintf(stderr, " Help: %s -h\n", argv[0]);
+ return 1;
+ }
+ }
- return 0;
+ return 0;
}
/* -------------------------------------------------------------------------- */
* separator = ","
*/
/* -------------------------------------------------------------------------- */
-int parse_DA_values( char* inArg, unsigned int *DA_x0, unsigned int *DA_y0, unsigned int *DA_x1, unsigned int *DA_y1)
+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;
- }
+ 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);
+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);
+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);
+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));
- }
+ 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;
- }
- }
+ 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, original->comps[0].w * original->comps[0].h * sizeof(OPJ_INT32));
- memcpy(l_new_image->comps[1].data, original->comps[0].data, original->comps[0].w * original->comps[0].h * sizeof(OPJ_INT32));
- memcpy(l_new_image->comps[2].data, original->comps[0].data, original->comps[0].w * original->comps[0].h * sizeof(OPJ_INT32));
-
- 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, original->comps[compno].w * original->comps[compno].h * sizeof(OPJ_INT32));
- }
- opj_image_destroy(original);
- return l_new_image;
+ 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;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int main(int argc, char **argv)
{
- opj_decompress_parameters parameters; /* decompression parameters */
- 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;
-
- char indexfilename[OPJ_PATH_LEN]; /* index file name */
-
- OPJ_INT32 num_images, imageno;
- img_fol_t img_fol;
- dircnt_t *dirptr = NULL;
- int failed = 0;
-
- /* 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;
- }
-
- /* 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){
- 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->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(load_images(dirptr,img_fol.imgdirpath)==1){
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
- }
- if (num_images==0){
- fprintf(stdout,"Folder is empty\n");
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
- }
- }else{
- num_images=1;
- }
-
- /*Decoding image one by one*/
- for(imageno = 0; imageno < num_images ; imageno++) {
-
- 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);
- destroy_parameters(¶meters);
- return EXIT_FAILURE;
- }
-
- /* 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;
- }
-
- /* 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);
-
- /* Setup the decoder decoding parameters using user parameters */
- if ( !opj_setup_decoder(l_codec, &(parameters.core)) ){
- fprintf(stderr, "ERROR -> opj_compress: failed to setup the decoder\n");
- destroy_parameters(¶meters);
- opj_stream_destroy(l_stream);
- opj_destroy_codec(l_codec);
- return EXIT_FAILURE;
- }
-
-
- /* 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;
- }
-
- if (!parameters.nb_tile_to_decode) {
- /* Optional if you want decode the entire image */
- 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;
- }
-
- /* 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;
- }
- }
- else {
-
- /* It is just here to illustrate how to use the resolution after set parameters */
- /*if (!opj_set_decoded_resolution_factor(l_codec, 5)) {
- 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);
- return EXIT_FAILURE;
- }*/
-
- 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;
- }
- 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 )
- image->color_space = OPJ_CLRSPC_SYCC;
- else if (image->numcomps <= 2)
- image->color_space = OPJ_CLRSPC_GRAY;
-
- if(image->icc_profile_buf) {
+ 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)
- 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;
- }
-
- /* 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;
- }
-
- }
- }
-
- /* 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");
- destroy_parameters(¶meters);
- opj_destroy_codec(l_codec);
- opj_stream_destroy(l_stream);
- return EXIT_FAILURE;
- }
- }
-
- /* create output image */
- /* ------------------- */
- switch (parameters.cod_format) {
- case PXM_DFMT: /* PNM PGM PPM */
- if (imagetopnm(image, parameters.outfile)) {
- fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
- failed = 1;
- }
- else {
- 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 {
- 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 {
- 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 {
- 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 {
- 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 {
- 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 {
- 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 {
- 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->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;
- /* free image data structure */
- opj_image_destroy(image);
+ 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: /* TIF(F) */
+ 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 or yuv file. Outfile %s not generated\n",
+ parameters.outfile);
+ failed = 1;
+ } else if (!(parameters.quiet)) {
+ fprintf(stdout, "[INFO] Generated Outfile %s\n", parameters.outfile);
+ }
+ break;
- /* destroy the codestream index */
- opj_destroy_cstr_index(&cstr_index);
+ 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;
- if(failed) remove(parameters.outfile);
- }
- destroy_parameters(¶meters);
- return failed ? EXIT_FAILURE : EXIT_SUCCESS;
+ 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 TIF(F) 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*/
+/*end main()*/
projects / openjpeg.git / blobdiff