opj_codestream_info_v2_t* get_info(struct opj_res *resources) {
opj_codestream_info_v2_t* cstr_info = NULL;
cstr_info = opj_get_cstr_info(resources->l_codec);
return cstr_info;
}
/* -------------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
FILE *fout = NULL;
opj_dparameters_t parameters; /* Decompression parameters */
opj_image_t* image = NULL; /* Image structure */
opj_codec_t* l_codec = NULL; /* Handle to a decompressor */
opj_stream_t *l_stream = NULL; /* Stream */
opj_codestream_info_v2_t* cstr_info = NULL;
opj_codestream_index_t* cstr_index = NULL;
int32_t num_images, imageno;
img_fol_t img_fol;
dircnt_t *dirptr = NULL;
#ifdef MSD
bool l_go_on = true;
uint32_t l_max_data_size = 1000;
uint8_t * l_data = (uint8_t *) malloc(1000);
#endif
/* Set decoding parameters to default values */
opj_set_default_decoder_parameters(¶meters);
/* Initialize img_fol */
memset(&img_fol,0,sizeof(img_fol_t));
img_fol.flag = OPJ_IMG_INFO | OPJ_J2K_MH_INFO | OPJ_J2K_MH_IND;
/* Parse input and get user encoding parameters */
if(parse_cmdline_decoder(argc, argv, ¶meters,&img_fol) == 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;
}
/* Try to open for writing the output file if necessary */
if (parameters.outfile[0] != 0) {
fout = fopen(parameters.outfile,"w");
if (!fout) {
fprintf(stderr, "ERROR -> failed to open %s for writing\n", parameters.outfile);
return EXIT_FAILURE;
}
} else
fout = stdout;
/* Read the header of each 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 */
/* ---------------------------------------- */
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);
return EXIT_FAILURE;
}
/* Read 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_dump: failed to setup the decoder\n");
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
fclose(fout);
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_dump: failed to read the header\n");
opj_stream_destroy(l_stream);
opj_destroy_codec(l_codec);
opj_image_destroy(image);
fclose(fout);
return EXIT_FAILURE;
}
opj_dump_codec(l_codec, img_fol.flag, fout );
cstr_info = opj_get_cstr_info(l_codec);
cstr_index = opj_get_cstr_index(l_codec);
/* close the byte stream */
opj_stream_destroy(l_stream);
/* free remaining structures */
if (l_codec) {
opj_destroy_codec(l_codec);
}
/* destroy the image header */
opj_image_destroy(image);
/* destroy the codestream index */
opj_destroy_cstr_index(&cstr_index);
/* destroy the codestream info */
opj_destroy_cstr_info(&cstr_info);
}
/* Close the output file */
fclose(fout);
return 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;
}
OpenJPEG_readHeader(OpenJPEGReaderImpl *impl, nrt_Error *error)
{
opj_stream_t *stream = NULL;
opj_image_t *image = NULL;
opj_codec_t *codec = NULL;
opj_codestream_info_v2_t* codeStreamInfo = NULL;
NRT_BOOL rc = NRT_SUCCESS;
OPJ_UINT32 tileWidth, tileHeight;
OPJ_UINT32 imageWidth, imageHeight;
if (!OpenJPEG_setup(impl, &stream, &codec, error))
{
goto CATCH_ERROR;
}
if (!opj_read_header(stream, codec, &image))
{
/*nrt_Error_init(error, "Error reading header", NRT_CTXT, NRT_ERR_UNK);*/
goto CATCH_ERROR;
}
codeStreamInfo = opj_get_cstr_info(codec);
if (!codeStreamInfo)
{
/*nrt_Error_init(error, "Error reading code stream", NRT_CTXT, NRT_ERR_UNK);*/
goto CATCH_ERROR;
}
tileWidth = codeStreamInfo->tdx;
tileHeight = codeStreamInfo->tdy;
/* sanity checking */
if (!image)
{
nrt_Error_init(error, "NULL image after reading header", NRT_CTXT,
NRT_ERR_UNK);
goto CATCH_ERROR;
}
if (image->x0 >= image->x1 || image->y0 >= image->y1)
{
nrt_Error_init(error, "Invalid image offsets", NRT_CTXT, NRT_ERR_UNK);
goto CATCH_ERROR;
}
if (image->numcomps == 0)
{
nrt_Error_init(error, "No image components found", NRT_CTXT,
NRT_ERR_UNK);
goto CATCH_ERROR;
}
/* TODO: We need special handling that's not implemented in readTile() to
* accommodate partial tiles with more than one band. */
imageWidth = image->x1 - image->x0;
imageHeight = image->y1 - image->y0;
if (image->numcomps > 1 &&
(imageWidth % tileWidth != 0 || imageHeight % tileHeight != 0))
{
nrt_Error_init(error, "No image components found", NRT_CTXT,
NRT_ERR_UNK);
goto CATCH_ERROR;
}
if (!impl->container)
{
/* initialize the container */
nrt_Uint32 idx;
j2k_Component **components = NULL;
int imageType;
if (!(components = (j2k_Component**)J2K_MALLOC(
sizeof(j2k_Component*) * image->numcomps)))
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
for(idx = 0; idx < image->numcomps; ++idx)
{
opj_image_comp_t cmp = image->comps[idx];
if (!(components[idx] = j2k_Component_construct(cmp.w, cmp.h,
cmp.prec, cmp.sgnd,
cmp.x0, cmp.y0,
cmp.dx, cmp.dy,
error)))
{
goto CATCH_ERROR;
}
}
switch(image->color_space)
{
case OPJ_CLRSPC_SRGB:
imageType = J2K_TYPE_RGB;
break;
case OPJ_CLRSPC_GRAY:
imageType = J2K_TYPE_MONO;
break;
default:
imageType = J2K_TYPE_UNKNOWN;
}
if (!(impl->container = j2k_Container_construct(image->x1 - image->x0,
image->y1 - image->y0,
image->numcomps,
components,
tileWidth, tileHeight,
imageType, error)))
{
goto CATCH_ERROR;
}
}
goto CLEANUP;
CATCH_ERROR:
{
rc = NRT_FAILURE;
}
CLEANUP:
{
opj_destroy_cstr_info(&codeStreamInfo);
OpenJPEG_cleanup(&stream, &codec, &image);
}
return rc;
}
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 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_info_v2_t* cstr_info = NULL;
/* Index of corner tiles */
OPJ_UINT32 tile_ul = 0;
OPJ_UINT32 tile_ur = 0;
OPJ_UINT32 tile_lr = 0;
OPJ_UINT32 tile_ll = 0;
if (argc != 2) {
fprintf(stderr, "Usage: %s <input_file>\n", argv[0]);
return EXIT_FAILURE;
}
/* Set decoding parameters to default values */
opj_set_default_decoder_parameters(¶meters);
strncpy(parameters.infile, argv[1], OPJ_PATH_LEN - 1);
/* read the input file */
/* ------------------- */
fsrc = fopen(parameters.infile, "rb");
if (!fsrc) {
fprintf(stderr, "ERROR -> failed to open %s for reading\n", parameters.infile);
return EXIT_FAILURE;
}
/* decode the JPEG2000 stream */
/* -------------------------- */
parameters.decod_format = infile_format(parameters.infile);
switch(parameters.decod_format) {
case J2K_CFMT: /* JPEG-2000 codestream */
{
/* Get a decoder handle */
l_codec = opj_create_decompress_v2(CODEC_J2K);
break;
}
case JP2_CFMT: /* JPEG 2000 compressed image data */
{
/* Get a decoder handle */
l_codec = opj_create_decompress_v2(CODEC_JP2);
break;
}
case JPT_CFMT: /* JPEG 2000, JPIP */
{
/* Get a decoder handle */
l_codec = opj_create_decompress_v2(CODEC_JPT);
break;
}
default:
fprintf(stderr,
"Unrecognized format for input %s [accept only *.j2k, *.jp2, *.jpc or *.jpt]\n\n",
parameters.infile);
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);
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;
}
/* Setup the decoder decoding parameters using user parameters */
if ( !opj_setup_decoder_v2(l_codec, ¶meters) ){
fprintf(stderr, "ERROR -> j2k_dump: 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 -> j2k_to_image: 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;
}
/* Extract some info from the code stream */
cstr_info = opj_get_cstr_info(l_codec);
fprintf(stdout, "The file contains %dx%d tiles\n", cstr_info->tw, cstr_info->th);
tile_ul = 0;
tile_ur = cstr_info->tw - 1;
tile_lr = cstr_info->tw * cstr_info->th - 1;
tile_ll = tile_lr - cstr_info->tw;
#define TEST_TILE( tile_index ) \
fprintf(stdout, "Decoding tile %d ...\n", tile_index); \
if(!opj_get_decoded_tile(l_codec, l_stream, image, tile_index )){ \
fprintf(stderr, "ERROR -> j2k_to_image: failed to decode tile %d\n", tile_index); \
opj_stream_destroy(l_stream); \
opj_destroy_cstr_info_v2(&cstr_info); \
opj_destroy_codec(l_codec); \
opj_image_destroy(image); \
fclose(fsrc); \
return EXIT_FAILURE; \
} \
fprintf(stdout, "Tile %d is decoded successfully\n", tile_index);
TEST_TILE(tile_ul)
TEST_TILE(tile_lr)
TEST_TILE(tile_ul)
TEST_TILE(tile_ll)
TEST_TILE(tile_ur)
TEST_TILE(tile_lr)
/* Close the byte stream */
opj_stream_destroy(l_stream);
/* Destroy code stream info */
opj_destroy_cstr_info_v2(&cstr_info);
/* Free remaining structures */
opj_destroy_codec(l_codec);
/* Free image data structure */
opj_image_destroy(image);
/* Close the input file */
fclose(fsrc);
return EXIT_SUCCESS;
}
