2005-12-02 14:34:15 +01:00
/*
2014-04-03 17:30:57 +02:00
* 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
2005-12-02 14:34:15 +01:00
* Copyright ( c ) 2001 - 2003 , David Janssens
* Copyright ( c ) 2002 - 2003 , Yannick Verschueren
2014-04-03 17:30:57 +02:00
* Copyright ( c ) 2003 - 2007 , Francois - Olivier Devaux
* Copyright ( c ) 2003 - 2014 , Antonin Descampe
2007-01-15 10:55:40 +01:00
* Copyright ( c ) 2005 , Herve Drolon , FreeImage Team
2007-03-20 18:15:18 +01:00
* Copyright ( c ) 2006 - 2007 , Parvatha Elangovan
2014-04-03 17:30:57 +02:00
* Copyright ( c ) 2008 , 2011 - 2012 , Centre National d ' Etudes Spatiales ( CNES ) , FR
2012-11-15 16:22:29 +01:00
* Copyright ( c ) 2012 , CS Systemes d ' Information , France
2005-12-02 14:34:15 +01:00
* 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 .
*/
2013-03-03 18:55:35 +01:00
# include "opj_apps_config.h"
2010-11-15 12:08:03 +01:00
2005-12-02 14:34:15 +01:00
# include <stdio.h>
# include <string.h>
# include <stdlib.h>
2007-09-07 17:01:55 +02:00
# include <math.h>
2004-11-26 17:33:18 +01:00
2010-12-08 12:06:41 +01:00
# ifdef _WIN32
2010-10-05 12:33:15 +02:00
# include "windirent.h"
# else
# include <dirent.h>
2010-12-08 12:06:41 +01:00
# endif /* _WIN32 */
2004-11-26 17:33:18 +01:00
2010-12-08 12:06:41 +01:00
# ifdef _WIN32
# include <windows.h>
2012-05-29 11:30:03 +02:00
# define strcasecmp _stricmp
# define strncasecmp _strnicmp
2010-12-08 12:06:41 +01:00
# else
2010-06-21 15:21:11 +02:00
# include <strings.h>
2015-06-16 02:16:32 +02:00
# include <sys/time.h>
# include <sys/resource.h>
# include <sys/times.h>
2010-12-08 12:06:41 +01:00
# endif /* _WIN32 */
2005-12-08 10:27:26 +01:00
2010-12-08 12:06:41 +01:00
# include "openjpeg.h"
2011-09-01 13:24:08 +02:00
# include "opj_getopt.h"
2010-12-08 12:06:41 +01:00
# include "convert.h"
# include "index.h"
2005-12-08 10:27:26 +01:00
2013-03-17 18:03:00 +01:00
# ifdef OPJ_HAVE_LIBLCMS2
2010-12-08 12:06:41 +01:00
# include <lcms2.h>
# endif
2013-03-17 18:03:00 +01:00
# ifdef OPJ_HAVE_LIBLCMS1
2010-12-08 12:06:41 +01:00
# include <lcms.h>
# endif
# include "color.h"
2007-02-26 16:40:01 +01:00
2010-12-08 12:06:41 +01:00
# include "format_defs.h"
2003-11-27 11:07:31 +01:00
2007-02-26 16:40:01 +01:00
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*/
2010-03-24 12:20:45 +01:00
const char * out_format ;
2007-02-26 16:40:01 +01:00
/** Enable option*/
char set_imgdir ;
/** Enable Cod Format for output*/
char set_out_format ;
} img_fol_t ;
2014-11-19 21:05:39 +01:00
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 ;
2014-11-22 01:04:39 +01:00
/* force output colorspace to RGB */
2014-11-22 13:30:04 +01:00
int force_rgb ;
2014-11-22 18:59:07 +01:00
/* upsample components according to their dx/dy values */
int upsample ;
2015-07-11 11:35:21 +02:00
/* split output components to different files */
int split_pnm ;
2014-11-19 21:05:39 +01:00
} opj_decompress_parameters ;
2011-10-05 18:27:16 +02:00
/* -------------------------------------------------------------------------- */
/* Declarations */
int get_num_images ( char * imgdirpath ) ;
int load_images ( dircnt_t * dirptr , char * imgdirpath ) ;
2011-11-09 15:32:54 +01:00
int get_file_format ( const char * filename ) ;
2014-11-19 21:05:39 +01:00
char get_next_file ( int imageno , dircnt_t * dirptr , img_fol_t * img_fol , opj_decompress_parameters * parameters ) ;
2011-11-09 15:32:54 +01:00
static int infile_format ( const char * fname ) ;
2011-10-05 18:27:16 +02:00
2014-11-19 21:05:39 +01:00
int parse_cmdline_decoder ( int argc , char * * argv , opj_decompress_parameters * parameters , img_fol_t * img_fol , char * indexfilename ) ;
2011-10-05 18:27:16 +02:00
int parse_DA_values ( char * inArg , unsigned int * DA_x0 , unsigned int * DA_y0 , unsigned int * DA_x1 , unsigned int * DA_y1 ) ;
2014-11-22 01:04:39 +01:00
static opj_image_t * convert_gray_to_rgb ( opj_image_t * original ) ;
2011-10-05 18:27:16 +02:00
/* -------------------------------------------------------------------------- */
2012-10-15 17:47:56 +02:00
static void decode_help_display ( void ) {
2014-11-19 21:05:39 +01:00
fprintf ( stdout , " \n This 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 "
2015-07-24 23:55:45 +02:00
" Output format for decompressed images. \n " ) ;
fprintf ( stdout , " -i <compressed file> \n "
2014-11-19 21:05:39 +01:00
" REQUIRED only if an Input image directory is not specified \n "
" Currently accepts J2K-files, JP2-files and JPT-files. The file type \n "
2015-07-24 23:55:45 +02:00
" is identified based on its suffix. \n " ) ;
fprintf ( stdout , " -o <decompressed file> \n "
2014-11-19 21:05:39 +01:00
" 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 "
2015-07-24 23:55:45 +02:00
" will be written to the file. \n " ) ;
fprintf ( stdout , " -r <reduce factor> \n "
2014-11-19 21:05:39 +01:00
" 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 "
2015-07-24 23:55:45 +02:00
" are decoded. \n " ) ;
fprintf ( stdout , " -x \n "
2014-11-19 21:05:39 +01:00
" 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 "
2015-07-24 23:55:45 +02:00
" By default all tiles are decoded. \n " ) ;
fprintf ( stdout , " -p <comp 0 precision>[C|S][,<comp 1 precision>[C|S][,...]] \n "
2014-11-19 21:05:39 +01:00
" OPTIONAL \n "
2015-07-25 03:16:16 +02:00
" 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 "
2014-11-19 21:05:39 +01:00
" 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 "
2015-07-25 03:16:16 +02:00
" A 0 value can be specified (meaning original bit depth). \n " ) ;
fprintf ( stdout , " -force-rgb \n "
2014-11-22 01:04:39 +01:00
" Force output image colorspace to RGB \n "
2014-11-22 18:59:07 +01:00
" -upsample \n "
" Downsampled components will be upsampled to image size \n "
2015-07-11 11:35:21 +02:00
" -split-pnm \n "
" Split output components to different files when writing to PNM \n "
2014-11-19 21:05:39 +01:00
" \n " ) ;
2006-12-04 15:55:38 +01:00
/* UniPG>> */
# ifdef USE_JPWL
2014-11-19 21:05:39 +01:00
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 ) ;
2006-12-04 15:55:38 +01:00
# endif /* USE_JPWL */
/* <<UniPG */
2005-12-08 10:27:26 +01:00
fprintf ( stdout , " \n " ) ;
2003-11-27 11:07:31 +01:00
}
2005-12-02 14:34:15 +01:00
/* -------------------------------------------------------------------------- */
2014-11-19 21:05:39 +01:00
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 ( ; ; )
{
2015-07-24 23:55:45 +02:00
int prec ;
2014-11-19 21:05:39 +01:00
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 ) {
2015-07-24 23:55:45 +02:00
if ( ( prec < 1 ) | | ( prec > 32 ) ) {
2014-11-19 21:05:39 +01:00
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 ;
}
2015-07-24 23:55:45 +02:00
parameters - > precision [ parameters - > nb_precision ] . prec = ( OPJ_UINT32 ) prec ;
2014-11-19 21:05:39 +01:00
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 ;
}
/* -------------------------------------------------------------------------- */
2007-02-26 16:40:01 +01:00
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 + + ;
}
2015-09-25 00:39:05 +02:00
closedir ( dir ) ;
2007-02-26 16:40:01 +01:00
return num_images ;
}
2011-10-05 18:27:16 +02:00
/* -------------------------------------------------------------------------- */
2007-02-26 16:40:01 +01:00
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 + + ;
}
2015-09-25 00:39:05 +02:00
closedir ( dir ) ;
2007-02-26 16:40:01 +01:00
return 0 ;
}
2011-10-05 18:27:16 +02:00
/* -------------------------------------------------------------------------- */
2011-11-09 15:32:54 +01:00
int get_file_format ( const char * filename ) {
2006-01-20 17:53:05 +01:00
unsigned int i ;
2012-05-29 11:30:03 +02:00
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 } ;
2007-02-27 15:19:09 +01:00
char * ext = strrchr ( filename , ' . ' ) ;
if ( ext = = NULL )
return - 1 ;
ext + + ;
2014-03-25 17:34:59 +01:00
if ( * ext ) {
2006-01-26 21:02:04 +01:00
for ( i = 0 ; i < sizeof ( format ) / sizeof ( * format ) ; i + + ) {
2012-05-29 11:30:03 +02:00
if ( strcasecmp ( ext , extension [ i ] ) = = 0 ) {
2005-12-08 10:27:26 +01:00
return format [ i ] ;
}
}
}
return - 1 ;
2005-12-02 14:34:15 +01:00
}
2015-02-02 17:11:23 +01:00
# ifdef _WIN32
const char * path_separator = " \\ " ;
# else
const char * path_separator = " / " ;
# endif
2011-10-05 18:27:16 +02:00
/* -------------------------------------------------------------------------- */
2014-11-19 21:05:39 +01:00
char get_next_file ( int imageno , dircnt_t * dirptr , img_fol_t * img_fol , opj_decompress_parameters * parameters ) {
2007-02-26 16:40:01 +01:00
char image_filename [ OPJ_PATH_LEN ] , infilename [ OPJ_PATH_LEN ] , outfilename [ OPJ_PATH_LEN ] , temp_ofname [ OPJ_PATH_LEN ] ;
2007-08-21 12:50:47 +02:00
char * temp_p , temp1 [ OPJ_PATH_LEN ] = " " ;
2007-02-26 16:40:01 +01:00
strcpy ( image_filename , dirptr - > filename [ imageno ] ) ;
2007-02-28 16:31:56 +01:00
fprintf ( stderr , " File Number %d \" %s \" \n " , imageno , image_filename ) ;
2015-02-02 17:11:23 +01:00
sprintf ( infilename , " %s%s%s " , img_fol - > imgdirpath , path_separator , image_filename ) ;
parameters - > decod_format = infile_format ( infilename ) ;
2007-02-27 15:19:09 +01:00
if ( parameters - > decod_format = = - 1 )
return 1 ;
2007-02-26 16:40:01 +01:00
strncpy ( parameters - > infile , infilename , sizeof ( infilename ) ) ;
2012-03-02 15:14:31 +01:00
/*Set output file*/
2007-02-26 16:40:01 +01:00
strcpy ( temp_ofname , strtok ( image_filename , " . " ) ) ;
2007-08-21 12:50:47 +02:00
while ( ( temp_p = strtok ( NULL , " . " ) ) ! = NULL ) {
strcat ( temp_ofname , temp1 ) ;
sprintf ( temp1 , " .%s " , temp_p ) ;
}
2007-02-26 16:40:01 +01:00
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 ) ) ;
}
2007-02-27 15:19:09 +01:00
return 0 ;
2007-02-26 16:40:01 +01:00
}
2011-11-17 15:29:36 +01:00
/* -------------------------------------------------------------------------- */
2011-11-09 15:32:54 +01:00
# 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 ] ;
2014-03-03 13:00:24 +01:00
OPJ_SIZE_T l_nb_read ;
2011-11-09 15:32:54 +01:00
reader = fopen ( fname , " rb " ) ;
if ( reader = = NULL )
2012-08-22 20:22:20 +02:00
return - 2 ;
2011-11-09 15:32:54 +01:00
memset ( buf , 0 , 12 ) ;
2011-11-18 09:42:57 +01:00
l_nb_read = fread ( buf , 1 , 12 , reader ) ;
2011-11-09 15:32:54 +01:00
fclose ( reader ) ;
2011-11-17 15:24:51 +01:00
if ( l_nb_read ! = 12 )
return - 1 ;
2011-11-09 15:32:54 +01:00
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 ;
}
2011-10-05 18:27:16 +02:00
/* -------------------------------------------------------------------------- */
/**
* Parse the command line
*/
2007-09-07 17:01:55 +02:00
/* -------------------------------------------------------------------------- */
2014-11-19 21:05:39 +01:00
int parse_cmdline_decoder ( int argc , char * * argv , opj_decompress_parameters * parameters , img_fol_t * img_fol , char * indexfilename ) {
2005-12-08 10:27:26 +01:00
/* parse the command line */
2011-07-29 10:50:55 +02:00
int totlen , c ;
2011-09-01 13:24:08 +02:00
opj_option_t long_option [ ] = {
2015-07-26 02:41:39 +02:00
{ " 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 }
2007-02-26 16:40:01 +01:00
} ;
2005-12-08 10:27:26 +01:00
2014-11-19 21:05:39 +01:00
const char optlist [ ] = " i:o:r:l:x:d:t:p: "
2006-12-04 15:55:38 +01:00
2007-07-17 18:19:41 +02:00
/* UniPG>> */
2006-12-04 15:55:38 +01:00
# ifdef USE_JPWL
" W: "
# endif /* USE_JPWL */
/* <<UniPG */
2014-04-23 11:12:30 +02:00
" h " ;
2015-07-26 02:41:39 +02:00
long_option [ 2 ] . flag = & ( parameters - > force_rgb ) ;
long_option [ 3 ] . flag = & ( parameters - > upsample ) ;
long_option [ 4 ] . flag = & ( parameters - > split_pnm ) ;
2007-02-26 16:40:01 +01:00
totlen = sizeof ( long_option ) ;
2014-11-22 01:04:39 +01:00
opj_reset_options_reading ( ) ;
2007-02-26 16:40:01 +01:00
img_fol - > set_out_format = 0 ;
2011-07-29 10:50:55 +02:00
do {
2011-09-01 13:24:08 +02:00
c = opj_getopt_long ( argc , argv , optlist , long_option , totlen ) ;
2005-12-08 10:27:26 +01:00
if ( c = = - 1 )
break ;
switch ( c ) {
2014-11-22 13:30:04 +01:00
case 0 : /* long opt with flag */
break ;
2005-12-08 10:27:26 +01:00
case ' i ' : /* input file */
{
2011-09-01 13:24:08 +02:00
char * infile = opj_optarg ;
2011-11-09 15:32:54 +01:00
parameters - > decod_format = infile_format ( infile ) ;
2005-12-08 10:27:26 +01:00
switch ( parameters - > decod_format ) {
case J2K_CFMT :
2011-10-05 18:27:16 +02:00
break ;
2005-12-08 10:27:26 +01:00
case JP2_CFMT :
2011-10-05 18:27:16 +02:00
break ;
2005-12-08 10:27:26 +01:00
case JPT_CFMT :
break ;
2012-08-22 20:22:20 +02:00
case - 2 :
fprintf ( stderr ,
" !! infile cannot be read: %s !! \n \n " ,
infile ) ;
return 1 ;
2005-12-08 10:27:26 +01:00
default :
fprintf ( stderr ,
2014-04-22 23:22:49 +02:00
" [ERROR] Unknown input file format: %s \n "
" Known file formats are *.j2k, *.jp2, *.jpc or *.jpt \n " ,
2005-12-08 10:27:26 +01:00
infile ) ;
return 1 ;
}
2007-02-13 10:00:37 +01:00
strncpy ( parameters - > infile , infile , sizeof ( parameters - > infile ) - 1 ) ;
2005-12-08 10:27:26 +01:00
}
break ;
/* ----------------------------------------------------- */
case ' o ' : /* output file */
{
2011-09-01 13:24:08 +02:00
char * outfile = opj_optarg ;
2005-12-08 10:27:26 +01:00
parameters - > cod_format = get_file_format ( outfile ) ;
switch ( parameters - > cod_format ) {
case PGX_DFMT :
2011-10-05 18:27:16 +02:00
break ;
2005-12-08 10:27:26 +01:00
case PXM_DFMT :
2011-10-05 18:27:16 +02:00
break ;
2005-12-08 10:27:26 +01:00
case BMP_DFMT :
2011-10-05 18:27:16 +02:00
break ;
2007-02-28 16:31:56 +01:00
case TIF_DFMT :
2011-10-05 18:27:16 +02:00
break ;
2007-07-17 18:19:41 +02:00
case RAW_DFMT :
2011-10-05 18:27:16 +02:00
break ;
2012-05-29 11:30:03 +02:00
case RAWL_DFMT :
break ;
2007-08-20 17:20:42 +02:00
case TGA_DFMT :
2011-10-05 18:27:16 +02:00
break ;
2010-03-26 16:46:17 +01:00
case PNG_DFMT :
2005-12-08 10:27:26 +01:00
break ;
default :
2007-08-20 17:20:42 +02:00
fprintf ( stderr , " Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n " , outfile ) ;
2005-12-08 10:27:26 +01:00
return 1 ;
}
2007-02-13 10:00:37 +01:00
strncpy ( parameters - > outfile , outfile , sizeof ( parameters - > outfile ) - 1 ) ;
2005-12-08 10:27:26 +01:00
}
break ;
/* ----------------------------------------------------- */
2007-02-26 16:40:01 +01:00
case ' O ' : /* output format */
{
char outformat [ 50 ] ;
2011-09-01 13:24:08 +02:00
char * of = opj_optarg ;
2007-02-26 16:40:01 +01:00
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 ;
2007-02-28 16:31:56 +01:00
case TIF_DFMT :
img_fol - > out_format = " tif " ;
break ;
2007-07-17 18:19:41 +02:00
case RAW_DFMT :
img_fol - > out_format = " raw " ;
break ;
2012-05-29 11:30:03 +02:00
case RAWL_DFMT :
img_fol - > out_format = " rawl " ;
break ;
2007-08-20 17:20:42 +02:00
case TGA_DFMT :
img_fol - > out_format = " raw " ;
break ;
2010-03-26 16:46:17 +01:00
case PNG_DFMT :
img_fol - > out_format = " png " ;
break ;
2007-02-26 16:40:01 +01:00
default :
2007-08-20 17:20:42 +02:00
fprintf ( stderr , " Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n " , outformat ) ;
2007-02-26 16:40:01 +01:00
return 1 ;
break ;
}
}
break ;
/* ----------------------------------------------------- */
2005-12-08 10:27:26 +01:00
case ' r ' : /* reduce option */
{
2015-05-29 00:16:49 +02:00
sscanf ( opj_optarg , " %u " , & ( parameters - > core . cp_reduce ) ) ;
2005-12-08 10:27:26 +01:00
}
break ;
/* ----------------------------------------------------- */
2005-01-26 09:59:49 +01:00
2005-12-02 14:34:15 +01:00
2005-12-08 10:27:26 +01:00
case ' l ' : /* layering option */
{
2015-05-29 00:16:49 +02:00
sscanf ( opj_optarg , " %u " , & ( parameters - > core . cp_layer ) ) ;
2005-12-08 10:27:26 +01:00
}
break ;
/* ----------------------------------------------------- */
2007-02-26 16:40:01 +01:00
2005-12-08 10:27:26 +01:00
case ' h ' : /* display an help description */
decode_help_display ( ) ;
2006-01-31 22:26:11 +01:00
return 1 ;
2007-02-26 16:40:01 +01:00
2014-04-22 23:22:49 +02:00
/* ----------------------------------------------------- */
2007-02-26 16:40:01 +01:00
case ' y ' : /* Image Directory path */
2014-04-22 23:22:49 +02:00
{
2011-09-01 13:24:08 +02:00
img_fol - > imgdirpath = ( char * ) malloc ( strlen ( opj_optarg ) + 1 ) ;
strcpy ( img_fol - > imgdirpath , opj_optarg ) ;
2007-02-26 16:40:01 +01:00
img_fol - > set_imgdir = 1 ;
}
break ;
2011-10-21 18:38:08 +02:00
/* ----------------------------------------------------- */
case ' d ' : /* Input decode ROI */
{
int size_optarg = ( int ) strlen ( opj_optarg ) + 1 ;
2014-03-07 13:01:41 +01:00
char * ROI_values = ( char * ) malloc ( ( size_t ) size_optarg ) ;
2011-10-21 18:38:08 +02:00
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 , & parameters - > DA_x0 , & parameters - > DA_y0 , & parameters - > DA_x1 , & parameters - > DA_y1 ) ;
free ( ROI_values ) ;
}
2011-11-17 15:24:51 +01:00
break ;
/* ----------------------------------------------------- */
case ' t ' : /* Input tile index */
{
2015-05-29 00:16:49 +02:00
sscanf ( opj_optarg , " %u " , & parameters - > tile_index ) ;
2011-11-17 15:24:51 +01:00
parameters - > nb_tile_to_decode = 1 ;
}
break ;
2011-10-21 18:38:08 +02:00
2007-09-07 17:01:55 +02:00
/* ----------------------------------------------------- */
2011-10-21 18:38:08 +02:00
2007-09-07 17:01:55 +02:00
case ' x ' : /* Creation of index file */
{
2011-09-01 13:24:08 +02:00
char * index = opj_optarg ;
2007-09-07 17:01:55 +02:00
strncpy ( indexfilename , index , OPJ_PATH_LEN ) ;
}
break ;
2014-11-19 21:05:39 +01:00
2007-02-26 16:40:01 +01:00
/* ----------------------------------------------------- */
2014-11-19 21:05:39 +01:00
case ' p ' : /* Force precision */
{
if ( ! parse_precision ( opj_optarg , parameters ) )
{
return 1 ;
}
}
break ;
/* ----------------------------------------------------- */
2007-09-07 17:01:55 +02:00
/* UniPG>> */
2006-12-04 15:55:38 +01:00
# ifdef USE_JPWL
case ' W ' : /* activate JPWL correction */
{
char * token = NULL ;
2011-09-01 13:24:08 +02:00
token = strtok ( opj_optarg , " , " ) ;
2006-12-04 15:55:38 +01:00
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 , " , " ) ;
} ;
2011-05-18 13:02:27 +02:00
parameters - > jpwl_correct = OPJ_TRUE ;
2006-12-04 15:55:38 +01:00
fprintf ( stdout , " JPWL correction capability activated \n " ) ;
fprintf ( stdout , " - expecting %d components \n " , parameters - > jpwl_exp_comps ) ;
}
break ;
# endif /* USE_JPWL */
/* <<UniPG */
2005-12-08 10:27:26 +01:00
/* ----------------------------------------------------- */
2014-04-22 23:22:49 +02:00
default :
2014-04-23 11:12:30 +02:00
fprintf ( stderr , " [WARNING] An invalid option has been ignored. \n " ) ;
2014-04-22 23:22:49 +02:00
break ;
2005-12-08 10:27:26 +01:00
}
2011-07-29 10:50:55 +02:00
} while ( c ! = - 1 ) ;
2005-12-08 10:27:26 +01:00
/* check for possible errors */
2007-02-26 16:40:01 +01:00
if ( img_fol - > set_imgdir = = 1 ) {
if ( ! ( parameters - > infile [ 0 ] = = 0 ) ) {
2014-04-23 11:12:30 +02:00
fprintf ( stderr , " [ERROR] options -ImgDir and -i cannot be used together. \n " ) ;
2007-02-26 16:40:01 +01:00
return 1 ;
}
if ( img_fol - > set_out_format = = 0 ) {
2014-04-23 11:12:30 +02:00
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 " ) ;
2007-02-26 16:40:01 +01:00
return 1 ;
}
if ( ! ( ( parameters - > outfile [ 0 ] = = 0 ) ) ) {
2014-04-23 11:12:30 +02:00
fprintf ( stderr , " [ERROR] options -ImgDir and -o cannot be used together. \n " ) ;
2007-02-26 16:40:01 +01:00
return 1 ;
}
} else {
if ( ( parameters - > infile [ 0 ] = = 0 ) | | ( parameters - > outfile [ 0 ] = = 0 ) ) {
2014-04-22 23:22:49 +02:00
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 ] ) ;
2007-02-26 16:40:01 +01:00
return 1 ;
}
2005-12-08 10:27:26 +01:00
}
return 0 ;
2005-12-02 14:34:15 +01:00
}
2011-10-05 18:27:16 +02:00
/* -------------------------------------------------------------------------- */
/**
* 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 {
2014-03-07 13:01:41 +01:00
* DA_x0 = ( OPJ_UINT32 ) values [ 0 ] ; * DA_y0 = ( OPJ_UINT32 ) values [ 1 ] ;
* DA_x1 = ( OPJ_UINT32 ) values [ 2 ] ; * DA_y1 = ( OPJ_UINT32 ) values [ 3 ] ;
2011-10-05 18:27:16 +02:00
return EXIT_SUCCESS ;
}
}
2015-06-16 02:16:32 +02:00
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 ) ;
2015-06-20 06:01:19 +02:00
return freq . QuadPart ? ( t . QuadPart / ( OPJ_FLOAT64 ) freq . QuadPart ) : 0 ;
2015-06-16 02:16:32 +02:00
# else
/* Unix or Linux: use resource usage */
struct rusage t ;
OPJ_FLOAT64 procTime ;
/* (1) Get the rusage data structure at this moment (man getrusage) */
getrusage ( 0 , & t ) ;
/* (2) What is the elapsed time ? - CPU time = User time + System time */
/* (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
}
2005-12-02 14:34:15 +01:00
/* -------------------------------------------------------------------------- */
/**
sample error callback expecting a FILE * client object
*/
2012-10-15 17:47:56 +02:00
static void error_callback ( const char * msg , void * client_data ) {
2012-05-14 19:47:10 +02:00
( void ) client_data ;
fprintf ( stdout , " [ERROR] %s " , msg ) ;
2005-12-02 14:34:15 +01:00
}
/**
sample warning callback expecting a FILE * client object
*/
2012-10-15 17:47:56 +02:00
static void warning_callback ( const char * msg , void * client_data ) {
2012-05-14 19:47:10 +02:00
( void ) client_data ;
fprintf ( stdout , " [WARNING] %s " , msg ) ;
2005-12-02 14:34:15 +01:00
}
/**
sample debug callback expecting no client object
*/
2012-10-15 17:47:56 +02:00
static void info_callback ( const char * msg , void * client_data ) {
2006-01-20 17:53:05 +01:00
( void ) client_data ;
2005-12-08 10:27:26 +01:00
fprintf ( stdout , " [INFO] %s " , msg ) ;
2005-12-02 14:34:15 +01:00
}
2014-11-19 21:05:39 +01:00
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 ;
}
}
}
2014-11-22 01:04:39 +01:00
/* -------------------------------------------------------------------------- */
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 ;
}
2014-11-22 18:59:07 +01:00
/* -------------------------------------------------------------------------- */
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 substraction 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 substraction 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 substraction 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 , l_org_cmp - > w * l_org_cmp - > h * sizeof ( OPJ_INT32 ) ) ;
}
}
opj_image_destroy ( original ) ;
return l_new_image ;
}
2005-12-02 14:34:15 +01:00
/* -------------------------------------------------------------------------- */
2011-10-05 18:27:16 +02:00
/**
2012-10-15 17:47:56 +02:00
* OPJ_DECOMPRESS MAIN
2011-10-05 18:27:16 +02:00
*/
/* -------------------------------------------------------------------------- */
int main ( int argc , char * * argv )
{
2014-11-19 21:05:39 +01:00
opj_decompress_parameters parameters ; /* decompression parameters */
2011-10-12 16:42:21 +02:00
opj_image_t * image = NULL ;
2012-05-02 09:01:13 +02:00
opj_stream_t * l_stream = NULL ; /* Stream */
opj_codec_t * l_codec = NULL ; /* Handle to a decompressor */
2011-10-21 18:36:04 +02:00
opj_codestream_index_t * cstr_index = NULL ;
2005-12-02 14:34:15 +01:00
2011-10-05 18:27:16 +02:00
char indexfilename [ OPJ_PATH_LEN ] ; /* index file name */
OPJ_INT32 num_images , imageno ;
2007-02-26 16:40:01 +01:00
img_fol_t img_fol ;
2011-07-27 18:37:57 +02:00
dircnt_t * dirptr = NULL ;
2014-03-07 18:23:19 +01:00
int failed = 0 ;
2015-06-16 02:16:32 +02:00
OPJ_FLOAT64 t , tCumulative = 0 ;
OPJ_UINT32 numDecompressedImages = 0 ;
2005-12-08 10:27:26 +01:00
/* set decoding parameters to default values */
2014-11-19 21:05:39 +01:00
set_default_parameters ( & parameters ) ;
2005-12-08 10:27:26 +01:00
2011-10-05 18:27:16 +02:00
/* FIXME Initialize indexfilename and img_fol */
2007-09-07 17:01:55 +02:00
* indexfilename = 0 ;
2011-10-05 18:27:16 +02:00
/* Initialize img_fol */
2007-09-06 18:49:15 +02:00
memset ( & img_fol , 0 , sizeof ( img_fol_t ) ) ;
2007-02-26 16:40:01 +01:00
/* parse input and get user encoding parameters */
2007-09-07 17:01:55 +02:00
if ( parse_cmdline_decoder ( argc , argv , & parameters , & img_fol , indexfilename ) = = 1 ) {
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2011-10-05 18:27:16 +02:00
return EXIT_FAILURE ;
2005-12-08 10:27:26 +01:00
}
2006-07-21 22:28:44 +02:00
2007-09-07 17:01:55 +02:00
/* Initialize reading of directory */
2007-02-26 16:40:01 +01:00
if ( img_fol . set_imgdir = = 1 ) {
2011-10-05 18:27:16 +02:00
int it_image ;
2007-02-26 16:40:01 +01:00
num_images = get_num_images ( img_fol . imgdirpath ) ;
dirptr = ( dircnt_t * ) malloc ( sizeof ( dircnt_t ) ) ;
if ( dirptr ) {
2014-03-07 13:01:41 +01:00
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 * ) ) ;
2007-02-26 16:40:01 +01:00
if ( ! dirptr - > filename_buf ) {
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2011-10-05 18:27:16 +02:00
return EXIT_FAILURE ;
2007-02-26 16:40:01 +01:00
}
2011-10-05 18:27:16 +02:00
for ( it_image = 0 ; it_image < num_images ; it_image + + ) {
dirptr - > filename [ it_image ] = dirptr - > filename_buf + it_image * OPJ_PATH_LEN ;
2007-02-26 16:40:01 +01:00
}
}
if ( load_images ( dirptr , img_fol . imgdirpath ) = = 1 ) {
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2011-10-05 18:27:16 +02:00
return EXIT_FAILURE ;
2007-02-26 16:40:01 +01:00
}
if ( num_images = = 0 ) {
fprintf ( stdout , " Folder is empty \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2011-10-05 18:27:16 +02:00
return EXIT_FAILURE ;
2007-02-26 16:40:01 +01:00
}
} else {
num_images = 1 ;
2006-07-21 22:28:44 +02:00
}
2011-10-05 18:27:16 +02:00
/*Decoding image one by one*/
2007-09-07 17:01:55 +02:00
for ( imageno = 0 ; imageno < num_images ; imageno + + ) {
2011-10-05 18:27:16 +02:00
2007-02-26 16:40:01 +01:00
fprintf ( stderr , " \n " ) ;
if ( img_fol . set_imgdir = = 1 ) {
2007-02-27 15:19:09 +01:00
if ( get_next_file ( imageno , dirptr , & img_fol , & parameters ) ) {
fprintf ( stderr , " skipping file... \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2007-02-27 15:19:09 +01:00
continue ;
}
2007-02-26 16:40:01 +01:00
}
/* read the input file and put it in memory */
/* ---------------------------------------- */
2011-10-05 18:27:16 +02:00
2014-04-23 09:46:11 +02:00
l_stream = opj_stream_create_default_file_stream ( parameters . infile , 1 ) ;
2012-05-02 09:01:13 +02:00
if ( ! l_stream ) {
2013-02-17 11:34:31 +01:00
fprintf ( stderr , " ERROR -> failed to create the stream from the file %s \n " , parameters . infile ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2011-10-05 18:27:16 +02:00
return EXIT_FAILURE ;
2011-07-27 18:37:57 +02:00
}
2007-02-26 16:40:01 +01:00
2011-10-05 18:27:16 +02:00
/* decode the JPEG2000 stream */
2007-02-26 16:40:01 +01:00
/* ---------------------- */
2005-12-02 14:34:15 +01:00
2007-02-26 16:40:01 +01:00
switch ( parameters . decod_format ) {
2011-10-05 18:27:16 +02:00
case J2K_CFMT : /* JPEG-2000 codestream */
{
/* Get a decoder handle */
2012-11-15 14:38:35 +01:00
l_codec = opj_create_decompress ( OPJ_CODEC_J2K ) ;
2011-10-05 18:27:16 +02:00
break ;
2005-12-08 10:27:26 +01:00
}
2011-10-05 18:27:16 +02:00
case JP2_CFMT : /* JPEG 2000 compressed image data */
{
/* Get a decoder handle */
2012-11-15 14:38:35 +01:00
l_codec = opj_create_decompress ( OPJ_CODEC_JP2 ) ;
2011-10-05 18:27:16 +02:00
break ;
2007-09-07 17:01:55 +02:00
}
2011-10-05 18:27:16 +02:00
case JPT_CFMT : /* JPEG 2000, JPIP */
{
/* Get a decoder handle */
2012-11-15 14:38:35 +01:00
l_codec = opj_create_decompress ( OPJ_CODEC_JPT ) ;
2011-10-05 18:27:16 +02:00
break ;
2005-12-08 10:27:26 +01:00
}
2011-10-05 18:27:16 +02:00
default :
fprintf ( stderr , " skipping file.. \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2011-10-05 18:27:16 +02:00
continue ;
}
2005-12-08 10:27:26 +01:00
2012-05-02 09:01:13 +02:00
/* 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 ) ;
2015-06-16 02:16:32 +02:00
t = opj_clock ( ) ;
2011-10-05 18:27:16 +02:00
/* Setup the decoder decoding parameters using user parameters */
2014-11-19 21:05:39 +01:00
if ( ! opj_setup_decoder ( l_codec , & ( parameters . core ) ) ) {
2014-12-26 16:37:16 +01:00
fprintf ( stderr , " ERROR -> opj_decompress: failed to setup the decoder \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2012-05-02 09:01:13 +02:00
opj_destroy_codec ( l_codec ) ;
2011-10-05 18:27:16 +02:00
return EXIT_FAILURE ;
}
2005-12-08 10:27:26 +01:00
2011-10-05 18:27:16 +02:00
/* Read the main header of the codestream and if necessary the JP2 boxes*/
2012-05-02 09:01:13 +02:00
if ( ! opj_read_header ( l_stream , l_codec , & image ) ) {
2012-10-15 17:47:56 +02:00
fprintf ( stderr , " ERROR -> opj_decompress: failed to read the header \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2012-05-02 09:01:13 +02:00
opj_destroy_codec ( l_codec ) ;
2011-10-21 18:38:08 +02:00
opj_image_destroy ( image ) ;
2011-10-05 18:27:16 +02:00
return EXIT_FAILURE ;
2005-12-08 10:27:26 +01:00
}
2011-11-17 15:24:51 +01:00
if ( ! parameters . nb_tile_to_decode ) {
2012-09-10 11:04:47 +02:00
/* Optional if you want decode the entire image */
2014-03-07 13:01:41 +01:00
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 ) ) {
2012-10-15 17:47:56 +02:00
fprintf ( stderr , " ERROR -> opj_decompress: failed to set the decoded area \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2012-05-02 09:01:13 +02:00
opj_destroy_codec ( l_codec ) ;
2011-11-17 15:24:51 +01:00
opj_image_destroy ( image ) ;
return EXIT_FAILURE ;
2011-10-21 18:38:08 +02:00
}
2011-11-17 15:24:51 +01:00
/* Get the decoded image */
2012-08-09 14:26:04 +02:00
if ( ! ( opj_decode ( l_codec , l_stream , image ) & & opj_end_decompress ( l_codec , l_stream ) ) ) {
2012-10-15 17:47:56 +02:00
fprintf ( stderr , " ERROR -> opj_decompress: failed to decode image! \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2012-05-02 09:01:13 +02:00
opj_destroy_codec ( l_codec ) ;
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2011-11-17 15:24:51 +01:00
opj_image_destroy ( image ) ;
return EXIT_FAILURE ;
}
}
else {
2011-11-17 15:29:36 +01:00
2012-09-10 11:04:47 +02:00
/* It is just here to illustrate how to use the resolution after set parameters */
2012-05-02 09:01:13 +02:00
/*if (!opj_set_decoded_resolution_factor(l_codec, 5)) {
2012-10-15 17:47:56 +02:00
fprintf ( stderr , " ERROR -> opj_decompress: failed to set the resolution factor tile! \n " ) ;
2012-05-02 09:01:13 +02:00
opj_destroy_codec ( l_codec ) ;
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2011-11-17 15:29:36 +01:00
opj_image_destroy ( image ) ;
return EXIT_FAILURE ;
} */
2012-05-02 09:01:13 +02:00
if ( ! opj_get_decoded_tile ( l_codec , l_stream , image , parameters . tile_index ) ) {
2012-10-15 17:47:56 +02:00
fprintf ( stderr , " ERROR -> opj_decompress: failed to decode tile! \n " ) ;
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2012-05-02 09:01:13 +02:00
opj_destroy_codec ( l_codec ) ;
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2011-11-17 15:24:51 +01:00
opj_image_destroy ( image ) ;
return EXIT_FAILURE ;
}
fprintf ( stdout , " tile %d is decoded! \n \n " , parameters . tile_index ) ;
2005-12-08 10:27:26 +01:00
}
2011-10-21 18:36:04 +02:00
2015-06-16 02:16:32 +02:00
tCumulative + = opj_clock ( ) - t ;
numDecompressedImages + + ;
2011-10-05 18:27:16 +02:00
/* Close the byte stream */
2014-04-23 09:46:11 +02:00
opj_stream_destroy ( l_stream ) ;
2006-07-21 22:28:44 +02:00
2013-03-25 00:12:41 +01:00
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 ;
2010-12-08 12:06:41 +01:00
2015-07-31 01:31:12 +02:00
if ( image - > color_space = = OPJ_CLRSPC_SYCC ) {
color_sycc_to_rgb ( image ) ;
}
2015-08-21 19:54:22 +02:00
else if ( ( image - > color_space = = OPJ_CLRSPC_CMYK ) & & ( parameters . cod_format ! = TIF_DFMT ) ) {
2015-07-31 01:31:12 +02:00
color_cmyk_to_rgb ( image ) ;
}
2015-08-21 19:54:22 +02:00
else if ( image - > color_space = = OPJ_CLRSPC_EYCC ) {
2015-07-31 01:31:12 +02:00
color_esycc_to_rgb ( image ) ;
}
2011-10-12 16:42:21 +02:00
if ( image - > icc_profile_buf ) {
2013-03-17 18:03:00 +01:00
# if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
2015-07-31 01:31:12 +02:00
if ( image - > icc_profile_len )
color_apply_icc_profile ( image ) ;
else
2015-09-13 14:42:56 +02:00
color_cielab_to_rgb ( image ) ;
2010-12-08 12:06:41 +01:00
# endif
2011-10-12 16:42:21 +02:00
free ( image - > icc_profile_buf ) ;
image - > icc_profile_buf = NULL ; image - > icc_profile_len = 0 ;
2011-10-05 18:27:16 +02:00
}
2014-11-19 21:05:39 +01:00
/* 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 ;
}
}
}
2014-11-22 01:04:39 +01:00
2014-11-22 18:59:07 +01:00
/* Upsample components */
/* ------------------- */
if ( parameters . upsample )
{
image = upsample_image_components ( image ) ;
if ( image = = NULL ) {
fprintf ( stderr , " ERROR -> opj_decompress: failed to upsample image components! \n " ) ;
destroy_parameters ( & parameters ) ;
opj_destroy_codec ( l_codec ) ;
return EXIT_FAILURE ;
}
}
2014-11-22 01:04:39 +01:00
/* 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 ( & parameters ) ;
opj_destroy_codec ( l_codec ) ;
return EXIT_FAILURE ;
}
}
2010-12-08 12:06:41 +01:00
2007-02-26 16:40:01 +01:00
/* create output image */
/* ------------------- */
2007-02-28 16:31:56 +01:00
switch ( parameters . cod_format ) {
2005-12-08 10:27:26 +01:00
case PXM_DFMT : /* PNM PGM PPM */
2015-07-11 11:35:21 +02:00
if ( imagetopnm ( image , parameters . outfile , parameters . split_pnm ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-07 18:23:19 +01:00
failed = 1 ;
2007-02-28 16:31:56 +01:00
}
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2007-02-28 16:31:56 +01:00
}
2005-12-08 10:27:26 +01:00
break ;
2006-07-21 22:28:44 +02:00
2005-12-08 10:27:26 +01:00
case PGX_DFMT : /* PGX */
2011-10-12 16:42:21 +02:00
if ( imagetopgx ( image , parameters . outfile ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2007-02-28 16:31:56 +01:00
}
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2007-02-28 16:31:56 +01:00
}
2005-12-08 10:27:26 +01:00
break ;
2006-07-21 22:28:44 +02:00
2005-12-08 10:27:26 +01:00
case BMP_DFMT : /* BMP */
2011-10-12 16:42:21 +02:00
if ( imagetobmp ( image , parameters . outfile ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2007-02-28 16:31:56 +01:00
}
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2007-02-26 16:40:01 +01:00
}
2007-02-28 16:31:56 +01:00
break ;
2013-03-03 18:55:35 +01:00
# ifdef OPJ_HAVE_LIBTIFF
2007-02-28 16:31:56 +01:00
case TIF_DFMT : /* TIFF */
2011-10-12 16:42:21 +02:00
if ( imagetotif ( image , parameters . outfile ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2007-02-26 16:40:01 +01:00
}
2007-02-28 16:31:56 +01:00
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2007-02-28 16:31:56 +01:00
}
break ;
2013-03-03 18:55:35 +01:00
# endif /* OPJ_HAVE_LIBTIFF */
2007-07-17 18:19:41 +02:00
case RAW_DFMT : /* RAW */
2011-10-12 16:42:21 +02:00
if ( imagetoraw ( image , parameters . outfile ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Error generating raw file. Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2007-07-17 18:19:41 +02:00
}
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2007-07-17 18:19:41 +02:00
}
break ;
2007-08-20 17:20:42 +02:00
2012-05-29 11:30:03 +02:00
case RAWL_DFMT : /* RAWL */
if ( imagetorawl ( image , parameters . outfile ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Error generating rawl file. Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2012-05-29 11:30:03 +02:00
}
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2012-05-29 11:30:03 +02:00
}
break ;
2007-08-20 17:20:42 +02:00
case TGA_DFMT : /* TGA */
2011-10-12 16:42:21 +02:00
if ( imagetotga ( image , parameters . outfile ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Error generating tga file. Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2007-08-20 17:20:42 +02:00
}
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2007-08-20 17:20:42 +02:00
}
break ;
2013-03-03 18:55:35 +01:00
# ifdef OPJ_HAVE_LIBPNG
2010-03-26 16:46:17 +01:00
case PNG_DFMT : /* PNG */
2011-10-12 16:42:21 +02:00
if ( imagetopng ( image , parameters . outfile ) ) {
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Error generating png file. Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2010-03-26 16:46:17 +01:00
}
else {
2014-04-22 23:22:49 +02:00
fprintf ( stdout , " [INFO] Generated Outfile %s \n " , parameters . outfile ) ;
2010-03-26 16:46:17 +01:00
}
break ;
2013-03-03 18:55:35 +01:00
# endif /* OPJ_HAVE_LIBPNG */
2010-10-05 12:33:15 +02:00
/* Can happen if output file is TIFF or PNG
2013-03-17 18:03:00 +01:00
* and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined
2010-10-05 12:33:15 +02:00
*/
default :
2014-04-22 23:22:49 +02:00
fprintf ( stderr , " [ERROR] Outfile %s not generated \n " , parameters . outfile ) ;
2014-03-13 13:31:41 +01:00
failed = 1 ;
2007-02-28 16:31:56 +01:00
}
/* free remaining structures */
2012-05-02 09:01:13 +02:00
if ( l_codec ) {
opj_destroy_codec ( l_codec ) ;
2007-02-28 16:31:56 +01:00
}
2011-10-05 18:27:16 +02:00
2007-02-28 16:31:56 +01:00
/* free image data structure */
2011-10-12 16:42:21 +02:00
opj_image_destroy ( image ) ;
2007-02-27 15:19:09 +01:00
2011-10-21 18:36:04 +02:00
/* destroy the codestream index */
opj_destroy_cstr_index ( & cstr_index ) ;
2015-09-25 00:08:34 +02:00
if ( failed ) ( void ) remove ( parameters . outfile ) ; /* ignore return value */
2005-12-08 10:27:26 +01:00
}
2014-11-19 21:05:39 +01:00
destroy_parameters ( & parameters ) ;
2015-07-24 23:55:45 +02:00
if ( numDecompressedImages ) {
fprintf ( stdout , " decode time: %d ms \n " , ( int ) ( ( tCumulative * 1000.0 ) / ( OPJ_FLOAT64 ) numDecompressedImages ) ) ;
}
2014-03-07 18:23:19 +01:00
return failed ? EXIT_FAILURE : EXIT_SUCCESS ;
2003-11-27 11:07:31 +01:00
}
2012-03-02 15:14:31 +01:00
/*end main*/