JNIEXPORT jintArray JNICALL Java_nl_kb_jp2_JP2Reader_getTile
(JNIEnv *env, jclass cls, jstring fname, jint tile_index, jint reduction_factor, jobjectArray pixels) {
const char *filename = (*env)->GetStringUTFChars(env, fname, 0);
jclass intArrayClass = (*env)->FindClass(env, "[I");
jintArray ary = (*env)->NewIntArray(env, 3);
int data[3];
int i = 0;
for(i = 0; i < 3; ++i) { data[i] = 0; }
data[0] = READ_FAILURE;
FILE *fptr = fopen(filename, "rb");
if(fptr != NULL && is_jp2(fptr)) {
opj_dparameters_t parameters;
opj_set_default_decoder_parameters(¶meters);
parameters.cp_reduce = reduction_factor;
struct opj_res resources = opj_init(filename, ¶meters);
if(resources.status == 0 && opj_get_decoded_tile(resources.l_codec, resources.l_stream, resources.image, tile_index)) {
int numpix = resources.image->comps[0].w * resources.image->comps[0].h;
int comp;
for(comp = 0; comp < resources.image->numcomps; ++comp) {
jintArray data = (*env)->NewIntArray(env, numpix);
(*env)->SetIntArrayRegion(env, data, (jsize) 0, (jsize) numpix, (jint*) resources.image->comps[comp].data);
(*env)->SetObjectArrayElement(env, pixels, (jsize) comp, data);
}
data[0] = READ_SUCCESS;
data[1] = resources.image->comps[0].w;
data[2] = resources.image->comps[0].h;
}
opj_cleanup(&resources);
}
(*env)->SetIntArrayRegion(env, ary, 0, 3, data);
return ary;
}
/* -------------------------------------------------------------------------- */
int main(int argc, char **argv)
{
FILE *fsrc = NULL;
opj_dparameters_t parameters; /* decompression parameters */
opj_image_t* image = NULL;
opj_stream_t *l_stream = NULL; /* Stream */
opj_codec_t* l_codec = NULL; /* Handle to a decompressor */
opj_codestream_index_t* cstr_index = NULL;
char indexfilename[OPJ_PATH_LEN]; /* index file name */
OPJ_INT32 num_images, imageno;
img_fol_t img_fol;
dircnt_t *dirptr = NULL;
int failed = 0;
/* set decoding parameters to default values */
opj_set_default_decoder_parameters(¶meters);
/* FIXME Initialize indexfilename and img_fol */
*indexfilename = 0;
/* Initialize img_fol */
memset(&img_fol,0,sizeof(img_fol_t));
/* parse input and get user encoding parameters */
if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol, indexfilename) == 1) {
return EXIT_FAILURE;
}
/* Initialize reading of directory */
if(img_fol.set_imgdir==1){
int it_image;
num_images=get_num_images(img_fol.imgdirpath);
dirptr=(dircnt_t*)malloc(sizeof(dircnt_t));
if(dirptr){
dirptr->filename_buf = (char*)malloc((size_t)num_images*OPJ_PATH_LEN*sizeof(char)); /* Stores at max 10 image file names*/
dirptr->filename = (char**) malloc((size_t)num_images*sizeof(char*));
if(!dirptr->filename_buf){
return EXIT_FAILURE;
}
for(it_image=0;it_image<num_images;it_image++){
dirptr->filename[it_image] = dirptr->filename_buf + it_image*OPJ_PATH_LEN;
}
}
if(load_images(dirptr,img_fol.imgdirpath)==1){
return EXIT_FAILURE;
}
if (num_images==0){
fprintf(stdout,"Folder is empty\n");
return EXIT_FAILURE;
}
}else{
num_images=1;
}
/*Decoding image one by one*/
for(imageno = 0; imageno < num_images ; imageno++) {
fprintf(stderr,"\n");
if(img_fol.set_imgdir==1){
if (get_next_file(imageno, dirptr,&img_fol, ¶meters)) {
fprintf(stderr,"skipping file...\n");
continue;
}
}
/* read the input file and put it in memory */
/* ---------------------------------------- */
fsrc = fopen(parameters.infile, "rb");
if (!fsrc) {
fprintf(stderr, "ERROR -> failed to open %s for reading\n", parameters.infile);
return EXIT_FAILURE;
}
l_stream = opj_stream_create_default_file_stream(fsrc,1);
if (!l_stream){
fclose(fsrc);
fprintf(stderr, "ERROR -> failed to create the stream from the file\n");
return EXIT_FAILURE;
}
/* decode the JPEG2000 stream */
/* ---------------------- */
switch(parameters.decod_format) {
case J2K_CFMT: /* JPEG-2000 codestream */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_J2K);
break;
}
case JP2_CFMT: /* JPEG 2000 compressed image data */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JP2);
break;
}
case JPT_CFMT: /* JPEG 2000, JPIP */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JPT);
break;
}
default:
fprintf(stderr, "skipping file..\n");
opj_stream_destroy(l_stream);
continue;
}
/* catch events using our callbacks and give a local context */
opj_set_info_handler(l_codec, info_callback,00);
opj_set_warning_handler(l_codec, warning_callback,00);
opj_set_error_handler(l_codec, error_callback,00);
/* Setup the decoder decoding parameters using user parameters */
if ( !opj_setup_decoder(l_codec, ¶meters) ){
fprintf(stderr, "ERROR -> opj_compress: failed to setup the decoder\n");
opj_stream_destroy(l_stream);
fclose(fsrc);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
/* Read the main header of the codestream and if necessary the JP2 boxes*/
if(! opj_read_header(l_stream, l_codec, &image)){
fprintf(stderr, "ERROR -> opj_decompress: failed to read the header\n");
opj_stream_destroy(l_stream);
fclose(fsrc);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return EXIT_FAILURE;
}
if (!parameters.nb_tile_to_decode) {
/* Optional if you want decode the entire image */
if (!opj_set_decode_area(l_codec, image, (OPJ_INT32)parameters.DA_x0,
(OPJ_INT32)parameters.DA_y0, (OPJ_INT32)parameters.DA_x1, (OPJ_INT32)parameters.DA_y1)){
fprintf(stderr, "ERROR -> opj_decompress: failed to set the decoded area\n");
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
fclose(fsrc);
return EXIT_FAILURE;
}
/* Get the decoded image */
if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) {
fprintf(stderr,"ERROR -> opj_decompress: failed to decode image!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
fclose(fsrc);
return EXIT_FAILURE;
}
}
else {
/* It is just here to illustrate how to use the resolution after set parameters */
/*if (!opj_set_decoded_resolution_factor(l_codec, 5)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to set the resolution factor tile!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
fclose(fsrc);
return EXIT_FAILURE;
}*/
if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to decode tile!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
fclose(fsrc);
return EXIT_FAILURE;
}
fprintf(stdout, "tile %d is decoded!\n\n", parameters.tile_index);
}
/* Close the byte stream */
opj_stream_destroy(l_stream);
fclose(fsrc);
if(image->color_space == OPJ_CLRSPC_SYCC){
color_sycc_to_rgb(image); /* FIXME */
}
if( image->color_space != OPJ_CLRSPC_SYCC
&& image->numcomps == 3 && image->comps[0].dx == image->comps[0].dy
&& image->comps[1].dx != 1 )
image->color_space = OPJ_CLRSPC_SYCC;
else if (image->numcomps <= 2)
image->color_space = OPJ_CLRSPC_GRAY;
if(image->icc_profile_buf) {
#if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
color_apply_icc_profile(image); /* FIXME */
#endif
free(image->icc_profile_buf);
image->icc_profile_buf = NULL; image->icc_profile_len = 0;
}
/* create output image */
/* ------------------- */
switch (parameters.cod_format) {
case PXM_DFMT: /* PNM PGM PPM */
if (imagetopnm(image, parameters.outfile)) {
fprintf(stderr,"Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
case PGX_DFMT: /* PGX */
if(imagetopgx(image, parameters.outfile)){
fprintf(stderr,"Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
case BMP_DFMT: /* BMP */
if(imagetobmp(image, parameters.outfile)){
fprintf(stderr,"Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBTIFF
case TIF_DFMT: /* TIFF */
if(imagetotif(image, parameters.outfile)){
fprintf(stderr,"Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBTIFF */
case RAW_DFMT: /* RAW */
if(imagetoraw(image, parameters.outfile)){
fprintf(stderr,"Error generating raw file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
break;
case RAWL_DFMT: /* RAWL */
if(imagetorawl(image, parameters.outfile)){
fprintf(stderr,"Error generating rawl file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
break;
case TGA_DFMT: /* TGA */
if(imagetotga(image, parameters.outfile)){
fprintf(stderr,"Error generating tga file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBPNG
case PNG_DFMT: /* PNG */
if(imagetopng(image, parameters.outfile)){
fprintf(stderr,"Error generating png file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBPNG */
/* Can happen if output file is TIFF or PNG
* and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined
*/
default:
fprintf(stderr,"Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
/* free remaining structures */
if (l_codec) {
opj_destroy_codec(l_codec);
}
/* free image data structure */
opj_image_destroy(image);
/* destroy the codestream index */
opj_destroy_cstr_index(&cstr_index);
}
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
static Image *ReadJP2Image(const ImageInfo *image_info,ExceptionInfo *exception)
{
const char
*option;
Image
*image;
int
jp2_status;
MagickBooleanType
status;
opj_codec_t
*jp2_codec;
opj_codestream_index_t
*codestream_index = (opj_codestream_index_t *) NULL;
opj_dparameters_t
parameters;
opj_image_t
*jp2_image;
opj_stream_t
*jp2_stream;
register ssize_t
i;
ssize_t
y;
unsigned char
sans[4];
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Initialize JP2 codec.
*/
if (ReadBlob(image,4,sans) != 4)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
(void) SeekBlob(image,SEEK_SET,0);
if (LocaleCompare(image_info->magick,"JPT") == 0)
jp2_codec=opj_create_decompress(OPJ_CODEC_JPT);
else
if (IsJ2K(sans,4) != MagickFalse)
jp2_codec=opj_create_decompress(OPJ_CODEC_J2K);
else
jp2_codec=opj_create_decompress(OPJ_CODEC_JP2);
opj_set_warning_handler(jp2_codec,JP2WarningHandler,exception);
opj_set_error_handler(jp2_codec,JP2ErrorHandler,exception);
opj_set_default_decoder_parameters(¶meters);
option=GetImageOption(image_info,"jp2:reduce-factor");
if (option != (const char *) NULL)
parameters.cp_reduce=StringToInteger(option);
option=GetImageOption(image_info,"jp2:quality-layers");
if (option != (const char *) NULL)
parameters.cp_layer=StringToInteger(option);
if (opj_setup_decoder(jp2_codec,¶meters) == 0)
{
opj_destroy_codec(jp2_codec);
ThrowReaderException(DelegateError,"UnableToManageJP2Stream");
}
jp2_stream=opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,1);
opj_stream_set_read_function(jp2_stream,JP2ReadHandler);
opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
opj_stream_set_user_data(jp2_stream,image,NULL);
opj_stream_set_user_data_length(jp2_stream,GetBlobSize(image));
if (opj_read_header(jp2_stream,jp2_codec,&jp2_image) == 0)
{
opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
jp2_status=1;
if ((image->columns != 0) && (image->rows != 0))
{
/*
Extract an area from the image.
*/
jp2_status=opj_set_decode_area(jp2_codec,jp2_image,
(OPJ_INT32) image->extract_info.x,(OPJ_INT32) image->extract_info.y,
(OPJ_INT32) (image->extract_info.x+(ssize_t) image->columns),
(OPJ_INT32) (image->extract_info.y+(ssize_t) image->rows));
if (jp2_status == 0)
{
opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
}
if ((image_info->number_scenes != 0) && (image_info->scene != 0))
jp2_status=opj_get_decoded_tile(jp2_codec,jp2_stream,jp2_image,
(unsigned int) image_info->scene-1);
else
if (image->ping == MagickFalse)
{
jp2_status=opj_decode(jp2_codec,jp2_stream,jp2_image);
if (jp2_status != 0)
jp2_status=opj_end_decompress(jp2_codec,jp2_stream);
}
if (jp2_status == 0)
{
opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
opj_stream_destroy(jp2_stream);
for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
{
if ((jp2_image->comps[i].dx == 0) || (jp2_image->comps[i].dy == 0))
{
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported")
}
}
/* -------------------------------------------------------------------------- */
int main(int argc, char **argv)
{
opj_decompress_parameters parameters; /* decompression parameters */
opj_image_t* image = NULL;
opj_stream_t *l_stream = NULL; /* Stream */
opj_codec_t* l_codec = NULL; /* Handle to a decompressor */
opj_codestream_index_t* cstr_index = NULL;
char indexfilename[OPJ_PATH_LEN]; /* index file name */
OPJ_INT32 num_images, imageno;
img_fol_t img_fol;
dircnt_t *dirptr = NULL;
int failed = 0;
OPJ_FLOAT64 t, tCumulative = 0;
OPJ_UINT32 numDecompressedImages = 0;
/* set decoding parameters to default values */
set_default_parameters(¶meters);
/* FIXME Initialize indexfilename and img_fol */
*indexfilename = 0;
/* Initialize img_fol */
memset(&img_fol,0,sizeof(img_fol_t));
/* parse input and get user encoding parameters */
if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol, indexfilename) == 1) {
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
/* Initialize reading of directory */
if(img_fol.set_imgdir==1){
int it_image;
num_images=get_num_images(img_fol.imgdirpath);
dirptr=(dircnt_t*)malloc(sizeof(dircnt_t));
if(dirptr){
dirptr->filename_buf = (char*)malloc((size_t)num_images*OPJ_PATH_LEN*sizeof(char)); /* Stores at max 10 image file names*/
dirptr->filename = (char**) malloc((size_t)num_images*sizeof(char*));
if(!dirptr->filename_buf){
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
for(it_image=0;it_image<num_images;it_image++){
dirptr->filename[it_image] = dirptr->filename_buf + it_image*OPJ_PATH_LEN;
}
}
if(load_images(dirptr,img_fol.imgdirpath)==1){
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
if (num_images==0){
fprintf(stdout,"Folder is empty\n");
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
}else{
num_images=1;
}
/*Decoding image one by one*/
for(imageno = 0; imageno < num_images ; imageno++) {
fprintf(stderr,"\n");
if(img_fol.set_imgdir==1){
if (get_next_file(imageno, dirptr,&img_fol, ¶meters)) {
fprintf(stderr,"skipping file...\n");
destroy_parameters(¶meters);
continue;
}
}
/* read the input file and put it in memory */
/* ---------------------------------------- */
l_stream = opj_stream_create_default_file_stream(parameters.infile,1);
if (!l_stream){
fprintf(stderr, "ERROR -> failed to create the stream from the file %s\n", parameters.infile);
destroy_parameters(¶meters);
return EXIT_FAILURE;
}
/* decode the JPEG2000 stream */
/* ---------------------- */
switch(parameters.decod_format) {
case J2K_CFMT: /* JPEG-2000 codestream */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_J2K);
break;
}
case JP2_CFMT: /* JPEG 2000 compressed image data */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JP2);
break;
}
case JPT_CFMT: /* JPEG 2000, JPIP */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JPT);
break;
}
default:
fprintf(stderr, "skipping file..\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
continue;
}
/* catch events using our callbacks and give a local context */
opj_set_info_handler(l_codec, info_callback,00);
opj_set_warning_handler(l_codec, warning_callback,00);
opj_set_error_handler(l_codec, error_callback,00);
t = opj_clock();
/* Setup the decoder decoding parameters using user parameters */
if ( !opj_setup_decoder(l_codec, &(parameters.core)) ){
fprintf(stderr, "ERROR -> opj_decompress: failed to setup the decoder\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
/* Read the main header of the codestream and if necessary the JP2 boxes*/
if(! opj_read_header(l_stream, l_codec, &image)){
fprintf(stderr, "ERROR -> opj_decompress: failed to read the header\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return EXIT_FAILURE;
}
if (!parameters.nb_tile_to_decode) {
/* Optional if you want decode the entire image */
if (!opj_set_decode_area(l_codec, image, (OPJ_INT32)parameters.DA_x0,
(OPJ_INT32)parameters.DA_y0, (OPJ_INT32)parameters.DA_x1, (OPJ_INT32)parameters.DA_y1)){
fprintf(stderr, "ERROR -> opj_decompress: failed to set the decoded area\n");
destroy_parameters(¶meters);
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return EXIT_FAILURE;
}
/* Get the decoded image */
if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) {
fprintf(stderr,"ERROR -> opj_decompress: failed to decode image!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}
}
else {
/* It is just here to illustrate how to use the resolution after set parameters */
/*if (!opj_set_decoded_resolution_factor(l_codec, 5)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to set the resolution factor tile!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}*/
if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to decode tile!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
opj_stream_destroy(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}
fprintf(stdout, "tile %d is decoded!\n\n", parameters.tile_index);
}
tCumulative += opj_clock() - t;
numDecompressedImages++;
/* Close the byte stream */
opj_stream_destroy(l_stream);
if( image->color_space != OPJ_CLRSPC_SYCC
&& image->numcomps == 3 && image->comps[0].dx == image->comps[0].dy
&& image->comps[1].dx != 1 )
image->color_space = OPJ_CLRSPC_SYCC;
else if (image->numcomps <= 2)
image->color_space = OPJ_CLRSPC_GRAY;
if(image->color_space == OPJ_CLRSPC_SYCC){
color_sycc_to_rgb(image);
}
else if((image->color_space == OPJ_CLRSPC_CMYK) && (parameters.cod_format != TIF_DFMT)){
color_cmyk_to_rgb(image);
}
else if(image->color_space == OPJ_CLRSPC_EYCC){
color_esycc_to_rgb(image);
}
if(image->icc_profile_buf) {
#if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
if(image->icc_profile_len)
color_apply_icc_profile(image);
else
color_cielab_to_rgb(image);
#endif
free(image->icc_profile_buf);
image->icc_profile_buf = NULL; image->icc_profile_len = 0;
}
/* Force output precision */
/* ---------------------- */
if (parameters.precision != NULL)
{
OPJ_UINT32 compno;
for (compno = 0; compno < image->numcomps; ++compno)
{
OPJ_UINT32 precno = compno;
OPJ_UINT32 prec;
if (precno >= parameters.nb_precision) {
precno = parameters.nb_precision - 1U;
}
prec = parameters.precision[precno].prec;
if (prec == 0) {
prec = image->comps[compno].prec;
}
switch (parameters.precision[precno].mode) {
case OPJ_PREC_MODE_CLIP:
clip_component(&(image->comps[compno]), prec);
break;
case OPJ_PREC_MODE_SCALE:
scale_component(&(image->comps[compno]), prec);
break;
default:
break;
}
}
}
/* Upsample components */
/* ------------------- */
if (parameters.upsample)
{
image = upsample_image_components(image);
if (image == NULL) {
fprintf(stderr, "ERROR -> opj_decompress: failed to upsample image components!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
}
/* Force RGB output */
/* ---------------- */
if (parameters.force_rgb)
{
switch (image->color_space) {
case OPJ_CLRSPC_SRGB:
break;
case OPJ_CLRSPC_GRAY:
image = convert_gray_to_rgb(image);
break;
default:
fprintf(stderr, "ERROR -> opj_decompress: don't know how to convert image to RGB colorspace!\n");
opj_image_destroy(image);
image = NULL;
break;
}
if (image == NULL) {
fprintf(stderr, "ERROR -> opj_decompress: failed to convert to RGB image!\n");
destroy_parameters(¶meters);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
}
/* create output image */
/* ------------------- */
switch (parameters.cod_format) {
case PXM_DFMT: /* PNM PGM PPM */
if (imagetopnm(image, parameters.outfile, parameters.split_pnm)) {
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case PGX_DFMT: /* PGX */
if(imagetopgx(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case BMP_DFMT: /* BMP */
if(imagetobmp(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBTIFF
case TIF_DFMT: /* TIFF */
if(imagetotif(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBTIFF */
case RAW_DFMT: /* RAW */
if(imagetoraw(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating raw file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case RAWL_DFMT: /* RAWL */
if(imagetorawl(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating rawl file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
case TGA_DFMT: /* TGA */
if(imagetotga(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating tga file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBPNG
case PNG_DFMT: /* PNG */
if(imagetopng(image, parameters.outfile)){
fprintf(stderr,"[ERROR] Error generating png file. Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
else {
fprintf(stdout,"[INFO] Generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBPNG */
/* Can happen if output file is TIFF or PNG
* and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined
*/
default:
fprintf(stderr,"[ERROR] Outfile %s not generated\n",parameters.outfile);
failed = 1;
}
/* free remaining structures */
if (l_codec) {
opj_destroy_codec(l_codec);
}
/* free image data structure */
opj_image_destroy(image);
/* destroy the codestream index */
opj_destroy_cstr_index(&cstr_index);
if(failed) remove(parameters.outfile);
}
destroy_parameters(¶meters);
if (numDecompressedImages) {
fprintf(stdout, "decode time: %d ms\n", (int)( (tCumulative * 1000.0) / (OPJ_FLOAT64)numDecompressedImages));
}
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
void* OPJSupport::decompressJPEG2KWithBuffer(void* inputBuffer,
void* jp2Data,
long jp2DataSize,
long *decompressedBufferSize,
int *colorModel)
{
//decoderMutex.lock();
opj_dparameters_t parameters;
int i;
int width, height;
OPJ_BOOL hasAlpha, fails = OPJ_FALSE;
OPJ_CODEC_FORMAT codec_format;
unsigned char rc, gc, bc, ac;
if (jp2DataSize<12)
{
//decoderMutex.unlock();
return 0;
}
/*-----------------------------------------------*/
decode_info_t decodeInfo;
memset(&decodeInfo, 0, sizeof(decode_info_t));
opj_set_default_decoder_parameters(¶meters);
parameters.decod_format = buffer_format(jp2Data);
// Create the stream
opj_buffer_info_t bufferInfo;
bufferInfo.cur = bufferInfo.buf = (OPJ_BYTE *)jp2Data;
bufferInfo.len = (OPJ_SIZE_T) jp2DataSize;
// Create the stream
decodeInfo.stream = opj_stream_create_buffer_stream(&bufferInfo , OPJ_STREAM_READ);
//GROK
//decodeInfo.stream = opj_stream_create_buffer_stream((OPJ_BYTE *)jp2Data, (OPJ_SIZE_T) jp2DataSize , OPJ_STREAM_READ);
if (!decodeInfo.stream)
{
fprintf(stderr,"%s:%d:\n\tNO decodeInfo.stream\n",__FILE__,__LINE__);
//decoderMutex.unlock();
return NULL;
}
/*-----------------------------------------------*/
switch (parameters.decod_format)
{
case J2K_CFMT: /* JPEG-2000 codestream */
codec_format = OPJ_CODEC_J2K;
break;
case JP2_CFMT: /* JPEG 2000 compressed image data */
codec_format = OPJ_CODEC_JP2;
break;
case JPT_CFMT: /* JPEG 2000, JPIP */
codec_format = OPJ_CODEC_JPT;
break;
case -1:
default:
release(&decodeInfo);
fprintf(stderr,"%s:%d: decode format missing\n",__FILE__,__LINE__);
//decoderMutex.unlock();
return NULL;
}
/*-----------------------------------------------*/
while(1)
{
int user_changed_tile=0, user_changed_reduction=0;
int max_tiles=0, max_reduction=0;
fails = OPJ_TRUE;
decodeInfo.codec = opj_create_decompress(codec_format);
if (decodeInfo.codec == NULL)
{
fprintf(stderr,"%s:%d:\n\tNO codec\n",__FILE__,__LINE__);
break;
}
#ifdef OPJ_VERBOSE
opj_set_info_handler(decodeInfo.codec, info_callback, this);
opj_set_warning_handler(decodeInfo.codec, warning_callback, this);
#endif
opj_set_error_handler(decodeInfo.codec, error_callback, this);
// Setup the decoder decoding parameters
if ( !opj_setup_decoder(decodeInfo.codec, ¶meters))
{
fprintf(stderr,"%s:%d:\n\topj_setup_decoder failed\n",__FILE__,__LINE__);
break;
}
if (user_changed_tile && user_changed_reduction)
{
int reduction=0;
opj_set_decoded_resolution_factor(decodeInfo.codec, reduction);
}
/* Read the main header of the codestream and if necessary the JP2 boxes
* see openjpeg.c
* For OPJ_CODEC_JP2 it will call 'opj_jp2_read_header()' in jp2.c:2276
* then call 'opj_j2k_read_header()'
*/
if( !opj_read_header(decodeInfo.stream, decodeInfo.codec, &(decodeInfo.image)))
{
fprintf(stderr,"%s:%d:\n\topj_read_header failed\n",__FILE__,__LINE__);
break;
}
if ( !(user_changed_tile && user_changed_reduction)
|| (max_tiles <= 0) || (max_reduction <= 0) )
{
decodeInfo.cstr_info = opj_get_cstr_info(decodeInfo.codec);
max_reduction = decodeInfo.cstr_info->m_default_tile_info.tccp_info->numresolutions;
max_tiles = decodeInfo.cstr_info->tw * decodeInfo.cstr_info->th;
decodeInfo.cstr_index = opj_get_cstr_index(decodeInfo.codec);
}
if (!parameters.nb_tile_to_decode)
{
int user_changed_area=0;
if(user_changed_area)
{
}
/* Optional if you want decode the entire image */
if (!opj_set_decode_area(decodeInfo.codec, decodeInfo.image,
(OPJ_INT32)parameters.DA_x0,
(OPJ_INT32)parameters.DA_y0,
(OPJ_INT32)parameters.DA_x1,
(OPJ_INT32)parameters.DA_y1)) {
fprintf(stderr,"%s:%d:\n\topj_set_decode_area failed\n",__FILE__,__LINE__);
break;
}
/* Get the decoded image */
if (!opj_decode(decodeInfo.codec, decodeInfo.stream, decodeInfo.image)) {
fprintf(stderr,"%s:%d:\n\topj_decode failed\n",__FILE__,__LINE__);
//decoderMutex.unlock();
return NULL;
}
if (!opj_end_decompress(decodeInfo.codec, decodeInfo.stream)) {
fprintf(stderr,"%s:%d:\n\topj_end_decompress failed\n",__FILE__,__LINE__);
break;
}
}
else
{
if (!opj_get_decoded_tile(decodeInfo.codec, decodeInfo.stream, decodeInfo.image, parameters.tile_index))
{
fprintf(stderr,"%s:%d:\n\topj_get_decoded_tile failed\n",__FILE__,__LINE__);
break;
}
}
fails = OPJ_FALSE;
break;
} // while
decodeInfo.deleteImage = fails;
if (fails)
{
//decoderMutex.unlock();
return NULL;
}
decodeInfo.deleteImage = OPJ_TRUE;
if(decodeInfo.image->color_space == OPJ_CLRSPC_SYCC)
{
//disable for now
//color_sycc_to_rgb(decodeInfo.image);
}
if (decodeInfo.image->color_space != OPJ_CLRSPC_SYCC
&& decodeInfo.image->numcomps == 3
&& decodeInfo.image->comps[0].dx == decodeInfo.image->comps[0].dy
&& decodeInfo.image->comps[1].dx != 1)
{
decodeInfo.image->color_space = OPJ_CLRSPC_SYCC;
}
else if(decodeInfo.image->numcomps <= 2)
{
decodeInfo.image->color_space = OPJ_CLRSPC_GRAY;
}
if (decodeInfo.image->icc_profile_buf)
{
#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
color_apply_icc_profile(decodeInfo.image);
#endif
free(decodeInfo.image->icc_profile_buf);
decodeInfo.image->icc_profile_buf = NULL;
decodeInfo.image->icc_profile_len = 0;
}
//---
width = decodeInfo.image->comps[0].w;
height = decodeInfo.image->comps[0].h;
long depth = (decodeInfo.image->comps[0].prec + 7)/8;
long decompressSize = width * height * decodeInfo.image->numcomps * depth;
if (decompressedBufferSize)
*decompressedBufferSize = decompressSize;;
if (!inputBuffer )
{
inputBuffer = malloc(decompressSize);
}
if (colorModel)
*colorModel = 0;
if ((decodeInfo.image->numcomps >= 3
&& decodeInfo.image->comps[0].dx == decodeInfo.image->comps[1].dx
&& decodeInfo.image->comps[1].dx == decodeInfo.image->comps[2].dx
&& decodeInfo.image->comps[0].dy == decodeInfo.image->comps[1].dy
&& decodeInfo.image->comps[1].dy == decodeInfo.image->comps[2].dy
&& decodeInfo.image->comps[0].prec == decodeInfo.image->comps[1].prec
&& decodeInfo.image->comps[1].prec == decodeInfo.image->comps[2].prec
)/* RGB[A] */
||
(decodeInfo.image->numcomps == 2
&& decodeInfo.image->comps[0].dx == decodeInfo.image->comps[1].dx
&& decodeInfo.image->comps[0].dy == decodeInfo.image->comps[1].dy
&& decodeInfo.image->comps[0].prec == decodeInfo.image->comps[1].prec
)
) /* GA */
{
int has_alpha4, has_alpha2, has_rgb;
int *red, *green, *blue, *alpha;
if (colorModel)
*colorModel = 1;
alpha = NULL;
has_rgb = (decodeInfo.image->numcomps == 3);
has_alpha4 = (decodeInfo.image->numcomps == 4);
has_alpha2 = (decodeInfo.image->numcomps == 2);
hasAlpha = (has_alpha4 || has_alpha2);
if(has_rgb)
{
red = decodeInfo.image->comps[0].data;
green = decodeInfo.image->comps[1].data;
blue = decodeInfo.image->comps[2].data;
if(has_alpha4)
{
alpha = decodeInfo.image->comps[3].data;
}
} /* if(has_rgb) */
else
{
red = green = blue = decodeInfo.image->comps[0].data;
if(has_alpha2)
{
alpha = decodeInfo.image->comps[1].data;
}
} /* if(has_rgb) */
ac = 255;/* 255: FULLY_OPAQUE; 0: FULLY_TRANSPARENT */
unsigned char* ptrIBody = (unsigned char*)inputBuffer;
for(i = 0; i < width*height; i++)
{
rc = (unsigned char)*red++;
gc = (unsigned char)*green++;
bc = (unsigned char)*blue++;
if(hasAlpha)
{
ac = (unsigned char)*alpha++;;
}
/* A R G B
*/
//*ptrIBody++ = (int)((ac<<24) | (rc<<16) | (gc<<8) | bc);
*ptrIBody = rc;
ptrIBody++;
*ptrIBody = gc;
ptrIBody++;
*ptrIBody = bc;
ptrIBody++;
if (hasAlpha)
{
*ptrIBody = ac;
ptrIBody++;
}
} /* for(i) */
}/* if (decodeInfo.image->numcomps >= 3 */
else if(decodeInfo.image->numcomps == 1) /* Grey */
{
/* 1 component 8 or 16 bpp decodeInfo.image
*/
int *grey = decodeInfo.image->comps[0].data;
if(decodeInfo.image->comps[0].prec <= 8)
{
char* ptrBBody = (char*)inputBuffer;
for(i=0; i<width*height; i++)
{
*ptrBBody++ = *grey++;
}
/* Replace image8 buffer:
*/
}
else /* prec[9:16] */
{
int *grey = decodeInfo.image->comps[0].data;
//int ushift = 0, dshift = 0, force16 = 0;
short* ptrSBody = (short*)inputBuffer;
for(i=0; i<width*height; i++)
{
//disable shift up for signed data: don't know why we are doing this
*ptrSBody++ = *grey++;
}
/* Replace image16 buffer:
*/
}
}
else
{
int *grey;
fprintf(stderr,"%s:%d:Can show only first component of decodeInfo.image\n"
" components(%d) prec(%d) color_space[%d](%s)\n"
" RECT(%d,%d,%d,%d)\n",__FILE__,__LINE__,decodeInfo.image->numcomps,
decodeInfo.image->comps[0].prec,
decodeInfo.image->color_space,clr_space(decodeInfo.image->color_space),
decodeInfo.image->x0,decodeInfo.image->y0,decodeInfo.image->x1,decodeInfo.image->y1 );
for(i = 0; i < decodeInfo.image->numcomps; ++i)
{
fprintf(stderr,"[%d]dx(%d) dy(%d) w(%d) h(%d) signed(%u)\n",i,
decodeInfo.image->comps[i].dx ,decodeInfo.image->comps[i].dy,
decodeInfo.image->comps[i].w,decodeInfo.image->comps[i].h,
decodeInfo.image->comps[i].sgnd);
}
/* 1 component 8 or 16 bpp decodeInfo.image
*/
grey = decodeInfo.image->comps[0].data;
if(decodeInfo.image->comps[0].prec <= 8)
{
char* ptrBBody = (char*)inputBuffer;
for(i=0; i<width*height; i++)
{
*ptrBBody++ = *grey++;
}
/* Replace image8 buffer:
*/
}
else /* prec[9:16] */
{
int *grey;
//int ushift = 0, dshift = 0, force16 = 0;
grey = decodeInfo.image->comps[0].data;
short* ptrSBody = (short*)inputBuffer;
for(i=0; i<width*height; i++)
{
*ptrSBody++ = *grey++;
}
/* Replace image16 buffer:
*/
}
}
release(&decodeInfo);
opj_destroy_cstr_index(&(decodeInfo.cstr_index));
//decoderMutex.unlock();
return inputBuffer;
}
void* OPJSupport::decompressJPEG2KWithBuffer ( void* inputBuffer, void* jp2Data, long jp2DataSize, long *decompressedBufferSize, int *colorModel){
opj_dparameters_t parameters;
OPJ_BOOL hasFile = OPJ_FALSE;
opj_buffer_info_t buf_info;
int i, decod_format;
int width, height;
OPJ_BOOL hasAlpha, fails = OPJ_FALSE;
OPJ_CODEC_FORMAT codec_format;
unsigned char rc, gc, bc, ac;
decode_info_t decodeInfo;
memset(&decodeInfo, 0, sizeof(decode_info_t));
memset(&buf_info, 0, sizeof(opj_buffer_info_t));
if (jp2Data != NULL)
{
buf_info.len = jp2DataSize;
buf_info.buf = (OPJ_BYTE*)jp2Data;
buf_info.cur = buf_info.buf;
}
opj_set_default_decoder_parameters(¶meters);
decod_format = buffer_format(&buf_info);
if(decod_format == -1)
{
fprintf(stderr,"%s:%d: decode format missing\n",__FILE__,__LINE__);
release(&decodeInfo);
return 0;
}
/*-----------------------------------------------*/
if(decod_format == J2K_CFMT)
codec_format = OPJ_CODEC_J2K;
else
if(decod_format == JP2_CFMT)
codec_format = OPJ_CODEC_JP2;
else
if(decod_format == JPT_CFMT)
codec_format = OPJ_CODEC_JPT;
else
{
/* clarified in infile_format() : */
release(&decodeInfo);
return 0;
}
parameters.decod_format = decod_format;
while(1)
{
int tile_index=-1, user_changed_tile=0, user_changed_reduction=0;
int max_tiles=0, max_reduction=0;
fails = OPJ_TRUE;
decodeInfo.stream = opj_stream_create_buffer_stream(&buf_info, 1);
if(decodeInfo.stream == NULL)
{
fprintf(stderr,"%s:%d: NO decodeInfo.stream\n",__FILE__,__LINE__);
break;
}
decodeInfo.codec = opj_create_decompress(codec_format);
if(decodeInfo.codec == NULL)
{
fprintf(stderr,"%s:%d: NO coded\n",__FILE__,__LINE__);
break;
}
// opj_set_info_handler(decodeInfo.codec, error_callback, this);
// opj_set_info_handler(decodeInfo.codec, warning_callback, this);
// opj_set_info_handler(decodeInfo.codec, info_callback, this);
if( !opj_setup_decoder(decodeInfo.codec, ¶meters))
{
fprintf(stderr,"%s:%d:\n\topj_setup_decoder failed\n",__FILE__,__LINE__);
break;
}
if(user_changed_tile && user_changed_reduction)
{
int reduction=0;
opj_set_decoded_resolution_factor(decodeInfo.codec, reduction);
}
if( !opj_read_header(decodeInfo.stream, decodeInfo.codec, &decodeInfo.image))
{
fprintf(stderr,"%s:%d:\n\topj_read_header failed\n",__FILE__,__LINE__);
break;
}
if( !(user_changed_tile && user_changed_reduction)
|| (max_tiles <= 0) || (max_reduction <= 0) )
{
opj_codestream_info_v2_t *cstr;
cstr = opj_get_cstr_info(decodeInfo.codec);
max_reduction = cstr->m_default_tile_info.tccp_info->numresolutions;
max_tiles = cstr->tw * cstr->th;
}
if(tile_index < 0)
{
unsigned int x0, y0, x1, y1;
int user_changed_area=0;
x0 = y0 = x1 = y1 = 0;
if(user_changed_area)
{
}
if( !opj_set_decode_area(decodeInfo.codec, decodeInfo.image, x0, y0, x1, y1))
{
fprintf(stderr,"%s:%d:\n\topj_set_decode_area failed\n",__FILE__,__LINE__);
break;
}
if( !opj_decode(decodeInfo.codec, decodeInfo.stream, decodeInfo.image))
{
fprintf(stderr,"%s:%d:\n\topj_decode failed\n",__FILE__,__LINE__);
break;
}
} /* if(tile_index < 0) */
else
{
if( !opj_get_decoded_tile(decodeInfo.codec, decodeInfo.stream, decodeInfo.image, tile_index))
{
fprintf(stderr,"%s:%d:\n\topj_get_decoded_tile failed\n",__FILE__,__LINE__);
break;
}
}
if( !opj_end_decompress(decodeInfo.codec, decodeInfo.stream))
{
fprintf(stderr,"%s:%d:\n\topj_end_decompress failed\n",__FILE__,__LINE__);
break;
}
fails = OPJ_FALSE;
break;
}
decodeInfo.deleteImage = fails;
release(&decodeInfo);
if(fails)
{
return 0;
}
decodeInfo.deleteImage = OPJ_TRUE;
if(decodeInfo.image->color_space != OPJ_CLRSPC_SYCC
&& decodeInfo.image->numcomps == 3
&& decodeInfo.image->comps[0].dx == decodeInfo.image->comps[0].dy
&& decodeInfo.image->comps[1].dx != 1)
decodeInfo.image->color_space = OPJ_CLRSPC_SYCC;
else
if(decodeInfo.image->numcomps <= 2)
decodeInfo.image->color_space = OPJ_CLRSPC_GRAY;
if(decodeInfo.image->color_space == OPJ_CLRSPC_SYCC)
{
//disable for now
//color_sycc_to_rgb(decodeInfo.image);
}
if(decodeInfo.image->icc_profile_buf)
{
#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
color_apply_icc_profile(decodeInfo.image);
#endif
free(decodeInfo.image->icc_profile_buf);
decodeInfo.image->icc_profile_buf = NULL;
decodeInfo.image->icc_profile_len = 0;
}
width = decodeInfo.image->comps[0].w;
height = decodeInfo.image->comps[0].h;
long depth = (decodeInfo.image->comps[0].prec + 7)/8;
long decompressSize = width * height * decodeInfo.image->numcomps * depth;
if (decompressedBufferSize)
*decompressedBufferSize = decompressSize;;
if (!inputBuffer ) {
inputBuffer = malloc(decompressSize);
}
if (colorModel)
*colorModel = 0;
if ((decodeInfo.image->numcomps >= 3
&& decodeInfo.image->comps[0].dx == decodeInfo.image->comps[1].dx
&& decodeInfo.image->comps[1].dx == decodeInfo.image->comps[2].dx
&& decodeInfo.image->comps[0].dy == decodeInfo.image->comps[1].dy
&& decodeInfo.image->comps[1].dy == decodeInfo.image->comps[2].dy
&& decodeInfo.image->comps[0].prec == decodeInfo.image->comps[1].prec
&& decodeInfo.image->comps[1].prec == decodeInfo.image->comps[2].prec
)/* RGB[A] */
||
(decodeInfo.image->numcomps == 2
&& decodeInfo.image->comps[0].dx == decodeInfo.image->comps[1].dx
&& decodeInfo.image->comps[0].dy == decodeInfo.image->comps[1].dy
&& decodeInfo.image->comps[0].prec == decodeInfo.image->comps[1].prec
)
) /* GA */
{
int has_alpha4, has_alpha2, has_rgb;
int *red, *green, *blue, *alpha;
if (colorModel)
*colorModel = 1;
alpha = NULL;
has_rgb = (decodeInfo.image->numcomps == 3);
has_alpha4 = (decodeInfo.image->numcomps == 4);
has_alpha2 = (decodeInfo.image->numcomps == 2);
hasAlpha = (has_alpha4 || has_alpha2);
if(has_rgb)
{
red = decodeInfo.image->comps[0].data;
green = decodeInfo.image->comps[1].data;
blue = decodeInfo.image->comps[2].data;
if(has_alpha4)
{
alpha = decodeInfo.image->comps[3].data;
}
} /* if(has_rgb) */
else
{
red = green = blue = decodeInfo.image->comps[0].data;
if(has_alpha2)
{
alpha = decodeInfo.image->comps[1].data;
}
} /* if(has_rgb) */
ac = 255;/* 255: FULLY_OPAQUE; 0: FULLY_TRANSPARENT */
unsigned char* ptrIBody = (unsigned char*)inputBuffer;
for(i = 0; i < width*height; i++)
{
rc = (unsigned char) *red++;
gc = (unsigned char)*green++;
bc = (unsigned char)*blue++;
if(hasAlpha)
{
ac = (unsigned char)*alpha++;
// A R G B
unsigned int pixel = (int)((ac<<24) | (rc<<16) | (gc<<8) | bc);
*reinterpret_cast<unsigned int*>(ptrIBody) = pixel;
ptrIBody += sizeof(unsigned int);
}
else
{
*ptrIBody++ = bc;
*ptrIBody++ = gc;
*ptrIBody++ = rc;
}
} /* for(i) */
}/* if (decodeInfo.image->numcomps >= 3 */
else
if(decodeInfo.image->numcomps == 1) /* Grey */
{
/* 1 component 8 or 16 bpp decodeInfo.image
*/
int *grey = decodeInfo.image->comps[0].data;
if(decodeInfo.image->comps[0].prec <= 8)
{
char* ptrBBody = (char*)inputBuffer;
for(i=0; i<width*height; i++)
{
*ptrBBody++ = *grey++;
}
/* Replace image8 buffer:
*/
}
else /* prec[9:16] */
{
int *grey;
int ushift = 0, dshift = 0, force16 = 0;
grey = decodeInfo.image->comps[0].data;
short* ptrSBody = (short*)inputBuffer;
for(i=0; i<width*height; i++)
{
//disable shift up for signed data: don't know why we are doing this
*ptrSBody++ = *grey++;
}
/* Replace image16 buffer:
*/
}
}
else
{
int *grey;
fprintf(stderr,"%s:%d:Can show only first component of decodeInfo.image\n"
" components(%d) prec(%d) color_space[%d](%s)\n"
" RECT(%d,%d,%d,%d)\n",__FILE__,__LINE__,decodeInfo.image->numcomps,
decodeInfo.image->comps[0].prec,
decodeInfo.image->color_space,clr_space(decodeInfo.image->color_space),
decodeInfo.image->x0,decodeInfo.image->y0,decodeInfo.image->x1,decodeInfo.image->y1 );
for(i = 0; i < decodeInfo.image->numcomps; ++i)
{
fprintf(stderr,"[%d]dx(%d) dy(%d) w(%d) h(%d) signed(%u)\n",i,
decodeInfo.image->comps[i].dx ,decodeInfo.image->comps[i].dy,
decodeInfo.image->comps[i].w,decodeInfo.image->comps[i].h,
decodeInfo.image->comps[i].sgnd);
}
/* 1 component 8 or 16 bpp decodeInfo.image
*/
grey = decodeInfo.image->comps[0].data;
if(decodeInfo.image->comps[0].prec <= 8)
{
char* ptrBBody = (char*)inputBuffer;
for(i=0; i<width*height; i++)
{
*ptrBBody++ = *grey++;
}
/* Replace image8 buffer:
*/
}
else /* prec[9:16] */
{
int *grey;
int ushift = 0, dshift = 0, force16 = 0;
grey = decodeInfo.image->comps[0].data;
short* ptrSBody = (short*)inputBuffer;
for(i=0; i<width*height; i++)
{
*ptrSBody++ = *grey++;
}
/* Replace image16 buffer:
*/
}
}
release(&decodeInfo);
return inputBuffer;
}
/* -------------------------------------------------------------------------- */
int jp2_decompress_main(char *infile, char *buf, int bufsize)
{
int i;
int *dataptr;
opj_dparameters_t parameters; /* decompression parameters */
opj_image_t* image = NULL;
opj_stream_t *l_stream = NULL; /* Stream */
opj_codec_t* l_codec = NULL; /* Handle to a decompressor */
opj_codestream_index_t* cstr_index = NULL;
char indexfilename[OPJ_PATH_LEN]; /* index file name */
OPJ_INT32 num_images, imageno;
img_fol_t img_fol;
dircnt_t *dirptr = NULL;
/* set decoding parameters to default values */
opj_set_default_decoder_parameters(¶meters);
/* FIXME Initialize indexfilename and img_fol */
*indexfilename = 0;
/* Initialize img_fol */
memset(&img_fol,0,sizeof(img_fol_t));
/* parse input and get user encoding parameters */
if (0 != parse_cmdline_decoder(¶meters,&img_fol, infile)) {
return EXIT_FAILURE;
}
/* read the input file and put it in memory */
/* ---------------------------------------- */
l_stream = opj_stream_create_default_file_stream_v3(parameters.infile,1);
if (!l_stream){
return EXIT_FAILURE;
}
/* decode the JPEG2000 stream */
/* ---------------------- */
switch(parameters.decod_format) {
case J2K_CFMT: /* JPEG-2000 codestream */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_J2K);
break;
}
case JP2_CFMT: /* JPEG 2000 compressed image data */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JP2);
break;
}
case JPT_CFMT: /* JPEG 2000, JPIP */
{
/* Get a decoder handle */
l_codec = opj_create_decompress(OPJ_CODEC_JPT);
break;
}
default:
fprintf(stderr, "skipping file..\n");
opj_stream_destroy_v3(l_stream);
return EXIT_FAILURE;
}
/* catch events using our callbacks and give a local context */
opj_set_info_handler(l_codec, info_callback,00);
opj_set_warning_handler(l_codec, warning_callback,00);
opj_set_error_handler(l_codec, error_callback,00);
/* Setup the decoder decoding parameters using user parameters */
if ( !opj_setup_decoder(l_codec, ¶meters) ){
fprintf(stderr, "ERROR -> j2k_dump: failed to setup the decoder\n");
opj_stream_destroy_v3(l_stream);
opj_destroy_codec(l_codec);
return EXIT_FAILURE;
}
/* Read the main header of the codestream and if necessary the JP2 boxes*/
if(! opj_read_header(l_stream, l_codec, &image)){
fprintf(stderr, "ERROR -> opj_decompress: failed to read the header\n");
opj_stream_destroy_v3(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return EXIT_FAILURE;
}
if (!parameters.nb_tile_to_decode) {
/* Optional if you want decode the entire image */
if (!opj_set_decode_area(l_codec, image, parameters.DA_x0,
parameters.DA_y0, parameters.DA_x1, parameters.DA_y1)){
fprintf(stderr, "ERROR -> opj_decompress: failed to set the decoded area\n");
opj_stream_destroy_v3(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
return EXIT_FAILURE;
}
/* Get the decoded image */
if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) {
fprintf(stderr,"ERROR -> opj_decompress: failed to decode image!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy_v3(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}
}
else {
/* It is just here to illustrate how to use the resolution after set parameters */
/*if (!opj_set_decoded_resolution_factor(l_codec, 5)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to set the resolution factor tile!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy_v3(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}*/
if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) {
fprintf(stderr, "ERROR -> opj_decompress: failed to decode tile!\n");
opj_destroy_codec(l_codec);
opj_stream_destroy_v3(l_stream);
opj_image_destroy(image);
return EXIT_FAILURE;
}
fprintf(stdout, "tile %d is decoded!\n\n", parameters.tile_index);
}
/* Close the byte stream */
opj_stream_destroy_v3(l_stream);
if(image->color_space == OPJ_CLRSPC_SYCC){
color_sycc_to_rgb(image); /* FIXME */
}
if( image->color_space != OPJ_CLRSPC_SYCC
&& image->numcomps == 3 && image->comps[0].dx == image->comps[0].dy
&& image->comps[1].dx != 1 )
image->color_space = OPJ_CLRSPC_SYCC;
else if (image->numcomps <= 2)
image->color_space = OPJ_CLRSPC_GRAY;
if(image->icc_profile_buf) {
#if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
color_apply_icc_profile(image); /* FIXME */
#endif
free(image->icc_profile_buf);
image->icc_profile_buf = NULL; image->icc_profile_len = 0;
}
/* create output image */
/* ------------------- */
switch (parameters.cod_format) {
case PXM_DFMT: /* PNM PGM PPM */
if (imagetopnm(image, parameters.outfile)) {
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
case PGX_DFMT: /* PGX */
if(imagetopgx(image, parameters.outfile)){
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
case BMP_DFMT: /* BMP */
if(imagetobmp(image, parameters.outfile)){
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBTIFF
case TIF_DFMT: /* TIFF */
if(imagetotif(image, parameters.outfile)){
fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBTIFF */
case RAW_DFMT: /* RAW */
dataptr = &image->comps[0].data[0];
char mask = 0xFF;
for (i = 0; i < bufsize; i++) {
*buf++ = *dataptr++ & mask;
}
/*
if(imagetoraw(image, parameters.outfile)){
fprintf(stdout,"Error generating raw file. Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
*/
break;
case RAWL_DFMT: /* RAWL */
if(imagetorawl(image, parameters.outfile)){
fprintf(stdout,"Error generating rawl file. Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
break;
case TGA_DFMT: /* TGA */
if(imagetotga(image, parameters.outfile)){
fprintf(stdout,"Error generating tga file. Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
break;
#ifdef OPJ_HAVE_LIBPNG
case PNG_DFMT: /* PNG */
if(imagetopng(image, parameters.outfile)){
fprintf(stdout,"Error generating png file. Outfile %s not generated\n",parameters.outfile);
}
else {
fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
}
break;
#endif /* OPJ_HAVE_LIBPNG */
/* Can happen if output file is TIFF or PNG
* and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined
*/
default:
fprintf(stderr,"Outfile %s not generated\n",parameters.outfile);
}
/* free remaining structures */
if (l_codec) {
opj_destroy_codec(l_codec);
}
/* free image data structure */
opj_image_destroy(image);
/* destroy the codestream index */
opj_destroy_cstr_index(&cstr_index);
return EXIT_SUCCESS;
}