| 1 |
/* |
| 2 |
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium |
| 3 |
* Copyright (c) 2002-2014, Professor Benoit Macq |
| 4 |
* Copyright (c) 2001-2003, David Janssens |
| 5 |
* Copyright (c) 2002-2003, Yannick Verschueren |
| 6 |
* Copyright (c) 2003-2007, Francois-Olivier Devaux |
| 7 |
* Copyright (c) 2003-2014, Antonin Descampe |
| 8 |
* Copyright (c) 2005, Herve Drolon, FreeImage Team |
| 9 |
* Copyright (c) 2006-2007, Parvatha Elangovan |
| 10 |
* Copyright (c) 2007, Patrick Piscaglia (Telemis) |
| 11 |
* All rights reserved. |
| 12 |
* |
| 13 |
* Redistribution and use in source and binary forms, with or without |
| 14 |
* modification, are permitted provided that the following conditions |
| 15 |
* are met: |
| 16 |
* 1. Redistributions of source code must retain the above copyright |
| 17 |
* notice, this list of conditions and the following disclaimer. |
| 18 |
* 2. Redistributions in binary form must reproduce the above copyright |
| 19 |
* notice, this list of conditions and the following disclaimer in the |
| 20 |
* documentation and/or other materials provided with the distribution. |
| 21 |
* |
| 22 |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' |
| 23 |
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 24 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 25 |
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| 26 |
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 27 |
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 28 |
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| 29 |
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| 30 |
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 31 |
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 32 |
* POSSIBILITY OF SUCH DAMAGE. |
| 33 |
*/ |
| 34 |
#include <stdio.h> |
| 35 |
#include <string.h> |
| 36 |
#include <stdlib.h> |
| 37 |
#include <jni.h> |
| 38 |
#include <math.h> |
| 39 |
|
| 40 |
#include "openjpeg.h" |
| 41 |
#include "opj_includes.h" |
| 42 |
#include "opj_getopt.h" |
| 43 |
#include "convert.h" |
| 44 |
#include "dirent.h" |
| 45 |
#include "org_openJpeg_OpenJPEGJavaDecoder.h" |
| 46 |
|
| 47 |
#ifndef _WIN32 |
| 48 |
#define stricmp strcasecmp |
| 49 |
#define strnicmp strncasecmp |
| 50 |
#endif |
| 51 |
|
| 52 |
#include "format_defs.h" |
| 53 |
|
| 54 |
typedef struct callback_variables { |
| 55 |
JNIEnv *env; |
| 56 |
/** 'jclass' object used to call a Java method from the C */ |
| 57 |
jobject *jobj; |
| 58 |
/** 'jclass' object used to call a Java method from the C */ |
| 59 |
jmethodID message_mid; |
| 60 |
jmethodID error_mid; |
| 61 |
} callback_variables_t; |
| 62 |
|
| 63 |
typedef struct dircnt{ |
| 64 |
/** Buffer for holding images read from Directory*/ |
| 65 |
char *filename_buf; |
| 66 |
/** Pointer to the buffer*/ |
| 67 |
char **filename; |
| 68 |
}dircnt_t; |
| 69 |
|
| 70 |
|
| 71 |
typedef struct img_folder{ |
| 72 |
/** The directory path of the folder containing input images*/ |
| 73 |
char *imgdirpath; |
| 74 |
/** Output format*/ |
| 75 |
char *out_format; |
| 76 |
/** Enable option*/ |
| 77 |
char set_imgdir; |
| 78 |
/** Enable Cod Format for output*/ |
| 79 |
char set_out_format; |
| 80 |
|
| 81 |
}img_fol_t; |
| 82 |
|
| 83 |
|
| 84 |
void decode_help_display() { |
| 85 |
fprintf(stdout,"HELP\n----\n\n"); |
| 86 |
fprintf(stdout,"- the -h option displays this help information on screen\n\n"); |
| 87 |
|
| 88 |
/* UniPG>> */ |
| 89 |
fprintf(stdout,"List of parameters for the JPEG 2000 " |
| 90 |
#ifdef USE_JPWL |
| 91 |
"+ JPWL " |
| 92 |
#endif /* USE_JPWL */ |
| 93 |
"decoder:\n"); |
| 94 |
/* <<UniPG */ |
| 95 |
fprintf(stdout,"\n"); |
| 96 |
fprintf(stdout,"\n"); |
| 97 |
fprintf(stdout," -ImgDir \n"); |
| 98 |
fprintf(stdout," Image file Directory path \n"); |
| 99 |
fprintf(stdout," -OutFor \n"); |
| 100 |
fprintf(stdout," REQUIRED only if -ImgDir is used\n"); |
| 101 |
fprintf(stdout," Need to specify only format without filename <BMP> \n"); |
| 102 |
fprintf(stdout," Currently accepts PGM, PPM, PNM, PGX, BMP format\n"); |
| 103 |
fprintf(stdout," -i <compressed file>\n"); |
| 104 |
fprintf(stdout," REQUIRED only if an Input image directory not specified\n"); |
| 105 |
fprintf(stdout," Currently accepts J2K-files, JP2-files and JPT-files. The file type\n"); |
| 106 |
fprintf(stdout," is identified based on its suffix.\n"); |
| 107 |
fprintf(stdout," -o <decompressed file>\n"); |
| 108 |
fprintf(stdout," REQUIRED\n"); |
| 109 |
fprintf(stdout," Currently accepts PGM-files, PPM-files, PNM-files, PGX-files and\n"); |
| 110 |
fprintf(stdout," BMP-files. Binary data is written to the file (not ascii). If a PGX\n"); |
| 111 |
fprintf(stdout," filename is given, there will be as many output files as there are\n"); |
| 112 |
fprintf(stdout," components: an indice starting from 0 will then be appended to the\n"); |
| 113 |
fprintf(stdout," output filename, just before the \"pgx\" extension. If a PGM filename\n"); |
| 114 |
fprintf(stdout," is given and there are more than one component, only the first component\n"); |
| 115 |
fprintf(stdout," will be written to the file.\n"); |
| 116 |
fprintf(stdout," -r <reduce factor>\n"); |
| 117 |
fprintf(stdout," Set the number of highest resolution levels to be discarded. The\n"); |
| 118 |
fprintf(stdout," image resolution is effectively divided by 2 to the power of the\n"); |
| 119 |
fprintf(stdout," number of discarded levels. The reduce factor is limited by the\n"); |
| 120 |
fprintf(stdout," smallest total number of decomposition levels among tiles.\n"); |
| 121 |
fprintf(stdout," -l <number of quality layers to decode>\n"); |
| 122 |
fprintf(stdout," Set the maximum number of quality layers to decode. If there are\n"); |
| 123 |
fprintf(stdout," less quality layers than the specified number, all the quality layers\n"); |
| 124 |
fprintf(stdout," are decoded.\n"); |
| 125 |
/* UniPG>> */ |
| 126 |
#ifdef USE_JPWL |
| 127 |
fprintf(stdout," -W <options>\n"); |
| 128 |
fprintf(stdout," Activates the JPWL correction capability, if the codestream complies.\n"); |
| 129 |
fprintf(stdout," Options can be a comma separated list of <param=val> tokens:\n"); |
| 130 |
fprintf(stdout," c, c=numcomps\n"); |
| 131 |
fprintf(stdout," numcomps is the number of expected components in the codestream\n"); |
| 132 |
fprintf(stdout," (search of first EPB rely upon this, default is %d)\n", JPWL_EXPECTED_COMPONENTS); |
| 133 |
#endif /* USE_JPWL */ |
| 134 |
/* <<UniPG */ |
| 135 |
fprintf(stdout,"\n"); |
| 136 |
} |
| 137 |
|
| 138 |
/* -------------------------------------------------------------------------- */ |
| 139 |
|
| 140 |
int get_num_images(char *imgdirpath){ |
| 141 |
DIR *dir; |
| 142 |
struct dirent* content; |
| 143 |
int num_images = 0; |
| 144 |
|
| 145 |
/*Reading the input images from given input directory*/ |
| 146 |
|
| 147 |
dir= opendir(imgdirpath); |
| 148 |
if(!dir){ |
| 149 |
fprintf(stderr,"Could not open Folder %s\n",imgdirpath); |
| 150 |
return 0; |
| 151 |
} |
| 152 |
|
| 153 |
while((content=readdir(dir))!=NULL){ |
| 154 |
if(strcmp(".",content->d_name)==0 || strcmp("..",content->d_name)==0 ) |
| 155 |
continue; |
| 156 |
num_images++; |
| 157 |
} |
| 158 |
return num_images; |
| 159 |
} |
| 160 |
|
| 161 |
int load_images(dircnt_t *dirptr, char *imgdirpath){ |
| 162 |
DIR *dir; |
| 163 |
struct dirent* content; |
| 164 |
int i = 0; |
| 165 |
|
| 166 |
/*Reading the input images from given input directory*/ |
| 167 |
|
| 168 |
dir= opendir(imgdirpath); |
| 169 |
if(!dir){ |
| 170 |
fprintf(stderr,"Could not open Folder %s\n",imgdirpath); |
| 171 |
return 1; |
| 172 |
}else { |
| 173 |
fprintf(stderr,"Folder opened successfully\n"); |
| 174 |
} |
| 175 |
|
| 176 |
while((content=readdir(dir))!=NULL){ |
| 177 |
if(strcmp(".",content->d_name)==0 || strcmp("..",content->d_name)==0 ) |
| 178 |
continue; |
| 179 |
|
| 180 |
strcpy(dirptr->filename[i],content->d_name); |
| 181 |
i++; |
| 182 |
} |
| 183 |
return 0; |
| 184 |
} |
| 185 |
|
| 186 |
int get_file_format(char *filename) { |
| 187 |
unsigned int i; |
| 188 |
static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp","tif", "raw", "tga", "j2k", "jp2", "jpt", "j2c" }; |
| 189 |
static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, TGA_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT, J2K_CFMT }; |
| 190 |
char * ext = strrchr(filename, '.'); |
| 191 |
if (ext == NULL) |
| 192 |
return -1; |
| 193 |
ext++; |
| 194 |
if(ext) { |
| 195 |
for(i = 0; i < sizeof(format)/sizeof(*format); i++) { |
| 196 |
if(strnicmp(ext, extension[i], 3) == 0) { |
| 197 |
return format[i]; |
| 198 |
} |
| 199 |
} |
| 200 |
} |
| 201 |
|
| 202 |
return -1; |
| 203 |
} |
| 204 |
|
| 205 |
|
| 206 |
/* -------------------------------------------------------------------------- */ |
| 207 |
|
| 208 |
int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,img_fol_t *img_fol) { |
| 209 |
/* parse the command line */ |
| 210 |
int totlen; |
| 211 |
opj_option_t long_option[]={ |
| 212 |
{"ImgDir",REQ_ARG, NULL ,'y'}, |
| 213 |
{"OutFor",REQ_ARG, NULL ,'O'}, |
| 214 |
}; |
| 215 |
|
| 216 |
/* UniPG>> */ |
| 217 |
const char optlist[] = "i:o:r:l:hx:" |
| 218 |
|
| 219 |
#ifdef USE_JPWL |
| 220 |
"W:" |
| 221 |
#endif /* USE_JPWL */ |
| 222 |
; |
| 223 |
/*for (i=0; i<argc; i++) { |
| 224 |
printf("[%s]",argv[i]); |
| 225 |
} |
| 226 |
printf("\n");*/ |
| 227 |
|
| 228 |
/* <<UniPG */ |
| 229 |
totlen=sizeof(long_option); |
| 230 |
img_fol->set_out_format = 0; |
| 231 |
reset_options_reading(); |
| 232 |
|
| 233 |
while (1) { |
| 234 |
int c = opj_getopt_long(argc, argv,optlist,long_option,totlen); |
| 235 |
if (c == -1) |
| 236 |
break; |
| 237 |
switch (c) { |
| 238 |
case 'i': /* input file */ |
| 239 |
{ |
| 240 |
char *infile = opj_optarg; |
| 241 |
parameters->decod_format = get_file_format(infile); |
| 242 |
switch(parameters->decod_format) { |
| 243 |
case J2K_CFMT: |
| 244 |
case JP2_CFMT: |
| 245 |
case JPT_CFMT: |
| 246 |
break; |
| 247 |
default: |
| 248 |
fprintf(stderr, |
| 249 |
"!! Unrecognized format for infile : %s [accept only *.j2k, *.jp2, *.jpc or *.jpt] !!\n\n", |
| 250 |
infile); |
| 251 |
return 1; |
| 252 |
} |
| 253 |
strncpy(parameters->infile, infile, sizeof(parameters->infile)-1); |
| 254 |
} |
| 255 |
break; |
| 256 |
|
| 257 |
/* ----------------------------------------------------- */ |
| 258 |
|
| 259 |
case 'o': /* output file */ |
| 260 |
{ |
| 261 |
char *outfile = opj_optarg; |
| 262 |
parameters->cod_format = get_file_format(outfile); |
| 263 |
switch(parameters->cod_format) { |
| 264 |
case PGX_DFMT: |
| 265 |
case PXM_DFMT: |
| 266 |
case BMP_DFMT: |
| 267 |
case TIF_DFMT: |
| 268 |
case RAW_DFMT: |
| 269 |
case TGA_DFMT: |
| 270 |
break; |
| 271 |
default: |
| 272 |
fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outfile); |
| 273 |
return 1; |
| 274 |
} |
| 275 |
strncpy(parameters->outfile, outfile, sizeof(parameters->outfile)-1); |
| 276 |
} |
| 277 |
break; |
| 278 |
|
| 279 |
/* ----------------------------------------------------- */ |
| 280 |
|
| 281 |
case 'O': /* output format */ |
| 282 |
{ |
| 283 |
char outformat[50]; |
| 284 |
char *of = opj_optarg; |
| 285 |
sprintf(outformat,".%s",of); |
| 286 |
img_fol->set_out_format = 1; |
| 287 |
parameters->cod_format = get_file_format(outformat); |
| 288 |
switch(parameters->cod_format) { |
| 289 |
case PGX_DFMT: |
| 290 |
img_fol->out_format = "pgx"; |
| 291 |
break; |
| 292 |
case PXM_DFMT: |
| 293 |
img_fol->out_format = "ppm"; |
| 294 |
break; |
| 295 |
case BMP_DFMT: |
| 296 |
img_fol->out_format = "bmp"; |
| 297 |
break; |
| 298 |
case TIF_DFMT: |
| 299 |
img_fol->out_format = "tif"; |
| 300 |
break; |
| 301 |
case RAW_DFMT: |
| 302 |
img_fol->out_format = "raw"; |
| 303 |
break; |
| 304 |
case TGA_DFMT: |
| 305 |
img_fol->out_format = "raw"; |
| 306 |
break; |
| 307 |
default: |
| 308 |
fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outformat); |
| 309 |
return 1; |
| 310 |
break; |
| 311 |
} |
| 312 |
} |
| 313 |
break; |
| 314 |
|
| 315 |
/* ----------------------------------------------------- */ |
| 316 |
|
| 317 |
|
| 318 |
case 'r': /* reduce option */ |
| 319 |
{ |
| 320 |
sscanf(opj_optarg, "%d", ¶meters->cp_reduce); |
| 321 |
} |
| 322 |
break; |
| 323 |
|
| 324 |
/* ----------------------------------------------------- */ |
| 325 |
|
| 326 |
|
| 327 |
case 'l': /* layering option */ |
| 328 |
{ |
| 329 |
sscanf(opj_optarg, "%d", ¶meters->cp_layer); |
| 330 |
} |
| 331 |
break; |
| 332 |
|
| 333 |
/* ----------------------------------------------------- */ |
| 334 |
|
| 335 |
case 'h': /* display an help description */ |
| 336 |
decode_help_display(); |
| 337 |
return 1; |
| 338 |
|
| 339 |
/* ------------------------------------------------------ */ |
| 340 |
|
| 341 |
case 'y': /* Image Directory path */ |
| 342 |
{ |
| 343 |
img_fol->imgdirpath = (char*)opj_malloc(strlen(opj_optarg) + 1); |
| 344 |
strcpy(img_fol->imgdirpath,opj_optarg); |
| 345 |
img_fol->set_imgdir=1; |
| 346 |
} |
| 347 |
break; |
| 348 |
/* ----------------------------------------------------- */ |
| 349 |
/* UniPG>> */ |
| 350 |
#ifdef USE_JPWL |
| 351 |
|
| 352 |
case 'W': /* activate JPWL correction */ |
| 353 |
{ |
| 354 |
char *token = NULL; |
| 355 |
|
| 356 |
token = strtok(opj_optarg, ","); |
| 357 |
while(token != NULL) { |
| 358 |
|
| 359 |
/* search expected number of components */ |
| 360 |
if (*token == 'c') { |
| 361 |
|
| 362 |
static int compno; |
| 363 |
|
| 364 |
compno = JPWL_EXPECTED_COMPONENTS; /* predefined no. of components */ |
| 365 |
|
| 366 |
if(sscanf(token, "c=%d", &compno) == 1) { |
| 367 |
/* Specified */ |
| 368 |
if ((compno < 1) || (compno > 256)) { |
| 369 |
fprintf(stderr, "ERROR -> invalid number of components c = %d\n", compno); |
| 370 |
return 1; |
| 371 |
} |
| 372 |
parameters->jpwl_exp_comps = compno; |
| 373 |
|
| 374 |
} else if (!strcmp(token, "c")) { |
| 375 |
/* default */ |
| 376 |
parameters->jpwl_exp_comps = compno; /* auto for default size */ |
| 377 |
|
| 378 |
} else { |
| 379 |
fprintf(stderr, "ERROR -> invalid components specified = %s\n", token); |
| 380 |
return 1; |
| 381 |
}; |
| 382 |
} |
| 383 |
|
| 384 |
/* search maximum number of tiles */ |
| 385 |
if (*token == 't') { |
| 386 |
|
| 387 |
static int tileno; |
| 388 |
|
| 389 |
tileno = JPWL_MAXIMUM_TILES; /* maximum no. of tiles */ |
| 390 |
|
| 391 |
if(sscanf(token, "t=%d", &tileno) == 1) { |
| 392 |
/* Specified */ |
| 393 |
if ((tileno < 1) || (tileno > JPWL_MAXIMUM_TILES)) { |
| 394 |
fprintf(stderr, "ERROR -> invalid number of tiles t = %d\n", tileno); |
| 395 |
return 1; |
| 396 |
} |
| 397 |
parameters->jpwl_max_tiles = tileno; |
| 398 |
|
| 399 |
} else if (!strcmp(token, "t")) { |
| 400 |
/* default */ |
| 401 |
parameters->jpwl_max_tiles = tileno; /* auto for default size */ |
| 402 |
|
| 403 |
} else { |
| 404 |
fprintf(stderr, "ERROR -> invalid tiles specified = %s\n", token); |
| 405 |
return 1; |
| 406 |
}; |
| 407 |
} |
| 408 |
|
| 409 |
/* next token or bust */ |
| 410 |
token = strtok(NULL, ","); |
| 411 |
}; |
| 412 |
parameters->jpwl_correct = true; |
| 413 |
fprintf(stdout, "JPWL correction capability activated\n"); |
| 414 |
fprintf(stdout, "- expecting %d components\n", parameters->jpwl_exp_comps); |
| 415 |
} |
| 416 |
break; |
| 417 |
#endif /* USE_JPWL */ |
| 418 |
/* <<UniPG */ |
| 419 |
|
| 420 |
/* ----------------------------------------------------- */ |
| 421 |
|
| 422 |
default: |
| 423 |
fprintf(stderr,"WARNING -> this option is not valid \"-%c %s\"\n",c, opj_optarg); |
| 424 |
break; |
| 425 |
} |
| 426 |
} |
| 427 |
|
| 428 |
/* No check for possible errors before the -i and -o options are of course not mandatory*/ |
| 429 |
|
| 430 |
return 0; |
| 431 |
} |
| 432 |
|
| 433 |
/* -------------------------------------------------------------------------- */ |
| 434 |
|
| 435 |
/** |
| 436 |
error callback returning the message to Java andexpecting a callback_variables_t client object |
| 437 |
*/ |
| 438 |
void error_callback(const char *msg, void *client_data) { |
| 439 |
callback_variables_t* vars = (callback_variables_t*) client_data; |
| 440 |
JNIEnv *env = vars->env; |
| 441 |
jstring jbuffer; |
| 442 |
|
| 443 |
jbuffer = (*env)->NewStringUTF(env, msg); |
| 444 |
(*env)->ExceptionClear(env); |
| 445 |
(*env)->CallVoidMethod(env, *(vars->jobj), vars->error_mid, jbuffer); |
| 446 |
|
| 447 |
if ((*env)->ExceptionOccurred(env)) { |
| 448 |
fprintf(stderr,"C: Exception during call back method\n"); |
| 449 |
(*env)->ExceptionDescribe(env); |
| 450 |
(*env)->ExceptionClear(env); |
| 451 |
} |
| 452 |
(*env)->DeleteLocalRef(env, jbuffer); |
| 453 |
} |
| 454 |
/** |
| 455 |
warning callback returning the message to Java andexpecting a callback_variables_t client object |
| 456 |
*/ |
| 457 |
void warning_callback(const char *msg, void *client_data) { |
| 458 |
callback_variables_t* vars = (callback_variables_t*) client_data; |
| 459 |
JNIEnv *env = vars->env; |
| 460 |
jstring jbuffer; |
| 461 |
|
| 462 |
jbuffer = (*env)->NewStringUTF(env, msg); |
| 463 |
(*env)->ExceptionClear(env); |
| 464 |
(*env)->CallVoidMethod(env, *(vars->jobj), vars->message_mid, jbuffer); |
| 465 |
|
| 466 |
if ((*env)->ExceptionOccurred(env)) { |
| 467 |
fprintf(stderr,"C: Exception during call back method\n"); |
| 468 |
(*env)->ExceptionDescribe(env); |
| 469 |
(*env)->ExceptionClear(env); |
| 470 |
} |
| 471 |
(*env)->DeleteLocalRef(env, jbuffer); |
| 472 |
} |
| 473 |
/** |
| 474 |
information callback returning the message to Java andexpecting a callback_variables_t client object |
| 475 |
*/ |
| 476 |
void info_callback(const char *msg, void *client_data) { |
| 477 |
callback_variables_t* vars = (callback_variables_t*) client_data; |
| 478 |
JNIEnv *env = vars->env; |
| 479 |
jstring jbuffer; |
| 480 |
|
| 481 |
jbuffer = (*env)->NewStringUTF(env, msg); |
| 482 |
(*env)->ExceptionClear(env); |
| 483 |
(*env)->CallVoidMethod(env, *(vars->jobj), vars->message_mid, jbuffer); |
| 484 |
|
| 485 |
if ((*env)->ExceptionOccurred(env)) { |
| 486 |
fprintf(stderr,"C: Exception during call back method\n"); |
| 487 |
(*env)->ExceptionDescribe(env); |
| 488 |
(*env)->ExceptionClear(env); |
| 489 |
} |
| 490 |
(*env)->DeleteLocalRef(env, jbuffer); |
| 491 |
} |
| 492 |
|
| 493 |
|
| 494 |
/* -------------------------------------------------------------------------- |
| 495 |
-------------------- MAIN METHOD, CALLED BY JAVA -----------------------*/ |
| 496 |
JNIEXPORT jint JNICALL Java_org_openJpeg_OpenJPEGJavaDecoder_internalDecodeJ2KtoImage(JNIEnv *env, jobject obj, jobjectArray javaParameters) { |
| 497 |
int argc; /* To simulate the command line parameters (taken from the javaParameters variable) and be able to re-use the */ |
| 498 |
char **argv; /* 'parse_cmdline_decoder' method taken from the j2k_to_image project */ |
| 499 |
opj_dparameters_t parameters; /* decompression parameters */ |
| 500 |
img_fol_t img_fol; |
| 501 |
opj_event_mgr_t event_mgr; /* event manager */ |
| 502 |
opj_image_t *image = NULL; |
| 503 |
FILE *fsrc = NULL; |
| 504 |
unsigned char *src = NULL; |
| 505 |
int file_length; |
| 506 |
int num_images; |
| 507 |
int i,j,imageno; |
| 508 |
opj_dinfo_t* dinfo = NULL; /* handle to a decompressor */ |
| 509 |
opj_cio_t *cio = NULL; |
| 510 |
int w,h; |
| 511 |
long min_value, max_value; |
| 512 |
short tempS; unsigned char tempUC, tempUC1, tempUC2; |
| 513 |
/* ==> Access variables to the Java member variables*/ |
| 514 |
jsize arraySize; |
| 515 |
jclass cls; |
| 516 |
jobject object; |
| 517 |
jboolean isCopy; |
| 518 |
jfieldID fid; |
| 519 |
jbyteArray jba; |
| 520 |
jshortArray jsa; |
| 521 |
jintArray jia; |
| 522 |
jbyte *jbBody, *ptrBBody; |
| 523 |
jshort *jsBody, *ptrSBody; |
| 524 |
jint *jiBody, *ptrIBody; |
| 525 |
callback_variables_t msgErrorCallback_vars; |
| 526 |
/* <=== access variable to Java member variables */ |
| 527 |
int *ptr, *ptr1, *ptr2; /* <== To transfer the decoded image to Java*/ |
| 528 |
|
| 529 |
/* configure the event callbacks */ |
| 530 |
memset(&event_mgr, 0, sizeof(opj_event_mgr_t)); |
| 531 |
event_mgr.error_handler = error_callback; |
| 532 |
event_mgr.warning_handler = warning_callback; |
| 533 |
event_mgr.info_handler = info_callback; |
| 534 |
|
| 535 |
/* JNI reference to the calling class*/ |
| 536 |
cls = (*env)->GetObjectClass(env, obj); |
| 537 |
|
| 538 |
/* Pointers to be able to call a Java method for all the info and error messages*/ |
| 539 |
msgErrorCallback_vars.env = env; |
| 540 |
msgErrorCallback_vars.jobj = &obj; |
| 541 |
msgErrorCallback_vars.message_mid = (*env)->GetMethodID(env, cls, "logMessage", "(Ljava/lang/String;)V"); |
| 542 |
msgErrorCallback_vars.error_mid = (*env)->GetMethodID(env, cls, "logError", "(Ljava/lang/String;)V"); |
| 543 |
|
| 544 |
/* Get the String[] containing the parameters, and converts it into a char** to simulate command line arguments.*/ |
| 545 |
arraySize = (*env)->GetArrayLength(env, javaParameters); |
| 546 |
argc = (int) arraySize +1; |
| 547 |
argv = opj_malloc(argc*sizeof(char*)); |
| 548 |
argv[0] = "ProgramName.exe"; /* The program name: useless*/ |
| 549 |
j=0; |
| 550 |
for (i=1; i<argc; i++) { |
| 551 |
object = (*env)->GetObjectArrayElement(env, javaParameters, i-1); |
| 552 |
argv[i] = (char*)(*env)->GetStringUTFChars(env, object, &isCopy); |
| 553 |
} |
| 554 |
|
| 555 |
/*printf("C: decoder params = "); |
| 556 |
for (i=0; i<argc; i++) { |
| 557 |
printf("[%s]",argv[i]); |
| 558 |
} |
| 559 |
printf("\n");*/ |
| 560 |
|
| 561 |
/* set decoding parameters to default values */ |
| 562 |
opj_set_default_decoder_parameters(¶meters); |
| 563 |
parameters.decod_format = J2K_CFMT; |
| 564 |
|
| 565 |
/* parse input and get user encoding parameters */ |
| 566 |
if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol) == 1) { |
| 567 |
/* Release the Java arguments array*/ |
| 568 |
for (i=1; i<argc; i++) |
| 569 |
(*env)->ReleaseStringUTFChars(env, (*env)->GetObjectArrayElement(env, javaParameters, i-1), argv[i]); |
| 570 |
return -1; |
| 571 |
} |
| 572 |
/* Release the Java arguments array*/ |
| 573 |
for (i=1; i<argc; i++) |
| 574 |
(*env)->ReleaseStringUTFChars(env, (*env)->GetObjectArrayElement(env, javaParameters, i-1), argv[i]); |
| 575 |
|
| 576 |
num_images=1; |
| 577 |
|
| 578 |
/* Get additional information from the Java object variables*/ |
| 579 |
fid = (*env)->GetFieldID(env, cls,"skippedResolutions", "I"); |
| 580 |
parameters.cp_reduce = (short) (*env)->GetIntField(env, obj, fid); |
| 581 |
|
| 582 |
/*Decoding image one by one*/ |
| 583 |
for(imageno = 0; imageno < num_images ; imageno++) |
| 584 |
{ |
| 585 |
image = NULL; |
| 586 |
fprintf(stderr,"\n"); |
| 587 |
|
| 588 |
/* read the input file and put it in memory into the 'src' object, if the -i option is given in JavaParameters. |
| 589 |
Implemented for debug purpose. */ |
| 590 |
/* -------------------------------------------------------------- */ |
| 591 |
if (parameters.infile && parameters.infile[0]!='\0') { |
| 592 |
/*printf("C: opening [%s]\n", parameters.infile);*/ |
| 593 |
fsrc = fopen(parameters.infile, "rb"); |
| 594 |
if (!fsrc) { |
| 595 |
fprintf(stderr, "ERROR -> failed to open %s for reading\n", parameters.infile); |
| 596 |
return 1; |
| 597 |
} |
| 598 |
fseek(fsrc, 0, SEEK_END); |
| 599 |
file_length = ftell(fsrc); |
| 600 |
fseek(fsrc, 0, SEEK_SET); |
| 601 |
src = (unsigned char *) opj_malloc(file_length); |
| 602 |
fread(src, 1, file_length, fsrc); |
| 603 |
fclose(fsrc); |
| 604 |
/*printf("C: %d bytes read from file\n",file_length);*/ |
| 605 |
} else { |
| 606 |
/* Preparing the transfer of the codestream from Java to C*/ |
| 607 |
/*printf("C: before transferring codestream\n");*/ |
| 608 |
fid = (*env)->GetFieldID(env, cls,"compressedStream", "[B"); |
| 609 |
jba = (*env)->GetObjectField(env, obj, fid); |
| 610 |
file_length = (*env)->GetArrayLength(env, jba); |
| 611 |
jbBody = (*env)->GetByteArrayElements(env, jba, &isCopy); |
| 612 |
src = (unsigned char*)jbBody; |
| 613 |
} |
| 614 |
|
| 615 |
/* decode the code-stream */ |
| 616 |
/* ---------------------- */ |
| 617 |
|
| 618 |
switch(parameters.decod_format) { |
| 619 |
case J2K_CFMT: |
| 620 |
{ |
| 621 |
/* JPEG-2000 codestream */ |
| 622 |
|
| 623 |
/* get a decoder handle */ |
| 624 |
dinfo = opj_create_decompress(CODEC_J2K); |
| 625 |
|
| 626 |
/* catch events using our callbacks and give a local context */ |
| 627 |
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, &msgErrorCallback_vars); |
| 628 |
|
| 629 |
/* setup the decoder decoding parameters using user parameters */ |
| 630 |
opj_setup_decoder(dinfo, ¶meters); |
| 631 |
|
| 632 |
/* open a byte stream */ |
| 633 |
cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length); |
| 634 |
|
| 635 |
/* decode the stream and fill the image structure */ |
| 636 |
image = opj_decode(dinfo, cio); |
| 637 |
if(!image) { |
| 638 |
fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n"); |
| 639 |
opj_destroy_decompress(dinfo); |
| 640 |
opj_cio_close(cio); |
| 641 |
return 1; |
| 642 |
} |
| 643 |
|
| 644 |
/* close the byte stream */ |
| 645 |
opj_cio_close(cio); |
| 646 |
} |
| 647 |
break; |
| 648 |
|
| 649 |
case JP2_CFMT: |
| 650 |
{ |
| 651 |
/* JPEG 2000 compressed image data */ |
| 652 |
|
| 653 |
/* get a decoder handle */ |
| 654 |
dinfo = opj_create_decompress(CODEC_JP2); |
| 655 |
|
| 656 |
/* catch events using our callbacks and give a local context */ |
| 657 |
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, &msgErrorCallback_vars); |
| 658 |
|
| 659 |
/* setup the decoder decoding parameters using the current image and user parameters */ |
| 660 |
opj_setup_decoder(dinfo, ¶meters); |
| 661 |
|
| 662 |
/* open a byte stream */ |
| 663 |
cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length); |
| 664 |
|
| 665 |
/* decode the stream and fill the image structure */ |
| 666 |
image = opj_decode(dinfo, cio); |
| 667 |
if(!image) { |
| 668 |
fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n"); |
| 669 |
opj_destroy_decompress(dinfo); |
| 670 |
opj_cio_close(cio); |
| 671 |
return 1; |
| 672 |
} |
| 673 |
|
| 674 |
/* close the byte stream */ |
| 675 |
opj_cio_close(cio); |
| 676 |
|
| 677 |
} |
| 678 |
break; |
| 679 |
|
| 680 |
case JPT_CFMT: |
| 681 |
{ |
| 682 |
/* JPEG 2000, JPIP */ |
| 683 |
|
| 684 |
/* get a decoder handle */ |
| 685 |
dinfo = opj_create_decompress(CODEC_JPT); |
| 686 |
|
| 687 |
/* catch events using our callbacks and give a local context */ |
| 688 |
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, &msgErrorCallback_vars); |
| 689 |
|
| 690 |
/* setup the decoder decoding parameters using user parameters */ |
| 691 |
opj_setup_decoder(dinfo, ¶meters); |
| 692 |
|
| 693 |
/* open a byte stream */ |
| 694 |
cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length); |
| 695 |
|
| 696 |
/* decode the stream and fill the image structure */ |
| 697 |
image = opj_decode(dinfo, cio); |
| 698 |
if(!image) { |
| 699 |
fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n"); |
| 700 |
opj_destroy_decompress(dinfo); |
| 701 |
opj_cio_close(cio); |
| 702 |
return 1; |
| 703 |
} |
| 704 |
|
| 705 |
/* close the byte stream */ |
| 706 |
opj_cio_close(cio); |
| 707 |
} |
| 708 |
break; |
| 709 |
|
| 710 |
default: |
| 711 |
fprintf(stderr, "skipping file..\n"); |
| 712 |
continue; |
| 713 |
} |
| 714 |
|
| 715 |
/* free the memory containing the code-stream */ |
| 716 |
if (parameters.infile && parameters.infile[0]!='\0') { |
| 717 |
opj_free(src); |
| 718 |
} else { |
| 719 |
(*env)->ReleaseByteArrayElements(env, jba, jbBody, 0); |
| 720 |
} |
| 721 |
src = NULL; |
| 722 |
|
| 723 |
/* create output image. |
| 724 |
If the -o parameter is given in the JavaParameters, write the decoded version into a file. |
| 725 |
Implemented for debug purpose. */ |
| 726 |
/* ---------------------------------- */ |
| 727 |
switch (parameters.cod_format) { |
| 728 |
case PXM_DFMT: /* PNM PGM PPM */ |
| 729 |
if (imagetopnm(image, parameters.outfile)) { |
| 730 |
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile); |
| 731 |
} |
| 732 |
else { |
| 733 |
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile); |
| 734 |
} |
| 735 |
break; |
| 736 |
|
| 737 |
case PGX_DFMT: /* PGX */ |
| 738 |
if(imagetopgx(image, parameters.outfile)){ |
| 739 |
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile); |
| 740 |
} |
| 741 |
else { |
| 742 |
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile); |
| 743 |
} |
| 744 |
break; |
| 745 |
|
| 746 |
case BMP_DFMT: /* BMP */ |
| 747 |
if(imagetobmp(image, parameters.outfile)){ |
| 748 |
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile); |
| 749 |
} |
| 750 |
else { |
| 751 |
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile); |
| 752 |
} |
| 753 |
break; |
| 754 |
|
| 755 |
} |
| 756 |
|
| 757 |
/* ========= Return the image to the Java structure ===============*/ |
| 758 |
#ifdef CHECK_THRESHOLDS |
| 759 |
printf("C: checking thresholds\n"); |
| 760 |
#endif |
| 761 |
/* First compute the real with and height, in function of the resolutions decoded.*/ |
| 762 |
/*wr = (image->comps[0].w + (1 << image->comps[0].factor) -1) >> image->comps[0].factor;*/ |
| 763 |
/*hr = (image->comps[0].h + (1 << image->comps[0].factor) -1) >> image->comps[0].factor;*/ |
| 764 |
w = image->comps[0].w; |
| 765 |
h = image->comps[0].h; |
| 766 |
|
| 767 |
if (image->numcomps==3) { /* 3 components color image*/ |
| 768 |
ptr = image->comps[0].data; |
| 769 |
ptr1 = image->comps[1].data; |
| 770 |
ptr2 = image->comps[2].data; |
| 771 |
#ifdef CHECK_THRESHOLDS |
| 772 |
if (image->comps[0].sgnd) { |
| 773 |
min_value = -128; |
| 774 |
max_value = 127; |
| 775 |
} else { |
| 776 |
min_value = 0; |
| 777 |
max_value = 255; |
| 778 |
} |
| 779 |
#endif |
| 780 |
/* Get the pointer to the Java structure where the data must be copied*/ |
| 781 |
fid = (*env)->GetFieldID(env, cls,"image24", "[I"); |
| 782 |
jia = (*env)->GetObjectField(env, obj, fid); |
| 783 |
jiBody = (*env)->GetIntArrayElements(env, jia, 0); |
| 784 |
ptrIBody = jiBody; |
| 785 |
printf("C: transferring image24: %d int to Java pointer=%d\n",image->numcomps*w*h, ptrIBody); |
| 786 |
|
| 787 |
for (i=0; i<w*h; i++) { |
| 788 |
tempUC = (unsigned char)(ptr[i]); |
| 789 |
tempUC1 = (unsigned char)(ptr1[i]); |
| 790 |
tempUC2 = (unsigned char)(ptr2[i]); |
| 791 |
#ifdef CHECK_THRESHOLDS |
| 792 |
if (tempUC < min_value) |
| 793 |
tempUC=min_value; |
| 794 |
else if (tempUC > max_value) |
| 795 |
tempUC=max_value; |
| 796 |
if (tempUC1 < min_value) |
| 797 |
tempUC1=min_value; |
| 798 |
else if (tempUC1 > max_value) |
| 799 |
tempUC1=max_value; |
| 800 |
if (tempUC2 < min_value) |
| 801 |
tempUC2=min_value; |
| 802 |
else if (tempUC2 > max_value) |
| 803 |
tempUC2=max_value; |
| 804 |
#endif |
| 805 |
*(ptrIBody++) = (int) ( (tempUC2<<16) + (tempUC1<<8) + tempUC ); |
| 806 |
} |
| 807 |
(*env)->ReleaseIntArrayElements(env, jia, jiBody, 0); |
| 808 |
|
| 809 |
} else { /* 1 component 8 or 16 bpp image*/ |
| 810 |
ptr = image->comps[0].data; |
| 811 |
printf("C: before transferring a %d bpp image to java (length = %d)\n",image->comps[0].prec ,w*h); |
| 812 |
if (image->comps[0].prec<=8) { |
| 813 |
fid = (*env)->GetFieldID(env, cls,"image8", "[B"); |
| 814 |
jba = (*env)->GetObjectField(env, obj, fid); |
| 815 |
jbBody = (*env)->GetByteArrayElements(env, jba, 0); |
| 816 |
ptrBBody = jbBody; |
| 817 |
#ifdef CHECK_THRESHOLDS |
| 818 |
if (image->comps[0].sgnd) { |
| 819 |
min_value = -128; |
| 820 |
max_value = 127; |
| 821 |
} else { |
| 822 |
min_value = 0; |
| 823 |
max_value = 255; |
| 824 |
} |
| 825 |
#endif |
| 826 |
/*printf("C: transferring %d shorts to Java image8 pointer = %d\n", wr*hr,ptrSBody);*/ |
| 827 |
for (i=0; i<w*h; i++) { |
| 828 |
tempUC = (unsigned char) (ptr[i]); |
| 829 |
#ifdef CHECK_THRESHOLDS |
| 830 |
if (tempUC<min_value) |
| 831 |
tempUC = min_value; |
| 832 |
else if (tempUC > max_value) |
| 833 |
tempUC = max_value; |
| 834 |
#endif |
| 835 |
*(ptrBBody++) = tempUC; |
| 836 |
} |
| 837 |
(*env)->ReleaseByteArrayElements(env, jba, jbBody, 0); |
| 838 |
printf("C: image8 transferred to Java\n"); |
| 839 |
} else { |
| 840 |
fid = (*env)->GetFieldID(env, cls,"image16", "[S"); |
| 841 |
jsa = (*env)->GetObjectField(env, obj, fid); |
| 842 |
jsBody = (*env)->GetShortArrayElements(env, jsa, 0); |
| 843 |
ptrSBody = jsBody; |
| 844 |
#ifdef CHECK_THRESHOLDS |
| 845 |
if (image->comps[0].sgnd) { |
| 846 |
min_value = -32768; |
| 847 |
max_value = 32767; |
| 848 |
} else { |
| 849 |
min_value = 0; |
| 850 |
max_value = 65535; |
| 851 |
} |
| 852 |
printf("C: minValue = %d, maxValue = %d\n", min_value, max_value); |
| 853 |
#endif |
| 854 |
printf("C: transferring %d shorts to Java image16 pointer = %d\n", w*h,ptrSBody); |
| 855 |
for (i=0; i<w*h; i++) { |
| 856 |
tempS = (short) (ptr[i]); |
| 857 |
#ifdef CHECK_THRESHOLDS |
| 858 |
if (tempS<min_value) { |
| 859 |
printf("C: value %d truncated to %d\n", tempS, min_value); |
| 860 |
tempS = min_value; |
| 861 |
} else if (tempS > max_value) { |
| 862 |
printf("C: value %d truncated to %d\n", tempS, max_value); |
| 863 |
tempS = max_value; |
| 864 |
} |
| 865 |
#endif |
| 866 |
*(ptrSBody++) = tempS; |
| 867 |
} |
| 868 |
(*env)->ReleaseShortArrayElements(env, jsa, jsBody, 0); |
| 869 |
printf("C: image16 completely filled\n"); |
| 870 |
} |
| 871 |
} |
| 872 |
|
| 873 |
|
| 874 |
/* free remaining structures */ |
| 875 |
if(dinfo) { |
| 876 |
opj_destroy_decompress(dinfo); |
| 877 |
} |
| 878 |
/* free image data structure */ |
| 879 |
opj_image_destroy(image); |
| 880 |
|
| 881 |
} |
| 882 |
return 1; /* OK */ |
| 883 |
} |
| 884 |
/*end main*/ |
| 885 |
|