static void
readJpc(const char * const inputFilename,
jas_image_t ** const jasperPP) {
jas_image_t * jasperP;
jas_stream_t *instream;
const char * options;
if ( strcmp(inputFilename, "-") == 0) {
/* The input image is to be read from standard input. */
instream = jas_stream_fdopen(fileno(stdin), "rb");
if (instream == NULL)
pm_error("error: cannot reopen standard input");
} else {
instream = jas_stream_fopen(inputFilename, "rb");
if (instream == NULL )
pm_error("cannot open input image file '%s'", inputFilename);
}
if (jas_image_getfmt(instream) != jas_image_strtofmt((char*)"jpc"))
pm_error("Input is not JPEG-2000 code stream");
options = "";
jasperP = jas_image_decode(instream, jas_image_strtofmt((char*)"jpc"),
(char*)options);
if (jasperP == NULL)
pm_error("Unable to interpret JPEG-2000 input. "
"The Jasper library jas_image_decode() subroutine failed.");
jas_stream_close(instream);
*jasperPP = jasperP;
}
fz_error
fz_processjpxd(fz_filter *filter, fz_buffer *in, fz_buffer *out)
{
fz_jpxd *d = (fz_jpxd*)filter;
int n, bpc, w, h;
int i, x, y;
switch (d->stage)
{
case 0: goto input;
case 1: goto decode;
case 2: goto output;
}
input:
while (in->rp < in->wp)
{
n = jas_stream_write(d->stream, in->rp, in->wp - in->rp);
in->rp += n;
}
if (!in->eof)
return fz_ioneedin;
d->stage = 1;
decode:
jas_stream_seek(d->stream, 0, SEEK_SET);
d->image = jas_image_decode(d->stream, -1, nil);
if (!d->image)
return fz_throw("jasper error: jas_image_decode()");
d->stage = 2;
output:
w = jas_image_width(d->image);
h = jas_image_height(d->image);
n = jas_image_numcmpts(d->image);
bpc = jas_image_cmptprec(d->image, 0); /* use precision of first component for all... */
while (d->offset < w * h)
{
y = d->offset / w;
x = d->offset - y * w;
/* FIXME bpc != 8 */
if (out->wp + n >= out->ep)
return fz_ioneedout;
for (i = 0; i < n; i++)
*out->wp++ = jas_image_readcmptsample(d->image, i, x, y);
d->offset ++;
}
return fz_iodone;
}
bool jasperConvert(jas_image_t* &image, jas_stream_t* &out, const char* data, unsigned size, int outfmt, const char* outopts)
{
jas_stream_t *in;
// kDebug(YAHOO_RAW_DEBUG) << "Got data - size=" << size;
if(!(in = jas_stream_memopen(const_cast<char*>(data), size)))
{
kDebug(YAHOO_RAW_DEBUG) << "Could not open jasper input stream";
return false;
}
int infmt;
infmt = jas_image_getfmt(in);
if (infmt < 0)
{
jas_stream_close(in);
kDebug(YAHOO_RAW_DEBUG) << "Failed to recognize input webcam image format";
return false;
}
if (!(image = jas_image_decode(in, infmt, 0)))
{
kDebug(YAHOO_RAW_DEBUG) << "Unable to decode image";
jas_stream_close(in);
return false;
}
/* kDebug(YAHOO_RAW_DEBUG) << "jasper: decoded image: " << jas_image_width(image) << "x" << jas_image_height(image) << " bytes: " <<
jas_image_rawsize(image) << " components:" << jas_image_numcmpts(image);
*/
char* out_img = NULL;
if(!(out = jas_stream_memopen(out_img, 0)))
{
kDebug(YAHOO_RAW_DEBUG) << "Could not open output stream";
jas_stream_close(in);
return false;
}
if (jas_image_encode(image, out, outfmt, const_cast<char*>(outopts)))
{
kDebug(YAHOO_RAW_DEBUG) << "Unable to convert image";
jas_stream_close(in);
jas_stream_close(out);
jas_image_destroy(image);
return false;
}
jas_stream_flush(out);
jas_stream_close(in);
return true;
}
bool GrFmtJpeg2000Reader::ReadHeader()
{
bool result = false;
Close();
m_stream = jas_stream_fopen( m_filename, "rb" );
if( m_stream )
{
m_image = jas_image_decode( m_stream, -1, 0 );
if( m_image ) {
m_width = jas_image_width( m_image );
m_height = jas_image_height( m_image );
int cntcmpts = 0; // count the known components
int numcmpts = jas_image_numcmpts( m_image );
for( int i = 0; i < numcmpts; i++ )
{
int depth = jas_image_cmptprec( m_image, i );
if( depth > m_bit_depth )
m_bit_depth = depth;
if( m_bit_depth > 8 )
m_bit_depth = 16;
if( jas_image_cmpttype( m_image, i ) > 2 )
continue;
cntcmpts++;
}
if( cntcmpts )
{
m_iscolor = (cntcmpts > 1);
result = true;
}
}
}
if( !result )
Close();
return result;
}
int jpeg2k_decode_mem(IMG_DAT **oimg_dat, int *lossyflag,
unsigned char *idata, const int ilen)
{
IMG_DAT *img_dat;
jas_image_t *image;
jas_stream_t *in;
if (jas_init() != 0){
fprintf(stderr, "ERROR : jpeg2k_decode_mem: init : jas\n");
return(-1);
}
/* The input image is to be read from buffer stream. */
if ((in = jas_stream_memopen((char *)idata, ilen)) == NULL){
fprintf(stderr, "ERROR : jpeg2k_decode_mem: failed to open jas stream\n");
return(-2);
}
/* Get the input image data. */
if ((image = jas_image_decode(in, -1, (char *)NULL)) == NULL){
fprintf(stderr, "error: cannot load image data\n");
return(-3);
}
/* Early cleanup--input stream no longer needed. */
(void) jas_stream_close(in);
/* Gerenate Image data sturcture. */
if ((img_dat_generate(&img_dat, image)) != 0){
jas_image_destroy(image);
fprintf(stderr, "ERROR : jpeg2k_decode_mem: failed to generate img_dat\n");
return(-5);
}
/* General clean up. */
jas_image_destroy(image);
*oimg_dat = img_dat;
*lossyflag = 0;
return(0);
}
int main(int argc, char **argv)
{
int fmtid = 0;
jas_image_fmtops_t fmtops;
fmtops.decode = jp2_decode;
fmtops.encode = NULL;
fmtops.validate = jp2_validate;
jas_image_addfmt(fmtid, "jp2", "jp2",
"JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops);
++fmtid;
fmtops.decode = NULL;
fmtops.encode = bmp_encode;
fmtops.validate = NULL;
jas_image_addfmt(fmtid, "bmp", "bmp",
"Microsoft Bitmap (BMP)", &fmtops);
++fmtid;
jas_stream_t *in = jas_stream_fdopen(STDIN_FILENO, "rb");
assert(in != NULL);
jas_stream_t *out = jas_stream_fdopen(STDOUT_FILENO, "w+b");
assert(out != NULL);
jas_image_t *image = jas_image_decode(in, 0, NULL);
assert(image != NULL);
int rc = jas_image_encode(image, out, 1, NULL);
assert(rc == 0);
jas_stream_flush(out);
jas_stream_close(in);
jas_stream_close(out);
jas_image_destroy(image);
return 0;
}
bool CxImageJAS::Decode(CxFile *hFile, uint32_t imagetype)
{
if (hFile == NULL) return false;
jas_image_t *image=0;
jas_stream_t *in=0;
jas_matrix_t **bufs=0;
int32_t i,error=0;
int32_t fmt;
//jas_setdbglevel(0);
cx_try
{
if (jas_init())
cx_throw("cannot initialize jasper");
in = jas_stream_fdopen(0, "rb");
if (!in)
cx_throw("error: cannot open standard input");
CxFileJas src(hFile,in);
fmt = jas_image_getfmt(in);
if (fmt<0)
cx_throw("error: unknowm format");
image = jas_image_decode(in, fmt, 0);
if (!image){
fmt = -1;
cx_throw("error: cannot load image data");
}
char szfmt[4];
*szfmt = '\0';
strncpy(szfmt,jas_image_fmttostr(fmt),3);
szfmt[3] = '\0';
fmt = -1;
#if CXIMAGE_SUPPORT_JP2
if (strcmp(szfmt,"jp2")==0) fmt = CXIMAGE_FORMAT_JP2;
#endif
#if CXIMAGE_SUPPORT_JPC
if (strcmp(szfmt,"jpc")==0) fmt = CXIMAGE_FORMAT_JPC;
#endif
#if CXIMAGE_SUPPORT_RAS
if (strcmp(szfmt,"ras")==0) fmt = CXIMAGE_FORMAT_RAS;
#endif
#if CXIMAGE_SUPPORT_PNM
if (strcmp(szfmt,"pnm")==0) fmt = CXIMAGE_FORMAT_PNM;
#endif
#if CXIMAGE_SUPPORT_PGX
if (strcmp(szfmt,"pgx")==0) fmt = CXIMAGE_FORMAT_PGX;
#endif
//if (fmt<0)
// cx_throw("error: unknowm format");
int32_t x,y,w,h,depth,cmptno;
w = jas_image_cmptwidth(image,0);
h = jas_image_cmptheight(image,0);
depth = jas_image_cmptprec(image,0);
if (info.nEscape == -1){
head.biWidth = w;
head.biHeight= h;
info.dwType = fmt<0 ? 0 : fmt;
cx_throw("output dimensions returned");
}
if (image->numcmpts_ > 64 || image->numcmpts_ < 0)
cx_throw("error: too many components");
// <LD> 01/Jan/2005: Always force conversion to sRGB. Seems to be required for many types of JPEG2000 file.
// if (depth!=1 && depth!=4 && depth!=8)
if (image->numcmpts_>=3 && depth <=8)
{
jas_image_t *newimage;
jas_cmprof_t *outprof;
//jas_eprintf("forcing conversion to sRGB\n");
outprof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB);
if (!outprof) {
cx_throw("cannot create sRGB profile");
}
newimage = jas_image_chclrspc(image, outprof, JAS_CMXFORM_INTENT_PER);
if (!newimage) {
jas_cmprof_destroy(outprof); // <LD> 01/Jan/2005: Destroy color profile on error.
cx_throw("cannot convert to sRGB");
}
jas_image_destroy(image);
jas_cmprof_destroy(outprof);
image = newimage;
}
bufs = (jas_matrix_t **)calloc(image->numcmpts_, sizeof(jas_matrix_t**));
for (i = 0; i < image->numcmpts_; ++i) {
bufs[i] = jas_matrix_create(1, w);
if (!bufs[i]) {
cx_throw("error: cannot allocate memory");
}
}
int32_t nshift = (depth>8) ? (depth-8) : 0;
if (image->numcmpts_==3 &&
image->cmpts_[0]->width_ == image->cmpts_[1]->width_ &&
image->cmpts_[1]->width_ == image->cmpts_[2]->width_ &&
image->cmpts_[0]->height_ == image->cmpts_[1]->height_ &&
image->cmpts_[1]->height_ == image->cmpts_[2]->height_ &&
image->cmpts_[0]->prec_ == image->cmpts_[1]->prec_ &&
image->cmpts_[1]->prec_ == image->cmpts_[2]->prec_ )
{
if(!Create(w,h,24,fmt))
cx_throw("");
RGBQUAD c;
for (y=0; y<h; y++) {
for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
jas_image_readcmpt(image, cmptno, 0, y, w, 1, bufs[cmptno]);
}
for (x=0; x<w; x++){
c.rgbRed = (uint8_t)((jas_matrix_getv(bufs[0], x)>>nshift));
c.rgbGreen = (uint8_t)((jas_matrix_getv(bufs[1], x)>>nshift));
c.rgbBlue = (uint8_t)((jas_matrix_getv(bufs[2], x)>>nshift));
SetPixelColor(x,h-1-y,c);
}
}
} else {
info.nNumFrames = image->numcmpts_;
if ((info.nFrame<0)||(info.nFrame>=info.nNumFrames)){
cx_throw("wrong frame!");
}
for (cmptno=0; cmptno<=info.nFrame; cmptno++) {
w = jas_image_cmptwidth(image,cmptno);
h = jas_image_cmptheight(image,cmptno);
depth = jas_image_cmptprec(image,cmptno);
if (depth>8) depth=8;
if(!Create(w,h,depth,imagetype))
cx_throw("");
SetGrayPalette();
for (y=0; y<h; y++) {
jas_image_readcmpt(image, cmptno, 0, y, w, 1, bufs[0]);
for (x=0; x<w; x++){
SetPixelIndex(x,h-1-y,(uint8_t)((jas_matrix_getv(bufs[0], x)>>nshift)));
}
}
}
}
} cx_catch {
int main(int argc, char **argv)
{
char *origpath;
char *reconpath;
int verbose;
char *metricname;
int metric;
int id;
jas_image_t *origimage;
jas_image_t *reconimage;
jas_matrix_t *origdata;
jas_matrix_t *recondata;
jas_image_t *diffimage;
jas_stream_t *diffstream;
int width;
int height;
int depth;
int numcomps;
double d;
double maxdist;
double mindist;
int compno;
jas_stream_t *origstream;
jas_stream_t *reconstream;
char *diffpath;
int maxonly;
int minonly;
int fmtid;
verbose = 0;
origpath = 0;
reconpath = 0;
metricname = 0;
metric = metricid_none;
diffpath = 0;
maxonly = 0;
minonly = 0;
if (jas_init()) {
errprint(0, "error: cannot initialize jasper library\n");
abort();
}
/* set our error callback */
jas_set_error_cb(errprint);
cmdname = argv[0];
/* Parse the command line options. */
while ((id = jas_getopt(argc, argv, opts)) >= 0) {
switch (id) {
case OPT_MAXONLY:
maxonly = 1;
break;
case OPT_MINONLY:
minonly = 1;
break;
case OPT_METRIC:
metricname = jas_optarg;
break;
case OPT_ORIG:
origpath = jas_optarg;
break;
case OPT_RECON:
reconpath = jas_optarg;
break;
case OPT_VERBOSE:
verbose = 1;
break;
case OPT_DIFFIMAGE:
diffpath = jas_optarg;
break;
case OPT_VERSION:
printf("%s\n", JAS_VERSION);
exit(EXIT_SUCCESS);
break;
case OPT_HELP:
default:
usage();
break;
}
}
if (verbose) {
cmdinfo();
}
/* Ensure that files are given for both the original and reconstructed
images. */
if (!origpath || !reconpath) {
usage();
}
/* If a metric was specified, process it. */
if (metricname) {
if ((metric = (jas_taginfo_nonull(jas_taginfos_lookup(metrictab,
metricname))->id)) < 0) {
usage();
}
}
/* Open the original image file. */
if (!(origstream = jas_stream_fopen(origpath, "rb"))) {
jas_eprintf("cannot open %s\n", origpath);
return EXIT_FAILURE;
}
/* Open the reconstructed image file. */
if (!(reconstream = jas_stream_fopen(reconpath, "rb"))) {
jas_eprintf("cannot open %s\n", reconpath);
return EXIT_FAILURE;
}
/* Decode the original image. */
if (!(origimage = jas_image_decode(origstream, -1, 0))) {
jas_eprintf("cannot load original image\n");
return EXIT_FAILURE;
}
/* Decoder the reconstructed image. */
if (!(reconimage = jas_image_decode(reconstream, -1, 0))) {
jas_eprintf("cannot load reconstructed image\n");
return EXIT_FAILURE;
}
/* Close the original image file. */
jas_stream_close(origstream);
/* Close the reconstructed image file. */
jas_stream_close(reconstream);
/* Ensure that both images have the same number of components. */
numcomps = jas_image_numcmpts(origimage);
if (jas_image_numcmpts(reconimage) != numcomps) {
jas_eprintf("number of components differ\n");
return EXIT_FAILURE;
}
/* Compute the difference for each component. */
maxdist = 0;
mindist = FLT_MAX;
for (compno = 0; compno < numcomps; ++compno) {
width = jas_image_cmptwidth(origimage, compno);
height = jas_image_cmptheight(origimage, compno);
depth = jas_image_cmptprec(origimage, compno);
if (jas_image_cmptwidth(reconimage, compno) != width ||
jas_image_cmptheight(reconimage, compno) != height) {
jas_eprintf("image dimensions differ\n");
return EXIT_FAILURE;
}
if (jas_image_cmptprec(reconimage, compno) != depth) {
jas_eprintf("precisions differ\n");
return EXIT_FAILURE;
}
if (!(origdata = jas_matrix_create(height, width))) {
jas_eprintf("internal error\n");
return EXIT_FAILURE;
}
if (!(recondata = jas_matrix_create(height, width))) {
jas_eprintf("internal error\n");
return EXIT_FAILURE;
}
if (jas_image_readcmpt(origimage, compno, 0, 0, width, height,
origdata)) {
jas_eprintf("cannot read component data\n");
return EXIT_FAILURE;
}
if (jas_image_readcmpt(reconimage, compno, 0, 0, width, height,
recondata)) {
jas_eprintf("cannot read component data\n");
return EXIT_FAILURE;
}
if (diffpath) {
if (!(diffstream = jas_stream_fopen(diffpath, "rwb"))) {
jas_eprintf("cannot open diff stream\n");
return EXIT_FAILURE;
}
if (!(diffimage = makediffimage(origdata, recondata))) {
jas_eprintf("cannot make diff image\n");
return EXIT_FAILURE;
}
fmtid = jas_image_strtofmt("pnm");
if (jas_image_encode(diffimage, diffstream, fmtid, 0)) {
jas_eprintf("cannot save\n");
return EXIT_FAILURE;
}
jas_stream_close(diffstream);
jas_image_destroy(diffimage);
}
if (metric != metricid_none) {
d = getdistortion(origdata, recondata, depth, metric);
if (d > maxdist) {
maxdist = d;
}
if (d < mindist) {
mindist = d;
}
if (!maxonly && !minonly) {
if (metric == metricid_pae || metric == metricid_equal) {
printf("%ld\n", (long) ceil(d));
} else {
printf("%f\n", d);
}
}
}
jas_matrix_destroy(origdata);
jas_matrix_destroy(recondata);
}
if (metric != metricid_none && (maxonly || minonly)) {
if (maxonly) {
d = maxdist;
} else if (minonly) {
d = mindist;
} else {
abort();
}
if (metric == metricid_pae || metric == metricid_equal) {
jas_eprintf("%ld\n", (long) ceil(d));
} else {
jas_eprintf("%f\n", d);
}
}
jas_image_destroy(origimage);
jas_image_destroy(reconimage);
jas_image_clearfmts();
return EXIT_SUCCESS;
}
static Image *ReadJP2Image(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
long
y;
jas_image_t
*jp2_image;
jas_matrix_t
*pixels;
jas_stream_t
*jp2_stream;
register long
x;
register PixelPacket
*q;
int
component,
components[4],
number_components;
Quantum
*channel_lut[4];
unsigned int
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Obtain a JP2 Stream.
*/
jp2_stream=JP2StreamManager(image);
if (jp2_stream == (jas_stream_t *) NULL)
ThrowReaderException(DelegateError,UnableToManageJP2Stream,image);
jp2_image=jas_image_decode(jp2_stream,-1,0);
if (jp2_image == (jas_image_t *) NULL)
{
(void) jas_stream_close(jp2_stream);
ThrowReaderException(DelegateError,UnableToDecodeImageFile,image);
}
/*
Validate that we can handle the image and obtain component
indexes.
*/
switch (jas_clrspc_fam(jas_image_clrspc(jp2_image)))
{
case JAS_CLRSPC_FAM_RGB:
{
if (((components[0]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0) ||
((components[1]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0) ||
((components[2]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
number_components=3;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in RGB colorspace family");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"RED is in channel %d, GREEN is in channel %d, BLUE is in channel %d",
components[0],components[1],components[2]);
if((components[3]=jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_OPACITY))) > 0)
{
image->matte=MagickTrue;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"OPACITY is in channel %d",components[3]);
number_components++;
}
break;
}
case JAS_CLRSPC_FAM_GRAY:
{
if ((components[0]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in GRAY colorspace family");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"GRAY is in channel %d",components[0]);
number_components=1;
break;
}
case JAS_CLRSPC_FAM_YCBCR:
{
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_Y);
components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CB);
components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CR);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_OPACITY);
if (components[3] > 0)
{
image->matte=True;
number_components++;
}
image->colorspace=YCbCrColorspace;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in YCBCR colorspace family");
break;
}
default:
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,ColorspaceModelIsNotSupported,image);
}
}
image->columns=jas_image_width(jp2_image);
image->rows=jas_image_height(jp2_image);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"columns=%lu rows=%lu components=%d",image->columns,image->rows,
number_components);
for (component=0; component < number_components; component++)
{
if(((unsigned long) jas_image_cmptwidth(jp2_image,components[component]) != image->columns) ||
((unsigned long) jas_image_cmptheight(jp2_image,components[component]) != image->rows) ||
(jas_image_cmpttlx(jp2_image, components[component]) != 0) ||
(jas_image_cmpttly(jp2_image, components[component]) != 0) ||
(jas_image_cmpthstep(jp2_image, components[component]) != 1) ||
(jas_image_cmptvstep(jp2_image, components[component]) != 1) ||
(jas_image_cmptsgnd(jp2_image, components[component]) != false))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,IrregularChannelGeometryNotSupported,image);
}
}
image->matte=number_components > 3;
for (component=0; component < number_components; component++)
{
unsigned int
component_depth;
component_depth=jas_image_cmptprec(jp2_image,components[component]);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Component[%d] depth is %u",component,component_depth);
if (0 == component)
image->depth=component_depth;
else
image->depth=Max(image->depth,component_depth);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image depth is %u",image->depth);
if (image_info->ping)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(image);
}
/*
Allocate Jasper pixels.
*/
pixels=jas_matrix_create(1,(unsigned int) image->columns);
if (pixels == (jas_matrix_t *) NULL)
{
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
}
/*
Allocate and populate channel LUTs
*/
for (component=0; component < (long) number_components; component++)
{
unsigned long
component_depth,
i,
max_value;
double
scale_to_quantum;
component_depth=jas_image_cmptprec(jp2_image,components[component]);
max_value=MaxValueGivenBits(component_depth);
scale_to_quantum=MaxRGBDouble/max_value;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Channel %d scale is %g", component, scale_to_quantum);
channel_lut[component]=MagickAllocateArray(Quantum *,max_value+1,sizeof(Quantum));
if (channel_lut[component] == (Quantum *) NULL)
{
for ( --component; component >= 0; --component)
MagickFreeMemory(channel_lut[component]);
jas_matrix_destroy(pixels);
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
}
for(i=0; i <= max_value; i++)
(channel_lut[component])[i]=scale_to_quantum*i+0.5;
}
/*
Convert JPEG 2000 pixels.
*/
for (y=0; y < (long) image->rows; y++)
{
q=GetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
if (1 == number_components)
{
/* Grayscale */
(void) jas_image_readcmpt(jp2_image,(short) components[0],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
{
q->red=q->green=q->blue=(channel_lut[0])[jas_matrix_getv(pixels,x)];
q->opacity=OpaqueOpacity;
q++;
}
}
else
{
/* Red */
(void) jas_image_readcmpt(jp2_image,(short) components[0],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].red=(channel_lut[0])[jas_matrix_getv(pixels,x)];
/* Green */
(void) jas_image_readcmpt(jp2_image,(short) components[1],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].green=(channel_lut[1])[jas_matrix_getv(pixels,x)];
/* Blue */
(void) jas_image_readcmpt(jp2_image,(short) components[2],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].blue=(channel_lut[2])[jas_matrix_getv(pixels,x)];
/* Opacity */
if (number_components > 3)
{
(void) jas_image_readcmpt(jp2_image,(short) components[3],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].opacity=MaxRGB-(channel_lut[3])[jas_matrix_getv(pixels,x)];
}
else
{
for (x=0; x < (long) image->columns; x++)
q[x].opacity=OpaqueOpacity;
}
}
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText,
image->filename,
image->columns,image->rows))
break;
}
if (number_components == 1)
image->is_grayscale=MagickTrue;
{
/*
Obtain ICC ICM color profile
*/
jas_cmprof_t
*cm_profile;
/* Obtain a pointer to the existing jas_cmprof_t profile handle. */
cm_profile=jas_image_cmprof(jp2_image);
if (cm_profile != (jas_cmprof_t *) NULL)
{
jas_iccprof_t
*icc_profile;
/* Obtain a copy of the jas_iccprof_t ICC profile handle */
icc_profile=jas_iccprof_createfromcmprof(cm_profile);
/* or maybe just icc_profile=cm_profile->iccprof */
if (icc_profile != (jas_iccprof_t *) NULL)
{
jas_stream_t
*icc_stream;
icc_stream=jas_stream_memopen(NULL,0);
if ((icc_stream != (jas_stream_t *) NULL) &&
(jas_iccprof_save(icc_profile,icc_stream) == 0) &&
(jas_stream_flush(icc_stream) == 0))
{
jas_stream_memobj_t
*blob;
blob=(jas_stream_memobj_t *) icc_stream->obj_;
if (image->logging)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"ICC profile: %lu bytes",(unsigned long) blob->len_);
SetImageProfile(image,"ICM",blob->buf_,blob->len_);
(void) jas_stream_close(icc_stream);
jas_iccprof_destroy(icc_profile);
}
}
}
}
for (component=0; component < (long) number_components; component++)
MagickFreeMemory(channel_lut[component]);
jas_matrix_destroy(pixels);
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(image);
}
int imFileFormatJP2::ReadImageInfo(int index)
{
(void)index;
// The counter is started because in Jasper all image reading is done here. BAD!
ijp2_counter = this->counter;
ijp2_abort = 0;
ijp2_message = "Reading JP2...";
this->image = jas_image_decode(this->stream, this->fmtid, 0);
ijp2_counter = -1;
if (!this->image)
return IM_ERR_ACCESS;
this->width = jas_image_width(this->image);
this->height = jas_image_height(this->image);
int clrspc_fam = jas_clrspc_fam(jas_image_clrspc(image));
switch(clrspc_fam)
{
case JAS_CLRSPC_FAM_GRAY:
this->file_color_mode = IM_GRAY;
break;
case JAS_CLRSPC_FAM_XYZ:
this->file_color_mode = IM_XYZ;
break;
case JAS_CLRSPC_FAM_RGB:
this->file_color_mode = IM_RGB;
break;
case JAS_CLRSPC_FAM_YCBCR:
this->file_color_mode = IM_YCBCR;
break;
case JAS_CLRSPC_FAM_LAB:
this->file_color_mode = IM_LAB;
break;
default:
return IM_ERR_DATA;
}
this->file_data_type = IM_BYTE;
int prec = jas_image_cmptprec(image, 0);
if (prec > 8)
this->file_data_type = IM_USHORT;
if (prec < 8)
this->convert_bpp = -prec; // just expand to 0-255
if (prec == 1 && this->file_color_mode == IM_GRAY)
this->file_color_mode = IM_BINARY;
int cmpno = jas_image_getcmptbytype(this->image, JAS_IMAGE_CT_OPACITY);
if (cmpno != -1)
this->file_color_mode |= IM_ALPHA;
this->file_color_mode |= IM_TOPDOWN;
if (image->metadata.count > 0)
{
imAttribTable* attrib_table = AttribTable();
// First write GeoTIFF data
jas_metadata_box_t *metabox = &image->metadata.boxes[JAS_IMAGE_BOX_GEO];
if (metabox->size>0 && metabox->buf)
attrib_table->Set("GeoTIFFBox", IM_BYTE, metabox->size, metabox->buf);
// Check if XMP is there
metabox = &image->metadata.boxes[JAS_IMAGE_BOX_XMP];
if (metabox->size>0 && metabox->buf)
attrib_table->Set("XMLPacket", IM_BYTE, metabox->size, metabox->buf);
}
return IM_ERR_NONE;
}
static GstFlowReturn
gst_jasper_dec_get_picture (GstJasperDec * dec, guint8 * data,
guint size, GstBuffer ** outbuf)
{
GstFlowReturn ret = GST_FLOW_OK;
jas_stream_t *stream = NULL;
jas_image_t *image = NULL;
gint i;
g_return_val_if_fail (outbuf != NULL, GST_FLOW_ERROR);
*outbuf = NULL;
if (!(stream = jas_stream_memopen ((gpointer) data, size)))
goto fail_stream;
if (!(image = jas_image_decode (stream, dec->fmt, (char *) "")))
goto fail_decode;
ret = gst_jasper_dec_negotiate (dec, image);
if (ret != GST_FLOW_OK)
goto fail_negotiate;
ret = gst_pad_alloc_buffer_and_set_caps (dec->srcpad,
GST_BUFFER_OFFSET_NONE,
dec->image_size, GST_PAD_CAPS (dec->srcpad), outbuf);
if (ret != GST_FLOW_OK)
goto no_buffer;
if (dec->alpha)
memset (GST_BUFFER_DATA (*outbuf), 0xff, dec->image_size);
for (i = 0; i < dec->channels; ++i) {
gint x, y, cwidth, cheight, inc, stride, cmpt;
guint8 *row_pix, *out_pix;
glong *tb;
inc = dec->inc[i];
stride = dec->stride[i];
cmpt = dec->cmpt[i];
cheight = dec->cheight[cmpt];
cwidth = dec->cwidth[cmpt];
GST_LOG_OBJECT (dec,
"retrieve component %d<=%d, size %dx%d, offset %d, inc %d, stride %d",
i, cmpt, cwidth, cheight, dec->offset[i], inc, stride);
out_pix = GST_BUFFER_DATA (*outbuf) + dec->offset[i];
for (y = 0; y < cheight; y++) {
row_pix = out_pix;
tb = dec->buf;
if (jas_image_readcmpt2 (image, i, 0, y, cwidth, 1, dec->buf))
goto fail_image;
for (x = 0; x < cwidth; x++) {
*out_pix = *tb;
tb++;
out_pix += inc;
}
out_pix = row_pix + stride;
}
}
GST_LOG_OBJECT (dec, "all components retrieved");
done:
if (image)
jas_image_destroy (image);
if (stream)
jas_stream_close (stream);
return ret;
/* ERRORS */
fail_stream:
{
GST_DEBUG_OBJECT (dec, "Failed to create inputstream.");
goto fail;
}
fail_decode:
{
GST_DEBUG_OBJECT (dec, "Failed to decode image.");
goto fail;
}
fail_image:
{
GST_DEBUG_OBJECT (dec, "Failed to process decoded image.");
goto fail;
}
fail:
{
if (*outbuf)
gst_buffer_unref (*outbuf);
*outbuf = NULL;
GST_ELEMENT_WARNING (dec, STREAM, DECODE, (NULL), (NULL));
ret = GST_FLOW_OK;
goto done;
}
no_buffer:
{
GST_DEBUG_OBJECT (dec, "Failed to create outbuffer - %s",
gst_flow_get_name (ret));
goto done;
}
fail_negotiate:
{
GST_DEBUG_OBJECT (dec, "Failed to determine output caps.");
goto done;
}
}
// Internal function used to load the Jpeg2000 stream.
ILboolean iLoadJp2Internal(jas_stream_t *Stream, ILimage *Image)
{
jas_image_t *Jp2Image = NULL;
jas_matrix_t *origdata;
ILuint x, y, c;
ILimage *TempImage;
// Decode image
Jp2Image = jas_image_decode(Stream, -1, 0);
if (!Jp2Image)
{
ilSetError(IL_ILLEGAL_FILE_VALUE);
jas_stream_close(Stream);
return IL_FALSE;
}
// We're not supporting anything other than 8 bits/component yet.
if (jas_image_cmptprec(Jp2Image, 0) != 8)
{
jas_image_destroy(Jp2Image);
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
switch (jas_image_numcmpts(Jp2Image))
{
case 3:
if (Image == NULL) {
ilTexImage(jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL);
TempImage = iCurImage;
}
else {
ifree(Image->Data); // @TODO: Not really the most efficient way to do this...
ilInitImage(Image, jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL);
TempImage = Image;
}
break;
case 4:
if (Image == NULL) {
ilTexImage(jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, NULL);
TempImage = iCurImage;
}
else {
ifree(Image->Data); // @TODO: Not really the most efficient way to do this...
ilInitImage(Image, jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, NULL);
TempImage = Image;
}
break;
default:
jas_image_destroy(Jp2Image);
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
TempImage->Origin = IL_ORIGIN_UPPER_LEFT;
// JasPer stores the data channels separately.
// I am assuming RGBA format. Is it possible for other formats to be included?
for (c = 0; c < TempImage->Bpp; c++)
{
origdata = jas_matrix_create(TempImage->Height, TempImage->Width);
if (!origdata)
{
ilSetError(IL_LIB_JP2_ERROR);
return IL_FALSE; // @TODO: Error
}
// Have to convert data into an intermediate matrix format.
if (jas_image_readcmpt(Jp2Image, c, 0, 0, TempImage->Width, TempImage->Height, origdata))
{
return IL_FALSE;
}
for (y = 0; y < TempImage->Height; y++)
{
for (x = 0; x < TempImage->Width; x++)
{
TempImage->Data[y * TempImage->Width * TempImage->Bpp + x * TempImage->Bpp + c] = origdata->data_[y * origdata->numcols_ + x];
}
}
jas_matrix_destroy(origdata);
}
jas_image_destroy(Jp2Image);
ilFixImage();
return IL_TRUE;
}
int JPEG2000Dataset::DecodeImage()
{
if (bAlreadyDecoded)
return psImage != NULL;
bAlreadyDecoded = TRUE;
if ( !( psImage = jas_image_decode(psStream, iFormat, 0) ) )
{
CPLDebug( "JPEG2000", "Unable to decode image. Format: %s, %d",
jas_image_fmttostr( iFormat ), iFormat );
return FALSE;
}
/* Case of a JP2 image : check that the properties given by */
/* the JP2 boxes match the ones of the code stream */
if (nBands != 0)
{
if (nBands != jas_image_numcmpts( psImage ))
{
CPLError(CE_Failure, CPLE_AppDefined,
"The number of components indicated in the IHDR box (%d) mismatch "
"the value specified in the code stream (%d)",
nBands, jas_image_numcmpts( psImage ));
jas_image_destroy( psImage );
psImage = NULL;
return FALSE;
}
if (nRasterXSize != jas_image_cmptwidth( psImage, 0 ) ||
nRasterYSize != jas_image_cmptheight( psImage, 0 ) )
{
CPLError(CE_Failure, CPLE_AppDefined,
"The dimensions indicated in the IHDR box (%d x %d) mismatch "
"the value specified in the code stream (%d x %d)",
nRasterXSize, nRasterYSize,
jas_image_cmptwidth( psImage, 0 ),
jas_image_cmptheight( psImage, 0 ));
jas_image_destroy( psImage );
psImage = NULL;
return FALSE;
}
int iBand;
for ( iBand = 0; iBand < nBands; iBand++ )
{
JPEG2000RasterBand* poBand = (JPEG2000RasterBand*) GetRasterBand(iBand+1);
if (poBand->iDepth != jas_image_cmptprec( psImage, iBand ) ||
poBand->bSignedness != jas_image_cmptsgnd( psImage, iBand ))
{
CPLError(CE_Failure, CPLE_AppDefined,
"The bit depth of band %d indicated in the IHDR box (%d) mismatch "
"the value specified in the code stream (%d)",
iBand + 1, poBand->iDepth, jas_image_cmptprec( psImage, iBand ));
jas_image_destroy( psImage );
psImage = NULL;
return FALSE;
}
}
}
/* Ask for YCbCr -> RGB translation */
if ( jas_clrspc_fam( jas_image_clrspc( psImage ) ) ==
JAS_CLRSPC_FAM_YCBCR )
{
jas_image_t *psRGBImage;
jas_cmprof_t *psRGBProf;
CPLDebug( "JPEG2000", "forcing conversion to sRGB");
if (!(psRGBProf = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB))) {
CPLDebug( "JPEG2000", "cannot create sRGB profile");
return TRUE;
}
if (!(psRGBImage = jas_image_chclrspc(psImage, psRGBProf, JAS_CMXFORM_INTENT_PER))) {
CPLDebug( "JPEG2000", "cannot convert to sRGB");
jas_cmprof_destroy(psRGBProf);
return TRUE;
}
jas_image_destroy(psImage);
jas_cmprof_destroy(psRGBProf);
psImage = psRGBImage;
}
return TRUE;
}
static Image *ReadJP2Image(const ImageInfo *image_info,ExceptionInfo *exception)
{
Image
*image;
jas_cmprof_t
*cm_profile;
jas_iccprof_t
*icc_profile;
jas_image_t
*jp2_image;
jas_matrix_t
*pixels[4];
jas_stream_t
*jp2_stream;
MagickBooleanType
status;
QuantumAny
pixel,
range[4];
register Quantum
*q;
register ssize_t
i,
x;
size_t
maximum_component_depth,
number_components,
x_step[4],
y_step[4];
ssize_t
components[4],
y;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Initialize JPEG 2000 API.
*/
jp2_stream=JP2StreamManager(image);
if (jp2_stream == (jas_stream_t *) NULL)
ThrowReaderException(DelegateError,"UnableToManageJP2Stream");
jp2_image=jas_image_decode(jp2_stream,-1,0);
if (jp2_image == (jas_image_t *) NULL)
{
(void) jas_stream_close(jp2_stream);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
image->columns=jas_image_width(jp2_image);
image->rows=jas_image_height(jp2_image);
image->compression=JPEG2000Compression;
switch (jas_clrspc_fam(jas_image_clrspc(jp2_image)))
{
case JAS_CLRSPC_FAM_RGB:
{
SetImageColorspace(image,RGBColorspace,exception);
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_RGB_R);
components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_RGB_G);
components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_RGB_B);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,3);
if (components[3] > 0)
{
image->alpha_trait=BlendPixelTrait;
number_components++;
}
break;
}
case JAS_CLRSPC_FAM_GRAY:
{
SetImageColorspace(image,GRAYColorspace,exception);
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_GRAY_Y);
if (components[0] < 0)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=1;
break;
}
case JAS_CLRSPC_FAM_YCBCR:
{
SetImageColorspace(image,YCbCrColorspace,exception);
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_Y);
components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CB);
components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CR);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_UNKNOWN);
if (components[3] > 0)
{
image->alpha_trait=BlendPixelTrait;
number_components++;
}
break;
}
case JAS_CLRSPC_FAM_XYZ:
{
SetImageColorspace(image,XYZColorspace,exception);
components[0]=jas_image_getcmptbytype(jp2_image,0);
components[1]=jas_image_getcmptbytype(jp2_image,1);
components[2]=jas_image_getcmptbytype(jp2_image,2);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_UNKNOWN);
if (components[3] > 0)
{
image->alpha_trait=BlendPixelTrait;
number_components++;
}
break;
}
case JAS_CLRSPC_FAM_LAB:
{
SetImageColorspace(image,LabColorspace,exception);
components[0]=jas_image_getcmptbytype(jp2_image,0);
components[1]=jas_image_getcmptbytype(jp2_image,1);
components[2]=jas_image_getcmptbytype(jp2_image,2);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_UNKNOWN);
if (components[3] > 0)
{
image->alpha_trait=BlendPixelTrait;
number_components++;
}
break;
}
default:
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,"ColorspaceModelIsNotSupported");
}
}
for (i=0; i < (ssize_t) number_components; i++)
{
size_t
height,
width;
width=(size_t) (jas_image_cmptwidth(jp2_image,components[i])*
jas_image_cmpthstep(jp2_image,components[i]));
height=(size_t) (jas_image_cmptheight(jp2_image,components[i])*
jas_image_cmptvstep(jp2_image,components[i]));
x_step[i]=(unsigned int) jas_image_cmpthstep(jp2_image,components[i]);
y_step[i]=(unsigned int) jas_image_cmptvstep(jp2_image,components[i]);
if ((width != image->columns) || (height != image->rows) ||
(jas_image_cmpttlx(jp2_image,components[i]) != 0) ||
(jas_image_cmpttly(jp2_image,components[i]) != 0) ||
(jas_image_cmptsgnd(jp2_image,components[i]) != MagickFalse))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported");
}
}
/*
Convert JPEG 2000 pixels.
*/
image->alpha_trait=number_components > 3 ? BlendPixelTrait :
UndefinedPixelTrait;
maximum_component_depth=0;
for (i=0; i < (ssize_t) number_components; i++)
{
maximum_component_depth=(unsigned int) MagickMax((size_t)
jas_image_cmptprec(jp2_image,components[i]),(size_t)
maximum_component_depth);
pixels[i]=jas_matrix_create(1,(int) (image->columns/x_step[i]));
if (pixels[i] == (jas_matrix_t *) NULL)
{
for (--i; i >= 0; i--)
jas_matrix_destroy(pixels[i]);
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
}
image->depth=maximum_component_depth;
if (image_info->ping != MagickFalse)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(GetFirstImageInList(image));
}
for (i=0; i < (ssize_t) number_components; i++)
range[i]=GetQuantumRange((size_t) jas_image_cmptprec(jp2_image,
components[i]));
for (y=0; y < (ssize_t) image->rows; y++)
{
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (i=0; i < (ssize_t) number_components; i++)
(void) jas_image_readcmpt(jp2_image,(short) components[i],0,
(jas_image_coord_t) (y/y_step[i]),(jas_image_coord_t) (image->columns/
x_step[i]),1,pixels[i]);
switch (number_components)
{
case 1:
{
/*
Grayscale.
*/
for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
q+=GetPixelChannels(image);
}
break;
}
case 3:
{
/*
RGB.
*/
for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
q+=GetPixelChannels(image);
}
break;
}
case 4:
{
/*
RGBA.
*/
for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[3],x/x_step[3]);
SetPixelAlpha(image,ScaleAnyToQuantum((QuantumAny) pixel,range[3]),q);
q+=GetPixelChannels(image);
}
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
cm_profile=jas_image_cmprof(jp2_image);
icc_profile=(jas_iccprof_t *) NULL;
if (cm_profile != (jas_cmprof_t *) NULL)
icc_profile=jas_iccprof_createfromcmprof(cm_profile);
if (icc_profile != (jas_iccprof_t *) NULL)
{
jas_stream_t
*icc_stream;
icc_stream=jas_stream_memopen(NULL,0);
if ((icc_stream != (jas_stream_t *) NULL) &&
(jas_iccprof_save(icc_profile,icc_stream) == 0) &&
(jas_stream_flush(icc_stream) == 0))
{
jas_stream_memobj_t
*blob;
StringInfo
*icc_profile,
*profile;
/*
Extract the icc profile, handle errors without much noise.
*/
blob=(jas_stream_memobj_t *) icc_stream->obj_;
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Profile: ICC, %.20g bytes",(double) blob->len_);
profile=BlobToStringInfo(blob->buf_,blob->len_);
if (profile == (StringInfo *) NULL)
ThrowReaderException(CorruptImageError,"MemoryAllocationFailed");
icc_profile=(StringInfo *) GetImageProfile(image,"icc");
if (icc_profile == (StringInfo *) NULL)
(void) SetImageProfile(image,"icc",profile,exception);
else
(void) ConcatenateStringInfo(icc_profile,profile);
profile=DestroyStringInfo(profile);
(void) jas_stream_close(icc_stream);
}
}
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
for (i=0; i < (ssize_t) number_components; i++)
jas_matrix_destroy(pixels[i]);
return(GetFirstImageInList(image));
}
bool FetchTIFFCornersWithJP2K(const char * inFileName, double corners[8], int& post_pos)
{
jas_stream_t *inStream;
jas_image_t *image;
if(jas_init() != 0 )
{
//If it failed then return error
return -1;
}
//If the data stream cannot be created
if((inStream = jas_stream_fopen(inFileName,"rb"))==false)
{
return false;
}
//Get the format ID
int formatId;
//If there are any errors in getting the format
if((formatId = jas_image_getfmt(inStream)) < 0)
{
//It is an invalid format
return false;
}
//If the image cannot be decoded
if((image = jas_image_decode(inStream, formatId, 0)) == false)
{
//Return an error
return false;
}
//If it turns out the .jp2 never had any geological data exit
if(image->aux_buf.size == 0)
{
return false;
}
#if DUMP_GTIF
FILE * foo = fopen("temp.tiff","wb");
if(foo)
{
fwrite(image->aux_buf.buf, 1, image->aux_buf.size, foo);
fclose(foo);
}
#endif
//Create the handle to be used in XTIFFClientOpen
MemJASGeoFile jasHandle(&image->aux_buf);
//Create a TIFF handle
TIFF * tif = XTIFFClientOpen(inFileName,"r",&jasHandle,MemJASGeoRead, MemJASGeoWrite,
MemJASGeoSeek, MemJASGeoClose,
MemJASGeoSize,
MemJASGeoMapFile, MemJASGeoUnmapFile);
int postType = dem_want_Area;
//Pass in our TIF handle, post type, width, and height
if(FetchTIFFCornersWithTIFF(tif,corners,postType,(image->brx_-image->tlx_),(image->bry_-image->tly_))==false)
{
return false;
}
//Shut downthe stream
jas_stream_close(inStream);
//Unintialize jasper
jas_cleanup();
//It all worked!
return true;
}
// Internal function used to load the Jpeg2000 stream.
ILboolean iLoadJp2Internal(jas_stream_t *Stream, ILimage *Image)
{
jas_image_t *Jp2Image = NULL;
jas_matrix_t *origdata;
ILuint x, y, c, Error;
ILimage *TempImage;
// Decode image
Jp2Image = jas_image_decode(Stream, -1, 0);
if (!Jp2Image)
{
ilSetError(IL_ILLEGAL_FILE_VALUE);
jas_stream_close(Stream);
return IL_FALSE;
}
// JasPer likes to buffer a lot, so it may try buffering past the end
// of the file. iread naturally sets IL_FILE_READ_ERROR if it tries
// reading past the end of the file, but this actually is not an error.
Error = ilGetError();
// Put the error back if it is not IL_FILE_READ_ERROR.
if (Error != IL_FILE_READ_ERROR)
ilSetError(Error);
// We're not supporting anything other than 8 bits/component yet.
if (jas_image_cmptprec(Jp2Image, 0) != 8)
{
jas_image_destroy(Jp2Image);
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
switch (jas_image_numcmpts(Jp2Image))
{
//@TODO: Can we do alpha data? jas_image_cmpttype always returns 0 for this case.
case 1: // Assuming this is luminance data.
if (Image == NULL) {
ilTexImage(jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 1, IL_LUMINANCE, IL_UNSIGNED_BYTE, NULL);
TempImage = iCurImage;
}
else {
ifree(Image->Data); // @TODO: Not really the most efficient way to do this...
ilInitImage(Image, jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 1, IL_LUMINANCE, IL_UNSIGNED_BYTE, NULL);
TempImage = Image;
}
break;
case 2: // Assuming this is luminance-alpha data.
if (Image == NULL) {
ilTexImage(jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 2, IL_LUMINANCE_ALPHA, IL_UNSIGNED_BYTE, NULL);
TempImage = iCurImage;
}
else {
ifree(Image->Data); // @TODO: Not really the most efficient way to do this...
ilInitImage(Image, jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 2, IL_LUMINANCE_ALPHA, IL_UNSIGNED_BYTE, NULL);
TempImage = Image;
}
break;
case 3:
if (Image == NULL) {
ilTexImage(jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL);
TempImage = iCurImage;
}
else {
ifree(Image->Data); // @TODO: Not really the most efficient way to do this...
ilInitImage(Image, jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 3, IL_RGB, IL_UNSIGNED_BYTE, NULL);
TempImage = Image;
}
break;
case 4:
if (Image == NULL) {
ilTexImage(jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, NULL);
TempImage = iCurImage;
}
else {
ifree(Image->Data); // @TODO: Not really the most efficient way to do this...
ilInitImage(Image, jas_image_width(Jp2Image), jas_image_height(Jp2Image), 1, 4, IL_RGBA, IL_UNSIGNED_BYTE, NULL);
TempImage = Image;
}
break;
default:
jas_image_destroy(Jp2Image);
ilSetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
}
TempImage->Origin = IL_ORIGIN_UPPER_LEFT;
// JasPer stores the data channels separately.
// I am assuming RGBA format. Is it possible for other formats to be included?
for (c = 0; c < TempImage->Bpp; c++)
{
origdata = jas_matrix_create(TempImage->Height, TempImage->Width);
if (!origdata)
{
ilSetError(IL_LIB_JP2_ERROR);
return IL_FALSE; // @TODO: Error
}
// Have to convert data into an intermediate matrix format.
if (jas_image_readcmpt(Jp2Image, c, 0, 0, TempImage->Width, TempImage->Height, origdata))
{
return IL_FALSE;
}
for (y = 0; y < TempImage->Height; y++)
{
for (x = 0; x < TempImage->Width; x++)
{
TempImage->Data[y * TempImage->Width * TempImage->Bpp + x * TempImage->Bpp + c] = origdata->data_[y * origdata->numcols_ + x];
}
}
jas_matrix_destroy(origdata);
}
jas_image_destroy(Jp2Image);
return ilFixImage();
}
static int loadimage()
{
int reshapeflag;
jas_stream_t *in;
int scrnwidth;
int scrnheight;
int vh;
int vw;
char *pathname;
jas_cmprof_t *outprof;
assert(!gs.image);
assert(!gs.altimage);
gs.image = 0;
gs.altimage = 0;
pathname = cmdopts.filenames[gs.filenum];
if (pathname && pathname[0] != '\0') {
#if 1
jas_eprintf("opening %s\n", pathname);
#endif
/* The input image is to be read from a file. */
if (!(in = jas_stream_fopen(pathname, "rb"))) {
jas_eprintf("error: cannot open file %s\n", pathname);
goto error;
}
} else {
/* The input image is to be read from standard input. */
in = streamin;
}
/* Get the input image data. */
if (!(gs.image = jas_image_decode(in, -1, 0))) {
jas_eprintf("error: cannot load image data\n");
goto error;
}
/* Close the input stream. */
if (in != streamin) {
jas_stream_close(in);
}
if (!(outprof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB)))
goto error;
if (!(gs.altimage = jas_image_chclrspc(gs.image, outprof, JAS_CMXFORM_INTENT_PER)))
goto error;
if ((scrnwidth = glutGet(GLUT_SCREEN_WIDTH)) < 0) {
scrnwidth = 256;
}
if ((scrnheight = glutGet(GLUT_SCREEN_HEIGHT)) < 0) {
scrnheight = 256;
}
vw = min(jas_image_width(gs.image), 0.95 * scrnwidth);
vh = min(jas_image_height(gs.image), 0.95 * scrnheight);
gs.vcx = (jas_image_tlx(gs.image) + jas_image_brx(gs.image)) / 2.0;
gs.vcy = (jas_image_tly(gs.image) + jas_image_bry(gs.image)) / 2.0;
gs.sx = 1.0;
gs.sy = 1.0;
if (gs.altimage) {
gs.monomode = 0;
} else {
gs.monomode = 1;
gs.cmptno = 0;
}
#if 1
jas_eprintf("num of components %d\n", jas_image_numcmpts(gs.image));
#endif
if (vw < jas_image_width(gs.image)) {
gs.sx = jas_image_width(gs.image) / ((float) vw);
}
if (vh < jas_image_height(gs.image)) {
gs.sy = jas_image_height(gs.image) / ((float) vh);
}
if (gs.sx > gs.sy) {
gs.sy = gs.sx;
} else if (gs.sx < gs.sy) {
gs.sx = gs.sy;
}
vw = jas_image_width(gs.image) / gs.sx;
vh = jas_image_height(gs.image) / gs.sy;
gs.dirty = 1;
reshapeflag = 0;
if (vw != glutGet(GLUT_WINDOW_WIDTH) ||
vh != glutGet(GLUT_WINDOW_HEIGHT)) {
glutReshapeWindow(vw, vh);
reshapeflag = 1;
}
if (cmdopts.title) {
glutSetWindowTitle(cmdopts.title);
} else {
glutSetWindowTitle((pathname && pathname[0] != '\0') ? pathname :
"stdin");
}
/* If we reshaped the window, GLUT will automatically invoke both
the reshape and display callback (in this order). Therefore, we
only need to explicitly force the display callback to be invoked
if the window was not reshaped. */
if (!reshapeflag) {
glutPostRedisplay();
}
if (cmdopts.tmout != 0) {
glutTimerFunc(cmdopts.tmout, timer, gs.nexttmid);
gs.activetmid = gs.nexttmid;
++gs.nexttmid;
}
return 0;
error:
unloadimage();
return -1;
}
static Image *ReadJP2Image(const ImageInfo *image_info,ExceptionInfo *exception)
{
Image
*image;
jas_cmprof_t
*cm_profile;
jas_iccprof_t
*icc_profile;
jas_image_t
*jp2_image;
jas_matrix_t
*pixels[4];
jas_stream_t
*jp2_stream;
long
components[4],
y;
MagickBooleanType
status;
QuantumAny
pixel,
*map[4],
range;
register long
i,
x;
register PixelPacket
*q;
unsigned long
maximum_component_depth,
number_components,
x_step[4],
y_step[4];
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AcquireImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Initialize JPEG 2000 API.
*/
jp2_stream=JP2StreamManager(image);
if (jp2_stream == (jas_stream_t *) NULL)
ThrowReaderException(DelegateError,"UnableToManageJP2Stream");
jp2_image=jas_image_decode(jp2_stream,-1,0);
if (jp2_image == (jas_image_t *) NULL)
{
(void) jas_stream_close(jp2_stream);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
switch (jas_clrspc_fam(jas_image_clrspc(jp2_image)))
{
case JAS_CLRSPC_FAM_RGB:
{
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_RGB_R);
components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_RGB_G);
components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_RGB_B);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,3);
if (components[3] > 0)
{
image->matte=MagickTrue;
number_components++;
}
break;
}
case JAS_CLRSPC_FAM_GRAY:
{
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_GRAY_Y);
if (components[0] < 0)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=1;
break;
}
case JAS_CLRSPC_FAM_YCBCR:
{
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_Y);
components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CB);
components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CR);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,"MissingImageChannel");
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_UNKNOWN);
if (components[3] > 0)
{
image->matte=MagickTrue;
number_components++;
}
image->colorspace=YCbCrColorspace;
break;
}
default:
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,"ColorspaceModelIsNotSupported");
}
}
image->columns=jas_image_width(jp2_image);
image->rows=jas_image_height(jp2_image);
image->compression=JPEG2000Compression;
for (i=0; i < (long) number_components; i++)
{
unsigned long
height,
width;
width=(unsigned long) (jas_image_cmptwidth(jp2_image,components[i])*
jas_image_cmpthstep(jp2_image,components[i]));
height=(unsigned long) (jas_image_cmptheight(jp2_image,components[i])*
jas_image_cmptvstep(jp2_image,components[i]));
x_step[i]=(unsigned int) jas_image_cmpthstep(jp2_image,components[i]);
y_step[i]=(unsigned int) jas_image_cmptvstep(jp2_image,components[i]);
if ((width != image->columns) || (height != image->rows) ||
(jas_image_cmpttlx(jp2_image,components[i]) != 0) ||
(jas_image_cmpttly(jp2_image,components[i]) != 0) ||
(x_step[i] != 1) || (y_step[i] != 1) ||
(jas_image_cmptsgnd(jp2_image,components[i]) != MagickFalse))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported");
}
}
/*
Convert JPEG 2000 pixels.
*/
image->matte=number_components > 3 ? MagickTrue : MagickFalse;
maximum_component_depth=0;
for (i=0; i < (long) number_components; i++)
{
maximum_component_depth=(unsigned int) MagickMax((size_t)
jas_image_cmptprec(jp2_image,components[i]),(size_t)
maximum_component_depth);
pixels[i]=jas_matrix_create(1,(int) (image->columns/x_step[i]));
if (pixels[i] == (jas_matrix_t *) NULL)
{
for (--i; i >= 0; i--)
jas_matrix_destroy(pixels[i]);
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
}
image->depth=maximum_component_depth;
if (image_info->ping != MagickFalse)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(GetFirstImageInList(image));
}
for (i=0; i < (long) number_components; i++)
{
long
j;
map[i]=(QuantumAny *) AcquireQuantumMemory(MaxMap+1,sizeof(**map));
if (map[i] == (QuantumAny *) NULL)
{
for (--i; i >= 0; i--)
map[i]=(QuantumAny *) RelinquishMagickMemory(map[i]);
for (i=0; i < (long) number_components; i++)
jas_matrix_destroy(pixels[i]);
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
range=GetQuantumRange((unsigned long) jas_image_cmptprec(jp2_image,
components[i]));
for (j=0; j <= (long) MaxMap; j++)
map[i][j]=ScaleQuantumToMap(ScaleAnyToQuantum((QuantumAny) j,range));
}
for (y=0; y < (long) image->rows; y++)
{
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (i=0; i < (long) number_components; i++)
(void) jas_image_readcmpt(jp2_image,(short) components[i],0,
((unsigned int) y)/y_step[i],((unsigned int) image->columns)/x_step[i],
1,pixels[i]);
switch (number_components)
{
case 1:
{
/*
Grayscale.
*/
for (x=0; x < (long) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
q->red=(Quantum) map[0][pixel];
q->green=q->red;
q->blue=q->red;
q++;
}
break;
}
case 3:
{
/*
RGB.
*/
for (x=0; x < (long) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
q->red=(Quantum) map[0][pixel];
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
q->green=(Quantum) map[1][pixel];
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
q->blue=(Quantum) map[2][pixel];
q++;
}
break;
}
case 4:
{
/*
RGBA.
*/
for (x=0; x < (long) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
q->red=(Quantum) map[0][pixel];
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
q->green=(Quantum) map[1][pixel];
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
q->blue=(Quantum) map[2][pixel];
pixel=(QuantumAny) jas_matrix_getv(pixels[3],x/x_step[3]);
q->opacity=(Quantum) (QuantumRange-map[3][pixel]);
q++;
}
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
status=SetImageProgress(image,LoadImageTag,y,image->rows);
if (status == MagickFalse)
break;
}
for (i=0; i < (long) number_components; i++)
map[i]=(QuantumAny *) RelinquishMagickMemory(map[i]);
cm_profile=jas_image_cmprof(jp2_image);
icc_profile=(jas_iccprof_t *) NULL;
if (cm_profile != (jas_cmprof_t *) NULL)
icc_profile=jas_iccprof_createfromcmprof(cm_profile);
if (icc_profile != (jas_iccprof_t *) NULL)
{
jas_stream_t
*icc_stream;
icc_stream=jas_stream_memopen(NULL,0);
if ((icc_stream != (jas_stream_t *) NULL) &&
(jas_iccprof_save(icc_profile,icc_stream) == 0) &&
(jas_stream_flush(icc_stream) == 0))
{
StringInfo
*icc_profile,
*profile;
jas_stream_memobj_t
*blob;
/*
Extract the icc profile, handle errors without much noise.
*/
blob=(jas_stream_memobj_t *) icc_stream->obj_;
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Profile: ICC, %lu bytes",(unsigned long) blob->len_);
profile=AcquireStringInfo(blob->len_);
SetStringInfoDatum(profile,blob->buf_);
icc_profile=(StringInfo *) GetImageProfile(image,"icc");
if (icc_profile == (StringInfo *) NULL)
(void) SetImageProfile(image,"icc",profile);
else
(void) ConcatenateStringInfo(icc_profile,profile);
profile=DestroyStringInfo(profile);
(void) jas_stream_close(icc_stream);
}
}
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
for (i=0; i < (long) number_components; i++)
jas_matrix_destroy(pixels[i]);
return(GetFirstImageInList(image));
}
static gboolean
query_jp2 (const gchar *path,
gint *width,
gint *height,
gint *depth,
jas_image_t **jas_image)
{
gboolean ret;
jas_stream_t *in;
int image_fmt;
jas_image_t *image;
jas_cmprof_t *output_profile;
jas_image_t *cimage;
int numcmpts;
int i;
gboolean b;
in = NULL;
cimage = image = NULL;
output_profile = NULL;
ret = FALSE;
do
{
in = jas_stream_fopen (path, "rb");
if (!in)
{
g_warning ("Unable to open image file '%s'", path);
break;
}
image_fmt = jas_image_getfmt (in);
if (image_fmt < 0)
{
g_warning (_("Unknown JPEG-2000 image format in '%s'"), path);
break;
}
image = jas_image_decode (in, image_fmt, NULL);
if (!image)
{
g_warning (_("Unable to open JPEG-2000 image in '%s'"), path);
break;
}
output_profile = jas_cmprof_createfromclrspc (JAS_CLRSPC_SRGB);
if (!output_profile)
{
g_warning (_("Unable to create output color profile for '%s'"), path);
break;
}
cimage = jas_image_chclrspc (image, output_profile,
JAS_CMXFORM_INTENT_PER);
if (!cimage)
{
g_warning (_("Unable to convert image to sRGB color space "
"when processing '%s'"), path);
break;
}
numcmpts = jas_image_numcmpts (cimage);
if (numcmpts != 3)
{
g_warning (_("Unsupported non-RGB JPEG-2000 file with "
"%d components in '%s'"), numcmpts, path);
break;
}
*width = jas_image_cmptwidth (cimage, 0);
*height = jas_image_cmptheight (cimage, 0);
*depth = jas_image_cmptprec (cimage, 0);
if ((*depth != 8) && (*depth != 16))
{
g_warning (_("Unsupported JPEG-2000 file with depth %d in '%s'"),
*depth, path);
break;
}
b = FALSE;
for (i = 1; i < 3; i++)
{
if ((jas_image_cmptprec (cimage, i) != *depth) ||
(jas_image_cmptwidth (cimage, i) != *width) ||
(jas_image_cmptheight (cimage, i) != *height))
{
g_warning (_("Components of input image '%s' don't match"),
path);
b = TRUE;
break;
}
}
if (b)
break;
ret = TRUE;
}
while (FALSE); /* structured goto */
if (jas_image)
*jas_image = cimage;
else if (cimage)
jas_image_destroy (cimage);
if (image)
jas_image_destroy (image);
if (output_profile)
jas_cmprof_destroy (output_profile);
if (in)
jas_stream_close (in);
return ret;
}
DEFINE_LOADER_PLUGIN_LOAD(p, st, vw
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
, c
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
, priv
#if !defined(IDENTIFY_BEFORE_LOAD)
__attribute__((unused))
#endif
)
{
jas_image_t *ji;
jas_stream_t *js;
unsigned char *d;
char *buf = NULL;
int k, cmp[3];
unsigned int i, j;
int tlx, tly;
int vs, hs;
//debug_message("JasPer: load() called\n");
#ifdef IDENTIFY_BEFORE_LOAD
{
LoaderStatus status;
if ((status = identify(p, st, vw, c, priv)) != LOAD_OK)
return status;
stream_rewind(st);
}
#endif
/* Read whole stream into buffer... */
{
char *tmp;
int size = 0, len;
int bufsize = 65536;
for (;;) {
if ((tmp = realloc(buf, bufsize)) == NULL) {
free(buf);
return LOAD_ERROR;
}
buf = tmp;
len = stream_read(st, (unsigned char *)(buf + size), bufsize - size);
size += len;
if (len < bufsize - size)
break;
bufsize += 65536;
}
if ((js = jas_stream_memopen(buf, size)) == NULL) {
free(buf);
return LOAD_ERROR;
}
}
/* loading... */
if ((ji = jas_image_decode(js, -1, 0)) == NULL) {
err_message_fnc("jas_image_decode() failed.\n");
goto error_clear;
}
/* colorspace conversion */
{
jas_cmprof_t *jc;
jas_image_t *new_ji;
if ((jc = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB)) == NULL)
goto error_destroy_free;
if ((new_ji = jas_image_chclrspc(ji, jc, JAS_CMXFORM_INTENT_PER)) == NULL)
goto error_destroy_free;
jas_image_destroy(ji);
ji = new_ji;
}
jas_stream_close(js);
free(buf);
debug_message("JasPer: jas_image_decode() OK: (%ld,%ld)\n", jas_image_cmptwidth(ji, 0), jas_image_cmptheight(ji, 0));
/* convert to enfle format */
p->bits_per_pixel = 24;
p->type = _RGB24;
p->depth = 24;
cmp[0] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
cmp[1] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
cmp[2] = jas_image_getcmptbytype(ji, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
/* dimension */
image_width(p) = jas_image_cmptwidth(ji, cmp[0]);
image_height(p) = jas_image_cmptheight(ji, cmp[0]);
image_left(p) = 0;
image_top(p) = 0;
image_bpl(p) = image_width(p) * 3;
tlx = jas_image_cmpttlx(ji, cmp[0]);
tly = jas_image_cmpttly(ji, cmp[0]);
vs = jas_image_cmptvstep(ji, cmp[0]);
hs = jas_image_cmpthstep(ji, cmp[0]);
debug_message("JasPer: tlx %d tly %d vs %d hs %d ncomponents %d\n", tlx, tly, vs, hs, jas_image_numcmpts(ji));
/* memory allocation */
if ((d = memory_alloc(image_image(p), image_bpl(p) * image_height(p))) == NULL) {
err_message("No enough memory (%d bytes)\n", image_bpl(p) * image_height(p));
goto error_destroy_free;
}
for (i = 0; i < image_height(p); i++) {
for (j = 0; j < image_width(p); j++) {
for (k = 0; k < 3; k++)
*d++ = jas_image_readcmptsample(ji, cmp[k], j, i);
}
}
jas_image_destroy(ji);
return LOAD_OK;
error_destroy_free:
jas_image_destroy(ji);
error_clear:
return LOAD_ERROR;
}
int main(int argc, char **argv)
{
int fmtid;
int id;
char *infile;
jas_stream_t *instream;
jas_image_t *image;
int width;
int height;
int depth;
int numcmpts;
int verbose;
char *fmtname;
if (jas_init()) {
errprint(0, "error: cannot initialize jasper library\n");
abort();
}
/* set our error callback */
jas_set_error_cb(errprint);
cmdname = argv[0];
infile = 0;
verbose = 0;
/* Parse the command line options. */
while ((id = jas_getopt(argc, argv, opts)) >= 0) {
switch (id) {
case OPT_VERBOSE:
verbose = 1;
break;
case OPT_VERSION:
printf("%s\n", JAS_VERSION);
exit(EXIT_SUCCESS);
break;
case OPT_INFILE:
infile = jas_optarg;
break;
case OPT_HELP:
default:
usage();
break;
}
}
/* Open the image file. */
if (infile) {
/* The image is to be read from a file. */
if (!(instream = jas_stream_fopen(infile, "rb"))) {
jas_eprintf("cannot open input image file %s\n", infile);
exit(EXIT_FAILURE);
}
} else {
/* The image is to be read from standard input. */
if (!(instream = jas_stream_fdopen(0, "rb"))) {
jas_eprintf("cannot open standard input\n");
exit(EXIT_FAILURE);
}
}
if ((fmtid = jas_image_getfmt(instream)) < 0) {
jas_eprintf("unknown image format\n");
}
/* Decode the image. */
if (!(image = jas_image_decode(instream, fmtid, 0))) {
jas_eprintf("cannot load image\n");
return EXIT_FAILURE;
}
/* Close the image file. */
jas_stream_close(instream);
numcmpts = jas_image_numcmpts(image);
width = jas_image_cmptwidth(image, 0);
height = jas_image_cmptheight(image, 0);
depth = jas_image_cmptprec(image, 0);
if (!(fmtname = jas_image_fmttostr(fmtid))) {
abort();
}
jas_eprintf("%s %d %d %d %d %ld\n", fmtname, numcmpts, width, height, depth, (long) jas_image_rawsize(image));
jas_image_destroy(image);
jas_image_clearfmts();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
jas_image_t *image;
cmdopts_t *cmdopts;
jas_stream_t *in;
jas_stream_t *out;
clock_t startclk;
clock_t endclk;
long dectime;
long enctime;
int_fast16_t numcmpts;
int i;
/* Determine the base name of this command. */
if ((cmdname = strrchr(argv[0], '/'))) {
++cmdname;
} else {
cmdname = argv[0];
}
if (jas_init()) {
errprint(0, "error: cannot initialize jasper library\n");
abort();
}
/* set our error callback */
jas_set_error_cb(errprint);
/* Parse the command line options. */
if (!(cmdopts = cmdopts_parse(argc, argv))) {
jas_eprintf("error: cannot parse command line\n");
exit(EXIT_FAILURE);
}
if (cmdopts->version) {
jas_eprintf("%s\n", JAS_VERSION);
jas_eprintf("libjasper %s\n", jas_getversion());
exit(EXIT_SUCCESS);
}
jas_setdbglevel(cmdopts->debug);
if (cmdopts->verbose) {
cmdinfo();
}
/* Open the input image file. */
if (cmdopts->infile) {
/* The input image is to be read from a file. */
if (!(in = jas_stream_fopen(cmdopts->infile, "rb"))) {
jas_eprintf("error: cannot open input image file %s\n",
cmdopts->infile);
exit(EXIT_FAILURE);
}
} else {
/* The input image is to be read from standard input. */
if (!(in = jas_stream_fdopen(0, "rb"))) {
jas_eprintf("error: cannot open standard input\n");
exit(EXIT_FAILURE);
}
}
/* Open the output image file. */
if (cmdopts->outfile) {
/* The output image is to be written to a file. */
if (!(out = jas_stream_fopen(cmdopts->outfile, "w+b"))) {
jas_eprintf("error: cannot open output image file %s\n",
cmdopts->outfile);
exit(EXIT_FAILURE);
}
} else {
/* The output image is to be written to standard output. */
if (!(out = jas_stream_fdopen(1, "w+b"))) {
jas_eprintf("error: cannot open standard output\n");
exit(EXIT_FAILURE);
}
}
if (cmdopts->infmt < 0) {
if ((cmdopts->infmt = jas_image_getfmt(in)) < 0) {
jas_eprintf("error: input image has unknown format\n");
exit(EXIT_FAILURE);
}
}
/* Get the input image data. */
startclk = clock();
if (!(image = jas_image_decode(in, cmdopts->infmt, cmdopts->inopts))) {
jas_eprintf("error: cannot load image data\n");
exit(EXIT_FAILURE);
}
endclk = clock();
dectime = endclk - startclk;
/* If requested, throw away all of the components except one.
Why might this be desirable? It is a hack, really.
None of the image formats other than the JPEG-2000 ones support
images with two, four, five, or more components. This hack
allows such images to be decoded with the non-JPEG-2000 decoders,
one component at a time. */
numcmpts = jas_image_numcmpts(image);
if (cmdopts->cmptno >= 0 && cmdopts->cmptno < numcmpts) {
for (i = numcmpts - 1; i >= 0; --i) {
if (i != cmdopts->cmptno) {
jas_image_delcmpt(image, i);
}
}
}
if (cmdopts->srgb) {
jas_image_t *newimage;
jas_cmprof_t *outprof;
jas_eprintf("forcing conversion to sRGB\n");
if (!(outprof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB))) {
jas_eprintf("cannot create sRGB profile\n");
exit(EXIT_FAILURE);
}
if (!(newimage = jas_image_chclrspc(image, outprof, JAS_CMXFORM_INTENT_PER))) {
jas_eprintf("cannot convert to sRGB\n");
exit(EXIT_FAILURE);
}
jas_image_destroy(image);
jas_cmprof_destroy(outprof);
image = newimage;
}
/* Generate the output image data. */
startclk = clock();
if (jas_image_encode(image, out, cmdopts->outfmt, cmdopts->outopts)) {
jas_eprintf("error: cannot encode image\n");
exit(EXIT_FAILURE);
}
jas_stream_flush(out);
endclk = clock();
enctime = endclk - startclk;
if (cmdopts->verbose) {
jas_eprintf("decoding time = %f\n", dectime / (double)
CLOCKS_PER_SEC);
jas_eprintf("encoding time = %f\n", enctime / (double)
CLOCKS_PER_SEC);
}
/* If this fails, we don't care. */
(void) jas_stream_close(in);
/* Close the output image stream. */
if (jas_stream_close(out)) {
jas_eprintf("error: cannot close output image file\n");
exit(EXIT_FAILURE);
}
cmdopts_destroy(cmdopts);
jas_image_destroy(image);
jas_image_clearfmts();
/* Success at last! :-) */
return EXIT_SUCCESS;
}
bool JP2KLoader::load(const QString& filePath, DImgLoaderObserver* observer)
{
readMetadata(filePath, DImg::JPEG);
FILE* file = fopen(QFile::encodeName(filePath), "rb");
if (!file)
{
loadingFailed();
return false;
}
unsigned char header[9];
if (fread(&header, 9, 1, file) != 1)
{
fclose(file);
loadingFailed();
return false;
}
unsigned char jp2ID[5] = { 0x6A, 0x50, 0x20, 0x20, 0x0D, };
unsigned char jpcID[2] = { 0xFF, 0x4F };
if (memcmp(&header[4], &jp2ID, 5) != 0 &&
memcmp(&header, &jpcID, 2) != 0)
{
// not a jpeg2000 file
fclose(file);
loadingFailed();
return false;
}
fclose(file);
imageSetAttribute("format", "JP2K");
if (!(m_loadFlags & LoadImageData) && !(m_loadFlags & LoadICCData))
{
// libjasper will load the full image in memory already when calling jas_image_decode.
// This is bad when scanning. See bugs 215458 and 195583.
//FIXME: Use Exiv2 or OpenJPEG to extract this info
DMetadata metadata(filePath);
QSize size = metadata.getImageDimensions();
if (size.isValid())
{
imageWidth() = size.width();
imageHeight() = size.height();
}
return true;
}
// -------------------------------------------------------------------
// Initialize JPEG 2000 API.
register long i, x, y;
int components[4];
unsigned int maximum_component_depth, scale[4], x_step[4], y_step[4];
unsigned long number_components;
jas_image_t* jp2_image = 0;
jas_stream_t* jp2_stream = 0;
jas_matrix_t* pixels[4];
int init = jas_init();
if (init != 0)
{
kDebug() << "Unable to init JPEG2000 decoder";
loadingFailed();
return false;
}
jp2_stream = jas_stream_fopen(QFile::encodeName(filePath), "rb");
if (jp2_stream == 0)
{
kDebug() << "Unable to open JPEG2000 stream";
loadingFailed();
return false;
}
jp2_image = jas_image_decode(jp2_stream, -1, 0);
if (jp2_image == 0)
{
jas_stream_close(jp2_stream);
kDebug() << "Unable to decode JPEG2000 image";
loadingFailed();
return false;
}
jas_stream_close(jp2_stream);
// some pseudo-progress
if (observer)
{
observer->progressInfo(m_image, 0.1F);
}
// -------------------------------------------------------------------
// Check color space.
int colorModel;
switch (jas_clrspc_fam(jas_image_clrspc(jp2_image)))
{
case JAS_CLRSPC_FAM_RGB:
{
components[0] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_RGB_R);
components[1] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_RGB_G);
components[2] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_RGB_B);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
jas_image_destroy(jp2_image);
kDebug() << "Error parsing JPEG2000 image : Missing Image Channel";
loadingFailed();
return false;
}
number_components = 3;
components[3] = jas_image_getcmptbytype(jp2_image, 3);
if (components[3] > 0)
{
m_hasAlpha = true;
++number_components;
}
colorModel = DImg::RGB;
break;
}
case JAS_CLRSPC_FAM_GRAY:
{
components[0] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_GRAY_Y);
if (components[0] < 0)
{
jas_image_destroy(jp2_image);
kDebug() << "Error parsing JP2000 image : Missing Image Channel";
loadingFailed();
return false;
}
number_components = 1;
colorModel = DImg::GRAYSCALE;
break;
}
case JAS_CLRSPC_FAM_YCBCR:
{
components[0] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_YCBCR_Y);
components[1] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_YCBCR_CB);
components[2] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_YCBCR_CR);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
jas_image_destroy(jp2_image);
kDebug() << "Error parsing JP2000 image : Missing Image Channel";
loadingFailed();
return false;
}
number_components = 3;
components[3] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_UNKNOWN);
if (components[3] > 0)
{
m_hasAlpha = true;
++number_components;
}
// FIXME : image->colorspace=YCbCrColorspace;
colorModel = DImg::YCBCR;
break;
}
default:
{
jas_image_destroy(jp2_image);
kDebug() << "Error parsing JP2000 image : Colorspace Model Is Not Supported";
loadingFailed();
return false;
}
}
// -------------------------------------------------------------------
// Check image geometry.
imageWidth() = jas_image_width(jp2_image);
imageHeight() = jas_image_height(jp2_image);
for (i = 0; i < (long)number_components; ++i)
{
if ((((jas_image_cmptwidth(jp2_image, components[i])*
jas_image_cmpthstep(jp2_image, components[i])) != (long)imageWidth())) ||
(((jas_image_cmptheight(jp2_image, components[i])*
jas_image_cmptvstep(jp2_image, components[i])) != (long)imageHeight())) ||
(jas_image_cmpttlx(jp2_image, components[i]) != 0) ||
(jas_image_cmpttly(jp2_image, components[i]) != 0) ||
(jas_image_cmptsgnd(jp2_image, components[i]) != false))
{
jas_image_destroy(jp2_image);
kDebug() << "Error parsing JPEG2000 image : Irregular Channel Geometry Not Supported";
loadingFailed();
return false;
}
x_step[i] = jas_image_cmpthstep(jp2_image, components[i]);
y_step[i] = jas_image_cmptvstep(jp2_image, components[i]);
}
// -------------------------------------------------------------------
// Get image format.
m_hasAlpha = number_components > 3;
maximum_component_depth = 0;
for (i = 0; i < (long)number_components; ++i)
{
maximum_component_depth = qMax((long)jas_image_cmptprec(jp2_image,components[i]),
(long)maximum_component_depth);
pixels[i] = jas_matrix_create(1, ((unsigned int)imageWidth())/x_step[i]);
if (!pixels[i])
{
jas_image_destroy(jp2_image);
kDebug() << "Error decoding JPEG2000 image data : Memory Allocation Failed";
loadingFailed();
return false;
}
}
if (maximum_component_depth > 8)
{
m_sixteenBit = true;
}
for (i = 0 ; i < (long)number_components ; ++i)
{
scale[i] = 1;
int prec = jas_image_cmptprec(jp2_image, components[i]);
if (m_sixteenBit && prec < 16)
{
scale[i] = (1 << (16 - jas_image_cmptprec(jp2_image, components[i])));
}
}
// -------------------------------------------------------------------
// Get image data.
uchar* data = 0;
if (m_loadFlags & LoadImageData)
{
if (m_sixteenBit) // 16 bits image.
{
data = new_failureTolerant(imageWidth()*imageHeight()*8);
}
else
{
data = new_failureTolerant(imageWidth()*imageHeight()*4);
}
if (!data)
{
kDebug() << "Error decoding JPEG2000 image data : Memory Allocation Failed";
jas_image_destroy(jp2_image);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
loadingFailed();
return false;
}
uint checkPoint = 0;
uchar* dst = data;
unsigned short* dst16 = (unsigned short*)data;
for (y = 0 ; y < (long)imageHeight() ; ++y)
{
for (i = 0 ; i < (long)number_components; ++i)
{
int ret = jas_image_readcmpt(jp2_image, (short)components[i], 0,
((unsigned int) y) / y_step[i],
((unsigned int) imageWidth()) / x_step[i],
1, pixels[i]);
if (ret != 0)
{
kDebug() << "Error decoding JPEG2000 image data";
delete [] data;
jas_image_destroy(jp2_image);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
loadingFailed();
return false;
}
}
switch (number_components)
{
case 1: // Grayscale.
{
for (x = 0 ; x < (long)imageWidth() ; ++x)
{
dst[0] = (uchar)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0]));
dst[1] = dst[0];
dst[2] = dst[0];
dst[3] = 0xFF;
dst += 4;
}
break;
}
case 3: // RGB.
{
if (!m_sixteenBit) // 8 bits image.
{
for (x = 0 ; x < (long)imageWidth() ; ++x)
{
// Blue
dst[0] = (uchar)(scale[2]*jas_matrix_getv(pixels[2], x/x_step[2]));
// Green
dst[1] = (uchar)(scale[1]*jas_matrix_getv(pixels[1], x/x_step[1]));
// Red
dst[2] = (uchar)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0]));
// Alpha
dst[3] = 0xFF;
dst += 4;
}
}
else // 16 bits image.
{
for (x = 0 ; x < (long)imageWidth() ; ++x)
{
// Blue
dst16[0] = (unsigned short)(scale[2]*jas_matrix_getv(pixels[2], x/x_step[2]));
// Green
dst16[1] = (unsigned short)(scale[1]*jas_matrix_getv(pixels[1], x/x_step[1]));
// Red
dst16[2] = (unsigned short)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0]));
// Alpha
dst16[3] = 0xFFFF;
dst16 += 4;
}
}
break;
}
case 4: // RGBA.
{
if (!m_sixteenBit) // 8 bits image.
{
for (x = 0 ; x < (long)imageWidth() ; ++x)
{
// Blue
dst[0] = (uchar)(scale[2] * jas_matrix_getv(pixels[2], x/x_step[2]));
// Green
dst[1] = (uchar)(scale[1] * jas_matrix_getv(pixels[1], x/x_step[1]));
// Red
dst[2] = (uchar)(scale[0] * jas_matrix_getv(pixels[0], x/x_step[0]));
// Alpha
dst[3] = (uchar)(scale[3] * jas_matrix_getv(pixels[3], x/x_step[3]));
dst += 4;
}
}
else // 16 bits image.
{
for (x = 0 ; x < (long)imageWidth() ; ++x)
{
// Blue
dst16[0] = (unsigned short)(scale[2]*jas_matrix_getv(pixels[2], x/x_step[2]));
// Green
dst16[1] = (unsigned short)(scale[1]*jas_matrix_getv(pixels[1], x/x_step[1]));
// Red
dst16[2] = (unsigned short)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0]));
// Alpha
dst16[3] = (unsigned short)(scale[3]*jas_matrix_getv(pixels[3], x/x_step[3]));
dst16 += 4;
}
}
break;
}
}
// use 0-10% and 90-100% for pseudo-progress
if (observer && y >= (long)checkPoint)
{
checkPoint += granularity(observer, y, 0.8F);
if (!observer->continueQuery(m_image))
{
delete [] data;
jas_image_destroy(jp2_image);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
loadingFailed();
return false;
}
observer->progressInfo(m_image, 0.1 + (0.8 * ( ((float)y)/((float)imageHeight()) )));
}
}
}
// -------------------------------------------------------------------
// Get ICC color profile.
if (m_loadFlags & LoadICCData)
{
jas_iccprof_t* icc_profile = 0;
jas_stream_t* icc_stream = 0;
jas_cmprof_t* cm_profile = 0;
cm_profile = jas_image_cmprof(jp2_image);
if (cm_profile != 0)
{
icc_profile = jas_iccprof_createfromcmprof(cm_profile);
}
if (icc_profile != 0)
{
icc_stream = jas_stream_memopen(NULL, 0);
if (icc_stream != 0)
{
if (jas_iccprof_save(icc_profile, icc_stream) == 0)
{
if (jas_stream_flush(icc_stream) == 0)
{
jas_stream_memobj_t* blob = (jas_stream_memobj_t*) icc_stream->obj_;
QByteArray profile_rawdata;
profile_rawdata.resize(blob->len_);
memcpy(profile_rawdata.data(), blob->buf_, blob->len_);
imageSetIccProfile(profile_rawdata);
jas_stream_close(icc_stream);
}
}
}
}
}
if (observer)
{
observer->progressInfo(m_image, 1.0);
}
imageData() = data;
imageSetAttribute("format", "JP2K");
imageSetAttribute("originalColorModel", colorModel);
imageSetAttribute("originalBitDepth", maximum_component_depth);
imageSetAttribute("originalSize", QSize(imageWidth(), imageHeight()));
jas_image_destroy(jp2_image);
for (i = 0 ; i < (long)number_components ; ++i)
{
jas_matrix_destroy(pixels[i]);
}
jas_cleanup();
return true;
}
