int jas_getopt(int argc, char **argv, jas_opt_t *opts)
{
char *cp;
int id;
int hasarg;
jas_opt_t *opt;
char *s;
if (!jas_optind) {
jas_optind = JAS_MIN(1, argc);
}
while (jas_optind < argc) {
s = cp = argv[jas_optind];
if (*cp == '-') {
/* We are processing an option. */
++jas_optind;
if (*++cp == '-') {
/* We are processing a long option. */
++cp;
if (*cp == '\0') {
/* This is the end of the options. */
return JAS_GETOPT_EOF;
}
if (!(opt = jas_optlookup(opts, cp))) {
if (jas_opterr) {
jas_eprintf("unknown long option %s\n", s);
}
return JAS_GETOPT_ERR;
}
hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
id = opt->id;
} else {
/* We are processing a short option. */
if (strlen(cp) != 1 ||
!(opt = jas_optlookup(opts, cp))) {
if (jas_opterr) {
jas_eprintf("unknown short option %s\n", s);
}
return JAS_GETOPT_ERR;
}
hasarg = (opt->flags & JAS_OPT_HASARG) != 0;
id = opt->id;
}
if (hasarg) {
/* The option has an argument. */
if (jas_optind >= argc) {
if (jas_opterr) {
jas_eprintf("missing argument for option %s\n", s);
}
return JAS_GETOPT_ERR;
}
jas_optarg = argv[jas_optind];
++jas_optind;
} else {
/* The option does not have an argument. */
jas_optarg = 0;
}
return id;
} else {
/* We are not processing an option. */
return JAS_GETOPT_EOF;
}
}
return JAS_GETOPT_EOF;
}
cmdopts_t *cmdopts_parse(int argc, char **argv)
{
typedef enum {
CMDOPT_HELP = 0,
CMDOPT_VERBOSE,
CMDOPT_INFILE,
CMDOPT_INFMT,
CMDOPT_INOPT,
CMDOPT_OUTFILE,
CMDOPT_OUTFMT,
CMDOPT_OUTOPT,
CMDOPT_VERSION,
CMDOPT_DEBUG,
CMDOPT_CMPTNO,
CMDOPT_SRGB
} cmdoptid_t;
static jas_opt_t cmdoptions[] = {
{CMDOPT_HELP, "help", 0},
{CMDOPT_VERBOSE, "verbose", 0},
{CMDOPT_INFILE, "input", JAS_OPT_HASARG},
{CMDOPT_INFILE, "f", JAS_OPT_HASARG},
{CMDOPT_INFMT, "input-format", JAS_OPT_HASARG},
{CMDOPT_INFMT, "t", JAS_OPT_HASARG},
{CMDOPT_INOPT, "input-option", JAS_OPT_HASARG},
{CMDOPT_INOPT, "o", JAS_OPT_HASARG},
{CMDOPT_OUTFILE, "output", JAS_OPT_HASARG},
{CMDOPT_OUTFILE, "F", JAS_OPT_HASARG},
{CMDOPT_OUTFMT, "output-format", JAS_OPT_HASARG},
{CMDOPT_OUTFMT, "T", JAS_OPT_HASARG},
{CMDOPT_OUTOPT, "output-option", JAS_OPT_HASARG},
{CMDOPT_OUTOPT, "O", JAS_OPT_HASARG},
{CMDOPT_VERSION, "version", 0},
{CMDOPT_DEBUG, "debug-level", JAS_OPT_HASARG},
{CMDOPT_CMPTNO, "cmptno", JAS_OPT_HASARG},
{CMDOPT_SRGB, "force-srgb", 0},
{CMDOPT_SRGB, "S", 0},
{-1, 0, 0}
};
cmdopts_t *cmdopts;
int c;
if (!(cmdopts = malloc(sizeof(cmdopts_t)))) {
jas_eprintf("error: insufficient memory\n");
exit(EXIT_FAILURE);
}
cmdopts->infile = 0;
cmdopts->infmt = -1;
cmdopts->inopts = 0;
cmdopts->inoptsbuf[0] = '\0';
cmdopts->outfile = 0;
cmdopts->outfmt = -1;
cmdopts->outopts = 0;
cmdopts->outoptsbuf[0] = '\0';
cmdopts->verbose = 0;
cmdopts->version = 0;
cmdopts->cmptno = -1;
cmdopts->debug = 0;
cmdopts->srgb = 0;
while ((c = jas_getopt(argc, argv, cmdoptions)) != EOF) {
switch (c) {
case CMDOPT_HELP:
cmdusage();
break;
case CMDOPT_VERBOSE:
cmdopts->verbose = 1;
break;
case CMDOPT_VERSION:
cmdopts->version = 1;
break;
case CMDOPT_DEBUG:
cmdopts->debug = atoi(jas_optarg);
break;
case CMDOPT_INFILE:
cmdopts->infile = jas_optarg;
break;
case CMDOPT_INFMT:
if ((cmdopts->infmt = jas_image_strtofmt(jas_optarg)) < 0) {
jas_eprintf("warning: ignoring invalid input format %s\n",
jas_optarg);
cmdopts->infmt = -1;
}
break;
case CMDOPT_INOPT:
addopt(cmdopts->inoptsbuf, OPTSMAX, jas_optarg);
cmdopts->inopts = cmdopts->inoptsbuf;
break;
case CMDOPT_OUTFILE:
cmdopts->outfile = jas_optarg;
break;
case CMDOPT_OUTFMT:
if ((cmdopts->outfmt = jas_image_strtofmt(jas_optarg)) < 0) {
jas_eprintf("error: invalid output format %s\n", jas_optarg);
badusage();
}
break;
case CMDOPT_OUTOPT:
addopt(cmdopts->outoptsbuf, OPTSMAX, jas_optarg);
cmdopts->outopts = cmdopts->outoptsbuf;
break;
case CMDOPT_CMPTNO:
cmdopts->cmptno = atoi(jas_optarg);
break;
case CMDOPT_SRGB:
cmdopts->srgb = 1;
break;
default:
badusage();
break;
}
}
while (jas_optind < argc) {
jas_eprintf(
"warning: ignoring bogus command line argument %s\n",
argv[jas_optind]);
++jas_optind;
}
if (cmdopts->version) {
goto done;
}
if (cmdopts->outfmt < 0 && cmdopts->outfile) {
if ((cmdopts->outfmt = jas_image_fmtfromname(cmdopts->outfile)) < 0) {
jas_eprintf(
"error: cannot guess image format from output file name\n");
}
}
if (cmdopts->outfmt < 0) {
jas_eprintf("error: no output format specified\n");
badusage();
}
done:
return cmdopts;
}
jas_image_t *jp2_decode(jas_stream_t *in, char *optstr)
{
jp2_box_t *box;
int found;
jas_image_t *image;
jp2_dec_t *dec;
bool samedtype;
int dtype;
unsigned int i;
jp2_cmap_t *cmapd;
jp2_pclr_t *pclrd;
jp2_cdef_t *cdefd;
unsigned int channo;
int newcmptno;
int_fast32_t *lutents;
#if 0
jp2_cdefchan_t *cdefent;
int cmptno;
#endif
jp2_cmapent_t *cmapent;
jas_icchdr_t icchdr;
jas_iccprof_t *iccprof;
dec = 0;
box = 0;
image = 0;
if (!(dec = jp2_dec_create())) {
goto error;
}
/* Get the first box. This should be a JP box. */
if (!(box = jp2_box_get(in))) {
jas_eprintf("error: cannot get box\n");
goto error;
}
if (box->type != JP2_BOX_JP) {
jas_eprintf("error: expecting signature box\n");
goto error;
}
if (box->data.jp.magic != JP2_JP_MAGIC) {
jas_eprintf("incorrect magic number\n");
goto error;
}
jp2_box_destroy(box);
box = 0;
/* Get the second box. This should be a FTYP box. */
if (!(box = jp2_box_get(in))) {
goto error;
}
if (box->type != JP2_BOX_FTYP) {
jas_eprintf("expecting file type box\n");
goto error;
}
jp2_box_destroy(box);
box = 0;
/* Get more boxes... */
found = 0;
while ((box = jp2_box_get(in))) {
if (jas_getdbglevel() >= 1) {
fprintf(stderr, "box type %s\n", box->info->name);
}
switch (box->type) {
case JP2_BOX_JP2C:
found = 1;
break;
case JP2_BOX_IHDR:
if (!dec->ihdr) {
dec->ihdr = box;
box = 0;
}
break;
case JP2_BOX_BPCC:
if (!dec->bpcc) {
dec->bpcc = box;
box = 0;
}
break;
case JP2_BOX_CDEF:
if (!dec->cdef) {
dec->cdef = box;
box = 0;
}
break;
case JP2_BOX_PCLR:
if (!dec->pclr) {
dec->pclr = box;
box = 0;
}
break;
case JP2_BOX_CMAP:
if (!dec->cmap) {
dec->cmap = box;
box = 0;
}
break;
case JP2_BOX_COLR:
if (!dec->colr) {
dec->colr = box;
box = 0;
}
break;
}
if (box) {
jp2_box_destroy(box);
box = 0;
}
if (found) {
break;
}
}
if (!found) {
jas_eprintf("error: no code stream found\n");
goto error;
}
if (!(dec->image = jpc_decode(in, optstr))) {
jas_eprintf("error: cannot decode code stream\n");
goto error;
}
/* An IHDR box must be present. */
if (!dec->ihdr) {
jas_eprintf("error: missing IHDR box\n");
goto error;
}
/* Does the number of components indicated in the IHDR box match
the value specified in the code stream? */
if (dec->ihdr->data.ihdr.numcmpts != JAS_CAST(uint, jas_image_numcmpts(dec->image))) {
jas_eprintf("warning: number of components mismatch\n");
}
/* At least one component must be present. */
if (!jas_image_numcmpts(dec->image)) {
jas_eprintf("error: no components\n");
goto error;
}
/* Determine if all components have the same data type. */
samedtype = true;
dtype = jas_image_cmptdtype(dec->image, 0);
for (i = 1; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
if (jas_image_cmptdtype(dec->image, i) != dtype) {
samedtype = false;
break;
}
}
/* Is the component data type indicated in the IHDR box consistent
with the data in the code stream? */
if ((samedtype && dec->ihdr->data.ihdr.bpc != JP2_DTYPETOBPC(dtype)) ||
(!samedtype && dec->ihdr->data.ihdr.bpc != JP2_IHDR_BPCNULL)) {
jas_eprintf("warning: component data type mismatch\n");
}
/* Is the compression type supported? */
if (dec->ihdr->data.ihdr.comptype != JP2_IHDR_COMPTYPE) {
jas_eprintf("error: unsupported compression type\n");
goto error;
}
if (dec->bpcc) {
/* Is the number of components indicated in the BPCC box
consistent with the code stream data? */
if (dec->bpcc->data.bpcc.numcmpts != JAS_CAST(uint, jas_image_numcmpts(
dec->image))) {
jas_eprintf("warning: number of components mismatch\n");
}
/* Is the component data type information indicated in the BPCC
box consistent with the code stream data? */
if (!samedtype) {
for (i = 0; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
if (jas_image_cmptdtype(dec->image, i) != JP2_BPCTODTYPE(dec->bpcc->data.bpcc.bpcs[i])) {
jas_eprintf("warning: component data type mismatch\n");
}
}
} else {
jas_eprintf("warning: superfluous BPCC box\n");
}
}
/* A COLR box must be present. */
if (!dec->colr) {
jas_eprintf("error: no COLR box\n");
goto error;
}
switch (dec->colr->data.colr.method) {
case JP2_COLR_ENUM:
jas_image_setclrspc(dec->image, jp2_getcs(&dec->colr->data.colr));
break;
case JP2_COLR_ICC:
iccprof = jas_iccprof_createfrombuf(dec->colr->data.colr.iccp,
dec->colr->data.colr.iccplen);
assert(iccprof);
jas_iccprof_gethdr(iccprof, &icchdr);
jas_eprintf("ICC Profile CS %08x\n", icchdr.colorspc);
jas_image_setclrspc(dec->image, fromiccpcs(icchdr.colorspc));
dec->image->cmprof_ = jas_cmprof_createfromiccprof(iccprof);
assert(dec->image->cmprof_);
jas_iccprof_destroy(iccprof);
break;
}
/* If a CMAP box is present, a PCLR box must also be present. */
if (dec->cmap && !dec->pclr) {
jas_eprintf("warning: missing PCLR box or superfluous CMAP box\n");
jp2_box_destroy(dec->cmap);
dec->cmap = 0;
}
/* If a CMAP box is not present, a PCLR box must not be present. */
if (!dec->cmap && dec->pclr) {
jas_eprintf("warning: missing CMAP box or superfluous PCLR box\n");
jp2_box_destroy(dec->pclr);
dec->pclr = 0;
}
/* Determine the number of channels (which is essentially the number
of components after any palette mappings have been applied). */
dec->numchans = dec->cmap ? dec->cmap->data.cmap.numchans : JAS_CAST(uint, jas_image_numcmpts(dec->image));
/* Perform a basic sanity check on the CMAP box if present. */
if (dec->cmap) {
for (i = 0; i < dec->numchans; ++i) {
/* Is the component number reasonable? */
if (dec->cmap->data.cmap.ents[i].cmptno >= JAS_CAST(uint, jas_image_numcmpts(dec->image))) {
jas_eprintf("error: invalid component number in CMAP box\n");
goto error;
}
/* Is the LUT index reasonable? */
if (dec->cmap->data.cmap.ents[i].pcol >= dec->pclr->data.pclr.numchans) {
jas_eprintf("error: invalid CMAP LUT index\n");
goto error;
}
}
}
/* Allocate space for the channel-number to component-number LUT. */
if (!(dec->chantocmptlut = jas_malloc(dec->numchans * sizeof(uint_fast16_t)))) {
jas_eprintf("error: no memory\n");
goto error;
}
if (!dec->cmap) {
for (i = 0; i < dec->numchans; ++i) {
dec->chantocmptlut[i] = i;
}
} else {
cmapd = &dec->cmap->data.cmap;
pclrd = &dec->pclr->data.pclr;
cdefd = &dec->cdef->data.cdef;
for (channo = 0; channo < cmapd->numchans; ++channo) {
cmapent = &cmapd->ents[channo];
if (cmapent->map == JP2_CMAP_DIRECT) {
dec->chantocmptlut[channo] = channo;
} else if (cmapent->map == JP2_CMAP_PALETTE) {
lutents = jas_malloc(pclrd->numlutents * sizeof(int_fast32_t));
for (i = 0; i < pclrd->numlutents; ++i) {
lutents[i] = pclrd->lutdata[cmapent->pcol + i * pclrd->numchans];
}
newcmptno = jas_image_numcmpts(dec->image);
jas_image_depalettize(dec->image, cmapent->cmptno, pclrd->numlutents, lutents, JP2_BPCTODTYPE(pclrd->bpc[cmapent->pcol]), newcmptno);
dec->chantocmptlut[channo] = newcmptno;
jas_free(lutents);
#if 0
if (dec->cdef) {
cdefent = jp2_cdef_lookup(cdefd, channo);
if (!cdefent) {
abort();
}
jas_image_setcmpttype(dec->image, newcmptno, jp2_getct(jas_image_clrspc(dec->image), cdefent->type, cdefent->assoc));
} else {
jas_image_setcmpttype(dec->image, newcmptno, jp2_getct(jas_image_clrspc(dec->image), 0, channo + 1));
}
#endif
}
}
}
/* Mark all components as being of unknown type. */
for (i = 0; i < JAS_CAST(uint, jas_image_numcmpts(dec->image)); ++i) {
jas_image_setcmpttype(dec->image, i, JAS_IMAGE_CT_UNKNOWN);
}
/* Determine the type of each component. */
if (dec->cdef) {
for (i = 0; i < dec->numchans; ++i) {
jas_image_setcmpttype(dec->image,
dec->chantocmptlut[dec->cdef->data.cdef.ents[i].channo],
jp2_getct(jas_image_clrspc(dec->image),
dec->cdef->data.cdef.ents[i].type, dec->cdef->data.cdef.ents[i].assoc));
}
} else {
for (i = 0; i < dec->numchans; ++i) {
jas_image_setcmpttype(dec->image, dec->chantocmptlut[i],
jp2_getct(jas_image_clrspc(dec->image), 0, i + 1));
}
}
/* Delete any components that are not of interest. */
for (i = jas_image_numcmpts(dec->image); i > 0; --i) {
if (jas_image_cmpttype(dec->image, i - 1) == JAS_IMAGE_CT_UNKNOWN) {
jas_image_delcmpt(dec->image, i - 1);
}
}
/* Ensure that some components survived. */
if (!jas_image_numcmpts(dec->image)) {
jas_eprintf("error: no components\n");
goto error;
}
#if 0
fprintf(stderr, "no of components is %d\n", jas_image_numcmpts(dec->image));
#endif
/* Prevent the image from being destroyed later. */
image = dec->image;
dec->image = 0;
jp2_dec_destroy(dec);
return image;
error:
if (box) {
jp2_box_destroy(box);
}
if (dec) {
jp2_dec_destroy(dec);
}
return 0;
}
jas_image_t *makediffimage(jas_matrix_t *origdata, jas_matrix_t *recondata)
{
jas_image_t *diffimage;
jas_matrix_t *diffdata[3];
int width;
int height;
int i;
int j;
int k;
jas_image_cmptparm_t compparms[3];
jas_seqent_t a;
jas_seqent_t b;
width = jas_matrix_numcols(origdata);
height = jas_matrix_numrows(origdata);
for (i = 0; i < 3; ++i) {
compparms[i].tlx = 0;
compparms[i].tly = 0;
compparms[i].hstep = 1;
compparms[i].vstep = 1;
compparms[i].width = width;
compparms[i].height = height;
compparms[i].prec = 8;
compparms[i].sgnd = jas_false;
}
if (!(diffimage = jas_image_create(3, compparms, JAS_CLRSPC_SRGB))) {
abort();
}
for (i = 0; i < 3; ++i) {
if (!(diffdata[i] = jas_matrix_create(height, width))) {
jas_eprintf("internal error\n");
return 0;
}
}
for (j = 0; j < height; ++j) {
for (k = 0; k < width; ++k) {
a = jas_matrix_get(origdata, j, k);
b = jas_matrix_get(recondata, j, k);
if (a > b) {
jas_matrix_set(diffdata[0], j, k, 255);
jas_matrix_set(diffdata[1], j, k, 0);
jas_matrix_set(diffdata[2], j, k, 0);
} else if (a < b) {
jas_matrix_set(diffdata[0], j, k, 0);
jas_matrix_set(diffdata[1], j, k, 255);
jas_matrix_set(diffdata[2], j, k, 0);
} else {
jas_matrix_set(diffdata[0], j, k, a);
jas_matrix_set(diffdata[1], j, k, a);
jas_matrix_set(diffdata[2], j, k, a);
}
}
}
for (i = 0; i < 3; ++i) {
if (jas_image_writecmpt(diffimage, i, 0, 0, width, height, diffdata[i])) {
return 0;
}
}
return diffimage;
}
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;
}
/* Read a marker segment from a stream. */
jpc_ms_t *jpc_getms(jas_stream_t *in, jpc_cstate_t *cstate)
{
jpc_ms_t *ms;
jpc_mstabent_t *mstabent;
jas_stream_t *tmpstream;
if (!(ms = jpc_ms_create(0))) {
return 0;
}
/* Get the marker type. */
if (jpc_getuint16(in, &ms->id) || ms->id < JPC_MS_MIN ||
ms->id > JPC_MS_MAX) {
jpc_ms_destroy(ms);
return 0;
}
mstabent = jpc_mstab_lookup(ms->id);
ms->ops = &mstabent->ops;
/* Get the marker segment length and parameters if present. */
/* Note: It is tacitly assumed that a marker segment cannot have
parameters unless it has a length field. That is, there cannot
be a parameters field without a length field and vice versa. */
if (JPC_MS_HASPARMS(ms->id)) {
/* Get the length of the marker segment. */
if (jpc_getuint16(in, &ms->len) || ms->len < 3) {
jpc_ms_destroy(ms);
return 0;
}
/* Calculate the length of the marker segment parameters. */
ms->len -= 2;
/* Create and prepare a temporary memory stream from which to
read the marker segment parameters. */
/* Note: This approach provides a simple way of ensuring that
we never read beyond the end of the marker segment (even if
the marker segment length is errantly set too small). */
if (!(tmpstream = jas_stream_memopen(0, 0))) {
jpc_ms_destroy(ms);
return 0;
}
if (jas_stream_copy(tmpstream, in, ms->len) ||
jas_stream_seek(tmpstream, 0, SEEK_SET) < 0) {
jas_stream_close(tmpstream);
jpc_ms_destroy(ms);
return 0;
}
/* Get the marker segment parameters. */
if ((*ms->ops->getparms)(ms, cstate, tmpstream)) {
ms->ops = 0;
jpc_ms_destroy(ms);
jas_stream_close(tmpstream);
return 0;
}
/* if (jas_getdbglevel() > 0) {
jpc_ms_dump(ms, stderr);
} */
if (JAS_CAST(ulong, jas_stream_tell(tmpstream)) != ms->len) {
jas_eprintf(
"warning: trailing garbage in marker segment (%ld bytes)\n",
ms->len - jas_stream_tell(tmpstream));
}
/* Close the temporary stream. */
jas_stream_close(tmpstream);
} else {
/* There are no marker segment parameters. */
ms->len = 0;
/* if (jas_getdbglevel() > 0) {
jpc_ms_dump(ms, stderr);
} */
}
/* Update the code stream state information based on the type of
marker segment read. */
/* Note: This is a bit of a hack, but I'm not going to define another
type of virtual function for this one special case. */
if (ms->id == JPC_MS_SIZ) {
cstate->numcomps = ms->parms.siz.numcomps;
}
return ms;
}
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;
}
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 jpg_encode(jas_image_t *image, jas_stream_t *out, char *optstr)
{
JDIMENSION numscanlines;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
jas_image_coord_t width;
jas_image_coord_t height;
jpg_src_t src_mgr_buf;
jpg_src_t *src_mgr = &src_mgr_buf;
FILE *output_file;
int cmptno;
jpg_enc_t encbuf;
jpg_enc_t *enc = &encbuf;
jpg_encopts_t encopts;
output_file = 0;
if (jpg_parseencopts(optstr, &encopts))
goto error;
switch (jas_clrspc_fam(jas_image_clrspc(image))) {
case JAS_CLRSPC_FAM_RGB:
if (jas_image_clrspc(image) != JAS_CLRSPC_SRGB)
jas_eprintf("warning: inaccurate color\n");
enc->numcmpts = 3;
if ((enc->cmpts[0] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0 ||
(enc->cmpts[1] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0 ||
(enc->cmpts[2] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0) {
jas_eprintf("error: missing color component\n");
goto error;
}
break;
case JAS_CLRSPC_FAM_YCBCR:
if (jas_image_clrspc(image) != JAS_CLRSPC_SYCBCR)
jas_eprintf("warning: inaccurate color\n");
enc->numcmpts = 3;
if ((enc->cmpts[0] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y))) < 0 ||
(enc->cmpts[1] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB))) < 0 ||
(enc->cmpts[2] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR))) < 0) {
jas_eprintf("error: missing color component\n");
goto error;
}
break;
case JAS_CLRSPC_FAM_GRAY:
if (jas_image_clrspc(image) != JAS_CLRSPC_SGRAY)
jas_eprintf("warning: inaccurate color\n");
enc->numcmpts = 1;
if ((enc->cmpts[0] = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0) {
jas_eprintf("error: missing color component\n");
goto error;
}
break;
default:
jas_eprintf("error: JPG format does not support color space\n");
goto error;
break;
}
width = jas_image_width(image);
height = jas_image_height(image);
for (cmptno = 0; cmptno < enc->numcmpts; ++cmptno) {
if (jas_image_cmptwidth(image, enc->cmpts[cmptno]) != width ||
jas_image_cmptheight(image, enc->cmpts[cmptno]) != height ||
jas_image_cmpttlx(image, enc->cmpts[cmptno]) != 0 ||
jas_image_cmpttly(image, enc->cmpts[cmptno]) != 0 ||
jas_image_cmpthstep(image, enc->cmpts[cmptno]) != 1 ||
jas_image_cmptvstep(image, enc->cmpts[cmptno]) != 1 ||
jas_image_cmptprec(image, enc->cmpts[cmptno]) != 8 ||
jas_image_cmptsgnd(image, enc->cmpts[cmptno]) != jas_false) {
jas_eprintf("error: The JPG encoder cannot handle an image with this geometry.\n");
goto error;
}
}
if (!(output_file = tmpfile())) {
goto error;
}
/* Create a JPEG compression object. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
/* Specify data destination for compression */
jpeg_stdio_dest(&cinfo, output_file);
cinfo.in_color_space = tojpgcs(jas_image_clrspc(image));
cinfo.image_width = width;
cinfo.image_height = height;
cinfo.input_components = enc->numcmpts;
jpeg_set_defaults(&cinfo);
src_mgr->error = 0;
src_mgr->image = image;
src_mgr->data = jas_matrix_create(1, width);
src_mgr->buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo,
JPOOL_IMAGE, (JDIMENSION) width * cinfo.input_components,
(JDIMENSION) 1);
src_mgr->buffer_height = 1;
src_mgr->enc = enc;
/* Read the input file header to obtain file size & colorspace. */
jpg_start_input(&cinfo, src_mgr);
if (encopts.qual >= 0) {
jpeg_set_quality(&cinfo, encopts.qual, jas_true);
}
/* Now that we know input colorspace, fix colorspace-dependent defaults */
jpeg_default_colorspace(&cinfo);
/* Start compressor */
jpeg_start_compress(&cinfo, jas_true );
/* Process data */
while (cinfo.next_scanline < cinfo.image_height) {
if ((numscanlines = jpg_get_pixel_rows(&cinfo, src_mgr)) <= 0) {
break;
}
jpeg_write_scanlines(&cinfo, src_mgr->buffer, numscanlines);
}
/* Finish compression and release memory */
jpg_finish_input(&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
rewind(output_file);
jpg_copyfiletostream(out, output_file);
fclose(output_file);
output_file = 0;
return 0;
error:
if (output_file) {
fclose(output_file);
}
return -1;
}
static int jas_cmshapmatlut_invert(jas_cmshapmatlut_t *invlut,
jas_cmshapmatlut_t *lut, int n)
{
int i;
int j;
int k;
jas_cmreal_t ax;
jas_cmreal_t ay;
jas_cmreal_t bx;
jas_cmreal_t by;
jas_cmreal_t sx;
jas_cmreal_t sy;
assert(n >= 2);
if (invlut->data) {
jas_free(invlut->data);
invlut->data = 0;
}
/* The sample values should be nondecreasing. */
for (i = 1; i < lut->size; ++i) {
if (lut->data[i - 1] > lut->data[i]) {
assert(0);
return -1;
}
}
if (!(invlut->data = jas_malloc(n * sizeof(jas_cmreal_t))))
return -1;
invlut->size = n;
for (i = 0; i < invlut->size; ++i) {
sy = ((double) i) / (invlut->size - 1);
sx = 1.0;
for (j = 0; j < lut->size; ++j) {
ay = lut->data[j];
if (sy == ay) {
for (k = j + 1; k < lut->size; ++k) {
by = lut->data[k];
if (by != sy)
break;
#if 0
assert(0);
#endif
}
if (k < lut->size) {
--k;
ax = ((double) j) / (lut->size - 1);
bx = ((double) k) / (lut->size - 1);
sx = (ax + bx) / 2.0;
}
break;
}
if (j < lut->size - 1) {
by = lut->data[j + 1];
if (sy > ay && sy < by) {
ax = ((double) j) / (lut->size - 1);
bx = ((double) j + 1) / (lut->size - 1);
sx = ax +
(sy - ay) / (by - ay) * (bx - ax);
break;
}
}
}
invlut->data[i] = sx;
}
#if 0
for (i=0;i<lut->size;++i)
jas_eprintf("lut[%d]=%f ", i, lut->data[i]);
for (i=0;i<invlut->size;++i)
jas_eprintf("invlut[%d]=%f ", i, invlut->data[i]);
#endif
return 0;
}
int pgx_encode(jas_image_t *image, jas_stream_t *out, char *optstr)
{
pgx_hdr_t hdr;
uint_fast32_t width;
uint_fast32_t height;
jas_bool sgnd;
int prec;
pgx_enc_t encbuf;
pgx_enc_t *enc = &encbuf;
/* Avoid compiler warnings about unused parameters. */
optstr = 0;
switch (jas_clrspc_fam(jas_image_clrspc(image))) {
case JAS_CLRSPC_FAM_GRAY:
if ((enc->cmpt = jas_image_getcmptbytype(image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0) {
jas_eprintf("error: missing color component\n");
return -1;
}
break;
default:
jas_eprintf("error: BMP format does not support color space\n");
return -1;
break;
}
width = jas_image_cmptwidth(image, enc->cmpt);
height = jas_image_cmptheight(image, enc->cmpt);
prec = jas_image_cmptprec(image, enc->cmpt);
sgnd = jas_image_cmptsgnd(image, enc->cmpt);
/* The PGX format is quite limited in the set of image geometries
that it can handle. Here, we check to ensure that the image to
be saved can actually be represented reasonably accurately using the
PGX format. */
/* There must be exactly one component. */
if (jas_image_numcmpts(image) > 1 || prec > 16) {
jas_eprintf("The PNM format cannot be used to represent an image with this geometry.\n");
return -1;
}
hdr.magic = PGX_MAGIC;
hdr.bigendian = jas_true;
hdr.sgnd = sgnd;
hdr.prec = prec;
hdr.width = width;
hdr.height = height;
#ifdef PGX_DEBUG
pgx_dumphdr(&hdr);
#endif
if (pgx_puthdr(out, &hdr)) {
return -1;
}
if (pgx_putdata(out, &hdr, image, enc->cmpt)) {
return -1;
}
return 0;
}
static int jpc_dec_decodecblk(jpc_dec_t* dec, jpc_dec_tile_t* tile, jpc_dec_tcomp_t* tcomp, jpc_dec_band_t* band,
jpc_dec_cblk_t* cblk, int dopartial, int maxlyrs) {
jpc_dec_seg_t* seg;
int i;
int bpno;
int passtype;
int ret;
int compno;
int filldata;
int fillmask;
jpc_dec_ccp_t* ccp;
compno = tcomp - tile->tcomps;
if (!cblk->flags) {
/* Note: matrix is assumed to be zeroed */
if (!(cblk->flags = jas_matrix_create(jas_matrix_numrows(cblk->data) +
2, jas_matrix_numcols(cblk->data) + 2))) {
return -1;
}
}
seg = cblk->segs.head;
while (seg && (seg != cblk->curseg || dopartial) && (maxlyrs < 0 ||
seg->lyrno < maxlyrs)) {
assert(seg->numpasses >= seg->maxpasses || dopartial);
assert(seg->stream);
jas_stream_rewind(seg->stream);
jas_stream_setrwcount(seg->stream, 0);
if (seg->type == JPC_SEG_MQ) {
if (!cblk->mqdec) {
if (!(cblk->mqdec = jpc_mqdec_create(JPC_NUMCTXS, 0))) {
return -1;
}
jpc_mqdec_setctxs(cblk->mqdec, JPC_NUMCTXS, jpc_mqctxs);
}
jpc_mqdec_setinput(cblk->mqdec, seg->stream);
jpc_mqdec_init(cblk->mqdec);
} else {
assert(seg->type == JPC_SEG_RAW);
if (!cblk->nulldec) {
if (!(cblk->nulldec = jpc_bitstream_sopen(seg->stream, "r"))) {
assert(0);
}
}
}
for (i = 0; i < seg->numpasses; ++i) {
if (cblk->numimsbs > band->numbps) {
ccp = &tile->cp->ccps[compno];
if (ccp->roishift <= 0) {
jas_eprintf("warning: corrupt code stream\n");
} else {
if (cblk->numimsbs < ccp->roishift - band->numbps) {
jas_eprintf("warning: corrupt code stream\n");
}
}
}
bpno = band->roishift + band->numbps - 1 - (cblk->numimsbs +
(seg->passno + i - cblk->firstpassno + 2) / 3);
if (bpno < 0) {
goto premature_exit;
}
#if 1
passtype = (seg->passno + i + 2) % 3;
#else
passtype = JPC_PASSTYPE(seg->passno + i + 2);
#endif
assert(bpno >= 0 && bpno < 31);
switch (passtype) {
case JPC_SIGPASS:
ret = (seg->type == JPC_SEG_MQ) ? dec_sigpass(dec,
cblk->mqdec, bpno, band->orient,
(tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
cblk->flags, cblk->data) :
dec_rawsigpass(dec, cblk->nulldec, bpno,
(tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
cblk->flags, cblk->data);
break;
case JPC_REFPASS:
ret = (seg->type == JPC_SEG_MQ) ?
dec_refpass(dec, cblk->mqdec, bpno,
(tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
cblk->flags, cblk->data) :
dec_rawrefpass(dec, cblk->nulldec, bpno,
(tile->cp->ccps[compno].cblkctx & JPC_COX_VSC) != 0,
cblk->flags, cblk->data);
break;
case JPC_CLNPASS:
assert(seg->type == JPC_SEG_MQ);
ret = dec_clnpass(dec, cblk->mqdec, bpno,
band->orient, (tile->cp->ccps[compno].cblkctx &
JPC_COX_VSC) != 0, (tile->cp->ccps[compno].cblkctx &
JPC_COX_SEGSYM) != 0, cblk->flags,
cblk->data);
break;
default:
ret = -1;
break;
}
/* Do we need to reset after each coding pass? */
if (tile->cp->ccps[compno].cblkctx & JPC_COX_RESET) {
jpc_mqdec_setctxs(cblk->mqdec, JPC_NUMCTXS, jpc_mqctxs);
}
if (ret) {
jas_eprintf("coding pass failed passtype=%d segtype=%d\n", passtype, seg->type);
return -1;
}
}
if (seg->type == JPC_SEG_MQ) {
/* Note: dont destroy mq decoder because context info will be lost */
} else {
assert(seg->type == JPC_SEG_RAW);
if (tile->cp->ccps[compno].cblkctx & JPC_COX_PTERM) {
fillmask = 0x7f;
filldata = 0x2a;
} else {
fillmask = 0;
filldata = 0;
}
if ((ret = jpc_bitstream_inalign(cblk->nulldec, fillmask,
filldata)) < 0) {
return -1;
} else if (ret > 0) {
jas_eprintf("warning: bad termination pattern detected\n");
}
jpc_bitstream_close(cblk->nulldec);
cblk->nulldec = 0;
}
cblk->curseg = seg->next;
jpc_seglist_remove(&cblk->segs, seg);
jpc_seg_destroy(seg);
seg = cblk->curseg;
}
assert(dopartial ? (!cblk->curseg) : 1);
premature_exit:
return 0;
}
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 void special(int key, int x, int y)
{
if (cmdopts.verbose) {
jas_eprintf("special(%d, %d, %d)\n", key, x, y);
}
switch (key) {
case GLUT_KEY_UP:
{
float oldvcy;
float vh;
float pan;
if (gs.vp.height < jas_image_height(gs.image) / gs.sy) {
pan = (glutGetModifiers() & GLUT_ACTIVE_SHIFT) ?
BIGPAN : SMALLPAN;
oldvcy = gs.vcy;
vh = gs.sy * gs.vp.height;
gs.vcy = max(gs.vcy - pan * vh, jas_image_tly(gs.image) +
0.5 * vh);
if (gs.vcy != oldvcy) {
gs.dirty = 1;
glutPostRedisplay();
}
}
}
break;
case GLUT_KEY_DOWN:
{
float oldvcy;
float vh;
float pan;
if (gs.vp.height < jas_image_height(gs.image) / gs.sy) {
pan = (glutGetModifiers() & GLUT_ACTIVE_SHIFT) ?
BIGPAN : SMALLPAN;
oldvcy = gs.vcy;
vh = gs.sy * gs.vp.height;
gs.vcy = min(gs.vcy + pan * vh, jas_image_bry(gs.image) -
0.5 * vh);
if (gs.vcy != oldvcy) {
gs.dirty = 1;
glutPostRedisplay();
}
}
}
break;
case GLUT_KEY_LEFT:
{
float oldvcx;
float vw;
float pan;
if (gs.vp.width < jas_image_width(gs.image) / gs.sx) {
pan = (glutGetModifiers() & GLUT_ACTIVE_SHIFT) ?
BIGPAN : SMALLPAN;
oldvcx = gs.vcx;
vw = gs.sx * gs.vp.width;
gs.vcx = max(gs.vcx - pan * vw, jas_image_tlx(gs.image) +
0.5 * vw);
if (gs.vcx != oldvcx) {
gs.dirty = 1;
glutPostRedisplay();
}
}
}
break;
case GLUT_KEY_RIGHT:
{
float oldvcx;
float vw;
float pan;
if (gs.vp.width < jas_image_width(gs.image) / gs.sx) {
pan = (glutGetModifiers() & GLUT_ACTIVE_SHIFT) ?
BIGPAN : SMALLPAN;
oldvcx = gs.vcx;
vw = gs.sx * gs.vp.width;
gs.vcx = min(gs.vcx + pan * vw, jas_image_brx(gs.image) -
0.5 * vw);
if (gs.vcx != oldvcx) {
gs.dirty = 1;
glutPostRedisplay();
}
}
}
break;
default:
break;
}
}
int main(int argc, char **argv)
{
int c;
init();
/* Determine the base name of this command. */
if ((cmdname = strrchr(argv[0], '/'))) {
++cmdname;
} else {
cmdname = argv[0];
}
/* Initialize the JasPer library. */
if (jas_init()) {
errprint(0, "error: cannot initialize jasper library\n");
abort();
}
/* set our error callback */
jas_set_error_cb(errprint);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE);
glutCreateWindow(cmdname);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutSpecialFunc(special);
glutKeyboardFunc(keyboard);
cmdopts.numfiles = 0;
cmdopts.filenames = 0;
cmdopts.title = 0;
cmdopts.tmout = 0;
cmdopts.loop = 0;
cmdopts.verbose = 0;
while ((c = jas_getopt(argc, argv, opts)) != EOF) {
switch (c) {
case 'w':
cmdopts.tmout = atof(jas_optarg) * 1000;
break;
case 'l':
cmdopts.loop = 1;
break;
case 't':
cmdopts.title = jas_optarg;
break;
case 'v':
cmdopts.verbose = 1;
break;
case 'V':
jas_eprintf("%s\n", JAS_VERSION);
jas_eprintf("libjasper %s\n", jas_getversion());
cleanupandexit(EXIT_SUCCESS);
break;
default:
case 'h':
usage();
break;
}
}
if (jas_optind < argc) {
/* The images are to be read from one or more explicitly named
files. */
cmdopts.numfiles = argc - jas_optind;
cmdopts.filenames = &argv[jas_optind];
} else {
/* The images are to be read from standard input. */
static char *null = 0;
cmdopts.filenames = &null;
cmdopts.numfiles = 1;
}
streamin = jas_stream_fdopen(0, "rb");
/* Load the next image. */
nextimage();
/* Start the GLUT main event handler loop. */
glutMainLoop();
return EXIT_SUCCESS;
}
jas_image_t *pnm_decode(jas_stream_t *in, const char *optstr)
{
pnm_hdr_t hdr;
jas_image_t *image;
jas_image_cmptparm_t cmptparms[3];
jas_image_cmptparm_t *cmptparm;
int i;
pnm_dec_importopts_t opts;
size_t num_samples;
image = 0;
JAS_DBGLOG(10, ("pnm_decode(%p, \"%s\")\n", in, optstr ? optstr : ""));
if (pnm_dec_parseopts(optstr, &opts)) {
goto error;
}
/* Read the file header. */
if (pnm_gethdr(in, &hdr)) {
goto error;
}
JAS_DBGLOG(10, (
"magic %lx; width %lu; height %ld; numcmpts %d; maxval %ld; sgnd %d\n",
JAS_CAST(unsigned long, hdr.magic), JAS_CAST(long, hdr.width),
JAS_CAST(long, hdr.height), hdr.numcmpts, JAS_CAST(long, hdr.maxval),
hdr.sgnd)
);
if (!jas_safe_size_mul3(hdr.width, hdr.height, hdr.numcmpts,
&num_samples)) {
jas_eprintf("image too large\n");
goto error;
}
if (opts.max_samples > 0 && num_samples > opts.max_samples) {
jas_eprintf(
"maximum number of samples would be exceeded (%zu > %zu)\n",
num_samples, opts.max_samples);
goto error;
}
/* Create an image of the correct size. */
for (i = 0, cmptparm = cmptparms; i < hdr.numcmpts; ++i, ++cmptparm) {
cmptparm->tlx = 0;
cmptparm->tly = 0;
cmptparm->hstep = 1;
cmptparm->vstep = 1;
cmptparm->width = hdr.width;
cmptparm->height = hdr.height;
cmptparm->prec = pnm_maxvaltodepth(hdr.maxval);
cmptparm->sgnd = hdr.sgnd;
}
if (!(image = jas_image_create(hdr.numcmpts, cmptparms,
JAS_CLRSPC_UNKNOWN))) {
goto error;
}
if (hdr.numcmpts == 3) {
jas_image_setclrspc(image, JAS_CLRSPC_SRGB);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
jas_image_setcmpttype(image, 1,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
jas_image_setcmpttype(image, 2,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
} else {
jas_image_setclrspc(image, JAS_CLRSPC_SGRAY);
jas_image_setcmpttype(image, 0,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y));
}
/* Read image data from stream into image. */
if (pnm_getdata(in, &hdr, image, opts.allow_trunc)) {
goto error;
}
return image;
error:
if (image) {
jas_image_destroy(image);
}
return 0;
}
