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;
}
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;
}
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;
}
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)
{
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;
}
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 {
static void
writeJpc(jas_image_t * const jasperP,
struct cmdlineInfo const cmdline,
FILE * const ofP) {
jas_stream_t * outStreamP;
const char * options;
const char * ilyrratesOpt;
const char * prgValue;
char rateOpt[20+1];
/* Note: ilyrrates is a hack because we're too lazy to properly parse
command line options to get the information and then compose
a proper input to Jasper. So the user can screw things up by
specifying garbage for the -ilyrrates option
*/
if (strlen(cmdline.ilyrrates) > 0)
asprintfN(&ilyrratesOpt, "ilyrrates=%s", cmdline.ilyrrates);
else
ilyrratesOpt = strdup("");
switch(cmdline.progression) {
case PROG_LRCP: prgValue = "lrcp"; break;
case PROG_RLCP: prgValue = "rlcp"; break;
case PROG_RPCL: prgValue = "rcpc"; break;
case PROG_PCRL: prgValue = "pcrl"; break;
case PROG_CPRL: prgValue = "cprl"; break;
}
/* Note that asprintfN() doesn't understand %f, but sprintf() does */
sprintf(rateOpt, "%1.9f", 1.0/cmdline.compressionRatio);
asprintfN(&options,
"imgareatlx=%u "
"imgareatly=%u "
"tilegrdtlx=%u "
"tilegrdtly=%u "
"tilewidth=%u "
"tileheight=%u "
"prcwidth=%u "
"prcheight=%u "
"cblkwidth=%u "
"cblkheight=%u "
"mode=%s "
"rate=%s "
"%s "
"prg=%s "
"numrlvls=%u "
"numgbits=%u "
"%s %s %s %s %s %s %s %s %s",
cmdline.imgareatlx,
cmdline.imgareatly,
cmdline.tilegrdtlx,
cmdline.tilegrdtlx,
cmdline.tilewidth,
cmdline.tileheight,
cmdline.prcwidth,
cmdline.prcheight,
cmdline.cblkwidth,
cmdline.cblkheight,
cmdline.compmode == COMPMODE_INTEGER ? "int" : "real",
rateOpt,
ilyrratesOpt,
prgValue,
cmdline.numrlvls,
cmdline.numgbits,
cmdline.nomct ? "nomct" : "",
cmdline.sop ? "sop" : "",
cmdline.eph ? "eph" : "",
cmdline.lazy ? "lazy" : "",
cmdline.termall ? "termall" : "",
cmdline.segsym ? "segsym" : "",
cmdline.vcausal ? "vcausal" : "",
cmdline.pterm ? "pterm" : "",
cmdline.resetprob ? "resetprob" : ""
);
strfree(ilyrratesOpt);
/* Open the output image file (Standard Output) */
outStreamP = jas_stream_fdopen(fileno(ofP), "w+b");
if (outStreamP == NULL)
pm_error("Unable to open output stream. jas_stream_fdopen() "
"failed");
{
int rc;
if (cmdline.verbose)
pm_message("Using Jasper to encode to 'jpc' format with options "
"'%s'", options);
rc = jas_image_encode(jasperP, outStreamP,
jas_image_strtofmt((char*)"jpc"),
(char*)options);
if (rc != 0)
pm_error("jas_image_encode() failed to encode the JPEG 2000 "
"image. Rc=%d", rc);
}
jas_stream_flush(outStreamP);
{
int rc;
rc = jas_stream_close(outStreamP);
if (rc != 0)
pm_error("Failed to close output stream, "
"jas_stream_close() rc = %d", rc);
}
jas_image_clearfmts();
strfree(options);
}
