ref: 0d62e74e14ccf4e123d5c2d7af76cb02e695c0ee
author: Sigrid Solveig Haflínudóttir <ftrvxmtrx@gmail.com>
date: Mon Nov 23 13:00:52 EST 2020
first
--- /dev/null
+++ b/LICENSE
@@ -1,0 +1,51 @@
+JasPer License Version 2.0
+
+Copyright (c) 2001-2016 Michael David Adams
+Copyright (c) 1999-2000 Image Power, Inc.
+Copyright (c) 1999-2000 The University of British Columbia
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person (the
+"User") obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+1. The above copyright notices and this permission notice (which
+includes the disclaimer below) shall be included in all copies or
+substantial portions of the Software.
+
+2. The name of a copyright holder shall not be used to endorse or
+promote products derived from the Software without specific prior
+written permission.
+
+THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+"AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+
--- /dev/null
+++ b/README.md
@@ -1,0 +1,5 @@
+# jp2
+
+JPEG2000 decoder for Plan 9.
+
+It's a stripped down port of Jasper library.
--- /dev/null
+++ b/jas_cm.c
@@ -1,0 +1,1253 @@
+/*
+ * Copyright (c) 2002-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Color Management
+ *
+ * $Id$
+ */
+
+#include "jasper/jas_cm.h"
+#include "jasper/jas_icc.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_math.h"
+
+static jas_cmprof_t *jas_cmprof_create(void);
+static void jas_cmshapmatlut_cleanup(jas_cmshapmatlut_t *);
+static jas_cmreal_t jas_cmshapmatlut_lookup(const jas_cmshapmatlut_t *lut, jas_cmreal_t x);
+
+static void jas_cmpxform_destroy(jas_cmpxform_t *pxform);
+static jas_cmpxform_t *jas_cmpxform_copy(jas_cmpxform_t *pxform);
+
+static void jas_cmshapmat_destroy(jas_cmpxform_t *pxform);
+static int jas_cmshapmat_apply(const jas_cmpxform_t *pxform, const jas_cmreal_t *in,
+ jas_cmreal_t *out, unsigned cnt);
+
+static int jas_cmputint(long **bufptr, int sgnd, unsigned prec, long val);
+static int jas_cmgetint(const long **bufptr, int sgnd, unsigned prec, long *val);
+static int jas_cmpxformseq_append(jas_cmpxformseq_t *pxformseq,
+ jas_cmpxformseq_t *othpxformseq);
+static int jas_cmpxformseq_appendcnvt(jas_cmpxformseq_t *pxformseq,
+ unsigned, unsigned);
+static int jas_cmpxformseq_resize(jas_cmpxformseq_t *pxformseq, unsigned n);
+
+static int mono(const jas_iccprof_t *prof, int op, jas_cmpxformseq_t **pxformseq);
+static int triclr(const jas_iccprof_t *prof, int op, jas_cmpxformseq_t **retpxformseq);
+
+static void jas_cmpxformseq_destroy(jas_cmpxformseq_t *pxformseq);
+static int jas_cmpxformseq_delete(jas_cmpxformseq_t *pxformseq, unsigned i);
+static jas_cmpxformseq_t *jas_cmpxformseq_create(void);
+static jas_cmpxformseq_t *jas_cmpxformseq_copy(jas_cmpxformseq_t *pxformseq);
+static int jas_cmshapmat_invmat(jas_cmreal_t out[3][4], jas_cmreal_t in[3][4]);
+static int jas_cmpxformseq_insertpxform(jas_cmpxformseq_t *pxformseq,
+ int i, jas_cmpxform_t *pxform);
+
+#define SEQFWD(intent) (intent)
+#define SEQREV(intent) (4 + (intent))
+#define SEQSIM(intent) (8 + (intent))
+#define SEQGAM 12
+
+#define fwdpxformseq(prof, intent) \
+ (((prof)->pxformseqs[SEQFWD(intent)]) ? \
+ ((prof)->pxformseqs[SEQFWD(intent)]) : \
+ ((prof)->pxformseqs[SEQFWD(0)]))
+
+#define revpxformseq(prof, intent) \
+ (((prof)->pxformseqs[SEQREV(intent)]) ? \
+ ((prof)->pxformseqs[SEQREV(intent)]) : \
+ ((prof)->pxformseqs[SEQREV(0)]))
+
+#define simpxformseq(prof, intent) \
+ (((prof)->pxformseqs[SEQSIM(intent)]) ? \
+ ((prof)->pxformseqs[SEQSIM(intent)]) : \
+ ((prof)->pxformseqs[SEQSIM(0)]))
+
+#define gampxformseq(prof) ((prof)->pxformseqs[SEQGAM])
+
+static jas_clrspc_t icctoclrspc(jas_iccsig_t iccclrspc, int refflag);
+static jas_cmpxform_t *jas_cmpxform_create0(void);
+static jas_cmpxform_t *jas_cmpxform_createshapmat(void);
+static void jas_cmshapmatlut_init(jas_cmshapmatlut_t *lut);
+static int jas_cmshapmatlut_set(jas_cmshapmatlut_t *lut, const jas_icccurv_t *curv);
+
+static const jas_cmpxformops_t shapmat_ops = {jas_cmshapmat_destroy, jas_cmshapmat_apply, 0};+static jas_cmprof_t *jas_cmprof_createsycc(void);
+
+/******************************************************************************\
+* Color profile class.
+\******************************************************************************/
+
+jas_cmprof_t *jas_cmprof_createfromclrspc(jas_clrspc_t clrspc)
+{+ jas_iccprof_t *iccprof;
+ jas_cmprof_t *prof;
+
+ iccprof = 0;
+ switch (clrspc) {+ case JAS_CLRSPC_SYCBCR:
+ if (!(prof = jas_cmprof_createsycc()))
+ goto error;
+ break;
+ default:
+ if (!(iccprof = jas_iccprof_createfromclrspc(clrspc)))
+ goto error;
+ if (!(prof = jas_cmprof_createfromiccprof(iccprof)))
+ goto error;
+ jas_iccprof_destroy(iccprof);
+ if (!jas_clrspc_isgeneric(clrspc))
+ prof->clrspc = clrspc;
+ break;
+ }
+ return prof;
+error:
+ if (iccprof)
+ jas_iccprof_destroy(iccprof);
+ return 0;
+}
+
+static jas_cmprof_t *jas_cmprof_createsycc()
+{+ jas_cmprof_t *prof;
+ jas_cmpxform_t *fwdpxform = NULL;
+ jas_cmpxform_t *revpxform = NULL;
+ jas_cmshapmat_t *fwdshapmat;
+ jas_cmshapmat_t *revshapmat;
+
+ if (!(prof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB)))
+ goto error;
+ prof->clrspc = JAS_CLRSPC_SYCBCR;
+ assert(prof->numchans == 3 && prof->numrefchans == 3);
+ assert(prof->refclrspc == JAS_CLRSPC_CIEXYZ);
+ if (!(fwdpxform = jas_cmpxform_createshapmat()))
+ goto error;
+ fwdpxform->numinchans = 3;
+ fwdpxform->numoutchans = 3;
+ fwdshapmat = &fwdpxform->data.shapmat;
+ fwdshapmat->mono = 0;
+ fwdshapmat->order = 0;
+ fwdshapmat->useluts = 0;
+ fwdshapmat->usemat = 1;
+ fwdshapmat->mat[0][0] = 1.0;
+ fwdshapmat->mat[0][1] = 0.0;
+ fwdshapmat->mat[0][2] = 1.402;
+ fwdshapmat->mat[1][0] = 1.0;
+ fwdshapmat->mat[1][1] = -0.34413;
+ fwdshapmat->mat[1][2] = -0.71414;
+ fwdshapmat->mat[2][0] = 1.0;
+ fwdshapmat->mat[2][1] = 1.772;
+ fwdshapmat->mat[2][2] = 0.0;
+ fwdshapmat->mat[0][3] = -0.5 * (1.402);
+ fwdshapmat->mat[1][3] = -0.5 * (-0.34413 - 0.71414);
+ fwdshapmat->mat[2][3] = -0.5 * (1.772);
+ if (!(revpxform = jas_cmpxform_createshapmat()))
+ goto error;
+ revpxform->numinchans = 3;
+ revpxform->numoutchans = 3;
+ revshapmat = &revpxform->data.shapmat;
+ revshapmat->mono = 0;
+ revshapmat->order = 1;
+ revshapmat->useluts = 0;
+ revshapmat->usemat = 1;
+ jas_cmshapmat_invmat(revshapmat->mat, fwdshapmat->mat);
+
+ for (unsigned i = 0; i < JAS_CMXFORM_NUMINTENTS; ++i) {+ unsigned j = SEQFWD(i);
+ if (prof->pxformseqs[j]) {+ if (jas_cmpxformseq_insertpxform(prof->pxformseqs[j], 0,
+ fwdpxform))
+ goto error;
+ }
+ j = SEQREV(i);
+ if (prof->pxformseqs[j]) {+ if (jas_cmpxformseq_insertpxform(prof->pxformseqs[j],
+ -1, revpxform))
+ goto error;
+ }
+ }
+
+ jas_cmpxform_destroy(fwdpxform);
+ jas_cmpxform_destroy(revpxform);
+ return prof;
+error:
+ if (fwdpxform)
+ jas_cmpxform_destroy(fwdpxform);
+ if (revpxform)
+ jas_cmpxform_destroy(revpxform);
+ return 0;
+}
+
+jas_cmprof_t *jas_cmprof_createfromiccprof(const jas_iccprof_t *iccprof)
+{+ jas_cmprof_t *prof;
+ jas_icchdr_t icchdr;
+ jas_cmpxformseq_t *fwdpxformseq;
+ jas_cmpxformseq_t *revpxformseq;
+
+ fwdpxformseq = 0;
+ revpxformseq = 0;
+
+ if (!(prof = jas_cmprof_create()))
+ goto error;
+ jas_iccprof_gethdr(iccprof, &icchdr);
+ if (!(prof->iccprof = jas_iccprof_copy(iccprof)))
+ goto error;
+ prof->clrspc = icctoclrspc(icchdr.colorspc, 0);
+ prof->refclrspc = icctoclrspc(icchdr.refcolorspc, 1);
+ prof->numchans = jas_clrspc_numchans(prof->clrspc);
+ prof->numrefchans = jas_clrspc_numchans(prof->refclrspc);
+
+ if (prof->numchans == 1) {+ if (mono(prof->iccprof, 0, &fwdpxformseq))
+ goto error;
+ if (mono(prof->iccprof, 1, &revpxformseq))
+ goto error;
+ } else if (prof->numchans == 3) {+ if (triclr(prof->iccprof, 0, &fwdpxformseq))
+ goto error;
+ if (triclr(prof->iccprof, 1, &revpxformseq))
+ goto error;
+ }
+ prof->pxformseqs[SEQFWD(0)] = fwdpxformseq;
+ prof->pxformseqs[SEQREV(0)] = revpxformseq;
+
+#if 0
+ if (prof->numchans > 1) {+ lut(prof->iccprof, 0, PER, &pxformseq);
+ pxformseqs_set(prof, SEQFWD(PER), pxformseq);
+ lut(prof->iccprof, 1, PER, &pxformseq);
+ pxformseqs_set(prof, SEQREV(PER), pxformseq);
+ lut(prof->iccprof, 0, CLR, &pxformseq);
+ pxformseqs_set(prof, SEQREV(CLR), pxformseq);
+ lut(prof->iccprof, 1, CLR, &pxformseq);
+ pxformseqs_set(prof, SEQREV(CLR), pxformseq);
+ lut(prof->iccprof, 0, SAT, &pxformseq);
+ pxformseqs_set(prof, SEQREV(SAT), pxformseq);
+ lut(prof->iccprof, 1, SAT, &pxformseq);
+ pxformseqs_set(prof, SEQREV(SAT), pxformseq);
+ }
+#endif
+
+ return prof;
+
+error:
+ if (fwdpxformseq) {+ jas_cmpxformseq_destroy(fwdpxformseq);
+ }
+ if (revpxformseq) {+ jas_cmpxformseq_destroy(revpxformseq);
+ }
+ if (prof) {+ jas_cmprof_destroy(prof);
+ }
+
+ return 0;
+}
+
+static jas_cmprof_t *jas_cmprof_create()
+{+ jas_cmprof_t *prof;
+ if (!(prof = jas_malloc(sizeof(jas_cmprof_t))))
+ return 0;
+ memset(prof, 0, sizeof(jas_cmprof_t));
+ prof->iccprof = 0;
+ for (unsigned i = 0; i < JAS_CMPROF_NUMPXFORMSEQS; ++i)
+ prof->pxformseqs[i] = 0;
+ return prof;
+}
+
+void jas_cmprof_destroy(jas_cmprof_t *prof)
+{ + for (unsigned i = 0; i < JAS_CMPROF_NUMPXFORMSEQS; ++i) {+ if (prof->pxformseqs[i]) {+ jas_cmpxformseq_destroy(prof->pxformseqs[i]);
+ prof->pxformseqs[i] = 0;
+ }
+ }
+ if (prof->iccprof)
+ jas_iccprof_destroy(prof->iccprof);
+ jas_free(prof);
+}
+
+jas_cmprof_t *jas_cmprof_copy(const jas_cmprof_t *prof)
+{+ jas_cmprof_t *newprof;
+
+ if (!(newprof = jas_cmprof_create()))
+ goto error;
+ newprof->clrspc = prof->clrspc;
+ newprof->numchans = prof->numchans;
+ newprof->refclrspc = prof->refclrspc;
+ newprof->numrefchans = prof->numrefchans;
+ newprof->iccprof = jas_iccprof_copy(prof->iccprof);
+ for (unsigned i = 0; i < JAS_CMPROF_NUMPXFORMSEQS; ++i) {+ if (prof->pxformseqs[i]) {+ if (!(newprof->pxformseqs[i] = jas_cmpxformseq_copy(prof->pxformseqs[i])))
+ goto error;
+ }
+ }
+ return newprof;
+error:
+ if (newprof)
+ jas_cmprof_destroy(newprof);
+ return 0;
+}
+
+/******************************************************************************\
+* Transform class.
+\******************************************************************************/
+
+jas_cmxform_t *jas_cmxform_create(const jas_cmprof_t *inprof, const jas_cmprof_t *outprof,
+ const jas_cmprof_t *prfprof, jas_cmxform_op_t op, jas_cmxform_intent_t intent, jas_cmxform_optm_t optimize)
+{+ jas_cmxform_t *xform;
+ jas_cmpxformseq_t *inpxformseq;
+ jas_cmpxformseq_t *outpxformseq;
+ jas_cmpxformseq_t *altoutpxformseq;
+ jas_cmpxformseq_t *prfpxformseq;
+
+ /* Avoid compiler warnings about unused parameters. */
+ (void)optimize;
+
+ const jas_cmxform_intent_t prfintent = intent;
+
+ if (!(xform = jas_malloc(sizeof(jas_cmxform_t))))
+ goto error;
+ if (!(xform->pxformseq = jas_cmpxformseq_create()))
+ goto error;
+
+ switch (op) {+ case JAS_CMXFORM_OP_FWD:
+ inpxformseq = fwdpxformseq(inprof, intent);
+ outpxformseq = revpxformseq(outprof, intent);
+ if (!inpxformseq || !outpxformseq)
+ goto error;
+ if (jas_cmpxformseq_append(xform->pxformseq, inpxformseq) ||
+ jas_cmpxformseq_appendcnvt(xform->pxformseq,
+ inprof->refclrspc, outprof->refclrspc) ||
+ jas_cmpxformseq_append(xform->pxformseq, outpxformseq))
+ goto error;
+ xform->numinchans = jas_clrspc_numchans(inprof->clrspc);
+ xform->numoutchans = jas_clrspc_numchans(outprof->clrspc);
+ break;
+ case JAS_CMXFORM_OP_REV:
+ outpxformseq = fwdpxformseq(outprof, intent);
+ inpxformseq = revpxformseq(inprof, intent);
+ if (!outpxformseq || !inpxformseq)
+ goto error;
+ if (jas_cmpxformseq_append(xform->pxformseq, outpxformseq) ||
+ jas_cmpxformseq_appendcnvt(xform->pxformseq,
+ outprof->refclrspc, inprof->refclrspc) ||
+ jas_cmpxformseq_append(xform->pxformseq, inpxformseq))
+ goto error;
+ xform->numinchans = jas_clrspc_numchans(outprof->clrspc);
+ xform->numoutchans = jas_clrspc_numchans(inprof->clrspc);
+ break;
+ case JAS_CMXFORM_OP_PROOF:
+ assert(prfprof);
+ inpxformseq = fwdpxformseq(inprof, intent);
+ prfpxformseq = fwdpxformseq(prfprof, prfintent);
+ if (!inpxformseq || !prfpxformseq)
+ goto error;
+ outpxformseq = simpxformseq(outprof, intent);
+ altoutpxformseq = 0;
+ if (!outpxformseq) {+ outpxformseq = revpxformseq(outprof, intent);
+ altoutpxformseq = fwdpxformseq(outprof, intent);
+ if (!outpxformseq || !altoutpxformseq)
+ goto error;
+ }
+ if (jas_cmpxformseq_append(xform->pxformseq, inpxformseq) ||
+ jas_cmpxformseq_appendcnvt(xform->pxformseq,
+ inprof->refclrspc, outprof->refclrspc))
+ goto error;
+ if (altoutpxformseq) {+ if (jas_cmpxformseq_append(xform->pxformseq, outpxformseq) ||
+ jas_cmpxformseq_append(xform->pxformseq, altoutpxformseq))
+ goto error;
+ } else {+ if (jas_cmpxformseq_append(xform->pxformseq, outpxformseq))
+ goto error;
+ }
+ if (jas_cmpxformseq_appendcnvt(xform->pxformseq,
+ outprof->refclrspc, inprof->refclrspc) ||
+ jas_cmpxformseq_append(xform->pxformseq, prfpxformseq))
+ goto error;
+ xform->numinchans = jas_clrspc_numchans(inprof->clrspc);
+ xform->numoutchans = jas_clrspc_numchans(prfprof->clrspc);
+ break;
+ case JAS_CMXFORM_OP_GAMUT:
+ inpxformseq = fwdpxformseq(inprof, intent);
+ outpxformseq = gampxformseq(outprof);
+ if (!inpxformseq || !outpxformseq)
+ goto error;
+ if (jas_cmpxformseq_append(xform->pxformseq, inpxformseq) ||
+ jas_cmpxformseq_appendcnvt(xform->pxformseq,
+ inprof->refclrspc, outprof->refclrspc) ||
+ jas_cmpxformseq_append(xform->pxformseq, outpxformseq))
+ goto error;
+ xform->numinchans = jas_clrspc_numchans(inprof->clrspc);
+ xform->numoutchans = 1;
+ break;
+ }
+ return xform;
+error:
+ if (xform)
+ jas_cmxform_destroy(xform);
+ return 0;
+}
+
+#define APPLYBUFSIZ 2048
+int jas_cmxform_apply(const jas_cmxform_t *xform, const jas_cmpixmap_t *in, jas_cmpixmap_t *out)
+{+ jas_cmreal_t buf[2][APPLYBUFSIZ];
+ jas_cmreal_t *inbuf;
+ jas_cmreal_t *outbuf;
+ jas_cmreal_t scale;
+ long v;
+
+ if (xform->numinchans > in->numcmpts || xform->numoutchans > out->numcmpts)
+ goto error;
+
+ const jas_cmcmptfmt_t *fmt = &in->cmptfmts[0];
+ const unsigned width = fmt->width;
+ const unsigned height = fmt->height;
+ for (unsigned i = 1; i < xform->numinchans; ++i) {+ fmt = &in->cmptfmts[i];
+ if (fmt->width != width || fmt->height != height) {+ goto error;
+ }
+ }
+ for (unsigned i = 0; i < xform->numoutchans; ++i) {+ fmt = &out->cmptfmts[i];
+ if (fmt->width != width || fmt->height != height) {+ goto error;
+ }
+ }
+
+ unsigned maxchans = 0;
+ const jas_cmpxformseq_t *pxformseq = xform->pxformseq;
+ for (unsigned i = 0; i < pxformseq->numpxforms; ++i) {+ const jas_cmpxform_t *pxform = pxformseq->pxforms[i];
+ if (pxform->numinchans > maxchans) {+ maxchans = pxform->numinchans;
+ }
+ if (pxform->numoutchans > maxchans) {+ maxchans = pxform->numoutchans;
+ }
+ }
+
+ if (maxchans == 0)
+ /* avoid division by zero */
+ goto error;
+
+ const unsigned bufmax = APPLYBUFSIZ / maxchans;
+ assert(bufmax > 0);
+
+ const unsigned total = width * height;
+ unsigned n = 0;
+ while (n < total) {+
+ inbuf = &buf[0][0];
+ const unsigned m = JAS_MIN(total - n, bufmax);
+
+ for (unsigned i = 0; i < xform->numinchans; ++i) {+ fmt = &in->cmptfmts[i];
+ scale = (double)((1 << fmt->prec) - 1);
+ const unsigned bias = fmt->sgnd ? (1 << (fmt->prec - 1)) : 0;
+ const long *dataptr = &fmt->buf[n];
+ jas_cmreal_t *bufptr = &inbuf[i];
+ for (unsigned j = 0; j < m; ++j) {+ if (jas_cmgetint(&dataptr, fmt->sgnd, fmt->prec, &v))
+ goto error;
+ *bufptr = (jas_cmreal_t)(v - bias) / scale;
+ bufptr += xform->numinchans;
+ }
+ }
+
+ inbuf = &buf[0][0];
+ outbuf = inbuf;
+ for (unsigned i = 0; i < pxformseq->numpxforms; ++i) {+ const jas_cmpxform_t *pxform = pxformseq->pxforms[i];
+ if (pxform->numoutchans > pxform->numinchans) {+ outbuf = (inbuf == &buf[0][0]) ? &buf[1][0] : &buf[0][0];
+ } else {+ outbuf = inbuf;
+ }
+ if ((*pxform->ops->apply)(pxform, inbuf, outbuf, m))
+ goto error;
+ inbuf = outbuf;
+ }
+
+ for (unsigned i = 0; i < xform->numoutchans; ++i) {+ fmt = &out->cmptfmts[i];
+ scale = (double)((1 << fmt->prec) - 1);
+ const unsigned bias = fmt->sgnd ? (1 << (fmt->prec - 1)) : 0;
+ const jas_cmreal_t *bufptr = &outbuf[i];
+ long *dataptr = &fmt->buf[n];
+ for (unsigned j = 0; j < m; ++j) {+ v = (long)((*bufptr) * scale + bias);
+ bufptr += xform->numoutchans;
+ if (jas_cmputint(&dataptr, fmt->sgnd, fmt->prec, v))
+ goto error;
+ }
+ }
+
+ n += m;
+ }
+
+ return 0;
+error:
+ return -1;
+}
+
+void jas_cmxform_destroy(jas_cmxform_t *xform)
+{+ if (xform->pxformseq)
+ jas_cmpxformseq_destroy(xform->pxformseq);
+ jas_free(xform);
+}
+
+/******************************************************************************\
+* Primitive transform sequence class.
+\******************************************************************************/
+
+static jas_cmpxformseq_t *jas_cmpxformseq_create()
+{+ jas_cmpxformseq_t *pxformseq;
+ if (!(pxformseq = jas_malloc(sizeof(jas_cmpxformseq_t))))
+ goto error;
+ pxformseq->pxforms = 0;
+ pxformseq->numpxforms = 0;
+ pxformseq->maxpxforms = 0;
+ if (jas_cmpxformseq_resize(pxformseq, 16))
+ goto error;
+ return pxformseq;
+error:
+ if (pxformseq)
+ jas_cmpxformseq_destroy(pxformseq);
+ return 0;
+}
+
+static jas_cmpxformseq_t *jas_cmpxformseq_copy(jas_cmpxformseq_t *pxformseq)
+{+ jas_cmpxformseq_t *newpxformseq;
+
+ if (!(newpxformseq = jas_cmpxformseq_create()))
+ goto error;
+ if (jas_cmpxformseq_append(newpxformseq, pxformseq))
+ goto error;
+ return newpxformseq;
+error:
+ if (newpxformseq)
+ jas_cmpxformseq_destroy(newpxformseq);
+ return 0;
+}
+
+static void jas_cmpxformseq_destroy(jas_cmpxformseq_t *pxformseq)
+{+ while (pxformseq->numpxforms > 0)
+ jas_cmpxformseq_delete(pxformseq, pxformseq->numpxforms - 1);
+ if (pxformseq->pxforms)
+ jas_free(pxformseq->pxforms);
+ jas_free(pxformseq);
+}
+
+static int jas_cmpxformseq_delete(jas_cmpxformseq_t *pxformseq, unsigned i)
+{+ assert(i < pxformseq->numpxforms);
+ assert(i == pxformseq->numpxforms - 1);
+ jas_cmpxform_destroy(pxformseq->pxforms[i]);
+ pxformseq->pxforms[i] = 0;
+ --pxformseq->numpxforms;
+ return 0;
+}
+
+static int jas_cmpxformseq_appendcnvt(jas_cmpxformseq_t *pxformseq,
+ unsigned dstclrspc, unsigned srcclrspc)
+{+ if (dstclrspc == srcclrspc)
+ return 0;
+ abort();
+ /* Avoid compiler warnings about unused parameters. */
+ USED(pxformseq);
+ return -1;
+}
+
+static int jas_cmpxformseq_insertpxform(jas_cmpxformseq_t *pxformseq,
+ int _i, jas_cmpxform_t *pxform)
+{+ jas_cmpxform_t *tmppxform;
+ const unsigned i = _i >= 0 ? (unsigned)_i : pxformseq->numpxforms;
+ assert(i <= pxformseq->numpxforms);
+ if (pxformseq->numpxforms >= pxformseq->maxpxforms) {+ if (jas_cmpxformseq_resize(pxformseq, pxformseq->numpxforms +
+ 16))
+ goto error;
+ }
+ assert(pxformseq->numpxforms < pxformseq->maxpxforms);
+ if (!(tmppxform = jas_cmpxform_copy(pxform)))
+ goto error;
+ const unsigned n = pxformseq->numpxforms - i;
+ if (n > 0) {+ memmove(&pxformseq->pxforms[i + 1], &pxformseq->pxforms[i],
+ n * sizeof(jas_cmpxform_t *));
+ }
+ pxformseq->pxforms[i] = tmppxform;
+ ++pxformseq->numpxforms;
+ return 0;
+error:
+ return -1;
+}
+
+static int jas_cmpxformseq_append(jas_cmpxformseq_t *pxformseq,
+ jas_cmpxformseq_t *othpxformseq)
+{+ jas_cmpxform_t *pxform;
+ jas_cmpxform_t *othpxform;
+ const unsigned n = pxformseq->numpxforms + othpxformseq->numpxforms;
+ if (n > pxformseq->maxpxforms) {+ if (jas_cmpxformseq_resize(pxformseq, n))
+ goto error;
+ }
+ for (unsigned i = 0; i < othpxformseq->numpxforms; ++i) {+ othpxform = othpxformseq->pxforms[i];
+ if (!(pxform = jas_cmpxform_copy(othpxform)))
+ goto error;
+ pxformseq->pxforms[pxformseq->numpxforms] = pxform;
+ ++pxformseq->numpxforms;
+ }
+ return 0;
+error:
+ return -1;
+}
+
+static int jas_cmpxformseq_resize(jas_cmpxformseq_t *pxformseq, unsigned n)
+{+ jas_cmpxform_t **p;
+ assert(n >= pxformseq->numpxforms);
+ p = (!pxformseq->pxforms) ? jas_alloc2(n, sizeof(jas_cmpxform_t *)) :
+ jas_realloc2(pxformseq->pxforms, n, sizeof(jas_cmpxform_t *));
+ if (!p) {+ return -1;
+ }
+ pxformseq->pxforms = p;
+ pxformseq->maxpxforms = n;
+ return 0;
+}
+
+/******************************************************************************\
+* Primitive transform class.
+\******************************************************************************/
+
+static jas_cmpxform_t *jas_cmpxform_create0()
+{+ jas_cmpxform_t *pxform;
+ if (!(pxform = jas_malloc(sizeof(jas_cmpxform_t))))
+ return 0;
+ memset(pxform, 0, sizeof(jas_cmpxform_t));
+ pxform->refcnt = 0;
+ pxform->ops = 0;
+ return pxform;
+}
+
+static void jas_cmpxform_destroy(jas_cmpxform_t *pxform)
+{+ if (--pxform->refcnt <= 0) {+ (*pxform->ops->destroy)(pxform);
+ jas_free(pxform);
+ }
+}
+
+static jas_cmpxform_t *jas_cmpxform_copy(jas_cmpxform_t *pxform)
+{+ ++pxform->refcnt;
+ return pxform;
+}
+
+/******************************************************************************\
+* Shaper matrix class.
+\******************************************************************************/
+
+static jas_cmpxform_t *jas_cmpxform_createshapmat()
+{+ jas_cmpxform_t *pxform;
+ jas_cmshapmat_t *shapmat;
+ if (!(pxform = jas_cmpxform_create0()))
+ return 0;
+ pxform->ops = &shapmat_ops;
+ shapmat = &pxform->data.shapmat;
+ shapmat->mono = 0;
+ shapmat->order = 0;
+ shapmat->useluts = 0;
+ shapmat->usemat = 0;
+ for (unsigned i = 0; i < 3; ++i)
+ jas_cmshapmatlut_init(&shapmat->luts[i]);
+ for (unsigned i = 0; i < 3; ++i) {+ for (unsigned j = 0; j < 4; ++j)
+ shapmat->mat[i][j] = 0.0;
+ }
+ ++pxform->refcnt;
+ return pxform;
+}
+
+static void jas_cmshapmat_destroy(jas_cmpxform_t *pxform)
+{+ jas_cmshapmat_t *shapmat = &pxform->data.shapmat;
+ for (unsigned i = 0; i < 3; ++i)
+ jas_cmshapmatlut_cleanup(&shapmat->luts[i]);
+}
+
+static int jas_cmshapmat_apply(const jas_cmpxform_t *pxform, const jas_cmreal_t *in,
+ jas_cmreal_t *out, unsigned cnt)
+{+ const jas_cmshapmat_t *shapmat = &pxform->data.shapmat;
+ jas_cmreal_t *dst;
+ jas_cmreal_t a0;
+ jas_cmreal_t a1;
+ jas_cmreal_t a2;
+ jas_cmreal_t b0;
+ jas_cmreal_t b1;
+ jas_cmreal_t b2;
+ const jas_cmreal_t *src = in;
+ dst = out;
+ if (!shapmat->mono) {+ while (cnt-- > 0) {+ a0 = *src++;
+ a1 = *src++;
+ a2 = *src++;
+ if (!shapmat->order && shapmat->useluts) {+ a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
+ a1 = jas_cmshapmatlut_lookup(&shapmat->luts[1], a1);
+ a2 = jas_cmshapmatlut_lookup(&shapmat->luts[2], a2);
+ }
+ if (shapmat->usemat) {+ b0 = shapmat->mat[0][0] * a0
+ + shapmat->mat[0][1] * a1
+ + shapmat->mat[0][2] * a2
+ + shapmat->mat[0][3];
+ b1 = shapmat->mat[1][0] * a0
+ + shapmat->mat[1][1] * a1
+ + shapmat->mat[1][2] * a2
+ + shapmat->mat[1][3];
+ b2 = shapmat->mat[2][0] * a0
+ + shapmat->mat[2][1] * a1
+ + shapmat->mat[2][2] * a2
+ + shapmat->mat[2][3];
+ a0 = b0;
+ a1 = b1;
+ a2 = b2;
+ }
+ if (shapmat->order && shapmat->useluts) {+ a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
+ a1 = jas_cmshapmatlut_lookup(&shapmat->luts[1], a1);
+ a2 = jas_cmshapmatlut_lookup(&shapmat->luts[2], a2);
+ }
+ *dst++ = a0;
+ *dst++ = a1;
+ *dst++ = a2;
+ }
+ } else {+ if (!shapmat->order) {+ while (cnt-- > 0) {+ a0 = *src++;
+ if (shapmat->useluts)
+ a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
+ a2 = a0 * shapmat->mat[2][0];
+ a1 = a0 * shapmat->mat[1][0];
+ a0 = a0 * shapmat->mat[0][0];
+ *dst++ = a0;
+ *dst++ = a1;
+ *dst++ = a2;
+ }
+ } else {+assert(0);
+ while (cnt-- > 0) {+ a0 = *src++;
+ src++;
+ src++;
+ a0 = a0 * shapmat->mat[0][0];
+ if (shapmat->useluts)
+ a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
+ *dst++ = a0;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static void jas_cmshapmatlut_init(jas_cmshapmatlut_t *lut)
+{+ lut->data = 0;
+ lut->size = 0;
+}
+
+static void jas_cmshapmatlut_cleanup(jas_cmshapmatlut_t *lut)
+{+ if (lut->data) {+ jas_free(lut->data);
+ lut->data = 0;
+ }
+ lut->size = 0;
+}
+
+static double gammafn(double x, double gamma)
+{+ if (x == 0.0)
+ return 0.0;
+ return pow(x, gamma);
+}
+
+static int jas_cmshapmatlut_set(jas_cmshapmatlut_t *lut, const jas_icccurv_t *curv)
+{+ jas_cmreal_t gamma;
+ jas_cmshapmatlut_cleanup(lut);
+ if (curv->numents == 0) {+ lut->size = 2;
+ if (!(lut->data = jas_alloc2(lut->size, sizeof(jas_cmreal_t))))
+ goto error;
+ lut->data[0] = 0.0;
+ lut->data[1] = 1.0;
+ } else if (curv->numents == 1) {+ lut->size = 256;
+ if (!(lut->data = jas_alloc2(lut->size, sizeof(jas_cmreal_t))))
+ goto error;
+ gamma = (jas_cmreal_t)curv->ents[0] / 256.0;
+ for (unsigned i = 0; i < lut->size; ++i) {+ lut->data[i] = gammafn(i / (double) (lut->size - 1), gamma);
+ }
+ } else {+ lut->size = curv->numents;
+ if (!(lut->data = jas_alloc2(lut->size, sizeof(jas_cmreal_t))))
+ goto error;
+ for (unsigned i = 0; i < lut->size; ++i) {+ lut->data[i] = (jas_cmreal_t)curv->ents[i] / 65535.0;
+ }
+ }
+ return 0;
+error:
+ return -1;
+}
+
+static jas_cmreal_t jas_cmshapmatlut_lookup(const jas_cmshapmatlut_t *lut, jas_cmreal_t x)
+{+ jas_cmreal_t t;
+ t = x * (lut->size - 1);
+ const int lo = (int)floor(t);
+ if (lo < 0)
+ return lut->data[0];
+ const unsigned hi = (unsigned)ceil(t);
+ if (hi >= lut->size)
+ return lut->data[lut->size - 1];
+ return lut->data[lo] + (t - lo) * (lut->data[hi] - lut->data[lo]);
+}
+
+static int jas_cmshapmatlut_invert(jas_cmshapmatlut_t *invlut,
+ const jas_cmshapmatlut_t *lut, unsigned n)
+{+ 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 (unsigned i = 1; i < lut->size; ++i) {+ if (lut->data[i - 1] > lut->data[i]) {+ assert(0);
+ return -1;
+ }
+ }
+ if (!(invlut->data = jas_alloc2(n, sizeof(jas_cmreal_t))))
+ return -1;
+ invlut->size = n;
+ for (unsigned i = 0; i < invlut->size; ++i) {+ sy = ((double) i) / (invlut->size - 1);
+ sx = 1.0;
+ for (unsigned j = 0; j < lut->size; ++j) {+ ay = lut->data[j];
+ if (sy == ay) {+ unsigned k;
+ 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;
+}
+
+static int jas_cmshapmat_invmat(jas_cmreal_t out[3][4], jas_cmreal_t in[3][4])
+{+ jas_cmreal_t d;
+ d = in[0][0] * (in[1][1] * in[2][2] - in[1][2] * in[2][1])
+ - in[0][1] * (in[1][0] * in[2][2] - in[1][2] * in[2][0])
+ + in[0][2] * (in[1][0] * in[2][1] - in[1][1] * in[2][0]);
+#if 0
+jas_eprintf("delta=%f\n", d);+#endif
+ if (JAS_ABS(d) < 1e-6)
+ return -1;
+ out[0][0] = (in[1][1] * in[2][2] - in[1][2] * in[2][1]) / d;
+ out[1][0] = -(in[1][0] * in[2][2] - in[1][2] * in[2][0]) / d;
+ out[2][0] = (in[1][0] * in[2][1] - in[1][1] * in[2][0]) / d;
+ out[0][1] = -(in[0][1] * in[2][2] - in[0][2] * in[2][1]) / d;
+ out[1][1] = (in[0][0] * in[2][2] - in[0][2] * in[2][0]) / d;
+ out[2][1] = -(in[0][0] * in[2][1] - in[0][1] * in[2][0]) / d;
+ out[0][2] = (in[0][1] * in[1][2] - in[0][2] * in[1][1]) / d;
+ out[1][2] = -(in[0][0] * in[1][2] - in[1][0] * in[0][2]) / d;
+ out[2][2] = (in[0][0] * in[1][1] - in[0][1] * in[1][0]) / d;
+ out[0][3] = -in[0][3];
+ out[1][3] = -in[1][3];
+ out[2][3] = -in[2][3];
+#if 0
+jas_eprintf("[ %f %f %f %f ]\n[ %f %f %f %f ]\n[ %f %f %f %f ]\n",+in[0][0], in[0][1], in[0][2], in[0][3],
+in[1][0], in[1][1], in[1][2], in[1][3],
+in[2][0], in[2][1], in[2][2], in[2][3]);
+jas_eprintf("[ %f %f %f %f ]\n[ %f %f %f %f ]\n[ %f %f %f %f ]\n",+out[0][0], out[0][1], out[0][2], out[0][3],
+out[1][0], out[1][1], out[1][2], out[1][3],
+out[2][0], out[2][1], out[2][2], out[2][3]);
+#endif
+ return 0;
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static jas_clrspc_t icctoclrspc(jas_iccsig_t iccclrspc, int refflag)
+{+ if (refflag) {+ switch (iccclrspc) {+ case JAS_ICC_COLORSPC_XYZ:
+ return JAS_CLRSPC_CIEXYZ;
+ case JAS_ICC_COLORSPC_LAB:
+ return JAS_CLRSPC_CIELAB;
+ default:
+ abort();
+ }
+ } else {+ switch (iccclrspc) {+ case JAS_ICC_COLORSPC_YCBCR:
+ return JAS_CLRSPC_GENYCBCR;
+ case JAS_ICC_COLORSPC_RGB:
+ return JAS_CLRSPC_GENRGB;
+ case JAS_ICC_COLORSPC_GRAY:
+ return JAS_CLRSPC_GENGRAY;
+ default:
+ abort();
+ }
+ }
+ return -1;
+}
+
+static int mono(const jas_iccprof_t *iccprof, int op, jas_cmpxformseq_t **retpxformseq)
+{+ jas_iccattrval_t *graytrc;
+ jas_cmshapmat_t *shapmat;
+ jas_cmpxform_t *pxform = NULL;
+ jas_cmpxformseq_t *pxformseq = NULL;
+ jas_cmshapmatlut_t lut;
+
+ jas_cmshapmatlut_init(&lut);
+ if (!(graytrc = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_GRYTRC)) ||
+ graytrc->type != JAS_ICC_TYPE_CURV)
+ goto error;
+ if (!(pxform = jas_cmpxform_createshapmat()))
+ goto error;
+ shapmat = &pxform->data.shapmat;
+ if (!(pxformseq = jas_cmpxformseq_create()))
+ goto error;
+ if (jas_cmpxformseq_insertpxform(pxformseq, -1, pxform))
+ goto error;
+
+ pxform->numinchans = 1;
+ pxform->numoutchans = 3;
+
+ shapmat->mono = 1;
+ shapmat->useluts = 1;
+ shapmat->usemat = 1;
+ if (!op) {+ shapmat->order = 0;
+ shapmat->mat[0][0] = 0.9642;
+ shapmat->mat[1][0] = 1.0;
+ shapmat->mat[2][0] = 0.8249;
+ if (jas_cmshapmatlut_set(&shapmat->luts[0], &graytrc->data.curv))
+ goto error;
+ } else {+ shapmat->order = 1;
+ shapmat->mat[0][0] = 1.0 / 0.9642;
+ shapmat->mat[1][0] = 1.0;
+ shapmat->mat[2][0] = 1.0 / 0.8249;
+ jas_cmshapmatlut_init(&lut);
+ if (jas_cmshapmatlut_set(&lut, &graytrc->data.curv))
+ goto error;
+ if (jas_cmshapmatlut_invert(&shapmat->luts[0], &lut, lut.size))
+ goto error;
+ jas_cmshapmatlut_cleanup(&lut);
+ }
+ jas_iccattrval_destroy(graytrc);
+ jas_cmpxform_destroy(pxform);
+ *retpxformseq = pxformseq;
+ return 0;
+error:
+ if (graytrc)
+ jas_iccattrval_destroy(graytrc);
+ if (pxform)
+ jas_cmpxform_destroy(pxform);
+ if (pxformseq)
+ jas_cmpxformseq_destroy(pxformseq);
+ return -1;
+}
+
+static int triclr(const jas_iccprof_t *iccprof, int op, jas_cmpxformseq_t **retpxformseq)
+{+ jas_iccattrval_t *trcs[3];
+ jas_iccattrval_t *cols[3];
+ jas_cmshapmat_t *shapmat;
+ jas_cmpxform_t *pxform;
+ jas_cmpxformseq_t *pxformseq;
+ jas_cmreal_t mat[3][4];
+ jas_cmshapmatlut_t lut;
+
+ pxform = 0;
+ pxformseq = 0;
+ for (unsigned i = 0; i < 3; ++i) {+ trcs[i] = 0;
+ cols[i] = 0;
+ }
+ jas_cmshapmatlut_init(&lut);
+
+ if (!(trcs[0] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_REDTRC)) ||
+ !(trcs[1] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_GRNTRC)) ||
+ !(trcs[2] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_BLUTRC)) ||
+ !(cols[0] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_REDMATCOL)) ||
+ !(cols[1] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_GRNMATCOL)) ||
+ !(cols[2] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_BLUMATCOL)))
+ goto error;
+ for (unsigned i = 0; i < 3; ++i) {+ if (trcs[i]->type != JAS_ICC_TYPE_CURV ||
+ cols[i]->type != JAS_ICC_TYPE_XYZ)
+ goto error;
+ }
+ if (!(pxform = jas_cmpxform_createshapmat()))
+ goto error;
+ pxform->numinchans = 3;
+ pxform->numoutchans = 3;
+ shapmat = &pxform->data.shapmat;
+ if (!(pxformseq = jas_cmpxformseq_create()))
+ goto error;
+ if (jas_cmpxformseq_insertpxform(pxformseq, -1, pxform))
+ goto error;
+ shapmat->mono = 0;
+ shapmat->useluts = 1;
+ shapmat->usemat = 1;
+ if (!op) {+ shapmat->order = 0;
+ for (unsigned i = 0; i < 3; ++i) {+ shapmat->mat[0][i] = (jas_cmreal_t)cols[i]->data.xyz.x / 65536.0;
+ shapmat->mat[1][i] = (jas_cmreal_t)cols[i]->data.xyz.y / 65536.0;
+ shapmat->mat[2][i] = (jas_cmreal_t)cols[i]->data.xyz.z / 65536.0;
+ }
+ for (unsigned i = 0; i < 3; ++i)
+ shapmat->mat[i][3] = 0.0;
+ for (unsigned i = 0; i < 3; ++i) {+ if (jas_cmshapmatlut_set(&shapmat->luts[i], &trcs[i]->data.curv))
+ goto error;
+ }
+ } else {+ shapmat->order = 1;
+ for (unsigned i = 0; i < 3; ++i) {+ mat[0][i] = (jas_cmreal_t)cols[i]->data.xyz.x / 65536.0;
+ mat[1][i] = (jas_cmreal_t)cols[i]->data.xyz.y / 65536.0;
+ mat[2][i] = (jas_cmreal_t)cols[i]->data.xyz.z / 65536.0;
+ }
+ for (unsigned i = 0; i < 3; ++i)
+ mat[i][3] = 0.0;
+ if (jas_cmshapmat_invmat(shapmat->mat, mat))
+ goto error;
+ for (unsigned i = 0; i < 3; ++i) {+ jas_cmshapmatlut_init(&lut);
+ if (jas_cmshapmatlut_set(&lut, &trcs[i]->data.curv))
+ goto error;
+ if (jas_cmshapmatlut_invert(&shapmat->luts[i], &lut, lut.size))
+ goto error;
+ jas_cmshapmatlut_cleanup(&lut);
+ }
+ }
+ for (unsigned i = 0; i < 3; ++i) {+ jas_iccattrval_destroy(trcs[i]);
+ jas_iccattrval_destroy(cols[i]);
+ }
+ jas_cmpxform_destroy(pxform);
+ *retpxformseq = pxformseq;
+ return 0;
+
+error:
+
+ for (unsigned i = 0; i < 3; ++i) {+ if (trcs[i]) {+ jas_iccattrval_destroy(trcs[i]);
+ }
+ if (cols[i]) {+ jas_iccattrval_destroy(cols[i]);
+ }
+ }
+ if (pxformseq) {+ jas_cmpxformseq_destroy(pxformseq);
+ }
+ if (pxform) {+ jas_cmpxform_destroy(pxform);
+ }
+
+ return -1;
+}
+
+static int jas_cmgetint(const long **bufptr, int sgnd, unsigned prec, long *val)
+{+ long v;
+ int m;
+ v = **bufptr;
+ if (sgnd) {+ m = (1 << (prec - 1));
+ if (v < -m || v >= m)
+ return -1;
+ } else {+ if (v < 0 || v >= (1 << prec))
+ return -1;
+ }
+ ++(*bufptr);
+ *val = v;
+ return 0;
+}
+
+static int jas_cmputint(long **bufptr, int sgnd, unsigned prec, long val)
+{+ int m;
+ if (sgnd) {+ m = (1 << (prec - 1));
+ if (val < -m || val >= m)
+ return -1;
+ } else {+ if (val < 0 || val >= (1 << prec))
+ return -1;
+ }
+ **bufptr = val;
+ ++(*bufptr);
+ return 0;
+}
+
+unsigned jas_clrspc_numchans(jas_clrspc_t clrspc)
+{+ switch (jas_clrspc_fam(clrspc)) {+ case JAS_CLRSPC_FAM_XYZ:
+ case JAS_CLRSPC_FAM_LAB:
+ case JAS_CLRSPC_FAM_RGB:
+ case JAS_CLRSPC_FAM_YCBCR:
+ return 3;
+ case JAS_CLRSPC_FAM_GRAY:
+ return 1;
+ default:
+ abort();
+ }
+ return -1;
+}
+
+jas_iccprof_t *jas_iccprof_createfromcmprof(const jas_cmprof_t *prof)
+{+ return jas_iccprof_copy(prof->iccprof);
+}
--- /dev/null
+++ b/jas_debug.c
@@ -1,0 +1,152 @@
+/*
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_debug.h"
+#include "jasper/jas_types.h"
+
+/******************************************************************************\
+* Local data.
+\******************************************************************************/
+
+static int jas_dbglevel = 0;
+/* The debug level. */
+
+/******************************************************************************\
+* Code for getting/setting the debug level.
+\******************************************************************************/
+
+/* Set the library debug level. */
+int jas_setdbglevel(int dbglevel)
+{+ int olddbglevel;
+
+ /* Save the old debug level. */
+ olddbglevel = jas_dbglevel;
+
+ /* Change the debug level. */
+ jas_dbglevel = dbglevel;
+
+ /* Return the old debug level. */
+ return olddbglevel;
+}
+
+/* Get the library debug level. */
+int jas_getdbglevel()
+{+ return jas_dbglevel;
+}
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+/* Perform formatted output to standard error. */
+int jas_eprintf(const char *fmt, ...)
+{+ int ret;
+ va_list ap;
+
+ va_start(ap, fmt);
+ ret = vfprintf(stderr, fmt, ap);
+ va_end(ap);
+ return ret;
+}
+
+/* Dump memory to a stream. */
+int jas_memdump(FILE *out, const void *data, size_t len)
+{+ size_t i;
+ size_t j;
+ const jas_uchar *dp = data;
+ for (i = 0; i < len; i += 16) {+ fprintf(out, "%04zx:", i);
+ for (j = 0; j < 16; ++j) {+ if (i + j < len) {+ fprintf(out, " %02x", dp[i + j]);
+ }
+ }
+ fprintf(out, "\n");
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+void jas_deprecated(const char *s)
+{+ static const char message[] =
+ "WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!!\n"
+ "WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!!\n"
+ "WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!!\n"
+ "YOUR CODE IS RELYING ON DEPRECATED FUNCTIONALITY IN THE JASPER LIBRARY.\n"
+ "THIS FUNCTIONALITY WILL BE REMOVED IN THE NEAR FUTURE.\n"
+ "PLEASE FIX THIS PROBLEM BEFORE YOUR CODE STOPS WORKING!\n"
+ ;
+ jas_eprintf("%s", message);+ jas_eprintf("The specific problem is as follows:\n%s\n", s);+ //abort();
+}
--- /dev/null
+++ b/jas_icc.c
@@ -1,0 +1,1813 @@
+/*
+ * Copyright (c) 2002-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+#include "jasper/jas_icc.h"
+#include "jasper/jas_types.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_debug.h"
+#include "jasper/jas_cm.h"
+#include "jasper/jas_stream.h"
+#include "jasper/jas_string.h"
+
+#define jas_iccputuint8(out, val) jas_iccputuint(out, 1, val)
+#define jas_iccputuint16(out, val) jas_iccputuint(out, 2, val)
+#define jas_iccputsint32(out, val) jas_iccputsint(out, 4, val)
+#define jas_iccputuint32(out, val) jas_iccputuint(out, 4, val)
+#define jas_iccputuint64(out, val) jas_iccputuint(out, 8, val)
+
+static jas_iccattrval_t *jas_iccattrval_create0(void);
+
+static int jas_iccgetuint(jas_stream_t *in, unsigned n, jas_ulonglong *val);
+static int jas_iccgetuint8(jas_stream_t *in, jas_iccuint8_t *val);
+static int jas_iccgetuint16(jas_stream_t *in, jas_iccuint16_t *val);
+static int jas_iccgetsint32(jas_stream_t *in, jas_iccsint32_t *val);
+static int jas_iccgetuint32(jas_stream_t *in, jas_iccuint32_t *val);
+static int jas_iccgetuint64(jas_stream_t *in, jas_iccuint64_t *val);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_iccputuint(jas_stream_t *out, unsigned n, jas_ulonglong val);
+static int jas_iccputsint(jas_stream_t *out, unsigned n, jas_longlong val);
+//#endif /* JAS_ENABLE_ENCODER */
+static jas_iccprof_t *jas_iccprof_create(void);
+static int jas_iccprof_readhdr(jas_stream_t *in, jas_icchdr_t *hdr);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_iccprof_writehdr(jas_stream_t *out, const jas_icchdr_t *hdr);
+//#endif
+static int jas_iccprof_gettagtab(jas_stream_t *in, jas_icctagtab_t *tagtab);
+static void jas_iccprof_sorttagtab(jas_icctagtab_t *tagtab);
+static int jas_iccattrtab_lookup(const jas_iccattrtab_t *attrtab, jas_iccuint32_t name);
+static jas_iccattrtab_t *jas_iccattrtab_copy(const jas_iccattrtab_t *attrtab);
+static const jas_iccattrvalinfo_t *jas_iccattrvalinfo_lookup(jas_iccsig_t name);
+static int jas_iccgettime(jas_stream_t *in, jas_icctime_t *time);
+static int jas_iccgetxyz(jas_stream_t *in, jas_iccxyz_t *xyz);
+static int jas_icctagtabent_cmp(const void *src, const void *dst);
+
+static void jas_icccurv_destroy(jas_iccattrval_t *attrval);
+static int jas_icccurv_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval);
+static int jas_icccurv_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt);
+static unsigned jas_icccurv_getsize(const jas_iccattrval_t *attrval);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icccurv_output(jas_iccattrval_t *attrval, jas_stream_t *out);
+//#endif
+static void jas_icccurv_dump(const jas_iccattrval_t *attrval, FILE *out);
+
+static void jas_icctxtdesc_destroy(jas_iccattrval_t *attrval);
+static int jas_icctxtdesc_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval);
+static int jas_icctxtdesc_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt);
+static unsigned jas_icctxtdesc_getsize(const jas_iccattrval_t *attrval);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icctxtdesc_output(jas_iccattrval_t *attrval, jas_stream_t *out);
+//#endif
+static void jas_icctxtdesc_dump(const jas_iccattrval_t *attrval, FILE *out);
+
+static void jas_icctxt_destroy(jas_iccattrval_t *attrval);
+static int jas_icctxt_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval);
+static int jas_icctxt_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt);
+static unsigned jas_icctxt_getsize(const jas_iccattrval_t *attrval);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icctxt_output(jas_iccattrval_t *attrval, jas_stream_t *out);
+//#endif
+static void jas_icctxt_dump(const jas_iccattrval_t *attrval, FILE *out);
+
+static int jas_iccxyz_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt);
+static unsigned jas_iccxyz_getsize(const jas_iccattrval_t *attrval);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_iccxyz_output(jas_iccattrval_t *attrval, jas_stream_t *out);
+//#endif
+static void jas_iccxyz_dump(const jas_iccattrval_t *attrval, FILE *out);
+
+static jas_iccattrtab_t *jas_iccattrtab_create(void);
+static void jas_iccattrtab_destroy(jas_iccattrtab_t *tab);
+static int jas_iccattrtab_resize(jas_iccattrtab_t *tab, unsigned maxents);
+static int jas_iccattrtab_add(jas_iccattrtab_t *attrtab, int i,
+ jas_iccuint32_t name, jas_iccattrval_t *val);
+static int jas_iccattrtab_replace(jas_iccattrtab_t *attrtab, unsigned i,
+ jas_iccuint32_t name, jas_iccattrval_t *val);
+static void jas_iccattrtab_delete(jas_iccattrtab_t *attrtab, unsigned i);
+//#ifdef JAS_ENABLE_ENCODER
+static unsigned jas_iccpadtomult(unsigned x, unsigned y);
+static int jas_iccattrtab_get(jas_iccattrtab_t *attrtab, unsigned i,
+ jas_iccattrname_t *name, jas_iccattrval_t **val);
+static int jas_iccprof_puttagtab(jas_stream_t *out, const jas_icctagtab_t *tagtab);
+//#endif /* JAS_ENABLE_ENCODER */
+
+static void jas_icclut16_destroy(jas_iccattrval_t *attrval);
+static int jas_icclut16_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval);
+static int jas_icclut16_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt);
+static unsigned jas_icclut16_getsize(const jas_iccattrval_t *attrval);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icclut16_output(jas_iccattrval_t *attrval, jas_stream_t *out);
+//#endif
+static void jas_icclut16_dump(const jas_iccattrval_t *attrval, FILE *out);
+
+static void jas_icclut8_destroy(jas_iccattrval_t *attrval);
+static int jas_icclut8_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval);
+static int jas_icclut8_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt);
+static unsigned jas_icclut8_getsize(const jas_iccattrval_t *attrval);
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icclut8_output(jas_iccattrval_t *attrval, jas_stream_t *out);
+//#endif /* JAS_ENABLE_ENCODER */
+static void jas_icclut8_dump(const jas_iccattrval_t *attrval, FILE *out);
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_iccputtime(jas_stream_t *out, const jas_icctime_t *ctime);
+static int jas_iccputxyz(jas_stream_t *out, const jas_iccxyz_t *xyz);
+//#endif /* JAS_ENABLE_ENCODER */
+
+static unsigned jas_iccpowi(unsigned x, unsigned n);
+
+static char *jas_iccsigtostr(unsigned sig, char *buf);
+
+
+static const jas_iccattrvalinfo_t jas_iccattrvalinfos[] = {+ {+ JAS_ICC_TYPE_CURV, {+ jas_icccurv_destroy,
+ jas_icccurv_copy,
+ jas_icccurv_input,
+//#ifdef JAS_ENABLE_ENCODER
+ jas_icccurv_output,
+//#endif
+ jas_icccurv_getsize,
+ jas_icccurv_dump,
+ },
+ },
+ {+ JAS_ICC_TYPE_XYZ,
+ {+ 0,
+ 0,
+ jas_iccxyz_input,
+//#ifdef JAS_ENABLE_ENCODER
+ jas_iccxyz_output,
+//#endif
+ jas_iccxyz_getsize,
+ jas_iccxyz_dump,
+ },
+ },
+ {+ JAS_ICC_TYPE_TXTDESC,
+ {+ jas_icctxtdesc_destroy,
+ jas_icctxtdesc_copy,
+ jas_icctxtdesc_input,
+//#ifdef JAS_ENABLE_ENCODER
+ jas_icctxtdesc_output,
+//#endif
+ jas_icctxtdesc_getsize,
+ jas_icctxtdesc_dump,
+ },
+ },
+ {+ JAS_ICC_TYPE_TXT,
+ {+ jas_icctxt_destroy,
+ jas_icctxt_copy,
+ jas_icctxt_input,
+//#ifdef JAS_ENABLE_ENCODER
+ jas_icctxt_output,
+//#endif
+ jas_icctxt_getsize,
+ jas_icctxt_dump,
+ },
+ },
+ {+ JAS_ICC_TYPE_LUT8,
+ {+ jas_icclut8_destroy,
+ jas_icclut8_copy,
+ jas_icclut8_input,
+//#ifdef JAS_ENABLE_ENCODER
+ jas_icclut8_output,
+//#endif
+ jas_icclut8_getsize,
+ jas_icclut8_dump,
+ },
+ },
+ {+ JAS_ICC_TYPE_LUT16, {+ jas_icclut16_destroy,
+ jas_icclut16_copy,
+ jas_icclut16_input,
+//#ifdef JAS_ENABLE_ENCODER
+ jas_icclut16_output,
+//#endif
+ jas_icclut16_getsize,
+ jas_icclut16_dump,
+ },
+ },
+ {+ 0,
+ {+ 0,
+ 0,
+ 0,
+//#ifdef JAS_ENABLE_ENCODER
+ 0,
+//#endif
+ 0,
+ 0,
+ },
+ }
+};
+
+/******************************************************************************\
+* profile class
+\******************************************************************************/
+
+static jas_iccprof_t *jas_iccprof_create()
+{+ jas_iccprof_t *prof;
+ if (!(prof = jas_malloc(sizeof(jas_iccprof_t)))) {+ goto error;
+ }
+ if (!(prof->attrtab = jas_iccattrtab_create()))
+ goto error;
+ memset(&prof->hdr, 0, sizeof(jas_icchdr_t));
+ prof->tagtab.numents = 0;
+ prof->tagtab.ents = 0;
+ return prof;
+error:
+ if (prof)
+ jas_iccprof_destroy(prof);
+ return 0;
+}
+
+jas_iccprof_t *jas_iccprof_copy(const jas_iccprof_t *prof)
+{+ jas_iccprof_t *newprof;
+ if (!(newprof = jas_iccprof_create()))
+ goto error;
+ newprof->hdr = prof->hdr;
+ newprof->tagtab.numents = 0;
+ newprof->tagtab.ents = 0;
+ assert(newprof->attrtab);
+ jas_iccattrtab_destroy(newprof->attrtab);
+ if (!(newprof->attrtab = jas_iccattrtab_copy(prof->attrtab)))
+ goto error;
+ return newprof;
+error:
+ if (newprof)
+ jas_iccprof_destroy(newprof);
+ return 0;
+}
+
+void jas_iccprof_destroy(jas_iccprof_t *prof)
+{+ if (prof->attrtab)
+ jas_iccattrtab_destroy(prof->attrtab);
+ if (prof->tagtab.ents)
+ jas_free(prof->tagtab.ents);
+ jas_free(prof);
+}
+
+void jas_iccprof_dump(const jas_iccprof_t *prof, FILE *out)
+{+ jas_iccattrtab_dump(prof->attrtab, out);
+}
+
+jas_iccprof_t *jas_iccprof_load(jas_stream_t *in)
+{+ jas_iccprof_t *prof;
+ long curoff;
+ long reloff;
+ long prevoff;
+ jas_iccsig_t type;
+ jas_iccattrval_t *attrval;
+ jas_iccattrval_t *prevattrval;
+
+ attrval = 0;
+
+ if (!(prof = jas_iccprof_create())) {+ goto error;
+ }
+
+ if (jas_iccprof_readhdr(in, &prof->hdr)) {+ jas_eprintf("cannot get header\n");+ goto error;
+ }
+ if (jas_iccprof_gettagtab(in, &prof->tagtab)) {+ jas_eprintf("cannot get tab table\n");+ goto error;
+ }
+ jas_iccprof_sorttagtab(&prof->tagtab);
+
+ const unsigned numtags = prof->tagtab.numents;
+ curoff = JAS_ICC_HDRLEN + 4 + 12 * numtags;
+ prevoff = 0;
+ prevattrval = 0;
+ for (unsigned i = 0; i < numtags; ++i) {+ const jas_icctagtabent_t *tagtabent = &prof->tagtab.ents[i];
+ if (tagtabent->off == JAS_CAST(jas_iccuint32_t, prevoff)) {+ if (prevattrval) {+ if (!(attrval = jas_iccattrval_clone(prevattrval)))
+ goto error;
+ if (jas_iccprof_setattr(prof, tagtabent->tag, attrval))
+ goto error;
+ jas_iccattrval_destroy(attrval);
+ attrval = 0;
+ } else {+#if 0
+ jas_eprintf("warning: skipping unknown tag type\n");+#endif
+ }
+ continue;
+ }
+ reloff = tagtabent->off - curoff;
+ if (reloff > 0) {+ if (jas_stream_gobble(in, reloff) != reloff)
+ goto error;
+ curoff += reloff;
+ } else if (reloff < 0) {+ goto error;
+ }
+ prevoff = curoff;
+ if (jas_iccgetuint32(in, &type)) {+ goto error;
+ }
+ if (jas_stream_gobble(in, 4) != 4) {+ goto error;
+ }
+ curoff += 8;
+ if (!jas_iccattrvalinfo_lookup(type)) {+#if 0
+ jas_eprintf("warning: skipping unknown tag type\n");+#endif
+ prevattrval = 0;
+ continue;
+ }
+ if (!(attrval = jas_iccattrval_create(type))) {+ goto error;
+ }
+ const unsigned len = tagtabent->len - 8;
+ if ((*attrval->ops->input)(attrval, in, len)) {+ goto error;
+ }
+ curoff += len;
+ if (jas_iccprof_setattr(prof, tagtabent->tag, attrval)) {+ goto error;
+ }
+ prevattrval = attrval; /* This is correct, but slimey. */
+ jas_iccattrval_destroy(attrval);
+ attrval = 0;
+ }
+
+ return prof;
+
+error:
+ if (prof)
+ jas_iccprof_destroy(prof);
+ if (attrval)
+ jas_iccattrval_destroy(attrval);
+ return 0;
+}
+
+int jas_iccprof_save(jas_iccprof_t *prof, jas_stream_t *out)
+{+//#ifdef JAS_ENABLE_ENCODER
+ long curoff;
+ long reloff;
+ long newoff;
+ jas_icctagtabent_t *tagtabent;
+ jas_icctagtabent_t *sharedtagtabent;
+ jas_icctagtabent_t *tmptagtabent;
+ jas_iccuint32_t attrname;
+ jas_iccattrval_t *attrval;
+ jas_icctagtab_t *tagtab;
+
+ tagtab = &prof->tagtab;
+ if (!(tagtab->ents = jas_alloc2(prof->attrtab->numattrs,
+ sizeof(jas_icctagtabent_t))))
+ goto error;
+ tagtab->numents = prof->attrtab->numattrs;
+ curoff = JAS_ICC_HDRLEN + 4 + 12 * tagtab->numents;
+ for (unsigned i = 0; i < tagtab->numents; ++i) {+ tagtabent = &tagtab->ents[i];
+ if (jas_iccattrtab_get(prof->attrtab, i, &attrname, &attrval))
+ goto error;
+ assert(attrval->ops->output);
+ tagtabent->tag = attrname;
+ tagtabent->data = &attrval->data;
+ sharedtagtabent = 0;
+ for (unsigned j = 0; j < i; ++j) {+ tmptagtabent = &tagtab->ents[j];
+ if (tagtabent->data == tmptagtabent->data) {+ sharedtagtabent = tmptagtabent;
+ break;
+ }
+ }
+ if (sharedtagtabent) {+ tagtabent->off = sharedtagtabent->off;
+ tagtabent->len = sharedtagtabent->len;
+ tagtabent->first = sharedtagtabent;
+ } else {+ tagtabent->off = curoff;
+ tagtabent->len = (*attrval->ops->getsize)(attrval) + 8;
+ tagtabent->first = 0;
+ if (i < tagtab->numents - 1) {+ curoff = jas_iccpadtomult(curoff + tagtabent->len, 4);
+ } else {+ curoff += tagtabent->len;
+ }
+ }
+ jas_iccattrval_destroy(attrval);
+ }
+ prof->hdr.size = curoff;
+ if (jas_iccprof_writehdr(out, &prof->hdr))
+ goto error;
+ if (jas_iccprof_puttagtab(out, &prof->tagtab))
+ goto error;
+ curoff = JAS_ICC_HDRLEN + 4 + 12 * tagtab->numents;
+ for (unsigned i = 0; i < tagtab->numents;) {+ tagtabent = &tagtab->ents[i];
+ assert(curoff == JAS_CAST(long, tagtabent->off));
+ if (jas_iccattrtab_get(prof->attrtab, i, &attrname, &attrval))
+ goto error;
+ if (jas_iccputuint32(out, attrval->type) || jas_stream_pad(out,
+ 4, 0) != 4)
+ goto error;
+ if ((*attrval->ops->output)(attrval, out))
+ goto error;
+ jas_iccattrval_destroy(attrval);
+ curoff += tagtabent->len;
+ ++i;
+ while (i < tagtab->numents &&
+ tagtab->ents[i].first)
+ ++i;
+ newoff = (i < tagtab->numents) ?
+ tagtab->ents[i].off : prof->hdr.size;
+ reloff = newoff - curoff;
+ assert(reloff >= 0);
+ if (reloff > 0) {+ if (jas_stream_pad(out, reloff, 0) != reloff)
+ goto error;
+ curoff += reloff;
+ }
+ }
+ return 0;
+error:
+ /* XXX - need to free some resources here */
+//#else
+// (void)prof;
+// (void)out;
+//#endif /* JAS_ENABLE_ENCODER */
+ return -1;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+
+static int jas_iccprof_writehdr(jas_stream_t *out, const jas_icchdr_t *hdr)
+{+ if (jas_iccputuint32(out, hdr->size) ||
+ jas_iccputuint32(out, hdr->cmmtype) ||
+ jas_iccputuint32(out, hdr->version) ||
+ jas_iccputuint32(out, hdr->clas) ||
+ jas_iccputuint32(out, hdr->colorspc) ||
+ jas_iccputuint32(out, hdr->refcolorspc) ||
+ jas_iccputtime(out, &hdr->ctime) ||
+ jas_iccputuint32(out, hdr->magic) ||
+ jas_iccputuint32(out, hdr->platform) ||
+ jas_iccputuint32(out, hdr->flags) ||
+ jas_iccputuint32(out, hdr->maker) ||
+ jas_iccputuint32(out, hdr->model) ||
+ jas_iccputuint64(out, hdr->attr) ||
+ jas_iccputuint32(out, hdr->intent) ||
+ jas_iccputxyz(out, &hdr->illum) ||
+ jas_iccputuint32(out, hdr->creator) ||
+ jas_stream_pad(out, 44, 0) != 44)
+ return -1;
+ return 0;
+}
+
+static int jas_iccprof_puttagtab(jas_stream_t *out, const jas_icctagtab_t *tagtab)
+{+ jas_icctagtabent_t *tagtabent;
+ if (jas_iccputuint32(out, tagtab->numents))
+ goto error;
+ for (unsigned i = 0; i < tagtab->numents; ++i) {+ tagtabent = &tagtab->ents[i];
+ if (jas_iccputuint32(out, tagtabent->tag) ||
+ jas_iccputuint32(out, tagtabent->off) ||
+ jas_iccputuint32(out, tagtabent->len))
+ goto error;
+ }
+ return 0;
+error:
+ return -1;
+}
+
+//#endif
+
+static int jas_iccprof_readhdr(jas_stream_t *in, jas_icchdr_t *hdr)
+{+ if (jas_iccgetuint32(in, &hdr->size) ||
+ jas_iccgetuint32(in, &hdr->cmmtype) ||
+ jas_iccgetuint32(in, &hdr->version) ||
+ jas_iccgetuint32(in, &hdr->clas) ||
+ jas_iccgetuint32(in, &hdr->colorspc) ||
+ jas_iccgetuint32(in, &hdr->refcolorspc) ||
+ jas_iccgettime(in, &hdr->ctime) ||
+ jas_iccgetuint32(in, &hdr->magic) ||
+ jas_iccgetuint32(in, &hdr->platform) ||
+ jas_iccgetuint32(in, &hdr->flags) ||
+ jas_iccgetuint32(in, &hdr->maker) ||
+ jas_iccgetuint32(in, &hdr->model) ||
+ jas_iccgetuint64(in, &hdr->attr) ||
+ jas_iccgetuint32(in, &hdr->intent) ||
+ jas_iccgetxyz(in, &hdr->illum) ||
+ jas_iccgetuint32(in, &hdr->creator) ||
+ jas_stream_gobble(in, 44) != 44)
+ return -1;
+ return 0;
+}
+
+static int jas_iccprof_gettagtab(jas_stream_t *in, jas_icctagtab_t *tagtab)
+{+ jas_icctagtabent_t *tagtabent;
+
+ if (tagtab->ents) {+ jas_free(tagtab->ents);
+ tagtab->ents = 0;
+ }
+ if (jas_iccgetuint32(in, &tagtab->numents))
+ goto error;
+ if (!(tagtab->ents = jas_alloc2(tagtab->numents,
+ sizeof(jas_icctagtabent_t))))
+ goto error;
+ tagtabent = tagtab->ents;
+ for (unsigned i = 0; i < tagtab->numents; ++i) {+ if (jas_iccgetuint32(in, &tagtabent->tag) ||
+ jas_iccgetuint32(in, &tagtabent->off) ||
+ jas_iccgetuint32(in, &tagtabent->len))
+ goto error;
+ ++tagtabent;
+ }
+ return 0;
+error:
+ if (tagtab->ents) {+ jas_free(tagtab->ents);
+ tagtab->ents = 0;
+ }
+ return -1;
+}
+
+jas_iccattrval_t *jas_iccprof_getattr(const jas_iccprof_t *prof,
+ jas_iccattrname_t name)
+{+ int i;
+ jas_iccattrval_t *attrval;
+ if ((i = jas_iccattrtab_lookup(prof->attrtab, name)) < 0)
+ goto error;
+ if (!(attrval = jas_iccattrval_clone(prof->attrtab->attrs[i].val)))
+ goto error;
+ return attrval;
+error:
+ return 0;
+}
+
+int jas_iccprof_setattr(jas_iccprof_t *prof, jas_iccattrname_t name,
+ jas_iccattrval_t *val)
+{+ int i;
+ if ((i = jas_iccattrtab_lookup(prof->attrtab, name)) >= 0) {+ if (val) {+ if (jas_iccattrtab_replace(prof->attrtab, i, name, val))
+ goto error;
+ } else {+ jas_iccattrtab_delete(prof->attrtab, i);
+ }
+ } else {+ if (val) {+ if (jas_iccattrtab_add(prof->attrtab, -1, name, val))
+ goto error;
+ } else {+ /* NOP */
+ }
+ }
+ return 0;
+error:
+ return -1;
+}
+
+int jas_iccprof_gethdr(const jas_iccprof_t *prof, jas_icchdr_t *hdr)
+{+ *hdr = prof->hdr;
+ return 0;
+}
+
+int jas_iccprof_sethdr(jas_iccprof_t *prof, const jas_icchdr_t *hdr)
+{+ prof->hdr = *hdr;
+ return 0;
+}
+
+static void jas_iccprof_sorttagtab(jas_icctagtab_t *tagtab)
+{+ qsort(tagtab->ents, tagtab->numents, sizeof(jas_icctagtabent_t),
+ jas_icctagtabent_cmp);
+}
+
+static int jas_icctagtabent_cmp(const void *src, const void *dst)
+{+ const jas_icctagtabent_t *srctagtabent = JAS_CAST(const jas_icctagtabent_t *, src);
+ const jas_icctagtabent_t *dsttagtabent = JAS_CAST(const jas_icctagtabent_t *, dst);
+ if (srctagtabent->off > dsttagtabent->off) {+ return 1;
+ } else if (srctagtabent->off < dsttagtabent->off) {+ return -1;
+ }
+ return 0;
+}
+
+static const jas_iccattrvalinfo_t *jas_iccattrvalinfo_lookup(jas_iccsig_t type)
+{+ const jas_iccattrvalinfo_t *info;
+ for (info = jas_iccattrvalinfos; info->type; ++info) {+ if (info->type == type) {+ return info;
+ }
+ }
+ return 0;
+}
+
+static int jas_iccgettime(jas_stream_t *in, jas_icctime_t *time)
+{+ if (jas_iccgetuint16(in, &time->year) ||
+ jas_iccgetuint16(in, &time->month) ||
+ jas_iccgetuint16(in, &time->day) ||
+ jas_iccgetuint16(in, &time->hour) ||
+ jas_iccgetuint16(in, &time->min) ||
+ jas_iccgetuint16(in, &time->sec)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jas_iccgetxyz(jas_stream_t *in, jas_iccxyz_t *xyz)
+{+ if (jas_iccgetsint32(in, &xyz->x) ||
+ jas_iccgetsint32(in, &xyz->y) ||
+ jas_iccgetsint32(in, &xyz->z)) {+ return -1;
+ }
+ return 0;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+
+static int jas_iccputtime(jas_stream_t *out, const jas_icctime_t *time)
+{+ jas_iccputuint16(out, time->year);
+ jas_iccputuint16(out, time->month);
+ jas_iccputuint16(out, time->day);
+ jas_iccputuint16(out, time->hour);
+ jas_iccputuint16(out, time->min);
+ jas_iccputuint16(out, time->sec);
+ return 0;
+}
+
+static int jas_iccputxyz(jas_stream_t *out, const jas_iccxyz_t *xyz)
+{+ jas_iccputuint32(out, xyz->x);
+ jas_iccputuint32(out, xyz->y);
+ jas_iccputuint32(out, xyz->z);
+ return 0;
+}
+
+//#endif /* JAS_ENABLE_ENCODER */
+
+/******************************************************************************\
+* attribute table class
+\******************************************************************************/
+
+static jas_iccattrtab_t *jas_iccattrtab_create()
+{+ jas_iccattrtab_t *tab;
+ if (!(tab = jas_malloc(sizeof(jas_iccattrtab_t))))
+ goto error;
+ tab->maxattrs = 0;
+ tab->numattrs = 0;
+ tab->attrs = 0;
+ if (jas_iccattrtab_resize(tab, 32))
+ goto error;
+ return tab;
+error:
+ if (tab)
+ jas_iccattrtab_destroy(tab);
+ return 0;
+}
+
+static jas_iccattrtab_t *jas_iccattrtab_copy(const jas_iccattrtab_t *attrtab)
+{+ jas_iccattrtab_t *newattrtab;
+ if (!(newattrtab = jas_iccattrtab_create()))
+ return NULL;
+ for (unsigned i = 0; i < attrtab->numattrs; ++i) {+ if (jas_iccattrtab_add(newattrtab, i, attrtab->attrs[i].name,
+ attrtab->attrs[i].val))
+ goto error;
+ }
+ return newattrtab;
+ error:
+ jas_iccattrtab_destroy(newattrtab);
+ return 0;
+}
+
+static void jas_iccattrtab_destroy(jas_iccattrtab_t *tab)
+{+ if (tab->attrs) {+ while (tab->numattrs > 0) {+ jas_iccattrtab_delete(tab, 0);
+ }
+ jas_free(tab->attrs);
+ }
+ jas_free(tab);
+}
+
+void jas_iccattrtab_dump(const jas_iccattrtab_t *attrtab, FILE *out)
+{+ char buf[16];
+ fprintf(out, "numattrs=%d\n", attrtab->numattrs);
+ fprintf(out, "---\n");
+ for (unsigned i = 0; i < attrtab->numattrs; ++i) {+ const jas_iccattr_t *attr = &attrtab->attrs[i];
+ const jas_iccattrval_t *attrval = attr->val;
+ const jas_iccattrvalinfo_t *info = jas_iccattrvalinfo_lookup(attrval->type);
+ assert(info);
+ (void)info;
+ fprintf(out, "attrno=%d; attrname=\"%s\"(0x%08"PRIxFAST32"); attrtype=\"%s\"(0x%08"PRIxFAST32")\n",
+ i,
+ jas_iccsigtostr(attr->name, &buf[0]),
+ attr->name,
+ jas_iccsigtostr(attrval->type, &buf[8]),
+ attrval->type
+ );
+ jas_iccattrval_dump(attrval, out);
+ fprintf(out, "---\n");
+ }
+}
+
+static int jas_iccattrtab_resize(jas_iccattrtab_t *tab, unsigned maxents)
+{+ jas_iccattr_t *newattrs;
+ assert(maxents >= tab->numattrs);
+ newattrs = tab->attrs ? jas_realloc2(tab->attrs, maxents,
+ sizeof(jas_iccattr_t)) : jas_alloc2(maxents, sizeof(jas_iccattr_t));
+ if (!newattrs) {+ return -1;
+ }
+ tab->attrs = newattrs;
+ tab->maxattrs = maxents;
+ return 0;
+}
+
+static int jas_iccattrtab_add(jas_iccattrtab_t *attrtab, int i,
+ jas_iccuint32_t name, jas_iccattrval_t *val)
+{+ jas_iccattr_t *attr;
+ jas_iccattrval_t *tmpattrval;
+ if (i < 0) {+ i = attrtab->numattrs;
+ }
+ assert(i >= 0 && (unsigned)i <= attrtab->numattrs);
+ if (attrtab->numattrs >= attrtab->maxattrs) {+ if (jas_iccattrtab_resize(attrtab, attrtab->numattrs + 32)) {+ return -1;
+ }
+ }
+ if (!(tmpattrval = jas_iccattrval_clone(val)))
+ return -1;
+ const unsigned n = attrtab->numattrs - i;
+ if (n > 0)
+ memmove(&attrtab->attrs[i + 1], &attrtab->attrs[i],
+ n * sizeof(jas_iccattr_t));
+ attr = &attrtab->attrs[i];
+ attr->name = name;
+ attr->val = tmpattrval;
+ ++attrtab->numattrs;
+ return 0;
+}
+
+static int jas_iccattrtab_replace(jas_iccattrtab_t *attrtab, unsigned i,
+ jas_iccuint32_t name, jas_iccattrval_t *val)
+{+ jas_iccattrval_t *newval;
+ jas_iccattr_t *attr;
+ if (!(newval = jas_iccattrval_clone(val)))
+ goto error;
+ attr = &attrtab->attrs[i];
+ jas_iccattrval_destroy(attr->val);
+ attr->name = name;
+ attr->val = newval;
+ return 0;
+error:
+ return -1;
+}
+
+static void jas_iccattrtab_delete(jas_iccattrtab_t *attrtab, unsigned i)
+{+ unsigned n;
+ jas_iccattrval_destroy(attrtab->attrs[i].val);
+ if ((n = attrtab->numattrs - i - 1) > 0)
+ memmove(&attrtab->attrs[i], &attrtab->attrs[i + 1],
+ n * sizeof(jas_iccattr_t));
+ --attrtab->numattrs;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_iccattrtab_get(jas_iccattrtab_t *attrtab, unsigned i,
+ jas_iccattrname_t *name, jas_iccattrval_t **val)
+{+ jas_iccattr_t *attr;
+ if (i >= attrtab->numattrs)
+ goto error;
+ attr = &attrtab->attrs[i];
+ *name = attr->name;
+ if (!(*val = jas_iccattrval_clone(attr->val)))
+ goto error;
+ return 0;
+error:
+ return -1;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static int jas_iccattrtab_lookup(const jas_iccattrtab_t *attrtab,
+ jas_iccuint32_t name)
+{+ jas_iccattr_t *attr;
+ for (unsigned i = 0; i < attrtab->numattrs; ++i) {+ attr = &attrtab->attrs[i];
+ if (attr->name == name)
+ return i;
+ }
+ return -1;
+}
+
+/******************************************************************************\
+* attribute value class
+\******************************************************************************/
+
+jas_iccattrval_t *jas_iccattrval_create(jas_iccuint32_t type)
+{+ jas_iccattrval_t *attrval;
+ const jas_iccattrvalinfo_t *info;
+
+ if (!(info = jas_iccattrvalinfo_lookup(type)))
+ goto error;
+ if (!(attrval = jas_iccattrval_create0()))
+ goto error;
+ attrval->ops = &info->ops;
+ attrval->type = type;
+ ++attrval->refcnt;
+ memset(&attrval->data, 0, sizeof(attrval->data));
+ return attrval;
+error:
+ return 0;
+}
+
+jas_iccattrval_t *jas_iccattrval_clone(jas_iccattrval_t *attrval)
+{+ ++attrval->refcnt;
+ return attrval;
+}
+
+void jas_iccattrval_destroy(jas_iccattrval_t *attrval)
+{+#if 0
+jas_eprintf("refcnt=%d\n", attrval->refcnt);+#endif
+ if (--attrval->refcnt <= 0) {+ if (attrval->ops->destroy)
+ (*attrval->ops->destroy)(attrval);
+ jas_free(attrval);
+ }
+}
+
+void jas_iccattrval_dump(const jas_iccattrval_t *attrval, FILE *out)
+{+ char buf[8];
+ jas_iccsigtostr(attrval->type, buf);
+ fprintf(out, "refcnt = %d; type = 0x%08"PRIxFAST32" %s\n", attrval->refcnt,
+ attrval->type, jas_iccsigtostr(attrval->type, &buf[0]));
+ if (attrval->ops->dump) {+ (*attrval->ops->dump)(attrval, out);
+ }
+}
+
+int jas_iccattrval_allowmodify(jas_iccattrval_t **attrvalx)
+{+ jas_iccattrval_t *newattrval;
+ jas_iccattrval_t *attrval = *attrvalx;
+ if (attrval->refcnt > 1) {+ if (!(newattrval = jas_iccattrval_create0()))
+ goto error;
+ newattrval->ops = attrval->ops;
+ newattrval->type = attrval->type;
+ ++newattrval->refcnt;
+ if (newattrval->ops->copy) {+ if ((*newattrval->ops->copy)(newattrval, attrval))
+ goto error;
+ } else {+ memcpy(&newattrval->data, &attrval->data,
+ sizeof(newattrval->data));
+ }
+ *attrvalx = newattrval;
+ }
+ return 0;
+error:
+ if (newattrval) {+ jas_free(newattrval);
+ }
+ return -1;
+}
+
+static jas_iccattrval_t *jas_iccattrval_create0()
+{+ jas_iccattrval_t *attrval;
+ if (!(attrval = jas_malloc(sizeof(jas_iccattrval_t))))
+ return 0;
+ memset(attrval, 0, sizeof(jas_iccattrval_t));
+ attrval->refcnt = 0;
+ attrval->ops = 0;
+ attrval->type = 0;
+ return attrval;
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static int jas_iccxyz_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned len)
+{+ assert(len == 4 * 3);
+ (void)len;
+ return jas_iccgetxyz(in, &attrval->data.xyz);
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_iccxyz_output(jas_iccattrval_t *attrval, jas_stream_t *out)
+{+ const jas_iccxyz_t *xyz = &attrval->data.xyz;
+ if (jas_iccputuint32(out, xyz->x) ||
+ jas_iccputuint32(out, xyz->y) ||
+ jas_iccputuint32(out, xyz->z))
+ return -1;
+ return 0;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static unsigned jas_iccxyz_getsize(const jas_iccattrval_t *attrval)
+{+ /* Avoid compiler warnings about unused parameters. */
+ USED(attrval);
+
+ return 12;
+}
+
+static void jas_iccxyz_dump(const jas_iccattrval_t *attrval, FILE *out)
+{+ const jas_iccxyz_t *xyz = &attrval->data.xyz;
+ fprintf(out, "(%f, %f, %f)\n", xyz->x / 65536.0, xyz->y / 65536.0, xyz->z / 65536.0);
+}
+
+/******************************************************************************\
+* attribute table class
+\******************************************************************************/
+
+static void jas_icccurv_destroy(jas_iccattrval_t *attrval)
+{+ jas_icccurv_t *curv = &attrval->data.curv;
+ if (curv->ents) {+ jas_free(curv->ents);
+ curv->ents = 0;
+ }
+}
+
+static int jas_icccurv_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval)
+{+ /* Avoid compiler warnings about unused parameters. */
+ USED(attrval);
+ USED(othattrval);
+
+ /* Not yet implemented. */
+ abort();
+ return -1;
+}
+
+static int jas_icccurv_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt)
+{+ jas_icccurv_t *curv = &attrval->data.curv;
+
+ curv->numents = 0;
+ curv->ents = 0;
+
+ if (jas_iccgetuint32(in, &curv->numents))
+ goto error;
+ if (!(curv->ents = jas_alloc2(curv->numents, sizeof(jas_iccuint16_t))))
+ goto error;
+ for (unsigned i = 0; i < curv->numents; ++i) {+ if (jas_iccgetuint16(in, &curv->ents[i]))
+ goto error;
+ }
+
+ if (4 + 2 * curv->numents != cnt)
+ goto error;
+ return 0;
+
+error:
+ jas_icccurv_destroy(attrval);
+ return -1;
+}
+
+static unsigned jas_icccurv_getsize(const jas_iccattrval_t *attrval)
+{+ const jas_icccurv_t *curv = &attrval->data.curv;
+ return 4 + 2 * curv->numents;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icccurv_output(jas_iccattrval_t *attrval, jas_stream_t *out)
+{+ const jas_icccurv_t *curv = &attrval->data.curv;
+
+ if (jas_iccputuint32(out, curv->numents))
+ goto error;
+ for (unsigned i = 0; i < curv->numents; ++i) {+ if (jas_iccputuint16(out, curv->ents[i]))
+ goto error;
+ }
+ return 0;
+error:
+ return -1;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static void jas_icccurv_dump(const jas_iccattrval_t *attrval, FILE *out)
+{+ const jas_icccurv_t *curv = &attrval->data.curv;
+ fprintf(out, "number of entries = %"PRIuFAST32"\n", curv->numents);
+ if (curv->numents == 1) {+ fprintf(out, "gamma = %f\n", curv->ents[0] / 256.0);
+ } else {+ for (unsigned i = 0; i < curv->numents; ++i) {+ if (i < 3 || i >= curv->numents - 3) {+ fprintf(out, "entry[%d] = %f\n", i, curv->ents[i] / 65535.0);
+ }
+ }
+ }
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static void jas_icctxtdesc_destroy(jas_iccattrval_t *attrval)
+{+ jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
+ if (txtdesc->ascdata) {+ jas_free(txtdesc->ascdata);
+ txtdesc->ascdata = 0;
+ }
+ if (txtdesc->ucdata) {+ jas_free(txtdesc->ucdata);
+ txtdesc->ucdata = 0;
+ }
+}
+
+static int jas_icctxtdesc_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval)
+{+ jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
+
+ /* Avoid compiler warnings about unused parameters. */
+ USED(attrval);
+ USED(othattrval);
+ USED(txtdesc);
+
+ /* Not yet implemented. */
+ abort();
+ return -1;
+}
+
+static int jas_icctxtdesc_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt)
+{+ int c;
+ jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
+ txtdesc->ascdata = 0;
+ txtdesc->ucdata = 0;
+ if (jas_iccgetuint32(in, &txtdesc->asclen))
+ goto error;
+ if (txtdesc->asclen < 1)
+ goto error;
+ if (!(txtdesc->ascdata = jas_malloc(txtdesc->asclen)))
+ goto error;
+ if (jas_stream_read(in, txtdesc->ascdata, txtdesc->asclen) !=
+ txtdesc->asclen)
+ goto error;
+ txtdesc->ascdata[txtdesc->asclen - 1] = '\0';
+ if (jas_iccgetuint32(in, &txtdesc->uclangcode) ||
+ jas_iccgetuint32(in, &txtdesc->uclen))
+ goto error;
+ if (!(txtdesc->ucdata = jas_alloc2(txtdesc->uclen, 2)))
+ goto error;
+ if (jas_stream_read(in, txtdesc->ucdata, txtdesc->uclen * 2) !=
+ txtdesc->uclen * 2)
+ goto error;
+ if (jas_iccgetuint16(in, &txtdesc->sccode))
+ goto error;
+ if ((c = jas_stream_getc(in)) == EOF)
+ goto error;
+ txtdesc->maclen = c;
+ if (jas_stream_read(in, txtdesc->macdata, 67) != 67)
+ goto error;
+ txtdesc->asclen = JAS_CAST(jas_iccuint32_t, strlen(txtdesc->ascdata) + 1);
+#define WORKAROUND_BAD_PROFILES
+#ifdef WORKAROUND_BAD_PROFILES
+ const unsigned n = txtdesc->asclen + txtdesc->uclen * 2 + 15 + 67;
+ if (n > cnt) {+ return -1;
+ }
+ if (n < cnt) {+ if (jas_stream_gobble(in, cnt - n) != (int)(cnt - n))
+ goto error;
+ }
+#else
+ if (txtdesc->asclen + txtdesc->uclen * 2 + 15 + 67 != cnt)
+ return -1;
+#endif
+ return 0;
+error:
+ jas_icctxtdesc_destroy(attrval);
+ return -1;
+}
+
+static unsigned jas_icctxtdesc_getsize(const jas_iccattrval_t *attrval)
+{+ const jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
+ return strlen(txtdesc->ascdata) + 1 + txtdesc->uclen * 2 + 15 + 67;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icctxtdesc_output(jas_iccattrval_t *attrval, jas_stream_t *out)
+{+ const jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
+ if (jas_iccputuint32(out, txtdesc->asclen) ||
+ jas_stream_puts(out, txtdesc->ascdata) ||
+ jas_stream_putc(out, 0) == EOF ||
+ jas_iccputuint32(out, txtdesc->uclangcode) ||
+ jas_iccputuint32(out, txtdesc->uclen) ||
+ jas_stream_write(out, txtdesc->ucdata, txtdesc->uclen * 2) != txtdesc->uclen * 2 ||
+ jas_iccputuint16(out, txtdesc->sccode) ||
+ jas_stream_putc(out, txtdesc->maclen) == EOF)
+ goto error;
+ if (txtdesc->maclen > 0) {+ if (jas_stream_write(out, txtdesc->macdata, 67) != 67)
+ goto error;
+ } else {+ if (jas_stream_pad(out, 67, 0) != 67)
+ goto error;
+ }
+ return 0;
+error:
+ return -1;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static void jas_icctxtdesc_dump(const jas_iccattrval_t *attrval, FILE *out)
+{+ const jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
+ fprintf(out, "ascii = \"%s\"\n", txtdesc->ascdata);
+ fprintf(out, "uclangcode = %"PRIuFAST32"; uclen = %"PRIuFAST32"\n",
+ txtdesc->uclangcode, txtdesc->uclen);
+ fprintf(out, "sccode = %"PRIuFAST16"\n", txtdesc->sccode);
+ fprintf(out, "maclen = %d\n", txtdesc->maclen);
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static void jas_icctxt_destroy(jas_iccattrval_t *attrval)
+{+ jas_icctxt_t *txt = &attrval->data.txt;
+ if (txt->string) {+ jas_free(txt->string);
+ txt->string = 0;
+ }
+}
+
+static int jas_icctxt_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval)
+{+ jas_icctxt_t *txt = &attrval->data.txt;
+ const jas_icctxt_t *othtxt = &othattrval->data.txt;
+ if (!(txt->string = jas_strdup(othtxt->string)))
+ return -1;
+ return 0;
+}
+
+static int jas_icctxt_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt)
+{+ jas_icctxt_t *txt = &attrval->data.txt;
+ txt->string = 0;
+ if (!(txt->string = jas_malloc(cnt)))
+ goto error;
+ if (jas_stream_read(in, txt->string, cnt) != cnt)
+ goto error;
+ txt->string[cnt - 1] = '\0';
+ if (strlen(txt->string) + 1 != cnt)
+ goto error;
+ return 0;
+error:
+ jas_icctxt_destroy(attrval);
+ return -1;
+}
+
+static unsigned jas_icctxt_getsize(const jas_iccattrval_t *attrval)
+{+ const jas_icctxt_t *txt = &attrval->data.txt;
+ return strlen(txt->string) + 1;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icctxt_output(jas_iccattrval_t *attrval, jas_stream_t *out)
+{+ const jas_icctxt_t *txt = &attrval->data.txt;
+ if (jas_stream_puts(out, txt->string) ||
+ jas_stream_putc(out, 0) == EOF)
+ return -1;
+ return 0;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static void jas_icctxt_dump(const jas_iccattrval_t *attrval, FILE *out)
+{+ const jas_icctxt_t *txt = &attrval->data.txt;
+ fprintf(out, "string = \"%s\"\n", txt->string);
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static void jas_icclut8_destroy(jas_iccattrval_t *attrval)
+{+ jas_icclut8_t *lut8 = &attrval->data.lut8;
+ if (lut8->clut) {+ jas_free(lut8->clut);
+ lut8->clut = 0;
+ }
+ if (lut8->intabs) {+ jas_free(lut8->intabs);
+ lut8->intabs = 0;
+ }
+ if (lut8->intabsbuf) {+ jas_free(lut8->intabsbuf);
+ lut8->intabsbuf = 0;
+ }
+ if (lut8->outtabs) {+ jas_free(lut8->outtabs);
+ lut8->outtabs = 0;
+ }
+ if (lut8->outtabsbuf) {+ jas_free(lut8->outtabsbuf);
+ lut8->outtabsbuf = 0;
+ }
+}
+
+static int jas_icclut8_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval)
+{+ /* Avoid compiler warnings about unused parameters. */
+ USED(attrval);
+ USED(othattrval);
+ abort();
+ return -1;
+}
+
+static int jas_icclut8_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt)
+{+ jas_icclut8_t *lut8 = &attrval->data.lut8;
+ lut8->clut = 0;
+ lut8->intabs = 0;
+ lut8->intabsbuf = 0;
+ lut8->outtabs = 0;
+ lut8->outtabsbuf = 0;
+ if (jas_iccgetuint8(in, &lut8->numinchans) ||
+ jas_iccgetuint8(in, &lut8->numoutchans) ||
+ jas_iccgetuint8(in, &lut8->clutlen) ||
+ jas_stream_getc(in) == EOF)
+ goto error;
+ for (unsigned i = 0; i < 3; ++i) {+ for (unsigned j = 0; j < 3; ++j) {+ if (jas_iccgetsint32(in, &lut8->e[i][j]))
+ goto error;
+ }
+ }
+ if (jas_iccgetuint16(in, &lut8->numintabents) ||
+ jas_iccgetuint16(in, &lut8->numouttabents))
+ goto error;
+ const unsigned clutsize = jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans;
+ if (!(lut8->clut = jas_alloc2(clutsize, sizeof(jas_iccuint8_t))) ||
+ !(lut8->intabsbuf = jas_alloc3(lut8->numinchans,
+ lut8->numintabents, sizeof(jas_iccuint8_t))) ||
+ !(lut8->intabs = jas_alloc2(lut8->numinchans,
+ sizeof(jas_iccuint8_t *))))
+ goto error;
+ for (unsigned i = 0; i < lut8->numinchans; ++i)
+ lut8->intabs[i] = &lut8->intabsbuf[i * lut8->numintabents];
+ if (!(lut8->outtabsbuf = jas_alloc3(lut8->numoutchans,
+ lut8->numouttabents, sizeof(jas_iccuint8_t))) ||
+ !(lut8->outtabs = jas_alloc2(lut8->numoutchans,
+ sizeof(jas_iccuint8_t *))))
+ goto error;
+ for (unsigned i = 0; i < lut8->numoutchans; ++i)
+ lut8->outtabs[i] = &lut8->outtabsbuf[i * lut8->numouttabents];
+ for (unsigned i = 0; i < lut8->numinchans; ++i) {+ for (unsigned j = 0; j < lut8->numintabents; ++j) {+ if (jas_iccgetuint8(in, &lut8->intabs[i][j]))
+ goto error;
+ }
+ }
+ for (unsigned i = 0; i < lut8->numoutchans; ++i) {+ for (unsigned j = 0; j < lut8->numouttabents; ++j) {+ if (jas_iccgetuint8(in, &lut8->outtabs[i][j]))
+ goto error;
+ }
+ }
+ for (unsigned i = 0; i < clutsize; ++i) {+ if (jas_iccgetuint8(in, &lut8->clut[i]))
+ goto error;
+ }
+ if (44 + lut8->numinchans * lut8->numintabents +
+ lut8->numoutchans * lut8->numouttabents +
+ jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans !=
+ cnt)
+ goto error;
+ return 0;
+error:
+ jas_icclut8_destroy(attrval);
+ return -1;
+}
+
+static unsigned jas_icclut8_getsize(const jas_iccattrval_t *attrval)
+{+ const jas_icclut8_t *lut8 = &attrval->data.lut8;
+ return 44 + lut8->numinchans * lut8->numintabents +
+ lut8->numoutchans * lut8->numouttabents +
+ jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icclut8_output(jas_iccattrval_t *attrval, jas_stream_t *out)
+{+ jas_icclut8_t *lut8 = &attrval->data.lut8;
+ lut8->clut = 0;
+ lut8->intabs = 0;
+ lut8->intabsbuf = 0;
+ lut8->outtabs = 0;
+ lut8->outtabsbuf = 0;
+ if (jas_stream_putc(out, lut8->numinchans) == EOF ||
+ jas_stream_putc(out, lut8->numoutchans) == EOF ||
+ jas_stream_putc(out, lut8->clutlen) == EOF ||
+ jas_stream_putc(out, 0) == EOF)
+ goto error;
+ for (unsigned i = 0; i < 3; ++i) {+ for (unsigned j = 0; j < 3; ++j) {+ if (jas_iccputsint32(out, lut8->e[i][j]))
+ goto error;
+ }
+ }
+ if (jas_iccputuint16(out, lut8->numintabents) ||
+ jas_iccputuint16(out, lut8->numouttabents))
+ goto error;
+ for (unsigned i = 0, n = lut8->numinchans * lut8->numintabents; i < n; ++i) {+ if (jas_iccputuint8(out, lut8->intabsbuf[i]))
+ goto error;
+ }
+ for (unsigned i = 0, n = lut8->numoutchans * lut8->numouttabents; i < n; ++i) {+ if (jas_iccputuint8(out, lut8->outtabsbuf[i]))
+ goto error;
+ }
+ for (unsigned i = 0, n = jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans; i < n; ++i) {+ if (jas_iccputuint8(out, lut8->clut[i]))
+ goto error;
+ }
+ return 0;
+error:
+ return -1;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static void jas_icclut8_dump(const jas_iccattrval_t *attrval, FILE *out)
+{+ const jas_icclut8_t *lut8 = &attrval->data.lut8;
+ fprintf(out, "numinchans=%d, numoutchans=%d, clutlen=%d\n",
+ lut8->numinchans, lut8->numoutchans, lut8->clutlen);
+ for (unsigned i = 0; i < 3; ++i) {+ for (unsigned j = 0; j < 3; ++j) {+ fprintf(out, "e[%d][%d]=%f ", i, j, lut8->e[i][j] / 65536.0);
+ }
+ fprintf(out, "\n");
+ }
+ fprintf(out, "numintabents=%"PRIuFAST16", numouttabents=%"PRIuFAST16"\n",
+ lut8->numintabents, lut8->numouttabents);
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static void jas_icclut16_destroy(jas_iccattrval_t *attrval)
+{+ jas_icclut16_t *lut16 = &attrval->data.lut16;
+ if (lut16->clut) {+ jas_free(lut16->clut);
+ lut16->clut = 0;
+ }
+ if (lut16->intabs) {+ jas_free(lut16->intabs);
+ lut16->intabs = 0;
+ }
+ if (lut16->intabsbuf) {+ jas_free(lut16->intabsbuf);
+ lut16->intabsbuf = 0;
+ }
+ if (lut16->outtabs) {+ jas_free(lut16->outtabs);
+ lut16->outtabs = 0;
+ }
+ if (lut16->outtabsbuf) {+ jas_free(lut16->outtabsbuf);
+ lut16->outtabsbuf = 0;
+ }
+}
+
+static int jas_icclut16_copy(jas_iccattrval_t *attrval,
+ const jas_iccattrval_t *othattrval)
+{+ /* Avoid compiler warnings about unused parameters. */
+ USED(attrval);
+ USED(othattrval);
+ /* Not yet implemented. */
+ abort();
+ return -1;
+}
+
+static int jas_icclut16_input(jas_iccattrval_t *attrval, jas_stream_t *in,
+ unsigned cnt)
+{+ jas_icclut16_t *lut16 = &attrval->data.lut16;
+ lut16->clut = 0;
+ lut16->intabs = 0;
+ lut16->intabsbuf = 0;
+ lut16->outtabs = 0;
+ lut16->outtabsbuf = 0;
+ if (jas_iccgetuint8(in, &lut16->numinchans) ||
+ jas_iccgetuint8(in, &lut16->numoutchans) ||
+ jas_iccgetuint8(in, &lut16->clutlen) ||
+ jas_stream_getc(in) == EOF)
+ goto error;
+ for (unsigned i = 0; i < 3; ++i) {+ for (unsigned j = 0; j < 3; ++j) {+ if (jas_iccgetsint32(in, &lut16->e[i][j]))
+ goto error;
+ }
+ }
+ if (jas_iccgetuint16(in, &lut16->numintabents) ||
+ jas_iccgetuint16(in, &lut16->numouttabents))
+ goto error;
+ const unsigned clutsize = jas_iccpowi(lut16->clutlen, lut16->numinchans) * lut16->numoutchans;
+ if (!(lut16->clut = jas_alloc2(clutsize, sizeof(jas_iccuint16_t))) ||
+ !(lut16->intabsbuf = jas_alloc3(lut16->numinchans,
+ lut16->numintabents, sizeof(jas_iccuint16_t))) ||
+ !(lut16->intabs = jas_alloc2(lut16->numinchans,
+ sizeof(jas_iccuint16_t *))))
+ goto error;
+ for (unsigned i = 0; i < lut16->numinchans; ++i)
+ lut16->intabs[i] = &lut16->intabsbuf[i * lut16->numintabents];
+ if (!(lut16->outtabsbuf = jas_alloc3(lut16->numoutchans,
+ lut16->numouttabents, sizeof(jas_iccuint16_t))) ||
+ !(lut16->outtabs = jas_alloc2(lut16->numoutchans,
+ sizeof(jas_iccuint16_t *))))
+ goto error;
+ for (unsigned i = 0; i < lut16->numoutchans; ++i)
+ lut16->outtabs[i] = &lut16->outtabsbuf[i * lut16->numouttabents];
+ for (unsigned i = 0; i < lut16->numinchans; ++i) {+ for (unsigned j = 0; j < lut16->numintabents; ++j) {+ if (jas_iccgetuint16(in, &lut16->intabs[i][j]))
+ goto error;
+ }
+ }
+ for (unsigned i = 0; i < lut16->numoutchans; ++i) {+ for (unsigned j = 0; j < lut16->numouttabents; ++j) {+ if (jas_iccgetuint16(in, &lut16->outtabs[i][j]))
+ goto error;
+ }
+ }
+ for (unsigned i = 0; i < clutsize; ++i) {+ if (jas_iccgetuint16(in, &lut16->clut[i]))
+ goto error;
+ }
+ if (44 + 2 * (lut16->numinchans * lut16->numintabents +
+ lut16->numoutchans * lut16->numouttabents +
+ jas_iccpowi(lut16->clutlen, lut16->numinchans) *
+ lut16->numoutchans) != cnt)
+ goto error;
+ return 0;
+error:
+ jas_icclut16_destroy(attrval);
+ return -1;
+}
+
+static unsigned jas_icclut16_getsize(const jas_iccattrval_t *attrval)
+{+ const jas_icclut16_t *lut16 = &attrval->data.lut16;
+ return 44 + 2 * (lut16->numinchans * lut16->numintabents +
+ lut16->numoutchans * lut16->numouttabents +
+ jas_iccpowi(lut16->clutlen, lut16->numinchans) * lut16->numoutchans);
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static int jas_icclut16_output(jas_iccattrval_t *attrval, jas_stream_t *out)
+{+ const jas_icclut16_t *lut16 = &attrval->data.lut16;
+ if (jas_stream_putc(out, lut16->numinchans) == EOF ||
+ jas_stream_putc(out, lut16->numoutchans) == EOF ||
+ jas_stream_putc(out, lut16->clutlen) == EOF ||
+ jas_stream_putc(out, 0) == EOF)
+ goto error;
+ for (unsigned i = 0; i < 3; ++i) {+ for (unsigned j = 0; j < 3; ++j) {+ if (jas_iccputsint32(out, lut16->e[i][j]))
+ goto error;
+ }
+ }
+ if (jas_iccputuint16(out, lut16->numintabents) ||
+ jas_iccputuint16(out, lut16->numouttabents))
+ goto error;
+ for (unsigned i = 0, n = lut16->numinchans * lut16->numintabents; i < n; ++i) {+ if (jas_iccputuint16(out, lut16->intabsbuf[i]))
+ goto error;
+ }
+ for (unsigned i = 0, n = lut16->numoutchans * lut16->numouttabents; i < n; ++i) {+ if (jas_iccputuint16(out, lut16->outtabsbuf[i]))
+ goto error;
+ }
+ for (unsigned i = 0, n = jas_iccpowi(lut16->clutlen, lut16->numinchans) * lut16->numoutchans; i < n; ++i) {+ if (jas_iccputuint16(out, lut16->clut[i]))
+ goto error;
+ }
+ return 0;
+error:
+ return -1;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static void jas_icclut16_dump(const jas_iccattrval_t *attrval, FILE *out)
+{+ const jas_icclut16_t *lut16 = &attrval->data.lut16;
+ fprintf(out, "numinchans=%d, numoutchans=%d, clutlen=%d\n",
+ lut16->numinchans, lut16->numoutchans, lut16->clutlen);
+ for (unsigned i = 0; i < 3; ++i) {+ for (unsigned j = 0; j < 3; ++j) {+ fprintf(out, "e[%d][%d]=%f ", i, j, lut16->e[i][j] / 65536.0);
+ }
+ fprintf(out, "\n");
+ }
+ fprintf(out, "numintabents=%"PRIuFAST16", numouttabents=%"PRIuFAST16"\n",
+ lut16->numintabents, lut16->numouttabents);
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static int jas_iccgetuint(jas_stream_t *in, unsigned n, jas_ulonglong *val)
+{+ int c;
+ jas_ulonglong v;
+ v = 0;
+ for (unsigned i = n; i > 0; --i) {+ if ((c = jas_stream_getc(in)) == EOF)
+ return -1;
+ v = (v << 8) | c;
+ }
+ *val = v;
+ return 0;
+}
+
+static int jas_iccgetuint8(jas_stream_t *in, jas_iccuint8_t *val)
+{+ int c;
+ if ((c = jas_stream_getc(in)) == EOF)
+ return -1;
+ *val = c;
+ return 0;
+}
+
+static int jas_iccgetuint16(jas_stream_t *in, jas_iccuint16_t *val)
+{+ jas_ulonglong tmp;
+ if (jas_iccgetuint(in, 2, &tmp))
+ return -1;
+ *val = (jas_iccuint16_t)tmp;
+ return 0;
+}
+
+static int jas_iccgetsint32(jas_stream_t *in, jas_iccsint32_t *val)
+{+ jas_ulonglong tmp;
+ if (jas_iccgetuint(in, 4, &tmp))
+ return -1;
+ *val = (tmp & 0x80000000) ? (-JAS_CAST(jas_longlong, (((~tmp) &
+ 0x7fffffff) + 1))) : JAS_CAST(jas_longlong, tmp);
+ return 0;
+}
+
+static int jas_iccgetuint32(jas_stream_t *in, jas_iccuint32_t *val)
+{+ jas_ulonglong tmp;
+ if (jas_iccgetuint(in, 4, &tmp))
+ return -1;
+ *val = (jas_iccuint32_t)tmp;
+ return 0;
+}
+
+static int jas_iccgetuint64(jas_stream_t *in, jas_iccuint64_t *val)
+{+ jas_ulonglong tmp;
+ if (jas_iccgetuint(in, 8, &tmp))
+ return -1;
+ *val = (jas_iccuint64_t)tmp;
+ return 0;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+
+static int jas_iccputuint(jas_stream_t *out, unsigned n, jas_ulonglong val)
+{+ int c;
+ for (unsigned i = n; i > 0; --i) {+ c = (val >> (8 * (i - 1))) & 0xff;
+ if (jas_stream_putc(out, c) == EOF)
+ return -1;
+ }
+ return 0;
+}
+
+static int jas_iccputsint(jas_stream_t *out, unsigned n, jas_longlong val)
+{+ assert(val >= 0);
+ jas_ulonglong tmp;
+ tmp = (val < 0) ? 0 : val;
+ return jas_iccputuint(out, n, tmp);
+}
+
+//#endif /* JAS_ENABLE_ENCODER */
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static char *jas_iccsigtostr(unsigned sig, char *buf)
+{+ int c;
+ char *bufptr;
+ bufptr = buf;
+ for (unsigned n = 4; n > 0; --n) {+ c = (sig >> 24) & 0xff;
+ if (isalpha(c) || isdigit(c)) {+ *bufptr++ = c;
+ }
+ sig <<= 8;
+ }
+ *bufptr = '\0';
+ return buf;
+}
+
+//#ifdef JAS_ENABLE_ENCODER
+static unsigned jas_iccpadtomult(unsigned x, unsigned y)
+{+ return ((x + y - 1) / y) * y;
+}
+//#endif /* JAS_ENABLE_ENCODER */
+
+static unsigned jas_iccpowi(unsigned x, unsigned n)
+{+ unsigned y;
+ y = 1;
+ while (n-- > 0)
+ y *= x;
+ return y;
+}
+
+
+jas_iccprof_t *jas_iccprof_createfrombuf(const jas_uchar *buf, unsigned len)
+{+ jas_stream_t *in;
+ jas_iccprof_t *prof;
+ if (!(in = jas_stream_memopen(JAS_CAST(char *, buf), len)))
+ goto error;
+ if (!(prof = jas_iccprof_load(in)))
+ goto error;
+ jas_stream_close(in);
+ return prof;
+error:
+ if (in)
+ jas_stream_close(in);
+ return 0;
+}
+
+jas_iccprof_t *jas_iccprof_createfromclrspc(unsigned clrspc)
+{+ jas_iccprof_t *prof;
+ switch (clrspc) {+ case JAS_CLRSPC_SRGB:
+ prof = jas_iccprof_createfrombuf(jas_iccprofdata_srgb,
+ jas_iccprofdata_srgblen);
+ break;
+ case JAS_CLRSPC_SGRAY:
+ prof = jas_iccprof_createfrombuf(jas_iccprofdata_sgray,
+ jas_iccprofdata_sgraylen);
+ break;
+ default:
+ prof = 0;
+ break;
+ }
+ return prof;
+}
--- /dev/null
+++ b/jas_iccdata.c
@@ -1,0 +1,517 @@
+/*
+ * Copyright (c) 2002-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+#include <jasper/jas_config.h> /* IWYU pragma: keep */
+#include <jasper/jas_types.h>
+
+const jas_uchar jas_iccprofdata_srgb[] =
+{+ 0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f,
+ 0x02, 0x10, 0x00, 0x00, 0x6d, 0x6e, 0x74, 0x72,
+ 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
+ 0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06,
+ 0x00, 0x31, 0x00, 0x00, 0x61, 0x63, 0x73, 0x70,
+ 0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
+ 0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+ 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+ 0x48, 0x50, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x11, 0x63, 0x70, 0x72, 0x74,
+ 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33,
+ 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84,
+ 0x00, 0x00, 0x00, 0x6c, 0x77, 0x74, 0x70, 0x74,
+ 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14,
+ 0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04,
+ 0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5a,
+ 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14,
+ 0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c,
+ 0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5a,
+ 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14,
+ 0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54,
+ 0x00, 0x00, 0x00, 0x70, 0x64, 0x6d, 0x64, 0x64,
+ 0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
+ 0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c,
+ 0x00, 0x00, 0x00, 0x86, 0x76, 0x69, 0x65, 0x77,
+ 0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24,
+ 0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8,
+ 0x00, 0x00, 0x00, 0x14, 0x6d, 0x65, 0x61, 0x73,
+ 0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24,
+ 0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30,
+ 0x00, 0x00, 0x00, 0x0c, 0x72, 0x54, 0x52, 0x43,
+ 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+ 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c,
+ 0x00, 0x00, 0x08, 0x0c, 0x62, 0x54, 0x52, 0x43,
+ 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
+ 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
+ 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68,
+ 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39,
+ 0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65,
+ 0x74, 0x74, 0x2d, 0x50, 0x61, 0x63, 0x6b, 0x61,
+ 0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61,
+ 0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+ 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43,
+ 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
+ 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47,
+ 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39,
+ 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5,
+ 0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x99,
+ 0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda,
+ 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x0f, 0x84,
+ 0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
+ 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70,
+ 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
+ 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
+ 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
+ 0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
+ 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36,
+ 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65,
+ 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
+ 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72,
+ 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d,
+ 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39,
+ 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
+ 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52,
+ 0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75,
+ 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
+ 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+ 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+ 0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e,
+ 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74,
+ 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49,
+ 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d,
+ 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52,
+ 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
+ 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67,
+ 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
+ 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45,
+ 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32,
+ 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe,
+ 0x00, 0x14, 0x5f, 0x2e, 0x00, 0x10, 0xcf, 0x14,
+ 0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b,
+ 0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01,
+ 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00,
+ 0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02,
+ 0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f,
+ 0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23,
+ 0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37,
+ 0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a,
+ 0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e,
+ 0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72,
+ 0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86,
+ 0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a,
+ 0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae,
+ 0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1,
+ 0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5,
+ 0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb,
+ 0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01,
+ 0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19,
+ 0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32,
+ 0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c,
+ 0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67,
+ 0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83,
+ 0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1,
+ 0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1,
+ 0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1,
+ 0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03,
+ 0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26,
+ 0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b,
+ 0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71,
+ 0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98,
+ 0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1,
+ 0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb,
+ 0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16,
+ 0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43,
+ 0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72,
+ 0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2,
+ 0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3,
+ 0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06,
+ 0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b,
+ 0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71,
+ 0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8,
+ 0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1,
+ 0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c,
+ 0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58,
+ 0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96,
+ 0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5,
+ 0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16,
+ 0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59,
+ 0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d,
+ 0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3,
+ 0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b,
+ 0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74,
+ 0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf,
+ 0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b,
+ 0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a,
+ 0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa,
+ 0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb,
+ 0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f,
+ 0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4,
+ 0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb,
+ 0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54,
+ 0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae,
+ 0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b,
+ 0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69,
+ 0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8,
+ 0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a,
+ 0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e,
+ 0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3,
+ 0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a,
+ 0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3,
+ 0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e,
+ 0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b,
+ 0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09,
+ 0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a,
+ 0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec,
+ 0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61,
+ 0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7,
+ 0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f,
+ 0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9,
+ 0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45,
+ 0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3,
+ 0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43,
+ 0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5,
+ 0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49,
+ 0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce,
+ 0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56,
+ 0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0,
+ 0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c,
+ 0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa,
+ 0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89,
+ 0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b,
+ 0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf,
+ 0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45,
+ 0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd,
+ 0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77,
+ 0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14,
+ 0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2,
+ 0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52,
+ 0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5,
+ 0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99,
+ 0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40,
+ 0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9,
+ 0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94,
+ 0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41,
+ 0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0,
+ 0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1,
+ 0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55,
+ 0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a,
+ 0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2,
+ 0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c,
+ 0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38,
+ 0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7,
+ 0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7,
+ 0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a,
+ 0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f,
+ 0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06,
+ 0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0,
+ 0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b,
+ 0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69,
+ 0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39,
+ 0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c,
+ 0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1,
+ 0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7,
+ 0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91,
+ 0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c,
+ 0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a,
+ 0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a,
+ 0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d,
+ 0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1,
+ 0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8,
+ 0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2,
+ 0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae,
+ 0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c,
+ 0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c,
+ 0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f,
+ 0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74,
+ 0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b,
+ 0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65,
+ 0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61,
+ 0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60,
+ 0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61,
+ 0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64,
+ 0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a,
+ 0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72,
+ 0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d,
+ 0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a,
+ 0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a,
+ 0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab,
+ 0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0,
+ 0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7,
+ 0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0,
+ 0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c,
+ 0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a,
+ 0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a,
+ 0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e,
+ 0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93,
+ 0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb,
+ 0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6,
+ 0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13,
+ 0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42,
+ 0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75,
+ 0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9,
+ 0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0,
+ 0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a,
+ 0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56,
+ 0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95,
+ 0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6,
+ 0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a,
+ 0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61,
+ 0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa,
+ 0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5,
+ 0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43,
+ 0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94,
+ 0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7,
+ 0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d,
+ 0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96,
+ 0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1,
+ 0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f,
+ 0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf,
+ 0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12,
+ 0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78,
+ 0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0,
+ 0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b,
+ 0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8,
+ 0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28,
+ 0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b,
+ 0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11,
+ 0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89,
+ 0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04,
+ 0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81,
+ 0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01,
+ 0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84,
+ 0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a,
+ 0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92,
+ 0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d,
+ 0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab,
+ 0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b,
+ 0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce,
+ 0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64,
+ 0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc,
+ 0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98,
+ 0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36,
+ 0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6,
+ 0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a,
+ 0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20,
+ 0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9,
+ 0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75,
+ 0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24,
+ 0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5,
+ 0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89,
+ 0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40,
+ 0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa,
+ 0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6,
+ 0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76,
+ 0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38,
+ 0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd,
+ 0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4,
+ 0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f,
+ 0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c,
+ 0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d,
+ 0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00,
+ 0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6,
+ 0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae,
+ 0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a,
+ 0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68,
+ 0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a,
+ 0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e,
+ 0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15,
+ 0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff,
+ 0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec,
+ 0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb,
+ 0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce,
+ 0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3,
+ 0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc,
+ 0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7,
+ 0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5,
+ 0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6,
+ 0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba,
+ 0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1,
+ 0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb,
+ 0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8,
+ 0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8,
+ 0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb,
+ 0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10,
+ 0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29,
+ 0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44,
+ 0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63,
+ 0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84,
+ 0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9,
+ 0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0,
+ 0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb,
+ 0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28,
+ 0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58,
+ 0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c,
+ 0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2,
+ 0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb,
+ 0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38,
+ 0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77,
+ 0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba,
+ 0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff
+};
+
+const unsigned jas_iccprofdata_srgblen = sizeof(jas_iccprofdata_srgb);
+
+const jas_uchar jas_iccprofdata_sgray[] = {+ 0x00, 0x00, 0x01, 0x8a, 0x00, 0x00, 0x00, 0x00,
+ 0x02, 0x20, 0x00, 0x00, 0x73, 0x63, 0x6e, 0x72,
+ 0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5a, 0x20,
+ 0x07, 0xd3, 0x00, 0x01, 0x00, 0x1f, 0x00, 0x0d,
+ 0x00, 0x35, 0x00, 0x21, 0x61, 0x63, 0x73, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x4b, 0x4f, 0x44, 0x41, 0x73, 0x47, 0x72, 0x79,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
+ 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d,
+ 0x4a, 0x50, 0x45, 0x47, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x04, 0x64, 0x65, 0x73, 0x63,
+ 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x86,
+ 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x3c,
+ 0x00, 0x00, 0x00, 0x2b, 0x77, 0x74, 0x70, 0x74,
+ 0x00, 0x00, 0x01, 0x68, 0x00, 0x00, 0x00, 0x14,
+ 0x6b, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x7c,
+ 0x00, 0x00, 0x00, 0x0e, 0x64, 0x65, 0x73, 0x63,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+ 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74,
+ 0x65, 0x64, 0x20, 0x49, 0x43, 0x43, 0x20, 0x70,
+ 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x64,
+ 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x69, 0x6e,
+ 0x67, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d, 0x67,
+ 0x72, 0x65, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74,
+ 0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
+ 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x32, 0x30,
+ 0x30, 0x33, 0x20, 0x73, 0x52, 0x47, 0x42, 0x2d,
+ 0x67, 0x72, 0x65, 0x79, 0x20, 0x52, 0x65, 0x66,
+ 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x00,
+ 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xf3, 0x54, 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x01, 0x16, 0xcf, 0x63, 0x75, 0x72, 0x76,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x01, 0xcd
+};
+
+const unsigned jas_iccprofdata_sgraylen = sizeof(jas_iccprofdata_sgray);
--- /dev/null
+++ b/jas_image.c
@@ -1,0 +1,1612 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Image Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_image.h"
+#include "jasper/jas_math.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_string.h"
+#include "jasper/jas_debug.h"
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+#define FLOORDIV(x, y) ((x) / (y))
+
+/******************************************************************************\
+* Local prototypes.
+\******************************************************************************/
+
+static jas_image_cmpt_t *jas_image_cmpt_create0(void);
+static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt);
+static jas_image_cmpt_t *jas_image_cmpt_create(int_fast32_t tlx,
+ int_fast32_t tly, int_fast32_t hstep, int_fast32_t vstep,
+ int_fast32_t width, int_fast32_t height, uint_fast16_t depth, bool sgnd,
+ bool inmem);
+static void jas_image_setbbox(jas_image_t *image);
+static jas_image_cmpt_t *jas_image_cmpt_copy(jas_image_cmpt_t *cmpt);
+static int jas_image_growcmpts(jas_image_t *image, unsigned maxcmpts);
+static uint_fast32_t inttobits(jas_seqent_t v, unsigned prec, bool sgnd);
+static jas_seqent_t bitstoint(uint_fast32_t v, unsigned prec, bool sgnd);
+static int putint(jas_stream_t *out, bool sgnd, unsigned prec, long val);
+static int getint(jas_stream_t *in, bool sgnd, unsigned prec, long *val);
+static long uptomult(long x, long y);
+static long downtomult(long x, long y);
+static long convert(long val, bool oldsgnd, unsigned oldprec, bool newsgnd,
+ unsigned newprec);
+static void jas_image_calcbbox2(const jas_image_t *image, jas_image_coord_t *tlx,
+ jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry);
+
+/******************************************************************************\
+* Global data.
+\******************************************************************************/
+
+static unsigned jas_image_numfmts = 0;
+static jas_image_fmtinfo_t jas_image_fmtinfos[JAS_IMAGE_MAXFMTS];
+
+/******************************************************************************\
+* Create and destroy operations.
+\******************************************************************************/
+
+jas_image_t *jas_image_create(unsigned numcmpts, const jas_image_cmptparm_t *cmptparms,
+ jas_clrspc_t clrspc)
+{+ jas_image_t *image;
+ size_t rawsize;
+ unsigned cmptno;
+ const jas_image_cmptparm_t *cmptparm;
+
+ JAS_DBGLOG(100, ("jas_image_create(%d, %p, %d)\n", numcmpts, cmptparms,+ clrspc));
+
+ if (!(image = jas_image_create0())) {+ goto error;
+ }
+
+ image->clrspc_ = clrspc;
+ image->maxcmpts_ = numcmpts;
+// image->inmem_ = true;
+
+ /* Allocate memory for the per-component information. */
+ if (!(image->cmpts_ = jas_alloc2(image->maxcmpts_,
+ sizeof(jas_image_cmpt_t *)))) {+ goto error;
+ }
+ /* Initialize in case of failure. */
+ for (cmptno = 0; cmptno < image->maxcmpts_; ++cmptno) {+ image->cmpts_[cmptno] = 0;
+ }
+
+#if 0
+ /* Compute the approximate raw size of the image. */
+ rawsize = 0;
+ for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno,
+ ++cmptparm) {+ rawsize += cmptparm->width * cmptparm->height *
+ (cmptparm->prec + 7) / 8;
+ }
+ /* Decide whether to buffer the image data in memory, based on the
+ raw size of the image. */
+ inmem = (rawsize < JAS_IMAGE_INMEMTHRESH);
+#endif
+
+ /* Create the individual image components. */
+ for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno,
+ ++cmptparm) {+ if (!jas_safe_size_mul3(cmptparm->width, cmptparm->height,
+ (cmptparm->prec + 7), &rawsize)) {+ goto error;
+ }
+ rawsize /= 8;
+ const bool inmem = (rawsize < JAS_IMAGE_INMEMTHRESH);
+ if (!(image->cmpts_[cmptno] = jas_image_cmpt_create(cmptparm->tlx,
+ cmptparm->tly, cmptparm->hstep, cmptparm->vstep,
+ cmptparm->width, cmptparm->height, cmptparm->prec,
+ cmptparm->sgnd, inmem))) {+ goto error;
+ }
+ ++image->numcmpts_;
+ }
+
+ /* Determine the bounding box for all of the components on the
+ reference grid (i.e., the image area) */
+ jas_image_setbbox(image);
+
+ return image;
+
+error:
+ if (image) {+ jas_image_destroy(image);
+ }
+ return 0;
+}
+
+jas_image_t *jas_image_create0()
+{+ jas_image_t *image;
+
+ if (!(image = jas_malloc(sizeof(jas_image_t)))) {+ return 0;
+ }
+
+ image->tlx_ = 0;
+ image->tly_ = 0;
+ image->brx_ = 0;
+ image->bry_ = 0;
+ image->clrspc_ = JAS_CLRSPC_UNKNOWN;
+ image->numcmpts_ = 0;
+ image->maxcmpts_ = 0;
+ image->cmpts_ = 0;
+// image->inmem_ = true;
+ image->cmprof_ = 0;
+
+ return image;
+}
+
+jas_image_t *jas_image_copy(jas_image_t *image)
+{+ jas_image_t *newimage;
+
+ if (!(newimage = jas_image_create0())) {+ goto error;
+ }
+
+ if (jas_image_growcmpts(newimage, image->numcmpts_)) {+ goto error;
+ }
+ for (unsigned cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {+ if (!(newimage->cmpts_[cmptno] = jas_image_cmpt_copy(image->cmpts_[cmptno]))) {+ goto error;
+ }
+ ++newimage->numcmpts_;
+ }
+
+ jas_image_setbbox(newimage);
+
+ if (image->cmprof_) {+ if (!(newimage->cmprof_ = jas_cmprof_copy(image->cmprof_)))
+ goto error;
+ }
+
+ return newimage;
+error:
+ if (newimage) {+ jas_image_destroy(newimage);
+ }
+ return 0;
+}
+
+static jas_image_cmpt_t *jas_image_cmpt_create0()
+{+ jas_image_cmpt_t *cmpt;
+ if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) {+ return 0;
+ }
+ memset(cmpt, 0, sizeof(jas_image_cmpt_t));
+ cmpt->type_ = JAS_IMAGE_CT_UNKNOWN;
+ return cmpt;
+}
+
+static jas_image_cmpt_t *jas_image_cmpt_copy(jas_image_cmpt_t *cmpt)
+{+ jas_image_cmpt_t *newcmpt;
+
+ if (!(newcmpt = jas_image_cmpt_create0())) {+ return 0;
+ }
+ newcmpt->tlx_ = cmpt->tlx_;
+ newcmpt->tly_ = cmpt->tly_;
+ newcmpt->hstep_ = cmpt->hstep_;
+ newcmpt->vstep_ = cmpt->vstep_;
+ newcmpt->width_ = cmpt->width_;
+ newcmpt->height_ = cmpt->height_;
+ newcmpt->prec_ = cmpt->prec_;
+ newcmpt->sgnd_ = cmpt->sgnd_;
+ newcmpt->cps_ = cmpt->cps_;
+ newcmpt->type_ = cmpt->type_;
+ if (!(newcmpt->stream_ = jas_stream_memopen(0, 0))) {+ goto error;
+ }
+ if (jas_stream_seek(cmpt->stream_, 0, SEEK_SET)) {+ goto error;
+ }
+ if (jas_stream_copy(newcmpt->stream_, cmpt->stream_, -1)) {+ goto error;
+ }
+ if (jas_stream_seek(newcmpt->stream_, 0, SEEK_SET)) {+ goto error;
+ }
+ return newcmpt;
+error:
+ jas_image_cmpt_destroy(newcmpt);
+ return 0;
+}
+
+void jas_image_destroy(jas_image_t *image)
+{+ if (image->cmpts_) {+ for (unsigned i = 0; i < image->numcmpts_; ++i) {+ jas_image_cmpt_destroy(image->cmpts_[i]);
+ image->cmpts_[i] = 0;
+ }
+ jas_free(image->cmpts_);
+ }
+ if (image->cmprof_)
+ jas_cmprof_destroy(image->cmprof_);
+ jas_free(image);
+}
+
+static jas_image_cmpt_t *jas_image_cmpt_create(int_fast32_t tlx,
+ int_fast32_t tly, int_fast32_t hstep, int_fast32_t vstep,
+ int_fast32_t width, int_fast32_t height, uint_fast16_t depth, bool sgnd,
+ bool inmem)
+{+ jas_image_cmpt_t *cmpt;
+ size_t size;
+
+ JAS_DBGLOG(100, (
+ "jas_image_cmpt_create(%ld, %ld, %ld, %ld, %ld, %ld, %d, %d, %d)\n",
+ JAS_CAST(long, tlx),
+ JAS_CAST(long, tly),
+ JAS_CAST(long, hstep),
+ JAS_CAST(long, vstep),
+ JAS_CAST(long, width),
+ JAS_CAST(long, height),
+ JAS_CAST(int, depth),
+ sgnd,
+ inmem
+ ));
+
+ if (depth < 1U + sgnd) {+ /* we need at least 1 bit for unsigned samples and 2
+ bits for signed samples */
+ return NULL;
+ }
+
+ if (width < 0 || height < 0 || hstep <= 0 || vstep <= 0) {+ return NULL;
+ }
+ if (!jas_safe_intfast32_add(tlx, width, 0) ||
+ !jas_safe_intfast32_add(tly, height, 0)) {+ return NULL;
+ }
+ if (!jas_safe_intfast32_mul3(width, height, depth, 0)) {+ return NULL;
+ }
+
+ if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) {+ return NULL;
+ }
+
+ cmpt->type_ = JAS_IMAGE_CT_UNKNOWN;
+ cmpt->tlx_ = tlx;
+ cmpt->tly_ = tly;
+ cmpt->hstep_ = hstep;
+ cmpt->vstep_ = vstep;
+ cmpt->width_ = width;
+ cmpt->height_ = height;
+ cmpt->prec_ = depth;
+ cmpt->sgnd_ = sgnd;
+ cmpt->stream_ = 0;
+ cmpt->cps_ = (depth + 7) / 8;
+
+ // Compute the number of samples in the image component, while protecting
+ // against overflow.
+ // size = cmpt->width_ * cmpt->height_ * cmpt->cps_;
+ if (!jas_safe_size_mul3(cmpt->width_, cmpt->height_, cmpt->cps_, &size)) {+ goto error;
+ }
+ cmpt->stream_ = (inmem) ? jas_stream_memopen2(0, size) :
+ jas_stream_tmpfile();
+ if (!cmpt->stream_) {+ goto error;
+ }
+
+ /* Zero the component data. This isn't necessary, but it is
+ convenient for debugging purposes. */
+ /* Note: conversion of size - 1 to long can overflow */
+ if (size > 0) {+ if (size - 1 > LONG_MAX) {+ goto error;
+ }
+ if (jas_stream_seek(cmpt->stream_, size - 1, SEEK_SET) < 0 ||
+ jas_stream_putc(cmpt->stream_, 0) == EOF ||
+ jas_stream_seek(cmpt->stream_, 0, SEEK_SET) < 0) {+ goto error;
+ }
+ }
+
+ return cmpt;
+
+error:
+ jas_image_cmpt_destroy(cmpt);
+ return 0;
+}
+
+static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt)
+{+ if (cmpt->stream_) {+ jas_stream_close(cmpt->stream_);
+ }
+ jas_free(cmpt);
+}
+
+/******************************************************************************\
+* Load and save operations.
+\******************************************************************************/
+
+jas_image_t *jas_image_decode(jas_stream_t *in, int fmt, const char *optstr)
+{+ const jas_image_fmtinfo_t *fmtinfo;
+ jas_image_t *image;
+
+ image = 0;
+
+ /* If possible, try to determine the format of the input data. */
+ if (fmt < 0) {+ if ((fmt = jas_image_getfmt(in)) < 0){+ werrstr("unknown format");+ goto error;
+ }
+ }
+
+ /* Is it possible to decode an image represented in this format? */
+ if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))){+ werrstr("unsupported format");+ goto error;
+ }
+ if (!fmtinfo->ops.decode){+ werrstr("no decoder for the format");+ goto error;
+ }
+
+ /* Decode the image. */
+ if (!(image = (*fmtinfo->ops.decode)(in, optstr))){+ werrstr("failed to decode");+ goto error;
+ }
+
+ /* Create a color profile if needed. */
+ if (!jas_clrspc_isunknown(image->clrspc_) &&
+ !jas_clrspc_isgeneric(image->clrspc_) && !image->cmprof_) {+ if (!(image->cmprof_ =
+ jas_cmprof_createfromclrspc(jas_image_clrspc(image)))){+ werrstr("failed to create colorspace");+ goto error;
+ }
+ }
+
+ return image;
+error:
+ if (image)
+ jas_image_destroy(image);
+ return 0;
+}
+
+int jas_image_encode(jas_image_t *image, jas_stream_t *out, int fmt,
+ const char *optstr)
+{+ const jas_image_fmtinfo_t *fmtinfo;
+ if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) {+ jas_eprintf("format lookup failed\n");+ return -1;
+ }
+ return (fmtinfo->ops.encode) ? (*fmtinfo->ops.encode)(image, out,
+ optstr) : (-1);
+}
+
+/******************************************************************************\
+* Component read and write operations.
+\******************************************************************************/
+
+int jas_image_readcmpt(jas_image_t *image, unsigned cmptno, jas_image_coord_t x,
+ jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
+ jas_matrix_t *data)
+{+ jas_image_cmpt_t *cmpt;
+ jas_image_coord_t i;
+ jas_image_coord_t j;
+ jas_seqent_t v;
+ int c;
+ jas_seqent_t *dr;
+ jas_seqent_t *d;
+
+ JAS_DBGLOG(100, ("jas_image_readcmpt(%p, %d, %ld, %ld, %ld, %ld, %p)\n",+ image, cmptno, JAS_CAST(long, x), JAS_CAST(long, y),
+ JAS_CAST(long, width), JAS_CAST(long, height), data));
+
+ if(data == NULL) {+ return -1;
+ }
+
+ if (cmptno >= image->numcmpts_) {+ return -1;
+ }
+
+ cmpt = image->cmpts_[cmptno];
+ if (x >= cmpt->width_ || y >= cmpt->height_ ||
+ x + width > cmpt->width_ ||
+ y + height > cmpt->height_) {+ return -1;
+ }
+
+ if (!jas_matrix_numrows(data) || !jas_matrix_numcols(data)) {+ return -1;
+ }
+
+ if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) {+ if (jas_matrix_resize(data, height, width)) {+ return -1;
+ }
+ }
+
+ jas_stream_t *const stream = cmpt->stream_;
+ const uint_least32_t cmpt_width = cmpt->width_;
+ const unsigned cps = cmpt->cps_;
+ const unsigned prec = cmpt->prec_;
+ const bool sgnd = cmpt->sgnd_;
+
+ dr = jas_matrix_getref(data, 0, 0);
+ const uint_least32_t drs = jas_matrix_rowstep(data);
+ for (i = 0; i < height; ++i, dr += drs) {+ d = dr;
+ if (jas_stream_seek(stream, (cmpt_width * (y + i) + x)
+ * cps, SEEK_SET) < 0) {+ return -1;
+ }
+
+ if (cps == 1 && !sgnd && width <= 16384) {+ /* fast path for 1 byte per sample and
+ unsigned with bulk reads */
+
+ jas_uchar buffer[16384];
+
+ if (jas_stream_read(stream, buffer, width) != width)
+ return -1;
+
+ for (j = 0; j < width; ++j)
+ d[j] = buffer[j];
+
+ continue;
+ }
+
+ for (j = width; j > 0; --j, ++d) {+ v = 0;
+ for (unsigned k = cps; k > 0; --k) {+ if ((c = jas_stream_getc(stream)) == EOF) {+ return -1;
+ }
+ v = (v << 8) | (c & 0xff);
+ }
+ *d = bitstoint(v, prec, sgnd);
+ }
+ }
+
+ return 0;
+}
+
+int jas_image_writecmpt(jas_image_t *image, unsigned cmptno, jas_image_coord_t x,
+ jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
+ const jas_matrix_t *data)
+{+ jas_image_cmpt_t *cmpt;
+ jas_image_coord_t i;
+ jas_image_coord_t j;
+ jas_seqent_t v;
+ int c;
+
+ JAS_DBGLOG(100, ("jas_image_writecmpt(%p, %d, %ld, %ld, %ld, %ld, %p)\n",+ image, cmptno, JAS_CAST(long, x), JAS_CAST(long, y),
+ JAS_CAST(long, width), JAS_CAST(long, height), data));
+
+ if (cmptno >= image->numcmpts_) {+ return -1;
+ }
+
+ cmpt = image->cmpts_[cmptno];
+ if (x >= cmpt->width_ || y >= cmpt->height_ ||
+ x + width > cmpt->width_ ||
+ y + height > cmpt->height_) {+ return -1;
+ }
+
+ if (!jas_matrix_numrows(data) || !jas_matrix_numcols(data)) {+ return -1;
+ }
+
+ if (jas_matrix_numrows(data) != height ||
+ jas_matrix_numcols(data) != width) {+ return -1;
+ }
+
+ jas_stream_t *const stream = cmpt->stream_;
+ const uint_least32_t cmpt_width = cmpt->width_;
+ const unsigned cps = cmpt->cps_;
+ const unsigned prec = cmpt->prec_;
+ const bool sgnd = cmpt->sgnd_;
+
+ const jas_seqent_t *dr = jas_matrix_getref(data, 0, 0);
+ const uint_least32_t drs = jas_matrix_rowstep(data);
+ for (i = 0; i < height; ++i, dr += drs) {+ const jas_seqent_t *d = dr;
+ if (jas_stream_seek(stream, (cmpt_width * (y + i) + x)
+ * cps, SEEK_SET) < 0) {+ return -1;
+ }
+
+ if (cps == 1 && !sgnd && width <= 16384) {+ /* fast path for 1 byte per sample and
+ unsigned with bulk writes */
+
+ jas_uchar buffer[16384];
+
+ for (j = 0; j < width; ++j)
+ buffer[j] = d[j];
+
+ jas_stream_write(stream, buffer, width);
+ continue;
+ }
+
+ for (j = width; j > 0; --j, ++d) {+ v = inttobits(*d, prec, sgnd);
+ for (unsigned k = cps; k > 0; --k) {+ c = (v >> (8 * (cps - 1))) & 0xff;
+ if (jas_stream_putc(stream,
+ (unsigned char) c) == EOF) {+ return -1;
+ }
+ v <<= 8;
+ }
+ }
+ }
+
+ return 0;
+}
+
+/******************************************************************************\
+* File format operations.
+\******************************************************************************/
+
+void jas_image_clearfmts()
+{+ jas_image_fmtinfo_t *fmtinfo;
+ for (unsigned i = 0; i < jas_image_numfmts; ++i) {+ fmtinfo = &jas_image_fmtinfos[i];
+ if (fmtinfo->name) {+ jas_free(fmtinfo->name);
+ fmtinfo->name = 0;
+ }
+ if (fmtinfo->ext) {+ jas_free(fmtinfo->ext);
+ fmtinfo->ext = 0;
+ }
+ if (fmtinfo->desc) {+ jas_free(fmtinfo->desc);
+ fmtinfo->desc = 0;
+ }
+ }
+ jas_image_numfmts = 0;
+}
+
+int jas_image_addfmt(int id, const char *name, const char *ext,
+ const char *desc, const jas_image_fmtops_t *ops)
+{+ jas_image_fmtinfo_t *fmtinfo;
+ assert(id >= 0 && name && ext && ops);
+ if (jas_image_numfmts >= JAS_IMAGE_MAXFMTS) {+ return -1;
+ }
+ fmtinfo = &jas_image_fmtinfos[jas_image_numfmts];
+ fmtinfo->id = id;
+ if (!(fmtinfo->name = jas_strdup(name))) {+ return -1;
+ }
+ if (!(fmtinfo->ext = jas_strdup(ext))) {+ jas_free(fmtinfo->name);
+ return -1;
+ }
+ if (!(fmtinfo->desc = jas_strdup(desc))) {+ jas_free(fmtinfo->name);
+ jas_free(fmtinfo->ext);
+ return -1;
+ }
+ fmtinfo->ops = *ops;
+ ++jas_image_numfmts;
+ return 0;
+}
+
+/* This is for future consideration for addition to the library API. */
+#if 0
+JAS_DLLEXPORT
+int jas_image_delfmt(int fmtid)
+{+ if (fmtid < 0 || fmtid >= JAS_CAST(int, jas_image_numfmts)) {+ return -1;
+ }
+ const jas_image_fmtinfo_t *fmtinfo;
+ if (!(fmtinfo = jas_image_lookupfmtbyid(fmtid))) {+ return -1;
+ }
+ for (int i = fmtinfo - jas_image_fmtinfos; i < JAS_CAST(int,
+ jas_image_numfmts) - 1; ++i) {+ jas_image_fmtinfos[i] = jas_image_fmtinfos[i + 1];
+ }
+ --jas_image_numfmts;
+ return 0;
+}
+#endif
+
+int jas_image_strtofmt(const char *name)
+{+ const jas_image_fmtinfo_t *fmtinfo;
+ if (!(fmtinfo = jas_image_lookupfmtbyname(name))) {+ return -1;
+ }
+ return fmtinfo->id;
+}
+
+const char *jas_image_fmttostr(int fmt)
+{+ const jas_image_fmtinfo_t *fmtinfo;
+ if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) {+ return 0;
+ }
+ return fmtinfo->name;
+}
+
+int jas_image_getfmt(jas_stream_t *in)
+{+ const jas_image_fmtinfo_t *fmtinfo;
+
+ /* Check for data in each of the supported formats. */
+ unsigned i;
+ for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i,
+ ++fmtinfo) {+ if (fmtinfo->ops.validate) {+ /* Is the input data valid for this format? */
+ JAS_DBGLOG(20, ("testing for format %s ... ", fmtinfo->name));+ if (!(*fmtinfo->ops.validate)(in)) {+ JAS_DBGLOG(20, ("test succeeded\n"));+ return fmtinfo->id;
+ }
+ JAS_DBGLOG(20, ("test failed\n"));+ }
+ }
+ return -1;
+}
+
+int jas_image_fmtfromname(const char *name)
+{+ const char *ext;
+ const jas_image_fmtinfo_t *fmtinfo;
+ /* Get the file name extension. */
+ if (!(ext = strrchr(name, '.'))) {+ return -1;
+ }
+ ++ext;
+ /* Try to find a format that uses this extension. */
+ unsigned i;
+ for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i,
+ ++fmtinfo) {+ /* Do we have a match? */
+ if (!strcmp(ext, fmtinfo->ext)) {+ return fmtinfo->id;
+ }
+ }
+ return -1;
+}
+
+/******************************************************************************\
+* Miscellaneous operations.
+\******************************************************************************/
+
+bool jas_image_cmpt_domains_same(const jas_image_t *image)
+{+ jas_image_cmpt_t *cmpt;
+ jas_image_cmpt_t *cmpt0;
+
+ cmpt0 = image->cmpts_[0];
+ for (unsigned cmptno = 1; cmptno < image->numcmpts_; ++cmptno) {+ cmpt = image->cmpts_[cmptno];
+ if (cmpt->tlx_ != cmpt0->tlx_ || cmpt->tly_ != cmpt0->tly_ ||
+ cmpt->hstep_ != cmpt0->hstep_ || cmpt->vstep_ != cmpt0->vstep_ ||
+ cmpt->width_ != cmpt0->width_ || cmpt->height_ != cmpt0->height_) {+ return 0;
+ }
+ }
+ return 1;
+}
+
+uint_fast32_t jas_image_rawsize(const jas_image_t *image)
+{+ uint_fast32_t rawsize;
+ jas_image_cmpt_t *cmpt;
+
+ rawsize = 0;
+ for (unsigned cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {+ cmpt = image->cmpts_[cmptno];
+ rawsize += (cmpt->width_ * cmpt->height_ * cmpt->prec_ +
+ 7) / 8;
+ }
+ return rawsize;
+}
+
+void jas_image_delcmpt(jas_image_t *image, unsigned cmptno)
+{+ if (cmptno >= image->numcmpts_) {+ return;
+ }
+ jas_image_cmpt_destroy(image->cmpts_[cmptno]);
+ if (cmptno < image->numcmpts_) {+ memmove(&image->cmpts_[cmptno], &image->cmpts_[cmptno + 1],
+ (image->numcmpts_ - 1 - cmptno) * sizeof(jas_image_cmpt_t *));
+ }
+ --image->numcmpts_;
+
+ jas_image_setbbox(image);
+}
+
+int jas_image_addcmpt(jas_image_t *image, int cmptno,
+ const jas_image_cmptparm_t *cmptparm)
+{+ jas_image_cmpt_t *newcmpt;
+ if (cmptno < 0) {+ cmptno = image->numcmpts_;
+ }
+ assert(cmptno >= 0 && (unsigned)cmptno <= image->numcmpts_);
+ if (image->numcmpts_ >= image->maxcmpts_) {+ if (jas_image_growcmpts(image, image->maxcmpts_ + 128)) {+ return -1;
+ }
+ }
+ if (!(newcmpt = jas_image_cmpt_create(cmptparm->tlx,
+ cmptparm->tly, cmptparm->hstep, cmptparm->vstep,
+ cmptparm->width, cmptparm->height, cmptparm->prec,
+ cmptparm->sgnd, true))) {+ return -1;
+ }
+ if ((unsigned)cmptno < image->numcmpts_) {+ memmove(&image->cmpts_[cmptno + 1], &image->cmpts_[cmptno],
+ (image->numcmpts_ - (unsigned)cmptno) * sizeof(jas_image_cmpt_t *));
+ }
+ image->cmpts_[cmptno] = newcmpt;
+ ++image->numcmpts_;
+
+ jas_image_setbbox(image);
+
+ return 0;
+}
+
+const jas_image_fmtinfo_t *jas_image_lookupfmtbyid(int id)
+{+ unsigned i;
+ const jas_image_fmtinfo_t *fmtinfo;
+
+ for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) {+ if (fmtinfo->id == id) {+ return fmtinfo;
+ }
+ }
+ return 0;
+}
+
+const jas_image_fmtinfo_t *jas_image_lookupfmtbyname(const char *name)
+{+ unsigned i;
+ const jas_image_fmtinfo_t *fmtinfo;
+
+ for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) {+ if (!strcmp(fmtinfo->name, name)) {+ return fmtinfo;
+ }
+ }
+ return 0;
+}
+
+static uint_fast32_t inttobits(jas_seqent_t v, unsigned prec, bool sgnd)
+{+ uint_fast32_t ret;
+ ret = ((sgnd && v < 0) ? ((1 << prec) + v) : v) & JAS_ONES(prec);
+ return ret;
+}
+
+static jas_seqent_t bitstoint(uint_fast32_t v, unsigned prec, bool sgnd)
+{+ jas_seqent_t ret;
+ v &= JAS_ONES(prec);
+ ret = (sgnd && (v & (1 << (prec - 1)))) ? (v - (1 << prec)) : v;
+ return ret;
+}
+
+static void jas_image_setbbox(jas_image_t *image)
+{+ jas_image_cmpt_t *cmpt;
+ int_fast32_t x;
+ int_fast32_t y;
+
+ if (image->numcmpts_ > 0) {+ /* Determine the bounding box for all of the components on the
+ reference grid (i.e., the image area) */
+ cmpt = image->cmpts_[0];
+ image->tlx_ = cmpt->tlx_;
+ image->tly_ = cmpt->tly_;
+ image->brx_ = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1;
+ image->bry_ = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1;
+ for (unsigned cmptno = 1; cmptno < image->numcmpts_; ++cmptno) {+ cmpt = image->cmpts_[cmptno];
+ if (image->tlx_ > cmpt->tlx_) {+ image->tlx_ = cmpt->tlx_;
+ }
+ if (image->tly_ > cmpt->tly_) {+ image->tly_ = cmpt->tly_;
+ }
+ x = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1;
+ if (image->brx_ < x) {+ image->brx_ = x;
+ }
+ y = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1;
+ if (image->bry_ < y) {+ image->bry_ = y;
+ }
+ }
+ } else {+ image->tlx_ = 0;
+ image->tly_ = 0;
+ image->brx_ = 0;
+ image->bry_ = 0;
+ }
+}
+
+static int jas_image_growcmpts(jas_image_t *image, unsigned maxcmpts)
+{+ jas_image_cmpt_t **newcmpts;
+
+ newcmpts = (!image->cmpts_) ? jas_alloc2(maxcmpts,
+ sizeof(jas_image_cmpt_t *)) :
+ jas_realloc2(image->cmpts_, maxcmpts, sizeof(jas_image_cmpt_t *));
+ if (!newcmpts) {+ return -1;
+ }
+ image->cmpts_ = newcmpts;
+ image->maxcmpts_ = maxcmpts;
+ for (unsigned cmptno = image->numcmpts_; cmptno < image->maxcmpts_; ++cmptno) {+ image->cmpts_[cmptno] = 0;
+ }
+ return 0;
+}
+
+int jas_image_copycmpt(jas_image_t *dstimage, unsigned dstcmptno,
+ jas_image_t *srcimage, unsigned srccmptno)
+{+ jas_image_cmpt_t *newcmpt;
+ if (dstimage->numcmpts_ >= dstimage->maxcmpts_) {+ if (jas_image_growcmpts(dstimage, dstimage->maxcmpts_ + 128)) {+ return -1;
+ }
+ }
+ if (!(newcmpt = jas_image_cmpt_copy(srcimage->cmpts_[srccmptno]))) {+ return -1;
+ }
+ if (dstcmptno < dstimage->numcmpts_) {+ memmove(&dstimage->cmpts_[dstcmptno + 1], &dstimage->cmpts_[dstcmptno],
+ (dstimage->numcmpts_ - dstcmptno) * sizeof(jas_image_cmpt_t *));
+ }
+ dstimage->cmpts_[dstcmptno] = newcmpt;
+ ++dstimage->numcmpts_;
+
+ jas_image_setbbox(dstimage);
+ return 0;
+}
+
+void jas_image_dump(jas_image_t *image, FILE *out)
+{+ long buf[1024];
+ jas_image_cmpt_t *cmpt;
+ for (unsigned cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {+ cmpt = image->cmpts_[cmptno];
+ fprintf(out, "prec=%d, sgnd=%d, cmpttype=%"PRIiFAST32"\n", cmpt->prec_,
+ cmpt->sgnd_, cmpt->type_);
+ const unsigned width = jas_image_cmptwidth(image, cmptno);
+ const unsigned height = jas_image_cmptheight(image, cmptno);
+ const unsigned n = JAS_MIN(16, width);
+ if (jas_image_readcmpt2(image, cmptno, 0, 0, n, 1, buf)) {+ abort();
+ }
+ for (unsigned i = 0; i < n; ++i) {+ fprintf(out, " f(%d,%d)=%ld", i, 0, buf[i]);
+ }
+ fprintf(out, "\n");
+ if (jas_image_readcmpt2(image, cmptno, width - n, height - 1, n, 1, buf)) {+ abort();
+ }
+ for (unsigned i = 0; i < n; ++i) {+ fprintf(out, " f(%d,%d)=%ld", width - n + i, height - 1, buf[i]);
+ }
+ fprintf(out, "\n");
+ }
+}
+
+int jas_image_depalettize(jas_image_t *image, unsigned cmptno, unsigned numlutents,
+ const int_fast32_t *lutents, unsigned dtype, unsigned newcmptno)
+{+ jas_image_cmptparm_t cmptparms;
+ const jas_image_cmpt_t *cmpt = image->cmpts_[cmptno];
+
+ const uint_least32_t width = cmpt->width_;
+ const uint_least32_t height = cmpt->height_;
+
+ cmptparms.tlx = cmpt->tlx_;
+ cmptparms.tly = cmpt->tly_;
+ cmptparms.hstep = cmpt->hstep_;
+ cmptparms.vstep = cmpt->vstep_;
+ cmptparms.width = width;
+ cmptparms.height = height;
+ cmptparms.prec = JAS_IMAGE_CDT_GETPREC(dtype);
+ cmptparms.sgnd = JAS_IMAGE_CDT_GETSGND(dtype);
+
+ if (jas_image_addcmpt(image, newcmptno, &cmptparms)) {+ return -1;
+ }
+ if (newcmptno <= cmptno) {+ ++cmptno;
+ }
+
+ for (uint_least32_t j = 0; j < height; ++j) {+ for (uint_least32_t i = 0; i < width; ++i) {+ int v = jas_image_readcmptsample(image, cmptno, i, j);
+ if (v < 0) {+ v = 0;
+ } else if ((unsigned)v >= numlutents) {+ assert(numlutents > 0);
+ v = numlutents - 1;
+ }
+ jas_image_writecmptsample(image, newcmptno, i, j,
+ lutents[v]);
+ }
+ }
+ return 0;
+}
+
+int jas_image_readcmptsample(jas_image_t *image, unsigned cmptno, unsigned x, unsigned y)
+{+ jas_image_cmpt_t *cmpt;
+ uint_fast32_t v;
+ int c;
+
+ cmpt = image->cmpts_[cmptno];
+
+ if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_,
+ SEEK_SET) < 0) {+ return -1;
+ }
+ v = 0;
+ for (unsigned k = cmpt->cps_; k > 0; --k) {+ if ((c = jas_stream_getc(cmpt->stream_)) == EOF) {+ return -1;
+ }
+ v = (v << 8) | (c & 0xff);
+ }
+ return bitstoint(v, cmpt->prec_, cmpt->sgnd_);
+}
+
+void jas_image_writecmptsample(jas_image_t *image, unsigned cmptno, unsigned x, unsigned y,
+ int_fast32_t v)
+{+ jas_image_cmpt_t *cmpt;
+ uint_fast32_t t;
+ int c;
+
+ cmpt = image->cmpts_[cmptno];
+
+ if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_,
+ SEEK_SET) < 0) {+ return;
+ }
+ t = inttobits(v, cmpt->prec_, cmpt->sgnd_);
+ for (unsigned k = cmpt->cps_; k > 0; --k) {+ c = (t >> (8 * (cmpt->cps_ - 1))) & 0xff;
+ if (jas_stream_putc(cmpt->stream_, (unsigned char) c) == EOF) {+ return;
+ }
+ t <<= 8;
+ }
+}
+
+int jas_image_getcmptbytype(const jas_image_t *image, jas_image_cmpttype_t ctype)
+{+ for (unsigned cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {+ if (image->cmpts_[cmptno]->type_ == ctype) {+ return cmptno;
+ }
+ }
+ return -1;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/***********************************************/
+/***********************************************/
+/***********************************************/
+/***********************************************/
+
+int jas_image_readcmpt2(jas_image_t *image, unsigned cmptno, jas_image_coord_t x,
+ jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
+ long *buf)
+{+ jas_image_cmpt_t *cmpt;
+ jas_image_coord_t i;
+ jas_image_coord_t j;
+ long v;
+ long *bufptr;
+
+ if (cmptno >= image->numcmpts_)
+ goto error;
+ cmpt = image->cmpts_[cmptno];
+ if (x < 0 || x >= cmpt->width_ || y < 0 || y >= cmpt->height_ ||
+ width < 0 || height < 0 || x + width > cmpt->width_ ||
+ y + height > cmpt->height_)
+ goto error;
+
+ bufptr = buf;
+ for (i = 0; i < height; ++i) {+ if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
+ * cmpt->cps_, SEEK_SET) < 0)
+ goto error;
+ for (j = 0; j < width; ++j) {+ if (getint(cmpt->stream_, cmpt->sgnd_, cmpt->prec_, &v))
+ goto error;
+ *bufptr++ = v;
+ }
+ }
+
+ return 0;
+error:
+ return -1;
+}
+
+int jas_image_writecmpt2(jas_image_t *image, unsigned cmptno, jas_image_coord_t x,
+ jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
+ const long *buf)
+{+ jas_image_cmpt_t *cmpt;
+ jas_image_coord_t i;
+ jas_image_coord_t j;
+ long v;
+
+ if (cmptno >= image->numcmpts_)
+ goto error;
+ cmpt = image->cmpts_[cmptno];
+ if (x < 0 || x >= cmpt->width_ || y < 0 || y >= cmpt->height_ ||
+ width < 0 || height < 0 || x + width > cmpt->width_ ||
+ y + height > cmpt->height_)
+ goto error;
+
+ const long *bufptr = buf;
+ for (i = 0; i < height; ++i) {+ if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
+ * cmpt->cps_, SEEK_SET) < 0)
+ goto error;
+ for (j = 0; j < width; ++j) {+ v = *bufptr++;
+ if (putint(cmpt->stream_, cmpt->sgnd_, cmpt->prec_, v))
+ goto error;
+ }
+ }
+
+ return 0;
+error:
+ return -1;
+}
+
+int jas_image_sampcmpt(jas_image_t *image, unsigned cmptno, unsigned newcmptno,
+ jas_image_coord_t ho, jas_image_coord_t vo, jas_image_coord_t hs,
+ jas_image_coord_t vs, int sgnd, unsigned prec)
+{+ jas_image_coord_t tlx;
+ jas_image_coord_t tly;
+ jas_image_coord_t brx;
+ jas_image_coord_t bry;
+ jas_image_cmptparm_t cmptparm;
+ jas_image_coord_t ax;
+ jas_image_coord_t ay;
+ jas_image_coord_t bx;
+ jas_image_coord_t by;
+ jas_image_coord_t d0;
+ jas_image_coord_t d1;
+ jas_image_coord_t d2;
+ jas_image_coord_t d3;
+ jas_image_coord_t oldx;
+ jas_image_coord_t oldy;
+ jas_image_coord_t x;
+ jas_image_coord_t y;
+ long v;
+ jas_image_coord_t cmptbrx;
+ jas_image_coord_t cmptbry;
+
+ assert(cmptno < image->numcmpts_);
+ const jas_image_cmpt_t *const oldcmpt = image->cmpts_[cmptno];
+ assert(oldcmpt->tlx_ == 0 && oldcmpt->tly_ == 0);
+ jas_image_calcbbox2(image, &tlx, &tly, &brx, &bry);
+ const unsigned width = FLOORDIV(brx - ho + hs, hs);
+ const unsigned height = FLOORDIV(bry - vo + vs, vs);
+ cmptparm.tlx = ho;
+ cmptparm.tly = vo;
+ cmptparm.hstep = hs;
+ cmptparm.vstep = vs;
+ cmptparm.width = width;
+ cmptparm.height = height;
+ cmptparm.prec = prec;
+ cmptparm.sgnd = sgnd;
+ if (jas_image_addcmpt(image, newcmptno, &cmptparm))
+ goto error;
+cmptbrx = oldcmpt->tlx_ + (oldcmpt->width_ - 1) * oldcmpt->hstep_;
+cmptbry = oldcmpt->tly_ + (oldcmpt->height_ - 1) * oldcmpt->vstep_;
+ const jas_image_cmpt_t *const newcmpt = image->cmpts_[newcmptno];
+ jas_stream_rewind(newcmpt->stream_);
+ for (unsigned i = 0; i < height; ++i) {+ y = newcmpt->tly_ + newcmpt->vstep_ * i;
+ for (unsigned j = 0; j < width; ++j) {+ x = newcmpt->tlx_ + newcmpt->hstep_ * j;
+ ax = downtomult(x - oldcmpt->tlx_, oldcmpt->hstep_) + oldcmpt->tlx_;
+ ay = downtomult(y - oldcmpt->tly_, oldcmpt->vstep_) + oldcmpt->tly_;
+ bx = uptomult(x - oldcmpt->tlx_, oldcmpt->hstep_) + oldcmpt->tlx_;
+ if (bx > cmptbrx)
+ bx = cmptbrx;
+ by = uptomult(y - oldcmpt->tly_, oldcmpt->vstep_) + oldcmpt->tly_;
+ if (by > cmptbry)
+ by = cmptbry;
+ d0 = (ax - x) * (ax - x) + (ay - y) * (ay - y);
+ d1 = (bx - x) * (bx - x) + (ay - y) * (ay - y);
+ d2 = (bx - x) * (bx - x) + (by - y) * (by - y);
+ d3 = (ax - x) * (ax - x) + (by - y) * (by - y);
+ if (d0 <= d1 && d0 <= d2 && d0 <= d3) {+ oldx = (ax - oldcmpt->tlx_) / oldcmpt->hstep_;
+ oldy = (ay - oldcmpt->tly_) / oldcmpt->vstep_;
+ } else if (d1 <= d0 && d1 <= d2 && d1 <= d3) {+ oldx = (bx - oldcmpt->tlx_) / oldcmpt->hstep_;
+ oldy = (ay - oldcmpt->tly_) / oldcmpt->vstep_;
+ } else if (d2 <= d0 && d2 <= d1 && d1 <= d3) {+ oldx = (bx - oldcmpt->tlx_) / oldcmpt->hstep_;
+ oldy = (by - oldcmpt->tly_) / oldcmpt->vstep_;
+ } else {+ oldx = (ax - oldcmpt->tlx_) / oldcmpt->hstep_;
+ oldy = (by - oldcmpt->tly_) / oldcmpt->vstep_;
+ }
+ assert(oldx >= 0 && oldx < oldcmpt->width_ &&
+ oldy >= 0 && oldy < oldcmpt->height_);
+ if (jas_stream_seek(oldcmpt->stream_, oldcmpt->cps_ *
+ (oldy * oldcmpt->width_ + oldx), SEEK_SET) < 0)
+ goto error;
+ if (getint(oldcmpt->stream_, oldcmpt->sgnd_,
+ oldcmpt->prec_, &v))
+ goto error;
+ if (newcmpt->prec_ != oldcmpt->prec_ ||
+ newcmpt->sgnd_ != oldcmpt->sgnd_) {+ v = convert(v, oldcmpt->sgnd_, oldcmpt->prec_,
+ newcmpt->sgnd_, newcmpt->prec_);
+ }
+ if (putint(newcmpt->stream_, newcmpt->sgnd_,
+ newcmpt->prec_, v))
+ goto error;
+ }
+ }
+ return 0;
+error:
+ return -1;
+}
+
+int jas_image_ishomosamp(const jas_image_t *image)
+{+ jas_image_coord_t hstep;
+ jas_image_coord_t vstep;
+ int result;
+ hstep = jas_image_cmpthstep(image, 0);
+ vstep = jas_image_cmptvstep(image, 0);
+ result = 1;
+ for (unsigned i = 0; i < image->numcmpts_; ++i) {+ if (jas_image_cmpthstep(image, i) != hstep ||
+ jas_image_cmptvstep(image, i) != vstep) {+ result = 0;
+ break;
+ }
+ }
+ return result;
+}
+
+/* Note: This function defines a bounding box differently. */
+static void jas_image_calcbbox2(const jas_image_t *image, jas_image_coord_t *tlx,
+ jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry)
+{+ jas_image_coord_t tmptlx;
+ jas_image_coord_t tmptly;
+ jas_image_coord_t tmpbrx;
+ jas_image_coord_t tmpbry;
+ jas_image_coord_t t;
+ if (image->numcmpts_ > 0) {+ const jas_image_cmpt_t *cmpt = image->cmpts_[0];
+ tmptlx = cmpt->tlx_;
+ tmptly = cmpt->tly_;
+ tmpbrx = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1);
+ tmpbry = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1);
+ for (unsigned i = 0; i < image->numcmpts_; ++i) {+ cmpt = image->cmpts_[i];
+ if (cmpt->tlx_ < tmptlx)
+ tmptlx = cmpt->tlx_;
+ if (cmpt->tly_ < tmptly)
+ tmptly = cmpt->tly_;
+ t = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1);
+ if (t > tmpbrx)
+ tmpbrx = t;
+ t = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1);
+ if (t > tmpbry)
+ tmpbry = t;
+ }
+ } else {+ tmptlx = 0;
+ tmptly = 0;
+ tmpbrx = -1;
+ tmpbry = -1;
+ }
+ *tlx = tmptlx;
+ *tly = tmptly;
+ *brx = tmpbrx;
+ *bry = tmpbry;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline long decode_twos_comp(jas_ulong c, unsigned prec)
+{+ long result;
+ assert(prec >= 2);
+ jas_eprintf("warning: support for signed data is untested\n");+ // NOTE: Is this correct?
+ result = (c & ((1 << (prec - 1)) - 1)) - (c & (1 << (prec - 1)));
+ return result;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jas_ulong encode_twos_comp(long n, unsigned prec)
+{+ jas_ulong result;
+ assert(prec >= 2);
+ jas_eprintf("warning: support for signed data is untested\n");+ // NOTE: Is this correct?
+ if (n < 0) {+ result = -n;
+ result = (result ^ 0xffffffffUL) + 1;
+ result &= (1 << prec) - 1;
+ } else {+ result = n;
+ }
+ return result;
+}
+
+static int getint(jas_stream_t *in, bool sgnd, unsigned prec, long *val)
+{+ long v;
+ int c;
+ assert((!sgnd && prec >= 1) || (sgnd && prec >= 2));
+ v = 0;
+ for (unsigned n = (prec + 7) / 8; n-- > 0;) {+ if ((c = jas_stream_getc(in)) == EOF)
+ return -1;
+ v = (v << 8) | c;
+ }
+ v &= ((1 << prec) - 1);
+ if (sgnd) {+ *val = decode_twos_comp(v, prec);
+ } else {+ *val = v;
+ }
+ return 0;
+}
+
+static int putint(jas_stream_t *out, bool sgnd, unsigned prec, long val)
+{+ int c;
+ assert((!sgnd && prec >= 1) || (sgnd && prec >= 2));
+ if (sgnd) {+ val = encode_twos_comp(val, prec);
+ }
+ assert(val >= 0);
+ val &= (1 << prec) - 1;
+ for (unsigned n = (prec + 7) / 8; n-- > 0;) {+ c = (val >> (n * 8)) & 0xff;
+ if (jas_stream_putc(out, c) != c)
+ return -1;
+ }
+ return 0;
+}
+
+static long convert(long val, bool oldsgnd, unsigned oldprec, bool newsgnd,
+ unsigned newprec)
+{+ if (newsgnd != oldsgnd) {+ }
+ if (newprec != oldprec) {+ if (newprec > oldprec) {+ val <<= newprec - oldprec;
+ } else if (oldprec > newprec) {+ val >>= oldprec - newprec;
+ }
+ }
+ return val;
+}
+
+static long downtomult(long x, long y)
+{+ assert(x >= 0);
+ return (x / y) * y;
+}
+
+static long uptomult(long x, long y)
+{+ assert(x >= 0);
+ return ((x + y - 1) / y) * y;
+}
+
+jas_image_t *jas_image_chclrspc(jas_image_t *image, const jas_cmprof_t *outprof,
+ jas_cmxform_intent_t intent)
+{+ jas_image_t *inimage;
+ int k;
+ jas_image_t *outimage;
+ jas_cmprof_t *inprof;
+ jas_cmprof_t *tmpprof;
+ jas_image_cmptparm_t cmptparm;
+ jas_cmxform_t *xform;
+ jas_cmpixmap_t inpixmap;
+ jas_cmpixmap_t outpixmap;
+ jas_cmcmptfmt_t *incmptfmts;
+ jas_cmcmptfmt_t *outcmptfmts;
+
+#if 0
+jas_eprintf("IMAGE\n");+jas_image_dump(image, stderr);
+#endif
+
+ if (image->numcmpts_ == 0)
+ /* can't work with a file with no components;
+ continuing would crash because we'd attempt to
+ obtain information about the first component */
+ return NULL;
+
+ outimage = 0;
+ xform = 0;
+ if (!(inimage = jas_image_copy(image)))
+ goto error;
+
+ if (!jas_image_ishomosamp(inimage)) {+ unsigned minhstep = jas_image_cmpthstep(inimage, 0);
+ unsigned minvstep = jas_image_cmptvstep(inimage, 0);
+ for (unsigned i = 1; i < jas_image_numcmpts(inimage); ++i) {+ const unsigned hstep = jas_image_cmpthstep(inimage, i);
+ const unsigned vstep = jas_image_cmptvstep(inimage, i);
+ if (hstep < minhstep) {+ minhstep = hstep;
+ }
+ if (vstep < minvstep) {+ minvstep = vstep;
+ }
+ }
+ unsigned n = jas_image_numcmpts(inimage);
+ for (unsigned i = 0; i < n; ++i) {+ if (jas_image_sampcmpt(inimage, i, i + 1, 0, 0, minhstep, minvstep,
+ jas_image_cmptsgnd(inimage, i), jas_image_cmptprec(inimage, i))) {+ goto error;
+ }
+ const jas_image_cmpttype_t cmpttype = jas_image_cmpttype(inimage, i);
+ jas_image_setcmpttype(inimage, i + 1, cmpttype);
+ jas_image_delcmpt(inimage, i);
+ }
+ }
+
+ const unsigned width = jas_image_cmptwidth(inimage, 0);
+ const unsigned height = jas_image_cmptheight(inimage, 0);
+ const unsigned hstep = jas_image_cmpthstep(inimage, 0);
+ const unsigned vstep = jas_image_cmptvstep(inimage, 0);
+
+ if (!(inprof = jas_image_cmprof(inimage))) {+ abort();
+ }
+ const unsigned numinclrchans = jas_clrspc_numchans(jas_cmprof_clrspc(inprof));
+ const unsigned numoutclrchans = jas_clrspc_numchans(jas_cmprof_clrspc(outprof));
+ const unsigned prec = 8;
+
+ if (!(outimage = jas_image_create0())) {+ goto error;
+ }
+
+ /* Create a component for each of the colorants. */
+ for (unsigned i = 0; i < numoutclrchans; ++i) {+ cmptparm.tlx = 0;
+ cmptparm.tly = 0;
+ cmptparm.hstep = hstep;
+ cmptparm.vstep = vstep;
+ cmptparm.width = width;
+ cmptparm.height = height;
+ cmptparm.prec = prec;
+ cmptparm.sgnd = 0;
+ if (jas_image_addcmpt(outimage, -1, &cmptparm))
+ goto error;
+ jas_image_setcmpttype(outimage, i, JAS_IMAGE_CT_COLOR(i));
+ }
+#if 0
+ /* Copy the auxiliary components without modification. */
+ for (i = 0; i < jas_image_numcmpts(inimage); ++i) {+ if (!ISCOLOR(jas_image_cmpttype(inimage, i))) {+ jas_image_copycmpt(outimage, -1, inimage, i);
+/* XXX - need to specify laydown of component on ref. grid */
+ }
+ }
+#endif
+
+ if (!(tmpprof = jas_cmprof_copy(outprof)))
+ goto error;
+ assert(!jas_image_cmprof(outimage));
+ jas_image_setcmprof(outimage, tmpprof);
+ jas_image_setclrspc(outimage, jas_cmprof_clrspc(outprof));
+
+ if (!(xform = jas_cmxform_create(inprof, outprof, 0, JAS_CMXFORM_OP_FWD,
+ intent, JAS_CMXFORM_OPTM_SPEED))) {+ goto error;
+ }
+
+ inpixmap.numcmpts = numinclrchans;
+ if (!(incmptfmts = jas_alloc2(numinclrchans, sizeof(jas_cmcmptfmt_t)))) {+ abort();
+ }
+ inpixmap.cmptfmts = incmptfmts;
+ for (unsigned i = 0; i < numinclrchans; ++i) {+ const int j = jas_image_getcmptbytype(inimage, JAS_IMAGE_CT_COLOR(i));
+ if (!(incmptfmts[i].buf = jas_alloc2(width, sizeof(long)))) {+ goto error;
+ }
+ incmptfmts[i].prec = jas_image_cmptprec(inimage, j);
+ incmptfmts[i].sgnd = jas_image_cmptsgnd(inimage, j);
+ incmptfmts[i].width = width;
+ incmptfmts[i].height = 1;
+ }
+
+ outpixmap.numcmpts = numoutclrchans;
+ if (!(outcmptfmts = jas_alloc2(numoutclrchans, sizeof(jas_cmcmptfmt_t)))) {+ abort();
+ }
+ outpixmap.cmptfmts = outcmptfmts;
+
+ for (unsigned i = 0; i < numoutclrchans; ++i) {+ const int j = jas_image_getcmptbytype(outimage, JAS_IMAGE_CT_COLOR(i));
+ if (!(outcmptfmts[i].buf = jas_alloc2(width, sizeof(long))))
+ goto error;
+ outcmptfmts[i].prec = jas_image_cmptprec(outimage, j);
+ outcmptfmts[i].sgnd = jas_image_cmptsgnd(outimage, j);
+ outcmptfmts[i].width = width;
+ outcmptfmts[i].height = 1;
+ }
+
+ for (unsigned i = 0; i < height; ++i) {+ for (unsigned j = 0; j < numinclrchans; ++j) {+ k = jas_image_getcmptbytype(inimage, JAS_IMAGE_CT_COLOR(j));
+ if (jas_image_readcmpt2(inimage, k, 0, i, width, 1,
+ incmptfmts[j].buf))
+ goto error;
+ }
+ jas_cmxform_apply(xform, &inpixmap, &outpixmap);
+ for (unsigned j = 0; j < numoutclrchans; ++j) {+ k = jas_image_getcmptbytype(outimage, JAS_IMAGE_CT_COLOR(j));
+ if (jas_image_writecmpt2(outimage, k, 0, i, width, 1,
+ outcmptfmts[j].buf))
+ goto error;
+ }
+ }
+
+ for (unsigned i = 0; i < numoutclrchans; ++i) {+ jas_free(outcmptfmts[i].buf);
+ }
+ jas_free(outcmptfmts);
+ for (unsigned i = 0; i < numinclrchans; ++i) {+ jas_free(incmptfmts[i].buf);
+ }
+ jas_free(incmptfmts);
+ jas_cmxform_destroy(xform);
+ jas_image_destroy(inimage);
+
+#if 0
+jas_eprintf("INIMAGE\n");+jas_image_dump(inimage, stderr);
+jas_eprintf("OUTIMAGE\n");+jas_image_dump(outimage, stderr);
+#endif
+ return outimage;
+error:
+ if (xform)
+ jas_cmxform_destroy(xform);
+ if (inimage)
+ jas_image_destroy(inimage);
+ if (outimage)
+ jas_image_destroy(outimage);
+ return 0;
+}
--- /dev/null
+++ b/jas_init.c
@@ -1,0 +1,107 @@
+/*
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_init.h"
+#include "jasper/jas_image.h"
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+/* Initialize the image format table. */
+JAS_DLLEXPORT
+int jas_init(void)
+{+ jas_image_fmtops_t fmtops;
+ int fmtid = 0;
+
+#if defined(JAS_INCLUDE_JP2_CODEC)
+ fmtops.decode = jp2_decode;
+ fmtops.validate = jp2_validate;
+ jas_image_addfmt(fmtid++, "jp2", "jp2",
+ "JPEG-2000 JP2 File Format Syntax (ISO/IEC 15444-1)", &fmtops);
+#endif
+
+#if defined(JAS_INCLUDE_JPC_CODEC) || defined(JAS_INCLUDE_JP2_CODEC)
+ fmtops.decode = jpc_decode;
+ fmtops.validate = jpc_validate;
+ jas_image_addfmt(fmtid, "jpc", "jpc",
+ "JPEG-2000 Code Stream Syntax (ISO/IEC 15444-1)", &fmtops);
+#endif
+
+ /* We must not register the JasPer library exit handler until after
+ at least one memory allocation is performed. This is desirable
+ as it ensures that the JasPer exit handler is called before the
+ debug memory allocator exit handler. */
+ atexit(jas_cleanup);
+
+ return 0;
+}
+
+JAS_DLLEXPORT
+void jas_cleanup(void)
+{+ jas_image_clearfmts();
+}
--- /dev/null
+++ b/jas_malloc.c
@@ -1,0 +1,299 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Memory Allocator
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_debug.h"
+#include "jasper/jas_math.h"
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+#if defined(JAS_DEFAULT_MAX_MEM_USAGE)
+
+static size_t jas_mem = 0;
+static size_t jas_max_mem = JAS_DEFAULT_MAX_MEM_USAGE;
+
+typedef struct {+ size_t size;
+} jas_mb_t;
+
+#define JAS_MB_ADJUST \
+ ((sizeof(jas_mb_t) + sizeof(max_align_t) - 1) / sizeof(max_align_t))
+#define JAS_MB_SIZE (JAS_MB_ADJUST * sizeof(max_align_t))
+
+jas_mb_t *jas_get_mb(void *ptr)
+{+ return JAS_CAST(jas_mb_t *, JAS_CAST(max_align_t *, ptr) - JAS_MB_ADJUST);
+}
+
+void *jas_mb_get_data(jas_mb_t *mb)
+{+ return JAS_CAST(void *, JAS_CAST(max_align_t *, mb) + JAS_MB_ADJUST);
+}
+
+void jas_set_max_mem_usage(size_t max_mem)
+{+ jas_max_mem = max_mem;
+}
+
+size_t jas_get_mem_usage()
+{+ return jas_mem;
+}
+
+void *jas_malloc(size_t size)
+{+ void *result;
+ jas_mb_t *mb;
+ size_t ext_size;
+ size_t mem;
+
+ JAS_DBGLOG(100, ("jas_malloc(%zu)\n", size));+#if defined(JAS_MALLOC_RETURN_NULL_PTR_FOR_ZERO_SIZE)
+ if (!size) {+ return 0;
+ }
+#endif
+ if (!jas_safe_size_add(size, JAS_MB_SIZE, &ext_size)) {+ jas_eprintf("requested memory size is too large\n");+ result = 0;
+ mb = 0;
+ } else if (!jas_safe_size_add(jas_mem, size, &mem) || mem > jas_max_mem) {+ jas_eprintf("maximum memory limit would be exceeded\n");+ result = 0;
+ mb = 0;
+ } else {+ JAS_DBGLOG(100, ("jas_malloc: ext_size=%zu\n", ext_size));+ if ((mb = malloc(ext_size))) {+ result = jas_mb_get_data(mb);
+ mb->size = size;
+ jas_mem = mem;
+ } else {+ result = 0;
+ }
+ }
+ JAS_DBGLOG(99, ("jas_malloc(%zu) -> %p (mb=%p)\n", size, result, mb));+ JAS_DBGLOG(102, ("max_mem=%zu; mem=%zu\n", jas_max_mem, jas_mem));+ return result;
+}
+
+void *jas_realloc(void *ptr, size_t size)
+{+ void *result;
+ jas_mb_t *mb;
+ jas_mb_t *old_mb;
+ size_t old_size;
+ size_t ext_size;
+ size_t mem;
+
+ JAS_DBGLOG(100, ("jas_realloc(%p, %zu)\n", ptr, size));+ if (!ptr) {+ return jas_malloc(size);
+ }
+ if (ptr && !size) {+ jas_free(ptr);
+ }
+ if (!jas_safe_size_add(size, JAS_MB_SIZE, &ext_size)) {+ jas_eprintf("requested memory size is too large\n");+ return 0;
+ }
+ old_mb = jas_get_mb(ptr);
+ old_size = old_mb->size;
+ JAS_DBGLOG(101, ("jas_realloc: old_mb=%p; old_size=%zu\n", old_mb,+ old_size));
+ if (size > old_size) {+ if (!jas_safe_size_add(jas_mem, ext_size, &mem) || mem > jas_max_mem) {+ jas_eprintf("maximum memory limit would be exceeded\n");+ return 0;
+ }
+ } else {+ if (!jas_safe_size_sub(jas_mem, old_size - size, &jas_mem)) {+ jas_eprintf("heap corruption detected\n");+ abort();
+ }
+ }
+ JAS_DBGLOG(100, ("jas_realloc: realloc(%p, %zu)\n", old_mb, ext_size));+ if (!(mb = realloc(old_mb, ext_size))) {+ result = 0;
+ } else {+ result = jas_mb_get_data(mb);
+ mb->size = size;
+ jas_mem = mem;
+ }
+ JAS_DBGLOG(100, ("jas_realloc(%p, %zu) -> %p (%p)\n", ptr, size, result,+ mb));
+ JAS_DBGLOG(102, ("max_mem=%zu; mem=%zu\n", jas_max_mem, jas_mem));+ return result;
+}
+
+void jas_free(void *ptr)
+{+ jas_mb_t *mb;
+ size_t mem;
+ size_t size;
+ JAS_DBGLOG(100, ("jas_free(%p)\n", ptr));+ if (ptr) {+ mb = jas_get_mb(ptr);
+ size = mb->size;
+ JAS_DBGLOG(101, ("jas_free(%p) (mb=%p; size=%zu)\n", ptr, mb, size));+ if (!jas_safe_size_sub(jas_mem, size, &jas_mem)) {+ jas_eprintf("heap corruption detected\n");+ abort();
+ }
+ JAS_DBGLOG(100, ("jas_free: free(%p)\n", mb));+ free(mb);
+ }
+ JAS_DBGLOG(102, ("max_mem=%zu; mem=%zu\n", jas_max_mem, jas_mem));+}
+
+#endif
+
+/******************************************************************************\
+* Basic memory allocation and deallocation primitives.
+\******************************************************************************/
+
+#if !defined(JAS_DEFAULT_MAX_MEM_USAGE)
+
+void *jas_malloc(size_t size)
+{+ void *result;
+ JAS_DBGLOG(101, ("jas_malloc(%zu)\n", size));+ result = malloc(size);
+ JAS_DBGLOG(100, ("jas_malloc(%zu) -> %p\n", size, result));+ return result;
+}
+
+void *jas_realloc(void *ptr, size_t size)
+{+ void *result;
+ JAS_DBGLOG(101, ("jas_realloc(%p, %zu)\n", ptr, size));+ result = realloc(ptr, size);
+ JAS_DBGLOG(100, ("jas_realloc(%p, %zu) -> %p\n", ptr, size, result));+ return result;
+}
+
+void jas_free(void *ptr)
+{+ JAS_DBGLOG(100, ("jas_free(%p)\n", ptr));+ free(ptr);
+}
+
+#endif
+
+/******************************************************************************\
+* Additional memory allocation and deallocation primitives
+* (mainly for overflow checking).
+\******************************************************************************/
+
+void *jas_alloc2(size_t num_elements, size_t element_size)
+{+ size_t size;
+ if (!jas_safe_size_mul(num_elements, element_size, &size)) {+ return 0;
+ }
+ return jas_malloc(size);
+}
+
+void *jas_alloc3(size_t num_arrays, size_t array_size, size_t element_size)
+{+ size_t size;
+ if (!jas_safe_size_mul(array_size, element_size, &size) ||
+ !jas_safe_size_mul(size, num_arrays, &size)) {+ return 0;
+ }
+ return jas_malloc(size);
+}
+
+void *jas_realloc2(void *ptr, size_t num_elements, size_t element_size)
+{+ size_t size;
+ if (!jas_safe_size_mul(num_elements, element_size, &size)) {+ return 0;
+ }
+ return jas_realloc(ptr, size);
+}
+
+void *jas_calloc(size_t num_elements, size_t element_size)
+{+ void *ptr;
+ size_t size;
+ if (!jas_safe_size_mul(num_elements, element_size, &size)) {+ return 0;
+ }
+ if (!(ptr = jas_malloc(size))) {+ return 0;
+ }
+ memset(ptr, 0, size);
+ return ptr;
+}
--- /dev/null
+++ b/jas_seq.c
@@ -1,0 +1,408 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Sequence/Matrix Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_seq.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_math.h"
+
+/******************************************************************************\
+* Constructors and destructors.
+\******************************************************************************/
+
+jas_matrix_t *jas_seq2d_create(jas_matind_t xstart, jas_matind_t ystart,
+ jas_matind_t xend, jas_matind_t yend)
+{+ jas_matrix_t *matrix;
+ assert(xstart <= xend && ystart <= yend);
+ if (!(matrix = jas_matrix_create(yend - ystart, xend - xstart))) {+ return 0;
+ }
+ matrix->xstart_ = xstart;
+ matrix->ystart_ = ystart;
+ matrix->xend_ = xend;
+ matrix->yend_ = yend;
+ return matrix;
+}
+
+jas_matrix_t *jas_matrix_create(jas_matind_t numrows, jas_matind_t numcols)
+{+ jas_matrix_t *matrix;
+ jas_matind_t i;
+ size_t size;
+
+ if (numrows < 0 || numcols < 0) {+ return NULL;
+ }
+
+ // matrix->datasize_ = numrows * numcols;
+ if (!jas_safe_size_mul(numrows, numcols, &size)) {+ return NULL;
+ }
+
+ if (!(matrix = jas_malloc(sizeof(jas_matrix_t)))) {+ return NULL;
+ }
+ matrix->flags_ = 0;
+ matrix->numrows_ = numrows;
+ matrix->numcols_ = numcols;
+ matrix->rows_ = 0;
+ matrix->maxrows_ = numrows;
+ matrix->data_ = 0;
+ matrix->datasize_ = size;
+
+ if (matrix->maxrows_ > 0) {+ if (!(matrix->rows_ = jas_alloc2(matrix->maxrows_,
+ sizeof(jas_seqent_t *)))) {+ goto error;
+ }
+ }
+
+ if (matrix->datasize_ > 0) {+ if (!(matrix->data_ = jas_alloc2(matrix->datasize_,
+ sizeof(jas_seqent_t)))) {+ goto error;
+ }
+
+ memset(matrix->data_, 0,
+ matrix->datasize_ * sizeof(jas_seqent_t));
+ }
+
+ for (i = 0; i < numrows; ++i) {+ matrix->rows_[i] = &matrix->data_[i * matrix->numcols_];
+ }
+
+ matrix->xstart_ = 0;
+ matrix->ystart_ = 0;
+ matrix->xend_ = matrix->numcols_;
+ matrix->yend_ = matrix->numrows_;
+
+ return matrix;
+
+error:
+ jas_matrix_destroy(matrix);
+ return 0;
+}
+
+void jas_matrix_destroy(jas_matrix_t *matrix)
+{+ if (matrix->data_) {+ assert(!(matrix->flags_ & JAS_MATRIX_REF));
+ }
+ jas_free(matrix->data_);
+ jas_free(matrix->rows_);
+ jas_free(matrix);
+}
+
+jas_seq2d_t *jas_seq2d_copy(jas_seq2d_t *x)
+{+ jas_matrix_t *y;
+ jas_matind_t i;
+ jas_matind_t j;
+ y = jas_seq2d_create(jas_seq2d_xstart(x), jas_seq2d_ystart(x),
+ jas_seq2d_xend(x), jas_seq2d_yend(x));
+ assert(y);
+ for (i = 0; i < x->numrows_; ++i) {+ for (j = 0; j < x->numcols_; ++j) {+ *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j);
+ }
+ }
+ return y;
+}
+
+jas_matrix_t *jas_matrix_copy(jas_matrix_t *x)
+{+ jas_matrix_t *y;
+ jas_matind_t i;
+ jas_matind_t j;
+ y = jas_matrix_create(x->numrows_, x->numcols_);
+ for (i = 0; i < x->numrows_; ++i) {+ for (j = 0; j < x->numcols_; ++j) {+ *jas_matrix_getref(y, i, j) = jas_matrix_get(x, i, j);
+ }
+ }
+ return y;
+}
+
+/******************************************************************************\
+* Bind operations.
+\******************************************************************************/
+
+int jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, jas_matind_t xstart,
+ jas_matind_t ystart, jas_matind_t xend, jas_matind_t yend)
+{+ if (xstart < s1->xstart_ || ystart < s1->ystart_ ||
+ xend > s1->xend_ || yend > s1->yend_)
+ return -1;
+
+ return jas_matrix_bindsub(s, s1, ystart - s1->ystart_, xstart - s1->xstart_,
+ yend - s1->ystart_ - 1, xend - s1->xstart_ - 1);
+}
+
+int jas_matrix_bindsub(jas_matrix_t *mat0, jas_matrix_t *mat1,
+ jas_matind_t r0, jas_matind_t c0, jas_matind_t r1, jas_matind_t c1)
+{+ jas_matind_t i;
+
+ if (mat0->data_) {+ if (!(mat0->flags_ & JAS_MATRIX_REF)) {+ jas_free(mat0->data_);
+ }
+ mat0->data_ = 0;
+ mat0->datasize_ = 0;
+ }
+ if (mat0->rows_) {+ jas_free(mat0->rows_);
+ mat0->rows_ = 0;
+ }
+ mat0->flags_ |= JAS_MATRIX_REF;
+ mat0->numrows_ = r1 - r0 + 1;
+ mat0->numcols_ = c1 - c0 + 1;
+ mat0->maxrows_ = mat0->numrows_;
+ if (!(mat0->rows_ = jas_alloc2(mat0->maxrows_, sizeof(jas_seqent_t *)))) {+ return -1;
+ }
+
+ for (i = 0; i < mat0->numrows_; ++i) {+ mat0->rows_[i] = mat1->rows_[r0 + i] + c0;
+ }
+
+ mat0->xstart_ = mat1->xstart_ + c0;
+ mat0->ystart_ = mat1->ystart_ + r0;
+ mat0->xend_ = mat0->xstart_ + mat0->numcols_;
+ mat0->yend_ = mat0->ystart_ + mat0->numrows_;
+
+ return 0;
+}
+
+/******************************************************************************\
+* Arithmetic operations.
+\******************************************************************************/
+
+int jas_matrix_cmp(jas_matrix_t *mat0, jas_matrix_t *mat1)
+{+ jas_matind_t i;
+ jas_matind_t j;
+
+ if (mat0->numrows_ != mat1->numrows_ || mat0->numcols_ !=
+ mat1->numcols_) {+ return 1;
+ }
+ for (i = 0; i < mat0->numrows_; i++) {+ for (j = 0; j < mat0->numcols_; j++) {+ if (jas_matrix_get(mat0, i, j) != jas_matrix_get(mat1, i, j)) {+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+void jas_matrix_divpow2(jas_matrix_t *matrix, unsigned n)
+{+ jas_matind_t i;
+ jas_matind_t j;
+ jas_seqent_t *rowstart;
+ jas_matind_t rowstep;
+ jas_seqent_t *data;
+
+ if (jas_matrix_numrows(matrix) > 0 && jas_matrix_numcols(matrix) > 0) {+ assert(matrix->rows_);
+ rowstep = jas_matrix_rowstep(matrix);
+ for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+ rowstart += rowstep) {+ for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+ ++data) {+ *data = (*data >= 0) ? ((*data) >> n) :
+ (-((-(*data)) >> n));
+ }
+ }
+ }
+}
+
+void jas_matrix_clip(jas_matrix_t *matrix, jas_seqent_t minval,
+ jas_seqent_t maxval)
+{+ jas_matind_t i;
+ jas_matind_t j;
+ jas_seqent_t v;
+ jas_seqent_t *rowstart;
+ jas_seqent_t *data;
+ jas_matind_t rowstep;
+
+ if (jas_matrix_numrows(matrix) > 0 && jas_matrix_numcols(matrix) > 0) {+ assert(matrix->rows_);
+ rowstep = jas_matrix_rowstep(matrix);
+ for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+ rowstart += rowstep) {+ for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+ ++data) {+ v = *data;
+ if (v < minval) {+ *data = minval;
+ } else if (v > maxval) {+ *data = maxval;
+ }
+ }
+ }
+ }
+}
+
+void jas_matrix_asr(jas_matrix_t *matrix, unsigned n)
+{+ jas_matind_t i;
+ jas_matind_t j;
+ jas_seqent_t *rowstart;
+ jas_matind_t rowstep;
+ jas_seqent_t *data;
+
+ if (jas_matrix_numrows(matrix) > 0 && jas_matrix_numcols(matrix) > 0) {+ assert(matrix->rows_);
+ rowstep = jas_matrix_rowstep(matrix);
+ for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+ rowstart += rowstep) {+ for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+ ++data) {+ //*data >>= n;
+ *data = jas_seqent_asr(*data, n);
+ }
+ }
+ }
+}
+
+void jas_matrix_asl(jas_matrix_t *matrix, unsigned n)
+{+ jas_matind_t i;
+ jas_matind_t j;
+ jas_seqent_t *rowstart;
+ jas_matind_t rowstep;
+ jas_seqent_t *data;
+
+ if (jas_matrix_numrows(matrix) > 0 && jas_matrix_numcols(matrix) > 0) {+ assert(matrix->rows_);
+ rowstep = jas_matrix_rowstep(matrix);
+ for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+ rowstart += rowstep) {+ for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+ ++data) {+ //*data <<= n;
+ *data = jas_seqent_asl(*data, n);
+ }
+ }
+ }
+}
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+int jas_matrix_resize(jas_matrix_t *matrix, jas_matind_t numrows,
+ jas_matind_t numcols)
+{+ jas_matind_t size;
+ jas_matind_t i;
+
+ size = numrows * numcols;
+ if (size > matrix->datasize_ || numrows > matrix->maxrows_) {+ return -1;
+ }
+
+ matrix->numrows_ = numrows;
+ matrix->numcols_ = numcols;
+
+ for (i = 0; i < numrows; ++i) {+ matrix->rows_[i] = &matrix->data_[numcols * i];
+ }
+
+ return 0;
+}
+
+void jas_matrix_setall(jas_matrix_t *matrix, jas_seqent_t val)
+{+ jas_matind_t i;
+ jas_matind_t j;
+ jas_seqent_t *rowstart;
+ jas_matind_t rowstep;
+ jas_seqent_t *data;
+
+ if (jas_matrix_numrows(matrix) > 0 && jas_matrix_numcols(matrix) > 0) {+ assert(matrix->rows_);
+ rowstep = jas_matrix_rowstep(matrix);
+ for (i = matrix->numrows_, rowstart = matrix->rows_[0]; i > 0; --i,
+ rowstart += rowstep) {+ for (j = matrix->numcols_, data = rowstart; j > 0; --j,
+ ++data) {+ *data = val;
+ }
+ }
+ }
+}
--- /dev/null
+++ b/jas_stream.c
@@ -1,0 +1,1454 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * I/O Stream Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_stream.h"
+#include "jasper/jas_debug.h"
+#include "jasper/jas_types.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_math.h"
+
+/******************************************************************************\
+* Local function prototypes.
+\******************************************************************************/
+
+static int jas_strtoopenmode(const char *s);
+static void jas_stream_destroy(jas_stream_t *stream);
+static jas_stream_t *jas_stream_create(void);
+static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
+ int bufsize);
+
+static int mem_read(jas_stream_obj_t *obj, char *buf, unsigned cnt);
+static int mem_write(jas_stream_obj_t *obj, const char *buf, unsigned cnt);
+static long mem_seek(jas_stream_obj_t *obj, long offset, int origin);
+static int mem_close(jas_stream_obj_t *obj);
+
+static int sfile_read(jas_stream_obj_t *obj, char *buf, unsigned cnt);
+static int sfile_write(jas_stream_obj_t *obj, const char *buf, unsigned cnt);
+static long sfile_seek(jas_stream_obj_t *obj, long offset, int origin);
+static int sfile_close(jas_stream_obj_t *obj);
+
+static int file_read(jas_stream_obj_t *obj, char *buf, unsigned cnt);
+static int file_write(jas_stream_obj_t *obj, const char *buf, unsigned cnt);
+static long file_seek(jas_stream_obj_t *obj, long offset, int origin);
+static int file_close(jas_stream_obj_t *obj);
+
+/******************************************************************************\
+* Local data.
+\******************************************************************************/
+
+static const jas_stream_ops_t jas_stream_fileops = {+ file_read,
+ file_write,
+ file_seek,
+ file_close
+};
+
+static const jas_stream_ops_t jas_stream_sfileops = {+ sfile_read,
+ sfile_write,
+ sfile_seek,
+ sfile_close
+};
+
+static const jas_stream_ops_t jas_stream_memops = {+ mem_read,
+ mem_write,
+ mem_seek,
+ mem_close
+};
+
+/******************************************************************************\
+* Code for opening and closing streams.
+\******************************************************************************/
+
+static jas_stream_t *jas_stream_create()
+{+ jas_stream_t *stream;
+
+ if (!(stream = jas_malloc(sizeof(jas_stream_t)))) {+ return 0;
+ }
+ stream->openmode_ = 0;
+ stream->bufmode_ = 0;
+ stream->flags_ = 0;
+ stream->bufbase_ = 0;
+ stream->bufstart_ = 0;
+ stream->bufsize_ = 0;
+ stream->ptr_ = 0;
+ stream->cnt_ = 0;
+ stream->ops_ = 0;
+ stream->obj_ = 0;
+ stream->rwcnt_ = 0;
+ stream->rwlimit_ = -1;
+
+ return stream;
+}
+
+/*
+This function will eventually replace jas_stream_memopen.
+For documentation of the interface for this function, see jas_stream.h.
+*/
+
+jas_stream_t *jas_stream_memopen2(char *buf, size_t bufsize)
+{+ jas_stream_t *stream;
+ jas_stream_memobj_t *obj;
+
+ JAS_DBGLOG(100, ("jas_stream_memopen2(%p, %zu)\n", buf, bufsize));+
+ assert((buf && bufsize > 0) || (!buf));
+
+ if (!(stream = jas_stream_create())) {+ return 0;
+ }
+
+ /* A stream associated with a memory buffer is always opened
+ for both reading and writing in binary mode. */
+ stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY;
+
+ /* Since the stream data is already resident in memory, buffering
+ is not necessary. */
+ jas_stream_initbuf(stream, JAS_STREAM_UNBUF, 0, 0);
+
+ /* Select the operations for a memory stream. */
+ stream->ops_ = &jas_stream_memops;
+
+ /* Allocate memory for the underlying memory stream object. */
+ if (!(obj = jas_malloc(sizeof(jas_stream_memobj_t)))) {+ jas_stream_destroy(stream);
+ return 0;
+ }
+ stream->obj_ = (void *) obj;
+
+ /* Initialize a few important members of the memory stream object. */
+ obj->myalloc_ = 0;
+ obj->buf_ = 0;
+
+ /* If the buffer size specified is nonpositive, then the buffer
+ is allocated internally and automatically grown as needed. */
+ if (!bufsize) {+ obj->bufsize_ = 1024;
+ obj->growable_ = 1;
+ } else {+ obj->bufsize_ = bufsize;
+ obj->growable_ = 0;
+ }
+ if (buf) {+ obj->buf_ = JAS_CAST(unsigned char *, buf);
+ } else {+ obj->buf_ = jas_malloc(obj->bufsize_);
+ obj->myalloc_ = 1;
+ }
+ if (!obj->buf_) {+ jas_stream_close(stream);
+ return 0;
+ }
+ JAS_DBGLOG(100, ("jas_stream_memopen2 buffer buf=%p myalloc=%d\n",+ obj->buf_, obj->myalloc_));
+
+ if (bufsize > 0 && buf) {+ /* If a buffer was supplied by the caller and its length is positive,
+ make the associated buffer data appear in the stream initially. */
+ obj->len_ = bufsize;
+ } else {+ /* The stream is initially empty. */
+ obj->len_ = 0;
+ }
+ obj->pos_ = 0;
+
+ return stream;
+}
+
+/*
+NOTE:
+The version of the function jas_stream_memopen only exists for backwards
+compatibility.
+Eventually, it should be replaced by jas_stream_memopen2.
+In retrospect, it was a very poor choice to have specified the buffer
+size parameter (bufsize) to have type int. On some machines, int may only
+be a 16-bit integer. This precludes larger-sized buffer allocations, which
+are needed in practice.
+
+If bufsize <= 0, the buffer is growable; otherwise, the buffer has a fixed
+size of bufsize.
+If buf is 0, the buffer is dynamically allocated with jas_malloc.
+If buf is not 0 and bufsize <= 0 (which is not permitted in any
+circumstances), bad things will happen (especially if the buf was not
+allocated with jas_malloc).
+*/
+jas_stream_t *jas_stream_memopen(char *buf, int bufsize)
+{+ char *new_buf;
+ size_t new_bufsize;
+
+ JAS_DBGLOG(100, ("jas_stream_memopen(%p, %d)\n", buf, bufsize));+ if (bufsize < 0) {+ jas_deprecated("negative buffer size for jas_stream_memopen");+ }
+ if (buf && bufsize <= 0) {+ // This was never a valid thing to do with the old API.
+ jas_eprintf("Invalid use of jas_stream_memopen detected.\n");+ jas_deprecated("A user-provided buffer for "+ "jas_stream_memopen cannot be growable.\n");
+ }
+ if (bufsize <= 0) {+ new_bufsize = 0;
+ new_buf = 0;
+ } else {+ new_bufsize = bufsize;
+ new_buf = buf;
+ }
+ return jas_stream_memopen2(new_buf, new_bufsize);
+}
+
+jas_stream_t *jas_stream_fopen(const char *filename, const char *mode)
+{+ jas_stream_t *stream;
+ jas_stream_fileobj_t *obj;
+ int openflags;
+
+ JAS_DBGLOG(100, ("jas_stream_fopen(\"%s\", \"%s\")\n", filename, mode));+
+ /* Allocate a stream object. */
+ if (!(stream = jas_stream_create())) {+ return 0;
+ }
+
+ /* Parse the mode string. */
+ stream->openmode_ = jas_strtoopenmode(mode);
+
+ /* Determine the correct flags to use for opening the file. */
+ if ((stream->openmode_ & JAS_STREAM_READ) &&
+ (stream->openmode_ & JAS_STREAM_WRITE)) {+ openflags = ORDWR;
+ } else if (stream->openmode_ & JAS_STREAM_READ) {+ openflags = OREAD;
+ } else if (stream->openmode_ & JAS_STREAM_WRITE) {+ openflags = OWRITE;
+ } else {+ openflags = 0;
+ }
+ if (stream->openmode_ & JAS_STREAM_CREATE) {+ openflags |= OTRUNC;
+ }
+
+ openflags |= OCEXEC;
+
+ /* Allocate space for the underlying file stream object. */
+ if (!(obj = jas_malloc(sizeof(jas_stream_fileobj_t)))) {+ jas_stream_destroy(stream);
+ return 0;
+ }
+ obj->fd = -1;
+ obj->flags = 0;
+ obj->pathname[0] = '\0';
+ stream->obj_ = (void *) obj;
+
+ /* Select the operations for a file stream object. */
+ stream->ops_ = &jas_stream_fileops;
+
+ if (stream->openmode_ & JAS_STREAM_CREATE) {+ obj->fd = create(filename, openflags, JAS_STREAM_PERMS);
+ } else {+ obj->fd = open(filename, openflags);
+ }
+
+ /* Open the underlying file. */
+ if (obj->fd < 0) {+ // Free the underlying file object, since it will not otherwise
+ // be freed.
+ jas_free(obj);
+ jas_stream_destroy(stream);
+ return 0;
+ }
+ if (stream->openmode_ & JAS_STREAM_APPEND) {+ seek(obj->fd, 0, 2);
+ }
+
+ /* By default, use full buffering for this type of stream. */
+ jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
+
+ return stream;
+}
+
+jas_stream_t *jas_stream_freopen(const char *path, const char *mode, FILE *fp)
+{+ jas_stream_t *stream;
+
+ JAS_DBGLOG(100, ("jas_stream_freopen(\"%s\", \"%s\", %p)\n", path, mode,+ fp));
+
+ /* Eliminate compiler warning about unused variable. */
+ USED(path);
+
+ /* Allocate a stream object. */
+ if (!(stream = jas_stream_create())) {+ return 0;
+ }
+
+ /* Parse the mode string. */
+ stream->openmode_ = jas_strtoopenmode(mode);
+
+ stream->obj_ = JAS_CAST(void *, fp);
+
+ /* Select the operations for a file stream object. */
+ stream->ops_ = &jas_stream_sfileops;
+
+ /* By default, use full buffering for this type of stream. */
+ jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
+
+ return stream;
+}
+
+#ifndef _WIN32
+
+/**
+ * Copy the absolute path of the directory for temporary files to the
+ * given buffer (without a null terminator), including a trailing path
+ * separator.
+ *
+ * @return the number of characters copied to the buffer or 0 on error
+ */
+static size_t get_temp_directory(char *buffer, size_t size)
+{+ const char *tmpdir = getenv("TMPDIR");+ if (tmpdir == NULL)
+ tmpdir = "/tmp";
+
+ size_t length = strlen(tmpdir);
+ if (length + 1 > size)
+ return 0;
+
+ memcpy(buffer, tmpdir, length);
+ buffer[length++] = '/';
+ return length;
+}
+
+#endif /* !_WIN32 */
+
+/**
+ * Generate a template for mkstemp().
+ *
+ * @return 0 on success, -1 on error
+ */
+static int make_mkstemp_template(char *buffer, size_t size)
+{+#ifdef _WIN32
+ char temp_directory[MAX_PATH];
+ if (GetTempPathA(sizeof(temp_directory), temp_directory) == 0)
+ return -1;
+
+ (void)size;
+
+ return GetTempFileNameA(temp_directory, "jasper", 0, buffer) > 0
+ ? 0 : -1;
+#else
+ static const char base[] = "jasper.XXXXXXXXXXX";
+
+ size_t length = get_temp_directory(buffer, size);
+ if (length == 0 || length + sizeof(base) >= size)
+ return -1;
+
+ memcpy(buffer + length, base, sizeof(base));
+ return 0;
+#endif
+}
+
+/**
+ * A wrapper for mkstemp() which generates a template for mkstemp()
+ * before calling the function.
+ *
+ * @return a non-negative file descriptor on success, -1 on error
+ */
+static int easy_mkstemp(char *buffer, size_t size)
+{+#if defined(__linux__) && defined(O_TMPFILE)
+ /* try to use O_TMPFILE, which is a Linux-specific feature to
+ create a temporary file without a name, not linked to any
+ directory; this is even more secure than mkstemp() */
+ const char *tmpdir = getenv("TMPDIR");+ if (tmpdir == NULL)
+ tmpdir = "/tmp";
+
+ int fd = open(tmpdir, O_TMPFILE|O_RDWR, JAS_STREAM_PERMS);
+ if (fd >= 0) {+ *buffer = 0;
+ return fd;
+ }
+#endif
+
+ if (make_mkstemp_template(buffer, size))
+ return -1;
+
+#ifdef _WIN32
+ return open(buffer,
+ O_CREAT | O_EXCL | O_RDWR | O_TRUNC | O_BINARY | O_CLOEXEC,
+ JAS_STREAM_PERMS);
+#else
+#ifdef JAS_HAVE_MKOSTEMP
+ return mkostemp(buffer, O_CLOEXEC);
+#else
+ return create(mktemp(buffer), OTRUNC|ORDWR|OEXCL|OCEXEC, JAS_STREAM_PERMS);
+#endif
+#endif
+}
+
+jas_stream_t *jas_stream_tmpfile()
+{+ jas_stream_t *stream;
+ jas_stream_fileobj_t *obj;
+
+ JAS_DBGLOG(100, ("jas_stream_tmpfile()\n"));+
+ if (!(stream = jas_stream_create())) {+ return 0;
+ }
+
+ /* A temporary file stream is always opened for both reading and
+ writing in binary mode. */
+ stream->openmode_ = JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY;
+
+ /* Allocate memory for the underlying temporary file object. */
+ if (!(obj = jas_malloc(sizeof(jas_stream_fileobj_t)))) {+ jas_stream_destroy(stream);
+ return 0;
+ }
+ obj->fd = -1;
+ obj->flags = 0;
+ obj->pathname[0] = '\0';
+ stream->obj_ = obj;
+
+ /* Create the temporary file. */
+ if ((obj->fd = easy_mkstemp(obj->pathname, sizeof(obj->pathname))) < 0) {+ jas_stream_destroy(stream);
+ return 0;
+ }
+
+ /* Unlink the file so that it will disappear if the program
+ terminates abnormally. */
+ /* Under UNIX, one can unlink an open file and continue to do I/O
+ on it. Not all operating systems support this functionality, however.
+ For example, under Microsoft Windows the unlink operation will fail,
+ since the file is open. */
+ if (*obj->pathname != 0 && remove(obj->pathname) < 0) {+ /* We will try unlinking the file again after it is closed. */
+ obj->flags |= JAS_STREAM_FILEOBJ_DELONCLOSE;
+ }
+
+ /* Use full buffering. */
+ jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
+
+ stream->ops_ = &jas_stream_fileops;
+
+ return stream;
+}
+
+jas_stream_t *jas_stream_fdopen(int fd, const char *mode)
+{+ jas_stream_t *stream;
+ jas_stream_fileobj_t *obj;
+
+ JAS_DBGLOG(100, ("jas_stream_fdopen(%d, \"%s\")\n", fd, mode));+
+ /* Allocate a stream object. */
+ if (!(stream = jas_stream_create())) {+ return 0;
+ }
+
+ /* Parse the mode string. */
+ stream->openmode_ = jas_strtoopenmode(mode);
+
+#if defined(WIN32)
+ /* Argh!!! Someone ought to banish text mode (i.e., O_TEXT) to the
+ greatest depths of purgatory! */
+ /* Ensure that the file descriptor is in binary mode, if the caller
+ has specified the binary mode flag. Arguably, the caller ought to
+ take care of this, but text mode is a ugly wart anyways, so we save
+ the caller some grief by handling this within the stream library. */
+ /* This ugliness is mainly for the benefit of those who run the
+ JasPer software under Windows from shells that insist on opening
+ files in text mode. For example, in the Cygwin environment,
+ shells often open files in text mode when I/O redirection is
+ used. Grr... */
+ if (stream->openmode_ & JAS_STREAM_BINARY) {+ setmode(fd, O_BINARY);
+ }
+#endif
+
+ /* Allocate space for the underlying file stream object. */
+ if (!(obj = jas_malloc(sizeof(jas_stream_fileobj_t)))) {+ jas_stream_destroy(stream);
+ return 0;
+ }
+ obj->fd = fd;
+ obj->flags = 0;
+ obj->pathname[0] = '\0';
+ stream->obj_ = (void *) obj;
+
+ /* Do not close the underlying file descriptor when the stream is
+ closed. */
+ obj->flags |= JAS_STREAM_FILEOBJ_NOCLOSE;
+
+ /* By default, use full buffering for this type of stream. */
+ jas_stream_initbuf(stream, JAS_STREAM_FULLBUF, 0, 0);
+
+ /* Select the operations for a file stream object. */
+ stream->ops_ = &jas_stream_fileops;
+
+ return stream;
+}
+
+static void jas_stream_destroy(jas_stream_t *stream)
+{+ JAS_DBGLOG(100, ("jas_stream_destroy(%p)\n", stream));+
+ /* If the memory for the buffer was allocated with malloc, free
+ this memory. */
+ if ((stream->bufmode_ & JAS_STREAM_FREEBUF) && stream->bufbase_) {+ JAS_DBGLOG(100, ("jas_stream_destroy freeing buffer %p\n",+ stream->bufbase_));
+ jas_free(stream->bufbase_);
+ stream->bufbase_ = 0;
+ }
+ jas_free(stream);
+}
+
+int jas_stream_close(jas_stream_t *stream)
+{+ JAS_DBGLOG(100, ("jas_stream_close(%p)\n", stream));+
+ /* Flush buffer if necessary. */
+ jas_stream_flush(stream);
+
+ /* Close the underlying stream object. */
+ (*stream->ops_->close_)(stream->obj_);
+
+ jas_stream_destroy(stream);
+
+ return 0;
+}
+
+static bool jas_stream_is_unbuffered(const jas_stream_t *stream)
+{+ return stream->bufsize_ <= 1;
+}
+
+static bool jas_stream_is_input_buffer_empty(const jas_stream_t *stream)
+{+ return stream->cnt_ == 0;
+}
+
+/******************************************************************************\
+* Code for reading and writing streams.
+\******************************************************************************/
+
+int jas_stream_getc_func(jas_stream_t *stream)
+{+ assert(stream->ptr_ - stream->bufbase_ <= stream->bufsize_ +
+ JAS_STREAM_MAXPUTBACK);
+ return jas_stream_getc_macro(stream);
+}
+
+int jas_stream_putc_func(jas_stream_t *stream, int c)
+{+ assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_);
+ return jas_stream_putc_macro(stream, c);
+}
+
+int jas_stream_ungetc(jas_stream_t *stream, int c)
+{+ if (!stream->ptr_ || stream->ptr_ == stream->bufbase_) {+ return -1;
+ }
+
+ /* Reset the EOF indicator (since we now have at least one character
+ to read). */
+ stream->flags_ &= ~JAS_STREAM_EOF;
+
+ --stream->rwcnt_;
+ --stream->ptr_;
+ ++stream->cnt_;
+ *stream->ptr_ = c;
+ return 0;
+}
+
+/* FIXME integral type */
+unsigned jas_stream_read(jas_stream_t *stream, void *buf, unsigned cnt)
+{+ int c;
+ char *bufptr;
+
+ JAS_DBGLOG(100, ("jas_stream_read(%p, %p, %u)\n", stream, buf, cnt));+
+ if (cnt == 0)
+ return 0;
+
+ bufptr = buf;
+
+ if (jas_stream_is_unbuffered(stream) && stream->rwlimit_ < 0 &&
+ jas_stream_is_input_buffer_empty(stream)) {+ /* fast path for unbuffered streams */
+
+ if ((stream->flags_ & JAS_STREAM_ERRMASK) != 0)
+ return 0;
+
+ if ((stream->openmode_ & JAS_STREAM_READ) == 0)
+ return 0;
+
+ assert((stream->bufmode_ & JAS_STREAM_WRBUF) == 0);
+
+ stream->bufmode_ |= JAS_STREAM_RDBUF;
+
+ int nbytes = stream->ops_->read_(stream->obj_, bufptr, cnt);
+ if (nbytes <= 0) {+ stream->flags_ |= nbytes < 0
+ ? JAS_STREAM_ERR
+ : JAS_STREAM_EOF;
+ return 0;
+ }
+
+ stream->rwcnt_ += nbytes;
+ return nbytes;
+ }
+
+ unsigned n = 0;
+ while (n < cnt) {+ if ((c = jas_stream_getc(stream)) == EOF) {+ return n;
+ }
+ *bufptr++ = c;
+ ++n;
+ }
+
+ return n;
+}
+
+unsigned jas_stream_peek(jas_stream_t *stream, void *buf, size_t cnt)
+{+ char *bufptr = buf;
+
+ const unsigned n = jas_stream_read(stream, bufptr, cnt);
+
+ /* Put the characters read back onto the stream. */
+ for (unsigned i = n; i-- > 0;)
+ if (jas_stream_ungetc(stream, bufptr[i]) == EOF)
+ return 0;
+
+ return n;
+}
+
+/* FIXME integral type */
+unsigned jas_stream_write(jas_stream_t *stream, const void *buf, unsigned cnt)
+{+ const char *bufptr;
+
+ JAS_DBGLOG(100, ("jas_stream_write(%p, %p, %d)\n", stream, buf, cnt));+
+ if (cnt == 0)
+ return 0;
+
+ bufptr = buf;
+
+ if (jas_stream_is_unbuffered(stream) && stream->rwlimit_ < 0) {+ /* fast path for unbuffered streams */
+
+ /* need to flush the output buffer before we do a raw
+ write */
+ if (jas_stream_flushbuf(stream, EOF))
+ return 0;
+
+ stream->bufmode_ |= JAS_STREAM_WRBUF;
+
+ int nbytes = stream->ops_->write_(stream->obj_, bufptr, cnt);
+ if (nbytes != (int)cnt) {+ stream->flags_ |= JAS_STREAM_ERR;
+ return 0;
+ }
+
+ stream->rwcnt_ += nbytes;
+ return nbytes;
+ }
+
+ unsigned n = 0;
+ while (n < cnt) {+ if (jas_stream_putc(stream, *bufptr) == EOF) {+ return n;
+ }
+ ++bufptr;
+ ++n;
+ }
+
+ return n;
+}
+
+/* Note: This function uses a fixed size buffer. Therefore, it cannot
+ handle invocations that will produce more output than can be held
+ by the buffer. */
+int jas_stream_printf(jas_stream_t *stream, const char *fmt, ...)
+{+ va_list ap;
+ char buf[4096];
+ int ret;
+
+ va_start(ap, fmt);
+ ret = vsnprintf(buf, sizeof buf, fmt, ap);
+ jas_stream_puts(stream, buf);
+ va_end(ap);
+ return ret;
+}
+
+int jas_stream_puts(jas_stream_t *stream, const char *s)
+{+ while (*s != '\0') {+ if (jas_stream_putc_macro(stream, *s) == EOF) {+ return -1;
+ }
+ ++s;
+ }
+ return 0;
+}
+
+/* TODO/FIXME: this function should return null upon error (buffer overrun or I/O error */
+/* FIXME integral type */
+char *jas_stream_gets(jas_stream_t *stream, char *buf, int bufsize)
+{+ int c;
+ char *bufptr;
+ assert(bufsize > 0);
+
+ JAS_DBGLOG(100, ("jas_stream_gets(%p, %p, %d)\n", stream, buf, bufsize));+
+ bufptr = buf;
+ while (bufsize > 1) {+ if ((c = jas_stream_getc(stream)) == EOF) {+ break;
+ }
+ *bufptr++ = c;
+ --bufsize;
+ if (c == '\n') {+ break;
+ }
+ }
+ *bufptr = '\0';
+ return buf;
+}
+
+/* FIXME integral type */
+int jas_stream_gobble(jas_stream_t *stream, int n)
+{+ int m;
+
+ JAS_DBGLOG(100, ("jas_stream_gobble(%p, %d)\n", stream, n));+
+ if (n < 0) {+ jas_deprecated("negative count for jas_stream_gobble");+ }
+ for (m = n; m > 0; --m) {+ if (jas_stream_getc(stream) == EOF) {+ return n - m;
+ }
+ }
+ return n;
+}
+
+/* FIXME integral type */
+int jas_stream_pad(jas_stream_t *stream, int n, int c)
+{+ int m;
+
+ JAS_DBGLOG(100, ("jas_stream_pad(%p, %d, %d)\n", stream, n, c));+
+ if (n < 0) {+ jas_deprecated("negative count for jas_stream_pad");+ }
+ for (m = n; m > 0; --m) {+ if (jas_stream_putc(stream, c) == EOF)
+ return n - m;
+ }
+ return n;
+}
+
+/******************************************************************************\
+* Code for getting and setting the stream position.
+\******************************************************************************/
+
+int jas_stream_isseekable(jas_stream_t *stream)
+{+ if (stream->ops_ == &jas_stream_memops) {+ return 1;
+ } else if (stream->ops_ == &jas_stream_fileops) {+ if ((*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR) < 0) {+ return 0;
+ }
+ return 1;
+ } else {+ return 0;
+ }
+}
+
+int jas_stream_rewind(jas_stream_t *stream)
+{+ JAS_DBGLOG(100, ("jas_stream_rewind(%p)\n", stream));+ return jas_stream_seek(stream, 0, SEEK_SET);
+}
+
+long jas_stream_seek(jas_stream_t *stream, long offset, int origin)
+{+ long newpos;
+
+ JAS_DBGLOG(100, ("jas_stream_seek(%p, %ld, %d)\n", stream, offset,+ origin));
+
+ /* The buffer cannot be in use for both reading and writing. */
+ assert(!((stream->bufmode_ & JAS_STREAM_RDBUF) && (stream->bufmode_ &
+ JAS_STREAM_WRBUF)));
+
+ /* Reset the EOF indicator (since we may not be at the EOF anymore). */
+ stream->flags_ &= ~JAS_STREAM_EOF;
+
+ if (stream->bufmode_ & JAS_STREAM_RDBUF) {+ if (origin == SEEK_CUR) {+ offset -= stream->cnt_;
+ }
+ } else if (stream->bufmode_ & JAS_STREAM_WRBUF) {+ if (jas_stream_flush(stream)) {+ return -1;
+ }
+ }
+ stream->cnt_ = 0;
+ stream->ptr_ = stream->bufstart_;
+ stream->bufmode_ &= ~(JAS_STREAM_RDBUF | JAS_STREAM_WRBUF);
+
+ if ((newpos = (*stream->ops_->seek_)(stream->obj_, offset, origin))
+ < 0) {+ return -1;
+ }
+
+ return newpos;
+}
+
+long jas_stream_tell(jas_stream_t *stream)
+{+ int adjust;
+ int offset;
+
+ JAS_DBGLOG(100, ("jas_stream_tell(%p)\n", stream));+
+ if (stream->bufmode_ & JAS_STREAM_RDBUF) {+ adjust = -stream->cnt_;
+ } else if (stream->bufmode_ & JAS_STREAM_WRBUF) {+ adjust = stream->ptr_ - stream->bufstart_;
+ } else {+ adjust = 0;
+ }
+
+ if ((offset = (*stream->ops_->seek_)(stream->obj_, 0, SEEK_CUR)) < 0) {+ return -1;
+ }
+
+ return offset + adjust;
+}
+
+/******************************************************************************\
+* Buffer initialization code.
+\******************************************************************************/
+
+/* FIXME integral type */
+static void jas_stream_initbuf(jas_stream_t *stream, int bufmode, char *buf,
+ int bufsize)
+{+ /* If this function is being called, the buffer should not have been
+ initialized yet. */
+ assert(!stream->bufbase_);
+
+ if (bufmode != JAS_STREAM_UNBUF) {+ /* The full- or line-buffered mode is being employed. */
+ if (!buf) {+ /* The caller has not specified a buffer to employ, so allocate
+ one. */
+ if ((stream->bufbase_ = jas_malloc(JAS_STREAM_BUFSIZE +
+ JAS_STREAM_MAXPUTBACK))) {+ stream->bufmode_ |= JAS_STREAM_FREEBUF;
+ stream->bufsize_ = JAS_STREAM_BUFSIZE;
+ } else {+ /* The buffer allocation has failed. Resort to unbuffered
+ operation. */
+ stream->bufbase_ = stream->tinybuf_;
+ stream->bufsize_ = 1;
+ }
+ } else {+ /* The caller has specified a buffer to employ. */
+ /* The buffer must be large enough to accommodate maximum
+ putback. */
+ assert(bufsize > JAS_STREAM_MAXPUTBACK);
+ stream->bufbase_ = JAS_CAST(jas_uchar *, buf);
+ stream->bufsize_ = bufsize - JAS_STREAM_MAXPUTBACK;
+ }
+ } else {+ /* The unbuffered mode is being employed. */
+ /* A buffer should not have been supplied by the caller. */
+ assert(!buf);
+ /* Use a trivial one-character buffer. */
+ stream->bufbase_ = stream->tinybuf_;
+ stream->bufsize_ = 1;
+ }
+ stream->bufstart_ = &stream->bufbase_[JAS_STREAM_MAXPUTBACK];
+ stream->ptr_ = stream->bufstart_;
+ stream->cnt_ = 0;
+ stream->bufmode_ |= bufmode & JAS_STREAM_BUFMODEMASK;
+}
+
+/******************************************************************************\
+* Buffer filling and flushing code.
+\******************************************************************************/
+
+int jas_stream_flush(jas_stream_t *stream)
+{+ if (stream->bufmode_ & JAS_STREAM_RDBUF) {+ return 0;
+ }
+ return jas_stream_flushbuf(stream, EOF);
+}
+
+int jas_stream_fillbuf(jas_stream_t *stream, int getflag)
+{+ int c;
+
+ /* The stream must not be in an error or EOF state. */
+ if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) {+ return EOF;
+ }
+
+ /* The stream must be open for reading. */
+ if ((stream->openmode_ & JAS_STREAM_READ) == 0) {+ return EOF;
+ }
+
+ /* Make a half-hearted attempt to confirm that the buffer is not
+ currently being used for writing. This check is not intended
+ to be foolproof! */
+ assert((stream->bufmode_ & JAS_STREAM_WRBUF) == 0);
+
+ assert(stream->ptr_ - stream->bufstart_ <= stream->bufsize_);
+
+ /* Mark the buffer as being used for reading. */
+ stream->bufmode_ |= JAS_STREAM_RDBUF;
+
+ /* Read new data into the buffer. */
+ stream->ptr_ = stream->bufstart_;
+ if ((stream->cnt_ = (*stream->ops_->read_)(stream->obj_,
+ (char *) stream->bufstart_, stream->bufsize_)) <= 0) {+ if (stream->cnt_ < 0) {+ stream->flags_ |= JAS_STREAM_ERR;
+ } else {+ stream->flags_ |= JAS_STREAM_EOF;
+ }
+ stream->cnt_ = 0;
+ return EOF;
+ }
+
+ assert(stream->cnt_ > 0);
+ /* Get or peek at the first character in the buffer. */
+ c = (getflag) ? jas_stream_getc2(stream) : (*stream->ptr_);
+
+ return c;
+}
+
+int jas_stream_flushbuf(jas_stream_t *stream, int c)
+{+ int len;
+ int n;
+
+ /* The stream should not be in an error or EOF state. */
+ if ((stream->flags_ & (JAS_STREAM_ERRMASK)) != 0) {+ return EOF;
+ }
+
+ /* The stream must be open for writing. */
+ if ((stream->openmode_ & (JAS_STREAM_WRITE | JAS_STREAM_APPEND)) == 0) {+ return EOF;
+ }
+
+ /* The buffer should not currently be in use for reading. */
+ assert(!(stream->bufmode_ & JAS_STREAM_RDBUF));
+
+ /* Note: Do not use the quantity stream->cnt to determine the number
+ of characters in the buffer! Depending on how this function was
+ called, the stream->cnt value may be "off-by-one". */
+ len = stream->ptr_ - stream->bufstart_;
+ if (len > 0) {+ n = (*stream->ops_->write_)(stream->obj_, (char *)
+ stream->bufstart_, len);
+ if (n != len) {+ stream->flags_ |= JAS_STREAM_ERR;
+ return EOF;
+ }
+ }
+ stream->cnt_ = stream->bufsize_;
+ stream->ptr_ = stream->bufstart_;
+
+ stream->bufmode_ |= JAS_STREAM_WRBUF;
+
+ if (c != EOF) {+ assert(stream->cnt_ > 0);
+ return jas_stream_putc2(stream, c);
+ }
+
+ return 0;
+}
+
+/******************************************************************************\
+* Miscellaneous code.
+\******************************************************************************/
+
+static int jas_strtoopenmode(const char *s)
+{+ int openmode = 0;
+ while (*s != '\0') {+ switch (*s) {+ case 'r':
+ openmode |= JAS_STREAM_READ;
+ break;
+ case 'w':
+ openmode |= JAS_STREAM_WRITE | JAS_STREAM_CREATE;
+ break;
+ case 'b':
+ openmode |= JAS_STREAM_BINARY;
+ break;
+ case 'a':
+ openmode |= JAS_STREAM_APPEND;
+ break;
+ case '+':
+ openmode |= JAS_STREAM_READ | JAS_STREAM_WRITE;
+ break;
+ default:
+ break;
+ }
+ ++s;
+ }
+ return openmode;
+}
+
+/* FIXME integral type */
+int jas_stream_copy(jas_stream_t *out, jas_stream_t *in, int n)
+{+ int m;
+
+ const bool all = n < 0;
+
+ char buffer[JAS_STREAM_BUFSIZE];
+
+ m = n;
+ while (all || m > 0) {+ unsigned nbytes = jas_stream_read(in, buffer,
+ JAS_MIN((size_t)m, sizeof(buffer)));
+ if (nbytes == 0)
+ return !all || jas_stream_error(in) ? -1 : 0;
+
+ if (jas_stream_write(out, buffer, nbytes) != nbytes)
+ return -1;
+
+ m -= nbytes;
+ }
+
+ return 0;
+}
+
+/* FIXME integral type */
+long jas_stream_setrwcount(jas_stream_t *stream, long rwcnt)
+{+ int old;
+
+ old = stream->rwcnt_;
+ stream->rwcnt_ = rwcnt;
+ return old;
+}
+
+JAS_DLLEXPORT
+long jas_stream_setrwlimit(jas_stream_t *stream, long rwlimit)
+{+ long old;
+
+ old = stream->rwlimit_;
+ stream->rwlimit_ = rwlimit;
+ return old;
+}
+
+/* FIXME integral type */
+int jas_stream_display(jas_stream_t *stream, FILE *fp, int n)
+{+ unsigned char buf[16];
+ int i;
+ int j;
+ int m;
+ int c;
+ int display;
+ int cnt;
+
+ cnt = n - (n % 16);
+ display = 1;
+
+ for (i = 0; i < n; i += 16) {+ if (n > 16 && i > 0) {+ display = (i >= cnt) ? 1 : 0;
+ }
+ if (display) {+ fprintf(fp, "%08x:", i);
+ }
+ m = JAS_MIN(n - i, 16);
+ for (j = 0; j < m; ++j) {+ if ((c = jas_stream_getc(stream)) == EOF) {+ abort();
+ return -1;
+ }
+ buf[j] = c;
+ }
+ if (display) {+ for (j = 0; j < m; ++j) {+ fprintf(fp, " %02x", buf[j]);
+ }
+ fputc(' ', fp);+ for (; j < 16; ++j) {+ fprintf(fp, " ");
+ }
+ for (j = 0; j < m; ++j) {+ if (isprint(buf[j])) {+ fputc(buf[j], fp);
+ } else {+ fputc(' ', fp);+ }
+ }
+ fprintf(fp, "\n");
+ }
+
+
+ }
+ return 0;
+}
+
+long jas_stream_length(jas_stream_t *stream)
+{+ long oldpos;
+ long pos;
+ if ((oldpos = jas_stream_tell(stream)) < 0) {+ return -1;
+ }
+ if (jas_stream_seek(stream, 0, SEEK_END) < 0) {+ return -1;
+ }
+ if ((pos = jas_stream_tell(stream)) < 0) {+ return -1;
+ }
+ if (jas_stream_seek(stream, oldpos, SEEK_SET) < 0) {+ return -1;
+ }
+ return pos;
+}
+
+/******************************************************************************\
+* Memory stream object.
+\******************************************************************************/
+
+/* FIXME integral type */
+static int mem_read(jas_stream_obj_t *obj, char *buf, unsigned cnt)
+{+ jas_stream_memobj_t *m;
+ assert(buf);
+
+ JAS_DBGLOG(100, ("mem_read(%p, %p, %u)\n", obj, buf, cnt));+ m = (jas_stream_memobj_t *)obj;
+ size_t n = m->len_ - m->pos_;
+ cnt = JAS_MIN(n, cnt);
+ memcpy(buf, &m->buf_[m->pos_], cnt);
+ m->pos_ += cnt;
+ return cnt;
+}
+
+static int mem_resize(jas_stream_memobj_t *m, size_t bufsize)
+{+ unsigned char *buf;
+
+ //assert(m->buf_);
+
+ JAS_DBGLOG(100, ("mem_resize(%p, %zu)\n", m, bufsize));+ if (!bufsize) {+ jas_eprintf(
+ "mem_resize was not really designed to handle a buffer of size 0\n"
+ "This may not work.\n"
+ );
+ }
+
+ if (!(buf = jas_realloc2(m->buf_, bufsize, sizeof(unsigned char))) &&
+ bufsize) {+ JAS_DBGLOG(100, ("mem_resize realloc failed\n"));+ return -1;
+ }
+ JAS_DBGLOG(100, ("mem_resize realloc succeeded\n"));+ m->buf_ = buf;
+ m->bufsize_ = bufsize;
+ return 0;
+}
+
+/* FIXME integral type */
+static int mem_write(jas_stream_obj_t *obj, const char *buf, unsigned cnt)
+{+ size_t n;
+ jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj;
+ size_t newbufsize;
+ size_t newpos;
+
+ assert(buf);
+
+ JAS_DBGLOG(100, ("mem_write(%p, %p, %u)\n", obj, buf, cnt));+ newpos = m->pos_ + cnt;
+ if (newpos > m->bufsize_ && m->growable_) {+ newbufsize = m->bufsize_;
+ while (newbufsize < newpos) {+ //newbufsize <<= 1;
+ if (!jas_safe_size_mul(newbufsize, 2, &newbufsize)) {+ JAS_DBGLOG(100, ("new buffer size would cause overflow\n"));+ return -1;
+ }
+ }
+ JAS_DBGLOG(100, ("mem_write resizing from %d to %zu\n", m->bufsize_,+ newbufsize));
+ assert(newbufsize > 0);
+ if (mem_resize(m, newbufsize)) {+ return -1;
+ }
+ }
+ if (m->pos_ > m->len_) {+ /* The current position is beyond the end of the file, so
+ pad the file to the current position with zeros. */
+ n = JAS_MIN(m->pos_, m->bufsize_) - m->len_;
+ if (n > 0) {+ memset(&m->buf_[m->len_], 0, n);
+ m->len_ += n;
+ }
+ if (m->pos_ != m->len_) {+ /* The buffer is not big enough. */
+ return 0;
+ }
+ }
+ n = m->bufsize_ - m->pos_;
+ unsigned ret = JAS_MIN(n, cnt);
+ if (ret > 0) {+ memcpy(&m->buf_[m->pos_], buf, ret);
+ m->pos_ += ret;
+ }
+ if (m->pos_ > m->len_) {+ m->len_ = m->pos_;
+ }
+ assert(ret == cnt);
+ return ret;
+}
+
+/* FIXME integral type */
+static long mem_seek(jas_stream_obj_t *obj, long offset, int origin)
+{+ jas_stream_memobj_t *m = (jas_stream_memobj_t *)obj;
+ long newpos;
+
+ JAS_DBGLOG(100, ("mem_seek(%p, %ld, %d)\n", obj, offset, origin));+ switch (origin) {+ case SEEK_SET:
+ newpos = offset;
+ break;
+ case SEEK_END:
+ newpos = m->len_ - offset;
+ break;
+ case SEEK_CUR:
+ newpos = m->pos_ + offset;
+ break;
+ default:
+ return -1;
+ }
+ if (newpos < 0) {+ return -1;
+ }
+ m->pos_ = newpos;
+
+ return m->pos_;
+}
+
+static int mem_close(jas_stream_obj_t *obj)
+{+ jas_stream_memobj_t *m;
+
+ JAS_DBGLOG(100, ("mem_close(%p)\n", obj));+ m = (jas_stream_memobj_t *)obj;
+ JAS_DBGLOG(100, ("mem_close myalloc=%d\n", m->myalloc_));+ if (m->myalloc_ && m->buf_) {+ JAS_DBGLOG(100, ("mem_close freeing buffer %p\n", m->buf_));+ jas_free(m->buf_);
+ m->buf_ = 0;
+ }
+ jas_free(obj);
+ return 0;
+}
+
+/******************************************************************************\
+* File stream object.
+\******************************************************************************/
+
+/* FIXME integral type */
+static int file_read(jas_stream_obj_t *obj, char *buf, unsigned cnt)
+{+ jas_stream_fileobj_t *fileobj;
+ JAS_DBGLOG(100, ("file_read(%p, %p, %u)\n", obj, buf, cnt));+ fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
+ return read(fileobj->fd, buf, cnt);
+}
+
+/* FIXME integral type */
+static int file_write(jas_stream_obj_t *obj, const char *buf, unsigned cnt)
+{+ jas_stream_fileobj_t *fileobj;
+ JAS_DBGLOG(100, ("file_write(%p, %p, %u)\n", obj, buf, cnt));+ fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
+ return write(fileobj->fd, buf, cnt);
+}
+
+/* FIXME integral type */
+static long file_seek(jas_stream_obj_t *obj, long offset, int origin)
+{+ jas_stream_fileobj_t *fileobj;
+ JAS_DBGLOG(100, ("file_seek(%p, %ld, %d)\n", obj, offset, origin));+ fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
+ return seek(fileobj->fd, offset, origin);
+}
+
+static int file_close(jas_stream_obj_t *obj)
+{+ int ret;
+ jas_stream_fileobj_t *fileobj;
+ JAS_DBGLOG(100, ("file_close(%p)\n", obj));+ fileobj = JAS_CAST(jas_stream_fileobj_t *, obj);
+ ret = close(fileobj->fd);
+ if (fileobj->flags & JAS_STREAM_FILEOBJ_DELONCLOSE) {+ remove(fileobj->pathname);
+ }
+ jas_free(fileobj);
+ return ret;
+}
+
+/******************************************************************************\
+* Stdio file stream object.
+\******************************************************************************/
+
+/* FIXME integral type */
+static int sfile_read(jas_stream_obj_t *obj, char *buf, unsigned cnt)
+{+ FILE *fp;
+ size_t n;
+ int result;
+ JAS_DBGLOG(100, ("sfile_read(%p, %p, %u)\n", obj, buf, cnt));+ fp = JAS_CAST(FILE *, obj);
+ n = fread(buf, 1, cnt, fp);
+ if (n != cnt) {+ result = (!ferror(fp) && feof(fp)) ? 0 : -1;
+ if(result != 0) {+ return result;
+ }
+ }
+ result = JAS_CAST(int, n);
+ return result;
+}
+
+/* FIXME integral type */
+static int sfile_write(jas_stream_obj_t *obj, const char *buf, unsigned cnt)
+{+ FILE *fp;
+ size_t n;
+ JAS_DBGLOG(100, ("sfile_write(%p, %p, %d)\n", obj, buf, cnt));+ fp = JAS_CAST(FILE *, obj);
+ n = fwrite(buf, 1, cnt, fp);
+ return (n != cnt) ? (-1) : (int)cnt;
+}
+
+/* FIXME integral type */
+static long sfile_seek(jas_stream_obj_t *obj, long offset, int origin)
+{+ FILE *fp;
+ JAS_DBGLOG(100, ("sfile_seek(%p, %ld, %d)\n", obj, offset, origin));+ fp = JAS_CAST(FILE *, obj);
+ return fseek(fp, offset, origin);
+}
+
+static int sfile_close(jas_stream_obj_t *obj)
+{+ FILE *fp;
+ JAS_DBGLOG(100, ("sfile_close(%p)\n", obj));+ fp = JAS_CAST(FILE *, obj);
+ return fclose(fp);
+}
--- /dev/null
+++ b/jas_string.c
@@ -1,0 +1,94 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * String Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes
+\******************************************************************************/
+
+#include "jasper/jas_string.h"
+#include "jasper/jas_malloc.h"
+
+/******************************************************************************\
+* Miscellaneous Functions
+\******************************************************************************/
+
+/* This function is equivalent to the popular but non-standard (and
+ not-always-available) strdup function. */
+
+char *jas_strdup(const char *s)
+{+ size_t n;
+ char *p;
+ n = strlen(s) + 1;
+ if (!(p = jas_malloc(n))) {+ return 0;
+ }
+ strcpy(p, s);
+ return p;
+}
--- /dev/null
+++ b/jasper/jas_cm.h
@@ -1,0 +1,272 @@
+/*
+ * Copyright (c) 2002-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_cm.h
+ * @brief JasPer Color Management
+ */
+
+#ifndef JAS_CM_H
+#define JAS_CM_H
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#include <jasper/jas_icc.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+typedef unsigned jas_clrspc_t;
+
+/* transform operations */
+typedef enum {+ JAS_CMXFORM_OP_FWD = 0,
+ JAS_CMXFORM_OP_REV = 1,
+ JAS_CMXFORM_OP_PROOF = 2,
+ JAS_CMXFORM_OP_GAMUT = 3,
+} jas_cmxform_op_t;
+
+/* rendering intents */
+typedef enum {+ JAS_CMXFORM_INTENT_PER = 0,
+ JAS_CMXFORM_INTENT_RELCLR = 1,
+ JAS_CMXFORM_INTENT_ABSCLR = 2,
+ JAS_CMXFORM_INTENT_SAT = 3,
+} jas_cmxform_intent_t;
+
+#define JAS_CMXFORM_NUMINTENTS 4
+
+typedef enum {+ JAS_CMXFORM_OPTM_SPEED = 0,
+ JAS_CMXFORM_OPTM_SIZE = 1,
+ JAS_CMXFORM_OPTM_ACC = 2,
+} jas_cmxform_optm_t;
+
+
+#define jas_clrspc_create(fam, mbr) (((fam) << 8) | (mbr))
+#define jas_clrspc_fam(clrspc) ((clrspc) >> 8)
+#define jas_clrspc_mbr(clrspc) ((clrspc) & 0xff)
+#define jas_clrspc_isgeneric(clrspc) (!jas_clrspc_mbr(clrspc))
+#define jas_clrspc_isunknown(clrspc) ((clrspc) & JAS_CLRSPC_UNKNOWNMASK)
+
+#define JAS_CLRSPC_UNKNOWNMASK 0x4000
+
+/* color space families */
+#define JAS_CLRSPC_FAM_UNKNOWN 0
+#define JAS_CLRSPC_FAM_XYZ 1
+#define JAS_CLRSPC_FAM_LAB 2
+#define JAS_CLRSPC_FAM_GRAY 3
+#define JAS_CLRSPC_FAM_RGB 4
+#define JAS_CLRSPC_FAM_YCBCR 5
+
+/* specific color spaces */
+#define JAS_CLRSPC_UNKNOWN JAS_CLRSPC_UNKNOWNMASK
+#define JAS_CLRSPC_CIEXYZ jas_clrspc_create(JAS_CLRSPC_FAM_XYZ, 1)
+#define JAS_CLRSPC_CIELAB jas_clrspc_create(JAS_CLRSPC_FAM_LAB, 1)
+#define JAS_CLRSPC_SGRAY jas_clrspc_create(JAS_CLRSPC_FAM_GRAY, 1)
+#define JAS_CLRSPC_SRGB jas_clrspc_create(JAS_CLRSPC_FAM_RGB, 1)
+#define JAS_CLRSPC_SYCBCR jas_clrspc_create(JAS_CLRSPC_FAM_YCBCR, 1)
+
+/* generic color spaces */
+#define JAS_CLRSPC_GENRGB jas_clrspc_create(JAS_CLRSPC_FAM_RGB, 0)
+#define JAS_CLRSPC_GENGRAY jas_clrspc_create(JAS_CLRSPC_FAM_GRAY, 0)
+#define JAS_CLRSPC_GENYCBCR jas_clrspc_create(JAS_CLRSPC_FAM_YCBCR, 0)
+
+#define JAS_CLRSPC_CHANIND_YCBCR_Y 0
+#define JAS_CLRSPC_CHANIND_YCBCR_CB 1
+#define JAS_CLRSPC_CHANIND_YCBCR_CR 2
+
+#define JAS_CLRSPC_CHANIND_RGB_R 0
+#define JAS_CLRSPC_CHANIND_RGB_G 1
+#define JAS_CLRSPC_CHANIND_RGB_B 2
+
+#define JAS_CLRSPC_CHANIND_GRAY_Y 0
+
+typedef double jas_cmreal_t;
+
+struct jas_cmpxform_s;
+
+typedef struct {+ long *buf;
+ unsigned prec;
+ int sgnd;
+ unsigned width;
+ unsigned height;
+} jas_cmcmptfmt_t;
+
+typedef struct {+ unsigned numcmpts;
+ jas_cmcmptfmt_t *cmptfmts;
+} jas_cmpixmap_t;
+
+typedef struct {+ void (*destroy)(struct jas_cmpxform_s *pxform);
+ int (*apply)(const struct jas_cmpxform_s *pxform, const jas_cmreal_t *in, jas_cmreal_t *out, unsigned cnt);
+ void (*dump)(struct jas_cmpxform_s *pxform);
+} jas_cmpxformops_t;
+
+typedef struct {+ jas_cmreal_t *data;
+ unsigned size;
+} jas_cmshapmatlut_t;
+
+typedef struct {+ int mono;
+ int order;
+ int useluts;
+ int usemat;
+ jas_cmshapmatlut_t luts[3];
+ jas_cmreal_t mat[3][4];
+} jas_cmshapmat_t;
+
+typedef struct {+ int order;
+} jas_cmshaplut_t;
+
+typedef struct {+ unsigned inclrspc;
+ unsigned outclrspc;
+} jas_cmclrspcconv_t;
+
+#define jas_align_t double
+
+typedef struct jas_cmpxform_s {+ unsigned refcnt;
+ const jas_cmpxformops_t *ops;
+ unsigned numinchans;
+ unsigned numoutchans;
+ union {+ jas_align_t dummy;
+ jas_cmshapmat_t shapmat;
+ jas_cmshaplut_t shaplut;
+ jas_cmclrspcconv_t clrspcconv;
+ } data;
+} jas_cmpxform_t;
+
+typedef struct {+ unsigned numpxforms;
+ unsigned maxpxforms;
+ jas_cmpxform_t **pxforms;
+} jas_cmpxformseq_t;
+
+typedef struct {+ unsigned numinchans;
+ unsigned numoutchans;
+ jas_cmpxformseq_t *pxformseq;
+} jas_cmxform_t;
+
+#define JAS_CMPROF_TYPE_DEV 1
+#define JAS_CMPROF_TYPE_CLRSPC 2
+
+#define JAS_CMPROF_NUMPXFORMSEQS 13
+
+typedef struct {+ jas_clrspc_t clrspc;
+ unsigned numchans;
+ unsigned refclrspc;
+ unsigned numrefchans;
+ jas_iccprof_t *iccprof;
+ jas_cmpxformseq_t *pxformseqs[JAS_CMPROF_NUMPXFORMSEQS];
+} jas_cmprof_t;
+
+#if 0
+typedef int_fast32_t jas_cmattrname_t;
+typedef int_fast32_t jas_cmattrval_t;
+typedef int_fast32_t jas_cmattrtype_t;
+/* Load a profile. */
+int jas_cmprof_load(jas_cmprof_t *prof, jas_stream_t *in, unsigned fmt);
+/* Save a profile. */
+int jas_cmprof_save(jas_cmprof_t *prof, jas_stream_t *out, unsigned fmt);
+/* Set an attribute of a profile. */
+int jas_cm_prof_setattr(jas_cm_prof_t *prof, jas_cm_attrname_t name, void *val);
+/* Get an attribute of a profile. */
+void *jas_cm_prof_getattr(jas_cm_prof_t *prof, jas_cm_attrname_t name);
+#endif
+
+JAS_DLLEXPORT jas_cmxform_t *jas_cmxform_create(const jas_cmprof_t *inprof, const jas_cmprof_t *outprof,
+ const jas_cmprof_t *proofprof, jas_cmxform_op_t op, jas_cmxform_intent_t intent, jas_cmxform_optm_t optimize);
+
+JAS_DLLEXPORT void jas_cmxform_destroy(jas_cmxform_t *xform);
+
+/* Apply a transform to data. */
+JAS_DLLEXPORT int jas_cmxform_apply(const jas_cmxform_t *xform, const jas_cmpixmap_t *in,
+ jas_cmpixmap_t *out);
+
+/* Create a profile. */
+JAS_DLLEXPORT jas_cmprof_t *jas_cmprof_createfromiccprof(const jas_iccprof_t *iccprof);
+JAS_DLLEXPORT jas_cmprof_t *jas_cmprof_createfromclrspc(jas_clrspc_t clrspc);
+
+/* Destroy a profile. */
+JAS_DLLEXPORT void jas_cmprof_destroy(jas_cmprof_t *prof);
+
+unsigned jas_clrspc_numchans(jas_clrspc_t clrspc);
+JAS_DLLEXPORT jas_iccprof_t *jas_iccprof_createfromcmprof(const jas_cmprof_t *prof);
+
+#define jas_cmprof_clrspc(prof) ((prof)->clrspc)
+JAS_DLLEXPORT jas_cmprof_t *jas_cmprof_copy(const jas_cmprof_t *prof);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_compiler.h
@@ -1,0 +1,103 @@
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_compiler.h
+ * @brief Compiler-related macros.
+ */
+
+#ifndef JAS_COMPILER_H
+#define JAS_COMPILER_H
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#ifdef _MSC_VER
+#ifndef __cplusplus
+#undef inline
+#define inline __inline
+#endif
+#endif
+
+#ifdef __GNUC__
+#define JAS_DEPRECATED __attribute__((deprecated))
+#define JAS_ATTRIBUTE_CONST __attribute__((const))
+#define JAS_ATTRIBUTE_PURE __attribute__((pure))
+#define JAS_FORCE_INLINE inline __attribute__((always_inline))
+#define JAS_UNREACHABLE() __builtin_unreachable()
+#define JAS_LIKELY(x) __builtin_expect (!!(x), 1)
+#define JAS_UNLIKELY(x) __builtin_expect (!!(x), 0)
+#else
+#define JAS_DEPRECATED
+#define JAS_ATTRIBUTE_CONST
+#define JAS_ATTRIBUTE_PURE
+#define JAS_FORCE_INLINE inline
+#define JAS_UNREACHABLE()
+#define JAS_LIKELY(x) (x)
+#define JAS_UNLIKELY(x) (x)
+#endif
+
+#ifdef __clang__
+#define JAS_ATTRIBUTE_DISABLE_USAN \
+ __attribute__((no_sanitize("undefined")))+#elif defined(__GNUC__) && __GNUC__ >= 6
+#define JAS_ATTRIBUTE_DISABLE_USAN \
+ __attribute__((no_sanitize_undefined))
+#else
+#define JAS_ATTRIBUTE_DISABLE_USAN
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_config.h
@@ -1,0 +1,20 @@
+#ifndef JAS_CONFIG_H
+#define JAS_CONFIG_H
+
+#include <u.h>
+#include <libc.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <jasper/jas_compiler.h>
+#include <jasper/jas_dll.h>
+
+#define JAS_VERSION "plan9"
+#define JAS_ENABLE_32BIT 1
+#define JAS_INCLUDE_JP2_CODEC 1
+#define JAS_INCLUDE_JPC_CODEC 1
+#define JAS_DEC_DEFAULT_MAX_SAMPLES (64 * ((size_t) 1048576))
+#define NDEBUG
+
+typedef usize size_t;
+
+#endif
--- /dev/null
+++ b/jasper/jas_debug.h
@@ -1,0 +1,120 @@
+/*
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_debug.h
+ * @brief JasPer Debugging-Related Functionality
+ */
+
+#ifndef JAS_DEBUG_H
+#define JAS_DEBUG_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/******************************************************************************\
+* Macros and functions.
+\******************************************************************************/
+
+/* Output debugging information to standard error provided that the debug
+ level is set sufficiently high. */
+#if !defined(NDEBUG)
+#define JAS_DBGLOG(n, x) \
+ ((jas_getdbglevel() >= (n)) ? (jas_eprintf x) : 0)
+#else
+#define JAS_DBGLOG(n, x)
+#endif
+
+/* Get the library debug level. */
+JAS_ATTRIBUTE_CONST
+JAS_DLLEXPORT int jas_getdbglevel(void);
+
+/* Set the library debug level. */
+JAS_DLLEXPORT int jas_setdbglevel(int dbglevel);
+
+/* Perform formatted output to standard error. */
+JAS_DLLEXPORT int jas_eprintf(const char *fmt, ...);
+
+/* Dump memory to a stream. */
+JAS_DLLEXPORT int jas_memdump(FILE *out, const void *data, size_t len);
+
+/* Warn about use of deprecated functionality. */
+JAS_DLLEXPORT void jas_deprecated(const char *s);
+
+/* Convert to a string literal */
+#define JAS_STRINGIFY(x) #x
+
+/* Convert to a string literal after macro expansion */
+#define JAS_STRINGIFYX(x) JAS_STRINGIFY(x)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_dll.h
@@ -1,0 +1,93 @@
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_dll.h
+ * @brief Shared Library Macros
+ */
+
+#ifndef JAS_DLL_H
+#define JAS_DLL_H
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#if defined(JAS_DLL)
+ #if defined(_WIN32)
+ #if defined(JAS_BUILDING_DLL)
+ #define JAS_DLLEXPORT __declspec(dllexport)
+ #else
+ #define JAS_DLLEXPORT __declspec(dllimport)
+ #endif
+ #define JAS_DLLLOCAL
+ #elif defined(JAS_HAVE_VISIBILITY)
+ #if defined(JAS_BUILDING_DLL)
+ #define JAS_DLLEXPORT __attribute__ ((visibility("default")))+ #define JAS_DLLLOCAL __attribute__ ((visibility("hidden")))+ #else
+ #define JAS_DLLEXPORT
+ #define JAS_DLLLOCAL
+ #endif
+ #else
+ #define JAS_DLLEXPORT
+ #define JAS_DLLLOCAL
+ #endif
+#else
+ #define JAS_DLLEXPORT
+ #define JAS_DLLLOCAL
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_fix.h
@@ -1,0 +1,349 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_fix.h
+ * @brief JasPer Fixed-Point Number Class
+ */
+
+#ifndef JAS_FIX_H
+#define JAS_FIX_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h> /* IWYU pragma: keep */
+
+#include <jasper/jas_types.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/* The representation of the value zero. */
+#define JAS_FIX_ZERO(fix_t, fracbits) \
+ JAS_INTTOFIX(fix_t, fracbits, 0)
+
+/* The representation of the value one. */
+#define JAS_FIX_ONE(fix_t, fracbits) \
+ JAS_INTTOFIX(fix_t, fracbits, 1)
+
+/* The representation of the value one half. */
+#define JAS_FIX_HALF(fix_t, fracbits) \
+ (JAS_CAST(fix_t, 1) << ((fracbits) - 1))
+
+/******************************************************************************\
+* Conversion operations.
+\******************************************************************************/
+
+/* Convert an int to a fixed-point number. */
+#define JAS_INTTOFIX(fix_t, fracbits, x) \
+ (JAS_CAST(fix_t, x) << (fracbits))
+
+/* Convert a fixed-point number to an int. */
+#define JAS_FIXTOINT(fix_t, fracbits, x) \
+ JAS_CAST(int, (x) >> (fracbits))
+
+/* Convert a fixed-point number to a double. */
+#define JAS_FIXTODBL(fix_t, fracbits, x) \
+ (JAS_CAST(double, x) / JAS_FIX_ONE(fix_t, fracbits))
+
+/* Convert a double to a fixed-point number. */
+#define JAS_DBLTOFIX(fix_t, fracbits, x) \
+ JAS_CAST(fix_t, ((x) * JAS_CAST(double, JAS_FIX_ONE(fix_t, fracbits))))
+
+/******************************************************************************\
+* Basic arithmetic operations.
+* All other arithmetic operations are synthesized from these basic operations.
+* There are three macros for each type of arithmetic operation.
+* One macro always performs overflow/underflow checking, one never performs
+* overflow/underflow checking, and one is generic with its behavior
+* depending on compile-time flags.
+* Only the generic macros should be invoked directly by application code.
+\******************************************************************************/
+
+/* Calculate the sum of two fixed-point numbers. */
+#if !defined(DEBUG_OVERFLOW)
+#define JAS_FIX_ADD JAS_FIX_ADD_FAST
+#else
+#define JAS_FIX_ADD JAS_FIX_ADD_OFLOW
+#endif
+
+/* Calculate the sum of two fixed-point numbers without overflow checking. */
+#define JAS_FIX_ADD_FAST(fix_t, fracbits, x, y) ((x) + (y))
+
+/* Calculate the sum of two fixed-point numbers with overflow checking. */
+#define JAS_FIX_ADD_OFLOW(fix_t, fracbits, x, y) \
+ ((x) >= 0) ? \
+ (((y) >= 0) ? ((x) + (y) >= 0 || JAS_FIX_OFLOW(), (x) + (y)) : \
+ ((x) + (y))) : \
+ (((y) >= 0) ? ((x) + (y)) : ((x) + (y) < 0 || JAS_FIX_OFLOW(), \
+ (x) + (y)))
+
+/* Calculate the product of two fixed-point numbers. */
+#if !defined(DEBUG_OVERFLOW)
+#define JAS_FIX_MUL JAS_FIX_MUL_FAST
+#else
+#define JAS_FIX_MUL JAS_FIX_MUL_OFLOW
+#endif
+
+/* Calculate the product of two fixed-point numbers without overflow
+ checking. */
+#define JAS_FIX_MUL_FAST(fix_t, fracbits, bigfix_t, x, y) \
+ JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y)) >> \
+ (fracbits))
+
+/* Calculate the product of two fixed-point numbers with overflow
+ checking. */
+#define JAS_FIX_MUL_OFLOW(fix_t, fracbits, bigfix_t, x, y) \
+ ((JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> (fracbits)) == \
+ JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \
+ (fracbits))) ? \
+ JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) * JAS_CAST(bigfix_t, y) >> \
+ (fracbits))) : JAS_FIX_OFLOW())
+
+/* Calculate the product of a fixed-point number and an int. */
+#if !defined(DEBUG_OVERFLOW)
+#define JAS_FIX_MULBYINT JAS_FIX_MULBYINT_FAST
+#else
+#define JAS_FIX_MULBYINT JAS_FIX_MULBYINT_OFLOW
+#endif
+
+/* Calculate the product of a fixed-point number and an int without overflow
+ checking. */
+#define JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y) \
+ JAS_CAST(fix_t, ((x) * (y)))
+
+/* Calculate the product of a fixed-point number and an int with overflow
+ checking. */
+#define JAS_FIX_MULBYINT_OFLOW(fix_t, fracbits, x, y) \
+ JAS_FIX_MULBYINT_FAST(fix_t, fracbits, x, y)
+
+/* Calculate the quotient of two fixed-point numbers. */
+#if !defined(DEBUG_OVERFLOW)
+#define JAS_FIX_DIV JAS_FIX_DIV_FAST
+#else
+#define JAS_FIX_DIV JAS_FIX_DIV_UFLOW
+#endif
+
+/* Calculate the quotient of two fixed-point numbers without underflow
+ checking. */
+#define JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y) \
+ JAS_CAST(fix_t, (JAS_CAST(bigfix_t, x) << (fracbits)) / (y))
+
+/* Calculate the quotient of two fixed-point numbers with underflow
+ checking. */
+#define JAS_FIX_DIV_UFLOW(fix_t, fracbits, bigfix_t, x, y) \
+ JAS_FIX_DIV_FAST(fix_t, fracbits, bigfix_t, x, y)
+
+/* Negate a fixed-point number. */
+#if !defined(DEBUG_OVERFLOW)
+#define JAS_FIX_NEG JAS_FIX_NEG_FAST
+#else
+#define JAS_FIX_NEG JAS_FIX_NEG_OFLOW
+#endif
+
+/* Negate a fixed-point number without overflow checking. */
+#define JAS_FIX_NEG_FAST(fix_t, fracbits, x) \
+ (-(x))
+
+/* Negate a fixed-point number with overflow checking. */
+/* Yes, overflow is actually possible for two's complement representations,
+ although highly unlikely to occur. */
+#define JAS_FIX_NEG_OFLOW(fix_t, fracbits, x) \
+ (((x) < 0) ? (-(x) > 0 || JAS_FIX_OFLOW(), -(x)) : (-(x)))
+
+/* Perform an arithmetic shift left of a fixed-point number. */
+#if !defined(DEBUG_OVERFLOW)
+#define JAS_FIX_ASL JAS_FIX_ASL_FAST
+#else
+#define JAS_FIX_ASL JAS_FIX_ASL_OFLOW
+#endif
+
+/* Perform an arithmetic shift left of a fixed-point number without overflow
+ checking. */
+#define JAS_FIX_ASL_FAST(fix_t, fracbits, x, n) \
+ ((x) << (n))
+
+/* Perform an arithmetic shift left of a fixed-point number with overflow
+ checking. */
+#define JAS_FIX_ASL_OFLOW(fix_t, fracbits, x, n) \
+ ((((x) << (n)) >> (n)) == (x) || JAS_FIX_OFLOW(), (x) << (n))
+
+/* Perform an arithmetic shift right of a fixed-point number. */
+#if !defined(DEBUG_OVERFLOW)
+#define JAS_FIX_ASR JAS_FIX_ASR_FAST
+#else
+#define JAS_FIX_ASR JAS_FIX_ASR_UFLOW
+#endif
+
+/* Perform an arithmetic shift right of a fixed-point number without underflow
+ checking. */
+#define JAS_FIX_ASR_FAST(fix_t, fracbits, x, n) \
+ ((x) >> (n))
+
+/* Perform an arithmetic shift right of a fixed-point number with underflow
+ checking. */
+#define JAS_FIX_ASR_UFLOW(fix_t, fracbits, x, n) \
+ JAS_FIX_ASR_FAST(fix_t, fracbits, x, n)
+
+/******************************************************************************\
+* Other basic arithmetic operations.
+\******************************************************************************/
+
+/* Calculate the difference between two fixed-point numbers. */
+#define JAS_FIX_SUB(fix_t, fracbits, x, y) \
+ JAS_FIX_ADD(fix_t, fracbits, x, JAS_FIX_NEG(fix_t, fracbits, y))
+
+/* Add one fixed-point number to another. */
+#define JAS_FIX_PLUSEQ(fix_t, fracbits, x, y) \
+ ((x) = JAS_FIX_ADD(fix_t, fracbits, x, y))
+
+/* Subtract one fixed-point number from another. */
+#define JAS_FIX_MINUSEQ(fix_t, fracbits, x, y) \
+ ((x) = JAS_FIX_SUB(fix_t, fracbits, x, y))
+
+/* Multiply one fixed-point number by another. */
+#define JAS_FIX_MULEQ(fix_t, fracbits, bigfix_t, x, y) \
+ ((x) = JAS_FIX_MUL(fix_t, fracbits, bigfix_t, x, y))
+
+/******************************************************************************\
+* Miscellaneous operations.
+\******************************************************************************/
+
+/* Calculate the absolute value of a fixed-point number. */
+#define JAS_FIX_ABS(fix_t, fracbits, x) \
+ (((x) >= 0) ? (x) : (JAS_FIX_NEG(fix_t, fracbits, x)))
+
+/* Is a fixed-point number an integer? */
+#define JAS_FIX_ISINT(fix_t, fracbits, x) \
+ (JAS_FIX_FLOOR(fix_t, fracbits, x) == (x))
+
+/* Get the sign of a fixed-point number. */
+#define JAS_FIX_SGN(fix_t, fracbits, x) \
+ ((x) >= 0 ? 1 : (-1))
+
+/******************************************************************************\
+* Relational operations.
+\******************************************************************************/
+
+/* Compare two fixed-point numbers. */
+#define JAS_FIX_CMP(fix_t, fracbits, x, y) \
+ ((x) > (y) ? 1 : (((x) == (y)) ? 0 : (-1)))
+
+/* Less than. */
+#define JAS_FIX_LT(fix_t, fracbits, x, y) \
+ ((x) < (y))
+
+/* Less than or equal. */
+#define JAS_FIX_LTE(fix_t, fracbits, x, y) \
+ ((x) <= (y))
+
+/* Greater than. */
+#define JAS_FIX_GT(fix_t, fracbits, x, y) \
+ ((x) > (y))
+
+/* Greater than or equal. */
+#define JAS_FIX_GTE(fix_t, fracbits, x, y) \
+ ((x) >= (y))
+
+/******************************************************************************\
+* Rounding functions.
+\******************************************************************************/
+
+/* Round a fixed-point number to the nearest integer. */
+#define JAS_FIX_ROUND(fix_t, fracbits, x) \
+ (((x) < 0) ? JAS_FIX_FLOOR(fix_t, fracbits, JAS_FIX_ADD(fix_t, fracbits, \
+ (x), JAS_FIX_HALF(fix_t, fracbits))) : \
+ JAS_FIX_NEG(fix_t, fracbits, JAS_FIX_FLOOR(fix_t, fracbits, \
+ JAS_FIX_ADD(fix_t, fracbits, (-(x)), JAS_FIX_HALF(fix_t, fracbits)))))
+
+/* Round a fixed-point number to the nearest integer in the direction of
+ negative infinity (i.e., the floor function). */
+#define JAS_FIX_FLOOR(fix_t, fracbits, x) \
+ ((x) & (~(JAS_FIX_ONE(fix_t, fracbits) - 1)))
+
+/******************************************************************************\
+* The below macros are for internal library use only. Do not invoke them
+* directly in application code.
+\******************************************************************************/
+
+/* Handle overflow. */
+#define JAS_FIX_OFLOW() \
+ jas_eprintf("overflow error: file %s, line %d\n", __FILE__, __LINE__)+
+/* Handle underflow. */
+#define JAS_FIX_UFLOW() \
+ jas_eprintf("underflow error: file %s, line %d\n", __FILE__, __LINE__)+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_icc.h
@@ -1,0 +1,417 @@
+/*
+ * Copyright (c) 2002-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_icc.h
+ * @brief ICC Profile
+ */
+
+#ifndef JAS_ICC_H
+#define JAS_ICC_H
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#include <jasper/jas_types.h>
+#include <jasper/jas_stream.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/* Profile file signature. */
+#define JAS_ICC_MAGIC 0x61637370
+
+#define JAS_ICC_HDRLEN 128
+
+/* Profile/device class signatures. */
+#define JAS_ICC_CLAS_IN 0x73636e72 /* input device */
+#define JAS_ICC_CLAS_DPY 0x6d6e7472 /* display device */
+#define JAS_ICC_CLAS_OUT 0x70727472 /* output device */
+#define JAS_ICC_CLAS_LNK 0x6c696e6b /* device link */
+#define JAS_ICC_CLAS_CNV 0x73706163 /* color space conversion */
+#define JAS_ICC_CLAS_ABS 0x61627374 /* abstract */
+#define JAS_ICC_CLAS_NAM 0x6e6d636c /* named color */
+
+/* Color space signatures. */
+#define JAS_ICC_COLORSPC_XYZ 0x58595a20 /* XYZ */
+#define JAS_ICC_COLORSPC_LAB 0x4c616220 /* LAB */
+#define JAS_ICC_COLORSPC_LUV 0x4c757620 /* LUV */
+#define JAS_ICC_COLORSPC_YCBCR 0x59436272 /* YCbCr */
+#define JAS_ICC_COLORSPC_YXY 0x59787920 /* Yxy */
+#define JAS_ICC_COLORSPC_RGB 0x52474220 /* RGB */
+#define JAS_ICC_COLORSPC_GRAY 0x47524159 /* Gray */
+#define JAS_ICC_COLORSPC_HSV 0x48535620 /* HSV */
+#define JAS_ICC_COLORSPC_HLS 0x484c5320 /* HLS */
+#define JAS_ICC_COLORSPC_CMYK 0x434d594b /* CMYK */
+#define JAS_ICC_COLORSPC_CMY 0x434d5920 /* CMY */
+#define JAS_ICC_COLORSPC_2 0x32434c52 /* 2 channel color */
+#define JAS_ICC_COLORSPC_3 0x33434c52 /* 3 channel color */
+#define JAS_ICC_COLORSPC_4 0x34434c52 /* 4 channel color */
+#define JAS_ICC_COLORSPC_5 0x35434c52 /* 5 channel color */
+#define JAS_ICC_COLORSPC_6 0x36434c52 /* 6 channel color */
+#define JAS_ICC_COLORSPC_7 0x37434c52 /* 7 channel color */
+#define JAS_ICC_COLORSPC_8 0x38434c52 /* 8 channel color */
+#define JAS_ICC_COLORSPC_9 0x39434c52 /* 9 channel color */
+#define JAS_ICC_COLORSPC_10 0x41434c52 /* 10 channel color */
+#define JAS_ICC_COLORSPC_11 0x42434c52 /* 11 channel color */
+#define JAS_ICC_COLORSPC_12 0x43434c52 /* 12 channel color */
+#define JAS_ICC_COLORSPC_13 0x44434c52 /* 13 channel color */
+#define JAS_ICC_COLORSPC_14 0x45434c52 /* 14 channel color */
+#define JAS_ICC_COLORSPC_15 0x46434c52 /* 15 channel color */
+
+/* Profile connection color space (PCS) signatures. */
+#define JAS_ICC_REFCOLORSPC_XYZ 0x58595a20 /* CIE XYZ */
+#define JAS_ICC_REFCOLORSPC_LAB 0x4c616220 /* CIE Lab */
+
+/* Primary platform signatures. */
+#define JAS_ICC_PLATFORM_APPL 0x4150504c /* Apple Computer */
+#define JAS_ICC_PLATFORM_MSFT 0x4d534654 /* Microsoft */
+#define JAS_ICC_PLATFORM_SGI 0x53474920 /* Silicon Graphics */
+#define JAS_ICC_PLATFORM_SUNW 0x53554e57 /* Sun Microsystems */
+#define JAS_ICC_PLATFORM_TGNT 0x54474e54 /* Taligent */
+
+/* Profile flags. */
+#define JAS_ICC_FLAGS_EMBED 0x01 /* embedded */
+#define JAS_ICC_FLAGS_NOSEP 0x02 /* no separate use */
+
+/* Attributes. */
+#define JAS_ICC_ATTR_TRANS 0x01 /* transparent */
+#define JAS_ICC_ATTR_MATTE 0x02 /* matte */
+
+/* Rendering intents. */
+#define JAS_ICC_INTENT_PER 0 /* perceptual */
+#define JAS_ICC_INTENT_REL 1 /* relative colorimetric */
+#define JAS_ICC_INTENT_SAT 2 /* saturation */
+#define JAS_ICC_INTENT_ABS 3 /* absolute colorimetric */
+
+/* Tag signatures. */
+#define JAS_ICC_TAG_ATOB0 0x41324230 /* */
+#define JAS_ICC_TAG_ATOB1 0x41324231 /* */
+#define JAS_ICC_TAG_ATOB2 0x41324232 /* */
+#define JAS_ICC_TAG_BLUMATCOL 0x6258595a /* */
+#define JAS_ICC_TAG_BLUTRC 0x62545243 /* */
+#define JAS_ICC_TAG_BTOA0 0x42324130 /* */
+#define JAS_ICC_TAG_BTOA1 0x42324131 /* */
+#define JAS_ICC_TAG_BTOA2 0x42324132 /* */
+#define JAS_ICC_TAG_CALTIME 0x63616c74 /* */
+#define JAS_ICC_TAG_CHARTARGET 0x74617267 /* */
+#define JAS_ICC_TAG_CPYRT 0x63707274 /* */
+#define JAS_ICC_TAG_CRDINFO 0x63726469 /* */
+#define JAS_ICC_TAG_DEVMAKERDESC 0x646d6e64 /* */
+#define JAS_ICC_TAG_DEVMODELDESC 0x646d6464 /* */
+#define JAS_ICC_TAG_DEVSET 0x64657673 /* */
+#define JAS_ICC_TAG_GAMUT 0x67616d74 /* */
+#define JAS_ICC_TAG_GRYTRC 0x6b545243 /* */
+#define JAS_ICC_TAG_GRNMATCOL 0x6758595a /* */
+#define JAS_ICC_TAG_GRNTRC 0x67545243 /* */
+#define JAS_ICC_TAG_LUM 0x6c756d69 /* */
+#define JAS_ICC_TAG_MEASURE 0x6d656173 /* */
+#define JAS_ICC_TAG_MEDIABLKPT 0x626b7074 /* */
+#define JAS_ICC_TAG_MEDIAWHIPT 0x77747074 /* */
+#define JAS_ICC_TAG_NAMCOLR 0x6e636f6c /* */
+#define JAS_ICC_TAG_NAMCOLR2 0x6e636c32 /* */
+#define JAS_ICC_TAG_OUTRESP 0x72657370 /* */
+#define JAS_ICC_TAG_PREVIEW0 0x70726530 /* */
+#define JAS_ICC_TAG_PREVIEW1 0x70726531 /* */
+#define JAS_ICC_TAG_PREVIEW2 0x70726532 /* */
+#define JAS_ICC_TAG_PROFDESC 0x64657363 /* */
+#define JAS_ICC_TAG_PROFSEQDESC 0x70736571 /* */
+#define JAS_ICC_TAG_PSDCRD0 0x70736430 /* */
+#define JAS_ICC_TAG_PSCRDD1 0x70736431 /* */
+#define JAS_ICC_TAG_PSCRDD2 0x70736432 /* */
+#define JAS_ICC_TAG_PSCRDD3 0x70736433 /* */
+#define JAS_ICC_TAG_PS2CSA 0x70733273 /* */
+#define JAS_ICC_TAG_PS2RENINTENT 0x70733269 /* */
+#define JAS_ICC_TAG_REDMATCOL 0x7258595a /* */
+#define JAS_ICC_TAG_REDTRC 0x72545243 /* */
+#define JAS_ICC_TAG_SCRNGDES 0x73637264 /* */
+#define JAS_ICC_TAG_SCRNG 0x7363726e /* */
+#define JAS_ICC_TAG_TECH 0x74656368 /* */
+#define JAS_ICC_TAG_UCRBG 0x62666420 /* */
+#define JAS_ICC_TAG_VIEWCONDDESC 0x76756564 /* */
+#define JAS_ICC_TAG_VIEWCOND 0x76696577 /* */
+
+/* Type signatures. */
+#define JAS_ICC_TYPE_CRDINFO 0x63726469 /* CRD information */
+#define JAS_ICC_TYPE_CURV 0x63757276 /* curve */
+#define JAS_ICC_TYPE_DATA 0x64617461 /* data */
+#define JAS_ICC_TYPE_TIME 0x6474696d /* date/time */
+#define JAS_ICC_TYPE_DEVSET 0x64657673 /* device settings */
+#define JAS_ICC_TYPE_LUT16 0x6d667432 /* */
+#define JAS_ICC_TYPE_LUT8 0x6d667431 /* */
+#define JAS_ICC_TYPE_MEASURE 0x6d656173 /* */
+#define JAS_ICC_TYPE_NAMCOLR 0x6e636f6c /* */
+#define JAS_ICC_TYPE_NAMCOLR2 0x6e636c32 /* */
+#define JAS_ICC_TYPE_PROFSEQDESC 0x70736571 /* profile sequence description */
+#define JAS_ICC_TYPE_RESPCURVSET16 0x72637332 /* response curve set 16 */
+#define JAS_ICC_TYPE_SF32 0x73663332 /* signed 32-bit fixed-point */
+#define JAS_ICC_TYPE_SCRNG 0x7363726e /* screening */
+#define JAS_ICC_TYPE_SIG 0x73696720 /* signature */
+#define JAS_ICC_TYPE_TXTDESC 0x64657363 /* text description */
+#define JAS_ICC_TYPE_TXT 0x74657874 /* text */
+#define JAS_ICC_TYPE_UF32 0x75663332 /* unsigned 32-bit fixed-point */
+#define JAS_ICC_TYPE_UCRBG 0x62666420 /* */
+#define JAS_ICC_TYPE_UI16 0x75693136 /* */
+#define JAS_ICC_TYPE_UI32 0x75693332 /* */
+#define JAS_ICC_TYPE_UI8 0x75693038 /* */
+#define JAS_ICC_TYPE_UI64 0x75693634 /* */
+#define JAS_ICC_TYPE_VIEWCOND 0x76696577 /* */
+#define JAS_ICC_TYPE_XYZ 0x58595a20 /* XYZ */
+
+typedef uint_fast8_t jas_iccuint8_t;
+typedef uint_fast16_t jas_iccuint16_t;
+typedef uint_fast32_t jas_iccuint32_t;
+typedef int_fast32_t jas_iccsint32_t;
+typedef int_fast32_t jas_iccs15fixed16_t;
+typedef uint_fast32_t jas_iccu16fixed16_t;
+typedef uint_fast64_t jas_iccuint64_t;
+typedef uint_fast32_t jas_iccsig_t;
+
+typedef jas_iccsig_t jas_icctagsig_t;
+typedef jas_iccsig_t jas_icctagtype_t;
+typedef jas_iccsig_t jas_iccattrname_t;
+
+/* Date/time type. */
+typedef struct {+ jas_iccuint16_t year;
+ jas_iccuint16_t month;
+ jas_iccuint16_t day;
+ jas_iccuint16_t hour;
+ jas_iccuint16_t min;
+ jas_iccuint16_t sec;
+} jas_icctime_t;
+
+/* XYZ type. */
+typedef struct {+ jas_iccs15fixed16_t x;
+ jas_iccs15fixed16_t y;
+ jas_iccs15fixed16_t z;
+} jas_iccxyz_t;
+
+/* Curve type. */
+typedef struct {+ jas_iccuint32_t numents;
+ jas_iccuint16_t *ents;
+} jas_icccurv_t;
+
+/* Text description type. */
+typedef struct {+ jas_iccuint32_t asclen;
+ char *ascdata; /* ASCII invariant description */
+ jas_iccuint32_t uclangcode; /* Unicode language code */
+ jas_iccuint32_t uclen; /* Unicode localizable description count */
+ jas_uchar *ucdata; /* Unicode localizable description */
+ jas_iccuint16_t sccode; /* ScriptCode code */
+ jas_iccuint8_t maclen; /* Localizable Macintosh description count */
+ jas_uchar macdata[69]; /* Localizable Macintosh description */
+} jas_icctxtdesc_t;
+
+/* Text type. */
+typedef struct {+ char *string; /* ASCII character string */
+} jas_icctxt_t;
+
+typedef struct {+ jas_iccuint8_t numinchans;
+ jas_iccuint8_t numoutchans;
+ jas_iccsint32_t e[3][3];
+ jas_iccuint8_t clutlen;
+ jas_iccuint8_t *clut;
+ jas_iccuint16_t numintabents;
+ jas_iccuint8_t **intabs;
+ jas_iccuint8_t *intabsbuf;
+ jas_iccuint16_t numouttabents;
+ jas_iccuint8_t **outtabs;
+ jas_iccuint8_t *outtabsbuf;
+} jas_icclut8_t;
+
+typedef struct {+ jas_iccuint8_t numinchans;
+ jas_iccuint8_t numoutchans;
+ jas_iccsint32_t e[3][3];
+ jas_iccuint8_t clutlen;
+ jas_iccuint16_t *clut;
+ jas_iccuint16_t numintabents;
+ jas_iccuint16_t **intabs;
+ jas_iccuint16_t *intabsbuf;
+ jas_iccuint16_t numouttabents;
+ jas_iccuint16_t **outtabs;
+ jas_iccuint16_t *outtabsbuf;
+} jas_icclut16_t;
+
+struct jas_iccattrval_s;
+
+typedef struct {+ void (*destroy)(struct jas_iccattrval_s *);
+ int (*copy)(struct jas_iccattrval_s *, const struct jas_iccattrval_s *);
+ int (*input)(struct jas_iccattrval_s *, jas_stream_t *, unsigned);
+//#ifdef JAS_ENABLE_ENCODER
+ int (*output)(struct jas_iccattrval_s *, jas_stream_t *);
+//#endif
+ unsigned (*getsize)(const struct jas_iccattrval_s *);
+ void (*dump)(const struct jas_iccattrval_s *, FILE *);
+} jas_iccattrvalops_t;
+
+/* Attribute value type (type and value information). */
+typedef struct jas_iccattrval_s {+ unsigned refcnt; /* reference count */
+ jas_iccsig_t type; /* type */
+ const jas_iccattrvalops_t *ops; /* type-dependent operations */
+ union {+ jas_iccxyz_t xyz;
+ jas_icccurv_t curv;
+ jas_icctxtdesc_t txtdesc;
+ jas_icctxt_t txt;
+ jas_icclut8_t lut8;
+ jas_icclut16_t lut16;
+ } data; /* value */
+} jas_iccattrval_t;
+
+/* Header type. */
+typedef struct {+ jas_iccuint32_t size; /* profile size */
+ jas_iccsig_t cmmtype; /* CMM type signature */
+ jas_iccuint32_t version; /* profile version */
+ jas_iccsig_t clas; /* profile/device class signature */
+ jas_iccsig_t colorspc; /* color space of data */
+ jas_iccsig_t refcolorspc; /* profile connection space */
+ jas_icctime_t ctime; /* creation time */
+ jas_iccsig_t magic; /* profile file signature */
+ jas_iccsig_t platform; /* primary platform */
+ jas_iccuint32_t flags; /* profile flags */
+ jas_iccsig_t maker; /* device manufacturer signature */
+ jas_iccsig_t model; /* device model signature */
+ jas_iccuint64_t attr; /* device setup attributes */
+ jas_iccsig_t intent; /* rendering intent */
+ jas_iccxyz_t illum; /* illuminant */
+ jas_iccsig_t creator; /* profile creator signature */
+} jas_icchdr_t;
+
+typedef struct {+ jas_iccsig_t name;
+ jas_iccattrval_t *val;
+} jas_iccattr_t;
+
+typedef struct {+ unsigned numattrs;
+ unsigned maxattrs;
+ jas_iccattr_t *attrs;
+} jas_iccattrtab_t;
+
+typedef struct jas_icctagtabent_s {+ jas_iccuint32_t tag;
+ jas_iccuint32_t off;
+ jas_iccuint32_t len;
+ void *data;
+ struct jas_icctagtabent_s *first;
+} jas_icctagtabent_t;
+
+typedef struct {+ jas_iccuint32_t numents;
+ jas_icctagtabent_t *ents;
+} jas_icctagtab_t;
+
+/* ICC profile type. */
+typedef struct {+ jas_icchdr_t hdr;
+ jas_icctagtab_t tagtab;
+ jas_iccattrtab_t *attrtab;
+} jas_iccprof_t;
+
+typedef struct {+ jas_iccuint32_t type;
+ jas_iccattrvalops_t ops;
+} jas_iccattrvalinfo_t;
+
+JAS_DLLEXPORT jas_iccprof_t *jas_iccprof_load(jas_stream_t *in);
+JAS_DLLEXPORT int jas_iccprof_save(jas_iccprof_t *prof, jas_stream_t *out);
+JAS_DLLEXPORT void jas_iccprof_destroy(jas_iccprof_t *prof);
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT jas_iccattrval_t *jas_iccprof_getattr(const jas_iccprof_t *prof,
+ jas_iccattrname_t name);
+JAS_DLLEXPORT int jas_iccprof_setattr(jas_iccprof_t *prof, jas_iccattrname_t name,
+ jas_iccattrval_t *val);
+JAS_DLLEXPORT void jas_iccprof_dump(const jas_iccprof_t *prof, FILE *out);
+JAS_DLLEXPORT jas_iccprof_t *jas_iccprof_copy(const jas_iccprof_t *prof);
+JAS_DLLEXPORT int jas_iccprof_gethdr(const jas_iccprof_t *prof, jas_icchdr_t *hdr);
+JAS_DLLEXPORT int jas_iccprof_sethdr(jas_iccprof_t *prof, const jas_icchdr_t *hdr);
+
+JAS_DLLEXPORT void jas_iccattrval_destroy(jas_iccattrval_t *attrval);
+JAS_DLLEXPORT void jas_iccattrval_dump(const jas_iccattrval_t *attrval, FILE *out);
+JAS_DLLEXPORT int jas_iccattrval_allowmodify(jas_iccattrval_t **attrval);
+JAS_DLLEXPORT jas_iccattrval_t *jas_iccattrval_clone(jas_iccattrval_t *attrval);
+JAS_DLLEXPORT jas_iccattrval_t *jas_iccattrval_create(jas_iccuint32_t type);
+
+JAS_DLLEXPORT void jas_iccattrtab_dump(const jas_iccattrtab_t *attrtab, FILE *out);
+
+JAS_DLLEXPORT extern const jas_uchar jas_iccprofdata_srgb[];
+JAS_DLLEXPORT extern const unsigned jas_iccprofdata_srgblen;
+JAS_DLLEXPORT extern const jas_uchar jas_iccprofdata_sgray[];
+JAS_DLLEXPORT extern const unsigned jas_iccprofdata_sgraylen;
+JAS_DLLEXPORT jas_iccprof_t *jas_iccprof_createfrombuf(const jas_uchar *buf, unsigned len);
+JAS_DLLEXPORT jas_iccprof_t *jas_iccprof_createfromclrspc(unsigned clrspc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_image.h
@@ -1,0 +1,772 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_image.h
+ * @brief JasPer Image Class
+ */
+
+#ifndef JAS_IMAGE_H
+#define JAS_IMAGE_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#include <jasper/jas_stream.h>
+#include <jasper/jas_types.h>
+#include <jasper/jas_seq.h> /* IWYU pragma: export */
+#include <jasper/jas_cm.h> /* IWYU pragma: export */
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/*!
+ * @addtogroup image
+ * @{+ */
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/*
+ * Miscellaneous constants.
+ */
+
+/* Basic units */
+#define JAS_IMAGE_KIBI (JAS_CAST(size_t, 1024))
+#define JAS_IMAGE_MEBI (JAS_IMAGE_KIBI * JAS_IMAGE_KIBI)
+
+/* The threshold at which image data is no longer stored in memory. */
+#define JAS_IMAGE_INMEMTHRESH (256 * JAS_IMAGE_MEBI)
+
+/*
+ * Component types
+ */
+
+#define JAS_IMAGE_CT_UNKNOWN 0x10000
+#define JAS_IMAGE_CT_COLOR(n) ((n) & 0x7fff)
+#define JAS_IMAGE_CT_OPACITY 0x08000
+
+#define JAS_IMAGE_CT_RGB_R 0
+#define JAS_IMAGE_CT_RGB_G 1
+#define JAS_IMAGE_CT_RGB_B 2
+
+#define JAS_IMAGE_CT_YCBCR_Y 0
+#define JAS_IMAGE_CT_YCBCR_CB 1
+#define JAS_IMAGE_CT_YCBCR_CR 2
+
+#define JAS_IMAGE_CT_GRAY_Y 0
+
+/******************************************************************************\
+* Simple types.
+\******************************************************************************/
+
+/*!
+@brief Image coordinate. */
+typedef int_fast32_t jas_image_coord_t;
+#define JAS_IMAGE_COORD_MAX INT_FAST32_MAX
+#define JAS_IMAGE_COORD_MIN INT_FAST32_MIN
+
+/*!
+@brief Color space (e.g., RGB, YCbCr).
+*/
+typedef int_fast16_t jas_image_colorspc_t;
+
+/*!
+@brief Component type (e.g., color, opacity).
+*/
+typedef int_fast32_t jas_image_cmpttype_t;
+
+/*!
+@brief Component sample data format
+(e.g., real/integer, signedness, precision).
+*/
+typedef int_fast16_t jas_image_smpltype_t;
+
+/******************************************************************************\
+* Image class and supporting classes.
+\******************************************************************************/
+
+/*!
+@brief Image component class.
+*/
+typedef struct {+
+ jas_image_coord_t tlx_;
+ /* The x-coordinate of the top-left corner of the component. */
+
+ jas_image_coord_t tly_;
+ /* The y-coordinate of the top-left corner of the component. */
+
+ jas_image_coord_t hstep_;
+ /* The horizontal sampling period in units of the reference grid. */
+
+ jas_image_coord_t vstep_;
+ /* The vertical sampling period in units of the reference grid. */
+
+ jas_image_coord_t width_;
+ /* The component width in samples. */
+
+ jas_image_coord_t height_;
+ /* The component height in samples. */
+
+ unsigned prec_;
+ /* The precision of the sample data (i.e., the number of bits per
+ sample). If the samples are signed values, this quantity
+ includes the sign bit. */
+
+ int sgnd_;
+ /* The signedness of the sample data. */
+
+ jas_stream_t *stream_;
+ /* The stream containing the component data. */
+
+ unsigned cps_;
+ /* The number of characters per sample in the stream. */
+
+ jas_image_cmpttype_t type_;
+ /* The type of component (e.g., opacity, red, green, blue, luma). */
+
+} jas_image_cmpt_t;
+
+/*!
+@brief Image class.
+*/
+typedef struct {+
+ jas_image_coord_t tlx_;
+ /* The x-coordinate of the top-left corner of the image bounding box. */
+
+ jas_image_coord_t tly_;
+ /* The y-coordinate of the top-left corner of the image bounding box. */
+
+ jas_image_coord_t brx_;
+ /* The x-coordinate of the bottom-right corner of the image bounding
+ box (plus one). */
+
+ jas_image_coord_t bry_;
+ /* The y-coordinate of the bottom-right corner of the image bounding
+ box (plus one). */
+
+ unsigned numcmpts_;
+ /* The number of components. */
+
+ unsigned maxcmpts_;
+ /* The maximum number of components that this image can have (i.e., the
+ allocated size of the components array). */
+
+ jas_image_cmpt_t **cmpts_;
+ /* Per-component information. */
+
+ jas_clrspc_t clrspc_;
+
+ jas_cmprof_t *cmprof_;
+
+// bool inmem_;
+
+} jas_image_t;
+
+/*!
+@brief Component parameters class.
+
+@details
+This data type exists solely/mainly for the purposes of the
+jas_image_create function.
+*/
+typedef struct {+
+ jas_image_coord_t tlx;
+ /* The x-coordinate of the top-left corner of the component. */
+
+ jas_image_coord_t tly;
+ /* The y-coordinate of the top-left corner of the component. */
+
+ jas_image_coord_t hstep;
+ /* The horizontal sampling period in units of the reference grid. */
+
+ jas_image_coord_t vstep;
+ /* The vertical sampling period in units of the reference grid. */
+
+ jas_image_coord_t width;
+ /* The width of the component in samples. */
+
+ jas_image_coord_t height;
+ /* The height of the component in samples. */
+
+ unsigned prec;
+ /* The precision of the component sample data. */
+
+ int sgnd;
+ /* The signedness of the component sample data. */
+
+} jas_image_cmptparm_t;
+
+/******************************************************************************\
+* File format related classes.
+\******************************************************************************/
+
+/*!
+@brief The maximum number of image data formats supported.
+*/
+#define JAS_IMAGE_MAXFMTS 32
+
+/*!
+@brief Image format-dependent operations.
+*/
+typedef struct {+
+ jas_image_t *(*decode)(jas_stream_t *in, const char *opts);
+ /* Decode image data from a stream. */
+
+ int (*encode)(jas_image_t *image, jas_stream_t *out, const char *opts);
+ /* Encode image data to a stream. */
+
+ int (*validate)(jas_stream_t *in);
+ /* Determine if stream data is in a particular format. */
+
+} jas_image_fmtops_t;
+
+/*!
+@brief Image format information.
+*/
+typedef struct {+
+ int id;
+ /* The ID for this format. */
+
+ char *name;
+ /* The name by which this format is identified. */
+
+ char *ext;
+ /* The file name extension associated with this format. */
+
+ char *desc;
+ /* A brief description of the format. */
+
+ jas_image_fmtops_t ops;
+ /* The operations for this format. */
+
+} jas_image_fmtinfo_t;
+
+/******************************************************************************\
+* Image operations.
+\******************************************************************************/
+
+/*!
+@brief Create an image.
+*/
+JAS_DLLEXPORT jas_image_t *jas_image_create(unsigned numcmpts,
+ const jas_image_cmptparm_t *cmptparms, jas_clrspc_t clrspc);
+
+/*!
+@brief Create an "empty" image.
+*/
+JAS_DLLEXPORT jas_image_t *jas_image_create0(void);
+
+/*!
+@brief Clone an image.
+*/
+JAS_DLLEXPORT jas_image_t *jas_image_copy(jas_image_t *image);
+
+/*!
+@brief Deallocate any resources associated with an image.
+*/
+JAS_DLLEXPORT void jas_image_destroy(jas_image_t *image);
+
+/*!
+@brief Get the width of the image in units of the image reference grid.
+*/
+#define jas_image_width(image) \
+ ((image)->brx_ - (image)->tlx_)
+
+/*!
+@brief Get the height of the image in units of the image reference grid.
+*/
+#define jas_image_height(image) \
+ ((image)->bry_ - (image)->tly_)
+
+/*!
+@brief Get the x-coordinate of the top-left corner of the image bounding box
+on the reference grid.
+*/
+#define jas_image_tlx(image) \
+ ((image)->tlx_)
+
+/*!
+@brief Get the y-coordinate of the top-left corner of the image bounding box
+ on the reference grid.
+*/
+#define jas_image_tly(image) \
+ ((image)->tly_)
+
+/*!
+@brief Get the x-coordinate of the bottom-right corner of the image bounding box
+ on the reference grid (plus one).
+*/
+#define jas_image_brx(image) \
+ ((image)->brx_)
+
+/*!
+@brief Get the y-coordinate of the bottom-right corner of the image bounding
+box on the reference grid (plus one).
+*/
+#define jas_image_bry(image) \
+ ((image)->bry_)
+
+/*!
+@brief Get the number of image components.
+*/
+#define jas_image_numcmpts(image) \
+ ((image)->numcmpts_)
+
+/*!
+@brief Get the color model used by the image.
+*/
+#define jas_image_clrspc(image) \
+ ((image)->clrspc_)
+
+/*!
+@brief Set the color model for an image.
+*/
+#define jas_image_setclrspc(image, clrspc) \
+ ((image)->clrspc_ = (clrspc))
+
+#define jas_image_cmpttype(image, cmptno) \
+ ((image)->cmpts_[(cmptno)]->type_)
+#define jas_image_setcmpttype(image, cmptno, type) \
+ ((image)->cmpts_[(cmptno)]->type_ = (type))
+
+/*!
+@brief Get the width of a component.
+*/
+#define jas_image_cmptwidth(image, cmptno) \
+ ((image)->cmpts_[cmptno]->width_)
+
+/*!
+@brief Get the height of a component.
+*/
+#define jas_image_cmptheight(image, cmptno) \
+ ((image)->cmpts_[cmptno]->height_)
+
+/*!
+@brief Get the signedness of the sample data for a component.
+*/
+#define jas_image_cmptsgnd(image, cmptno) \
+ ((image)->cmpts_[cmptno]->sgnd_)
+
+/*!
+@brief Get the precision of the sample data for a component.
+*/
+#define jas_image_cmptprec(image, cmptno) \
+ ((image)->cmpts_[cmptno]->prec_)
+
+/*!
+@brief Get the horizontal subsampling factor for a component.
+*/
+#define jas_image_cmpthstep(image, cmptno) \
+ ((image)->cmpts_[cmptno]->hstep_)
+
+/*!
+@brief Get the vertical subsampling factor for a component.
+*/
+#define jas_image_cmptvstep(image, cmptno) \
+ ((image)->cmpts_[cmptno]->vstep_)
+
+/*!
+@brief Get the x-coordinate of the top-left corner of a component.
+*/
+#define jas_image_cmpttlx(image, cmptno) \
+ ((image)->cmpts_[cmptno]->tlx_)
+
+/*!
+@brief Get the y-coordinate of the top-left corner of a component.
+*/
+#define jas_image_cmpttly(image, cmptno) \
+ ((image)->cmpts_[cmptno]->tly_)
+
+/*!
+@brief Get the x-coordinate of the bottom-right corner of a component
+(plus "one").
+*/
+#define jas_image_cmptbrx(image, cmptno) \
+ ((image)->cmpts_[cmptno]->tlx_ + (image)->cmpts_[cmptno]->width_ * \
+ (image)->cmpts_[cmptno]->hstep_)
+
+/*!
+@brief Get the y-coordinate of the bottom-right corner of a component
+(plus "one").
+*/
+#define jas_image_cmptbry(image, cmptno) \
+ ((image)->cmpts_[cmptno]->tly_ + (image)->cmpts_[cmptno]->height_ * \
+ (image)->cmpts_[cmptno]->vstep_)
+
+/*!
+@brief Test if all components are specified at the same positions in space.
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT bool jas_image_cmpt_domains_same(const jas_image_t *image);
+
+/*!
+@brief Get the raw size of an image
+(i.e., the nominal size of the image without any compression.
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT
+uint_fast32_t jas_image_rawsize(const jas_image_t *image);
+
+/*!
+@brief Create an image from a stream in some specified format.
+*/
+JAS_DLLEXPORT
+jas_image_t *jas_image_decode(jas_stream_t *in, int fmt, const char *optstr);
+
+/*!
+@brief Write an image to a stream in a specified format.
+*/
+JAS_DLLEXPORT
+int jas_image_encode(jas_image_t *image, jas_stream_t *out, int fmt,
+ const char *optstr);
+
+/*!
+@brief Read a rectangular region of an image component.
+
+@details
+The position and size of the rectangular region to be read is specified
+relative to the component's coordinate system.
+*/
+JAS_DLLEXPORT
+int jas_image_readcmpt(jas_image_t *image, unsigned cmptno,
+ jas_image_coord_t x, jas_image_coord_t y, jas_image_coord_t width,
+ jas_image_coord_t height, jas_matrix_t *data);
+
+/*!
+@brief Write a rectangular region of an image component.
+*/
+JAS_DLLEXPORT
+int jas_image_writecmpt(jas_image_t *image, unsigned cmptno,
+ jas_image_coord_t x, jas_image_coord_t y, jas_image_coord_t width,
+ jas_image_coord_t height, const jas_matrix_t *data);
+
+/*!
+@brief Delete a component from an image.
+*/
+JAS_DLLEXPORT void jas_image_delcmpt(jas_image_t *image, unsigned cmptno);
+
+/*!
+@brief Add a component to an image.
+*/
+JAS_DLLEXPORT int jas_image_addcmpt(jas_image_t *image, int cmptno,
+ const jas_image_cmptparm_t *cmptparm);
+
+/*!
+@brief Copy a component from one image to another.
+*/
+JAS_DLLEXPORT int jas_image_copycmpt(jas_image_t *dstimage, unsigned dstcmptno,
+ jas_image_t *srcimage, unsigned srccmptno);
+
+JAS_ATTRIBUTE_CONST
+static inline bool JAS_IMAGE_CDT_GETSGND(uint_least8_t dtype)
+{+ return (dtype >> 7) & 1;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JAS_IMAGE_CDT_SETSGND(bool sgnd)
+{+ return (uint_least8_t)sgnd << 7;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JAS_IMAGE_CDT_GETPREC(uint_least8_t dtype)
+{+ return dtype & 0x7f;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JAS_IMAGE_CDT_SETPREC(uint_least8_t dtype)
+{+ return dtype & 0x7f;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline uint_least8_t jas_image_cmptdtype(const jas_image_t *image, unsigned cmptno)
+{+ return JAS_IMAGE_CDT_SETSGND(image->cmpts_[cmptno]->sgnd_) |
+ JAS_IMAGE_CDT_SETPREC(image->cmpts_[cmptno]->prec_);
+}
+
+/*!
+@brief Depalettize an image
+*/
+JAS_DLLEXPORT
+int jas_image_depalettize(jas_image_t *image, unsigned cmptno,
+ unsigned numlutents, const int_fast32_t *lutents, unsigned dtype,
+ unsigned newcmptno);
+
+/*!
+@brief Read a component sample for an image.
+*/
+JAS_DLLEXPORT
+int jas_image_readcmptsample(jas_image_t *image, unsigned cmptno, unsigned x,
+ unsigned y);
+
+/*!
+@brief Write a component sample for an image.
+*/
+JAS_DLLEXPORT
+void jas_image_writecmptsample(jas_image_t *image, unsigned cmptno,
+ unsigned x, unsigned y, int_fast32_t v);
+
+/*!
+@brief Get an image component by its type.
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT
+int jas_image_getcmptbytype(const jas_image_t *image, jas_image_cmpttype_t ctype);
+
+/******************************************************************************\
+* Image format-related operations.
+\******************************************************************************/
+
+/*!
+@brief Clear the table of image formats.
+*/
+JAS_DLLEXPORT
+void jas_image_clearfmts(void);
+
+/*!
+@brief Add entry to table of image formats.
+*/
+JAS_DLLEXPORT
+int jas_image_addfmt(int id, const char *name, const char *ext,
+ const char *desc, const jas_image_fmtops_t *ops);
+
+/*!
+@brief Get the ID for the image format with the specified name.
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT
+int jas_image_strtofmt(const char *s);
+
+/*!
+@brief Get the name of the image format with the specified ID.
+*/
+JAS_ATTRIBUTE_CONST
+JAS_DLLEXPORT
+const char *jas_image_fmttostr(int fmt);
+
+/*!
+@brief Lookup image format information by the format ID.
+*/
+JAS_ATTRIBUTE_CONST
+JAS_DLLEXPORT
+const jas_image_fmtinfo_t *jas_image_lookupfmtbyid(int id);
+
+/*!
+@brief Lookup image format information by the format name.
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT
+const jas_image_fmtinfo_t *jas_image_lookupfmtbyname(const char *name);
+
+/*!
+@brief Guess the format of an image file based on its name.
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT
+int jas_image_fmtfromname(const char *filename);
+
+/*!
+@brief Get the format of image data in a stream.
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT
+int jas_image_getfmt(jas_stream_t *in);
+
+
+/*!
+@brief Get the color management profile of an image.
+*/
+#define jas_image_cmprof(image) ((image)->cmprof_)
+
+/*!
+@brief ???
+*/
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT
+int jas_image_ishomosamp(const jas_image_t *image);
+
+/*!
+@brief ???
+*/
+JAS_DLLEXPORT
+int jas_image_sampcmpt(jas_image_t *image, unsigned cmptno, unsigned newcmptno,
+ jas_image_coord_t ho, jas_image_coord_t vo, jas_image_coord_t hs,
+ jas_image_coord_t vs, int sgnd, unsigned prec);
+
+/*!
+@brief Write sample data in a component of an image.
+*/
+JAS_DLLEXPORT int jas_image_writecmpt2(jas_image_t *image, unsigned cmptno, jas_image_coord_t x,
+ jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
+ const long *buf);
+
+/*!
+@brief Read sample data in a component of an image.
+*/
+JAS_DLLEXPORT
+int jas_image_readcmpt2(jas_image_t *image, unsigned cmptno,
+ jas_image_coord_t x, jas_image_coord_t y, jas_image_coord_t width,
+ jas_image_coord_t height, long *buf);
+
+/*!
+@brief Set the color management profile for an image.
+*/
+#define jas_image_setcmprof(image, cmprof) ((image)->cmprof_ = cmprof)
+
+/*!
+@brief Change the color space for an image.
+*/
+JAS_DLLEXPORT jas_image_t *jas_image_chclrspc(jas_image_t *image, const jas_cmprof_t *outprof,
+ jas_cmxform_intent_t intent);
+
+/*!
+@brief Dump the information for an image (for debugging).
+*/
+JAS_DLLEXPORT void jas_image_dump(jas_image_t *image, FILE *out);
+
+/******************************************************************************\
+* Image format-dependent operations.
+\******************************************************************************/
+
+#if defined(JAS_INCLUDE_JPG_CODEC)
+/* Format-dependent operations for JPG support. */
+JAS_DLLEXPORT jas_image_t *jpg_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int jpg_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int jpg_validate(jas_stream_t *in);
+#endif
+
+#if defined(JAS_INCLUDE_MIF_CODEC)
+/* Format-dependent operations for MIF support. */
+JAS_DLLEXPORT jas_image_t *mif_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int mif_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int mif_validate(jas_stream_t *in);
+#endif
+
+#if defined(JAS_INCLUDE_PNM_CODEC)
+/* Format-dependent operations for PNM support. */
+JAS_DLLEXPORT jas_image_t *pnm_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int pnm_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int pnm_validate(jas_stream_t *in);
+#endif
+
+#if defined(JAS_INCLUDE_RAS_CODEC)
+/* Format-dependent operations for Sun Rasterfile support. */
+JAS_DLLEXPORT jas_image_t *ras_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int ras_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int ras_validate(jas_stream_t *in);
+#endif
+
+#if defined(JAS_INCLUDE_BMP_CODEC)
+/* Format-dependent operations for BMP support. */
+JAS_DLLEXPORT jas_image_t *bmp_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int bmp_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int bmp_validate(jas_stream_t *in);
+#endif
+
+#if defined(JAS_INCLUDE_JP2_CODEC)
+/* Format-dependent operations for JP2 support. */
+JAS_DLLEXPORT jas_image_t *jp2_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int jp2_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int jp2_validate(jas_stream_t *in);
+#endif
+
+#if defined(JAS_INCLUDE_JPC_CODEC)
+/* Format-dependent operations for JPEG-2000 code stream support. */
+JAS_DLLEXPORT jas_image_t *jpc_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int jpc_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int jpc_validate(jas_stream_t *in);
+#endif
+
+#if defined(JAS_INCLUDE_PGX_CODEC)
+/* Format-dependent operations for PGX support. */
+JAS_DLLEXPORT jas_image_t *pgx_decode(jas_stream_t *in, const char *optstr);
+JAS_DLLEXPORT int pgx_encode(jas_image_t *image, jas_stream_t *out, const char *optstr);
+JAS_DLLEXPORT int pgx_validate(jas_stream_t *in);
+#endif
+
+/*!
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_init.h
@@ -1,0 +1,117 @@
+/*
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_init.h
+ * @brief JasPer Initialization/Cleanup Code
+ */
+
+#ifndef JAS_INIT_H
+#define JAS_INIT_H
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/*!
+ * @addtogroup init
+ * @{+ */
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/*!
+@brief Initialize the JasPer library.
+
+@details
+This function must be called before any other code in the JasPer library
+is invoked.
+This function registers the codecs that are enabled by default.
+
+@returns
+If successful, zero is returned; otherwise, a nonzero value is returned.
+*/
+JAS_DLLEXPORT
+int jas_init(void);
+
+/*!
+@brief Perform any clean up for the JasPer library.
+
+@details
+This function performs any clean up for the JasPer library.
+*/
+JAS_DLLEXPORT
+void jas_cleanup(void);
+
+/*!
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_malloc.h
@@ -1,0 +1,122 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+
+/*!
+ * @file jas_malloc.h
+ * @brief JasPer Memory Allocator
+ */
+
+#ifndef JAS_MALLOC_H
+#define JAS_MALLOC_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Allocate memory. */
+JAS_DLLEXPORT void *jas_malloc(size_t size);
+
+/* Free memory. */
+JAS_DLLEXPORT void jas_free(void *ptr);
+
+/* Resize a block of allocated memory. */
+JAS_DLLEXPORT void *jas_realloc(void *ptr, size_t size);
+
+/* Allocate a block of memory and initialize the contents to zero. */
+JAS_DLLEXPORT void *jas_calloc(size_t num_elements, size_t element_size);
+
+/* Allocate array (with overflow checking) . */
+JAS_DLLEXPORT void *jas_alloc2(size_t num_elements, size_t element_size);
+
+/* Allocate array of arrays (with overflow checking) . */
+JAS_DLLEXPORT void *jas_alloc3(size_t num_arrays, size_t array_size, size_t element_size);
+
+/* Resize a block of allocated memory (with overflow checking) . */
+JAS_DLLEXPORT void *jas_realloc2(void *ptr, size_t num_elements, size_t element_size);
+
+#if defined(JAS_DEFAULT_MAX_MEM_USAGE)
+
+JAS_DLLEXPORT void jas_set_max_mem_usage(size_t max_mem);
+
+JAS_ATTRIBUTE_PURE
+JAS_DLLEXPORT size_t jas_get_mem_usage();
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_math.h
@@ -1,0 +1,368 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_math.h
+ * @brief Math-Related Code
+ */
+
+#ifndef JAS_MATH_H
+#define JAS_MATH_H
+
+/******************************************************************************\
+* Includes
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+#include <jasper/jas_types.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/******************************************************************************\
+* Macros
+\******************************************************************************/
+
+#define JAS_KIBI JAS_CAST(size_t, 1024)
+#define JAS_MEBI (JAS_KIBI * JAS_KIBI)
+
+/* Compute the absolute value. */
+#define JAS_ABS(x) \
+ (((x) >= 0) ? (x) : (-(x)))
+
+/* Compute the minimum of two values. */
+#define JAS_MIN(x, y) \
+ (((x) < (y)) ? (x) : (y))
+
+/* Compute the maximum of two values. */
+#define JAS_MAX(x, y) \
+ (((x) > (y)) ? (x) : (y))
+
+/* Compute the remainder from division (where division is defined such
+ that the remainder is always nonnegative). */
+#define JAS_MOD(x, y) \
+ (((x) < 0) ? (((-x) % (y)) ? ((y) - ((-(x)) % (y))) : (0)) : ((x) % (y)))
+
+/* Compute the integer with the specified number of least significant bits
+ set to one. */
+#define JAS_ONES(n) \
+ ((1 << (n)) - 1)
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 6)
+/* suppress clang warning "shifting a negative signed value is
+ undefined" in the assertions below */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshift-negative-value"
+#endif
+
+JAS_ATTRIBUTE_CONST
+JAS_ATTRIBUTE_DISABLE_USAN
+inline static int jas_int_asr(int x, unsigned n)
+{+ // Ensure that the shift of a negative value appears to behave as a
+ // signed arithmetic shift.
+ assert(((-1) >> 1) == -1);
+ // The behavior is undefined when x is negative. */
+ // We tacitly assume the behavior is equivalent to a signed
+ // arithmetic right shift.
+ return x >> n;
+}
+
+JAS_ATTRIBUTE_CONST
+JAS_ATTRIBUTE_DISABLE_USAN
+inline static int jas_int_asl(int x, unsigned n)
+{+ // Ensure that the shift of a negative value appears to behave as a
+ // signed arithmetic shift.
+ assert(((-1) << 1) == -2);
+ // The behavior is undefined when x is negative. */
+ // We tacitly assume the behavior is equivalent to a signed
+ // arithmetic left shift.
+ return x << n;
+}
+
+JAS_ATTRIBUTE_CONST
+JAS_ATTRIBUTE_DISABLE_USAN
+inline static int_least32_t jas_least32_asr(int_least32_t x, unsigned n)
+{+ // Ensure that the shift of a negative value appears to behave as a
+ // signed arithmetic shift.
+ assert(((JAS_CAST(int_least32_t, -1)) >> 1) == JAS_CAST(int_least32_t, -1));
+ // The behavior is undefined when x is negative. */
+ // We tacitly assume the behavior is equivalent to a signed
+ // arithmetic right shift.
+ return x >> n;
+}
+
+JAS_ATTRIBUTE_CONST
+JAS_ATTRIBUTE_DISABLE_USAN
+inline static int_least32_t jas_least32_asl(int_least32_t x, unsigned n)
+{+ // Ensure that the shift of a negative value appears to behave as a
+ // signed arithmetic shift.
+ assert(((JAS_CAST(int_least32_t, -1)) << 1) == JAS_CAST(int_least32_t, -2));
+ // The behavior is undefined when x is negative. */
+ // We tacitly assume the behavior is equivalent to a signed
+ // arithmetic left shift.
+ return x << n;
+}
+
+JAS_ATTRIBUTE_CONST
+JAS_ATTRIBUTE_DISABLE_USAN
+inline static int_fast32_t jas_fast32_asr(int_fast32_t x, unsigned n)
+{+ // Ensure that the shift of a negative value appears to behave as a
+ // signed arithmetic shift.
+ assert(((JAS_CAST(int_fast32_t, -1)) >> 1) == JAS_CAST(int_fast32_t, -1));
+ // The behavior is undefined when x is negative. */
+ // We tacitly assume the behavior is equivalent to a signed
+ // arithmetic right shift.
+ return x >> n;
+}
+
+JAS_ATTRIBUTE_CONST
+JAS_ATTRIBUTE_DISABLE_USAN
+inline static int_fast32_t jas_fast32_asl(int_fast32_t x, unsigned n)
+{+ // Ensure that the shift of a negative value appears to behave as a
+ // signed arithmetic shift.
+ assert(((JAS_CAST(int_fast32_t, -1)) << 1) == JAS_CAST(int_fast32_t, -2));
+ // The behavior is undefined when x is negative. */
+ // We tacitly assume the behavior is equivalent to a signed
+ // arithmetic left shift.
+ return x << n;
+}
+
+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 6)
+#pragma GCC diagnostic pop
+#endif
+
+/******************************************************************************\
+* Safe integer arithmetic (i.e., with overflow checking).
+\******************************************************************************/
+
+/* Compute the product of two size_t integers with overflow checking. */
+inline static bool jas_safe_size_mul(size_t x, size_t y, size_t *result)
+{+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 5)
+ size_t result_buffer;
+ if (!result)
+ result = &result_buffer;
+ return !__builtin_mul_overflow(x, y, result);
+#else
+ /* Check if overflow would occur */
+ if (x && y > SIZE_MAX / x) {+ /* Overflow would occur. */
+ return false;
+ }
+ if (result) {+ *result = x * y;
+ }
+ return true;
+#endif
+}
+
+/* Compute the product of three size_t integers with overflow checking. */
+inline static bool jas_safe_size_mul3(size_t a, size_t b, size_t c,
+ size_t *result)
+{+ size_t tmp;
+ if (!jas_safe_size_mul(a, b, &tmp) ||
+ !jas_safe_size_mul(tmp, c, &tmp)) {+ return false;
+ }
+ if (result) {+ *result = tmp;
+ }
+ return true;
+}
+
+/* Compute the sum of two size_t integers with overflow checking. */
+inline static bool jas_safe_size_add(size_t x, size_t y, size_t *result)
+{+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 5)
+ size_t result_buffer;
+ if (!result)
+ result = &result_buffer;
+ return !__builtin_add_overflow(x, y, result);
+#else
+ if (y > SIZE_MAX - x) {+ return false;
+ }
+ if (result) {+ *result = x + y;
+ }
+ return true;
+#endif
+}
+
+/* Compute the difference of two size_t integers with overflow checking. */
+inline static bool jas_safe_size_sub(size_t x, size_t y, size_t *result)
+{+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 5)
+ size_t result_buffer;
+ if (!result)
+ result = &result_buffer;
+ return !__builtin_sub_overflow(x, y, result);
+#else
+ if (y > x) {+ return false;
+ }
+ if (result) {+ *result = x - y;
+ }
+ return true;
+#endif
+}
+
+/* Compute the product of two int_fast32_t integers with overflow checking. */
+inline static bool jas_safe_intfast32_mul(int_fast32_t x, int_fast32_t y,
+ int_fast32_t *result)
+{+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 5)
+ int_fast32_t result_buffer;
+ if (!result)
+ result = &result_buffer;
+ return !__builtin_mul_overflow(x, y, result);
+#else
+ if (x > 0) {+ /* x is positive */
+ if (y > 0) {+ /* x and y are positive */
+ if (x > INT_FAST32_MAX / y) {+ return false;
+ }
+ } else {+ /* x positive, y nonpositive */
+ if (y < INT_FAST32_MIN / x) {+ return false;
+ }
+ }
+ } else {+ /* x is nonpositive */
+ if (y > 0) {+ /* x is nonpositive, y is positive */
+ if (x < INT_FAST32_MIN / y) {+ return false;
+ }
+ } else { /* x and y are nonpositive */+ if (x != 0 && y < INT_FAST32_MAX / x) {+ return false;
+ }
+ }
+ }
+
+ if (result) {+ *result = x * y;
+ }
+ return true;
+#endif
+}
+
+/* Compute the product of three int_fast32_t integers with overflow checking. */
+inline static bool jas_safe_intfast32_mul3(int_fast32_t a, int_fast32_t b,
+ int_fast32_t c, int_fast32_t *result)
+{+ int_fast32_t tmp;
+ if (!jas_safe_intfast32_mul(a, b, &tmp) ||
+ !jas_safe_intfast32_mul(tmp, c, &tmp)) {+ return false;
+ }
+ if (result) {+ *result = tmp;
+ }
+ return true;
+}
+
+/* Compute the sum of two int_fast32_t integers with overflow checking. */
+inline static bool jas_safe_intfast32_add(int_fast32_t x, int_fast32_t y,
+ int_fast32_t *result)
+{+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ > 5)
+ int_fast32_t result_buffer;
+ if (!result)
+ result = &result_buffer;
+ return !__builtin_add_overflow(x, y, result);
+#else
+ if ((y > 0 && x > INT_FAST32_MAX - y) ||
+ (y < 0 && x < INT_FAST32_MIN - y)) {+ return false;
+ }
+ if (result) {+ *result = x + y;
+ }
+ return true;
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_seq.h
@@ -1,0 +1,463 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_seq.h
+ * @brief Sequence/Matrix Library
+ */
+
+#ifndef JAS_SEQ_H
+#define JAS_SEQ_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h> /* IWYU pragma: keep */
+
+#include <jasper/jas_types.h>
+#include <jasper/jas_math.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/* This matrix is a reference to another matrix. */
+#define JAS_MATRIX_REF 0x0001
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/* An element in a sequence. */
+#ifdef JAS_ENABLE_32BIT
+typedef int_least32_t jas_seqent_t;
+#define PRIjas_seqent PRIiLEAST32
+#else
+typedef int_fast32_t jas_seqent_t;
+#define PRIjas_seqent PRIiFAST32
+#endif
+
+/* An element in a matrix. */
+#ifdef JAS_ENABLE_32BIT
+typedef int_least32_t jas_matent_t;
+#else
+typedef int_fast32_t jas_matent_t;
+#endif
+
+#ifdef JAS_ENABLE_32BIT
+typedef int_least32_t jas_matind_t;
+#else
+typedef int_fast32_t jas_matind_t;
+#endif
+
+/* Matrix. */
+
+typedef struct {+
+ /* Additional state information. */
+ int flags_;
+
+ /* The starting horizontal index. */
+ jas_matind_t xstart_;
+
+ /* The starting vertical index. */
+ jas_matind_t ystart_;
+
+ /* The ending horizontal index. */
+ jas_matind_t xend_;
+
+ /* The ending vertical index. */
+ jas_matind_t yend_;
+
+ /* The number of rows in the matrix. */
+ jas_matind_t numrows_;
+
+ /* The number of columns in the matrix. */
+ jas_matind_t numcols_;
+
+ /* Pointers to the start of each row. */
+ jas_seqent_t **rows_;
+
+ /* The allocated size of the rows array. */
+ int_fast32_t maxrows_;
+
+ /* The matrix data buffer. */
+ jas_seqent_t *data_;
+
+ /* The allocated size of the data array. */
+ int_fast32_t datasize_;
+
+} jas_matrix_t;
+
+typedef jas_matrix_t jas_seq2d_t;
+typedef jas_matrix_t jas_seq_t;
+
+/******************************************************************************\
+* Functions/macros for matrix class.
+\******************************************************************************/
+
+/* Get the number of rows. */
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_matrix_numrows(const jas_matrix_t *matrix)
+{+ return matrix->numrows_;
+}
+
+/* Get the number of columns. */
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_matrix_numcols(const jas_matrix_t *matrix)
+{+ return matrix->numcols_;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_matrix_size(const jas_matrix_t *matrix)
+{+ return jas_matrix_numcols(matrix) * jas_matrix_numrows(matrix);
+}
+
+JAS_ATTRIBUTE_PURE
+static inline bool jas_matrix_empty(const jas_matrix_t *matrix)
+{+ return jas_matrix_numcols(matrix) == 0 || jas_matrix_numrows(matrix) == 0;
+}
+
+/* Get a matrix element. */
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t jas_matrix_get(const jas_matrix_t *matrix, jas_matind_t i, jas_matind_t j)
+{+ return matrix->rows_[i][j];
+}
+
+/* Set a matrix element. */
+static inline void jas_matrix_set(jas_matrix_t *matrix, jas_matind_t i, jas_matind_t j, jas_seqent_t v)
+{+ matrix->rows_[i][j] = v;
+}
+
+/* Get an element from a matrix that is known to be a row or column vector. */
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t jas_matrix_getv(const jas_matrix_t *matrix, jas_matind_t i)
+{+ return matrix->numrows_ == 1
+ ? matrix->rows_[0][i]
+ : matrix->rows_[i][0];
+}
+
+/* Set an element in a matrix that is known to be a row or column vector. */
+static inline void jas_matrix_setv(jas_matrix_t *matrix, jas_matind_t i, jas_seqent_t v)
+{+ if (matrix->numrows_ == 1)
+ matrix->rows_[0][i] = v;
+ else
+ matrix->rows_[i][0] = v;
+}
+
+/* Get the address of an element in a matrix. */
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t *jas_matrix_getref(const jas_matrix_t *matrix, jas_matind_t i, jas_matind_t j)
+{+ return &matrix->rows_[i][j];
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t *jas_matrix_getvref(const jas_matrix_t *matrix, jas_matind_t i)
+{+ return matrix->numrows_ > 1
+ ? jas_matrix_getref(matrix, i, 0)
+ : jas_matrix_getref(matrix, 0, i);
+}
+
+/* Create a matrix with the specified dimensions. */
+JAS_DLLEXPORT jas_matrix_t *jas_matrix_create(jas_matind_t numrows, jas_matind_t numcols);
+
+/* Destroy a matrix. */
+JAS_DLLEXPORT void jas_matrix_destroy(jas_matrix_t *matrix);
+
+/* Resize a matrix. The previous contents of the matrix are lost. */
+JAS_DLLEXPORT int jas_matrix_resize(jas_matrix_t *matrix, jas_matind_t numrows, jas_matind_t numcols);
+
+JAS_DLLEXPORT int jas_matrix_output(jas_matrix_t *matrix, FILE *out);
+
+/* Create a matrix that references part of another matrix. */
+JAS_DLLEXPORT int jas_matrix_bindsub(jas_matrix_t *mat0, jas_matrix_t *mat1, jas_matind_t r0,
+ jas_matind_t c0, jas_matind_t r1, jas_matind_t c1);
+
+/* Create a matrix that is a reference to a row of another matrix. */
+static inline int jas_matrix_bindrow(jas_matrix_t *mat0, jas_matrix_t *mat1, jas_matind_t r)
+{+ return jas_matrix_bindsub(mat0, mat1, r, 0, r, mat1->numcols_ - 1);
+}
+
+/* Create a matrix that is a reference to a column of another matrix. */
+static inline int jas_matrix_bindcol(jas_matrix_t *mat0, jas_matrix_t *mat1, jas_matind_t c)
+{+ return jas_matrix_bindsub(mat0, mat1, 0, c, mat1->numrows_ - 1, c);
+}
+
+/* Clip the values of matrix elements to the specified range. */
+JAS_DLLEXPORT void jas_matrix_clip(jas_matrix_t *matrix, jas_seqent_t minval,
+ jas_seqent_t maxval);
+
+/* Arithmetic shift left of all elements in a matrix. */
+JAS_DLLEXPORT void jas_matrix_asl(jas_matrix_t *matrix, unsigned n);
+
+/* Arithmetic shift right of all elements in a matrix. */
+JAS_DLLEXPORT void jas_matrix_asr(jas_matrix_t *matrix, unsigned n);
+
+/* Almost-but-not-quite arithmetic shift right of all elements in a matrix. */
+JAS_DLLEXPORT void jas_matrix_divpow2(jas_matrix_t *matrix, unsigned n);
+
+/* Set all elements of a matrix to the specified value. */
+JAS_DLLEXPORT void jas_matrix_setall(jas_matrix_t *matrix, jas_seqent_t val);
+
+/* The spacing between rows of a matrix. */
+JAS_ATTRIBUTE_PURE
+static inline size_t jas_matrix_rowstep(const jas_matrix_t *matrix)
+{+ return matrix->numrows_ > 1
+ ? (size_t)(matrix->rows_[1] - matrix->rows_[0])
+ : 0u;
+}
+
+/* The spacing between columns of a matrix. */
+JAS_ATTRIBUTE_PURE
+static inline size_t jas_matrix_step(const jas_matrix_t *matrix)
+{+ return matrix->numrows_ > 1
+ ? jas_matrix_rowstep(matrix)
+ : 1;
+}
+
+/* Compare two matrices for equality. */
+JAS_DLLEXPORT int jas_matrix_cmp(jas_matrix_t *mat0, jas_matrix_t *mat1);
+
+JAS_DLLEXPORT jas_matrix_t *jas_matrix_copy(jas_matrix_t *x);
+
+JAS_DLLEXPORT jas_matrix_t *jas_matrix_input(FILE *);
+
+JAS_ATTRIBUTE_CONST
+static inline jas_seqent_t jas_seqent_asl(jas_seqent_t x, unsigned n)
+{+#ifdef JAS_ENABLE_32BIT
+ return jas_least32_asl(x, n);
+#else
+ return jas_fast32_asl(x, n);
+#endif
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jas_seqent_t jas_seqent_asr(jas_seqent_t x, unsigned n)
+{+#ifdef JAS_ENABLE_32BIT
+ return jas_least32_asr(x, n);
+#else
+ return jas_fast32_asr(x, n);
+#endif
+}
+
+/******************************************************************************\
+* Functions/macros for 2-D sequence class.
+\******************************************************************************/
+
+JAS_DLLEXPORT jas_seq2d_t *jas_seq2d_copy(jas_seq2d_t *x);
+
+JAS_DLLEXPORT jas_matrix_t *jas_seq2d_create(jas_matind_t xstart, jas_matind_t ystart,
+ jas_matind_t xend, jas_matind_t yend);
+
+static inline void jas_seq2d_destroy(jas_seq2d_t *s)
+{+ jas_matrix_destroy(s);
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_seq2d_xstart(const jas_seq2d_t *s)
+{+ return s->xstart_;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_seq2d_ystart(const jas_seq2d_t *s)
+{+ return s->ystart_;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_seq2d_xend(const jas_seq2d_t *s)
+{+ return s->xend_;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_seq2d_yend(const jas_seq2d_t *s)
+{+ return s->yend_;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t *jas_seq2d_getref(const jas_seq2d_t *s, jas_matind_t x, jas_matind_t y)
+{+ return jas_matrix_getref(s, y - s->ystart_, x - s->xstart_);
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t jas_seq2d_get(const jas_seq2d_t *s, jas_matind_t x, jas_matind_t y)
+{+ return jas_matrix_get(s, y - s->ystart_, x - s->xstart_);
+}
+
+JAS_ATTRIBUTE_PURE
+static inline size_t jas_seq2d_rowstep(const jas_seq2d_t *s)
+{+ return jas_matrix_rowstep(s);
+}
+
+JAS_ATTRIBUTE_PURE
+static inline unsigned jas_seq2d_width(const jas_seq2d_t *s)
+{+ return (unsigned)(s->xend_ - s->xstart_);
+}
+
+JAS_ATTRIBUTE_PURE
+static inline unsigned jas_seq2d_height(const jas_seq2d_t *s)
+{+ return (unsigned)(s->yend_ - s->ystart_);
+}
+
+static inline void jas_seq2d_setshift(jas_seq2d_t *s, jas_matind_t x, jas_matind_t y)
+{+ s->xstart_ = x;
+ s->ystart_ = y;
+ s->xend_ = s->xstart_ + s->numcols_;
+ s->yend_ = s->ystart_ + s->numrows_;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_seq2d_size(const jas_seq2d_t *s)
+{+ return jas_seq2d_width(s) * jas_seq2d_height(s);
+}
+
+JAS_ATTRIBUTE_PURE
+static inline bool jas_seq2d_empty(const jas_seq2d_t *s)
+{+ return jas_seq2d_width(s) == 0 || jas_seq2d_height(s) == 0;
+}
+
+JAS_DLLEXPORT int jas_seq2d_bindsub(jas_matrix_t *s, jas_matrix_t *s1, jas_matind_t xstart,
+ jas_matind_t ystart, jas_matind_t xend, jas_matind_t yend);
+
+/******************************************************************************\
+* Functions/macros for 1-D sequence class.
+\******************************************************************************/
+
+static inline jas_seq_t *jas_seq_create(jas_matind_t start, jas_matind_t end)
+{+ return jas_seq2d_create(start, 0, end, 1);
+}
+
+static inline void jas_seq_destroy(jas_seq_t *seq)
+{+ jas_seq2d_destroy(seq);
+}
+
+static inline void jas_seq_set(jas_seq_t *seq, jas_matind_t i, jas_seqent_t v)
+{+ seq->rows_[0][i - seq->xstart_] = v;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t *jas_seq_getref(const jas_seq_t *seq, jas_matind_t i)
+{+ return &seq->rows_[0][i - seq->xstart_];
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_seqent_t jas_seq_get(const jas_seq_t *seq, jas_matind_t i)
+{+ return seq->rows_[0][i - seq->xstart_];
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_seq_start(const jas_seq_t *seq)
+{+ return seq->xstart_;
+}
+
+JAS_ATTRIBUTE_PURE
+static inline jas_matind_t jas_seq_end(const jas_seq_t *seq)
+{+ return seq->xend_;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_stream.h
@@ -1,0 +1,1047 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_stream.h
+ * @brief I/O Stream Class
+ */
+
+#ifndef JAS_STREAM_H
+#define JAS_STREAM_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h> /* IWYU pragma: export */
+#include <jasper/jas_types.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/*!
+ * @addtogroup iostreams
+ * @{+ */
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/* On most UNIX systems, we probably need to define O_BINARY ourselves. */
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+/*
+ * Stream open flags.
+ */
+
+/* The stream was opened for reading. */
+#define JAS_STREAM_READ 0x0001
+/* The stream was opened for writing. */
+#define JAS_STREAM_WRITE 0x0002
+/* The stream was opened for appending. */
+#define JAS_STREAM_APPEND 0x0004
+/* The stream was opened in binary mode. */
+#define JAS_STREAM_BINARY 0x0008
+/* The stream should be created/truncated. */
+#define JAS_STREAM_CREATE 0x0010
+
+/*
+ * Stream buffering flags.
+ */
+
+/* The stream is unbuffered. */
+#define JAS_STREAM_UNBUF 0x0000
+/* The stream is line buffered. */
+#define JAS_STREAM_LINEBUF 0x0001
+/* The stream is fully buffered. */
+#define JAS_STREAM_FULLBUF 0x0002
+/* The buffering mode mask. */
+#define JAS_STREAM_BUFMODEMASK 0x000f
+
+/* The memory associated with the buffer needs to be deallocated when the
+ stream is destroyed. */
+#define JAS_STREAM_FREEBUF 0x0008
+/* The buffer is currently being used for reading. */
+#define JAS_STREAM_RDBUF 0x0010
+/* The buffer is currently being used for writing. */
+#define JAS_STREAM_WRBUF 0x0020
+
+/*
+ * Stream error flags.
+ */
+
+/* The end-of-file has been encountered (on reading). */
+#define JAS_STREAM_EOF 0x0001
+/* An I/O error has been encountered on the stream. */
+#define JAS_STREAM_ERR 0x0002
+/* The read/write limit has been exceeded. */
+#define JAS_STREAM_RWLIMIT 0x0004
+/* The error mask. */
+#define JAS_STREAM_ERRMASK \
+ (JAS_STREAM_EOF | JAS_STREAM_ERR | JAS_STREAM_RWLIMIT)
+
+/*
+ * Other miscellaneous constants.
+ */
+
+/* The default buffer size (for fully-buffered operation). */
+#define JAS_STREAM_BUFSIZE 8192
+/* The default permission mask for file creation. */
+#define JAS_STREAM_PERMS 0666
+
+/* The maximum number of characters that can always be put back on a stream. */
+#define JAS_STREAM_MAXPUTBACK 16
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/*
+ * Generic file object.
+ */
+
+typedef void jas_stream_obj_t;
+
+/*
+ * Generic file object operations.
+ */
+
+typedef struct {+
+ /* Read characters from a file object. */
+ int (*read_)(jas_stream_obj_t *obj, char *buf, unsigned cnt);
+
+ /* Write characters to a file object. */
+ int (*write_)(jas_stream_obj_t *obj, const char *buf, unsigned cnt);
+
+ /* Set the position for a file object. */
+ long (*seek_)(jas_stream_obj_t *obj, long offset, int origin);
+
+ /* Close a file object. */
+ int (*close_)(jas_stream_obj_t *obj);
+
+} jas_stream_ops_t;
+
+/*
+ * Stream object.
+ */
+
+typedef struct {+
+ /* The mode in which the stream was opened. */
+ int openmode_;
+
+ /* The buffering mode. */
+ int bufmode_;
+
+ /* The stream status. */
+ int flags_;
+
+ /* The start of the buffer area to use for reading/writing. */
+ jas_uchar *bufbase_;
+
+ /* The start of the buffer area excluding the extra initial space for
+ character putback. */
+ jas_uchar *bufstart_;
+
+ /* The buffer size. */
+ int bufsize_;
+
+ /* The current position in the buffer. */
+ jas_uchar *ptr_;
+
+ /* The number of characters that must be read/written before
+ the buffer needs to be filled/flushed. */
+ int cnt_;
+
+ /* A trivial buffer to be used for unbuffered operation. */
+ jas_uchar tinybuf_[JAS_STREAM_MAXPUTBACK + 1];
+
+ /* The operations for the underlying stream file object. */
+ const jas_stream_ops_t *ops_;
+
+ /* The underlying stream file object. */
+ jas_stream_obj_t *obj_;
+
+ /* The number of characters read/written. */
+ long rwcnt_;
+
+ /* The maximum number of characters that may be read/written. */
+ long rwlimit_;
+
+} jas_stream_t;
+
+/*
+ * Regular file object.
+ */
+
+/*
+ * File descriptor file object.
+ */
+typedef struct {+ int fd;
+ int flags;
+ char pathname[L_tmpnam + 1];
+} jas_stream_fileobj_t;
+
+/* Delete underlying file object upon stream close. */
+#define JAS_STREAM_FILEOBJ_DELONCLOSE 0x01
+/* Do not close underlying file object upon stream close. */
+#define JAS_STREAM_FILEOBJ_NOCLOSE 0x02
+
+/*
+ * Memory file object.
+ */
+
+typedef struct {+
+ /* The data associated with this file. */
+ jas_uchar *buf_;
+
+ /* The allocated size of the buffer for holding file data. */
+ size_t bufsize_;
+
+ /* The length of the file. */
+ uint_fast32_t len_;
+
+ /* The seek position. */
+ uint_fast32_t pos_;
+
+ /* Is the buffer growable? */
+ int growable_;
+
+ /* Was the buffer allocated internally? */
+ int myalloc_;
+
+} jas_stream_memobj_t;
+
+/******************************************************************************\
+* Macros/functions for opening and closing streams.
+\******************************************************************************/
+
+/*!
+@brief Open a file as a stream.
+
+@param filename
+A pointer to the pathname of the file to be opened.
+@param mode
+A pointer to the string specifying the open mode.
+The open mode is similar to that used by the fopen function in the
+C standard library.
+
+@return
+Upon success, a pointer to the opened stream is returned.
+Otherwise, a null pointer is returned.
+*/
+JAS_DLLEXPORT
+jas_stream_t *jas_stream_fopen(const char *filename, const char *mode);
+
+/*!
+@brief Open a memory buffer as a stream.
+
+@param buffer
+A pointer to the buffer to be used to store stream data.
+@param buffer_size
+The size of the buffer.
+
+@details
+<ul>
+<li>
+If buffer is 0 and buffer_size > 0:
+a buffer is dynamically allocated with size buffer_size and this buffer is
+not growable.
+<li>
+If buffer is 0 and buffer_size is 0:
+a buffer is dynamically allocated whose size will automatically grow to
+accommodate the amount of data written.
+<li>
+If buffer is not 0:
+buffer_size (which, in this case, is not currently allowed to be zero) is
+the size of the (nongrowable) buffer pointed to by buffer.
+</ul>
+
+@warning
+TODO/FIXME: The type of the buffer_size parameter will be
+changed to size_t in the future.
+
+@warning
+TODO/FIXME:
+In a later release, this function will be changed to have the same
+prototype as jas_stream_memopen2, at which point jas_stream_memopen2
+will be removed.
+*/
+JAS_DLLEXPORT
+jas_stream_t *jas_stream_memopen(char *buffer, int buffer_size);
+
+/*!
+@warning
+This function will be renamed jas_stream_memopen in a future release.
+Do not use this function.
+*/
+JAS_DLLEXPORT
+jas_stream_t *jas_stream_memopen2(char *buffer, size_t buffer_size);
+
+/*!
+@brief Open a file descriptor as a stream.
+
+@param fd
+The file descriptor of the file to open as a stream.
+@param mode
+A pointer to a string specifying the open mode.
+The format of this string is similar to that of the fdopen function
+in the C standard library.
+
+@return
+Upon success, a pointer to the opened stream is returned.
+Otherwise, a null pointer is returned.
+*/
+JAS_DLLEXPORT
+jas_stream_t *jas_stream_fdopen(int fd, const char *mode);
+
+/*!
+@brief Open a stdio (i.e., C standard library) stream as a stream.
+
+@param path
+A pointer to a string containing the path of the filename associated
+with the stdio stream.
+@param mode
+A pointer to a string containing the open mode to be used for the
+(JasPer) stream.
+This string is similar to that used by the fdopen function in the
+C standard library.
+@param fp
+A pointer to the stdio stream.
+
+@details
+It is unspecified whether the open mode specified by mode can be
+changed from the open mode used for opening the stdio stream.
+
+@return
+Upon success, a pointer to the opened stream is returned.
+Otherwise, a null pointer is returned.
+*/
+JAS_DLLEXPORT
+jas_stream_t *jas_stream_freopen(const char *path, const char *mode, FILE *fp);
+
+/*!
+@brief Open a temporary file as a stream.
+
+@details
+A temporary file is created and opened as a stream.
+The temporary file is deleted when closed via jas_stream_close().
+Some operating systems provide a mechanism for ensuring that a file
+is removed when closed.
+Such functionality may be used by the implementation when available.
+
+@return
+Upon success, a pointer to the opened stream is returned.
+Otherwise, a null pointer is returned.
+*/
+JAS_DLLEXPORT jas_stream_t *jas_stream_tmpfile(void);
+
+/*!
+@brief Close a stream.
+
+@param stream
+A (nonnull) pointer to the stream to be closed.
+
+@details
+The close operation will implicitly flush any pending output
+to the stream before closing.
+If such a flush operation fails, this will be reflected in
+the return value of this function.
+For many systems, it is likely that the main reason that this function
+can fail is due to an I/O error when flushing buffered output.
+
+@return
+If no errors are encountered when closing the stream, 0 is returned.
+Otherwise, a nonzero value is returned.
+*/
+JAS_DLLEXPORT
+int jas_stream_close(jas_stream_t *stream);
+
+/******************************************************************************\
+* Macros/functions for getting/setting the stream state.
+\******************************************************************************/
+
+/*!
+@brief Get the EOF indicator for a stream.
+
+@param stream
+The stream whose EOF indicator is to be queried.
+
+@return
+The value of the EOF indicator is returned.
+A nonzero value indicates that the stream has encountered EOF.
+*/
+#define jas_stream_eof(stream) \
+ (((stream)->flags_ & JAS_STREAM_EOF) != 0)
+
+/*!
+@brief Get the error indicator for a stream.
+@param stream
+The stream whose error indicator is to be queried.
+@return
+The value of the error indicator is returned.
+A nonzero value indicates that the stream has encountered an error
+of some type (such as an I/O error).
+Note that EOF is not an error.
+*/
+#define jas_stream_error(stream) \
+ (((stream)->flags_ & JAS_STREAM_ERR) != 0)
+
+/*!
+@brief Clear the error indicator for a stream.
+@param stream
+The stream whose error indicator is to be cleared.
+
+@todo
+TODO/FIXME: Should this macro evaluate to void?
+*/
+#define jas_stream_clearerr(stream) \
+ ((stream)->flags_ &= ~(JAS_STREAM_ERR | JAS_STREAM_EOF))
+
+/*!
+@brief Get the read/write limit for a stream.
+@param stream
+A pointer to the stream whose read/write limit is to be queried.
+@return
+The read/write limit for the stream is returned.
+This operation cannot fail.
+A negative read/write limit indicates no limit (i.e., an limit that is
+effectively infinite).
+*/
+#define jas_stream_getrwlimit(stream) \
+ (((const jas_stream_t *)(stream))->rwlimit_)
+
+/*!
+@brief Set the read/write limit for a stream.
+@param stream
+A pointer to the stream whose read/write limit is to be set.
+@param rwlimit
+The new value for the read/write limit.
+
+@details
+A negative read/write limit is treated as if it were infinity
+(i.e., there is no read/write limit).
+
+@return
+The old read/write limit is returned.
+*/
+JAS_DLLEXPORT long jas_stream_setrwlimit(jas_stream_t *stream, long rwlimit);
+
+/*!
+@brief Get the read/write count for a stream.
+
+@param stream
+A pointer to the stream whose read/write count is to be queried.
+
+@return
+The read/write count is returned.
+This operation cannot fail.
+*/
+#define jas_stream_getrwcount(stream) \
+ (((const jas_stream_t *)(stream))->rwcnt_)
+
+/*!
+@brief Set the read/write count for a stream.
+@param stream
+A pointer to the stream whose read/write count is to be set.
+@param rw_count
+The new value for the read/write count.
+@return
+The old value of the read/write count is returned.
+This operation cannot fail.
+@todo
+TODO/FIXME: Should this macro evaluate to void?
+*/
+JAS_DLLEXPORT long jas_stream_setrwcount(jas_stream_t *stream, long rw_count);
+
+/******************************************************************************\
+* Macros/functions for I/O.
+\******************************************************************************/
+
+/* Read a character from a stream. */
+#ifndef NDEBUG
+/*!
+@brief jas_stream_getc
+Read a character from a stream.
+*/
+#define jas_stream_getc(stream) jas_stream_getc_func(stream)
+#else
+#define jas_stream_getc(stream) jas_stream_getc_macro(stream)
+#endif
+
+/* Write a character to a stream. */
+#ifndef NDEBUG
+/*!
+@brief jas_stream_putc
+Write a character to a stream.
+*/
+#define jas_stream_putc(stream, c) jas_stream_putc_func(stream, c)
+#else
+#define jas_stream_putc(stream, c) jas_stream_putc_macro(stream, c)
+#endif
+
+/*!
+@brief Read characters from a stream into a buffer.
+
+@param stream
+A pointer to the stream from which to read data.
+@param buffer
+A pointer to the start of the buffer.
+@param count
+A count of the number of characters to read (nominally).
+
+@details
+If @c count is zero, the function has no effect (and therefore cannot fail).
+Otherwise, the function attempts to read @c count characters from the
+stream @c stream into the buffer starting at @c buffer.
+The number of characters read can be less than @c count, due to
+end-of-file (EOF) or an I/O error.
+
+@return
+The number of characters read is returned.
+In the case that the number of characters read is less than @c count,
+jas_stream_eof() and/or jas_stream_error() must be used
+to distinguish between:
+<ol>
+<li>a failure due to an I/O error
+<li>a failure due to the read/write limit being exceeded
+<li>EOF.
+</ol>
+TODO/CHECK: can items 1 and 2 be distinguished currently?
+
+@warning
+TODO/FIXME/CHECK: jas_stream_error should be true if RWLIMIT exceeded?
+or need a jas_stream_rwlimit predicate?
+
+@warning
+TODO/FIXME: In the future, the type of the count parameter and the
+return type will be changed to size_t.
+*/
+JAS_DLLEXPORT
+unsigned jas_stream_read(jas_stream_t *stream, void *buffer, unsigned count);
+
+/*!
+@brief Attempt to retrieve one or more pending characters of input
+from a stream into a buffer
+without actually removing the characters from the stream.
+
+@param stream
+A pointer to the stream from which to retrieve pending input.
+@param buffer
+A pointer to the start of the buffer.
+@param count
+A count of how many characters to retrieve.
+
+@details
+The extent to which one can peek into the stream is limited.
+Therefore, this function can fail if count is sufficiently large.
+
+@return
+Returns the number of bytes copied to the given buffer, or 0 on error
+or EOF.
+
+@warning
+TODO/FIXME: peeking at EOF should be distinguishable from an I/O error
+*/
+JAS_DLLEXPORT
+unsigned jas_stream_peek(jas_stream_t *stream, void *buffer, size_t count);
+
+/*!
+@brief Write characters from a buffer to a stream.
+@param stream
+A pointer to the stream to which to write data.
+@param buffer
+A pointer to the start of the buffer.
+@param count
+A count of the number of characters to write.
+
+@details
+If @c count is zero, the function has no effect (and therefore cannot fail).
+Otherwise, the function will attempt to write @c count characters
+from the buffer starting at @c buffer to the stream @c stream.
+The number of characters written can be less than @c count due to
+an I/O error or the read/write limit being exceeded.
+
+@return
+Upon success, the number of characters successfully written is returned.
+If an error occurs, the value returned will be less than @c count.
+The jas_stream_error() and jas_stream_rwlimit() function (TODO/CHECK: the latter
+of which does not currently exist?) can be used to distinguish between:
+<ol>
+<li>failure due to an I/O error
+<li>failure due to the read/write limit being exceeded
+</ol>
+
+@warning
+TODO/FIXME:
+The type of the count parameter should be size_t.
+The return type should be size_t.
+*/
+JAS_DLLEXPORT
+unsigned jas_stream_write(jas_stream_t *stream, const void *buffer,
+ unsigned count);
+
+/*!
+@brief Write formatted output to a stream.
+
+@param stream
+A pointer to the stream to which to write output.
+@param format
+A pointer to a format string similar to the printf function in the C standard
+library.
+
+@details
+The function prints the information associated with the format string
+to the specified stream.
+
+@return
+Upon success, the number of characters output to the stream is returned.
+If an error is encountered, a negative value is returned.
+
+@todo
+I think that the return type of int is okay here.
+It is consistent with printf and friends.
+*/
+JAS_DLLEXPORT
+int jas_stream_printf(jas_stream_t *stream, const char *format, ...);
+
+/*!
+@brief Write a string to a stream.
+
+@param stream
+A pointer to the stream to which the string should be written.
+@param s
+A pointer to a null-terminated string for output.
+
+@details
+The null character is not output.
+
+@return
+Upon success, a nonnegative value is returned.
+Upon failure, a negative value is returned.
+*/
+JAS_DLLEXPORT int jas_stream_puts(jas_stream_t *stream, const char *s);
+
+/*!
+@brief Read a line of input from a stream.
+
+@param stream
+A pointer to the stream from which to read input.
+@param buffer
+A pointer to the start of the buffer to hold to input to be read.
+@param buffer_size
+The size of the buffer in characters.
+
+@details
+The function reads a line of input from a stream into a buffer.
+If a newline character is read, it is placed in the buffer.
+Since the buffer may be too small to hold the input,
+this operation can fail due to attempted buffer overrun.
+
+@return
+If the operation fails (e.g., due to an I/O error or attempted buffer overrun),
+a null pointer is returned.
+Otherwise, buffer is returned.
+*/
+JAS_DLLEXPORT char *
+jas_stream_gets(jas_stream_t *stream, char *buffer, int buffer_size);
+
+/*!
+@brief Look at the next character to be read from a stream without actually
+removing the character from the stream.
+
+@param stream
+A pointer to the stream to be examined.
+
+@details
+This function examines the next character that would be read from the
+stream and returns this character without actually removing it from the
+stream.
+
+@return
+If the peek operation fails (e.g., due to EOF or I/O error),
+EOF is returned.
+Otherwise, the character that would be next read from the stream
+is returned.
+*/
+#define jas_stream_peekc(stream) \
+ (((stream)->cnt_ <= 0) ? jas_stream_fillbuf(stream, 0) : \
+ ((int)(*(stream)->ptr_)))
+
+/*!
+@brief Put a character back on a stream.
+
+@param stream
+A pointer to the stream to which the character should be put back.
+@param c
+The character to put back.
+
+@details
+The character @c c (which was presumably read previously from the stream
+@c stream) is put back on the stream (as if it had not yet been read).
+In other words, this function undoes the effect of jas_stream_getc().
+It is unspecified what happens if the character put back was not the
+one originally read.
+The number of characters that can be pushed back onto the stream
+for subsequent reading is limited.
+Trying to push back too many characters on a stream will result in an error.
+The approximate limit is given by the value of JAS_STREAM_MAXPUTBACK.
+
+@return
+Upon success, zero is returned.
+If the specified character cannot be pushed back, a negative value is returned.
+*/
+JAS_DLLEXPORT int
+jas_stream_ungetc(jas_stream_t *stream, int c);
+
+/******************************************************************************\
+* Macros/functions for getting/setting the stream position.
+\******************************************************************************/
+
+/*!
+@brief Determine if stream supports seeking.
+
+@param stream
+A pointer to the stream to query.
+
+@details
+The function is a predicate that tests if the underlying file object
+supports seek operations.
+
+@return
+If the underlying file object supports seek operations, a (strictly)
+positive value is returned.
+Otherwise, 0 is returned.
+*/
+JAS_ATTRIBUTE_PURE JAS_DLLEXPORT
+int jas_stream_isseekable(jas_stream_t *stream);
+
+/*!
+@brief Set the current position within the stream.
+
+@param stream
+A pointer to the stream for which to set the current position.
+@param offset
+The new position for the stream.
+@param origin
+The origin to which this new position is relative.
+
+@details
+The origin can be SEEK_CUR, SEEK_SET, or SEEK_END
+in a similar fashion as the fseek function in the C standard library
+(and the lseek function in POSIX).
+
+@return
+Upon success, the new stream position is returned.
+Upon failure, a negative value is returned.
+*/
+JAS_DLLEXPORT
+long jas_stream_seek(jas_stream_t *stream, long offset, int origin);
+
+/*!
+@brief Get the current position within the stream.
+@param stream
+A pointer to the stream whose current position is to be queried.
+
+@details
+The current position of the stream is returned.
+
+@return
+Upon success, the current stream position is returned.
+If an error is encountered, a negative value is returned.
+*/
+JAS_ATTRIBUTE_PURE JAS_DLLEXPORT
+long jas_stream_tell(jas_stream_t *stream);
+
+/*!
+@brief Seek to the beginning of a stream.
+@param stream
+A pointer to the stream whose position is to be set.
+@details
+The stream position is set to the start of the stream.
+This function is equivalent to returning the value
+of jas_stream_seek(stream, 0, SEEK_SET).
+@return
+Upon success, the new stream position is returned.
+Otherwise, a negative value is returned.
+*/
+JAS_DLLEXPORT int jas_stream_rewind(jas_stream_t *stream);
+
+/******************************************************************************\
+* Macros/functions for flushing.
+\******************************************************************************/
+
+/*!
+@brief Flush any pending output to a stream.
+@param stream
+A pointer to the stream for which output should be flushed.
+@details
+The function flushes any buffered output to the underlying file object.
+@return
+Upon success, zero is returned.
+Otherwise, a negative value is returned.
+*/
+JAS_DLLEXPORT int jas_stream_flush(jas_stream_t *stream);
+
+/******************************************************************************\
+* Miscellaneous macros/functions.
+\******************************************************************************/
+
+/*!
+@brief Copy data from one stream to another.
+
+@param destination
+A pointer to the stream that is the destination for the copy.
+@param source
+A pointer to the stream that is the source for the copy.
+@param count
+The number of characters to copy.
+
+@details
+The function copies the specified number of characters from the
+source stream to the destination stream.
+
+@return
+Upon success, 0 is returned; otherwise, -1 is returned.
+
+@todo
+TODO/FIXME: count should probably be a size_t; return type ssize_t?
+*/
+JAS_DLLEXPORT int jas_stream_copy(jas_stream_t *destination, jas_stream_t *source, int count);
+
+/*!
+@brief Print a hex dump of data read from a stream.
+
+@param stream
+A pointer to the stream from which to read data.
+@param fp
+A pointer to a stdio stream (i.e., FILE) to which to print the hex dump.
+@param count
+The number of characters to include in the hex dump.
+
+@details
+This function prints a hex dump of data read from a stream to a
+stdio stream.
+This function is most likely to be useful for debugging.
+
+@return
+Upon success, 0 is returned.
+Otherwise, a negative value is returned.
+
+@todo
+TODO/FIXME: should count be unsigned int or size_t instead of int?
+*/
+JAS_DLLEXPORT
+int jas_stream_display(jas_stream_t *stream, FILE *fp, int count);
+
+/*!
+@brief Consume (i.e., discard) characters from stream.
+
+@param stream
+A pointer to the stream from which to discard data.
+@param count
+The number of characters to discard.
+
+@details
+This function reads and discards the specified number of characters from the
+given stream.
+
+@return
+This function returns the number of characters read and discarded.
+If an error or EOF is encountered, the number of characters read
+will be less than count.
+To distinguish EOF from an I/O error, jas_stream_eof() and jas_stream_error()
+can be used.
+
+@warning
+TODO/FIXME: count be size_t and return type should be ssize_t
+*/
+JAS_DLLEXPORT int jas_stream_gobble(jas_stream_t *stream, int count);
+
+/*!
+@brief Write a fill character multiple times to a stream.
+
+@param stream
+A pointer to the stream to which to write.
+@param count
+The number of times to write the fill character to the stream.
+@param value
+The fill character.
+
+@details
+This function writes the given fill character to a stream a
+specified number of times.
+If a count of zero is specified, the function should have no effect.
+
+@return
+The number of times the fill character was written to the stream is
+returned.
+If this value is less than the specified count, an error must have
+occurred.
+
+@todo
+TODO: should the count be size_t; return type maybe size_t?
+*/
+JAS_DLLEXPORT int jas_stream_pad(jas_stream_t *stream, int count, int value);
+
+/*!
+@brief Get the size of the file associated with the specified stream.
+
+@param stream
+
+@details
+This function queries the size (i.e., length) of the underlying file object
+associated with the specified stream.
+The specified stream must be seekable.
+
+@return
+Upon success, the size of the stream is returned.
+If an error occurs, a negative value is returned.
+
+@warning
+TODO/FIXME: the return type should be ssize_t?
+*/
+JAS_ATTRIBUTE_PURE JAS_DLLEXPORT
+long jas_stream_length(jas_stream_t *stream);
+
+/******************************************************************************\
+* Internal functions.
+\******************************************************************************/
+
+/* The following functions are for internal use only! If you call them
+directly, you will die a horrible, miserable, and painful death! */
+
+/* These prototypes need to be here for the sake of the stream_getc and
+stream_putc macros. */
+/* Library users must not invoke these functions directly. */
+JAS_DLLEXPORT int jas_stream_fillbuf(jas_stream_t *stream, int getflag);
+JAS_DLLEXPORT int jas_stream_flushbuf(jas_stream_t *stream, int c);
+JAS_DLLEXPORT int jas_stream_getc_func(jas_stream_t *stream);
+JAS_DLLEXPORT int jas_stream_putc_func(jas_stream_t *stream, int c);
+
+/* Read a character from a stream. */
+static inline int jas_stream_getc2(jas_stream_t *stream)
+{+ if (--stream->cnt_ < 0)
+ return jas_stream_fillbuf(stream, 1);
+
+ ++stream->rwcnt_;
+ return (int)(*stream->ptr_++);
+}
+
+static inline int jas_stream_getc_macro(jas_stream_t *stream)
+{+ if (stream->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | JAS_STREAM_RWLIMIT))
+ return EOF;
+
+ if (stream->rwlimit_ >= 0 && stream->rwcnt_ >= stream->rwlimit_) {+ stream->flags_ |= JAS_STREAM_RWLIMIT;
+ return EOF;
+ }
+
+ return jas_stream_getc2(stream);
+}
+
+/* Write a character to a stream. */
+static inline int jas_stream_putc2(jas_stream_t *stream, jas_uchar c)
+{+ stream->bufmode_ |= JAS_STREAM_WRBUF;
+
+ if (--stream->cnt_ < 0)
+ return jas_stream_flushbuf(stream, c);
+ else {+ ++stream->rwcnt_;
+ return (int)(*stream->ptr_++ = c);
+ }
+}
+
+static inline int jas_stream_putc_macro(jas_stream_t *stream, jas_uchar c)
+{+ if (stream->flags_ & (JAS_STREAM_ERR | JAS_STREAM_EOF | JAS_STREAM_RWLIMIT))
+ return EOF;
+
+ if (stream->rwlimit_ >= 0 && stream->rwcnt_ >= stream->rwlimit_) {+ stream->flags_ |= JAS_STREAM_RWLIMIT;
+ return EOF;
+ }
+
+ return jas_stream_putc2(stream, c);
+}
+
+/*!
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_string.h
@@ -1,0 +1,94 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_string.h
+ * @brief String Library
+ */
+
+#ifndef JAS_STRING_H
+#define JAS_STRING_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Copy a string (a la strdup). */
+JAS_DLLEXPORT char *jas_strdup(const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jas_types.h
@@ -1,0 +1,134 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jas_types.h
+ * @brief Primitive Types
+ */
+
+#ifndef JAS_TYPES_H
+#define JAS_TYPES_H
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#define INT_MAX 0x7fffffff
+#define UINT_FAST32_MAX 0xffffffff
+#define SIZE_MAX UINT_FAST32_MAX
+#define INT_FAST32_MIN ((s32int)0x80000000)
+#define INT_FAST32_MAX INT_MAX
+#define LONG_MAX INT_MAX
+
+typedef s8int int_least8_t;
+typedef s16int int_fast16_t;
+typedef s32int int_fast32_t;
+typedef s32int int_least32_t;
+typedef s64int int_fast64_t;
+
+typedef u8int uint_least8_t;
+typedef u8int uint_fast8_t;
+typedef u16int uint_fast16_t;
+typedef u16int uint_least16_t;
+typedef u32int uint_fast32_t;
+typedef u32int uint_least32_t;
+typedef u64int uint_least64_t;
+typedef u64int uint_fast64_t;
+
+typedef unsigned char jas_uchar;
+typedef unsigned int jas_uint;
+typedef unsigned long jas_ulong;
+typedef long long jas_longlong;
+typedef unsigned long long jas_ulonglong;
+
+typedef enum { false, true } bool;+
+#define PRIxFAST32 "x"
+#define PRIxFAST16 PRIxFAST32
+#define PRIuFAST32 "u"
+#define PRIuFAST16 PRIuFAST32
+#define PRIiFAST32 "i"
+#define PRIiLEAST32 PRIiFAST32
+#define PRIxLEAST16 "x"
+#define PRIdPTR "lld"
+#define _HUGE_ENUF 1e+300
+#define INFINITY ((float)(_HUGE_ENUF * _HUGE_ENUF))
+
+/* The below macro is intended to be used for type casts. By using this
+ macro, type casts can be easily located in the source code with
+ tools like "grep". */
+#define JAS_CAST(t, e) \
+ ((t) (e))
+
+/* The number of bits in the integeral type uint_fast32_t. */
+/* NOTE: This could underestimate the size on some exotic architectures. */
+#define JAS_UINTFAST32_NUMBITS (8 * sizeof(uint_fast32_t))
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+++ b/jasper/jasper.h
@@ -1,0 +1,101 @@
+/*
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*!
+ * @file jasper.h
+ * @brief JasPer Main Header
+ */
+
+#ifndef JAS_JASPER_H
+#define JAS_JASPER_H
+
+// IWYU pragma: begin_exports
+
+/* The configuration header file should be included first. */
+#include <jasper/jas_config.h>
+
+#include <jasper/jas_types.h>
+
+#include <jasper/jas_init.h>
+#include <jasper/jas_cm.h>
+#include <jasper/jas_icc.h>
+#include <jasper/jas_fix.h>
+#include <jasper/jas_debug.h>
+#include <jasper/jas_image.h>
+#include <jasper/jas_math.h>
+#include <jasper/jas_malloc.h>
+#include <jasper/jas_seq.h>
+#include <jasper/jas_stream.h>
+#include <jasper/jas_string.h>
+
+#pragma lib "./libjp29.a"
+
+#ifdef __cplusplus
+extern "C" {+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+// IWYU pragma: end_exports
+
+#endif
--- /dev/null
+++ b/jp2.c
@@ -1,0 +1,97 @@
+#include <jasper/jasper.h>
+#include <draw.h>
+#include <memdraw.h>
+
+static void
+usage(void)
+{+ fprint(2, "usage: %s < FILE.jp2 > FILE.pic\n", argv0);
+ exits("usage");+}
+
+void
+main(int argc, char **argv)
+{+ jas_stream_t *s;
+ jas_image_t *im;
+ jas_cmprof_t *cp;
+ int c, i, w, h, x, y;
+ jas_image_cmpttype_t comps[] = {+ JAS_IMAGE_CT_RGB_R,
+ JAS_IMAGE_CT_RGB_G,
+ JAS_IMAGE_CT_RGB_B,
+ };
+ u8int *rgb;
+ long *b;
+ Memimage *m;
+
+ ARGBEGIN{+ default:
+ usage();
+ }ARGEND
+
+ if(argc != 0)
+ usage();
+
+ memimageinit();
+ jas_init();
+
+ if((cp = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB)) == nil){+ werrstr("failed to create color space");+ goto error;
+ }
+ if((s = jas_stream_fdopen(0, "rb")) == nil){+ werrstr("failed to open");+ goto error;
+ }
+ if((im = jas_image_decode(s, -1, "")) == nil){+ werrstr("failed to decode: %r");+ goto error;
+ }
+ jas_stream_close(s);
+ if((im = jas_image_chclrspc(im, cp, JAS_CMXFORM_INTENT_PER)) == nil){+ werrstr("failed to change color space");+ goto error;
+ }
+ w = jas_image_width(im);
+ h = jas_image_height(im);
+ if((b = malloc(w*h*sizeof(*b))) == nil){+ werrstr("memory");+ goto error;
+ }
+ if((rgb = malloc(w*h*3)) == nil){+ werrstr("memory");+ goto error;
+ }
+
+ for(i = 0; i < 3; i++){+ if((c = jas_image_getcmptbytype(im, comps[i])) < 0){+ werrstr("failed to get component R");+ goto error;
+ }
+ if(jas_image_readcmpt2(im, c, 0, 0, w, h, b) < 0){+ werrstr("read component failed");+ goto error;
+ }
+ for(y = 0; y < h; y++){+ for(x = 0; x < w; x++){+ rgb[3*(y*w + x) + 2-i] = b[y*w + x];
+ }
+ }
+ }
+ jas_image_destroy(im);
+ free(b);
+
+ if((m = allocmemimage(Rect(0,0,w,h), RGB24)) == nil){+ werrstr("memory");+ goto error;
+ }
+ loadmemimage(m, m->r, rgb, w*h*3);
+ writememimage(1, m);
+ freememimage(m);
+
+ exits(nil);
+error:
+ fprint(2, "%r\n");
+ exits("error");+}
--- /dev/null
+++ b/jp2_cod.c
@@ -1,0 +1,958 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * JP2 Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jp2_cod.h"
+
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_debug.h"
+
+/******************************************************************************\
+* Function prototypes.
+\******************************************************************************/
+
+#define ONES(n) ((1 << (n)) - 1)
+
+static const jp2_boxinfo_t *jp2_boxinfolookup(int type);
+
+static int jp2_getuint8(jas_stream_t *in, uint_fast8_t *val);
+static int jp2_getuint16(jas_stream_t *in, uint_fast16_t *val);
+static int jp2_getuint32(jas_stream_t *in, uint_fast32_t *val);
+static int jp2_getuint64(jas_stream_t *in, uint_fast64_t *val);
+static int jp2_putuint8(jas_stream_t *out, uint_fast8_t val);
+static int jp2_putuint16(jas_stream_t *out, uint_fast16_t val);
+static int jp2_putuint32(jas_stream_t *out, uint_fast32_t val);
+static int jp2_putuint64(jas_stream_t *out, uint_fast64_t val);
+
+static int jp2_getint(jas_stream_t *in, int s, int n, int_fast32_t *val);
+
+static void jp2_box_dump(const jp2_box_t *box, FILE *out);
+
+static int jp2_jp_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_jp_putdata(const jp2_box_t *box, jas_stream_t *out);
+static int jp2_ftyp_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_ftyp_putdata(const jp2_box_t *box, jas_stream_t *out);
+static int jp2_ihdr_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_ihdr_putdata(const jp2_box_t *box, jas_stream_t *out);
+static void jp2_bpcc_destroy(jp2_box_t *box);
+static int jp2_bpcc_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_bpcc_putdata(const jp2_box_t *box, jas_stream_t *out);
+static int jp2_colr_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_colr_putdata(const jp2_box_t *box, jas_stream_t *out);
+static void jp2_colr_dumpdata(const jp2_box_t *box, FILE *out);
+static void jp2_colr_destroy(jp2_box_t *box);
+static void jp2_cdef_destroy(jp2_box_t *box);
+static int jp2_cdef_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_cdef_putdata(const jp2_box_t *box, jas_stream_t *out);
+static void jp2_cdef_dumpdata(const jp2_box_t *box, FILE *out);
+static void jp2_cmap_destroy(jp2_box_t *box);
+static int jp2_cmap_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_cmap_putdata(const jp2_box_t *box, jas_stream_t *out);
+static void jp2_cmap_dumpdata(const jp2_box_t *box, FILE *out);
+static void jp2_pclr_destroy(jp2_box_t *box);
+static int jp2_pclr_getdata(jp2_box_t *box, jas_stream_t *in);
+static int jp2_pclr_putdata(const jp2_box_t *box, jas_stream_t *out);
+static void jp2_pclr_dumpdata(const jp2_box_t *box, FILE *out);
+
+/******************************************************************************\
+* Local data.
+\******************************************************************************/
+
+static const jp2_boxinfo_t jp2_boxinfos[] = {+ {JP2_BOX_JP, 0, "JP",+ {0, 0, jp2_jp_getdata, jp2_jp_putdata, 0}},+ {JP2_BOX_FTYP, 0, "FTYP",+ {0, 0, jp2_ftyp_getdata, jp2_ftyp_putdata, 0}},+ {JP2_BOX_JP2H, JP2_BOX_SUPER, "JP2H",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_IHDR, 0, "IHDR",+ {0, 0, jp2_ihdr_getdata, jp2_ihdr_putdata, 0}},+ {JP2_BOX_BPCC, 0, "BPCC",+ {0, jp2_bpcc_destroy, jp2_bpcc_getdata, jp2_bpcc_putdata, 0}},+ {JP2_BOX_COLR, 0, "COLR",+ {0, jp2_colr_destroy, jp2_colr_getdata, jp2_colr_putdata, jp2_colr_dumpdata}},+ {JP2_BOX_PCLR, 0, "PCLR",+ {0, jp2_pclr_destroy, jp2_pclr_getdata, jp2_pclr_putdata, jp2_pclr_dumpdata}},+ {JP2_BOX_CMAP, 0, "CMAP",+ {0, jp2_cmap_destroy, jp2_cmap_getdata, jp2_cmap_putdata, jp2_cmap_dumpdata}},+ {JP2_BOX_CDEF, 0, "CDEF",+ {0, jp2_cdef_destroy, jp2_cdef_getdata, jp2_cdef_putdata, jp2_cdef_dumpdata}},+ {JP2_BOX_RES, JP2_BOX_SUPER, "RES",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_RESC, 0, "RESC",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_RESD, 0, "RESD",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_JP2C, JP2_BOX_NODATA, "JP2C",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_JP2I, 0, "JP2I",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_XML, 0, "XML",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_UUID, 0, "UUID",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_UINF, JP2_BOX_SUPER, "UINF",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_ULST, 0, "ULST",+ {0, 0, 0, 0, 0}},+ {JP2_BOX_URL, 0, "URL",+ {0, 0, 0, 0, 0}},+ {0, 0, 0, {0, 0, 0, 0, 0}},+};
+
+static const jp2_boxinfo_t jp2_boxinfo_unk = {+ 0, 0, "Unknown", {0, 0, 0, 0, 0}+};
+
+/******************************************************************************\
+* Box constructor.
+\******************************************************************************/
+
+static jp2_box_t *jp2_box_create0(void)
+{+ jp2_box_t *box;
+ if (!(box = jas_malloc(sizeof(jp2_box_t)))) {+ return 0;
+ }
+ memset(box, 0, sizeof(jp2_box_t));
+ // Mark the box data as never having been constructed
+ // so that we will not errantly attempt to destroy it later.
+ box->ops = &jp2_boxinfo_unk.ops;
+ return box;
+}
+
+jp2_box_t *jp2_box_create(int type)
+{+ const jp2_boxinfo_t *boxinfo = jp2_boxinfolookup(type);
+ assert(boxinfo != NULL);
+ if (boxinfo == &jp2_boxinfo_unk) {+ // on error, jp2_boxinfolookup() returns &jp2_boxinfo_unk
+ return NULL;
+ }
+
+ jp2_box_t *box;
+ if (!(box = jp2_box_create0())) {+ return 0;
+ }
+ box->type = type;
+ box->len = 0;
+ box->info = boxinfo;
+ box->ops = &boxinfo->ops;
+ return box;
+}
+
+/******************************************************************************\
+* Box destructor.
+\******************************************************************************/
+
+void jp2_box_destroy(jp2_box_t *box)
+{+ if (box->ops->destroy) {+ (*box->ops->destroy)(box);
+ }
+ jas_free(box);
+}
+
+static void jp2_bpcc_destroy(jp2_box_t *box)
+{+ jp2_bpcc_t *bpcc = &box->data.bpcc;
+ if (bpcc->bpcs) {+ jas_free(bpcc->bpcs);
+ bpcc->bpcs = 0;
+ }
+}
+
+static void jp2_cdef_destroy(jp2_box_t *box)
+{+ jp2_cdef_t *cdef = &box->data.cdef;
+ if (cdef->ents) {+ jas_free(cdef->ents);
+ cdef->ents = 0;
+ }
+}
+
+/******************************************************************************\
+* Box input.
+\******************************************************************************/
+
+jp2_box_t *jp2_box_get(jas_stream_t *in)
+{+ jp2_box_t *box;
+ const jp2_boxinfo_t *boxinfo;
+ jas_stream_t *tmpstream;
+ uint_fast32_t len;
+ uint_fast64_t extlen;
+ bool dataflag;
+
+ tmpstream = 0;
+
+ if (!(box = jp2_box_create0())) {+ goto error;
+ }
+ if (jp2_getuint32(in, &len) || jp2_getuint32(in, &box->type)) {+ goto error;
+ }
+ boxinfo = jp2_boxinfolookup(box->type);
+ box->info = boxinfo;
+ box->len = len;
+ JAS_DBGLOG(10, (
+ "preliminary processing of JP2 box: "
+ "type=%c%s%c (0x%08x); length=%"PRIuFAST32"\n",
+ '"', boxinfo->name, '"', box->type, box->len
+ ));
+ size_t hdrlen;
+ if (box->len == 1) {+ JAS_DBGLOG(10, ("big length\n"));+ if (jp2_getuint64(in, &extlen)) {+ goto error;
+ }
+ if (extlen > 0xffffffffUL) {+ jas_eprintf("warning: cannot handle large 64-bit box length\n");+ goto error;
+ }
+ box->len = extlen;
+ hdrlen = JP2_BOX_HDRLEN(true);
+ } else {+ hdrlen = JP2_BOX_HDRLEN(false);
+ }
+ if (box->len != 0 && box->len < 8) {+ goto error;
+ }
+ if (box->len > 0x7fffffffUL) {+ /* this limit is the largest value which can
+ be passed to jas_stream_copy() without
+ overflowing */
+ goto error;
+ }
+
+ dataflag = !(box->info->flags & (JP2_BOX_SUPER | JP2_BOX_NODATA));
+
+ if (dataflag) {+ if (box->len < hdrlen)
+ goto error;
+ box->datalen = box->len - hdrlen;
+
+ if (!(tmpstream = jas_stream_memopen(0, 0))) {+ goto error;
+ }
+ if (jas_stream_copy(tmpstream, in, box->datalen)) {+ jas_eprintf("cannot copy box data\n");+ goto error;
+ }
+ jas_stream_rewind(tmpstream);
+
+ // From here onwards, the box data will need to be destroyed.
+ // So, initialize the box operations.
+ box->ops = &boxinfo->ops;
+
+ if (box->ops->getdata) {+ if ((*box->ops->getdata)(box, tmpstream)) {+ jas_eprintf("cannot parse box data\n");+ goto error;
+ }
+ }
+ jas_stream_close(tmpstream);
+ }
+
+ if (jas_getdbglevel() >= 1) {+ jp2_box_dump(box, stderr);
+ }
+
+ return box;
+
+error:
+ if (box) {+ jp2_box_destroy(box);
+ }
+ if (tmpstream) {+ jas_stream_close(tmpstream);
+ }
+ return 0;
+}
+
+static void jp2_box_dump(const jp2_box_t *box, FILE *out)
+{+ const jp2_boxinfo_t *boxinfo = box->info;
+ assert(boxinfo);
+
+ fprintf(out, "JP2 box: ");
+ fprintf(out, "type=%c%s%c (0x%08"PRIxFAST32"); length=%"PRIuFAST32"\n", '"',
+ boxinfo->name, '"', box->type, box->len);
+ if (box->ops->dumpdata) {+ (*box->ops->dumpdata)(box, out);
+ }
+}
+
+static int jp2_jp_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ jp2_jp_t *jp = &box->data.jp;
+ if (jp2_getuint32(in, &jp->magic)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jp2_ftyp_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ if (box->datalen < 8)
+ return -1;
+
+ jp2_ftyp_t *ftyp = &box->data.ftyp;
+ unsigned int i;
+ if (jp2_getuint32(in, &ftyp->majver) || jp2_getuint32(in, &ftyp->minver)) {+ return -1;
+ }
+ ftyp->numcompatcodes = (box->datalen - 8) / 4;
+ if (ftyp->numcompatcodes > JP2_FTYP_MAXCOMPATCODES) {+ return -1;
+ }
+ for (i = 0; i < ftyp->numcompatcodes; ++i) {+ if (jp2_getuint32(in, &ftyp->compatcodes[i])) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jp2_ihdr_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ jp2_ihdr_t *ihdr = &box->data.ihdr;
+ if (jp2_getuint32(in, &ihdr->height) || jp2_getuint32(in, &ihdr->width) ||
+ jp2_getuint16(in, &ihdr->numcmpts) || jp2_getuint8(in, &ihdr->bpc) ||
+ jp2_getuint8(in, &ihdr->comptype) || jp2_getuint8(in, &ihdr->csunk) ||
+ jp2_getuint8(in, &ihdr->ipr)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jp2_bpcc_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ if (box->datalen > 0xffff)
+ /* excessive number of components - this is a
+ pessimistic limit, because in jp2_ihdr_getdata(),
+ it's a 16 bit integer */
+ return -1;
+
+ jp2_bpcc_t *bpcc = &box->data.bpcc;
+ unsigned int i;
+ bpcc->bpcs = 0;
+ bpcc->numcmpts = box->datalen;
+ if (!(bpcc->bpcs = jas_alloc2(bpcc->numcmpts, sizeof(uint_fast8_t)))) {+ return -1;
+ }
+ for (i = 0; i < bpcc->numcmpts; ++i) {+ if (jp2_getuint8(in, &bpcc->bpcs[i])) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static void jp2_colr_dumpdata(const jp2_box_t *box, FILE *out)
+{+ const jp2_colr_t *colr = &box->data.colr;
+ fprintf(out, "method=%d; pri=%d; approx=%d\n", (int)colr->method, (int)colr->pri, (int)colr->approx);
+ switch (colr->method) {+ case JP2_COLR_ENUM:
+ fprintf(out, "csid=%d\n", (int)colr->csid);
+ break;
+ case JP2_COLR_ICC:
+ jas_memdump(out, colr->iccp, colr->iccplen);
+ break;
+ }
+}
+
+static int jp2_colr_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ if (box->datalen < 3)
+ return -1;
+
+ jp2_colr_t *colr = &box->data.colr;
+ colr->csid = 0;
+ colr->iccp = 0;
+ colr->iccplen = 0;
+
+ if (jp2_getuint8(in, &colr->method) || jp2_getuint8(in, &colr->pri) ||
+ jp2_getuint8(in, &colr->approx)) {+ return -1;
+ }
+ switch (colr->method) {+ case JP2_COLR_ENUM:
+ if (jp2_getuint32(in, &colr->csid)) {+ return -1;
+ }
+ break;
+ case JP2_COLR_ICC:
+ colr->iccplen = box->datalen - 3;
+ if (colr->iccplen > 1024 * 1024)
+ /* refuse to read ICC profiles larger than 1
+ MB (I have no idea how large ICC profiles
+ can get, but I believe this limit might be
+ very pessimistic and should be lowered
+ further) */
+ return -1;
+ if (!(colr->iccp = jas_alloc2(colr->iccplen, sizeof(uint_fast8_t)))) {+ return -1;
+ }
+ if (jas_stream_read(in, colr->iccp, colr->iccplen) != colr->iccplen) {+ return -1;
+ }
+ break;
+ }
+ return 0;
+}
+
+static void jp2_cdef_dumpdata(const jp2_box_t *box, FILE *out)
+{+ const jp2_cdef_t *cdef = &box->data.cdef;
+ unsigned int i;
+ for (i = 0; i < cdef->numchans; ++i) {+ fprintf(out,
+ "channo=%"PRIuFAST16"; type=%"PRIuFAST16"; assoc=%"PRIuFAST16"\n",
+ cdef->ents[i].channo, cdef->ents[i].type, cdef->ents[i].assoc);
+ }
+}
+
+static void jp2_colr_destroy(jp2_box_t *box)
+{+ jp2_colr_t *colr = &box->data.colr;
+ if (colr->iccp) {+ jas_free(colr->iccp);
+ }
+}
+
+static int jp2_cdef_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ jp2_cdef_t *cdef = &box->data.cdef;
+ jp2_cdefchan_t *chan;
+ unsigned int channo;
+ cdef->ents = 0;
+ if (jp2_getuint16(in, &cdef->numchans)) {+ return -1;
+ }
+ if (!(cdef->ents = jas_alloc2(cdef->numchans, sizeof(jp2_cdefchan_t)))) {+ return -1;
+ }
+ for (channo = 0; channo < cdef->numchans; ++channo) {+ chan = &cdef->ents[channo];
+ if (jp2_getuint16(in, &chan->channo) || jp2_getuint16(in, &chan->type) ||
+ jp2_getuint16(in, &chan->assoc)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Box output.
+\******************************************************************************/
+
+int jp2_box_put(jp2_box_t *box, jas_stream_t *out)
+{+ jas_stream_t *tmpstream;
+ bool extlen;
+ bool dataflag;
+
+ tmpstream = 0;
+
+ dataflag = !(box->info->flags & (JP2_BOX_SUPER | JP2_BOX_NODATA));
+
+ if (dataflag) {+ if (!(tmpstream = jas_stream_memopen(0, 0))) {+ goto error;
+ }
+ if (box->ops->putdata) {+ if ((*box->ops->putdata)(box, tmpstream)) {+ goto error;
+ }
+ }
+ box->len = jas_stream_tell(tmpstream) + JP2_BOX_HDRLEN(false);
+ jas_stream_rewind(tmpstream);
+ }
+ extlen = (box->len >= (((uint_fast64_t)1) << 32)) != 0;
+ if (jp2_putuint32(out, extlen ? 1 : box->len)) {+ goto error;
+ }
+ if (jp2_putuint32(out, box->type)) {+ goto error;
+ }
+ if (extlen) {+ if (jp2_putuint64(out, box->len)) {+ goto error;
+ }
+ }
+
+ if (dataflag) {+ if (jas_stream_copy(out, tmpstream, box->len -
+ JP2_BOX_HDRLEN(false))) {+ jas_eprintf("cannot copy box data\n");+ goto error;
+ }
+ jas_stream_close(tmpstream);
+ }
+
+ return 0;
+
+error:
+
+ if (tmpstream) {+ jas_stream_close(tmpstream);
+ }
+ return -1;
+}
+
+static int jp2_jp_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+ const jp2_jp_t *jp = &box->data.jp;
+ if (jp2_putuint32(out, jp->magic)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jp2_ftyp_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+ const jp2_ftyp_t *ftyp = &box->data.ftyp;
+ unsigned int i;
+ if (jp2_putuint32(out, ftyp->majver) || jp2_putuint32(out, ftyp->minver)) {+ return -1;
+ }
+ for (i = 0; i < ftyp->numcompatcodes; ++i) {+ if (jp2_putuint32(out, ftyp->compatcodes[i])) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jp2_ihdr_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+ const jp2_ihdr_t *ihdr = &box->data.ihdr;
+ if (jp2_putuint32(out, ihdr->height) || jp2_putuint32(out, ihdr->width) ||
+ jp2_putuint16(out, ihdr->numcmpts) || jp2_putuint8(out, ihdr->bpc) ||
+ jp2_putuint8(out, ihdr->comptype) || jp2_putuint8(out, ihdr->csunk) ||
+ jp2_putuint8(out, ihdr->ipr)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jp2_bpcc_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+ const jp2_bpcc_t *bpcc = &box->data.bpcc;
+ unsigned int i;
+ for (i = 0; i < bpcc->numcmpts; ++i) {+ if (jp2_putuint8(out, bpcc->bpcs[i])) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jp2_colr_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+ const jp2_colr_t *colr = &box->data.colr;
+ if (jp2_putuint8(out, colr->method) || jp2_putuint8(out, colr->pri) ||
+ jp2_putuint8(out, colr->approx)) {+ return -1;
+ }
+ switch (colr->method) {+ case JP2_COLR_ENUM:
+ if (jp2_putuint32(out, colr->csid)) {+ return -1;
+ }
+ break;
+ case JP2_COLR_ICC:
+ if (jas_stream_write(out, colr->iccp, colr->iccplen) != colr->iccplen)
+ return -1;
+ break;
+ }
+ return 0;
+}
+
+static int jp2_cdef_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+ const jp2_cdef_t *cdef = &box->data.cdef;
+ unsigned int i;
+
+ if (jp2_putuint16(out, cdef->numchans)) {+ return -1;
+ }
+
+ for (i = 0; i < cdef->numchans; ++i) {+ const jp2_cdefchan_t *ent = &cdef->ents[i];
+ if (jp2_putuint16(out, ent->channo) ||
+ jp2_putuint16(out, ent->type) ||
+ jp2_putuint16(out, ent->assoc)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Input operations for primitive types.
+\******************************************************************************/
+
+static int jp2_getuint8(jas_stream_t *in, uint_fast8_t *val)
+{+ int c;
+ if ((c = jas_stream_getc(in)) == EOF) {+ return -1;
+ }
+ if (val) {+ *val = c;
+ }
+ return 0;
+}
+
+static int jp2_getuint16(jas_stream_t *in, uint_fast16_t *val)
+{+ jas_uchar buffer[2];
+ if (jas_stream_read(in, buffer, sizeof(buffer)) != sizeof(buffer))
+ return -1;
+ *val = (uint_fast16_t)buffer[0] << 8 | (uint_fast16_t)buffer[1];
+ return 0;
+}
+
+static int jp2_getuint32(jas_stream_t *in, uint_fast32_t *val)
+{+ jas_uchar buffer[4];
+ if (jas_stream_read(in, buffer, sizeof(buffer)) != sizeof(buffer))
+ return -1;
+ *val = (uint_fast32_t)buffer[0] << 24 | (uint_fast32_t)buffer[1] << 16
+ | (uint_fast32_t)buffer[2] << 8 | (uint_fast32_t)buffer[3];
+ return 0;
+}
+
+static int jp2_getuint64(jas_stream_t *in, uint_fast64_t *val)
+{+ uint_fast64_t tmpval;
+ int i;
+ int c;
+
+ tmpval = 0;
+ for (i = 0; i < 8; ++i) {+ tmpval <<= 8;
+ if ((c = jas_stream_getc(in)) == EOF) {+ return -1;
+ }
+ tmpval |= (c & 0xff);
+ }
+ *val = tmpval;
+
+ return 0;
+}
+
+/******************************************************************************\
+* Output operations for primitive types.
+\******************************************************************************/
+
+static int jp2_putuint8(jas_stream_t *out, uint_fast8_t val)
+{+ if (jas_stream_putc(out, val & 0xff) == EOF) {+ return -1;
+ }
+ return 0;
+}
+
+static int jp2_putuint16(jas_stream_t *out, uint_fast16_t val)
+{+ if (jas_stream_putc(out, (val >> 8) & 0xff) == EOF ||
+ jas_stream_putc(out, val & 0xff) == EOF) {+ return -1;
+ }
+ return 0;
+}
+
+static int jp2_putuint32(jas_stream_t *out, uint_fast32_t val)
+{+ if (jas_stream_putc(out, (val >> 24) & 0xff) == EOF ||
+ jas_stream_putc(out, (val >> 16) & 0xff) == EOF ||
+ jas_stream_putc(out, (val >> 8) & 0xff) == EOF ||
+ jas_stream_putc(out, val & 0xff) == EOF) {+ return -1;
+ }
+ return 0;
+}
+
+static int jp2_putuint64(jas_stream_t *out, uint_fast64_t val)
+{+ if (jp2_putuint32(out, (val >> 32) & 0xffffffffUL) ||
+ jp2_putuint32(out, val & 0xffffffffUL)) {+ return -1;
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Miscellaneous code.
+\******************************************************************************/
+
+static const jp2_boxinfo_t *jp2_boxinfolookup(int type)
+{+ const jp2_boxinfo_t *boxinfo;
+ for (boxinfo = jp2_boxinfos; boxinfo->name; ++boxinfo) {+ if (boxinfo->type == type) {+ return boxinfo;
+ }
+ }
+ return &jp2_boxinfo_unk;
+}
+
+
+
+
+
+static void jp2_cmap_destroy(jp2_box_t *box)
+{+ jp2_cmap_t *cmap = &box->data.cmap;
+ if (cmap->ents) {+ jas_free(cmap->ents);
+ }
+}
+
+static int jp2_cmap_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ jp2_cmap_t *cmap = &box->data.cmap;
+ jp2_cmapent_t *ent;
+ unsigned int i;
+ cmap->ents = 0;
+
+ cmap->numchans = (box->datalen) / 4;
+ if (cmap->numchans > 0xff)
+ /* excessive number of channels - this is a
+ pessimistic limit, because in jp2_pclr_getdata(),
+ it's a 8 bit integer */
+ return -1;
+
+ if (!(cmap->ents = jas_alloc2(cmap->numchans, sizeof(jp2_cmapent_t)))) {+ return -1;
+ }
+ for (i = 0; i < cmap->numchans; ++i) {+ ent = &cmap->ents[i];
+ if (jp2_getuint16(in, &ent->cmptno) ||
+ jp2_getuint8(in, &ent->map) ||
+ jp2_getuint8(in, &ent->pcol)) {+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int jp2_cmap_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+ /* Eliminate compiler warning about unused variables. */
+ USED(box);
+ USED(out);
+
+ return -1;
+}
+
+static void jp2_cmap_dumpdata(const jp2_box_t *box, FILE *out)
+{+ const jp2_cmap_t *cmap = &box->data.cmap;
+ unsigned int i;
+ fprintf(out, "numchans = %d\n", (int) cmap->numchans);
+ for (i = 0; i < cmap->numchans; ++i) {+ const jp2_cmapent_t *ent = &cmap->ents[i];
+ fprintf(out, "cmptno=%d; map=%d; pcol=%d\n",
+ (int) ent->cmptno, (int) ent->map, (int) ent->pcol);
+ }
+}
+
+static void jp2_pclr_destroy(jp2_box_t *box)
+{+ jp2_pclr_t *pclr = &box->data.pclr;
+ if (pclr->lutdata) {+ jas_free(pclr->lutdata);
+ }
+ if (pclr->bpc)
+ jas_free(pclr->bpc);
+}
+
+static int jp2_pclr_getdata(jp2_box_t *box, jas_stream_t *in)
+{+ jp2_pclr_t *pclr = &box->data.pclr;
+ int lutsize;
+ unsigned int i;
+ unsigned int j;
+ int_fast32_t x;
+
+ pclr->lutdata = 0;
+ pclr->bpc = 0;
+
+ if (jp2_getuint16(in, &pclr->numlutents) ||
+ jp2_getuint8(in, &pclr->numchans)) {+ return -1;
+ }
+
+ // verify in range data as per I.5.3.4 - Palette box
+ if (pclr->numchans < 1 || pclr->numlutents < 1 || pclr->numlutents > 1024) {+ return -1;
+ }
+
+ lutsize = pclr->numlutents * pclr->numchans;
+ if (!(pclr->lutdata = jas_alloc2(lutsize, sizeof(int_fast32_t)))) {+ return -1;
+ }
+ if (!(pclr->bpc = jas_alloc2(pclr->numchans, sizeof(uint_fast8_t)))) {+ return -1;
+ }
+ for (i = 0; i < pclr->numchans; ++i) {+ if (jp2_getuint8(in, &pclr->bpc[i])) {+ return -1;
+ }
+ }
+ for (i = 0; i < pclr->numlutents; ++i) {+ for (j = 0; j < pclr->numchans; ++j) {+ if (jp2_getint(in, (pclr->bpc[j] & 0x80) != 0,
+ (pclr->bpc[j] & 0x7f) + 1, &x)) {+ return -1;
+ }
+ pclr->lutdata[i * pclr->numchans + j] = x;
+ }
+ }
+ return 0;
+}
+
+static int jp2_pclr_putdata(const jp2_box_t *box, jas_stream_t *out)
+{+#if 0
+ const jp2_pclr_t *pclr = &box->data.pclr;
+#endif
+ /* Eliminate warning about unused variable. */
+ USED(box);
+ USED(out);
+ return -1;
+}
+
+static void jp2_pclr_dumpdata(const jp2_box_t *box, FILE *out)
+{+ const jp2_pclr_t *pclr = &box->data.pclr;
+ unsigned int i;
+ int j;
+ fprintf(out, "numents=%d; numchans=%d\n", (int) pclr->numlutents,
+ (int) pclr->numchans);
+ for (i = 0; i < pclr->numlutents; ++i) {+ for (j = 0; j < pclr->numchans; ++j) {+ fprintf(out, "LUT[%d][%d]=%"PRIiFAST32"\n", i, j,
+ pclr->lutdata[i * pclr->numchans + j]);
+ }
+ }
+}
+
+static int jp2_getint(jas_stream_t *in, int s, int n, int_fast32_t *val)
+{+ int c;
+ int i;
+ uint_fast32_t v;
+ int m;
+
+ m = (n + 7) / 8;
+
+ v = 0;
+ for (i = 0; i < m; ++i) {+ if ((c = jas_stream_getc(in)) == EOF) {+ return -1;
+ }
+ v = (v << 8) | c;
+ }
+ v &= ONES(n);
+ if (s) {+ int sb;
+ sb = v & (1 << (8 * m - 1));
+ *val = ((~v) + 1) & ONES(8 * m);
+ if (sb) {+ *val = -*val;
+ }
+ } else {+ *val = v;
+ }
+
+ return 0;
+}
+
+const jp2_cdefchan_t *jp2_cdef_lookup(jp2_cdef_t *cdef, int channo)
+{+ unsigned int i;
+ jp2_cdefchan_t *cdefent;
+ for (i = 0; i < cdef->numchans; ++i) {+ cdefent = &cdef->ents[i];
+ if (cdefent->channo == JAS_CAST(unsigned int, channo)) {+ return cdefent;
+ }
+ }
+ return 0;
+}
--- /dev/null
+++ b/jp2_cod.h
@@ -1,0 +1,313 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * JP2 Library
+ *
+ * $Id$
+ */
+
+#ifndef JP2_COD_H
+#define JP2_COD_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_types.h"
+#include "jasper/jas_stream.h"
+#include "jasper/jas_image.h"
+
+/******************************************************************************\
+* Macros.
+\******************************************************************************/
+
+#define JP2_SPTOBPC(s, p) \
+ ((((p) - 1) & 0x7f) | (((s) & 1) << 7))
+
+/******************************************************************************\
+* Box class.
+\******************************************************************************/
+
+#define JP2_BOX_HDRLEN(ext) ((ext) ? 16 : 8)
+
+/* Box types. */
+#define JP2_BOX_JP 0x6a502020 /* Signature */
+#define JP2_BOX_FTYP 0x66747970 /* File Type */
+#define JP2_BOX_JP2H 0x6a703268 /* JP2 Header */
+#define JP2_BOX_IHDR 0x69686472 /* Image Header */
+#define JP2_BOX_BPCC 0x62706363 /* Bits Per Component */
+#define JP2_BOX_COLR 0x636f6c72 /* Color Specification */
+#define JP2_BOX_PCLR 0x70636c72 /* Palette */
+#define JP2_BOX_CMAP 0x636d6170 /* Component Mapping */
+#define JP2_BOX_CDEF 0x63646566 /* Channel Definition */
+#define JP2_BOX_RES 0x72657320 /* Resolution */
+#define JP2_BOX_RESC 0x72657363 /* Capture Resolution */
+#define JP2_BOX_RESD 0x72657364 /* Default Display Resolution */
+#define JP2_BOX_JP2C 0x6a703263 /* Contiguous Code Stream */
+#define JP2_BOX_JP2I 0x6a703269 /* Intellectual Property */
+#define JP2_BOX_XML 0x786d6c20 /* XML */
+#define JP2_BOX_UUID 0x75756964 /* UUID */
+#define JP2_BOX_UINF 0x75696e66 /* UUID Info */
+#define JP2_BOX_ULST 0x75637374 /* UUID List */
+#define JP2_BOX_URL 0x75726c20 /* URL */
+
+#define JP2_BOX_SUPER 0x01
+#define JP2_BOX_NODATA 0x02
+
+/* JP box data. */
+
+#define JP2_JP_MAGIC 0x0d0a870a
+#define JP2_JP_LEN 12
+
+typedef struct {+ uint_fast32_t magic;
+} jp2_jp_t;
+
+/* FTYP box data. */
+
+#define JP2_FTYP_MAXCOMPATCODES 32
+#define JP2_FTYP_MAJVER 0x6a703220
+#define JP2_FTYP_MINVER 0
+#define JP2_FTYP_COMPATCODE JP2_FTYP_MAJVER
+
+typedef struct {+ uint_fast32_t majver;
+ uint_fast32_t minver;
+ uint_fast32_t numcompatcodes;
+ uint_fast32_t compatcodes[JP2_FTYP_MAXCOMPATCODES];
+} jp2_ftyp_t;
+
+/* IHDR box data. */
+
+#define JP2_IHDR_COMPTYPE 7
+#define JP2_IHDR_BPCNULL 255
+
+typedef struct {+ uint_fast32_t width;
+ uint_fast32_t height;
+ uint_fast16_t numcmpts;
+ uint_fast8_t bpc;
+ uint_fast8_t comptype;
+ uint_fast8_t csunk;
+ uint_fast8_t ipr;
+} jp2_ihdr_t;
+
+/* BPCC box data. */
+
+typedef struct {+ uint_fast16_t numcmpts;
+ uint_fast8_t *bpcs;
+} jp2_bpcc_t;
+
+/* COLR box data. */
+
+#define JP2_COLR_ENUM 1
+#define JP2_COLR_ICC 2
+#define JP2_COLR_PRI 0
+
+#define JP2_COLR_SRGB 16
+#define JP2_COLR_SGRAY 17
+#define JP2_COLR_SYCC 18
+
+typedef struct {+ uint_fast8_t method;
+ uint_fast8_t pri;
+ uint_fast8_t approx;
+ uint_fast32_t csid;
+ uint_fast8_t *iccp;
+ size_t iccplen;
+ /* XXX - Someday we ought to add ICC profile data here. */
+} jp2_colr_t;
+
+/* PCLR box data. */
+
+typedef struct {+ uint_fast16_t numlutents;
+ uint_fast8_t numchans;
+ int_fast32_t *lutdata;
+ uint_fast8_t *bpc;
+} jp2_pclr_t;
+
+/* CDEF box per-channel data. */
+
+#define JP2_CDEF_RGB_R 1
+#define JP2_CDEF_RGB_G 2
+#define JP2_CDEF_RGB_B 3
+
+#define JP2_CDEF_YCBCR_Y 1
+#define JP2_CDEF_YCBCR_CB 2
+#define JP2_CDEF_YCBCR_CR 3
+
+#define JP2_CDEF_GRAY_Y 1
+
+#define JP2_CDEF_TYPE_COLOR 0
+#define JP2_CDEF_TYPE_OPACITY 1
+#define JP2_CDEF_TYPE_UNSPEC 65535
+#define JP2_CDEF_ASOC_ALL 0
+#define JP2_CDEF_ASOC_NONE 65535
+
+typedef struct {+ uint_fast16_t channo;
+ uint_fast16_t type;
+ uint_fast16_t assoc;
+} jp2_cdefchan_t;
+
+/* CDEF box data. */
+
+typedef struct {+ uint_fast16_t numchans;
+ jp2_cdefchan_t *ents;
+} jp2_cdef_t;
+
+typedef struct {+ uint_fast16_t cmptno;
+ uint_fast8_t map;
+ uint_fast8_t pcol;
+} jp2_cmapent_t;
+
+typedef struct {+ uint_fast16_t numchans;
+ jp2_cmapent_t *ents;
+} jp2_cmap_t;
+
+#define JP2_CMAP_DIRECT 0
+#define JP2_CMAP_PALETTE 1
+
+/* Generic box. */
+
+struct jp2_boxops_s;
+typedef struct {+
+ const struct jp2_boxops_s *ops;
+ const struct jp2_boxinfo_s *info;
+
+ uint_fast32_t type;
+
+ /* The length of the box including the (variable-length) header. */
+ uint_fast64_t len;
+
+ /* The length of the box data. */
+ uint_fast32_t datalen;
+
+ union {+ jp2_jp_t jp;
+ jp2_ftyp_t ftyp;
+ jp2_ihdr_t ihdr;
+ jp2_bpcc_t bpcc;
+ jp2_colr_t colr;
+ jp2_pclr_t pclr;
+ jp2_cdef_t cdef;
+ jp2_cmap_t cmap;
+ } data;
+
+} jp2_box_t;
+
+typedef struct jp2_boxops_s {+ void (*init)(jp2_box_t *box);
+ void (*destroy)(jp2_box_t *box);
+ int (*getdata)(jp2_box_t *box, jas_stream_t *in);
+ int (*putdata)(const jp2_box_t *box, jas_stream_t *out);
+ void (*dumpdata)(const jp2_box_t *box, FILE *out);
+} jp2_boxops_t;
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+typedef struct jp2_boxinfo_s {+ int type;
+ int flags;
+ const char *name;
+ jp2_boxops_t ops;
+} jp2_boxinfo_t;
+
+/******************************************************************************\
+* Box class.
+\******************************************************************************/
+
+jp2_box_t *jp2_box_create(int type);
+void jp2_box_destroy(jp2_box_t *box);
+jp2_box_t *jp2_box_get(jas_stream_t *in);
+int jp2_box_put(jp2_box_t *box, jas_stream_t *out);
+
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JP2_DTYPETOBPC(uint_least8_t dtype)
+{+ return (JAS_IMAGE_CDT_GETSGND(dtype) << 7) | (JAS_IMAGE_CDT_GETPREC(dtype) - 1);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JP2_BPCTODTYPE(uint_least8_t bpc)
+{+ return JAS_IMAGE_CDT_SETSGND(bpc >> 7) | JAS_IMAGE_CDT_SETPREC((bpc & 0x7f) + 1);
+}
+
+#define ICC_CS_RGB 0x52474220
+#define ICC_CS_YCBCR 0x59436272
+#define ICC_CS_GRAY 0x47524159
+
+const jp2_cdefchan_t *jp2_cdef_lookup(jp2_cdef_t *cdef, int channo);
+
+
+#endif
--- /dev/null
+++ b/jp2_dec.c
@@ -1,0 +1,603 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * JP2 Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jp2_dec.h"
+#include "jp2_cod.h"
+
+#include "jasper/jas_image.h"
+#include "jasper/jas_stream.h"
+#include "jasper/jas_math.h"
+#include "jasper/jas_debug.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_types.h"
+
+#define JP2_VALIDATELEN (JAS_MIN(JP2_JP_LEN + 16, JAS_STREAM_MAXPUTBACK))
+
+static jp2_dec_t *jp2_dec_create(void);
+static void jp2_dec_destroy(jp2_dec_t *dec);
+static int jp2_getcs(jp2_colr_t *colr);
+static int fromiccpcs(int cs);
+static int jp2_getct(int colorspace, int type, int assoc);
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+jas_image_t *jp2_decode(jas_stream_t *in, const 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;
+
+ box = 0;
+
+ JAS_DBGLOG(100, ("jp2_decode(%p, \"%s\")\n", in, optstr));+
+ 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);
+
+ /* 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);
+
+ /* Get more boxes... */
+ found = 0;
+ while ((box = jp2_box_get(in))) {+ if (jas_getdbglevel() >= 1) {+ jas_eprintf("got 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(jas_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(jas_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(jas_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(jas_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);
+ if (!iccprof) {+ jas_eprintf("error: failed to parse ICC profile\n");+ goto error;
+ }
+ 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);
+ if (!dec->image->cmprof_) {+ jas_iccprof_destroy(iccprof);
+ goto error;
+ }
+ 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(jas_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(jas_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_alloc2(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;
+ 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) {+ if (!pclrd->numlutents) {+ goto error;
+ }
+ lutents = jas_alloc2(pclrd->numlutents, sizeof(int_fast32_t));
+ if (!lutents) {+ goto error;
+ }
+ 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));
+ }
+#else
+ /* suppress -Wunused-but-set-variable */
+ (void)cdefd;
+#endif
+ } else {+ jas_eprintf("error: invalid MTYP in CMAP box\n");+ goto error;
+ }
+ }
+ }
+
+ /* Mark all components as being of unknown type. */
+
+ for (i = 0; i < JAS_CAST(jas_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->cdef->data.cdef.numchans; ++i) {+ /* Is the channel number reasonable? */
+ if (dec->cdef->data.cdef.ents[i].channo >= dec->numchans) {+ jas_eprintf("error: invalid channel number in CDEF box\n");+ goto error;
+ }
+ 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
+jas_eprintf("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;
+}
+
+int jp2_validate(jas_stream_t *in)
+{+ unsigned char buf[JP2_VALIDATELEN];
+#if 0
+ jas_stream_t *tmpstream;
+ jp2_box_t *box;
+#endif
+
+ assert(JAS_STREAM_MAXPUTBACK >= JP2_VALIDATELEN);
+
+ /* Read the validation data (i.e., the data used for detecting
+ the format). */
+ if (jas_stream_peek(in, buf, sizeof(buf)) != sizeof(buf))
+ return -1;
+
+ /* Is the box type correct? */
+ if ((((uint_least32_t)buf[4] << 24) | ((uint_least32_t)buf[5] << 16) | ((uint_least32_t)buf[6] << 8) | (uint_least32_t)buf[7]) !=
+ JP2_BOX_JP)
+ {+ return -1;
+ }
+
+ return 0;
+}
+
+static jp2_dec_t *jp2_dec_create(void)
+{+ jp2_dec_t *dec;
+
+ if (!(dec = jas_malloc(sizeof(jp2_dec_t)))) {+ return 0;
+ }
+ dec->ihdr = 0;
+ dec->bpcc = 0;
+ dec->cdef = 0;
+ dec->pclr = 0;
+ dec->image = 0;
+ dec->chantocmptlut = 0;
+ dec->cmap = 0;
+ dec->colr = 0;
+ return dec;
+}
+
+static void jp2_dec_destroy(jp2_dec_t *dec)
+{+ if (dec->ihdr) {+ jp2_box_destroy(dec->ihdr);
+ }
+ if (dec->bpcc) {+ jp2_box_destroy(dec->bpcc);
+ }
+ if (dec->cdef) {+ jp2_box_destroy(dec->cdef);
+ }
+ if (dec->pclr) {+ jp2_box_destroy(dec->pclr);
+ }
+ if (dec->image) {+ jas_image_destroy(dec->image);
+ }
+ if (dec->cmap) {+ jp2_box_destroy(dec->cmap);
+ }
+ if (dec->colr) {+ jp2_box_destroy(dec->colr);
+ }
+ if (dec->chantocmptlut) {+ jas_free(dec->chantocmptlut);
+ }
+ jas_free(dec);
+}
+
+static int jp2_getct(int colorspace, int type, int assoc)
+{+ if (type == 1 && assoc == 0) {+ return JAS_IMAGE_CT_OPACITY;
+ }
+ if (type == 0 && assoc >= 1 && assoc <= 65534) {+ switch (colorspace) {+ case JAS_CLRSPC_FAM_RGB:
+ switch (assoc) {+ case JP2_CDEF_RGB_R:
+ return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R);
+ case JP2_CDEF_RGB_G:
+ return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G);
+ case JP2_CDEF_RGB_B:
+ return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B);
+ }
+ break;
+ case JAS_CLRSPC_FAM_YCBCR:
+ switch (assoc) {+ case JP2_CDEF_YCBCR_Y:
+ return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_Y);
+ case JP2_CDEF_YCBCR_CB:
+ return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CB);
+ case JP2_CDEF_YCBCR_CR:
+ return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_YCBCR_CR);
+ }
+ break;
+ case JAS_CLRSPC_FAM_GRAY:
+ switch (assoc) {+ case JP2_CDEF_GRAY_Y:
+ return JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y);
+ }
+ break;
+ default:
+ return JAS_IMAGE_CT_COLOR(assoc - 1);
+ }
+ }
+ return JAS_IMAGE_CT_UNKNOWN;
+}
+
+static int jp2_getcs(jp2_colr_t *colr)
+{+ if (colr->method == JP2_COLR_ENUM) {+ switch (colr->csid) {+ case JP2_COLR_SRGB:
+ return JAS_CLRSPC_SRGB;
+ case JP2_COLR_SYCC:
+ return JAS_CLRSPC_SYCBCR;
+ case JP2_COLR_SGRAY:
+ return JAS_CLRSPC_SGRAY;
+ }
+ }
+ return JAS_CLRSPC_UNKNOWN;
+}
+
+static int fromiccpcs(int cs)
+{+ switch (cs) {+ case ICC_CS_RGB:
+ return JAS_CLRSPC_GENRGB;
+ case ICC_CS_YCBCR:
+ return JAS_CLRSPC_GENYCBCR;
+ case ICC_CS_GRAY:
+ return JAS_CLRSPC_GENGRAY;
+ }
+ return JAS_CLRSPC_UNKNOWN;
+}
--- /dev/null
+++ b/jp2_dec.h
@@ -1,0 +1,84 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+#ifndef JP2_DEC_H
+#define JP2_DEC_H
+
+#include "jasper/jas_image.h"
+#include "jp2_cod.h"
+
+typedef struct {+
+ jp2_box_t *pclr;
+ jp2_box_t *cdef;
+ jp2_box_t *ihdr;
+ jp2_box_t *bpcc;
+ jp2_box_t *cmap;
+ jp2_box_t *colr;
+ jas_image_t *image;
+ uint_fast16_t numchans;
+ uint_fast16_t *chantocmptlut;
+
+} jp2_dec_t;
+
+#endif
--- /dev/null
+++ b/jpc_bs.c
@@ -1,0 +1,440 @@
+/*
+ * Copyright (c) 1999-2000, Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Bit Stream Class
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_bs.h"
+
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_math.h"
+#include "jasper/jas_debug.h"
+
+/******************************************************************************\
+* Local function prototypes.
+\******************************************************************************/
+
+static jpc_bitstream_t *jpc_bitstream_alloc(void);
+
+/******************************************************************************\
+* Code for opening and closing bit streams.
+\******************************************************************************/
+
+/* Open a bit stream from a stream. */
+jpc_bitstream_t *jpc_bitstream_sopen(jas_stream_t *stream, const char *mode)
+{+ jpc_bitstream_t *bitstream;
+
+ /* Ensure that the open mode is valid. */
+#if 0 /* This causes a string literal too long error (with c99 pedantic mode). Why is this so? */
+ assert(!strcmp(mode, "r") || !strcmp(mode, "w") || !strcmp(mode, "r+")
+ || !strcmp(mode, "w+"));
+#endif
+
+ if (!(bitstream = jpc_bitstream_alloc())) {+ return 0;
+ }
+
+ /* By default, do not close the underlying (character) stream, upon
+ the close of the bit stream. */
+ bitstream->flags_ = JPC_BITSTREAM_NOCLOSE;
+
+ bitstream->stream_ = stream;
+ bitstream->openmode_ = (mode[0] == 'w') ? JPC_BITSTREAM_WRITE :
+ JPC_BITSTREAM_READ;
+
+ /* Mark the data buffer as empty. */
+ bitstream->cnt_ = (bitstream->openmode_ == JPC_BITSTREAM_READ) ? 0 : 8;
+ bitstream->buf_ = 0;
+
+ return bitstream;
+}
+
+/* Close a bit stream. */
+int jpc_bitstream_close(jpc_bitstream_t *bitstream)
+{+ int ret = 0;
+
+ /* Align to the next byte boundary while considering the effects of
+ bit stuffing. */
+ if (jpc_bitstream_align(bitstream)) {+ ret = -1;
+ }
+
+ /* If necessary, close the underlying (character) stream. */
+ if (!(bitstream->flags_ & JPC_BITSTREAM_NOCLOSE) && bitstream->stream_) {+ if (jas_stream_close(bitstream->stream_)) {+ ret = -1;
+ }
+ bitstream->stream_ = 0;
+ }
+
+ jas_free(bitstream);
+ return ret;
+}
+
+/* Allocate a new bit stream. */
+static jpc_bitstream_t *jpc_bitstream_alloc()
+{+ jpc_bitstream_t *bitstream;
+
+ /* Allocate memory for the new bit stream object. */
+ if (!(bitstream = jas_malloc(sizeof(jpc_bitstream_t)))) {+ return 0;
+ }
+ /* Initialize all of the data members. */
+ bitstream->stream_ = 0;
+ bitstream->cnt_ = 0;
+ bitstream->flags_ = 0;
+ bitstream->openmode_ = 0;
+
+ return bitstream;
+}
+
+/******************************************************************************\
+* Code for reading/writing from/to bit streams.
+\******************************************************************************/
+
+/* Get a bit from a bit stream. */
+int jpc_bitstream_getbit_func(jpc_bitstream_t *bitstream)
+{+ int ret;
+ JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func(%p)\n", bitstream));+ ret = jpc_bitstream_getbit_macro(bitstream);
+ JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func -> %d\n", ret));+ return ret;
+}
+
+/* Put a bit to a bit stream. */
+int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int b)
+{+ int ret;
+ JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func(%p, %d)\n", bitstream, b));+ ret = jpc_bitstream_putbit_macro(bitstream, b);
+ JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func() -> %d\n", ret));+ return ret;
+}
+
+/* Get one or more bits from a bit stream. */
+long jpc_bitstream_getbits(jpc_bitstream_t *bitstream, int n)
+{+ long v;
+ int u;
+
+ /* We can reliably get at most 31 bits since ISO/IEC 9899 only
+ guarantees that a long can represent values up to 2^31-1. */
+ //assert(n >= 0 && n < 32);
+ if (n < 0 || n >= 32) {+ return -1;
+ }
+
+ /* Get the number of bits requested from the specified bit stream. */
+ v = 0;
+ while (--n >= 0) {+ if ((u = jpc_bitstream_getbit(bitstream)) < 0) {+ return -1;
+ }
+ v = (v << 1) | u;
+ }
+ return v;
+}
+
+/* Put one or more bits to a bit stream. */
+int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v)
+{+ int m;
+
+ /* We can reliably put at most 31 bits since ISO/IEC 9899 only
+ guarantees that a long can represent values up to 2^31-1. */
+ //assert(n >= 0 && n < 32);
+ if (n < 0 || n >= 32) {+ return EOF;
+ }
+ /* Ensure that only the bits to be output are nonzero. */
+ assert(!(v & (~JAS_ONES(n))));
+
+ /* Put the desired number of bits to the specified bit stream. */
+ m = n - 1;
+ while (--n >= 0) {+ if (jpc_bitstream_putbit(bitstream, (v >> m) & 1) == EOF) {+ return EOF;
+ }
+ v <<= 1;
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Code for buffer filling and flushing.
+\******************************************************************************/
+
+/* Fill the buffer for a bit stream. */
+int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream)
+{+ int c;
+ /* Note: The count has already been decremented by the caller. */
+ assert(bitstream->openmode_ & JPC_BITSTREAM_READ);
+ assert(bitstream->cnt_ <= 0);
+
+ if (bitstream->flags_ & JPC_BITSTREAM_ERR) {+ bitstream->cnt_ = 0;
+ return -1;
+ }
+
+ if (bitstream->flags_ & JPC_BITSTREAM_EOF) {+ bitstream->buf_ = 0x7f;
+ bitstream->cnt_ = 7;
+ return 1;
+ }
+
+ bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
+ if ((c = jas_stream_getc((bitstream)->stream_)) == EOF) {+ bitstream->flags_ |= JPC_BITSTREAM_EOF;
+ return 1;
+ }
+ bitstream->cnt_ = (bitstream->buf_ == 0xff00) ? 6 : 7;
+ bitstream->buf_ |= c & ((1 << (bitstream->cnt_ + 1)) - 1);
+ return (bitstream->buf_ >> bitstream->cnt_) & 1;
+}
+
+
+/******************************************************************************\
+* Code related to flushing.
+\******************************************************************************/
+
+/* Does the bit stream need to be aligned to a byte boundary (considering
+ the effects of bit stuffing)? */
+int jpc_bitstream_needalign(const jpc_bitstream_t *bitstream)
+{+ if (bitstream->openmode_ & JPC_BITSTREAM_READ) {+ /* The bit stream is open for reading. */
+ /* If there are any bits buffered for reading, or the
+ previous byte forced a stuffed bit, alignment is
+ required. */
+ if ((bitstream->cnt_ < 8 && bitstream->cnt_ > 0) ||
+ ((bitstream->buf_ >> 8) & 0xff) == 0xff) {+ return 1;
+ }
+ } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {+ /* The bit stream is open for writing. */
+ /* If there are any bits buffered for writing, or the
+ previous byte forced a stuffed bit, alignment is
+ required. */
+ if ((bitstream->cnt_ < 8 && bitstream->cnt_ >= 0) ||
+ ((bitstream->buf_ >> 8) & 0xff) == 0xff) {+ return 1;
+ }
+ } else {+ /* This should not happen. Famous last words, eh? :-) */
+ assert(0);
+ return -1;
+ }
+ return 0;
+}
+
+/* How many additional bytes would be output if we align the bit stream? */
+int jpc_bitstream_pending(const jpc_bitstream_t *bitstream)
+{+ if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {+ /* The bit stream is being used for writing. */
+#if 1
+ /* XXX - Is this really correct? Check someday... */
+ if (bitstream->cnt_ < 8) {+ return 1;
+ }
+#else
+ if (bitstream->cnt_ < 8) {+ if (((bitstream->buf_ >> 8) & 0xff) == 0xff) {+ return 2;
+ }
+ return 1;
+ }
+#endif
+ return 0;
+ } else {+ /* This operation should not be invoked on a bit stream that
+ is being used for reading. */
+ return -1;
+ }
+}
+
+/* Align the bit stream to a byte boundary. */
+int jpc_bitstream_align(jpc_bitstream_t *bitstream)
+{+ int ret = -1;
+ if (bitstream->openmode_ & JPC_BITSTREAM_READ) {+ ret = jpc_bitstream_inalign(bitstream, 0, 0);
+ } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {+ ret = jpc_bitstream_outalign(bitstream, 0);
+ } else {+ assert(false);
+ JAS_UNREACHABLE();
+ }
+ return ret;
+}
+
+/* Align a bit stream in the input case. */
+int jpc_bitstream_inalign(jpc_bitstream_t *bitstream, int fillmask,
+ int filldata)
+{+ int n;
+ int v;
+ int u;
+ int numfill;
+ int m;
+
+ numfill = 7;
+ m = 0;
+ v = 0;
+ if (bitstream->cnt_ > 0) {+ n = bitstream->cnt_;
+ } else if (!bitstream->cnt_) {+ n = ((bitstream->buf_ & 0xff) == 0xff) ? 7 : 0;
+ } else {+ n = 0;
+ }
+ if (n > 0) {+ if ((u = jpc_bitstream_getbits(bitstream, n)) < 0) {+ return -1;
+ }
+ m += n;
+ v = (v << n) | u;
+ }
+ if ((bitstream->buf_ & 0xff) == 0xff) {+ if ((u = jpc_bitstream_getbits(bitstream, 7)) < 0) {+ return -1;
+ }
+ v = (v << 7) | u;
+ m += 7;
+ }
+ if (m > numfill) {+ v >>= m - numfill;
+ } else {+ filldata >>= numfill - m;
+ fillmask >>= numfill - m;
+ }
+ if (((~(v ^ filldata)) & fillmask) != fillmask) {+ /* The actual fill pattern does not match the expected one. */
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Align a bit stream in the output case. */
+int jpc_bitstream_outalign(jpc_bitstream_t *bitstream, int filldata)
+{+ int n;
+ int v;
+
+ /* Ensure that this bit stream is open for writing. */
+ assert(bitstream->openmode_ & JPC_BITSTREAM_WRITE);
+
+ /* Ensure that the first bit of fill data is zero. */
+ /* Note: The first bit of fill data must be zero. If this were not
+ the case, the fill data itself could cause further bit stuffing to
+ be required (which would cause numerous complications). */
+ assert(!(filldata & (~0x3f)));
+
+ if (!bitstream->cnt_) {+ if ((bitstream->buf_ & 0xff) == 0xff) {+ n = 7;
+ v = filldata;
+ } else {+ n = 0;
+ v = 0;
+ }
+ } else if (bitstream->cnt_ > 0 && bitstream->cnt_ < 8) {+ n = bitstream->cnt_;
+ v = filldata >> (7 - n);
+ } else {+ return 0;
+ }
+
+ /* Write the appropriate fill data to the bit stream. */
+ if (n > 0) {+ if (jpc_bitstream_putbits(bitstream, n, v)) {+ return -1;
+ }
+ }
+ if (bitstream->cnt_ < 8) {+ assert(bitstream->cnt_ >= 0 && bitstream->cnt_ < 8);
+ assert((bitstream->buf_ & 0xff) != 0xff);
+ /* Force the pending byte of output to be written to the
+ underlying (character) stream. */
+ if (jas_stream_putc(bitstream->stream_, bitstream->buf_ & 0xff) == EOF) {+ return -1;
+ }
+ bitstream->cnt_ = 8;
+ bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
+ }
+
+ return 0;
+}
--- /dev/null
+++ b/jpc_bs.h
@@ -1,0 +1,229 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Bit Stream Class
+ *
+ * $Id$
+ */
+
+#ifndef JPC_BS_H
+#define JPC_BS_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_types.h"
+#include "jasper/jas_stream.h"
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/*
+ * Bit stream open mode flags.
+ */
+
+/* Bit stream open for reading. */
+#define JPC_BITSTREAM_READ 0x01
+/* Bit stream open for writing. */
+#define JPC_BITSTREAM_WRITE 0x02
+
+/*
+ * Bit stream flags.
+ */
+
+/* Do not close underlying character stream. */
+#define JPC_BITSTREAM_NOCLOSE 0x01
+/* End of file has been reached while reading. */
+#define JPC_BITSTREAM_EOF 0x02
+/* An I/O error has occured. */
+#define JPC_BITSTREAM_ERR 0x04
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/* Bit stream class. */
+
+typedef struct {+
+ /* Some miscellaneous flags. */
+ int flags_;
+
+ /* The input/output buffer. */
+ uint_fast16_t buf_;
+
+ /* The number of bits remaining in the byte being read/written. */
+ int cnt_;
+
+ /* The underlying stream associated with this bit stream. */
+ jas_stream_t *stream_;
+
+ /* The mode in which this bit stream was opened. */
+ int openmode_;
+
+} jpc_bitstream_t;
+
+/******************************************************************************\
+* Functions/macros for opening and closing bit streams..
+\******************************************************************************/
+
+/* Open a stream as a bit stream. */
+jpc_bitstream_t *jpc_bitstream_sopen(jas_stream_t *stream, const char *mode);
+
+/* Close a bit stream. */
+int jpc_bitstream_close(jpc_bitstream_t *bitstream);
+
+/******************************************************************************\
+* Functions/macros for reading from and writing to bit streams..
+\******************************************************************************/
+
+/* Read a bit from a bit stream. */
+#ifndef NDEBUG
+#define jpc_bitstream_getbit(bitstream) \
+ jpc_bitstream_getbit_func(bitstream)
+#else
+#define jpc_bitstream_getbit(bitstream) \
+ jpc_bitstream_getbit_macro(bitstream)
+#endif
+
+/* Write a bit to a bit stream. */
+#ifndef NDEBUG
+#define jpc_bitstream_putbit(bitstream, v) \
+ jpc_bitstream_putbit_func(bitstream, v)
+#else
+#define jpc_bitstream_putbit(bitstream, v) \
+ jpc_bitstream_putbit_macro(bitstream, v)
+#endif
+
+/* Read one or more bits from a bit stream. */
+long jpc_bitstream_getbits(jpc_bitstream_t *bitstream, int n);
+
+/* Write one or more bits to a bit stream. */
+int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v);
+
+/******************************************************************************\
+* Functions/macros for flushing and aligning bit streams.
+\******************************************************************************/
+
+/* Align the current position within the bit stream to the next byte
+ boundary. */
+int jpc_bitstream_align(jpc_bitstream_t *bitstream);
+
+/* Align the current position in the bit stream with the next byte boundary,
+ ensuring that certain bits consumed in the process match a particular
+ pattern. */
+int jpc_bitstream_inalign(jpc_bitstream_t *bitstream, int fillmask,
+ int filldata);
+
+/* Align the current position in the bit stream with the next byte boundary,
+ writing bits from the specified pattern (if necessary) in the process. */
+int jpc_bitstream_outalign(jpc_bitstream_t *bitstream, int filldata);
+
+/* Check if a bit stream needs alignment. */
+JAS_ATTRIBUTE_PURE
+int jpc_bitstream_needalign(const jpc_bitstream_t *bitstream);
+
+/* How many additional bytes would be output if the bit stream was aligned? */
+JAS_ATTRIBUTE_PURE
+int jpc_bitstream_pending(const jpc_bitstream_t *bitstream);
+
+/******************************************************************************\
+* Functions/macros for querying state information for bit streams.
+\******************************************************************************/
+
+/* Has EOF been encountered on a bit stream? */
+#define jpc_bitstream_eof(bitstream) \
+ ((bitstream)->flags_ & JPC_BITSTREAM_EOF)
+
+/******************************************************************************\
+* Internals.
+\******************************************************************************/
+
+/* DO NOT DIRECTLY INVOKE ANY OF THE MACROS OR FUNCTIONS BELOW. THEY ARE
+ FOR INTERNAL USE ONLY. */
+
+int jpc_bitstream_getbit_func(jpc_bitstream_t *bitstream);
+
+int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int v);
+
+int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream);
+
+#define jpc_bitstream_getbit_macro(bitstream) \
+ ((--(bitstream)->cnt_ >= 0) ? \
+ ((int)(((bitstream)->buf_ >> (bitstream)->cnt_) & 1)) : \
+ jpc_bitstream_fillbuf(bitstream))
+
+#define jpc_bitstream_putbit_macro(bitstream, bit) \
+ ((--(bitstream)->cnt_ < 0) ? \
+ ((bitstream)->buf_ = ((bitstream)->buf_ << 8) & 0xffff, \
+ (bitstream)->cnt_ = ((bitstream)->buf_ == 0xff00) ? 6 : 7, \
+ (bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \
+ (jas_stream_putc((bitstream)->stream_, (bitstream)->buf_ >> 8) == EOF) \
+ ? (EOF) : ((bit) & 1)) : \
+ ((bitstream)->buf_ |= ((bit) & 1) << (bitstream)->cnt_, \
+ (bit) & 1))
+
+#endif
--- /dev/null
+++ b/jpc_cod.h
@@ -1,0 +1,78 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * $Id$
+ */
+
+#ifndef JPC_COD_H
+#define JPC_COD_H
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/* The nominal word size used by this implementation. */
+#define JPC_PREC 32
+
+#endif
--- /dev/null
+++ b/jpc_cs.c
@@ -1,0 +1,1699 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * JPEG-2000 Code Stream Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_cs.h"
+
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_debug.h"
+#include "jasper/jas_image.h"
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/* Marker segment table entry. */
+typedef struct {+ int id;
+ const char *name;
+ jpc_msops_t ops;
+} jpc_mstabent_t;
+
+/******************************************************************************\
+* Local prototypes.
+\******************************************************************************/
+
+static const jpc_mstabent_t *jpc_mstab_lookup(int id);
+
+static int jpc_poc_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_poc_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_poc_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static void jpc_poc_destroyparms(jpc_ms_t *ms);
+
+static int jpc_unk_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_sot_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_siz_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_cod_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_coc_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_qcd_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_qcc_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_rgn_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_sop_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_ppm_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_ppt_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_crg_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+static int jpc_com_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+
+static int jpc_sot_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_siz_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_cod_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_coc_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_qcd_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_qcc_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_rgn_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_unk_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_sop_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_ppm_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_ppt_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_crg_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+static int jpc_com_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+
+static int jpc_sot_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_siz_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_cod_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_coc_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_qcd_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_qcc_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_rgn_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_unk_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_sop_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_ppm_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_ppt_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_crg_dumpparms(jpc_ms_t *ms, FILE *out);
+static int jpc_com_dumpparms(jpc_ms_t *ms, FILE *out);
+
+static void jpc_siz_destroyparms(jpc_ms_t *ms);
+static void jpc_qcd_destroyparms(jpc_ms_t *ms);
+static void jpc_qcc_destroyparms(jpc_ms_t *ms);
+static void jpc_cod_destroyparms(jpc_ms_t *ms);
+static void jpc_coc_destroyparms(jpc_ms_t *ms);
+static void jpc_unk_destroyparms(jpc_ms_t *ms);
+static void jpc_ppm_destroyparms(jpc_ms_t *ms);
+static void jpc_ppt_destroyparms(jpc_ms_t *ms);
+static void jpc_crg_destroyparms(jpc_ms_t *ms);
+static void jpc_com_destroyparms(jpc_ms_t *ms);
+
+static void jpc_qcx_destroycompparms(jpc_qcxcp_t *compparms);
+static int jpc_qcx_getcompparms(jpc_qcxcp_t *compparms, jpc_cstate_t *cstate,
+ jas_stream_t *in, uint_fast16_t len);
+static int jpc_qcx_putcompparms(jpc_qcxcp_t *compparms, jpc_cstate_t *cstate,
+ jas_stream_t *out);
+static void jpc_cox_destroycompparms(jpc_coxcp_t *compparms);
+static int jpc_cox_getcompparms(jpc_ms_t *ms, jpc_cstate_t *cstate,
+ jas_stream_t *in, int prtflag, jpc_coxcp_t *compparms);
+static int jpc_cox_putcompparms(jpc_ms_t *ms, jpc_cstate_t *cstate,
+ jas_stream_t *out, int prtflag, jpc_coxcp_t *compparms);
+
+/******************************************************************************\
+* Global data.
+\******************************************************************************/
+
+static const jpc_mstabent_t jpc_mstab[] = {+ {JPC_MS_SOC, "SOC", {0, 0, 0, 0}},+ {JPC_MS_SOT, "SOT", {0, jpc_sot_getparms, jpc_sot_putparms,+ jpc_sot_dumpparms}},
+ {JPC_MS_SOD, "SOD", {0, 0, 0, 0}},+ {JPC_MS_EOC, "EOC", {0, 0, 0, 0}},+ {JPC_MS_SIZ, "SIZ", {jpc_siz_destroyparms, jpc_siz_getparms,+ jpc_siz_putparms, jpc_siz_dumpparms}},
+ {JPC_MS_COD, "COD", {jpc_cod_destroyparms, jpc_cod_getparms,+ jpc_cod_putparms, jpc_cod_dumpparms}},
+ {JPC_MS_COC, "COC", {jpc_coc_destroyparms, jpc_coc_getparms,+ jpc_coc_putparms, jpc_coc_dumpparms}},
+ {JPC_MS_RGN, "RGN", {0, jpc_rgn_getparms, jpc_rgn_putparms,+ jpc_rgn_dumpparms}},
+ {JPC_MS_QCD, "QCD", {jpc_qcd_destroyparms, jpc_qcd_getparms,+ jpc_qcd_putparms, jpc_qcd_dumpparms}},
+ {JPC_MS_QCC, "QCC", {jpc_qcc_destroyparms, jpc_qcc_getparms,+ jpc_qcc_putparms, jpc_qcc_dumpparms}},
+ {JPC_MS_POC, "POC", {jpc_poc_destroyparms, jpc_poc_getparms,+ jpc_poc_putparms, jpc_poc_dumpparms}},
+ {JPC_MS_TLM, "TLM", {jpc_unk_destroyparms, jpc_unk_getparms, jpc_unk_putparms, 0}},+ {JPC_MS_PLM, "PLM", {jpc_unk_destroyparms, jpc_unk_getparms, jpc_unk_putparms, 0}},+ {JPC_MS_PPM, "PPM", {jpc_ppm_destroyparms, jpc_ppm_getparms,+ jpc_ppm_putparms, jpc_ppm_dumpparms}},
+ {JPC_MS_PPT, "PPT", {jpc_ppt_destroyparms, jpc_ppt_getparms,+ jpc_ppt_putparms, jpc_ppt_dumpparms}},
+ {JPC_MS_SOP, "SOP", {0, jpc_sop_getparms, jpc_sop_putparms,+ jpc_sop_dumpparms}},
+ {JPC_MS_EPH, "EPH", {0, 0, 0, 0}},+ {JPC_MS_CRG, "CRG", {jpc_crg_destroyparms, jpc_crg_getparms,+ jpc_crg_putparms, jpc_crg_dumpparms}},
+ {JPC_MS_COM, "COM", {jpc_com_destroyparms, jpc_com_getparms,+ jpc_com_putparms, jpc_com_dumpparms}},
+ {-1, "UNKNOWN", {jpc_unk_destroyparms, jpc_unk_getparms,+ jpc_unk_putparms, jpc_unk_dumpparms}}
+};
+
+/******************************************************************************\
+* Code stream manipulation functions.
+\******************************************************************************/
+
+/* Create a code stream state object. */
+jpc_cstate_t *jpc_cstate_create()
+{+ jpc_cstate_t *cstate;
+ if (!(cstate = jas_malloc(sizeof(jpc_cstate_t)))) {+ return 0;
+ }
+ cstate->numcomps = 0;
+ return cstate;
+}
+
+/* Destroy a code stream state object. */
+void jpc_cstate_destroy(jpc_cstate_t *cstate)
+{+ jas_free(cstate);
+}
+
+/* Read a marker segment from a stream. */
+jpc_ms_t *jpc_getms(jas_stream_t *in, jpc_cstate_t *cstate)
+{+ jpc_ms_t *ms;
+ const 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) {+ 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(jas_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;
+}
+
+/* Write a marker segment to a stream. */
+int jpc_putms(jas_stream_t *out, jpc_cstate_t *cstate, jpc_ms_t *ms)
+{+ jas_stream_t *tmpstream;
+ int len;
+
+ /* Output the marker segment type. */
+ if (jpc_putuint16(out, ms->id)) {+ return -1;
+ }
+
+ /* Output the marker segment length and parameters if necessary. */
+ if (ms->ops->putparms) {+ /* Create a temporary stream in which to buffer the
+ parameter data. */
+ if (!(tmpstream = jas_stream_memopen(0, 0))) {+ return -1;
+ }
+ if ((*ms->ops->putparms)(ms, cstate, tmpstream)) {+ jas_stream_close(tmpstream);
+ return -1;
+ }
+ /* Get the number of bytes of parameter data written. */
+ if ((len = jas_stream_tell(tmpstream)) < 0) {+ jas_stream_close(tmpstream);
+ return -1;
+ }
+ ms->len = len;
+ /* Write the marker segment length and parameter data to
+ the output stream. */
+ if (jas_stream_seek(tmpstream, 0, SEEK_SET) < 0 ||
+ jpc_putuint16(out, ms->len + 2) ||
+ jas_stream_copy(out, tmpstream, ms->len) < 0) {+ jas_stream_close(tmpstream);
+ return -1;
+ }
+ /* Close the temporary stream. */
+ jas_stream_close(tmpstream);
+ }
+
+ /* 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;
+ }
+
+ if (jas_getdbglevel() > 0) {+ jpc_ms_dump(ms, stderr);
+ }
+
+ return 0;
+}
+
+/******************************************************************************\
+* Marker segment operations.
+\******************************************************************************/
+
+/* Create a marker segment of the specified type. */
+jpc_ms_t *jpc_ms_create(int type)
+{+ jpc_ms_t *ms;
+ const jpc_mstabent_t *mstabent;
+
+ if (!(ms = jas_malloc(sizeof(jpc_ms_t)))) {+ return 0;
+ }
+ ms->id = type;
+ ms->len = 0;
+ mstabent = jpc_mstab_lookup(ms->id);
+ ms->ops = &mstabent->ops;
+ memset(&ms->parms, 0, sizeof(jpc_msparms_t));
+ return ms;
+}
+
+/* Destroy a marker segment. */
+void jpc_ms_destroy(jpc_ms_t *ms)
+{+ if (ms->ops && ms->ops->destroyparms) {+ (*ms->ops->destroyparms)(ms);
+ }
+ jas_free(ms);
+}
+
+/* Dump a marker segment to a stream for debugging. */
+void jpc_ms_dump(jpc_ms_t *ms, FILE *out)
+{+ const jpc_mstabent_t *mstabent;
+ mstabent = jpc_mstab_lookup(ms->id);
+ fprintf(out, "type = 0x%04"PRIxFAST16" (%s);", ms->id, mstabent->name);
+ if (JPC_MS_HASPARMS(ms->id)) {+ fprintf(out, " len = %"PRIuFAST16";", ms->len + 2);
+ if (ms->ops->dumpparms) {+ (*ms->ops->dumpparms)(ms, out);
+ } else {+ fprintf(out, "\n");
+ }
+ } else {+ fprintf(out, "\n");
+ }
+}
+
+/******************************************************************************\
+* SOT marker segment operations.
+\******************************************************************************/
+
+static int jpc_sot_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_sot_t *sot = &ms->parms.sot;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (jpc_getuint16(in, &sot->tileno) ||
+ jpc_getuint32(in, &sot->len) ||
+ jpc_getuint8(in, &sot->partno) ||
+ jpc_getuint8(in, &sot->numparts)) {+ return -1;
+ }
+ if (sot->tileno > 65534 || sot->len < 12 || sot->partno > 254) {+ return -1;
+ }
+ if (jas_stream_eof(in)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_sot_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_sot_t *sot = &ms->parms.sot;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (jpc_putuint16(out, sot->tileno) ||
+ jpc_putuint32(out, sot->len) ||
+ jpc_putuint8(out, sot->partno) ||
+ jpc_putuint8(out, sot->numparts)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_sot_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_sot_t *sot = &ms->parms.sot;
+ fprintf(out,
+ "tileno = %"PRIuFAST16"; len = %"PRIuFAST32"; partno = %d; numparts = %d\n",
+ sot->tileno, sot->len, sot->partno, sot->numparts);
+ return 0;
+}
+
+/******************************************************************************\
+* SIZ marker segment operations.
+\******************************************************************************/
+
+static void jpc_siz_destroyparms(jpc_ms_t *ms)
+{+ jpc_siz_t *siz = &ms->parms.siz;
+ if (siz->comps) {+ jas_free(siz->comps);
+ }
+}
+
+static int jpc_siz_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate,
+ jas_stream_t *in)
+{+ jpc_siz_t *siz = &ms->parms.siz;
+ unsigned int i;
+ uint_fast8_t tmp;
+
+ siz->comps = 0;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (jpc_getuint16(in, &siz->caps) ||
+ jpc_getuint32(in, &siz->width) ||
+ jpc_getuint32(in, &siz->height) ||
+ jpc_getuint32(in, &siz->xoff) ||
+ jpc_getuint32(in, &siz->yoff) ||
+ jpc_getuint32(in, &siz->tilewidth) ||
+ jpc_getuint32(in, &siz->tileheight) ||
+ jpc_getuint32(in, &siz->tilexoff) ||
+ jpc_getuint32(in, &siz->tileyoff) ||
+ jpc_getuint16(in, &siz->numcomps)) {+ goto error;
+ }
+ if (!siz->width || !siz->height) {+ jas_eprintf("reference grid cannot have zero area\n");+ goto error;
+ }
+ if (!siz->tilewidth || !siz->tileheight) {+ jas_eprintf("tile cannot have zero area\n");+ goto error;
+ }
+ if (!siz->numcomps || siz->numcomps > 16384) {+ jas_eprintf("number of components not in permissible range\n");+ goto error;
+ }
+ if (siz->xoff >= siz->width) {+ jas_eprintf("XOsiz not in permissible range\n");+ goto error;
+ }
+ if (siz->yoff >= siz->height) {+ jas_eprintf("YOsiz not in permissible range\n");+ goto error;
+ }
+ if (siz->tilexoff > siz->xoff || siz->tilexoff + siz->tilewidth <= siz->xoff) {+ jas_eprintf("XTOsiz not in permissible range\n");+ goto error;
+ }
+ if (siz->tileyoff > siz->yoff || siz->tileyoff + siz->tileheight <= siz->yoff) {+ jas_eprintf("YTOsiz not in permissible range\n");+ goto error;
+ }
+
+ if (!(siz->comps = jas_alloc2(siz->numcomps, sizeof(jpc_sizcomp_t)))) {+ goto error;
+ }
+ for (i = 0; i < siz->numcomps; ++i) {+ if (jpc_getuint8(in, &tmp) ||
+ jpc_getuint8(in, &siz->comps[i].hsamp) ||
+ jpc_getuint8(in, &siz->comps[i].vsamp)) {+ goto error;
+ }
+ if (siz->comps[i].hsamp == 0) {+ jas_eprintf("invalid XRsiz value %d\n", siz->comps[i].hsamp);+ goto error;
+ }
+ if (siz->comps[i].vsamp == 0) {+ jas_eprintf("invalid YRsiz value %d\n", siz->comps[i].vsamp);+ goto error;
+ }
+ siz->comps[i].sgnd = (tmp >> 7) & 1;
+ siz->comps[i].prec = (tmp & 0x7f) + 1;
+ /* we need at least 1 bit of precision for unsigned
+ samples and 2 bits for signed samples */
+ if (siz->comps[i].prec < 1U + siz->comps[i].sgnd ||
+ siz->comps[i].prec > 38) {+ jas_eprintf("invalid component bit depth %d\n", siz->comps[i].prec);+ goto error;
+ }
+ }
+ if (jas_stream_eof(in)) {+ goto error;
+ }
+ return 0;
+
+error:
+ if (siz->comps) {+ jas_free(siz->comps);
+ }
+ return -1;
+}
+
+static int jpc_siz_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_siz_t *siz = &ms->parms.siz;
+ unsigned int i;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ assert(siz->width && siz->height && siz->tilewidth &&
+ siz->tileheight && siz->numcomps);
+ if (jpc_putuint16(out, siz->caps) ||
+ jpc_putuint32(out, siz->width) ||
+ jpc_putuint32(out, siz->height) ||
+ jpc_putuint32(out, siz->xoff) ||
+ jpc_putuint32(out, siz->yoff) ||
+ jpc_putuint32(out, siz->tilewidth) ||
+ jpc_putuint32(out, siz->tileheight) ||
+ jpc_putuint32(out, siz->tilexoff) ||
+ jpc_putuint32(out, siz->tileyoff) ||
+ jpc_putuint16(out, siz->numcomps)) {+ return -1;
+ }
+ for (i = 0; i < siz->numcomps; ++i) {+ if (jpc_putuint8(out, ((siz->comps[i].sgnd & 1) << 7) |
+ ((siz->comps[i].prec - 1) & 0x7f)) ||
+ jpc_putuint8(out, siz->comps[i].hsamp) ||
+ jpc_putuint8(out, siz->comps[i].vsamp)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jpc_siz_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_siz_t *siz = &ms->parms.siz;
+ unsigned int i;
+ fprintf(out, "caps = 0x%02"PRIxFAST16";\n", siz->caps);
+ fprintf(out, "width = %"PRIuFAST32"; height = %"PRIuFAST32"; xoff = %"PRIuFAST32"; yoff = %" PRIuFAST32 ";\n",
+ siz->width, siz->height, siz->xoff, siz->yoff);
+ fprintf(out, "tilewidth = %"PRIuFAST32"; tileheight = %"PRIuFAST32"; "
+ "tilexoff = %"PRIuFAST32"; tileyoff = %" PRIuFAST32 ";\n",
+ siz->tilewidth, siz->tileheight, siz->tilexoff, siz->tileyoff);
+ fprintf(out, "numcomps = %"PRIuFAST16";\n", siz->numcomps);
+ for (i = 0; i < siz->numcomps; ++i) {+ fprintf(out, "prec[%d] = %d; sgnd[%d] = %d; hsamp[%d] = %d; "
+ "vsamp[%d] = %d\n", i, siz->comps[i].prec, i,
+ siz->comps[i].sgnd, i, siz->comps[i].hsamp, i,
+ siz->comps[i].vsamp);
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* COD marker segment operations.
+\******************************************************************************/
+
+static void jpc_cod_destroyparms(jpc_ms_t *ms)
+{+ jpc_cod_t *cod = &ms->parms.cod;
+ jpc_cox_destroycompparms(&cod->compparms);
+}
+
+static int jpc_cod_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_cod_t *cod = &ms->parms.cod;
+ if (jpc_getuint8(in, &cod->csty)) {+ return -1;
+ }
+ if (jpc_getuint8(in, &cod->prg) ||
+ jpc_getuint16(in, &cod->numlyrs) ||
+ jpc_getuint8(in, &cod->mctrans)) {+ return -1;
+ }
+ if (cod->numlyrs < 1) {+ return -1;
+ }
+ if (jpc_cox_getcompparms(ms, cstate, in,
+ (cod->csty & JPC_COX_PRT) != 0, &cod->compparms)) {+ return -1;
+ }
+ if (jas_stream_eof(in)) {+ jpc_cod_destroyparms(ms);
+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_cod_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_cod_t *cod = &ms->parms.cod;
+ assert(cod->numlyrs > 0 && cod->compparms.numdlvls <= 32);
+ assert(cod->compparms.numdlvls == cod->compparms.numrlvls - 1);
+ if (jpc_putuint8(out, cod->compparms.csty) ||
+ jpc_putuint8(out, cod->prg) ||
+ jpc_putuint16(out, cod->numlyrs) ||
+ jpc_putuint8(out, cod->mctrans)) {+ return -1;
+ }
+ if (jpc_cox_putcompparms(ms, cstate, out,
+ (cod->csty & JPC_COX_PRT) != 0, &cod->compparms)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_cod_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_cod_t *cod = &ms->parms.cod;
+ int i;
+ fprintf(out, "csty = 0x%02x;\n", cod->compparms.csty);
+ fprintf(out, "numdlvls = %d; qmfbid = %d; mctrans = %d\n",
+ cod->compparms.numdlvls, cod->compparms.qmfbid, cod->mctrans);
+ fprintf(out, "prg = %d; numlyrs = %"PRIuFAST16";\n",
+ cod->prg, cod->numlyrs);
+ fprintf(out, "cblkwidthval = %d; cblkheightval = %d; "
+ "cblksty = 0x%02x;\n", cod->compparms.cblkwidthval, cod->compparms.cblkheightval,
+ cod->compparms.cblksty);
+ if (cod->csty & JPC_COX_PRT) {+ for (i = 0; i < cod->compparms.numrlvls; ++i) {+ jas_eprintf("prcwidth[%d] = %d, prcheight[%d] = %d\n",+ i, cod->compparms.rlvls[i].parwidthval,
+ i, cod->compparms.rlvls[i].parheightval);
+ }
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* COC marker segment operations.
+\******************************************************************************/
+
+static void jpc_coc_destroyparms(jpc_ms_t *ms)
+{+ jpc_coc_t *coc = &ms->parms.coc;
+ jpc_cox_destroycompparms(&coc->compparms);
+}
+
+static int jpc_coc_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_coc_t *coc = &ms->parms.coc;
+ uint_fast8_t tmp;
+ if (cstate->numcomps <= 256) {+ if (jpc_getuint8(in, &tmp)) {+ return -1;
+ }
+ coc->compno = tmp;
+ } else {+ if (jpc_getuint16(in, &coc->compno)) {+ return -1;
+ }
+ }
+ if (jpc_getuint8(in, &coc->compparms.csty)) {+ return -1;
+ }
+ if (jpc_cox_getcompparms(ms, cstate, in,
+ (coc->compparms.csty & JPC_COX_PRT) != 0, &coc->compparms)) {+ return -1;
+ }
+ if (jas_stream_eof(in)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_coc_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_coc_t *coc = &ms->parms.coc;
+ assert(coc->compparms.numdlvls <= 32);
+ if (cstate->numcomps <= 256) {+ if (jpc_putuint8(out, coc->compno)) {+ return -1;
+ }
+ } else {+ if (jpc_putuint16(out, coc->compno)) {+ return -1;
+ }
+ }
+ if (jpc_putuint8(out, coc->compparms.csty)) {+ return -1;
+ }
+ if (jpc_cox_putcompparms(ms, cstate, out,
+ (coc->compparms.csty & JPC_COX_PRT) != 0, &coc->compparms)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_coc_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_coc_t *coc = &ms->parms.coc;
+ fprintf(out, "compno = %"PRIuFAST16"; csty = 0x%02x; numdlvls = %d;\n",
+ coc->compno, coc->compparms.csty, coc->compparms.numdlvls);
+ fprintf(out, "cblkwidthval = %d; cblkheightval = %d; "
+ "cblksty = 0x%02x; qmfbid = %d;\n", coc->compparms.cblkwidthval,
+ coc->compparms.cblkheightval, coc->compparms.cblksty, coc->compparms.qmfbid);
+ return 0;
+}
+/******************************************************************************\
+* COD/COC marker segment operation helper functions.
+\******************************************************************************/
+
+static void jpc_cox_destroycompparms(jpc_coxcp_t *compparms)
+{+ /* Eliminate compiler warning about unused variables. */
+ USED(compparms);
+}
+
+static int jpc_cox_getcompparms(jpc_ms_t *ms, jpc_cstate_t *cstate,
+ jas_stream_t *in, int prtflag, jpc_coxcp_t *compparms)
+{+ uint_fast8_t tmp;
+ int i;
+
+ /* Eliminate compiler warning about unused variables. */
+ USED(ms);
+ USED(cstate);
+
+ if (jpc_getuint8(in, &compparms->numdlvls) ||
+ jpc_getuint8(in, &compparms->cblkwidthval) ||
+ jpc_getuint8(in, &compparms->cblkheightval) ||
+ jpc_getuint8(in, &compparms->cblksty) ||
+ jpc_getuint8(in, &compparms->qmfbid)) {+ return -1;
+ }
+ if (compparms->numdlvls > 32) {+ goto error;
+ }
+ if (compparms->qmfbid != JPC_COX_INS &&
+ compparms->qmfbid != JPC_COX_RFT)
+ goto error;
+ compparms->numrlvls = compparms->numdlvls + 1;
+ if (compparms->numrlvls > JPC_MAXRLVLS) {+ goto error;
+ }
+ if (prtflag) {+ for (i = 0; i < compparms->numrlvls; ++i) {+ if (jpc_getuint8(in, &tmp)) {+ goto error;
+ }
+ compparms->rlvls[i].parwidthval = tmp & 0xf;
+ compparms->rlvls[i].parheightval = (tmp >> 4) & 0xf;
+ }
+ /* Sigh.
+ This bit should be in the same field in both COC and COD mrk segs. */
+ compparms->csty |= JPC_COX_PRT;
+ }
+ if (jas_stream_eof(in)) {+ goto error;
+ }
+ return 0;
+error:
+ jpc_cox_destroycompparms(compparms);
+ return -1;
+}
+
+static int jpc_cox_putcompparms(jpc_ms_t *ms, jpc_cstate_t *cstate,
+ jas_stream_t *out, int prtflag, jpc_coxcp_t *compparms)
+{+ int i;
+ assert(compparms->numdlvls <= 32);
+
+ /* Eliminate compiler warning about unused variables. */
+ USED(ms);
+ USED(cstate);
+
+ if (jpc_putuint8(out, compparms->numdlvls) ||
+ jpc_putuint8(out, compparms->cblkwidthval) ||
+ jpc_putuint8(out, compparms->cblkheightval) ||
+ jpc_putuint8(out, compparms->cblksty) ||
+ jpc_putuint8(out, compparms->qmfbid)) {+ return -1;
+ }
+ if (prtflag) {+ for (i = 0; i < compparms->numrlvls; ++i) {+ if (jpc_putuint8(out,
+ ((compparms->rlvls[i].parheightval & 0xf) << 4) |
+ (compparms->rlvls[i].parwidthval & 0xf))) {+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* RGN marker segment operations.
+\******************************************************************************/
+
+static int jpc_rgn_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_rgn_t *rgn = &ms->parms.rgn;
+ uint_fast8_t tmp;
+ if (cstate->numcomps <= 256) {+ if (jpc_getuint8(in, &tmp)) {+ return -1;
+ }
+ rgn->compno = tmp;
+ } else {+ if (jpc_getuint16(in, &rgn->compno)) {+ return -1;
+ }
+ }
+ if (jpc_getuint8(in, &rgn->roisty) ||
+ jpc_getuint8(in, &rgn->roishift)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_rgn_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_rgn_t *rgn = &ms->parms.rgn;
+ if (cstate->numcomps <= 256) {+ if (jpc_putuint8(out, rgn->compno)) {+ return -1;
+ }
+ } else {+ if (jpc_putuint16(out, rgn->compno)) {+ return -1;
+ }
+ }
+ if (jpc_putuint8(out, rgn->roisty) ||
+ jpc_putuint8(out, rgn->roishift)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_rgn_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_rgn_t *rgn = &ms->parms.rgn;
+ fprintf(out, "compno = %"PRIuFAST16"; roisty = %d; roishift = %d\n",
+ rgn->compno, rgn->roisty, rgn->roishift);
+ return 0;
+}
+
+/******************************************************************************\
+* QCD marker segment operations.
+\******************************************************************************/
+
+static void jpc_qcd_destroyparms(jpc_ms_t *ms)
+{+ jpc_qcd_t *qcd = &ms->parms.qcd;
+ jpc_qcx_destroycompparms(&qcd->compparms);
+}
+
+static int jpc_qcd_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_qcxcp_t *compparms = &ms->parms.qcd.compparms;
+ return jpc_qcx_getcompparms(compparms, cstate, in, ms->len);
+}
+
+static int jpc_qcd_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_qcxcp_t *compparms = &ms->parms.qcd.compparms;
+ return jpc_qcx_putcompparms(compparms, cstate, out);
+}
+
+static int jpc_qcd_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_qcd_t *qcd = &ms->parms.qcd;
+ int i;
+ fprintf(out, "qntsty = %d; numguard = %d; numstepsizes = %d\n",
+ (int) qcd->compparms.qntsty, qcd->compparms.numguard, qcd->compparms.numstepsizes);
+ for (i = 0; i < qcd->compparms.numstepsizes; ++i) {+ fprintf(out, "expn[%d] = 0x%04x; mant[%d] = 0x%04x;\n",
+ i, JAS_CAST(unsigned, JPC_QCX_GETEXPN(qcd->compparms.stepsizes[i])),
+ i, JAS_CAST(unsigned, JPC_QCX_GETMANT(qcd->compparms.stepsizes[i])));
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* QCC marker segment operations.
+\******************************************************************************/
+
+static void jpc_qcc_destroyparms(jpc_ms_t *ms)
+{+ jpc_qcc_t *qcc = &ms->parms.qcc;
+ jpc_qcx_destroycompparms(&qcc->compparms);
+}
+
+static int jpc_qcc_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_qcc_t *qcc = &ms->parms.qcc;
+ uint_fast8_t tmp;
+ int len;
+ len = ms->len;
+ if (cstate->numcomps <= 256) {+ if (jpc_getuint8(in, &tmp)) {+ return -1;
+ }
+ qcc->compno = tmp;
+ --len;
+ } else {+ if (jpc_getuint16(in, &qcc->compno)) {+ return -1;
+ }
+ len -= 2;
+ }
+ if (jpc_qcx_getcompparms(&qcc->compparms, cstate, in, len)) {+ return -1;
+ }
+ if (jas_stream_eof(in)) {+ jpc_qcc_destroyparms(ms);
+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_qcc_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_qcc_t *qcc = &ms->parms.qcc;
+ if (cstate->numcomps <= 256) {+ if (jpc_putuint8(out, qcc->compno)) {+ return -1;
+ }
+ } else {+ if (jpc_putuint16(out, qcc->compno)) {+ return -1;
+ }
+ }
+ if (jpc_qcx_putcompparms(&qcc->compparms, cstate, out)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_qcc_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_qcc_t *qcc = &ms->parms.qcc;
+ int i;
+ fprintf(out, "compno = %"PRIuFAST16"; qntsty = %d; numguard = %d; "
+ "numstepsizes = %d\n", qcc->compno, qcc->compparms.qntsty, qcc->compparms.numguard,
+ qcc->compparms.numstepsizes);
+ for (i = 0; i < qcc->compparms.numstepsizes; ++i) {+ fprintf(out, "expn[%d] = 0x%04x; mant[%d] = 0x%04x;\n",
+ i, (unsigned) JPC_QCX_GETEXPN(qcc->compparms.stepsizes[i]),
+ i, (unsigned) JPC_QCX_GETMANT(qcc->compparms.stepsizes[i]));
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* QCD/QCC marker segment helper functions.
+\******************************************************************************/
+
+static void jpc_qcx_destroycompparms(jpc_qcxcp_t *compparms)
+{+ if (compparms->stepsizes) {+ jas_free(compparms->stepsizes);
+ }
+}
+
+static int jpc_qcx_getcompparms(jpc_qcxcp_t *compparms, jpc_cstate_t *cstate,
+ jas_stream_t *in, uint_fast16_t len)
+{+ uint_fast8_t tmp;
+ int n;
+ int i;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ n = 0;
+ if (jpc_getuint8(in, &tmp)) {+ return -1;
+ }
+ ++n;
+ compparms->qntsty = tmp & 0x1f;
+ compparms->numguard = (tmp >> 5) & 7;
+ switch (compparms->qntsty) {+ case JPC_QCX_SIQNT:
+ compparms->numstepsizes = 1;
+ break;
+ case JPC_QCX_NOQNT:
+ compparms->numstepsizes = (len - n);
+ break;
+ case JPC_QCX_SEQNT:
+ /* XXX - this is a hack */
+ compparms->numstepsizes = (len - n) / 2;
+ break;
+ }
+ /* Ensure that the step size array is sufficiently large. */
+ if (compparms->numstepsizes > 3 * JPC_MAXRLVLS + 1) {+ jpc_qcx_destroycompparms(compparms);
+ return -1;
+ }
+ if (compparms->numstepsizes > 0) {+ if (!(compparms->stepsizes = jas_alloc2(compparms->numstepsizes,
+ sizeof(uint_fast16_t)))) {+ jpc_qcx_destroycompparms(compparms);
+ return -1;
+ }
+ for (i = 0; i < compparms->numstepsizes; ++i) {+ if (compparms->qntsty == JPC_QCX_NOQNT) {+ if (jpc_getuint8(in, &tmp)) {+ jpc_qcx_destroycompparms(compparms);
+ return -1;
+ }
+ compparms->stepsizes[i] = JPC_QCX_EXPN(tmp >> 3);
+ } else {+ if (jpc_getuint16(in, &compparms->stepsizes[i])) {+ jpc_qcx_destroycompparms(compparms);
+ return -1;
+ }
+ }
+ }
+ } else {+ compparms->stepsizes = 0;
+ }
+ if (jas_stream_error(in) || jas_stream_eof(in)) {+ jpc_qcx_destroycompparms(compparms);
+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_qcx_putcompparms(jpc_qcxcp_t *compparms, jpc_cstate_t *cstate,
+ jas_stream_t *out)
+{+ int i;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (jpc_putuint8(out, ((compparms->numguard & 7) << 5) | compparms->qntsty)) {+ return -1;
+ }
+ for (i = 0; i < compparms->numstepsizes; ++i) {+ if (compparms->qntsty == JPC_QCX_NOQNT) {+ if (jpc_putuint8(out, JPC_QCX_GETEXPN(
+ compparms->stepsizes[i]) << 3)) {+ return -1;
+ }
+ } else {+ if (jpc_putuint16(out, compparms->stepsizes[i])) {+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* SOP marker segment operations.
+\******************************************************************************/
+
+static int jpc_sop_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_sop_t *sop = &ms->parms.sop;
+
+ /* Eliminate compiler warning about unused variable. */
+ (void)cstate;
+
+ if (jpc_getuint16(in, &sop->seqno)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_sop_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_sop_t *sop = &ms->parms.sop;
+
+ /* Eliminate compiler warning about unused variable. */
+ (void)cstate;
+
+ if (jpc_putuint16(out, sop->seqno)) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_sop_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_sop_t *sop = &ms->parms.sop;
+ fprintf(out, "seqno = %"PRIuFAST16";\n", sop->seqno);
+ return 0;
+}
+
+/******************************************************************************\
+* PPM marker segment operations.
+\******************************************************************************/
+
+static void jpc_ppm_destroyparms(jpc_ms_t *ms)
+{+ jpc_ppm_t *ppm = &ms->parms.ppm;
+ if (ppm->data) {+ jas_free(ppm->data);
+ }
+}
+
+static int jpc_ppm_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_ppm_t *ppm = &ms->parms.ppm;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ ppm->data = 0;
+
+ if (ms->len < 1) {+ goto error;
+ }
+ if (jpc_getuint8(in, &ppm->ind)) {+ goto error;
+ }
+
+ ppm->len = ms->len - 1;
+ if (ppm->len > 0) {+ if (!(ppm->data = jas_malloc(ppm->len))) {+ goto error;
+ }
+ if (JAS_CAST(jas_uint, jas_stream_read(in, ppm->data, ppm->len)) != ppm->len) {+ goto error;
+ }
+ } else {+ ppm->data = 0;
+ }
+ return 0;
+
+error:
+ jpc_ppm_destroyparms(ms);
+ return -1;
+}
+
+static int jpc_ppm_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_ppm_t *ppm = &ms->parms.ppm;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (JAS_CAST(jas_uint, jas_stream_write(out, (char *) ppm->data, ppm->len)) != ppm->len) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_ppm_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_ppm_t *ppm = &ms->parms.ppm;
+ fprintf(out, "ind=%d; len = %"PRIuFAST16";\n", ppm->ind, ppm->len);
+ if (ppm->len > 0) {+ fprintf(out, "data =\n");
+ jas_memdump(out, ppm->data, ppm->len);
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* PPT marker segment operations.
+\******************************************************************************/
+
+static void jpc_ppt_destroyparms(jpc_ms_t *ms)
+{+ jpc_ppt_t *ppt = &ms->parms.ppt;
+ if (ppt->data) {+ jas_free(ppt->data);
+ }
+}
+
+static int jpc_ppt_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_ppt_t *ppt = &ms->parms.ppt;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ ppt->data = 0;
+
+ if (ms->len < 1) {+ goto error;
+ }
+ if (jpc_getuint8(in, &ppt->ind)) {+ goto error;
+ }
+ ppt->len = ms->len - 1;
+ if (ppt->len > 0) {+ if (!(ppt->data = jas_malloc(ppt->len))) {+ goto error;
+ }
+ if (jas_stream_read(in, (char *) ppt->data, ppt->len) != ppt->len) {+ goto error;
+ }
+ } else {+ ppt->data = 0;
+ }
+ return 0;
+
+error:
+ jpc_ppt_destroyparms(ms);
+ return -1;
+}
+
+static int jpc_ppt_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_ppt_t *ppt = &ms->parms.ppt;
+
+ /* Eliminate compiler warning about unused variable. */
+ (void)cstate;
+
+ if (jpc_putuint8(out, ppt->ind)) {+ return -1;
+ }
+ if (jas_stream_write(out, (char *) ppt->data, ppt->len) != ppt->len) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_ppt_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_ppt_t *ppt = &ms->parms.ppt;
+ fprintf(out, "ind=%d; len = %"PRIuFAST32";\n", ppt->ind, ppt->len);
+ if (ppt->len > 0) {+ fprintf(out, "data =\n");
+ jas_memdump(out, ppt->data, ppt->len);
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* POC marker segment operations.
+\******************************************************************************/
+
+static void jpc_poc_destroyparms(jpc_ms_t *ms)
+{+ jpc_poc_t *poc = &ms->parms.poc;
+ if (poc->pchgs) {+ jas_free(poc->pchgs);
+ }
+}
+
+static int jpc_poc_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_poc_t *poc = &ms->parms.poc;
+ jpc_pocpchg_t *pchg;
+ int pchgno;
+ uint_fast8_t tmp;
+ poc->numpchgs = (cstate->numcomps > 256) ? (ms->len / 9) :
+ (ms->len / 7);
+ if (!(poc->pchgs = jas_alloc2(poc->numpchgs, sizeof(jpc_pocpchg_t)))) {+ goto error;
+ }
+ for (pchgno = 0, pchg = poc->pchgs; pchgno < poc->numpchgs; ++pchgno,
+ ++pchg) {+ if (jpc_getuint8(in, &pchg->rlvlnostart)) {+ goto error;
+ }
+ if (cstate->numcomps > 256) {+ if (jpc_getuint16(in, &pchg->compnostart)) {+ goto error;
+ }
+ } else {+ if (jpc_getuint8(in, &tmp)) {+ goto error;
+ };
+ pchg->compnostart = tmp;
+ }
+ if (jpc_getuint16(in, &pchg->lyrnoend) ||
+ jpc_getuint8(in, &pchg->rlvlnoend)) {+ goto error;
+ }
+ if (cstate->numcomps > 256) {+ if (jpc_getuint16(in, &pchg->compnoend)) {+ goto error;
+ }
+ } else {+ if (jpc_getuint8(in, &tmp)) {+ goto error;
+ }
+ pchg->compnoend = tmp;
+ }
+ if (jpc_getuint8(in, &pchg->prgord)) {+ goto error;
+ }
+ if (pchg->rlvlnostart > pchg->rlvlnoend ||
+ pchg->compnostart > pchg->compnoend) {+ goto error;
+ }
+ }
+ return 0;
+
+error:
+ jpc_poc_destroyparms(ms);
+ return -1;
+}
+
+static int jpc_poc_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_poc_t *poc = &ms->parms.poc;
+ jpc_pocpchg_t *pchg;
+ int pchgno;
+ for (pchgno = 0, pchg = poc->pchgs; pchgno < poc->numpchgs; ++pchgno,
+ ++pchg) {+ if (jpc_putuint8(out, pchg->rlvlnostart) ||
+ ((cstate->numcomps > 256) ?
+ jpc_putuint16(out, pchg->compnostart) :
+ jpc_putuint8(out, pchg->compnostart)) ||
+ jpc_putuint16(out, pchg->lyrnoend) ||
+ jpc_putuint8(out, pchg->rlvlnoend) ||
+ ((cstate->numcomps > 256) ?
+ jpc_putuint16(out, pchg->compnoend) :
+ jpc_putuint8(out, pchg->compnoend)) ||
+ jpc_putuint8(out, pchg->prgord)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jpc_poc_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_poc_t *poc = &ms->parms.poc;
+ jpc_pocpchg_t *pchg;
+ int pchgno;
+ for (pchgno = 0, pchg = poc->pchgs; pchgno < poc->numpchgs;
+ ++pchgno, ++pchg) {+ fprintf(out, "po[%d] = %d; ", pchgno, pchg->prgord);
+ fprintf(out, "cs[%d] = %"PRIuFAST16"; ce[%d] = %"PRIuFAST16"; ",
+ pchgno, pchg->compnostart, pchgno, pchg->compnoend);
+ fprintf(out, "rs[%d] = %d; re[%d] = %d; ",
+ pchgno, pchg->rlvlnostart, pchgno, pchg->rlvlnoend);
+ fprintf(out, "le[%d] = %"PRIuFAST16"\n", pchgno, pchg->lyrnoend);
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* CRG marker segment operations.
+\******************************************************************************/
+
+static void jpc_crg_destroyparms(jpc_ms_t *ms)
+{+ jpc_crg_t *crg = &ms->parms.crg;
+ if (crg->comps) {+ jas_free(crg->comps);
+ }
+}
+
+static int jpc_crg_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_crg_t *crg = &ms->parms.crg;
+ jpc_crgcomp_t *comp;
+ uint_fast16_t compno;
+ crg->numcomps = cstate->numcomps;
+ if (!(crg->comps = jas_alloc2(cstate->numcomps, sizeof(jpc_crgcomp_t)))) {+ return -1;
+ }
+ for (compno = 0, comp = crg->comps; compno < cstate->numcomps;
+ ++compno, ++comp) {+ if (jpc_getuint16(in, &comp->hoff) ||
+ jpc_getuint16(in, &comp->voff)) {+ jpc_crg_destroyparms(ms);
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jpc_crg_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_crg_t *crg = &ms->parms.crg;
+ int compno;
+ jpc_crgcomp_t *comp;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ for (compno = 0, comp = crg->comps; compno < crg->numcomps; ++compno,
+ ++comp) {+ if (jpc_putuint16(out, comp->hoff) ||
+ jpc_putuint16(out, comp->voff)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jpc_crg_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_crg_t *crg = &ms->parms.crg;
+ int compno;
+ jpc_crgcomp_t *comp;
+ for (compno = 0, comp = crg->comps; compno < crg->numcomps; ++compno,
+ ++comp) {+ fprintf(out, "hoff[%d] = %"PRIuFAST16"; voff[%d] = %"PRIuFAST16"\n",
+ compno, comp->hoff, compno, comp->voff);
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Operations for COM marker segment.
+\******************************************************************************/
+
+static void jpc_com_destroyparms(jpc_ms_t *ms)
+{+ jpc_com_t *com = &ms->parms.com;
+ if (com->data) {+ jas_free(com->data);
+ }
+}
+
+static int jpc_com_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_com_t *com = &ms->parms.com;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (jpc_getuint16(in, &com->regid)) {+ return -1;
+ }
+ com->len = ms->len - 2;
+ if (com->len > 0) {+ if (!(com->data = jas_malloc(com->len))) {+ return -1;
+ }
+ if (jas_stream_read(in, com->data, com->len) != com->len) {+ return -1;
+ }
+ } else {+ com->data = 0;
+ }
+ return 0;
+}
+
+static int jpc_com_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ jpc_com_t *com = &ms->parms.com;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (jpc_putuint16(out, com->regid)) {+ return -1;
+ }
+ if (jas_stream_write(out, com->data, com->len) != com->len) {+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_com_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ jpc_com_t *com = &ms->parms.com;
+ unsigned int i;
+ int printable;
+ fprintf(out, "regid = %"PRIuFAST16";\n", com->regid);
+ printable = 1;
+ for (i = 0; i < com->len; ++i) {+ if (!isprint(com->data[i])) {+ printable = 0;
+ break;
+ }
+ }
+ if (printable) {+ fprintf(out, "data = ");
+ fwrite(com->data, sizeof(char), com->len, out);
+ fprintf(out, "\n");
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Operations for unknown types of marker segments.
+\******************************************************************************/
+
+static void jpc_unk_destroyparms(jpc_ms_t *ms)
+{+ jpc_unk_t *unk = &ms->parms.unk;
+ if (unk->data) {+ jas_free(unk->data);
+ }
+}
+
+static int jpc_unk_getparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in)
+{+ jpc_unk_t *unk = &ms->parms.unk;
+
+ unk->data = 0;
+
+ /* Eliminate compiler warning about unused variables. */
+ (void)cstate;
+
+ if (ms->len > 0) {+ if (!(unk->data = jas_alloc2(ms->len, sizeof(unsigned char)))) {+ return -1;
+ }
+ if (jas_stream_read(in, (char *) unk->data, ms->len) != ms->len) {+ jas_free(unk->data);
+ return -1;
+ }
+ unk->len = ms->len;
+ } else {+ unk->data = 0;
+ unk->len = 0;
+ }
+ return 0;
+}
+
+static int jpc_unk_putparms(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out)
+{+ /* Eliminate compiler warning about unused variables. */
+ USED(cstate);
+ USED(ms);
+ USED(out);
+
+ /* If this function is called, we are trying to write an unsupported
+ type of marker segment. Return with an error indication. */
+ return -1;
+}
+
+static int jpc_unk_dumpparms(jpc_ms_t *ms, FILE *out)
+{+ unsigned int i;
+ jpc_unk_t *unk = &ms->parms.unk;
+ for (i = 0; i < unk->len; ++i) {+ fprintf(out, "%02x ", unk->data[i]);
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Primitive I/O operations.
+\******************************************************************************/
+
+int jpc_getuint8(jas_stream_t *in, uint_fast8_t *val)
+{+ int c;
+ if ((c = jas_stream_getc(in)) == EOF) {+ return -1;
+ }
+ if (val) {+ *val = c;
+ }
+ return 0;
+}
+
+int jpc_putuint8(jas_stream_t *out, uint_fast8_t val)
+{+ if (jas_stream_putc(out, val & 0xff) == EOF) {+ return -1;
+ }
+ return 0;
+}
+
+int jpc_getuint16(jas_stream_t *in, uint_fast16_t *val)
+{+ jas_uchar buffer[2];
+ if (jas_stream_read(in, buffer, sizeof(buffer)) != sizeof(buffer))
+ return -1;
+ *val = (uint_fast16_t)buffer[0] << 8 | (uint_fast16_t)buffer[1];
+ return 0;
+}
+
+int jpc_putuint16(jas_stream_t *out, uint_fast16_t val)
+{+ if (jas_stream_putc(out, (val >> 8) & 0xff) == EOF ||
+ jas_stream_putc(out, val & 0xff) == EOF) {+ return -1;
+ }
+ return 0;
+}
+
+int jpc_getuint32(jas_stream_t *in, uint_fast32_t *val)
+{+ jas_uchar buffer[4];
+ if (jas_stream_read(in, buffer, sizeof(buffer)) != sizeof(buffer))
+ return -1;
+ *val = (uint_fast32_t)buffer[0] << 24 | (uint_fast32_t)buffer[1] << 16
+ | (uint_fast32_t)buffer[2] << 8 | (uint_fast32_t)buffer[3];
+ return 0;
+}
+
+int jpc_putuint32(jas_stream_t *out, uint_fast32_t val)
+{+ if (jas_stream_putc(out, (val >> 24) & 0xff) == EOF ||
+ jas_stream_putc(out, (val >> 16) & 0xff) == EOF ||
+ jas_stream_putc(out, (val >> 8) & 0xff) == EOF ||
+ jas_stream_putc(out, val & 0xff) == EOF) {+ return -1;
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Miscellany
+\******************************************************************************/
+
+static const jpc_mstabent_t *jpc_mstab_lookup(int id)
+{+ const jpc_mstabent_t *mstabent;
+ for (mstabent = jpc_mstab;; ++mstabent) {+ if (mstabent->id == id || mstabent->id < 0) {+ return mstabent;
+ }
+ }
+}
+
+int jpc_validate(jas_stream_t *in)
+{+ unsigned char buf[2];
+
+ assert(JAS_STREAM_MAXPUTBACK >= 2);
+
+ if (jas_stream_peek(in, buf, sizeof(buf)) != sizeof(buf))
+ return -1;
+
+ if (buf[0] == (JPC_MS_SOC >> 8) && buf[1] == (JPC_MS_SOC & 0xff)) {+ return 0;
+ }
+ return -1;
+}
+
+int jpc_getdata(jas_stream_t *in, jas_stream_t *out, long len)
+{+ return jas_stream_copy(out, in, len);
+}
+
+int jpc_putdata(jas_stream_t *out, jas_stream_t *in, long len)
+{+ return jas_stream_copy(out, in, len);
+}
--- /dev/null
+++ b/jpc_cs.h
@@ -1,0 +1,798 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * JPEG-2000 Code Stream Library
+ *
+ * $Id$
+ */
+
+#ifndef JPC_CS_H
+#define JPC_CS_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_stream.h"
+
+/******************************************************************************\
+* Constants and Types.
+\******************************************************************************/
+
+/* The maximum number of resolution levels. */
+#define JPC_MAXRLVLS 33
+
+/* The maximum number of bands. */
+#define JPC_MAXBANDS (3 * JPC_MAXRLVLS + 1)
+
+/* The maximum number of layers. */
+#define JPC_MAXLYRS 16384
+
+/**************************************\
+* Code stream.
+\**************************************/
+
+/*
+ * Code stream states.
+ */
+
+/* Initial. */
+#define JPC_CS_INIT 0
+/* Main header. */
+#define JPC_CS_MHDR 1
+/* Tile-part header. */
+#define JPC_CS_THDR 2
+/* Main trailer. */
+#define JPC_CS_MTLR 3
+/* Tile-part data. */
+#define JPC_CS_TDATA 4
+
+/*
+ * Unfortunately, the code stream syntax was not designed in such a way that
+ * any given marker segment can be correctly decoded without additional state
+ * derived from previously decoded marker segments.
+ * For example, a RGN/COC/QCC marker segment cannot be decoded unless the
+ * number of components is known.
+ */
+
+/*
+ * Code stream state information.
+ */
+
+typedef struct {+
+ /* The number of components. */
+ uint_fast16_t numcomps;
+
+} jpc_cstate_t;
+
+/**************************************\
+* SOT marker segment parameters.
+\**************************************/
+
+typedef struct {+
+ /* The tile number. */
+ uint_fast16_t tileno;
+
+ /* The combined length of the marker segment and its auxilary data
+ (i.e., packet data). */
+ uint_fast32_t len;
+
+ /* The tile-part instance. */
+ uint_fast8_t partno;
+
+ /* The number of tile-parts. */
+ uint_fast8_t numparts;
+
+} jpc_sot_t;
+
+/**************************************\
+* SIZ marker segment parameters.
+\**************************************/
+
+/* Per component information. */
+
+typedef struct {+
+ /* The precision of the samples. */
+ uint_fast8_t prec;
+
+ /* The signedness of the samples. */
+ uint_fast8_t sgnd;
+
+ /* The horizontal separation of samples with respect to the reference
+ grid. */
+ uint_fast8_t hsamp;
+
+ /* The vertical separation of samples with respect to the reference
+ grid. */
+ uint_fast8_t vsamp;
+
+} jpc_sizcomp_t;
+
+/* SIZ marker segment parameters. */
+
+typedef struct {+
+ /* The code stream capabilities. */
+ uint_fast16_t caps;
+
+ /* The width of the image in units of the reference grid. */
+ uint_fast32_t width;
+
+ /* The height of the image in units of the reference grid. */
+ uint_fast32_t height;
+
+ /* The horizontal offset from the origin of the reference grid to the
+ left side of the image area. */
+ uint_fast32_t xoff;
+
+ /* The vertical offset from the origin of the reference grid to the
+ top side of the image area. */
+ uint_fast32_t yoff;
+
+ /* The nominal width of a tile in units of the reference grid. */
+ uint_fast32_t tilewidth;
+
+ /* The nominal height of a tile in units of the reference grid. */
+ uint_fast32_t tileheight;
+
+ /* The horizontal offset from the origin of the reference grid to the
+ left side of the first tile. */
+ uint_fast32_t tilexoff;
+
+ /* The vertical offset from the origin of the reference grid to the
+ top side of the first tile. */
+ uint_fast32_t tileyoff;
+
+ /* The number of components. */
+ uint_fast16_t numcomps;
+
+ /* The per-component information. */
+ jpc_sizcomp_t *comps;
+
+} jpc_siz_t;
+
+/**************************************\
+* COD marker segment parameters.
+\**************************************/
+
+/*
+ * Coding style constants.
+ */
+
+/* Precincts may be used. */
+#define JPC_COX_PRT 0x01
+/* SOP marker segments may be used. */
+#define JPC_COD_SOP 0x02
+/* EPH marker segments may be used. */
+#define JPC_COD_EPH 0x04
+
+/*
+ * Progression order constants.
+ */
+
+/* Layer-resolution-component-precinct progressive
+ (i.e., progressive by fidelity). */
+#define JPC_COD_LRCPPRG 0
+/* Resolution-layer-component-precinct progressive
+ (i.e., progressive by resolution). */
+#define JPC_COD_RLCPPRG 1
+/* Resolution-precinct-component-layer progressive. */
+#define JPC_COD_RPCLPRG 2
+/* Precinct-component-resolution-layer progressive. */
+#define JPC_COD_PCRLPRG 3
+/* Component-position-resolution-layer progressive. */
+#define JPC_COD_CPRLPRG 4
+
+/*
+ * Code block style constants.
+ */
+
+#define JPC_COX_LAZY 0x01 /* Selective arithmetic coding bypass. */
+#define JPC_COX_RESET 0x02 /* Reset context probabilities. */
+#define JPC_COX_TERMALL 0x04 /* Terminate all coding passes. */
+#define JPC_COX_VSC 0x08 /* Vertical stripe causal context formation. */
+#define JPC_COX_PTERM 0x10 /* Predictable termination. */
+#define JPC_COX_SEGSYM 0x20 /* Use segmentation symbols. */
+
+/* Transform constants. */
+#define JPC_COX_INS 0x00 /* Irreversible 9/7. */
+#define JPC_COX_RFT 0x01 /* Reversible 5/3. */
+
+/* Multicomponent transform constants. */
+#define JPC_COD_NOMCT 0x00 /* No multicomponent transform. */
+#define JPC_COD_MCT 0x01 /* Multicomponent transform. */
+
+/* Get the code block size value from the code block size exponent. */
+JAS_ATTRIBUTE_CONST
+static inline unsigned JPC_COX_CBLKSIZEEXPN(unsigned x)
+{+ return x - 2;
+}
+
+/* Get the code block size exponent from the code block size value. */
+JAS_ATTRIBUTE_CONST
+static inline unsigned JPC_COX_GETCBLKSIZEEXPN(unsigned x)
+{+ return x + 2;
+}
+
+/* Per resolution-level information. */
+
+typedef struct {+
+ /* The packet partition width. */
+ uint_fast8_t parwidthval;
+
+ /* The packet partition height. */
+ uint_fast8_t parheightval;
+
+} jpc_coxrlvl_t;
+
+/* Per component information. */
+
+typedef struct {+
+ /* The coding style. */
+ uint_fast8_t csty;
+
+ /* The number of decomposition levels. */
+ uint_fast8_t numdlvls;
+
+ /* The nominal code block width specifier. */
+ uint_fast8_t cblkwidthval;
+
+ /* The nominal code block height specifier. */
+ uint_fast8_t cblkheightval;
+
+ /* The style of coding passes. */
+ uint_fast8_t cblksty;
+
+ /* The QMFB employed. */
+ uint_fast8_t qmfbid;
+
+ /* The number of resolution levels. */
+ int numrlvls;
+
+ /* The per-resolution-level information. */
+ jpc_coxrlvl_t rlvls[JPC_MAXRLVLS];
+
+} jpc_coxcp_t;
+
+/* COD marker segment parameters. */
+
+typedef struct {+
+ /* The general coding style. */
+ uint_fast8_t csty;
+
+ /* The progression order. */
+ uint_fast8_t prg;
+
+ /* The number of layers. */
+ uint_fast16_t numlyrs;
+
+ /* The multicomponent transform. */
+ uint_fast8_t mctrans;
+
+ /* Component-related parameters. */
+ jpc_coxcp_t compparms;
+
+} jpc_cod_t;
+
+/* COC marker segment parameters. */
+
+typedef struct {+
+ /* The component number. */
+ uint_fast16_t compno;
+
+ /* Component-related parameters. */
+ jpc_coxcp_t compparms;
+
+} jpc_coc_t;
+
+/**************************************\
+* RGN marker segment parameters.
+\**************************************/
+
+/* The maxshift ROI style. */
+#define JPC_RGN_MAXSHIFT 0x00
+
+typedef struct {+
+ /* The component to which the marker applies. */
+ uint_fast16_t compno;
+
+ /* The ROI style. */
+ uint_fast8_t roisty;
+
+ /* The ROI shift value. */
+ uint_fast8_t roishift;
+
+} jpc_rgn_t;
+
+/**************************************\
+* QCD/QCC marker segment parameters.
+\**************************************/
+
+/*
+ * Quantization style constants.
+ */
+
+#define JPC_QCX_NOQNT 0 /* No quantization. */
+#define JPC_QCX_SIQNT 1 /* Scalar quantization, implicit. */
+#define JPC_QCX_SEQNT 2 /* Scalar quantization, explicit. */
+
+/*
+ * Stepsize manipulation macros.
+ */
+
+JAS_ATTRIBUTE_CONST
+static inline unsigned JPC_QCX_GETEXPN(unsigned x)
+{+ return x >> 11;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline unsigned JPC_QCX_GETMANT(unsigned x)
+{+ return x & 0x7ff;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline uint_fast16_t JPC_QCX_EXPN(unsigned x)
+{+ assert(!(x & (~0x1f)));
+
+ return (x & 0x1f) << 11;
+}
+
+JAS_ATTRIBUTE_CONST
+static inline uint_fast16_t JPC_QCX_MANT(unsigned x)
+{+ assert(!(x & (~0x7ff)));
+
+ return x & 0x7ff;
+}
+
+/* Per component information. */
+
+typedef struct {+
+ /* The quantization style. */
+ uint_fast8_t qntsty;
+
+ /* The number of step sizes. */
+ int numstepsizes;
+
+ /* The step sizes. */
+ uint_fast16_t *stepsizes;
+
+ /* The number of guard bits. */
+ uint_fast8_t numguard;
+
+} jpc_qcxcp_t;
+
+/* QCC marker segment parameters. */
+
+typedef struct {+
+ /* The component associated with this marker segment. */
+ uint_fast16_t compno;
+
+ /* The parameters. */
+ jpc_qcxcp_t compparms;
+
+} jpc_qcc_t;
+
+/* QCD marker segment parameters. */
+
+typedef struct {+
+ /* The parameters. */
+ jpc_qcxcp_t compparms;
+
+} jpc_qcd_t;
+
+/**************************************\
+* POD marker segment parameters.
+\**************************************/
+
+typedef struct {+
+ /* The progression order. */
+ uint_fast8_t prgord;
+
+ /* The lower bound (inclusive) on the resolution level for the
+ progression order volume. */
+ uint_fast8_t rlvlnostart;
+
+ /* The upper bound (exclusive) on the resolution level for the
+ progression order volume. */
+ uint_fast8_t rlvlnoend;
+
+ /* The lower bound (inclusive) on the component for the progression
+ order volume. */
+ uint_fast16_t compnostart;
+
+ /* The upper bound (exclusive) on the component for the progression
+ order volume. */
+ uint_fast16_t compnoend;
+
+ /* The upper bound (exclusive) on the layer for the progression
+ order volume. */
+ uint_fast16_t lyrnoend;
+
+} jpc_pocpchg_t;
+
+/* An alias for the above type. */
+typedef jpc_pocpchg_t jpc_pchg_t;
+
+/* POC marker segment parameters. */
+
+typedef struct {+
+ /* The number of progression order changes. */
+ int numpchgs;
+
+ /* The per-progression-order-change information. */
+ jpc_pocpchg_t *pchgs;
+
+} jpc_poc_t;
+
+/**************************************\
+* PPM/PPT marker segment parameters.
+\**************************************/
+
+/* PPM marker segment parameters. */
+
+typedef struct {+
+ /* The index. */
+ uint_fast8_t ind;
+
+ /* The length. */
+ uint_fast16_t len;
+
+ /* The data. */
+ jas_uchar *data;
+
+} jpc_ppm_t;
+
+/* PPT marker segment parameters. */
+
+typedef struct {+
+ /* The index. */
+ uint_fast8_t ind;
+
+ /* The length. */
+ uint_fast32_t len;
+
+ /* The data. */
+ unsigned char *data;
+
+} jpc_ppt_t;
+
+/**************************************\
+* COM marker segment parameters.
+\**************************************/
+
+/*
+ * Registration IDs.
+ */
+
+#define JPC_COM_BIN 0x00
+#define JPC_COM_LATIN 0x01
+
+typedef struct {+
+ /* The registration ID. */
+ uint_fast16_t regid;
+
+ /* The length of the data in bytes. */
+ uint_fast16_t len;
+
+ /* The data. */
+ jas_uchar *data;
+
+} jpc_com_t;
+
+/**************************************\
+* SOP marker segment parameters.
+\**************************************/
+
+typedef struct {+
+ /* The sequence number. */
+ uint_fast16_t seqno;
+
+} jpc_sop_t;
+
+/**************************************\
+* CRG marker segment parameters.
+\**************************************/
+
+/* Per component information. */
+
+typedef struct {+
+ /* The horizontal offset. */
+ uint_fast16_t hoff;
+
+ /* The vertical offset. */
+ uint_fast16_t voff;
+
+} jpc_crgcomp_t;
+
+typedef struct {+
+ /* The number of components. */
+ int numcomps;
+
+ /* Per component information. */
+ jpc_crgcomp_t *comps;
+
+} jpc_crg_t;
+
+/**************************************\
+* Marker segment parameters for unknown marker type.
+\**************************************/
+
+typedef struct {+
+ /* The data. */
+ jas_uchar *data;
+
+ /* The length. */
+ uint_fast16_t len;
+
+} jpc_unk_t;
+
+/**************************************\
+* Generic marker segment parameters.
+\**************************************/
+
+typedef union {+ int soc; /* unused */
+ jpc_sot_t sot;
+ int sod; /* unused */
+ int eoc; /* unused */
+ jpc_siz_t siz;
+ jpc_cod_t cod;
+ jpc_coc_t coc;
+ jpc_rgn_t rgn;
+ jpc_qcd_t qcd;
+ jpc_qcc_t qcc;
+ jpc_poc_t poc;
+ /* jpc_plm_t plm; */
+ /* jpc_plt_t plt; */
+ jpc_ppm_t ppm;
+ jpc_ppt_t ppt;
+ jpc_sop_t sop;
+ int eph; /* unused */
+ jpc_com_t com;
+ jpc_crg_t crg;
+ jpc_unk_t unk;
+} jpc_msparms_t;
+
+/**************************************\
+* Marker segment.
+\**************************************/
+
+/* Marker segment IDs. */
+
+/* The smallest valid marker value. */
+#define JPC_MS_MIN 0xff00
+
+/* The largest valid marker value. */
+#define JPC_MS_MAX 0xffff
+
+/* The minimum marker value that cannot occur within packet data. */
+#define JPC_MS_INMIN 0xff80
+/* The maximum marker value that cannot occur within packet data. */
+#define JPC_MS_INMAX 0xffff
+
+/* Delimiting marker segments. */
+#define JPC_MS_SOC 0xff4f /* Start of code stream (SOC). */
+#define JPC_MS_SOT 0xff90 /* Start of tile-part (SOT). */
+#define JPC_MS_SOD 0xff93 /* Start of data (SOD). */
+#define JPC_MS_EOC 0xffd9 /* End of code stream (EOC). */
+
+/* Fixed information marker segments. */
+#define JPC_MS_SIZ 0xff51 /* Image and tile size (SIZ). */
+
+/* Functional marker segments. */
+#define JPC_MS_COD 0xff52 /* Coding style default (COD). */
+#define JPC_MS_COC 0xff53 /* Coding style component (COC). */
+#define JPC_MS_RGN 0xff5e /* Region of interest (RGN). */
+#define JPC_MS_QCD 0xff5c /* Quantization default (QCD). */
+#define JPC_MS_QCC 0xff5d /* Quantization component (QCC). */
+#define JPC_MS_POC 0xff5f /* Progression order default (POC). */
+
+/* Pointer marker segments. */
+#define JPC_MS_TLM 0xff55 /* Tile-part lengths, main header (TLM). */
+#define JPC_MS_PLM 0xff57 /* Packet length, main header (PLM). */
+#define JPC_MS_PLT 0xff58 /* Packet length, tile-part header (PLT). */
+#define JPC_MS_PPM 0xff60 /* Packed packet headers, main header (PPM). */
+#define JPC_MS_PPT 0xff61 /* Packet packet headers, tile-part header (PPT). */
+
+/* In bit stream marker segments. */
+#define JPC_MS_SOP 0xff91 /* Start of packet (SOP). */
+#define JPC_MS_EPH 0xff92 /* End of packet header (EPH). */
+
+/* Informational marker segments. */
+#define JPC_MS_CRG 0xff63 /* Component registration (CRG). */
+#define JPC_MS_COM 0xff64 /* Comment (COM). */
+
+/* Forward declaration. */
+struct jpc_msops_s;
+
+/* Generic marker segment class. */
+
+typedef struct {+
+ /* The type of marker segment. */
+ uint_fast16_t id;
+
+ /* The length of the marker segment. */
+ uint_fast16_t len;
+
+ /* The starting offset within the stream. */
+ uint_fast32_t off;
+
+ /* The parameters of the marker segment. */
+ jpc_msparms_t parms;
+
+ /* The marker segment operations. */
+ const struct jpc_msops_s *ops;
+
+} jpc_ms_t;
+
+/* Marker segment operations (which depend on the marker segment type). */
+
+typedef struct jpc_msops_s {+
+ /* Destroy the marker segment parameters. */
+ void (*destroyparms)(jpc_ms_t *ms);
+
+ /* Get the marker segment parameters from a stream. */
+ int (*getparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *in);
+
+ /* Put the marker segment parameters to a stream. */
+ int (*putparms)(jpc_ms_t *ms, jpc_cstate_t *cstate, jas_stream_t *out);
+
+ /* Dump the marker segment parameters (for debugging). */
+ int (*dumpparms)(jpc_ms_t *ms, FILE *out);
+
+} jpc_msops_t;
+
+/******************************************************************************\
+* Macros/Functions.
+\******************************************************************************/
+
+/* Create a code-stream state object. */
+jpc_cstate_t *jpc_cstate_create(void);
+
+/* Destroy a code-stream state object. */
+void jpc_cstate_destroy(jpc_cstate_t *cstate);
+
+/* Create a marker segment. */
+jpc_ms_t *jpc_ms_create(int type);
+
+/* Destroy a marker segment. */
+void jpc_ms_destroy(jpc_ms_t *ms);
+
+/* Does a marker segment have parameters? */
+JAS_ATTRIBUTE_CONST
+static inline bool JPC_MS_HASPARMS(unsigned x)
+{+ return !(x == JPC_MS_SOC || x == JPC_MS_SOD || x == JPC_MS_EOC ||
+ x == JPC_MS_EPH || (x >= 0xff30 && x <= 0xff3f));
+}
+
+/* Get the marker segment type. */
+JAS_ATTRIBUTE_PURE
+static inline unsigned jpc_ms_gettype(const jpc_ms_t *ms)
+{+ return ms->id;
+}
+
+/* Read a marker segment from a stream. */
+jpc_ms_t *jpc_getms(jas_stream_t *in, jpc_cstate_t *cstate);
+
+/* Write a marker segment to a stream. */
+int jpc_putms(jas_stream_t *out, jpc_cstate_t *cstate, jpc_ms_t *ms);
+
+/* Copy code stream data from one stream to another. */
+int jpc_getdata(jas_stream_t *in, jas_stream_t *out, long n);
+
+/* Copy code stream data from one stream to another. */
+int jpc_putdata(jas_stream_t *out, jas_stream_t *in, long n);
+
+/* Dump a marker segment (for debugging). */
+void jpc_ms_dump(jpc_ms_t *ms, FILE *out);
+
+/* Read a 8-bit unsigned integer from a stream. */
+int jpc_getuint8(jas_stream_t *in, uint_fast8_t *val);
+
+/* Read a 16-bit unsigned integer from a stream. */
+int jpc_getuint16(jas_stream_t *in, uint_fast16_t *val);
+
+/* Read a 32-bit unsigned integer from a stream. */
+int jpc_getuint32(jas_stream_t *in, uint_fast32_t *val);
+
+/* Write a 8-bit unsigned integer to a stream. */
+int jpc_putuint8(jas_stream_t *out, uint_fast8_t val);
+
+/* Write a 16-bit unsigned integer to a stream. */
+int jpc_putuint16(jas_stream_t *out, uint_fast16_t val);
+
+/* Write a 32-bit unsigned integer to a stream. */
+int jpc_putuint32(jas_stream_t *out, uint_fast32_t val);
+
+#endif
--- /dev/null
+++ b/jpc_dec.c
@@ -1,0 +1,2451 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_dec.h"
+#include "jpc_fix.h"
+#include "jpc_cs.h"
+#include "jpc_mct.h"
+#include "jpc_t2dec.h"
+#include "jpc_t1cod.h"
+#include "jpc_t1dec.h"
+#include "jpc_math.h"
+
+#include "jasper/jas_types.h"
+#include "jasper/jas_math.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_debug.h"
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+#define JPC_MHSOC 0x0001
+ /* In the main header, expecting a SOC marker segment. */
+#define JPC_MHSIZ 0x0002
+ /* In the main header, expecting a SIZ marker segment. */
+#define JPC_MH 0x0004
+ /* In the main header, expecting "other" marker segments. */
+#define JPC_TPHSOT 0x0008
+ /* In a tile-part header, expecting a SOT marker segment. */
+#define JPC_TPH 0x0010
+ /* In a tile-part header, expecting "other" marker segments. */
+#define JPC_MT 0x0020
+ /* In the main trailer. */
+
+typedef struct {+
+ uint_least16_t id;
+ /* The marker segment type. */
+
+ uint_least16_t validstates;
+ /* The states in which this type of marker segment can be
+ validly encountered. */
+
+ int (*action)(jpc_dec_t *dec, jpc_ms_t *ms);
+ /* The action to take upon encountering this type of marker segment. */
+
+} jpc_dec_mstabent_t;
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+/* COD/COC parameters have been specified. */
+#define JPC_CSET 0x0001
+/* QCD/QCC parameters have been specified. */
+#define JPC_QSET 0x0002
+/* COD/COC parameters set from a COC marker segment. */
+#define JPC_COC 0x0004
+/* QCD/QCC parameters set from a QCC marker segment. */
+#define JPC_QCC 0x0008
+
+/******************************************************************************\
+* Local function prototypes.
+\******************************************************************************/
+
+static int jpc_dec_dump(const jpc_dec_t *dec, FILE *out);
+
+static jpc_ppxstab_t *jpc_ppxstab_create(void);
+static void jpc_ppxstab_destroy(jpc_ppxstab_t *tab);
+static int jpc_ppxstab_grow(jpc_ppxstab_t *tab, unsigned maxents);
+static int jpc_ppxstab_insert(jpc_ppxstab_t *tab, jpc_ppxstabent_t *ent);
+static jpc_streamlist_t *jpc_ppmstabtostreams(jpc_ppxstab_t *tab);
+static int jpc_pptstabwrite(jas_stream_t *out, jpc_ppxstab_t *tab);
+static jpc_ppxstabent_t *jpc_ppxstabent_create(void);
+static void jpc_ppxstabent_destroy(jpc_ppxstabent_t *ent);
+
+static int jpc_streamlist_numstreams(jpc_streamlist_t *streamlist);
+static jpc_streamlist_t *jpc_streamlist_create(void);
+
+static int jpc_streamlist_insert(jpc_streamlist_t *streamlist, unsigned streamno,
+ jas_stream_t *stream);
+static jas_stream_t *jpc_streamlist_remove(jpc_streamlist_t *streamlist, unsigned streamno);
+static void jpc_streamlist_destroy(jpc_streamlist_t *streamlist);
+
+static void jpc_dec_cp_resetflags(jpc_dec_cp_t *cp);
+static jpc_dec_cp_t *jpc_dec_cp_create(uint_fast16_t numcomps);
+static int jpc_dec_cp_isvalid(const jpc_dec_cp_t *cp);
+static jpc_dec_cp_t *jpc_dec_cp_copy(const jpc_dec_cp_t *cp);
+static int jpc_dec_cp_setfromcod(jpc_dec_cp_t *cp, const jpc_cod_t *cod);
+static int jpc_dec_cp_setfromcoc(jpc_dec_cp_t *cp, const jpc_coc_t *coc);
+static int jpc_dec_cp_setfromcox(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
+ const jpc_coxcp_t *compparms, unsigned flags);
+static int jpc_dec_cp_setfromqcd(jpc_dec_cp_t *cp, const jpc_qcd_t *qcd);
+static int jpc_dec_cp_setfromqcc(jpc_dec_cp_t *cp, const jpc_qcc_t *qcc);
+static int jpc_dec_cp_setfromqcx(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
+ const jpc_qcxcp_t *compparms, unsigned flags);
+static int jpc_dec_cp_setfromrgn(jpc_dec_cp_t *cp, const jpc_rgn_t *rgn);
+static int jpc_dec_cp_prepare(jpc_dec_cp_t *cp);
+static void jpc_dec_cp_destroy(jpc_dec_cp_t *cp);
+static int jpc_dec_cp_setfrompoc(jpc_dec_cp_t *cp, const jpc_poc_t *poc, int reset);
+static int jpc_pi_addpchgfrompoc(jpc_pi_t *pi, const jpc_poc_t *poc);
+
+static int jpc_dec_decode(jpc_dec_t *dec);
+static jpc_dec_t *jpc_dec_create(jpc_dec_importopts_t *impopts,
+ jas_stream_t *in);
+static void jpc_dec_destroy(jpc_dec_t *dec);
+static void jpc_dequantize(jas_matrix_t *x, jpc_fix_t absstepsize);
+static void jpc_undo_roi(jas_matrix_t *x, int roishift, int bgshift, unsigned numbps);
+static jpc_fix_t jpc_calcabsstepsize(unsigned stepsize, unsigned numbits);
+static int jpc_dec_tiledecode(jpc_dec_t *dec, jpc_dec_tile_t *tile);
+static int jpc_dec_tileinit(jpc_dec_t *dec, jpc_dec_tile_t *tile);
+static int jpc_dec_tilefini(jpc_dec_t *dec, jpc_dec_tile_t *tile);
+static int jpc_dec_process_soc(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_sot(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_sod(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_eoc(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_siz(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_cod(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_coc(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_rgn(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_qcd(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_qcc(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_poc(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_ppm(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_ppt(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_com(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_unk(jpc_dec_t *dec, jpc_ms_t *ms);
+static int jpc_dec_process_crg(jpc_dec_t *dec, jpc_ms_t *ms);
+static jpc_dec_importopts_t *jpc_dec_opts_create(const char *optstr);
+static void jpc_dec_opts_destroy(jpc_dec_importopts_t *opts);
+
+static const jpc_dec_mstabent_t *jpc_dec_mstab_lookup(uint_fast16_t id);
+
+/******************************************************************************\
+* Global data.
+\******************************************************************************/
+
+static const jpc_dec_mstabent_t jpc_dec_mstab[] = {+ {JPC_MS_SOC, JPC_MHSOC, jpc_dec_process_soc},+ {JPC_MS_SOT, JPC_MH | JPC_TPHSOT, jpc_dec_process_sot},+ {JPC_MS_SOD, JPC_TPH, jpc_dec_process_sod},+ {JPC_MS_EOC, JPC_TPHSOT, jpc_dec_process_eoc},+ {JPC_MS_SIZ, JPC_MHSIZ, jpc_dec_process_siz},+ {JPC_MS_COD, JPC_MH | JPC_TPH, jpc_dec_process_cod},+ {JPC_MS_COC, JPC_MH | JPC_TPH, jpc_dec_process_coc},+ {JPC_MS_RGN, JPC_MH | JPC_TPH, jpc_dec_process_rgn},+ {JPC_MS_QCD, JPC_MH | JPC_TPH, jpc_dec_process_qcd},+ {JPC_MS_QCC, JPC_MH | JPC_TPH, jpc_dec_process_qcc},+ {JPC_MS_POC, JPC_MH | JPC_TPH, jpc_dec_process_poc},+ {JPC_MS_TLM, JPC_MH, 0},+ {JPC_MS_PLM, JPC_MH, 0},+ {JPC_MS_PLT, JPC_TPH, 0},+ {JPC_MS_PPM, JPC_MH, jpc_dec_process_ppm},+ {JPC_MS_PPT, JPC_TPH, jpc_dec_process_ppt},+ {JPC_MS_SOP, 0, 0},+ {JPC_MS_CRG, JPC_MH, jpc_dec_process_crg},+ {JPC_MS_COM, JPC_MH | JPC_TPH, jpc_dec_process_com},+ {0, JPC_MH | JPC_TPH, jpc_dec_process_unk}+};
+
+/******************************************************************************\
+* The main entry point for the JPEG-2000 decoder.
+\******************************************************************************/
+
+jas_image_t *jpc_decode(jas_stream_t *in, const char *optstr)
+{+ jpc_dec_importopts_t *opts;
+ jpc_dec_t *dec;
+ jas_image_t *image;
+
+ dec = 0;
+
+ JAS_DBGLOG(100, ("jpc_decode(%p, \"%s\")\n", in, optstr));+
+ if (!(opts = jpc_dec_opts_create(optstr))) {+ goto error;
+ }
+
+ jpc_initluts();
+
+ if (!(dec = jpc_dec_create(opts, in))) {+ goto error;
+ }
+ jpc_dec_opts_destroy(opts);
+ opts = 0;
+
+ /* Do most of the work. */
+ if (jpc_dec_decode(dec)) {+ goto error;
+ }
+
+ if (jas_image_numcmpts(dec->image) >= 3) {+ jas_image_setclrspc(dec->image, JAS_CLRSPC_SRGB);
+ jas_image_setcmpttype(dec->image, 0,
+ JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R));
+ jas_image_setcmpttype(dec->image, 1,
+ JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G));
+ jas_image_setcmpttype(dec->image, 2,
+ JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B));
+ } else {+ jas_image_setclrspc(dec->image, JAS_CLRSPC_SGRAY);
+ jas_image_setcmpttype(dec->image, 0,
+ JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y));
+ }
+
+ /* Save the return value. */
+ image = dec->image;
+
+ /* Stop the image from being discarded. */
+ dec->image = 0;
+
+ /* Destroy decoder. */
+ jpc_dec_destroy(dec);
+
+ return image;
+
+error:
+ if (opts) {+ jpc_dec_opts_destroy(opts);
+ }
+ if (dec) {+ jpc_dec_destroy(dec);
+ }
+ return 0;
+}
+
+static jpc_dec_importopts_t *jpc_dec_opts_create(const char *optstr)
+{+ jpc_dec_importopts_t *opts;
+
+ USED(optstr);
+ if (!(opts = jas_malloc(sizeof(jpc_dec_importopts_t)))) {+ goto error;
+ }
+
+ opts->debug = 0;
+ opts->maxlyrs = JPC_MAXLYRS;
+ opts->maxpkts = -1;
+ opts->max_samples = JAS_DEC_DEFAULT_MAX_SAMPLES;
+
+ return opts;
+
+error:
+ if (opts) {+ jpc_dec_opts_destroy(opts);
+ }
+ return 0;
+}
+
+static void jpc_dec_opts_destroy(jpc_dec_importopts_t *opts)
+{+ jas_free(opts);
+}
+
+/******************************************************************************\
+* Code for table-driven code stream decoder.
+\******************************************************************************/
+
+JAS_ATTRIBUTE_CONST
+static const jpc_dec_mstabent_t *jpc_dec_mstab_lookup(uint_fast16_t id)
+{+ const jpc_dec_mstabent_t *mstabent;
+ for (mstabent = jpc_dec_mstab; mstabent->id != 0; ++mstabent) {+ if (mstabent->id == id) {+ break;
+ }
+ }
+ return mstabent;
+}
+
+static int jpc_dec_decode(jpc_dec_t *dec)
+{+ jpc_ms_t *ms;
+ const jpc_dec_mstabent_t *mstabent;
+ int ret;
+ jpc_cstate_t *cstate;
+
+ if (!(cstate = jpc_cstate_create())) {+ return -1;
+ }
+ dec->cstate = cstate;
+
+ /* Initially, we should expect to encounter a SOC marker segment. */
+ dec->state = JPC_MHSOC;
+
+ for (;;) {+
+ /* Get the next marker segment in the code stream. */
+ if (!(ms = jpc_getms(dec->in, cstate))) {+ jas_eprintf("cannot get marker segment\n");+ return -1;
+ }
+
+ mstabent = jpc_dec_mstab_lookup(ms->id);
+ assert(mstabent);
+
+ /* Ensure that this type of marker segment is permitted
+ at this point in the code stream. */
+ if (!(dec->state & mstabent->validstates)) {+ jas_eprintf("unexpected marker segment type\n");+ jpc_ms_destroy(ms);
+ return -1;
+ }
+
+ /* Process the marker segment. */
+ if (mstabent->action) {+ ret = (*mstabent->action)(dec, ms);
+ } else {+ /* No explicit action is required. */
+ ret = 0;
+ }
+
+ /* Destroy the marker segment. */
+ jpc_ms_destroy(ms);
+
+ if (ret < 0) {+ return -1;
+ } else if (ret > 0) {+ break;
+ }
+
+ }
+
+ return 0;
+}
+
+static int jpc_dec_process_crg(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ jpc_dec_cmpt_t *cmpt;
+ jpc_crg_t *crg;
+
+ crg = &ms->parms.crg;
+ unsigned cmptno;
+ for (cmptno = 0, cmpt = dec->cmpts; cmptno < dec->numcomps; ++cmptno,
+ ++cmpt) {+ /* Ignore the information in the CRG marker segment for now.
+ This information serves no useful purpose for decoding anyhow.
+ Some other parts of the code need to be changed if these lines
+ are uncommented.
+ cmpt->hsubstep = crg->comps[cmptno].hoff;
+ cmpt->vsubstep = crg->comps[cmptno].voff;
+ */
+ /* suppress -Wunused-but-set-variable */
+ USED(crg);
+ }
+ return 0;
+}
+
+static int jpc_dec_process_soc(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ /* Eliminate warnings about unused variables. */
+ (void)ms;
+
+ /* We should expect to encounter a SIZ marker segment next. */
+ dec->state = JPC_MHSIZ;
+
+ return 0;
+}
+
+static int jpc_dec_process_sot(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ jpc_dec_tile_t *tile;
+ jpc_sot_t *sot = &ms->parms.sot;
+ jas_image_cmptparm_t *compinfos;
+ jas_image_cmptparm_t *compinfo;
+ jpc_dec_cmpt_t *cmpt;
+
+ if (dec->state == JPC_MH) {+
+ if (!(compinfos = jas_alloc2(dec->numcomps,
+ sizeof(jas_image_cmptparm_t)))) {+ return -1;
+ }
+ unsigned cmptno;
+ for (cmptno = 0, cmpt = dec->cmpts, compinfo = compinfos;
+ cmptno < dec->numcomps; ++cmptno, ++cmpt, ++compinfo) {+ compinfo->tlx = 0;
+ compinfo->tly = 0;
+ compinfo->prec = cmpt->prec;
+ compinfo->sgnd = cmpt->sgnd;
+ compinfo->width = cmpt->width;
+ compinfo->height = cmpt->height;
+ compinfo->hstep = cmpt->hstep;
+ compinfo->vstep = cmpt->vstep;
+ }
+
+ if (!(dec->image = jas_image_create(dec->numcomps, compinfos,
+ JAS_CLRSPC_UNKNOWN))) {+ jas_free(compinfos);
+ return -1;
+ }
+ jas_free(compinfos);
+
+ /* Is the packet header information stored in PPM marker segments in
+ the main header? */
+ if (dec->ppmstab) {+ /* Convert the PPM marker segment data into a collection of streams
+ (one stream per tile-part). */
+ if (!(dec->pkthdrstreams = jpc_ppmstabtostreams(dec->ppmstab))) {+ return -1;
+ }
+ jpc_ppxstab_destroy(dec->ppmstab);
+ dec->ppmstab = 0;
+ }
+ }
+
+ if (sot->len > 0) {+ dec->curtileendoff = jas_stream_getrwcount(dec->in) - ms->len -
+ 4 + sot->len;
+ } else {+ dec->curtileendoff = 0;
+ }
+
+ if (sot->tileno >= dec->numtiles) {+ jas_eprintf("invalid tile number in SOT marker segment\n");+ return -1;
+ }
+ /* Set the current tile. */
+ dec->curtile = &dec->tiles[sot->tileno];
+ tile = dec->curtile;
+ /* Ensure that this is the expected part number. */
+ if (sot->partno != tile->partno) {+ return -1;
+ }
+ if (tile->numparts > 0 && sot->partno >= tile->numparts) {+ return -1;
+ }
+ if (!tile->numparts && sot->numparts > 0) {+ tile->numparts = sot->numparts;
+ }
+
+ tile->pptstab = 0;
+
+ switch (tile->state) {+ case JPC_TILE_INIT:
+ /* This is the first tile-part for this tile. */
+ tile->state = JPC_TILE_ACTIVE;
+ assert(!tile->cp);
+ if (!(tile->cp = jpc_dec_cp_copy(dec->cp))) {+ return -1;
+ }
+ jpc_dec_cp_resetflags(dec->cp);
+ break;
+ default:
+ if (sot->numparts == sot->partno - 1) {+ tile->state = JPC_TILE_ACTIVELAST;
+ }
+ break;
+ }
+
+ /* Note: We do not increment the expected tile-part number until
+ all processing for this tile-part is complete. */
+
+ /* We should expect to encounter other tile-part header marker
+ segments next. */
+ dec->state = JPC_TPH;
+
+ return 0;
+}
+
+static int jpc_dec_process_sod(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ jpc_dec_tile_t *tile;
+ int pos;
+
+ /* Eliminate compiler warnings about unused variables. */
+ (void)ms;
+
+ if (!(tile = dec->curtile)) {+ return -1;
+ }
+
+ if (!tile->partno) {+ if (!jpc_dec_cp_isvalid(tile->cp)) {+ return -1;
+ }
+ if (jpc_dec_cp_prepare(tile->cp)) {+ return -1;
+ }
+ if (jpc_dec_tileinit(dec, tile)) {+ return -1;
+ }
+ }
+
+ /* Are packet headers stored in the main header or tile-part header? */
+ if (dec->pkthdrstreams) {+ /* Get the stream containing the packet header data for this
+ tile-part. */
+ if (!(tile->pkthdrstream = jpc_streamlist_remove(dec->pkthdrstreams, 0))) {+ return -1;
+ }
+ }
+
+ if (tile->pptstab) {+ if (!tile->pkthdrstream) {+ if (!(tile->pkthdrstream = jas_stream_memopen(0, 0))) {+ return -1;
+ }
+ }
+ pos = jas_stream_tell(tile->pkthdrstream);
+ jas_stream_seek(tile->pkthdrstream, 0, SEEK_END);
+ if (jpc_pptstabwrite(tile->pkthdrstream, tile->pptstab)) {+ return -1;
+ }
+ jas_stream_seek(tile->pkthdrstream, pos, SEEK_SET);
+ jpc_ppxstab_destroy(tile->pptstab);
+ tile->pptstab = 0;
+ }
+
+ if (jas_getdbglevel() >= 10) {+ jpc_dec_dump(dec, stderr);
+ }
+
+ if (jpc_dec_decodepkts(dec, (tile->pkthdrstream) ? tile->pkthdrstream :
+ dec->in, dec->in)) {+ jas_eprintf("jpc_dec_decodepkts failed\n");+ return -1;
+ }
+
+ /* Gobble any unconsumed tile data. */
+ if (dec->curtileendoff > 0) {+ long curoff;
+ uint_fast32_t n;
+ curoff = jas_stream_getrwcount(dec->in);
+ if (curoff < dec->curtileendoff) {+ n = dec->curtileendoff - curoff;
+ jas_eprintf("warning: ignoring trailing garbage (%lu bytes)\n",+ (unsigned long) n);
+
+ while (n-- > 0) {+ if (jas_stream_getc(dec->in) == EOF) {+ jas_eprintf("read error\n");+ return -1;
+ }
+ }
+ } else if (curoff > dec->curtileendoff) {+ jas_eprintf("warning: not enough tile data (%lu bytes)\n",+ (unsigned long) curoff - dec->curtileendoff);
+ }
+
+ }
+
+ if (tile->numparts > 0 && tile->partno == tile->numparts - 1) {+ if (jpc_dec_tiledecode(dec, tile)) {+ return -1;
+ }
+ jpc_dec_tilefini(dec, tile);
+ }
+
+ dec->curtile = 0;
+
+ /* Increment the expected tile-part number. */
+ ++tile->partno;
+
+ /* We should expect to encounter a SOT marker segment next. */
+ dec->state = JPC_TPHSOT;
+
+ return 0;
+}
+
+static int jpc_dec_tileinit(jpc_dec_t *dec, jpc_dec_tile_t *tile)
+{+ jpc_dec_tcomp_t *tcomp;
+ unsigned rlvlno;
+ jpc_dec_rlvl_t *rlvl;
+ jpc_dec_band_t *band;
+ jpc_dec_prc_t *prc;
+ jpc_dec_cblk_t *cblk;
+ uint_fast32_t tlprcxstart;
+ uint_fast32_t tlprcystart;
+ uint_fast32_t brprcxend;
+ uint_fast32_t brprcyend;
+ uint_fast32_t tlcbgxstart;
+ uint_fast32_t tlcbgystart;
+ uint_fast32_t brcbgxend;
+ uint_fast32_t cbgxstart;
+ uint_fast32_t cbgystart;
+ uint_fast32_t cbgxend;
+ uint_fast32_t cbgyend;
+ uint_fast32_t tlcblkxstart;
+ uint_fast32_t tlcblkystart;
+ uint_fast32_t brcblkxend;
+ uint_fast32_t brcblkyend;
+ uint_fast32_t cblkxstart;
+ uint_fast32_t cblkystart;
+ uint_fast32_t cblkxend;
+ uint_fast32_t cblkyend;
+ uint_fast32_t tmpxstart;
+ uint_fast32_t tmpystart;
+ uint_fast32_t tmpxend;
+ uint_fast32_t tmpyend;
+ jpc_tsfb_band_t bnds[JPC_MAXBANDS];
+ jpc_pchg_t *pchg;
+
+ const jpc_dec_cp_t *cp = tile->cp;
+ tile->realmode = 0;
+ if (cp->mctid == JPC_MCT_ICT) {+ tile->realmode = 1;
+ }
+
+ unsigned compno;
+ const jpc_dec_cmpt_t *cmpt;
+ for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
+ dec->numcomps; ++compno, ++tcomp, ++cmpt) {+ const jpc_dec_ccp_t *ccp = &tile->cp->ccps[compno];
+ if (ccp->qmfbid == JPC_COX_INS) {+ tile->realmode = 1;
+ }
+ tcomp->numrlvls = ccp->numrlvls;
+ if (!(tcomp->rlvls = jas_alloc2(tcomp->numrlvls,
+ sizeof(jpc_dec_rlvl_t)))) {+ return -1;
+ }
+ for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
+ ++rlvlno, ++rlvl) {+ rlvl->bands = NULL;
+ }
+ if (!(tcomp->data = jas_seq2d_create(JPC_CEILDIV(tile->xstart,
+ cmpt->hstep), JPC_CEILDIV(tile->ystart, cmpt->vstep),
+ JPC_CEILDIV(tile->xend, cmpt->hstep), JPC_CEILDIV(tile->yend,
+ cmpt->vstep)))) {+ return -1;
+ }
+ if (!(tcomp->tsfb = jpc_cod_gettsfb(ccp->qmfbid,
+ tcomp->numrlvls - 1))) {+ return -1;
+ }
+ {+ jpc_tsfb_getbands(tcomp->tsfb, jas_seq2d_xstart(tcomp->data),
+ jas_seq2d_ystart(tcomp->data), jas_seq2d_xend(tcomp->data),
+ jas_seq2d_yend(tcomp->data), bnds);
+ }
+ for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
+ ++rlvlno, ++rlvl) {+ rlvl->bands = 0;
+ rlvl->xstart = JPC_CEILDIVPOW2(tcomp->xstart,
+ tcomp->numrlvls - 1 - rlvlno);
+ rlvl->ystart = JPC_CEILDIVPOW2(tcomp->ystart,
+ tcomp->numrlvls - 1 - rlvlno);
+ rlvl->xend = JPC_CEILDIVPOW2(tcomp->xend,
+ tcomp->numrlvls - 1 - rlvlno);
+ rlvl->yend = JPC_CEILDIVPOW2(tcomp->yend,
+ tcomp->numrlvls - 1 - rlvlno);
+ rlvl->prcwidthexpn = ccp->prcwidthexpns[rlvlno];
+ rlvl->prcheightexpn = ccp->prcheightexpns[rlvlno];
+ tlprcxstart = JPC_FLOORDIVPOW2(rlvl->xstart,
+ rlvl->prcwidthexpn) << rlvl->prcwidthexpn;
+ tlprcystart = JPC_FLOORDIVPOW2(rlvl->ystart,
+ rlvl->prcheightexpn) << rlvl->prcheightexpn;
+ brprcxend = JPC_CEILDIVPOW2(rlvl->xend,
+ rlvl->prcwidthexpn) << rlvl->prcwidthexpn;
+ brprcyend = JPC_CEILDIVPOW2(rlvl->yend,
+ rlvl->prcheightexpn) << rlvl->prcheightexpn;
+ rlvl->numhprcs = (brprcxend - tlprcxstart) >>
+ rlvl->prcwidthexpn;
+ rlvl->numvprcs = (brprcyend - tlprcystart) >>
+ rlvl->prcheightexpn;
+ rlvl->numprcs = rlvl->numhprcs * rlvl->numvprcs;
+
+ if (rlvl->numprcs >= 64 * 1024) {+ /* avoid out-of-memory due to
+ malicious file; this limit is
+ rather arbitrary; "good" files I
+ have seen have values 1..12 */
+ return -1;
+ }
+
+ if (rlvl->xstart >= rlvl->xend || rlvl->ystart >= rlvl->yend) {+ rlvl->bands = 0;
+ rlvl->numprcs = 0;
+ rlvl->numhprcs = 0;
+ rlvl->numvprcs = 0;
+ continue;
+ }
+ if (!rlvlno) {+ tlcbgxstart = tlprcxstart;
+ tlcbgystart = tlprcystart;
+ brcbgxend = brprcxend;
+ rlvl->cbgwidthexpn = rlvl->prcwidthexpn;
+ rlvl->cbgheightexpn = rlvl->prcheightexpn;
+ } else {+ tlcbgxstart = JPC_CEILDIVPOW2(tlprcxstart, 1);
+ tlcbgystart = JPC_CEILDIVPOW2(tlprcystart, 1);
+ brcbgxend = JPC_CEILDIVPOW2(brprcxend, 1);
+ if (rlvl->prcwidthexpn < 1 || rlvl->prcheightexpn < 1) {+ /* the control block width/height offset
+ exponent must not be negative */
+ return -1;
+ }
+ rlvl->cbgwidthexpn = rlvl->prcwidthexpn - 1;
+ rlvl->cbgheightexpn = rlvl->prcheightexpn - 1;
+ }
+ rlvl->cblkwidthexpn = JAS_MIN(ccp->cblkwidthexpn,
+ rlvl->cbgwidthexpn);
+ rlvl->cblkheightexpn = JAS_MIN(ccp->cblkheightexpn,
+ rlvl->cbgheightexpn);
+
+ rlvl->numbands = (!rlvlno) ? 1 : 3;
+ if (!(rlvl->bands = jas_alloc2(rlvl->numbands,
+ sizeof(jpc_dec_band_t)))) {+ return -1;
+ }
+ unsigned bandno;
+ for (bandno = 0, band = rlvl->bands;
+ bandno < rlvl->numbands; ++bandno, ++band) {+ unsigned bndno = (!rlvlno) ? 0 : (3 * (rlvlno - 1) +
+ bandno + 1);
+ const jpc_tsfb_band_t *bnd = &bnds[bndno];
+
+ band->orient = bnd->orient;
+ band->stepsize = ccp->stepsizes[bndno];
+ band->analgain = JPC_NOMINALGAIN(ccp->qmfbid,
+ tcomp->numrlvls - 1, rlvlno, band->orient);
+ band->absstepsize = jpc_calcabsstepsize(band->stepsize,
+ cmpt->prec + band->analgain);
+ band->numbps = ccp->numguardbits +
+ JPC_QCX_GETEXPN(band->stepsize) - 1;
+ band->roishift = (ccp->roishift + band->numbps >= JPC_PREC) ?
+ (JPC_PREC - 1 - band->numbps) : ccp->roishift;
+ band->data = 0;
+ band->prcs = 0;
+ if (bnd->xstart == bnd->xend || bnd->ystart == bnd->yend) {+ continue;
+ }
+ if (!(band->data = jas_seq2d_create(0, 0, 0, 0))) {+ return -1;
+ }
+ if (jas_seq2d_bindsub(band->data, tcomp->data, bnd->locxstart,
+ bnd->locystart, bnd->locxend, bnd->locyend)) {+ return -1;
+ }
+ jas_seq2d_setshift(band->data, bnd->xstart, bnd->ystart);
+
+ assert(rlvl->numprcs);
+
+ if (!(band->prcs = jas_alloc2(rlvl->numprcs,
+ sizeof(jpc_dec_prc_t)))) {+ return -1;
+ }
+
+/************************************************/
+ cbgxstart = tlcbgxstart;
+ cbgystart = tlcbgystart;
+ unsigned prccnt; for (prccnt = rlvl->numprcs, prc = band->prcs;
+ prccnt > 0; --prccnt, ++prc) {+ cbgxend = cbgxstart + (1 << rlvl->cbgwidthexpn);
+ cbgyend = cbgystart + (1 << rlvl->cbgheightexpn);
+ prc->xstart = JAS_MAX(cbgxstart, JAS_CAST(uint_fast32_t,
+ jas_seq2d_xstart(band->data)));
+ prc->ystart = JAS_MAX(cbgystart, JAS_CAST(uint_fast32_t,
+ jas_seq2d_ystart(band->data)));
+ prc->xend = JAS_MIN(cbgxend, JAS_CAST(uint_fast32_t,
+ jas_seq2d_xend(band->data)));
+ prc->yend = JAS_MIN(cbgyend, JAS_CAST(uint_fast32_t,
+ jas_seq2d_yend(band->data)));
+ if (prc->xend > prc->xstart && prc->yend > prc->ystart) {+ tlcblkxstart = JPC_FLOORDIVPOW2(prc->xstart,
+ rlvl->cblkwidthexpn) << rlvl->cblkwidthexpn;
+ tlcblkystart = JPC_FLOORDIVPOW2(prc->ystart,
+ rlvl->cblkheightexpn) << rlvl->cblkheightexpn;
+ brcblkxend = JPC_CEILDIVPOW2(prc->xend,
+ rlvl->cblkwidthexpn) << rlvl->cblkwidthexpn;
+ brcblkyend = JPC_CEILDIVPOW2(prc->yend,
+ rlvl->cblkheightexpn) << rlvl->cblkheightexpn;
+ prc->numhcblks = (brcblkxend - tlcblkxstart) >>
+ rlvl->cblkwidthexpn;
+ prc->numvcblks = (brcblkyend - tlcblkystart) >>
+ rlvl->cblkheightexpn;
+ prc->numcblks = prc->numhcblks * prc->numvcblks;
+ assert(prc->numcblks > 0);
+
+ if (!(prc->incltagtree = jpc_tagtree_create(
+ prc->numhcblks, prc->numvcblks))) {+ return -1;
+ }
+ if (!(prc->numimsbstagtree = jpc_tagtree_create(
+ prc->numhcblks, prc->numvcblks))) {+ return -1;
+ }
+ if (!(prc->cblks = jas_alloc2(prc->numcblks,
+ sizeof(jpc_dec_cblk_t)))) {+ return -1;
+ }
+
+ cblkxstart = cbgxstart;
+ cblkystart = cbgystart;
+ unsigned cblkcnt;
+ for (cblkcnt = prc->numcblks, cblk = prc->cblks;
+ cblkcnt > 0;) {+ cblkxend = cblkxstart + (1 << rlvl->cblkwidthexpn);
+ cblkyend = cblkystart + (1 << rlvl->cblkheightexpn);
+ tmpxstart = JAS_MAX(cblkxstart, prc->xstart);
+ tmpystart = JAS_MAX(cblkystart, prc->ystart);
+ tmpxend = JAS_MIN(cblkxend, prc->xend);
+ tmpyend = JAS_MIN(cblkyend, prc->yend);
+ if (tmpxend > tmpxstart && tmpyend > tmpystart) {+ cblk->firstpassno = -1;
+ cblk->numpasses = 0;
+ cblk->segs.head = 0;
+ cblk->segs.tail = 0;
+ cblk->curseg = 0;
+ cblk->numimsbs = 0;
+ cblk->numlenbits = 3;
+ if (!(cblk->data = jas_seq2d_create(0, 0, 0,
+ 0))) {+ return -1;
+ }
+ if (jas_seq2d_bindsub(cblk->data, band->data,
+ tmpxstart, tmpystart, tmpxend, tmpyend)) {+ return -1;
+ }
+ ++cblk;
+ --cblkcnt;
+ }
+ cblkxstart += 1 << rlvl->cblkwidthexpn;
+ if (cblkxstart >= cbgxend) {+ cblkxstart = cbgxstart;
+ cblkystart += 1 << rlvl->cblkheightexpn;
+ }
+ }
+
+ } else {+ prc->cblks = 0;
+ prc->incltagtree = 0;
+ prc->numimsbstagtree = 0;
+ }
+ cbgxstart += 1 << rlvl->cbgwidthexpn;
+ if (cbgxstart >= brcbgxend) {+ cbgxstart = tlcbgxstart;
+ cbgystart += 1 << rlvl->cbgheightexpn;
+ }
+
+ }
+/********************************************/
+ }
+ }
+ }
+
+ if (!(tile->pi = jpc_dec_pi_create(dec, tile))) {+ return -1;
+ }
+
+ for (unsigned pchgno = 0; pchgno < jpc_pchglist_numpchgs(tile->cp->pchglist);
+ ++pchgno) {+ pchg = jpc_pchg_copy(jpc_pchglist_get(tile->cp->pchglist, pchgno));
+ assert(pchg);
+ jpc_pi_addpchg(tile->pi, pchg);
+ }
+ jpc_pi_init(tile->pi);
+
+ return 0;
+}
+
+static int jpc_dec_tilefini(jpc_dec_t *dec, jpc_dec_tile_t *tile)
+{+ jpc_dec_tcomp_t *tcomp;
+ unsigned rlvlno;
+ jpc_dec_seg_t *seg;
+ jpc_dec_cblk_t *cblk;
+
+ if (tile->tcomps) {+
+ unsigned compno;
+ for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
+ ++compno, ++tcomp) {+ const jpc_dec_rlvl_t *rlvl;
+ for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
+ ++rlvlno, ++rlvl) {+ if (!rlvl->bands) {+ continue;
+ }
+ unsigned bandno;
+ const jpc_dec_band_t *band;
+ for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
+ ++bandno, ++band) {+ if (band->prcs) {+ unsigned prcno;
+ const jpc_dec_prc_t *prc;
+ for (prcno = 0, prc = band->prcs; prcno <
+ rlvl->numprcs; ++prcno, ++prc) {+ if (!prc->cblks) {+ continue;
+ }
+ unsigned cblkno;
+ for (cblkno = 0, cblk = prc->cblks; cblkno <
+ prc->numcblks; ++cblkno, ++cblk) {+
+ while (cblk->segs.head) {+ seg = cblk->segs.head;
+ jpc_seglist_remove(&cblk->segs, seg);
+ jpc_seg_destroy(seg);
+ }
+ jas_matrix_destroy(cblk->data);
+ }
+ if (prc->incltagtree) {+ jpc_tagtree_destroy(prc->incltagtree);
+ }
+ if (prc->numimsbstagtree) {+ jpc_tagtree_destroy(prc->numimsbstagtree);
+ }
+ if (prc->cblks) {+ jas_free(prc->cblks);
+ }
+ }
+ }
+ if (band->data) {+ jas_matrix_destroy(band->data);
+ }
+ if (band->prcs) {+ jas_free(band->prcs);
+ }
+ }
+ if (rlvl->bands) {+ jas_free(rlvl->bands);
+ }
+ }
+ if (tcomp->rlvls) {+ jas_free(tcomp->rlvls);
+ }
+ if (tcomp->data) {+ jas_matrix_destroy(tcomp->data);
+ }
+ if (tcomp->tsfb) {+ jpc_tsfb_destroy(tcomp->tsfb);
+ }
+ }
+ }
+
+ if (tile->cp) {+ jpc_dec_cp_destroy(tile->cp);
+ //tile->cp = 0;
+ }
+ if (tile->tcomps) {+ jas_free(tile->tcomps);
+ //tile->tcomps = 0;
+ }
+ if (tile->pi) {+ jpc_pi_destroy(tile->pi);
+ //tile->pi = 0;
+ }
+ if (tile->pkthdrstream) {+ jas_stream_close(tile->pkthdrstream);
+ //tile->pkthdrstream = 0;
+ }
+ if (tile->pptstab) {+ jpc_ppxstab_destroy(tile->pptstab);
+ //tile->pptstab = 0;
+ }
+
+ tile->state = JPC_TILE_DONE;
+
+ return 0;
+}
+
+static int jpc_dec_tiledecode(jpc_dec_t *dec, jpc_dec_tile_t *tile)
+{+ unsigned rlvlno;
+ int v;
+
+ if (jpc_dec_decodecblks(dec, tile)) {+ jas_eprintf("jpc_dec_decodecblks failed\n");+ return -1;
+ }
+
+ /* Perform dequantization. */
+ unsigned compno;
+ const jpc_dec_tcomp_t *tcomp;
+ for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
+ ++compno, ++tcomp) {+ const jpc_dec_ccp_t *ccp = &tile->cp->ccps[compno];
+ const jpc_dec_rlvl_t *rlvl;
+ for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno < tcomp->numrlvls;
+ ++rlvlno, ++rlvl) {+ if (!rlvl->bands) {+ continue;
+ }
+ unsigned bandno;
+ const jpc_dec_band_t *band;
+ for (bandno = 0, band = rlvl->bands;
+ bandno < rlvl->numbands; ++bandno, ++band) {+ if (!band->data) {+ continue;
+ }
+ jpc_undo_roi(band->data, band->roishift, ccp->roishift -
+ band->roishift, band->numbps);
+ if (ccp->qmfbid == JPC_COX_INS) {+ jas_matrix_asl(band->data, JPC_FIX_FRACBITS);
+ jpc_dequantize(band->data, band->absstepsize);
+ }
+
+ }
+ }
+ }
+
+ /* Apply an inverse wavelet transform if necessary. */
+ for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
+ ++compno, ++tcomp) {+ jpc_tsfb_synthesize(tcomp->tsfb, tcomp->data);
+ }
+
+
+ /* Apply an inverse intercomponent transform if necessary. */
+ switch (tile->cp->mctid) {+ case JPC_MCT_RCT:
+ if (dec->numcomps < 3) {+ jas_eprintf("RCT requires at least three components\n");+ return -1;
+ }
+ if (!jas_image_cmpt_domains_same(dec->image)) {+ jas_eprintf("RCT requires all components have the same domain\n");+ return -1;
+ }
+ jpc_irct(tile->tcomps[0].data, tile->tcomps[1].data,
+ tile->tcomps[2].data);
+ break;
+ case JPC_MCT_ICT:
+ if (dec->numcomps < 3) {+ jas_eprintf("ICT requires at least three components\n");+ return -1;
+ }
+ if (!jas_image_cmpt_domains_same(dec->image)) {+ jas_eprintf("RCT requires all components have the same domain\n");+ return -1;
+ }
+ jpc_iict(tile->tcomps[0].data, tile->tcomps[1].data,
+ tile->tcomps[2].data);
+ break;
+ }
+
+ /* Perform rounding and convert to integer values. */
+ for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
+ ++compno, ++tcomp) {+ const jpc_dec_ccp_t *ccp = &tile->cp->ccps[compno];
+ if (ccp->qmfbid == JPC_COX_INS) {+ jas_matrix_t *const data = tcomp->data;
+ const jas_matind_t height = jas_matrix_numrows(data);
+ const jas_matind_t numcols = jas_matrix_numcols(data);
+ for (jas_matind_t i = 0; i < height; ++i) {+ jpc_fix_t *p = jas_matrix_getref(data, i, 0);
+ for (jas_matind_t j = 0; j < numcols; ++j) {+ v = p[j];
+ v = jpc_fix_round(v);
+ p[j] = jpc_fixtoint(v);
+ }
+ }
+ }
+ }
+
+ /* Perform level shift. */
+ const jpc_dec_cmpt_t *cmpt;
+ for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
+ dec->numcomps; ++compno, ++tcomp, ++cmpt) {+ if (cmpt->sgnd)
+ continue;
+
+ jas_matrix_t *const data = tcomp->data;
+ const jas_matind_t width = jas_matrix_numcols(data);
+ const jas_matind_t height = jas_matrix_numrows(data);
+ const jas_seqent_t adjust = (jas_seqent_t)1 << (cmpt->prec - 1);
+ for (jas_matind_t i = 0; i < height; ++i) {+ jpc_fix_t *p = jas_matrix_getref(data, i, 0);
+ for (jas_matind_t j = 0; j < width; ++j) {+ p[j] += adjust;
+ }
+ }
+ }
+
+ /* Perform clipping. */
+ for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
+ dec->numcomps; ++compno, ++tcomp, ++cmpt) {+ if (cmpt->prec >= sizeof(jpc_fix_t) * 8 - 2 + cmpt->sgnd)
+ /* no need to clip, because the calculated
+ minimum/maximum values would overflow our
+ integer type anyway */
+ continue;
+
+ const jas_seqent_t mn = cmpt->sgnd
+ ? (-((jpc_fix_t)1 << (cmpt->prec - 1)))
+ : (0);
+ const jas_seqent_t mx = cmpt->sgnd
+ ? (((jpc_fix_t)1 << (cmpt->prec - 1)) - 1)
+ : (((jpc_fix_t)1 << cmpt->prec) - 1);
+ jas_matrix_clip(tcomp->data, mn, mx);
+ }
+
+ /* XXX need to free tsfb struct */
+
+ /* Write the data for each component of the image. */
+ for (compno = 0, tcomp = tile->tcomps, cmpt = dec->cmpts; compno <
+ dec->numcomps; ++compno, ++tcomp, ++cmpt) {+ if (jas_image_writecmpt(dec->image, compno, tcomp->xstart -
+ JPC_CEILDIV(dec->xstart, cmpt->hstep), tcomp->ystart -
+ JPC_CEILDIV(dec->ystart, cmpt->vstep), jas_matrix_numcols(
+ tcomp->data), jas_matrix_numrows(tcomp->data), tcomp->data)) {+ jas_eprintf("write component failed\n");+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int jpc_dec_process_eoc(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ jpc_dec_tile_t *tile;
+
+ /* Eliminate compiler warnings about unused variables. */
+ (void)ms;
+
+ unsigned tileno;
+ for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
+ ++tile) {+ if (tile->state == JPC_TILE_ACTIVE ||
+ tile->state == JPC_TILE_ACTIVELAST) {+ if (jpc_dec_tiledecode(dec, tile)) {+ return -1;
+ }
+ }
+ /* If the tile has not yet been finalized, finalize it. */
+ // OLD CODE: jpc_dec_tilefini(dec, tile);
+ if (tile->state != JPC_TILE_DONE) {+ jpc_dec_tilefini(dec, tile);
+ }
+ }
+
+ /* We are done processing the code stream. */
+ dec->state = JPC_MT;
+
+ return 1;
+}
+
+static int jpc_dec_process_siz(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ jpc_siz_t *siz = &ms->parms.siz;
+ jpc_dec_tile_t *tile;
+ jpc_dec_tcomp_t *tcomp;
+ jpc_dec_cmpt_t *cmpt;
+ size_t size;
+ size_t num_samples;
+ size_t num_samples_delta;
+
+ size_t total_samples;
+ if (!jas_safe_size_mul(siz->width, siz->height, &total_samples) ||
+ (dec->max_samples > 0 && total_samples > dec->max_samples)) {+ jas_eprintf("image too large\n");+ return -1;
+ }
+
+ size_t tile_samples;
+ if (!jas_safe_size_mul(siz->tilewidth, siz->tileheight, &tile_samples) ||
+ (dec->max_samples > 0 && tile_samples > dec->max_samples)) {+ jas_eprintf("tile too large\n");+ return -1;
+ }
+
+ dec->xstart = siz->xoff;
+ dec->ystart = siz->yoff;
+ dec->xend = siz->width;
+ dec->yend = siz->height;
+ dec->tilewidth = siz->tilewidth;
+ dec->tileheight = siz->tileheight;
+ dec->tilexoff = siz->tilexoff;
+ dec->tileyoff = siz->tileyoff;
+ dec->numcomps = siz->numcomps;
+
+ if (!(dec->cp = jpc_dec_cp_create(dec->numcomps))) {+ return -1;
+ }
+
+ if (!(dec->cmpts = jas_alloc2(dec->numcomps, sizeof(jpc_dec_cmpt_t)))) {+ return -1;
+ }
+
+ num_samples = 0;
+ unsigned compno;
+ for (compno = 0, cmpt = dec->cmpts; compno < dec->numcomps; ++compno,
+ ++cmpt) {+ cmpt->prec = siz->comps[compno].prec;
+ cmpt->sgnd = siz->comps[compno].sgnd;
+ cmpt->hstep = siz->comps[compno].hsamp;
+ cmpt->vstep = siz->comps[compno].vsamp;
+ cmpt->width = JPC_CEILDIV(dec->xend, cmpt->hstep) -
+ JPC_CEILDIV(dec->xstart, cmpt->hstep);
+ cmpt->height = JPC_CEILDIV(dec->yend, cmpt->vstep) -
+ JPC_CEILDIV(dec->ystart, cmpt->vstep);
+ cmpt->hsubstep = 0;
+ cmpt->vsubstep = 0;
+
+ if (!jas_safe_size_mul(cmpt->width, cmpt->height, &num_samples_delta)) {+ jas_eprintf("image too large\n");+ return -1;
+ }
+ if (!jas_safe_size_add(num_samples, num_samples_delta, &num_samples)) {+ jas_eprintf("image too large\n");+ return -1;
+ }
+ }
+
+ if (dec->max_samples > 0 && num_samples > dec->max_samples) {+ jas_eprintf("maximum number of samples exceeded (%zu > %zu)\n",+ num_samples, dec->max_samples);
+ return -1;
+ }
+
+ dec->image = 0;
+
+ dec->numhtiles = JPC_CEILDIV(dec->xend - dec->tilexoff, dec->tilewidth);
+ dec->numvtiles = JPC_CEILDIV(dec->yend - dec->tileyoff, dec->tileheight);
+ if (!jas_safe_size_mul(dec->numhtiles, dec->numvtiles, &size) ||
+ size > INT_MAX) {+ return -1;
+ }
+ if (dec->max_samples > 0 && size > dec->max_samples / 16 / 16) {+ /* avoid Denial of Service by a malicious input file
+ with millions of tiny tiles; if max_samples is
+ configured, then assume the tiles are at least
+ 16x16, and don't allow more than this number of
+ tiles */
+ return -1;
+ }
+ if (dec->max_samples > 0 && size > dec->max_samples / dec->numcomps / 16) {+ /* another DoS check: since each tile allocates an
+ array of components, this check attempts to catch
+ excessive tile*component numbers */
+ return -1;
+ }
+ dec->numtiles = size;
+ JAS_DBGLOG(10, ("numtiles = %d; numhtiles = %d; numvtiles = %d;\n",+ dec->numtiles, dec->numhtiles, dec->numvtiles));
+ if (!(dec->tiles = jas_alloc2(dec->numtiles, sizeof(jpc_dec_tile_t)))) {+ return -1;
+ }
+
+ unsigned tileno;
+ for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
+ ++tile) {+ /* initialize all tiles with JPC_TILE_DONE so
+ jpc_dec_destroy() knows which ones need a
+ jpc_dec_tilefini() call; they are not actually
+ "done", of course */
+ tile->state = JPC_TILE_DONE;
+ }
+
+ for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
+ ++tile) {+ const unsigned htileno = tileno % dec->numhtiles;
+ const unsigned vtileno = tileno / dec->numhtiles;
+ tile->realmode = 0;
+ tile->state = JPC_TILE_INIT;
+ tile->xstart = JAS_MAX(dec->tilexoff + htileno * dec->tilewidth,
+ dec->xstart);
+ tile->ystart = JAS_MAX(dec->tileyoff + vtileno * dec->tileheight,
+ dec->ystart);
+ tile->xend = JAS_MIN(dec->tilexoff + (htileno + 1) *
+ dec->tilewidth, dec->xend);
+ tile->yend = JAS_MIN(dec->tileyoff + (vtileno + 1) *
+ dec->tileheight, dec->yend);
+ tile->numparts = 0;
+ tile->partno = 0;
+ tile->pkthdrstream = 0;
+ tile->pptstab = 0;
+ tile->cp = 0;
+ tile->pi = 0;
+ if (!(tile->tcomps = jas_alloc2(dec->numcomps,
+ sizeof(jpc_dec_tcomp_t)))) {+ return -1;
+ }
+ for (compno = 0, cmpt = dec->cmpts, tcomp = tile->tcomps;
+ compno < dec->numcomps; ++compno, ++cmpt, ++tcomp) {+ tcomp->rlvls = 0;
+ tcomp->numrlvls = 0;
+ tcomp->data = 0;
+ tcomp->xstart = JPC_CEILDIV(tile->xstart, cmpt->hstep);
+ tcomp->ystart = JPC_CEILDIV(tile->ystart, cmpt->vstep);
+ tcomp->xend = JPC_CEILDIV(tile->xend, cmpt->hstep);
+ tcomp->yend = JPC_CEILDIV(tile->yend, cmpt->vstep);
+ tcomp->tsfb = 0;
+ }
+ }
+
+ dec->pkthdrstreams = 0;
+
+ /* We should expect to encounter other main header marker segments
+ or an SOT marker segment next. */
+ dec->state = JPC_MH;
+
+ return 0;
+}
+
+static int jpc_dec_process_cod(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ const jpc_cod_t *cod = &ms->parms.cod;
+ jpc_dec_tile_t *tile;
+
+ switch (dec->state) {+ case JPC_MH:
+ jpc_dec_cp_setfromcod(dec->cp, cod);
+ break;
+ case JPC_TPH:
+ if (!(tile = dec->curtile)) {+ return -1;
+ }
+ if (tile->partno != 0) {+ return -1;
+ }
+ jpc_dec_cp_setfromcod(tile->cp, cod);
+ break;
+ }
+ return 0;
+}
+
+static int jpc_dec_process_coc(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ const jpc_coc_t *coc = &ms->parms.coc;
+ jpc_dec_tile_t *tile;
+
+ if (coc->compno >= dec->numcomps) {+ jas_eprintf("invalid component number in COC marker segment\n");+ return -1;
+ }
+ switch (dec->state) {+ case JPC_MH:
+ jpc_dec_cp_setfromcoc(dec->cp, coc);
+ break;
+ case JPC_TPH:
+ if (!(tile = dec->curtile)) {+ return -1;
+ }
+ if (tile->partno > 0) {+ return -1;
+ }
+ jpc_dec_cp_setfromcoc(tile->cp, coc);
+ break;
+ }
+ return 0;
+}
+
+static int jpc_dec_process_rgn(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ const jpc_rgn_t *rgn = &ms->parms.rgn;
+ jpc_dec_tile_t *tile;
+
+ if (rgn->compno >= dec->numcomps) {+ jas_eprintf("invalid component number in RGN marker segment\n");+ return -1;
+ }
+ switch (dec->state) {+ case JPC_MH:
+ jpc_dec_cp_setfromrgn(dec->cp, rgn);
+ break;
+ case JPC_TPH:
+ if (!(tile = dec->curtile)) {+ return -1;
+ }
+ if (tile->partno > 0) {+ return -1;
+ }
+ jpc_dec_cp_setfromrgn(tile->cp, rgn);
+ break;
+ }
+
+ return 0;
+}
+
+static int jpc_dec_process_qcd(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ const jpc_qcd_t *qcd = &ms->parms.qcd;
+ jpc_dec_tile_t *tile;
+
+ switch (dec->state) {+ case JPC_MH:
+ jpc_dec_cp_setfromqcd(dec->cp, qcd);
+ break;
+ case JPC_TPH:
+ if (!(tile = dec->curtile)) {+ return -1;
+ }
+ if (tile->partno > 0) {+ return -1;
+ }
+ jpc_dec_cp_setfromqcd(tile->cp, qcd);
+ break;
+ }
+ return 0;
+}
+
+static int jpc_dec_process_qcc(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ const jpc_qcc_t *qcc = &ms->parms.qcc;
+ jpc_dec_tile_t *tile;
+
+ if (qcc->compno >= dec->numcomps) {+ jas_eprintf("invalid component number in QCC marker segment\n");+ return -1;
+ }
+ switch (dec->state) {+ case JPC_MH:
+ jpc_dec_cp_setfromqcc(dec->cp, qcc);
+ break;
+ case JPC_TPH:
+ if (!(tile = dec->curtile)) {+ return -1;
+ }
+ if (tile->partno > 0) {+ return -1;
+ }
+ jpc_dec_cp_setfromqcc(tile->cp, qcc);
+ break;
+ }
+ return 0;
+}
+
+static int jpc_dec_process_poc(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ const jpc_poc_t *poc = &ms->parms.poc;
+ jpc_dec_tile_t *tile;
+ switch (dec->state) {+ case JPC_MH:
+ if (jpc_dec_cp_setfrompoc(dec->cp, poc, 1)) {+ return -1;
+ }
+ break;
+ case JPC_TPH:
+ if (!(tile = dec->curtile)) {+ return -1;
+ }
+ if (!tile->partno) {+ if (jpc_dec_cp_setfrompoc(tile->cp, poc, (!tile->partno))) {+ return -1;
+ }
+ } else {+ jpc_pi_addpchgfrompoc(tile->pi, poc);
+ }
+ break;
+ }
+ return 0;
+}
+
+static int jpc_dec_process_ppm(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ jpc_ppm_t *ppm = &ms->parms.ppm;
+ jpc_ppxstabent_t *ppmstabent;
+
+ if (!dec->ppmstab) {+ if (!(dec->ppmstab = jpc_ppxstab_create())) {+ return -1;
+ }
+ }
+
+ if (!(ppmstabent = jpc_ppxstabent_create())) {+ return -1;
+ }
+ ppmstabent->ind = ppm->ind;
+ ppmstabent->data = ppm->data;
+ ppm->data = 0;
+ ppmstabent->len = ppm->len;
+ if (jpc_ppxstab_insert(dec->ppmstab, ppmstabent)) {+ jpc_ppxstabent_destroy(ppmstabent);
+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_dec_process_ppt(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ jpc_ppt_t *ppt = &ms->parms.ppt;
+ jpc_dec_tile_t *tile;
+ jpc_ppxstabent_t *pptstabent;
+
+ tile = dec->curtile;
+ if (!tile->pptstab) {+ if (!(tile->pptstab = jpc_ppxstab_create())) {+ return -1;
+ }
+ }
+ if (!(pptstabent = jpc_ppxstabent_create())) {+ return -1;
+ }
+ pptstabent->ind = ppt->ind;
+ pptstabent->data = ppt->data;
+ ppt->data = 0;
+ pptstabent->len = ppt->len;
+ if (jpc_ppxstab_insert(tile->pptstab, pptstabent)) {+ jpc_ppxstabent_destroy(pptstabent);
+ return -1;
+ }
+ return 0;
+}
+
+static int jpc_dec_process_com(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ /* Eliminate compiler warnings about unused variables. */
+ USED(dec);
+ USED(ms);
+
+ return 0;
+}
+
+static int jpc_dec_process_unk(jpc_dec_t *dec, jpc_ms_t *ms)
+{+ /* Eliminate compiler warnings about unused variables. */
+ USED(dec);
+
+ jas_eprintf("warning: ignoring unknown marker segment (0x%x)\n",+ ms->id);
+ return 0;
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static jpc_dec_cp_t *jpc_dec_cp_create(uint_fast16_t numcomps)
+{+ jpc_dec_cp_t *cp;
+ jpc_dec_ccp_t *ccp;
+
+ if (!(cp = jas_malloc(sizeof(jpc_dec_cp_t)))) {+ return 0;
+ }
+ cp->flags = 0;
+ cp->numcomps = numcomps;
+ cp->prgord = 0;
+ cp->numlyrs = 0;
+ cp->mctid = 0;
+ cp->csty = 0;
+ if (!(cp->ccps = jas_alloc2(cp->numcomps, sizeof(jpc_dec_ccp_t)))) {+ goto error;
+ }
+ if (!(cp->pchglist = jpc_pchglist_create())) {+ goto error;
+ }
+ unsigned compno;
+ for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
+ ++compno, ++ccp) {+ ccp->flags = 0;
+ ccp->numrlvls = 0;
+ ccp->cblkwidthexpn = 0;
+ ccp->cblkheightexpn = 0;
+ ccp->qmfbid = 0;
+ ccp->numstepsizes = 0;
+ ccp->numguardbits = 0;
+ ccp->roishift = 0;
+ ccp->cblkctx = 0;
+ }
+ return cp;
+error:
+ if (cp) {+ jpc_dec_cp_destroy(cp);
+ }
+ return 0;
+}
+
+static jpc_dec_cp_t *jpc_dec_cp_copy(const jpc_dec_cp_t *cp)
+{+ jpc_dec_cp_t *newcp;
+ jpc_dec_ccp_t *newccp;
+ const jpc_dec_ccp_t *ccp;
+
+ if (!(newcp = jpc_dec_cp_create(cp->numcomps))) {+ return 0;
+ }
+ newcp->flags = cp->flags;
+ newcp->prgord = cp->prgord;
+ newcp->numlyrs = cp->numlyrs;
+ newcp->mctid = cp->mctid;
+ newcp->csty = cp->csty;
+ jpc_pchglist_destroy(newcp->pchglist);
+ newcp->pchglist = 0;
+ if (!(newcp->pchglist = jpc_pchglist_copy(cp->pchglist))) {+ jas_free(newcp);
+ return 0;
+ }
+ unsigned compno;
+ for (compno = 0, newccp = newcp->ccps, ccp = cp->ccps;
+ compno < cp->numcomps;
+ ++compno, ++newccp, ++ccp) {+ *newccp = *ccp;
+ }
+ return newcp;
+}
+
+static void jpc_dec_cp_resetflags(jpc_dec_cp_t *cp)
+{+ jpc_dec_ccp_t *ccp;
+ cp->flags &= (JPC_CSET | JPC_QSET);
+
+ unsigned compno;
+ for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
+ ++compno, ++ccp) {+ ccp->flags = 0;
+ }
+}
+
+static void jpc_dec_cp_destroy(jpc_dec_cp_t *cp)
+{+ if (cp->ccps) {+ jas_free(cp->ccps);
+ }
+ if (cp->pchglist) {+ jpc_pchglist_destroy(cp->pchglist);
+ }
+ jas_free(cp);
+}
+
+static int jpc_dec_cp_isvalid(const jpc_dec_cp_t *cp)
+{+ uint_fast16_t compcnt;
+ const jpc_dec_ccp_t *ccp;
+
+ if (!(cp->flags & JPC_CSET) || !(cp->flags & JPC_QSET)) {+ return 0;
+ }
+ for (compcnt = cp->numcomps, ccp = cp->ccps; compcnt > 0; --compcnt,
+ ++ccp) {+ /* Is there enough step sizes for the number of bands? */
+ if ((ccp->qsty != JPC_QCX_SIQNT && JAS_CAST(int, ccp->numstepsizes) < 3 *
+ ccp->numrlvls - 2) || (ccp->qsty == JPC_QCX_SIQNT &&
+ ccp->numstepsizes != 1)) {+ return 0;
+ }
+ }
+ return 1;
+}
+
+static int calcstepsizes(uint_fast16_t refstepsize, unsigned numrlvls,
+ uint_fast16_t *stepsizes)
+{+ uint_fast16_t expn;
+ uint_fast16_t mant;
+ expn = JPC_QCX_GETEXPN(refstepsize);
+ mant = JPC_QCX_GETMANT(refstepsize);
+ const unsigned numbands = 3 * numrlvls - 2;
+ for (unsigned bandno = 0; bandno < numbands; ++bandno) {+//jas_eprintf("DEBUG %d %d %d %d %d\n", bandno, expn, numrlvls, bandno, ((numrlvls - 1) - (numrlvls - 1 - ((bandno > 0) ? ((bandno + 2) / 3) : (0)))));+ const unsigned r = (bandno + 2) / 3;
+ const unsigned nb = (r == 0) ? (numrlvls - 1) - r : (numrlvls - 1) - r + 1;
+ uint_fast16_t e = expn - (numrlvls - 1) + nb;
+ if (e >= 0x20)
+ return -1;
+ stepsizes[bandno] = JPC_QCX_MANT(mant) | JPC_QCX_EXPN(e);
+ }
+ return 0;
+}
+
+static int jpc_dec_cp_prepare(jpc_dec_cp_t *cp)
+{+ jpc_dec_ccp_t *ccp;
+ unsigned compno;
+ for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
+ ++compno, ++ccp) {+ if (!(ccp->csty & JPC_COX_PRT)) {+ for (unsigned i = 0; i < JPC_MAXRLVLS; ++i) {+ ccp->prcwidthexpns[i] = 15;
+ ccp->prcheightexpns[i] = 15;
+ }
+ }
+ if (ccp->qsty == JPC_QCX_SIQNT) {+ if (calcstepsizes(ccp->stepsizes[0], ccp->numrlvls, ccp->stepsizes)) {+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+static int jpc_dec_cp_setfromcod(jpc_dec_cp_t *cp, const jpc_cod_t *cod)
+{+ jpc_dec_ccp_t *ccp;
+ cp->flags |= JPC_CSET;
+ cp->prgord = cod->prg;
+ if (cod->mctrans) {+ cp->mctid = (cod->compparms.qmfbid == JPC_COX_INS) ? (JPC_MCT_ICT) : (JPC_MCT_RCT);
+ } else {+ cp->mctid = JPC_MCT_NONE;
+ }
+ cp->numlyrs = cod->numlyrs;
+ cp->csty = cod->csty & (JPC_COD_SOP | JPC_COD_EPH);
+ unsigned compno;
+ for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
+ ++compno, ++ccp) {+ jpc_dec_cp_setfromcox(cp, ccp, &cod->compparms, 0);
+ }
+ cp->flags |= JPC_CSET;
+ return 0;
+}
+
+static int jpc_dec_cp_setfromcoc(jpc_dec_cp_t *cp, const jpc_coc_t *coc)
+{+ jpc_dec_cp_setfromcox(cp, &cp->ccps[coc->compno], &coc->compparms, JPC_COC);
+ return 0;
+}
+
+static int jpc_dec_cp_setfromcox(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
+ const jpc_coxcp_t *compparms, unsigned flags)
+{+ int rlvlno;
+
+ /* Eliminate compiler warnings about unused variables. */
+ USED(cp);
+
+ if ((flags & JPC_COC) || !(ccp->flags & JPC_COC)) {+ ccp->numrlvls = compparms->numdlvls + 1;
+ ccp->cblkwidthexpn = JPC_COX_GETCBLKSIZEEXPN(
+ compparms->cblkwidthval);
+ ccp->cblkheightexpn = JPC_COX_GETCBLKSIZEEXPN(
+ compparms->cblkheightval);
+ ccp->qmfbid = compparms->qmfbid;
+ ccp->cblkctx = compparms->cblksty;
+ ccp->csty = compparms->csty & JPC_COX_PRT;
+ for (rlvlno = 0; rlvlno < compparms->numrlvls; ++rlvlno) {+ ccp->prcwidthexpns[rlvlno] =
+ compparms->rlvls[rlvlno].parwidthval;
+ ccp->prcheightexpns[rlvlno] =
+ compparms->rlvls[rlvlno].parheightval;
+ }
+ ccp->flags |= flags | JPC_CSET;
+ }
+ return 0;
+}
+
+static int jpc_dec_cp_setfromqcd(jpc_dec_cp_t *cp, const jpc_qcd_t *qcd)
+{+ unsigned compno;
+ jpc_dec_ccp_t *ccp;
+ for (compno = 0, ccp = cp->ccps; compno < cp->numcomps;
+ ++compno, ++ccp) {+ jpc_dec_cp_setfromqcx(cp, ccp, &qcd->compparms, 0);
+ }
+ cp->flags |= JPC_QSET;
+ return 0;
+}
+
+static int jpc_dec_cp_setfromqcc(jpc_dec_cp_t *cp, const jpc_qcc_t *qcc)
+{+ return jpc_dec_cp_setfromqcx(cp, &cp->ccps[qcc->compno], &qcc->compparms, JPC_QCC);
+}
+
+static int jpc_dec_cp_setfromqcx(jpc_dec_cp_t *cp, jpc_dec_ccp_t *ccp,
+ const jpc_qcxcp_t *compparms, unsigned flags)
+{+ int bandno;
+
+ /* Eliminate compiler warnings about unused variables. */
+ USED(cp);
+
+ /* Sanity check to prevent buffer overflow */
+ if (compparms->numstepsizes > (3 * JPC_MAXRLVLS + 1)) {+ return -1;
+ }
+
+ if ((flags & JPC_QCC) || !(ccp->flags & JPC_QCC)) {+ ccp->flags |= flags | JPC_QSET;
+ for (bandno = 0; bandno < compparms->numstepsizes; ++bandno) {+ ccp->stepsizes[bandno] = compparms->stepsizes[bandno];
+ }
+ ccp->numstepsizes = compparms->numstepsizes;
+ ccp->numguardbits = compparms->numguard;
+ ccp->qsty = compparms->qntsty;
+ }
+ return 0;
+}
+
+static int jpc_dec_cp_setfromrgn(jpc_dec_cp_t *cp, const jpc_rgn_t *rgn)
+{+ jpc_dec_ccp_t *ccp;
+ ccp = &cp->ccps[rgn->compno];
+ ccp->roishift = rgn->roishift;
+ return 0;
+}
+
+static int jpc_pi_addpchgfrompoc(jpc_pi_t *pi, const jpc_poc_t *poc)
+{+ int pchgno;
+ jpc_pchg_t *pchg;
+ for (pchgno = 0; pchgno < poc->numpchgs; ++pchgno) {+ if (!(pchg = jpc_pchg_copy(&poc->pchgs[pchgno]))) {+ return -1;
+ }
+ if (jpc_pchglist_insert(pi->pchglist, -1, pchg)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int jpc_dec_cp_setfrompoc(jpc_dec_cp_t *cp, const jpc_poc_t *poc, int reset)
+{+ int pchgno;
+ jpc_pchg_t *pchg;
+ if (reset) {+ while (jpc_pchglist_numpchgs(cp->pchglist) > 0) {+ pchg = jpc_pchglist_remove(cp->pchglist, 0);
+ jpc_pchg_destroy(pchg);
+ }
+ }
+ for (pchgno = 0; pchgno < poc->numpchgs; ++pchgno) {+ if (!(pchg = jpc_pchg_copy(&poc->pchgs[pchgno]))) {+ return -1;
+ }
+ if (jpc_pchglist_insert(cp->pchglist, -1, pchg)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static jpc_fix_t jpc_calcabsstepsize(unsigned stepsize, unsigned numbits)
+{+ jpc_fix_t absstepsize;
+ int n;
+
+ absstepsize = jpc_inttofix(1);
+ n = JPC_FIX_FRACBITS - 11;
+ absstepsize |= (n >= 0) ? (JPC_QCX_GETMANT(stepsize) << n) :
+ (JPC_QCX_GETMANT(stepsize) >> (-n));
+ n = numbits - JPC_QCX_GETEXPN(stepsize);
+ absstepsize = (n >= 0) ? (absstepsize << n) : (absstepsize >> (-n));
+ return absstepsize;
+}
+
+static void jpc_dequantize(jas_matrix_t *x, jpc_fix_t absstepsize)
+{+ // a reconstruction parameter defined in E 1.1.2 of the ISO/IEC 15444-1
+ jpc_fix_t recparam = JPC_FIX_HALF;
+
+ assert(absstepsize >= 0);
+ if (absstepsize == jpc_inttofix(1)) {+ return;
+ }
+
+ const jas_matind_t height = jas_matrix_numrows(x);
+ const size_t width = jas_matrix_numcols(x);
+
+ for (jas_matind_t i = 0; i < height; ++i) {+ jpc_fix_t *p = jas_matrix_getref(x, i, 0);
+ for (size_t j = 0; j < width; ++j) {+ jas_seqent_t t = p[j];
+ if (t) {+ // mid-point reconstruction
+ t = (t > 0) ? jpc_fix_add(t, recparam) : jpc_fix_sub(t, recparam);
+ t = jpc_fix_mul(t, absstepsize);
+ p[j] = t;
+ }
+ }
+ }
+
+}
+
+static void jpc_undo_roi(jas_matrix_t *x, int roishift, int bgshift, unsigned numbps)
+{+ int thresh;
+ jpc_fix_t val;
+ jpc_fix_t mag;
+ bool warn;
+ uint_fast32_t mask;
+
+ if (roishift < 0) {+ /* We could instead return an error here. */
+ /* I do not think it matters much. */
+ jas_eprintf("warning: forcing negative ROI shift to zero "+ "(bitstream is probably corrupt)\n");
+ roishift = 0;
+ }
+ if (roishift == 0 && bgshift == 0) {+ return;
+ }
+ thresh = 1 << roishift;
+
+ warn = false;
+
+ const jas_matind_t width = jas_matrix_numcols(x);
+ const jas_matind_t height = jas_matrix_numrows(x);
+ for (jas_matind_t i = 0; i < height; ++i) {+ jpc_fix_t *p = jas_matrix_getref(x, i, 0);
+ for (jas_matind_t j = 0; j < width; ++j, ++p) {+ val = *p;
+ mag = JAS_ABS(val);
+ if (mag >= thresh) {+ /* We are dealing with ROI data. */
+ mag >>= roishift;
+ val = (val < 0) ? (-mag) : mag;
+ *p = val;
+ } else {+ /* We are dealing with non-ROI (i.e., background) data. */
+ mag <<= bgshift;
+ mask = (JAS_CAST(uint_fast32_t, 1) << numbps) - 1;
+ /* Perform a basic sanity check on the sample value. */
+ /* Some implementations write garbage in the unused
+ most-significant bit planes introduced by ROI shifting.
+ Here we ensure that any such bits are masked off. */
+ if (mag & (~mask)) {+ if (!warn) {+ jas_eprintf("warning: possibly corrupt code stream\n");+ warn = true;
+ }
+ mag &= mask;
+ }
+ val = (val < 0) ? (-mag) : mag;
+ *p = val;
+ }
+ }
+ }
+}
+
+static jpc_dec_t *jpc_dec_create(jpc_dec_importopts_t *impopts, jas_stream_t *in)
+{+ jpc_dec_t *dec;
+
+ if (!(dec = jas_malloc(sizeof(jpc_dec_t)))) {+ return 0;
+ }
+
+ dec->image = 0;
+ dec->xstart = 0;
+ dec->ystart = 0;
+ dec->xend = 0;
+ dec->yend = 0;
+ dec->tilewidth = 0;
+ dec->tileheight = 0;
+ dec->tilexoff = 0;
+ dec->tileyoff = 0;
+ dec->numhtiles = 0;
+ dec->numvtiles = 0;
+ dec->numtiles = 0;
+ dec->tiles = 0;
+ dec->curtile = 0;
+ dec->numcomps = 0;
+ dec->in = in;
+ dec->cp = 0;
+ dec->maxlyrs = impopts->maxlyrs;
+ dec->maxpkts = impopts->maxpkts;
+dec->numpkts = 0;
+ dec->ppmseqno = 0;
+ dec->state = 0;
+ dec->cmpts = 0;
+ dec->pkthdrstreams = 0;
+ dec->ppmstab = 0;
+ dec->curtileendoff = 0;
+ dec->max_samples = impopts->max_samples;
+
+ return dec;
+}
+
+static void jpc_dec_destroy(jpc_dec_t *dec)
+{+ if (dec->cstate) {+ jpc_cstate_destroy(dec->cstate);
+ }
+ if (dec->pkthdrstreams) {+ jpc_streamlist_destroy(dec->pkthdrstreams);
+ }
+ if (dec->ppmstab) {+ jpc_ppxstab_destroy(dec->ppmstab);
+ }
+ if (dec->image) {+ jas_image_destroy(dec->image);
+ }
+
+ if (dec->cp) {+ jpc_dec_cp_destroy(dec->cp);
+ }
+
+ if (dec->cmpts) {+ jas_free(dec->cmpts);
+ }
+
+ if (dec->tiles) {+ unsigned tileno;
+ jpc_dec_tile_t *tile;
+
+ for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles; ++tileno,
+ ++tile) {+ if (tile->state != JPC_TILE_DONE) {+ jpc_dec_tilefini(dec, tile);
+ }
+ }
+
+ jas_free(dec->tiles);
+ }
+
+ jas_free(dec);
+}
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+void jpc_seglist_insert(jpc_dec_seglist_t *list, jpc_dec_seg_t *ins, jpc_dec_seg_t *node)
+{+ jpc_dec_seg_t *prev;
+ jpc_dec_seg_t *next;
+
+ prev = ins;
+ node->prev = prev;
+ next = prev ? (prev->next) : 0;
+ node->prev = prev;
+ node->next = next;
+ if (prev) {+ prev->next = node;
+ } else {+ list->head = node;
+ }
+ if (next) {+ next->prev = node;
+ } else {+ list->tail = node;
+ }
+}
+
+void jpc_seglist_remove(jpc_dec_seglist_t *list, jpc_dec_seg_t *seg)
+{+ jpc_dec_seg_t *prev;
+ jpc_dec_seg_t *next;
+
+ prev = seg->prev;
+ next = seg->next;
+ if (prev) {+ prev->next = next;
+ } else {+ list->head = next;
+ }
+ if (next) {+ next->prev = prev;
+ } else {+ list->tail = prev;
+ }
+ seg->prev = 0;
+ seg->next = 0;
+}
+
+jpc_dec_seg_t *jpc_seg_alloc()
+{+ jpc_dec_seg_t *seg;
+
+ if (!(seg = jas_malloc(sizeof(jpc_dec_seg_t)))) {+ return 0;
+ }
+ seg->prev = 0;
+ seg->next = 0;
+ seg->passno = -1;
+ seg->numpasses = 0;
+ seg->maxpasses = 0;
+ seg->type = JPC_SEG_INVALID;
+ seg->stream = 0;
+ seg->cnt = 0;
+ seg->complete = 0;
+ seg->lyrno = -1;
+ return seg;
+}
+
+void jpc_seg_destroy(jpc_dec_seg_t *seg)
+{+ if (seg->stream) {+ jas_stream_close(seg->stream);
+ }
+ jas_free(seg);
+}
+
+static int jpc_dec_dump(const jpc_dec_t *dec, FILE *out)
+{+ assert(!dec->numtiles || dec->tiles);
+ unsigned tileno;
+ const jpc_dec_tile_t *tile;
+ for (tileno = 0, tile = dec->tiles; tileno < dec->numtiles;
+ ++tileno, ++tile) {+ assert(!dec->numcomps || tile->tcomps);
+ unsigned compno;
+ const jpc_dec_tcomp_t *tcomp;
+ for (compno = 0, tcomp = tile->tcomps; compno < dec->numcomps;
+ ++compno, ++tcomp) {+ unsigned rlvlno;
+ const jpc_dec_rlvl_t *rlvl;
+ for (rlvlno = 0, rlvl = tcomp->rlvls; rlvlno <
+ tcomp->numrlvls; ++rlvlno, ++rlvl) {+ fprintf(out, "RESOLUTION LEVEL %d\n", rlvlno);
+ fprintf(out, "xs = %"PRIuFAST32", ys = %"PRIuFAST32", xe = %"PRIuFAST32", ye = %"PRIuFAST32", w = %"PRIuFAST32", h = %"PRIuFAST32"\n",
+ rlvl->xstart, rlvl->ystart, rlvl->xend, rlvl->yend,
+ rlvl->xend - rlvl->xstart, rlvl->yend - rlvl->ystart);
+ assert(!rlvl->numbands || rlvl->bands);
+ unsigned bandno;
+ const jpc_dec_band_t *band;
+ for (bandno = 0, band = rlvl->bands;
+ bandno < rlvl->numbands; ++bandno, ++band) {+ fprintf(out, "BAND %d\n", bandno);
+ if (!band->data) {+ fprintf(out, "band has no data (null pointer)\n");
+ assert(!band->prcs);
+ continue;
+ }
+ fprintf(out, "xs = %"PRIjas_seqent", ys = %"PRIjas_seqent", xe = %"PRIjas_seqent", ye = %"PRIjas_seqent", w = %"PRIjas_seqent", h = %"PRIjas_seqent"\n",
+ jas_seq2d_xstart(band->data),
+ jas_seq2d_ystart(band->data),
+ jas_seq2d_xend(band->data),
+ jas_seq2d_yend(band->data),
+ jas_seq2d_xend(band->data) -
+ jas_seq2d_xstart(band->data),
+ jas_seq2d_yend(band->data) -
+ jas_seq2d_ystart(band->data));
+ assert(!rlvl->numprcs || band->prcs);
+ unsigned prcno;
+ const jpc_dec_prc_t *prc;
+ for (prcno = 0, prc = band->prcs;
+ prcno < rlvl->numprcs; ++prcno,
+ ++prc) {+ fprintf(out, "CODE BLOCK GROUP %d\n", prcno);
+ fprintf(out, "xs = %"PRIuFAST32", ys = %"PRIuFAST32", xe = %"PRIuFAST32", ye = %"PRIuFAST32", w = %"PRIuFAST32", h = %"PRIuFAST32"\n",
+ prc->xstart, prc->ystart, prc->xend, prc->yend,
+ prc->xend - prc->xstart, prc->yend - prc->ystart);
+ assert(!prc->numcblks || prc->cblks);
+ unsigned cblkno;
+ const jpc_dec_cblk_t *cblk;
+ for (cblkno = 0, cblk =
+ prc->cblks; cblkno <
+ prc->numcblks; ++cblkno,
+ ++cblk) {+ fprintf(out, "CODE BLOCK %d\n", cblkno);
+ fprintf(out, "xs = %"PRIjas_seqent", ys = %"PRIjas_seqent", xe = %"PRIjas_seqent", ye = %"PRIjas_seqent", w = %"PRIjas_seqent", h = %"PRIjas_seqent"\n",
+ jas_seq2d_xstart(cblk->data),
+ jas_seq2d_ystart(cblk->data),
+ jas_seq2d_xend(cblk->data),
+ jas_seq2d_yend(cblk->data),
+ jas_seq2d_xend(cblk->data) -
+ jas_seq2d_xstart(cblk->data),
+ jas_seq2d_yend(cblk->data) -
+ jas_seq2d_ystart(cblk->data));
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+static jpc_streamlist_t *jpc_streamlist_create()
+{+ jpc_streamlist_t *streamlist;
+
+ if (!(streamlist = jas_malloc(sizeof(jpc_streamlist_t)))) {+ return 0;
+ }
+ streamlist->numstreams = 0;
+ streamlist->maxstreams = 100;
+ if (!(streamlist->streams = jas_alloc2(streamlist->maxstreams,
+ sizeof(jas_stream_t *)))) {+ jas_free(streamlist);
+ return 0;
+ }
+ for (unsigned i = 0; i < streamlist->maxstreams; ++i) {+ streamlist->streams[i] = 0;
+ }
+ return streamlist;
+}
+
+static int jpc_streamlist_insert(jpc_streamlist_t *streamlist, unsigned streamno,
+ jas_stream_t *stream)
+{+ jas_stream_t **newstreams;
+ /* Grow the array of streams if necessary. */
+ if (streamlist->numstreams >= streamlist->maxstreams) {+ const unsigned newmaxstreams = streamlist->maxstreams + 1024;
+ if (!(newstreams = jas_realloc2(streamlist->streams,
+ (newmaxstreams + 1024), sizeof(jas_stream_t *)))) {+ return -1;
+ }
+ for (unsigned i = streamlist->numstreams; i < streamlist->maxstreams; ++i) {+ streamlist->streams[i] = 0;
+ }
+ streamlist->maxstreams = newmaxstreams;
+ streamlist->streams = newstreams;
+ }
+ if (streamno != streamlist->numstreams) {+ /* Can only handle insertion at start of list. */
+ return -1;
+ }
+ streamlist->streams[streamno] = stream;
+ ++streamlist->numstreams;
+ return 0;
+}
+
+static jas_stream_t *jpc_streamlist_remove(jpc_streamlist_t *streamlist, unsigned streamno)
+{+ assert(streamno < streamlist->numstreams);
+
+ jas_stream_t *stream;
+ stream = streamlist->streams[streamno];
+ for (unsigned i = streamno + 1; i < streamlist->numstreams; ++i) {+ streamlist->streams[i - 1] = streamlist->streams[i];
+ }
+ --streamlist->numstreams;
+ return stream;
+}
+
+static void jpc_streamlist_destroy(jpc_streamlist_t *streamlist)
+{+ if (streamlist->streams) {+ for (unsigned streamno = 0; streamno < streamlist->numstreams;
+ ++streamno) {+ jas_stream_close(streamlist->streams[streamno]);
+ }
+ jas_free(streamlist->streams);
+ }
+ jas_free(streamlist);
+}
+
+static int jpc_streamlist_numstreams(jpc_streamlist_t *streamlist)
+{+ return streamlist->numstreams;
+}
+
+static jpc_ppxstab_t *jpc_ppxstab_create()
+{+ jpc_ppxstab_t *tab;
+
+ if (!(tab = jas_malloc(sizeof(jpc_ppxstab_t)))) {+ return 0;
+ }
+ tab->numents = 0;
+ tab->maxents = 0;
+ tab->ents = 0;
+ return tab;
+}
+
+static void jpc_ppxstab_destroy(jpc_ppxstab_t *tab)
+{+ for (unsigned i = 0; i < tab->numents; ++i) {+ jpc_ppxstabent_destroy(tab->ents[i]);
+ }
+ if (tab->ents) {+ jas_free(tab->ents);
+ }
+ jas_free(tab);
+}
+
+static int jpc_ppxstab_grow(jpc_ppxstab_t *tab, unsigned maxents)
+{+ jpc_ppxstabent_t **newents;
+ if (tab->maxents < maxents) {+ newents = (tab->ents) ? jas_realloc2(tab->ents, maxents,
+ sizeof(jpc_ppxstabent_t *)) : jas_alloc2(maxents, sizeof(jpc_ppxstabent_t *));
+ if (!newents) {+ return -1;
+ }
+ tab->ents = newents;
+ tab->maxents = maxents;
+ }
+ return 0;
+}
+
+static int jpc_ppxstab_insert(jpc_ppxstab_t *tab, jpc_ppxstabent_t *ent)
+{+ unsigned i;
+
+ for (i = 0; i < tab->numents; ++i) {+ if (tab->ents[i]->ind > ent->ind) {+ break;
+ }
+ }
+ const unsigned inspt = i;
+
+ if (tab->numents >= tab->maxents) {+ if (jpc_ppxstab_grow(tab, tab->maxents + 128)) {+ return -1;
+ }
+ }
+
+ for (i = tab->numents; i > inspt; --i) {+ tab->ents[i] = tab->ents[i - 1];
+ }
+ tab->ents[i] = ent;
+ ++tab->numents;
+
+ return 0;
+}
+
+static jpc_streamlist_t *jpc_ppmstabtostreams(jpc_ppxstab_t *tab)
+{+ jpc_streamlist_t *streams;
+ uint_fast32_t datacnt;
+ uint_fast32_t tpcnt;
+ jas_stream_t *stream;
+
+ if (!(streams = jpc_streamlist_create())) {+ goto error;
+ }
+
+ if (!tab->numents) {+ return streams;
+ }
+
+ unsigned entno = 0;
+ const jpc_ppxstabent_t *ent = tab->ents[entno];
+ const jas_uchar *dataptr = ent->data;
+ datacnt = ent->len;
+ for (;;) {+
+ /* Get the length of the packet header data for the current
+ tile-part. */
+ if (datacnt < 4) {+ goto error;
+ }
+ if (!(stream = jas_stream_memopen(0, 0))) {+ goto error;
+ }
+ if (jpc_streamlist_insert(streams, jpc_streamlist_numstreams(streams),
+ stream)) {+ goto error;
+ }
+ tpcnt = ((uint_least32_t)dataptr[0] << 24) | ((uint_least32_t)dataptr[1] << 16) | ((uint_least32_t)dataptr[2] << 8)
+ | (uint_least32_t)dataptr[3];
+ datacnt -= 4;
+ dataptr += 4;
+
+ /* Get the packet header data for the current tile-part. */
+ while (tpcnt) {+ if (!datacnt) {+ if (++entno >= tab->numents) {+ goto error;
+ }
+ ent = tab->ents[entno];
+ dataptr = ent->data;
+ datacnt = ent->len;
+ }
+ const size_t n = JAS_MIN(tpcnt, datacnt);
+ if (jas_stream_write(stream, dataptr, n) != n) {+ goto error;
+ }
+ tpcnt -= n;
+ dataptr += n;
+ datacnt -= n;
+ }
+ jas_stream_rewind(stream);
+ if (!datacnt) {+ if (++entno >= tab->numents) {+ break;
+ }
+ ent = tab->ents[entno];
+ dataptr = ent->data;
+ datacnt = ent->len;
+ }
+ }
+
+ return streams;
+
+error:
+ if (streams) {+ jpc_streamlist_destroy(streams);
+ }
+ return 0;
+}
+
+static int jpc_pptstabwrite(jas_stream_t *out, jpc_ppxstab_t *tab)
+{+ for (unsigned i = 0; i < tab->numents; ++i) {+ const jpc_ppxstabent_t *ent = tab->ents[i];
+ if (jas_stream_write(out, ent->data, ent->len) != ent->len) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+static jpc_ppxstabent_t *jpc_ppxstabent_create()
+{+ jpc_ppxstabent_t *ent;
+ if (!(ent = jas_malloc(sizeof(jpc_ppxstabent_t)))) {+ return 0;
+ }
+ ent->data = 0;
+ ent->len = 0;
+ ent->ind = 0;
+ return ent;
+}
+
+static void jpc_ppxstabent_destroy(jpc_ppxstabent_t *ent)
+{+ if (ent->data) {+ jas_free(ent->data);
+ }
+ jas_free(ent);
+}
--- /dev/null
+++ b/jpc_dec.h
@@ -1,0 +1,687 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * JPEG-2000 Decoder
+ *
+ * $Id$
+ */
+
+#ifndef JPC_DEC_H
+#define JPC_DEC_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_stream.h"
+#include "jasper/jas_image.h"
+
+#include "jpc_tsfb.h"
+#include "jpc_tagtree.h"
+#include "jpc_cs.h"
+#include "jpc_t1cod.h"
+#include "jpc_t2cod.h"
+
+/******************************************************************************\
+* Below are some ugly warts necessary to support packed packet headers.
+\******************************************************************************/
+
+/* PPM/PPT marker segment table entry. */
+
+typedef struct {+
+ /* The index for this entry. */
+ uint_fast16_t ind;
+
+ /* The data length. */
+ uint_fast32_t len;
+
+ /* The data. */
+ jas_uchar *data;
+
+} jpc_ppxstabent_t;
+
+/* PPM/PPT marker segment table. */
+
+typedef struct {+
+ /* The number of entries. */
+ unsigned numents;
+
+ /* The maximum number of entries (i.e., the allocated size of the array
+ below). */
+ unsigned maxents;
+
+ /* The table entries. */
+ jpc_ppxstabent_t **ents;
+
+} jpc_ppxstab_t;
+
+/* Stream list class. */
+
+typedef struct {+
+ /* The number of streams in this list. */
+ unsigned numstreams;
+
+ /* The maximum number of streams that can be accomodated without
+ growing the streams array. */
+ unsigned maxstreams;
+
+ /* The streams. */
+ jas_stream_t **streams;
+
+} jpc_streamlist_t;
+
+/******************************************************************************\
+* Coding parameters class.
+\******************************************************************************/
+
+/* Per-component coding parameters. */
+
+typedef struct {+
+ /* How were various coding parameters set? */
+ unsigned flags;
+
+ /* Per-component coding style parameters (e.g., explicit precinct sizes) */
+ uint_fast8_t csty;
+
+ /* The number of resolution levels. */
+ uint_fast8_t numrlvls;
+
+ /* The code block width exponent. */
+ uint_fast8_t cblkwidthexpn;
+
+ /* The code block height exponent. */
+ uint_fast8_t cblkheightexpn;
+
+ /* The QMFB ID. */
+ uint_fast8_t qmfbid;
+
+ /* The quantization style. */
+ uint_fast8_t qsty;
+
+ /* The number of quantizer step sizes. */
+ uint_fast16_t numstepsizes;
+
+ /* The step sizes. */
+ uint_fast16_t stepsizes[3 * JPC_MAXRLVLS + 1];
+
+ /* The number of guard bits. */
+ uint_fast8_t numguardbits;
+
+ /* The ROI shift value. */
+ uint_fast8_t roishift;
+
+ /* The code block parameters. */
+ uint_fast8_t cblkctx;
+
+ /* The precinct width exponents. */
+ uint_fast8_t prcwidthexpns[JPC_MAXRLVLS];
+
+ /* The precinct height exponents. */
+ uint_fast8_t prcheightexpns[JPC_MAXRLVLS];
+
+} jpc_dec_ccp_t;
+
+/* Coding paramters. */
+
+typedef struct {+
+ /* How were these coding parameters set? */
+ unsigned flags;
+
+ /* Progression change list. */
+ jpc_pchglist_t *pchglist;
+
+ /* Progression order. */
+ uint_fast8_t prgord;
+
+ /* The number of layers. */
+ uint_fast16_t numlyrs;
+
+ /* The MCT ID. */
+ uint_fast8_t mctid;
+
+ /* The coding style parameters (e.g., SOP, EPH). */
+ uint_fast8_t csty;
+
+ /* The number of components. */
+ unsigned numcomps;
+
+ /* The per-component coding parameters. */
+ jpc_dec_ccp_t *ccps;
+
+} jpc_dec_cp_t;
+
+/******************************************************************************\
+* Decoder class.
+\******************************************************************************/
+
+/* Decoder per-segment state information. */
+
+typedef struct jpc_dec_seg_s {+
+ /* The next segment in the list. */
+ struct jpc_dec_seg_s *next;
+
+ /* The previous segment in the list. */
+ struct jpc_dec_seg_s *prev;
+
+ /* The starting pass number for this segment. */
+ unsigned passno;
+
+ /* The number of passes in this segment. */
+ unsigned numpasses;
+
+ /* The maximum number of passes in this segment. */
+ unsigned maxpasses;
+
+ /* The type of data in this segment (i.e., MQ or raw). */
+ enum jpc_segtype type;
+
+ /* A stream containing the data for this segment. */
+ jas_stream_t *stream;
+
+ /* The number of bytes destined for this segment from the packet
+ currently being decoded. */
+ unsigned cnt;
+
+ /* A flag indicating if this segment has been terminated. */
+ int complete;
+
+ /* The layer number to which this segment belongs. */
+ /* If the segment spans multiple layers, then the largest layer number
+ spanned by the segment is used. */
+ unsigned lyrno;
+
+} jpc_dec_seg_t;
+
+/* Decoder segment list. */
+
+typedef struct {+
+ /* The first entry in the list. */
+ jpc_dec_seg_t *head;
+
+ /* The last entry in the list. */
+ jpc_dec_seg_t *tail;
+
+} jpc_dec_seglist_t;
+
+/* Decoder per-code-block state information. */
+
+typedef struct {+
+ /* The number of passes. */
+ unsigned numpasses;
+
+ /* A list of segments that still need to be decoded. */
+ jpc_dec_seglist_t segs;
+
+ /* The first incomplete/partial segment. */
+ jpc_dec_seg_t *curseg;
+
+ /* The number of leading insignificant bit planes for this code block. */
+ unsigned numimsbs;
+
+ /* The number of bits used to encode pass data lengths. */
+ unsigned numlenbits;
+
+ /* The first pass number containing data for this code block. */
+ unsigned firstpassno;
+
+ /* The sample data associated with this code block. */
+ jas_matrix_t *data;
+
+} jpc_dec_cblk_t;
+
+/* Decoder per-code-block-group state information. */
+
+typedef struct {+
+ /* The x-coordinate of the top-left corner of the precinct. */
+ uint_fast32_t xstart;
+
+ /* The y-coordinate of the top-left corner of the precinct. */
+ uint_fast32_t ystart;
+
+ /* The x-coordinate of the bottom-right corner of the precinct
+ (plus one). */
+ uint_fast32_t xend;
+
+ /* The y-coordinate of the bottom-right corner of the precinct
+ (plus one). */
+ uint_fast32_t yend;
+
+ /* The number of code blocks spanning this precinct in the horizontal
+ direction. */
+ unsigned numhcblks;
+
+ /* The number of code blocks spanning this precinct in the vertical
+ direction. */
+ unsigned numvcblks;
+
+ /* The total number of code blocks in this precinct. */
+ unsigned numcblks;
+
+ /* The per code block information. */
+ jpc_dec_cblk_t *cblks;
+
+ /* The inclusion tag tree. */
+ jpc_tagtree_t *incltagtree;
+
+ /* The insignificant MSBs tag tree. */
+ jpc_tagtree_t *numimsbstagtree;
+
+} jpc_dec_prc_t;
+
+/* Decoder per-band state information. */
+
+typedef struct {+
+ /* The per-code-block-group state information. */
+ jpc_dec_prc_t *prcs;
+
+ /* The sample data associated with this band. */
+ jas_matrix_t *data;
+
+ /* The orientation of this band (i.e., LL, LH, HL, or HH). */
+ enum jpc_tsfb_orient orient;
+
+ /* The encoded quantizer step size. */
+ unsigned stepsize;
+
+ /* The absolute quantizer step size. */
+ jpc_fix_t absstepsize;
+
+ /* The number of bit planes for this band. */
+ unsigned numbps;
+
+ /* The analysis gain associated with this band. */
+ int analgain;
+
+ /* The ROI shift value for this band. */
+ int roishift;
+
+} jpc_dec_band_t;
+
+/* Decoder per-resolution-level state information. */
+
+typedef struct {+
+ /* The number of bands associated with this resolution level. */
+ unsigned numbands;
+
+ /* The per-band information. */
+ jpc_dec_band_t *bands;
+
+ /* The x-coordinate of the top-left corner of the tile-component
+ at this resolution. */
+ uint_fast32_t xstart;
+
+ /* The y-coordinate of the top-left corner of the tile-component
+ at this resolution. */
+ uint_fast32_t ystart;
+
+ /* The x-coordinate of the bottom-right corner of the tile-component
+ at this resolution (plus one). */
+ uint_fast32_t xend;
+
+ /* The y-coordinate of the bottom-right corner of the tile-component
+ at this resolution (plus one). */
+ uint_fast32_t yend;
+
+ /* The exponent value for the nominal precinct width measured
+ relative to the associated LL band. */
+ unsigned prcwidthexpn;
+
+ /* The exponent value for the nominal precinct height measured
+ relative to the associated LL band. */
+ unsigned prcheightexpn;
+
+ /* The number of precincts in the horizontal direction. */
+ unsigned numhprcs;
+
+ /* The number of precincts in the vertical direction. */
+ unsigned numvprcs;
+
+ /* The total number of precincts. */
+ unsigned numprcs;
+
+ /* The exponent value for the nominal code block group width.
+ This quantity is associated with the next lower resolution level
+ (assuming that there is one). */
+ unsigned cbgwidthexpn;
+
+ /* The exponent value for the nominal code block group height
+ This quantity is associated with the next lower resolution level
+ (assuming that there is one). */
+ unsigned cbgheightexpn;
+
+ /* The exponent value for the code block width. */
+ uint_fast16_t cblkwidthexpn;
+
+ /* The exponent value for the code block height. */
+ uint_fast16_t cblkheightexpn;
+
+} jpc_dec_rlvl_t;
+
+/* Decoder per-tile-component state information. */
+
+typedef struct {+
+ /* The x-coordinate of the top-left corner of the tile-component
+ in the coordinate system of the tile-component. */
+ uint_fast32_t xstart;
+
+ /* The y-coordinate of the top-left corner of the tile-component
+ in the coordinate system of the tile-component. */
+ uint_fast32_t ystart;
+
+ /* The x-coordinate of the bottom-right corner of the tile-component
+ in the coordinate system of the tile-component (plus one). */
+ uint_fast32_t xend;
+
+ /* The y-coordinate of the bottom-right corner of the tile-component
+ in the coordinate system of the tile-component (plus one). */
+ uint_fast32_t yend;
+
+ /* The component data for the current tile. */
+ jas_matrix_t *data;
+
+ /* The number of resolution levels. */
+ unsigned numrlvls;
+
+ /* The per resolution level information. */
+ jpc_dec_rlvl_t *rlvls;
+
+ /* The TSFB. */
+ jpc_tsfb_t *tsfb;
+
+} jpc_dec_tcomp_t;
+
+/*
+ * Tile states.
+ */
+
+#define JPC_TILE_INIT 0
+#define JPC_TILE_ACTIVE 1
+#define JPC_TILE_ACTIVELAST 2
+#define JPC_TILE_DONE 3
+
+/* Decoder per-tile state information. */
+
+typedef struct {+
+ /* The processing state for this tile. */
+ int state;
+
+ /* The x-coordinate of the top-left corner of the tile on the reference
+ grid. */
+ uint_fast32_t xstart;
+
+ /* The y-coordinate of the top-left corner of the tile on the reference
+ grid. */
+ uint_fast32_t ystart;
+
+ /* The x-coordinate of the bottom-right corner of the tile on the
+ reference grid (plus one). */
+ uint_fast32_t xend;
+
+ /* The y-coordinate of the bottom-right corner of the tile on the
+ reference grid (plus one). */
+ uint_fast32_t yend;
+
+ /* The packed packet header data for this tile. */
+ jpc_ppxstab_t *pptstab;
+
+ /* A stream containing the packed packet header data for this tile. */
+ jas_stream_t *pkthdrstream;
+
+ /* The coding parameters for this tile. */
+ jpc_dec_cp_t *cp;
+
+ /* The per tile-component information. */
+ jpc_dec_tcomp_t *tcomps;
+
+ /* The next expected tile-part number. */
+ unsigned partno;
+
+ /* The number of tile-parts. */
+ unsigned numparts;
+
+ /* The coding mode. */
+ int realmode;
+
+ /* The packet iterator for this tile. */
+ jpc_pi_t *pi;
+
+} jpc_dec_tile_t;
+
+/* Decoder per-component state information. */
+
+typedef struct {+
+ /* The horizontal sampling period. */
+ uint_fast32_t hstep;
+
+ /* The vertical sampling period. */
+ uint_fast32_t vstep;
+
+ /* The number of samples in the horizontal direction. */
+ uint_fast32_t width;
+
+ /* The number of samples in the vertical direction. */
+ uint_fast32_t height;
+
+ /* The precision of the sample data. */
+ uint_fast16_t prec;
+
+ /* The signedness of the sample data. */
+ bool sgnd;
+
+ /* The sample alignment horizontal offset. */
+ uint_fast32_t hsubstep;
+
+ /* The sample alignment vertical offset. */
+ uint_fast32_t vsubstep;
+
+} jpc_dec_cmpt_t;
+
+/* Decoder state information. */
+
+typedef struct {+
+ /* The decoded image. */
+ jas_image_t *image;
+
+ /* The x-coordinate of the top-left corner of the image area on
+ the reference grid. */
+ uint_fast32_t xstart;
+
+ /* The y-coordinate of the top-left corner of the image area on
+ the reference grid. */
+ uint_fast32_t ystart;
+
+ /* The x-coordinate of the bottom-right corner of the image area on
+ the reference grid (plus one). */
+ uint_fast32_t xend;
+
+ /* The y-coordinate of the bottom-right corner of the image area on
+ the reference grid (plus one). */
+ uint_fast32_t yend;
+
+ /* The nominal tile width in units of the image reference grid. */
+ uint_fast32_t tilewidth;
+
+ /* The nominal tile height in units of the image reference grid. */
+ uint_fast32_t tileheight;
+
+ /* The horizontal offset from the origin of the reference grid to the
+ left side of the first tile. */
+ uint_fast32_t tilexoff;
+
+ /* The vertical offset from the origin of the reference grid to the
+ top side of the first tile. */
+ uint_fast32_t tileyoff;
+
+ /* The number of tiles spanning the image area in the vertical
+ direction. */
+ unsigned numhtiles;
+
+ /* The number of tiles spanning the image area in the horizontal
+ direction. */
+ unsigned numvtiles;
+
+ /* The total number of tiles. */
+ unsigned numtiles;
+
+ /* The per-tile information. */
+ jpc_dec_tile_t *tiles;
+
+ /* The tile currently being processed. */
+ jpc_dec_tile_t *curtile;
+
+ /* The number of components. */
+ unsigned numcomps;
+
+ /* The stream containing the input JPEG-2000 code stream data. */
+ jas_stream_t *in;
+
+ /* The default coding parameters for all tiles. */
+ jpc_dec_cp_t *cp;
+
+ /* The maximum number of layers that may be decoded. */
+ unsigned maxlyrs;
+
+ /* The maximum number of packets that may be decoded. */
+ int maxpkts;
+
+ /* The number of packets decoded so far in the processing of the entire
+ code stream. */
+ unsigned numpkts;
+
+ /* The next expected PPM marker segment sequence number. */
+ unsigned ppmseqno;
+
+ /* The current state for code stream processing. */
+ int state;
+
+ /* The per-component information. */
+ jpc_dec_cmpt_t *cmpts;
+
+ /* The information from PPM marker segments. */
+ jpc_ppxstab_t *ppmstab;
+
+ /* A list of streams containing packet header data from PPM marker
+ segments. */
+ jpc_streamlist_t *pkthdrstreams;
+
+ /* The expected ending offset for a tile-part. */
+ long curtileendoff;
+
+ /* This is required by the tier-2 decoder. */
+ jpc_cstate_t *cstate;
+
+ size_t max_samples;
+
+} jpc_dec_t;
+
+/* Decoder options. */
+
+typedef struct {+
+ /* The debug level for the decoder. */
+ int debug;
+
+ /* The maximum number of layers to decode. */
+ unsigned maxlyrs;
+
+ /* The maximum number of packets to decode. */
+ int maxpkts;
+
+ size_t max_samples;
+
+} jpc_dec_importopts_t;
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Create a decoder segment object. */
+jpc_dec_seg_t *jpc_seg_alloc(void);
+
+/* Destroy a decoder segment object. */
+void jpc_seg_destroy(jpc_dec_seg_t *seg);
+
+/* Remove a segment from a segment list. */
+void jpc_seglist_remove(jpc_dec_seglist_t *list, jpc_dec_seg_t *node);
+
+/* Insert a segment into a segment list. */
+void jpc_seglist_insert(jpc_dec_seglist_t *list, jpc_dec_seg_t *ins,
+ jpc_dec_seg_t *node);
+
+#endif
--- /dev/null
+++ b/jpc_fix.h
@@ -1,0 +1,231 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Fixed-Point Number Class
+ *
+ * $Id$
+ */
+
+#ifndef JPC_FIX_H
+#define JPC_FIX_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_config.h"
+#include "jasper/jas_types.h"
+#include "jasper/jas_fix.h"
+#include "jasper/jas_math.h"
+
+/******************************************************************************\
+* Basic parameters of the fixed-point type.
+\******************************************************************************/
+
+/* The integral type used to represent a fixed-point number. This
+ type must be capable of representing values from -(2^31) to 2^31-1
+ (inclusive). */
+#ifdef JAS_ENABLE_32BIT
+typedef int_least32_t jpc_fix_t;
+#else
+typedef int_fast32_t jpc_fix_t;
+#endif
+
+/* The integral type used to respresent higher-precision intermediate results.
+ This type should be capable of representing values from -(2^63) to 2^63-1
+ (inclusive). */
+typedef int_fast64_t jpc_fix_big_t;
+
+/* The number of bits used for the fractional part of a fixed-point number. */
+#define JPC_FIX_FRACBITS 13
+
+/******************************************************************************\
+* Instantiations of the generic fixed-point number macros for the
+* parameters given above. (Too bad C does not support templates, eh?)
+* The purpose of these macros is self-evident if one examines the
+* corresponding macros in the jasper/jas_fix.h header file.
+\******************************************************************************/
+
+#define JPC_FIX_ZERO JAS_FIX_ZERO(jpc_fix_t, JPC_FIX_FRACBITS)
+#define JPC_FIX_ONE JAS_FIX_ONE(jpc_fix_t, JPC_FIX_FRACBITS)
+#define JPC_FIX_HALF JAS_FIX_HALF(jpc_fix_t, JPC_FIX_FRACBITS)
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_inttofix(int x)
+{+ return JAS_INTTOFIX(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline int jpc_fixtoint(jpc_fix_t x)
+{+ return JAS_FIXTOINT(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline double jpc_fixtodbl(jpc_fix_t x)
+{+ return JAS_FIXTODBL(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_dbltofix(double x)
+{+ return JAS_DBLTOFIX(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_add(jpc_fix_t x, jpc_fix_t y)
+{+ return JAS_FIX_ADD(jpc_fix_t, JPC_FIX_FRACBITS, x, y);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_sub(jpc_fix_t x, jpc_fix_t y)
+{+ return JAS_FIX_SUB(jpc_fix_t, JPC_FIX_FRACBITS, x, y);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_mul(jpc_fix_big_t x, jpc_fix_big_t y)
+{+ return JAS_FIX_MUL(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_big_t jpc_fix_mulbyint(jpc_fix_big_t x, int y)
+{+ return JAS_FIX_MUL(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_div(jpc_fix_big_t x, jpc_fix_t y)
+{+ return JAS_FIX_DIV(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_neg(jpc_fix_t x)
+{+ return JAS_FIX_NEG(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+//#define jpc_fix_asl(x, n) JAS_FIX_ASL(jpc_fix_t, JPC_FIX_FRACBITS, x, n)
+//#define jpc_fix_asr(x, n) JAS_FIX_ASR(jpc_fix_t, JPC_FIX_FRACBITS, x, n)
+
+#ifdef JAS_ENABLE_32BIT
+#define jpc_fix_asl jas_least32_asl
+#define jpc_fix_asr jas_least32_asr
+#else
+#define jpc_fix_asl jas_fast32_asl
+#define jpc_fix_asr jas_fast32_asr
+#endif
+
+#define jpc_fix_pluseq(x, y) JAS_FIX_PLUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
+#define jpc_fix_minuseq(x, y) JAS_FIX_MINUSEQ(jpc_fix_t, JPC_FIX_FRACBITS, x, y)
+#define jpc_fix_muleq(x, y) \
+ JAS_FIX_MULEQ(jpc_fix_t, JPC_FIX_FRACBITS, jpc_fix_big_t, x, y)
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_abs(jpc_fix_t x)
+{+ return JAS_FIX_ABS(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline bool jpc_fix_isint(jpc_fix_t x)
+{+ return JAS_FIX_ISINT(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline int jpc_fix_sgn(jpc_fix_t x)
+{+ return JAS_FIX_SGN(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_round(jpc_fix_t x)
+{+ return JAS_FIX_ROUND(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_floor(jpc_fix_t x)
+{+ return JAS_FIX_FLOOR(jpc_fix_t, JPC_FIX_FRACBITS, x);
+}
+
+/******************************************************************************\
+* Extra macros for convenience.
+\******************************************************************************/
+
+/* Compute the sum of three fixed-point numbers. */
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t jpc_fix_add3(jpc_fix_t x, jpc_fix_t y, jpc_fix_t z)
+{+ return jpc_fix_add(jpc_fix_add(x, y), z);
+}
+
+#endif
--- /dev/null
+++ b/jpc_flt.h
@@ -1,0 +1,78 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Floating-Point Class
+ *
+ * $Id$
+ */
+
+#ifndef JPC_FLT_H
+#define JPC_FLT_H
+
+/* The code ought to be modified so this type is not used at all. */
+/* Very few places in the code rely on floating-point arithmetic, aside
+ from conversions in printf's. */
+typedef double jpc_flt_t;
+
+#endif
--- /dev/null
+++ b/jpc_math.c
@@ -1,0 +1,129 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Math Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes
+\******************************************************************************/
+
+#include "jpc_math.h"
+
+/******************************************************************************\
+* Miscellaneous Functions
+\******************************************************************************/
+
+/* Calculate the integer quantity floor(log2(x)), where x is a positive
+ integer. */
+unsigned jpc_floorlog2(uint_fast32_t x)
+{+ int y;
+
+ /* The argument must be positive. */
+ assert(x > 0);
+
+ y = 0;
+ while (x > 1) {+ x >>= 1;
+ ++y;
+ }
+ return y;
+}
+
+/* Calculate the bit position of the first leading one in a nonnegative
+ integer. */
+/* This function is the basically the same as ceillog2(x), except that the
+ allowable range for x is slightly different. */
+int jpc_int_firstone(int x)
+{+ int n;
+
+ /* The argument must be nonnegative. */
+ assert(x >= 0);
+
+ n = -1;
+ while (x > 0) {+ x >>= 1;
+ ++n;
+ }
+ return n;
+}
+
+int jpc_fix_firstone(jpc_fix_t x)
+{+ int n;
+
+ /* The argument must be nonnegative. */
+ assert(x >= 0);
+
+ n = -1;
+ while (x > 0) {+ x >>= 1;
+ ++n;
+ }
+ return n;
+}
--- /dev/null
+++ b/jpc_math.h
@@ -1,0 +1,106 @@
+/*
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+#ifndef JPC_MATH_H
+#define JPC_MATH_H
+
+/******************************************************************************\
+* Includes
+\******************************************************************************/
+
+#include "jasper/jas_config.h"
+
+#include "jpc_fix.h"
+
+/******************************************************************************\
+* Macros
+\******************************************************************************/
+
+/* Compute the floor of the quotient of two integers. */
+#define JPC_FLOORDIV(x, y) ((x) / (y))
+
+/* Compute the ceiling of the quotient of two integers. */
+#define JPC_CEILDIV(x, y) (((x) + (y) - 1) / (y))
+
+/* Compute the floor of (x / 2^y). */
+#define JPC_FLOORDIVPOW2(x, y) ((x) >> (y))
+
+/* Compute the ceiling of (x / 2^y). */
+#define JPC_CEILDIVPOW2(x, y) (((x) + (1 << (y)) - 1) >> (y))
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Calculate the bit position of the first leading one in a nonnegative
+ integer. */
+JAS_ATTRIBUTE_CONST
+int jpc_int_firstone(int x);
+
+JAS_ATTRIBUTE_CONST
+int jpc_fix_firstone(jpc_fix_t x);
+
+/* Calculate the integer quantity floor(log2(x)), where x is a positive
+ integer. */
+JAS_ATTRIBUTE_CONST
+unsigned jpc_floorlog2(uint_fast32_t x);
+
+#endif
--- /dev/null
+++ b/jpc_mct.c
@@ -1,0 +1,249 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Multicomponent Transform Code
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_mct.h"
+#include "jpc_fix.h"
+
+#include "jasper/jas_seq.h"
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+/* Compute the forward RCT. */
+
+void jpc_rct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
+{+ int numrows;
+ int numcols;
+ int i;
+ int j;
+ jpc_fix_t *c0p;
+ jpc_fix_t *c1p;
+ jpc_fix_t *c2p;
+
+ numrows = jas_matrix_numrows(c0);
+ numcols = jas_matrix_numcols(c0);
+
+ /* All three matrices must have the same dimensions. */
+ assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols
+ && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols);
+
+ for (i = 0; i < numrows; i++) {+ c0p = jas_matrix_getref(c0, i, 0);
+ c1p = jas_matrix_getref(c1, i, 0);
+ c2p = jas_matrix_getref(c2, i, 0);
+ for (j = numcols; j > 0; --j) {+ int r;
+ int g;
+ int b;
+ int y;
+ int u;
+ int v;
+ r = *c0p;
+ g = *c1p;
+ b = *c2p;
+ //y = (r + (g << 1) + b) >> 2;
+ y = jpc_fix_asr(r + jpc_fix_asl(g, 1) + b, 2);
+ u = b - g;
+ v = r - g;
+ *c0p++ = y;
+ *c1p++ = u;
+ *c2p++ = v;
+ }
+ }
+}
+
+/* Compute the inverse RCT. */
+
+void jpc_irct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
+{+ int numrows;
+ int numcols;
+ int i;
+ int j;
+ jpc_fix_t *c0p;
+ jpc_fix_t *c1p;
+ jpc_fix_t *c2p;
+
+ numrows = jas_matrix_numrows(c0);
+ numcols = jas_matrix_numcols(c0);
+
+ /* All three matrices must have the same dimensions. */
+ assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numcols(c1) == numcols
+ && jas_matrix_numrows(c2) == numrows && jas_matrix_numcols(c2) == numcols);
+
+ for (i = 0; i < numrows; i++) {+ c0p = jas_matrix_getref(c0, i, 0);
+ c1p = jas_matrix_getref(c1, i, 0);
+ c2p = jas_matrix_getref(c2, i, 0);
+ for (j = numcols; j > 0; --j) {+ int r;
+ int g;
+ int b;
+ int y;
+ int u;
+ int v;
+ y = *c0p;
+ u = *c1p;
+ v = *c2p;
+ //g = y - ((u + v) >> 2);
+ g = y - jpc_fix_asr(u + v, 2);
+ r = v + g;
+ b = u + g;
+ *c0p++ = r;
+ *c1p++ = g;
+ *c2p++ = b;
+ }
+ }
+}
+
+void jpc_ict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
+{+ int numrows;
+ int numcols;
+ int i;
+ int j;
+ jpc_fix_t r;
+ jpc_fix_t g;
+ jpc_fix_t b;
+ jpc_fix_t y;
+ jpc_fix_t u;
+ jpc_fix_t v;
+ jpc_fix_t *c0p;
+ jpc_fix_t *c1p;
+ jpc_fix_t *c2p;
+
+ numrows = jas_matrix_numrows(c0);
+ assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows);
+ numcols = jas_matrix_numcols(c0);
+ assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols);
+ for (i = 0; i < numrows; ++i) {+ c0p = jas_matrix_getref(c0, i, 0);
+ c1p = jas_matrix_getref(c1, i, 0);
+ c2p = jas_matrix_getref(c2, i, 0);
+ for (j = numcols; j > 0; --j) {+ r = *c0p;
+ g = *c1p;
+ b = *c2p;
+ y = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.299), r), jpc_fix_mul(jpc_dbltofix(0.587), g),
+ jpc_fix_mul(jpc_dbltofix(0.114), b));
+ u = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(-0.16875), r), jpc_fix_mul(jpc_dbltofix(-0.33126), g),
+ jpc_fix_mul(jpc_dbltofix(0.5), b));
+ v = jpc_fix_add3(jpc_fix_mul(jpc_dbltofix(0.5), r), jpc_fix_mul(jpc_dbltofix(-0.41869), g),
+ jpc_fix_mul(jpc_dbltofix(-0.08131), b));
+ *c0p++ = y;
+ *c1p++ = u;
+ *c2p++ = v;
+ }
+ }
+}
+
+void jpc_iict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2)
+{+ int numrows;
+ int numcols;
+ int i;
+ int j;
+ jpc_fix_t r;
+ jpc_fix_t g;
+ jpc_fix_t b;
+ jpc_fix_t y;
+ jpc_fix_t u;
+ jpc_fix_t v;
+ jpc_fix_t *c0p;
+ jpc_fix_t *c1p;
+ jpc_fix_t *c2p;
+
+ numrows = jas_matrix_numrows(c0);
+ assert(jas_matrix_numrows(c1) == numrows && jas_matrix_numrows(c2) == numrows);
+ numcols = jas_matrix_numcols(c0);
+ assert(jas_matrix_numcols(c1) == numcols && jas_matrix_numcols(c2) == numcols);
+ for (i = 0; i < numrows; ++i) {+ c0p = jas_matrix_getref(c0, i, 0);
+ c1p = jas_matrix_getref(c1, i, 0);
+ c2p = jas_matrix_getref(c2, i, 0);
+ for (j = numcols; j > 0; --j) {+ y = *c0p;
+ u = *c1p;
+ v = *c2p;
+ r = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.402), v));
+ g = jpc_fix_add3(y, jpc_fix_mul(jpc_dbltofix(-0.34413), u),
+ jpc_fix_mul(jpc_dbltofix(-0.71414), v));
+ b = jpc_fix_add(y, jpc_fix_mul(jpc_dbltofix(1.772), u));
+ *c0p++ = r;
+ *c1p++ = g;
+ *c2p++ = b;
+ }
+ }
+}
--- /dev/null
+++ b/jpc_mct.h
@@ -1,0 +1,109 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Multicomponent Transform Code
+ *
+ * $Id$
+ */
+
+#ifndef JPC_MCT_H
+#define JPC_MCT_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_fix.h"
+
+#include "jasper/jas_seq.h"
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/*
+ * Multicomponent transform IDs.
+ */
+
+#define JPC_MCT_NONE 0
+#define JPC_MCT_ICT 1
+#define JPC_MCT_RCT 2
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Calculate the forward RCT. */
+void jpc_rct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2);
+
+/* Calculate the inverse RCT. */
+void jpc_irct(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2);
+
+/* Calculate the forward ICT. */
+void jpc_ict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2);
+
+/* Calculate the inverse ICT. */
+void jpc_iict(jas_matrix_t *c0, jas_matrix_t *c1, jas_matrix_t *c2);
+
+#endif
--- /dev/null
+++ b/jpc_mqcod.c
@@ -1,0 +1,177 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * MQ Arithmetic Coder
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_mqcod.h"
+
+/******************************************************************************\
+* Data.
+\******************************************************************************/
+
+/* MQ coder per-state information. */
+
+const jpc_mqstate_t jpc_mqstates[47 * 2] = {+ {0x5601, 0, &jpc_mqstates[ 2], &jpc_mqstates[ 3]},+ {0x5601, 1, &jpc_mqstates[ 3], &jpc_mqstates[ 2]},+ {0x3401, 0, &jpc_mqstates[ 4], &jpc_mqstates[12]},+ {0x3401, 1, &jpc_mqstates[ 5], &jpc_mqstates[13]},+ {0x1801, 0, &jpc_mqstates[ 6], &jpc_mqstates[18]},+ {0x1801, 1, &jpc_mqstates[ 7], &jpc_mqstates[19]},+ {0x0ac1, 0, &jpc_mqstates[ 8], &jpc_mqstates[24]},+ {0x0ac1, 1, &jpc_mqstates[ 9], &jpc_mqstates[25]},+ {0x0521, 0, &jpc_mqstates[10], &jpc_mqstates[58]},+ {0x0521, 1, &jpc_mqstates[11], &jpc_mqstates[59]},+ {0x0221, 0, &jpc_mqstates[76], &jpc_mqstates[66]},+ {0x0221, 1, &jpc_mqstates[77], &jpc_mqstates[67]},+ {0x5601, 0, &jpc_mqstates[14], &jpc_mqstates[13]},+ {0x5601, 1, &jpc_mqstates[15], &jpc_mqstates[12]},+ {0x5401, 0, &jpc_mqstates[16], &jpc_mqstates[28]},+ {0x5401, 1, &jpc_mqstates[17], &jpc_mqstates[29]},+ {0x4801, 0, &jpc_mqstates[18], &jpc_mqstates[28]},+ {0x4801, 1, &jpc_mqstates[19], &jpc_mqstates[29]},+ {0x3801, 0, &jpc_mqstates[20], &jpc_mqstates[28]},+ {0x3801, 1, &jpc_mqstates[21], &jpc_mqstates[29]},+ {0x3001, 0, &jpc_mqstates[22], &jpc_mqstates[34]},+ {0x3001, 1, &jpc_mqstates[23], &jpc_mqstates[35]},+ {0x2401, 0, &jpc_mqstates[24], &jpc_mqstates[36]},+ {0x2401, 1, &jpc_mqstates[25], &jpc_mqstates[37]},+ {0x1c01, 0, &jpc_mqstates[26], &jpc_mqstates[40]},+ {0x1c01, 1, &jpc_mqstates[27], &jpc_mqstates[41]},+ {0x1601, 0, &jpc_mqstates[58], &jpc_mqstates[42]},+ {0x1601, 1, &jpc_mqstates[59], &jpc_mqstates[43]},+ {0x5601, 0, &jpc_mqstates[30], &jpc_mqstates[29]},+ {0x5601, 1, &jpc_mqstates[31], &jpc_mqstates[28]},+ {0x5401, 0, &jpc_mqstates[32], &jpc_mqstates[28]},+ {0x5401, 1, &jpc_mqstates[33], &jpc_mqstates[29]},+ {0x5101, 0, &jpc_mqstates[34], &jpc_mqstates[30]},+ {0x5101, 1, &jpc_mqstates[35], &jpc_mqstates[31]},+ {0x4801, 0, &jpc_mqstates[36], &jpc_mqstates[32]},+ {0x4801, 1, &jpc_mqstates[37], &jpc_mqstates[33]},+ {0x3801, 0, &jpc_mqstates[38], &jpc_mqstates[34]},+ {0x3801, 1, &jpc_mqstates[39], &jpc_mqstates[35]},+ {0x3401, 0, &jpc_mqstates[40], &jpc_mqstates[36]},+ {0x3401, 1, &jpc_mqstates[41], &jpc_mqstates[37]},+ {0x3001, 0, &jpc_mqstates[42], &jpc_mqstates[38]},+ {0x3001, 1, &jpc_mqstates[43], &jpc_mqstates[39]},+ {0x2801, 0, &jpc_mqstates[44], &jpc_mqstates[38]},+ {0x2801, 1, &jpc_mqstates[45], &jpc_mqstates[39]},+ {0x2401, 0, &jpc_mqstates[46], &jpc_mqstates[40]},+ {0x2401, 1, &jpc_mqstates[47], &jpc_mqstates[41]},+ {0x2201, 0, &jpc_mqstates[48], &jpc_mqstates[42]},+ {0x2201, 1, &jpc_mqstates[49], &jpc_mqstates[43]},+ {0x1c01, 0, &jpc_mqstates[50], &jpc_mqstates[44]},+ {0x1c01, 1, &jpc_mqstates[51], &jpc_mqstates[45]},+ {0x1801, 0, &jpc_mqstates[52], &jpc_mqstates[46]},+ {0x1801, 1, &jpc_mqstates[53], &jpc_mqstates[47]},+ {0x1601, 0, &jpc_mqstates[54], &jpc_mqstates[48]},+ {0x1601, 1, &jpc_mqstates[55], &jpc_mqstates[49]},+ {0x1401, 0, &jpc_mqstates[56], &jpc_mqstates[50]},+ {0x1401, 1, &jpc_mqstates[57], &jpc_mqstates[51]},+ {0x1201, 0, &jpc_mqstates[58], &jpc_mqstates[52]},+ {0x1201, 1, &jpc_mqstates[59], &jpc_mqstates[53]},+ {0x1101, 0, &jpc_mqstates[60], &jpc_mqstates[54]},+ {0x1101, 1, &jpc_mqstates[61], &jpc_mqstates[55]},+ {0x0ac1, 0, &jpc_mqstates[62], &jpc_mqstates[56]},+ {0x0ac1, 1, &jpc_mqstates[63], &jpc_mqstates[57]},+ {0x09c1, 0, &jpc_mqstates[64], &jpc_mqstates[58]},+ {0x09c1, 1, &jpc_mqstates[65], &jpc_mqstates[59]},+ {0x08a1, 0, &jpc_mqstates[66], &jpc_mqstates[60]},+ {0x08a1, 1, &jpc_mqstates[67], &jpc_mqstates[61]},+ {0x0521, 0, &jpc_mqstates[68], &jpc_mqstates[62]},+ {0x0521, 1, &jpc_mqstates[69], &jpc_mqstates[63]},+ {0x0441, 0, &jpc_mqstates[70], &jpc_mqstates[64]},+ {0x0441, 1, &jpc_mqstates[71], &jpc_mqstates[65]},+ {0x02a1, 0, &jpc_mqstates[72], &jpc_mqstates[66]},+ {0x02a1, 1, &jpc_mqstates[73], &jpc_mqstates[67]},+ {0x0221, 0, &jpc_mqstates[74], &jpc_mqstates[68]},+ {0x0221, 1, &jpc_mqstates[75], &jpc_mqstates[69]},+ {0x0141, 0, &jpc_mqstates[76], &jpc_mqstates[70]},+ {0x0141, 1, &jpc_mqstates[77], &jpc_mqstates[71]},+ {0x0111, 0, &jpc_mqstates[78], &jpc_mqstates[72]},+ {0x0111, 1, &jpc_mqstates[79], &jpc_mqstates[73]},+ {0x0085, 0, &jpc_mqstates[80], &jpc_mqstates[74]},+ {0x0085, 1, &jpc_mqstates[81], &jpc_mqstates[75]},+ {0x0049, 0, &jpc_mqstates[82], &jpc_mqstates[76]},+ {0x0049, 1, &jpc_mqstates[83], &jpc_mqstates[77]},+ {0x0025, 0, &jpc_mqstates[84], &jpc_mqstates[78]},+ {0x0025, 1, &jpc_mqstates[85], &jpc_mqstates[79]},+ {0x0015, 0, &jpc_mqstates[86], &jpc_mqstates[80]},+ {0x0015, 1, &jpc_mqstates[87], &jpc_mqstates[81]},+ {0x0009, 0, &jpc_mqstates[88], &jpc_mqstates[82]},+ {0x0009, 1, &jpc_mqstates[89], &jpc_mqstates[83]},+ {0x0005, 0, &jpc_mqstates[90], &jpc_mqstates[84]},+ {0x0005, 1, &jpc_mqstates[91], &jpc_mqstates[85]},+ {0x0001, 0, &jpc_mqstates[90], &jpc_mqstates[86]},+ {0x0001, 1, &jpc_mqstates[91], &jpc_mqstates[87]},+ {0x5601, 0, &jpc_mqstates[92], &jpc_mqstates[92]},+ {0x5601, 1, &jpc_mqstates[93], &jpc_mqstates[93]},+};
--- /dev/null
+++ b/jpc_mqcod.h
@@ -1,0 +1,124 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * MQ Arithmetic Coder
+ *
+ * $Id$
+ */
+
+#ifndef JPC_MQCOD_H
+#define JPC_MQCOD_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_types.h"
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/*
+ * MQ coder context information.
+ */
+
+typedef struct {+
+ /* The most probable symbol (MPS). */
+ bool mps;
+
+ /* The state index. */
+ int_least8_t ind;
+
+} jpc_mqctx_t;
+
+/*
+ * MQ coder state table entry.
+ */
+
+typedef struct jpc_mqstate_s {+
+ /* The Qe value. */
+ uint_least16_t qeval;
+
+ /* The MPS. */
+ bool mps;
+
+ /* The NMPS state. */
+ const struct jpc_mqstate_s *nmps;
+
+ /* The NLPS state. */
+ const struct jpc_mqstate_s *nlps;
+
+} jpc_mqstate_t;
+
+/******************************************************************************\
+* Data.
+\******************************************************************************/
+
+/* The state table for the MQ coder. */
+extern const jpc_mqstate_t jpc_mqstates[];
+
+#endif
--- /dev/null
+++ b/jpc_mqdec.c
@@ -1,0 +1,298 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * MQ Arithmetic Decoder
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_mqdec.h"
+
+#include "jasper/jas_types.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_math.h"
+#include "jasper/jas_debug.h"
+
+/******************************************************************************\
+* Local macros.
+\******************************************************************************/
+
+#ifndef NDEBUG
+#define MQDEC_CALL(n, x) \
+ ((jas_getdbglevel() >= (n)) ? ((void)(x)) : ((void)0))
+#else
+#define MQDEC_CALL(n, x)
+#endif
+
+/******************************************************************************\
+* Local function prototypes.
+\******************************************************************************/
+
+static void jpc_mqdec_bytein(jpc_mqdec_t *mqdec);
+
+/******************************************************************************\
+* Code for creation and destruction of a MQ decoder.
+\******************************************************************************/
+
+/* Create a MQ decoder. */
+jpc_mqdec_t *jpc_mqdec_create(unsigned maxctxs, jas_stream_t *in)
+{+ jpc_mqdec_t *mqdec;
+
+ /* There must be at least one context. */
+ assert(maxctxs > 0);
+
+ /* Allocate memory for the MQ decoder. */
+ if (!(mqdec = jas_malloc(sizeof(jpc_mqdec_t)))) {+ goto error;
+ }
+ mqdec->in = in;
+ mqdec->maxctxs = maxctxs;
+ /* Allocate memory for the per-context state information. */
+ if (!(mqdec->ctxs = jas_alloc2(mqdec->maxctxs, sizeof(jpc_mqstate_t *)))) {+ goto error;
+ }
+ /* Set the current context to the first context. */
+ mqdec->curctx = mqdec->ctxs;
+
+ /* If an input stream has been associated with the MQ decoder,
+ initialize the decoder state from the stream. */
+ if (mqdec->in) {+ jpc_mqdec_init(mqdec);
+ }
+ /* Initialize the per-context state information. */
+ jpc_mqdec_setctxs(mqdec, 0, 0);
+
+ return mqdec;
+
+error:
+ /* Oops... Something has gone wrong. */
+ if (mqdec) {+ jpc_mqdec_destroy(mqdec);
+ }
+ return 0;
+}
+
+/* Destroy a MQ decoder. */
+void jpc_mqdec_destroy(jpc_mqdec_t *mqdec)
+{+ jas_free(mqdec->ctxs);
+ jas_free(mqdec);
+}
+
+/******************************************************************************\
+* Code for initialization of a MQ decoder.
+\******************************************************************************/
+
+/* Initialize the state of a MQ decoder. */
+
+void jpc_mqdec_init(jpc_mqdec_t *mqdec)
+{+ int c;
+
+ mqdec->eof = false;
+ mqdec->creg = 0;
+ /* Get the next byte from the input stream. */
+ if ((c = jas_stream_getc(mqdec->in)) == EOF) {+ /* We have encountered an I/O error or EOF. */
+ c = 0xff;
+ mqdec->eof = true;
+ }
+ mqdec->inbuffer = c;
+ mqdec->creg += mqdec->inbuffer << 16;
+ jpc_mqdec_bytein(mqdec);
+ mqdec->creg <<= 7;
+ mqdec->ctreg -= 7;
+ mqdec->areg = 0x8000;
+}
+
+/* Set the input stream for a MQ decoder. */
+
+void jpc_mqdec_setinput(jpc_mqdec_t *mqdec, jas_stream_t *in)
+{+ mqdec->in = in;
+}
+
+/* Initialize one or more contexts. */
+
+void jpc_mqdec_setctxs(const jpc_mqdec_t *mqdec, unsigned numctxs, const jpc_mqctx_t *ctxs)
+{+ const jpc_mqstate_t **ctx;
+
+ ctx = mqdec->ctxs;
+ unsigned n = JAS_MIN(mqdec->maxctxs, numctxs);
+ while (n-- > 0) {+ *ctx = &jpc_mqstates[2 * ctxs->ind + ctxs->mps];
+ ++ctx;
+ ++ctxs;
+ }
+ n = mqdec->maxctxs - numctxs;
+ while (n-- > 0) {+ *ctx = &jpc_mqstates[0];
+ ++ctx;
+ }
+}
+
+/******************************************************************************\
+* Code for decoding a bit.
+\******************************************************************************/
+
+/* Decode a bit. */
+
+bool jpc_mqdec_getbit_func(register jpc_mqdec_t *mqdec)
+{+ bool bit;
+ JAS_DBGLOG(100, ("jpc_mqdec_getbit_func(%p)\n", mqdec));+ MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr));
+ bit = jpc_mqdec_getbit_macro(mqdec);
+ MQDEC_CALL(100, jpc_mqdec_dump(mqdec, stderr));
+ JAS_DBGLOG(100, ("ctx = %d, decoded %d\n", mqdec->curctx -+ mqdec->ctxs, bit));
+ return bit;
+}
+
+static void jpc_mqdec_renormd(jpc_mqdec_t *mqdec)
+{+ do {+ if (!mqdec->ctreg)
+ jpc_mqdec_bytein(mqdec);
+
+ mqdec->areg <<= 1;
+ mqdec->creg <<= 1;
+ --mqdec->ctreg;
+ } while (!(mqdec->areg & 0x8000));
+}
+
+/* Apply MPS_EXCHANGE algorithm (with RENORMD). */
+bool jpc_mqdec_mpsexchrenormd(register jpc_mqdec_t *mqdec)
+{+ register const jpc_mqstate_t *state = *mqdec->curctx;
+ bool ret = jpc_mqdec_mpsexchange(mqdec->areg, state->qeval, mqdec->curctx);
+ jpc_mqdec_renormd(mqdec);
+ return ret;
+}
+
+/* Apply LPS_EXCHANGE algorithm (with RENORMD). */
+bool jpc_mqdec_lpsexchrenormd(register jpc_mqdec_t *mqdec)
+{+ register const jpc_mqstate_t *state = *mqdec->curctx;
+ bool ret = jpc_mqdec_lpsexchange(&mqdec->areg, state->qeval, mqdec->curctx);
+ jpc_mqdec_renormd(mqdec);
+ return ret;
+}
+
+/******************************************************************************\
+* Support code.
+\******************************************************************************/
+
+/* Apply the BYTEIN algorithm. */
+static void jpc_mqdec_bytein(jpc_mqdec_t *mqdec)
+{+ int c;
+ unsigned char prevbuf;
+
+ if (!mqdec->eof) {+ if ((c = jas_stream_getc(mqdec->in)) == EOF) {+ mqdec->eof = true;
+ c = 0xff;
+ }
+ prevbuf = mqdec->inbuffer;
+ mqdec->inbuffer = c;
+ if (prevbuf == 0xff) {+ if (c > 0x8f) {+ mqdec->creg += 0xff00;
+ mqdec->ctreg = 8;
+ } else {+ mqdec->creg += c << 9;
+ mqdec->ctreg = 7;
+ }
+ } else {+ mqdec->creg += c << 8;
+ mqdec->ctreg = 8;
+ }
+ } else {+ mqdec->creg += 0xff00;
+ mqdec->ctreg = 8;
+ }
+}
+
+/******************************************************************************\
+* Code for debugging.
+\******************************************************************************/
+
+/* Dump a MQ decoder to a stream for debugging. */
+
+void jpc_mqdec_dump(const jpc_mqdec_t *mqdec, FILE *out)
+{+ fprintf(out, "MQDEC A = %08lx, C = %08lx, CT=%08lx, ",
+ (unsigned long) mqdec->areg, (unsigned long) mqdec->creg,
+ (unsigned long) mqdec->ctreg);
+ fprintf(out, "CTX = %" PRIdPTR ", ", mqdec->curctx - mqdec->ctxs);
+ fprintf(out, "IND %" PRIdPTR ", MPS %d, QEVAL %"PRIxLEAST16"\n", *mqdec->curctx -
+ jpc_mqstates, (*mqdec->curctx)->mps, (*mqdec->curctx)->qeval);
+}
--- /dev/null
+++ b/jpc_mqdec.h
@@ -1,0 +1,241 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * MQ Arithmetic Decoder
+ *
+ * $Id$
+ */
+
+#ifndef JPC_MQDEC_H
+#define JPC_MQDEC_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_types.h"
+#include "jasper/jas_stream.h"
+
+#include "jpc_mqcod.h"
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/* MQ arithmetic decoder. */
+
+typedef struct {+
+ /* The C register. */
+ uint_least32_t creg;
+
+ /* The A register. */
+ uint_least32_t areg;
+
+ /* The CT register. */
+ uint_least32_t ctreg;
+
+ /* The current context. */
+ const jpc_mqstate_t **curctx;
+
+ /* The per-context information. */
+ const jpc_mqstate_t **ctxs;
+
+ /* The maximum number of contexts. */
+ unsigned maxctxs;
+
+ /* The stream from which to read data. */
+ jas_stream_t *in;
+
+ /* The last character read. */
+ jas_uchar inbuffer;
+
+ /* The EOF indicator. */
+ bool eof;
+
+} jpc_mqdec_t;
+
+/******************************************************************************\
+* Functions/macros for construction and destruction.
+\******************************************************************************/
+
+/* Create a MQ decoder. */
+jpc_mqdec_t *jpc_mqdec_create(unsigned maxctxs, jas_stream_t *in);
+
+/* Destroy a MQ decoder. */
+void jpc_mqdec_destroy(jpc_mqdec_t *dec);
+
+/******************************************************************************\
+* Functions/macros for initialization.
+\******************************************************************************/
+
+/* Set the input stream associated with a MQ decoder. */
+void jpc_mqdec_setinput(jpc_mqdec_t *dec, jas_stream_t *in);
+
+/* Initialize a MQ decoder. */
+void jpc_mqdec_init(jpc_mqdec_t *dec);
+
+/******************************************************************************\
+* Functions/macros for manipulating contexts.
+\******************************************************************************/
+
+/* Set the current context for a MQ decoder. */
+static inline void jpc_mqdec_setcurctx(jpc_mqdec_t *dec, unsigned ctxno)
+{+ dec->curctx = &dec->ctxs[ctxno];
+}
+
+/* Set the state information for all contexts of a MQ decoder. */
+void jpc_mqdec_setctxs(const jpc_mqdec_t *dec, unsigned numctxs, const jpc_mqctx_t *ctxs);
+
+/******************************************************************************\
+* Functions/macros for decoding bits.
+\******************************************************************************/
+
+/* Decode a symbol. */
+#ifdef NDEBUG
+#define jpc_mqdec_getbit(dec) \
+ jpc_mqdec_getbit_macro(dec)
+#else
+#define jpc_mqdec_getbit(dec) \
+ jpc_mqdec_getbit_func(dec)
+#endif
+
+/* Decode a symbol (assuming an unskewed probability distribution). */
+#ifdef NDEBUG
+#define jpc_mqdec_getbitnoskew(dec) \
+ jpc_mqdec_getbit_macro(dec)
+#else
+#define jpc_mqdec_getbitnoskew(dec) \
+ jpc_mqdec_getbit_func(dec)
+#endif
+
+/******************************************************************************\
+* Functions/macros for debugging.
+\******************************************************************************/
+
+/* Dump the MQ decoder state for debugging. */
+void jpc_mqdec_dump(const jpc_mqdec_t *dec, FILE *out);
+
+/******************************************************************************\
+* EVERYTHING BELOW THIS POINT IS IMPLEMENTATION SPECIFIC AND NOT PART OF THE
+* APPLICATION INTERFACE. DO NOT RELY ON ANY OF THE INTERNAL FUNCTIONS/MACROS
+* GIVEN BELOW.
+\******************************************************************************/
+
+bool jpc_mqdec_mpsexchrenormd(jpc_mqdec_t *dec);
+bool jpc_mqdec_lpsexchrenormd(jpc_mqdec_t *dec);
+
+JAS_FORCE_INLINE
+static bool jpc_mqdec_getbit_macro(jpc_mqdec_t *dec)
+{+ const jpc_mqstate_t *const state = *dec->curctx;
+
+ dec->areg -= state->qeval;
+
+ if (dec->creg >= (uint_least32_t)state->qeval << 16) {+ dec->creg -= (uint_least32_t)state->qeval << 16;
+ return dec->areg & 0x8000
+ ? state->mps
+ : jpc_mqdec_mpsexchrenormd(dec);
+ } else {+ return jpc_mqdec_lpsexchrenormd(dec);
+ }
+}
+
+JAS_FORCE_INLINE
+static bool jpc_mqdec_mpsexchange(uint_least32_t areg, uint_least32_t delta, const jpc_mqstate_t **curctx)
+{+ if (areg < delta) {+ const jpc_mqstate_t *state = *curctx;
+ /* LPS decoded. */
+ *curctx = state->nlps;
+ return !state->mps;
+ } else {+ const jpc_mqstate_t *state = *curctx;
+ /* MPS decoded. */
+ *curctx = state->nmps;
+ return state->mps;
+ }
+}
+
+JAS_FORCE_INLINE
+static bool jpc_mqdec_lpsexchange(uint_least32_t *areg_p, uint_least32_t delta, const jpc_mqstate_t **curctx)
+{+ if (*areg_p >= delta) {+ const jpc_mqstate_t *state = *curctx;
+ *areg_p = delta;
+ *curctx = state->nlps;
+ return !state->mps;
+ } else {+ const jpc_mqstate_t *state = *curctx;
+ *areg_p = delta;
+ *curctx = state->nmps;
+ return state->mps;
+ }
+}
+
+bool jpc_mqdec_getbit_func(jpc_mqdec_t *dec);
+
+#endif
--- /dev/null
+++ b/jpc_qmfb.c
@@ -1,0 +1,2207 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Quadrature Mirror-Image Filter Bank (QMFB) Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+#undef WT_LENONE /* This is not needed due to normalization. */
+#define WT_DOSCALE
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_qmfb.h"
+#include "jpc_math.h"
+
+#include "jasper/jas_malloc.h"
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+#define QMFB_SPLITBUFSIZE 4096
+#define QMFB_JOINBUFSIZE 4096
+
+static int jpc_ft_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
+ int stride);
+static int jpc_ft_synthesize(jpc_fix_t *a, int xstart, int ystart, int width, int height,
+ int stride);
+
+static int jpc_ns_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
+ int stride);
+static int jpc_ns_synthesize(jpc_fix_t *a, int xstart, int ystart, int width,
+ int height, int stride);
+
+static void jpc_ft_fwdlift_row(jpc_fix_t *a, unsigned numcols, bool parity);
+static void jpc_ft_fwdlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride,
+ bool parity);
+static void jpc_ft_fwdlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols,
+ unsigned stride, bool parity);
+
+static void jpc_ft_invlift_row(jpc_fix_t *a, unsigned numcols, bool parity);
+static void jpc_ft_invlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride,
+ bool parity);
+static void jpc_ft_invlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols,
+ unsigned stride, bool parity);
+
+static void jpc_ns_fwdlift_row(jpc_fix_t *a, unsigned numcols, bool parity);
+static void jpc_ns_fwdlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride, bool parity);
+static void jpc_ns_fwdlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols, unsigned stride,
+ bool parity);
+static void jpc_ns_invlift_row(jpc_fix_t *a, unsigned numcols, bool parity);
+static void jpc_ns_invlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride, bool parity);
+static void jpc_ns_invlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols, unsigned stride,
+ bool parity);
+
+static void jpc_qmfb_split_row(jpc_fix_t *a, unsigned numrows, bool parity);
+static void jpc_qmfb_split_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride, bool parity);
+static void jpc_qmfb_split_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols, unsigned stride,
+ bool parity);
+
+static void jpc_qmfb_join_row(jpc_fix_t *a, unsigned numcols, bool parity);
+static void jpc_qmfb_join_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride, bool parity);
+static void jpc_qmfb_join_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols, unsigned stride,
+ bool parity);
+
+static const double jpc_ft_lpenergywts[32] = {+ 1.2247448713915889,
+ 1.6583123951776999,
+ 2.3184046238739260,
+ 3.2691742076555053,
+ 4.6199296531440819,
+ 6.5323713152269596,
+ 9.2377452606141937,
+ 13.0639951297449581,
+ 18.4752262333915667,
+ 26.1278968190610392,
+ 36.9504194305524791,
+ 52.2557819580462777,
+ 73.9008347315741645,
+ 104.5115624560829133,
+ 147.8016689469569656,
+ 209.0231247296646018,
+ 295.6033378293900000,
+ 418.0462494347059419,
+ 591.2066756503630813,
+ 836.0924988714708661,
+ /* approximations */
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661,
+ 836.0924988714708661
+};
+
+static const double jpc_ft_hpenergywts[32] = {+ 0.8477912478906585,
+ 0.9601432184835760,
+ 1.2593401049756179,
+ 1.7444107171191079,
+ 2.4538713036750726,
+ 3.4656517695088755,
+ 4.8995276398597856,
+ 6.9283970402160842,
+ 9.7980274940131444,
+ 13.8564306871112652,
+ 19.5959265076535587,
+ 27.7128159494245487,
+ 39.1918369552045860,
+ 55.4256262207444053,
+ 78.3836719028959124,
+ 110.8512517317256822,
+ 156.7673435548526868,
+ 221.7025033739244293,
+ 313.5346870787551552,
+ 443.4050067351659550,
+ /* approximations */
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550,
+ 443.4050067351659550
+};
+
+static const double jpc_ns_lpenergywts[32] = {+ 1.4021081679297411,
+ 2.0303718560817923,
+ 2.9011625562785555,
+ 4.1152851751758002,
+ 5.8245108637728071,
+ 8.2387599345725171,
+ 11.6519546479210838,
+ 16.4785606470644375,
+ 23.3042776444606794,
+ 32.9572515613740435,
+ 46.6086013487782793,
+ 65.9145194076860861,
+ 93.2172084551803977,
+ 131.8290408510004283,
+ 186.4344176300625691,
+ 263.6580819564562148,
+ 372.8688353500955373,
+ 527.3161639447193920,
+ 745.7376707114038936,
+ 1054.6323278917823245,
+ /* approximations follow */
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245,
+ 1054.6323278917823245
+};
+
+static const double jpc_ns_hpenergywts[32] = {+ 1.4425227650161456,
+ 1.9669426082455688,
+ 2.8839248082788891,
+ 4.1475208393432981,
+ 5.8946497530677817,
+ 8.3471789178590949,
+ 11.8086046551047463,
+ 16.7012780415647804,
+ 23.6196657032246620,
+ 33.4034255108592362,
+ 47.2396388881632632,
+ 66.8069597416714061,
+ 94.4793162154500692,
+ 133.6139330736999113,
+ 188.9586372358249378,
+ 267.2278678461869390,
+ 377.9172750722391356,
+ 534.4557359047058753,
+ 755.8345502191498326,
+ 1068.9114718353569060,
+ /* approximations follow */
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060,
+ 1068.9114718353569060
+};
+
+const jpc_qmfb2d_t jpc_ft_qmfb2d = {+ jpc_ft_analyze,
+ jpc_ft_synthesize,
+ jpc_ft_lpenergywts,
+ jpc_ft_hpenergywts
+};
+
+const jpc_qmfb2d_t jpc_ns_qmfb2d = {+ jpc_ns_analyze,
+ jpc_ns_synthesize,
+ jpc_ns_lpenergywts,
+ jpc_ns_hpenergywts
+};
+
+/******************************************************************************\
+* generic
+\******************************************************************************/
+
+static void jpc_qmfb_split_row(jpc_fix_t *a, unsigned numcols, bool parity)
+{+ jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE];
+ jpc_fix_t *buf = splitbuf;
+ register jpc_fix_t *srcptr;
+ register jpc_fix_t *dstptr;
+
+ /* Get a buffer. */
+ const size_t bufsize = JPC_CEILDIVPOW2(numcols, 1);
+ if (bufsize > QMFB_SPLITBUFSIZE) {+ if (!(buf = jas_alloc2(bufsize, sizeof(jpc_fix_t)))) {+ /* We have no choice but to commit suicide in this case. */
+ abort();
+ }
+ }
+
+ if (numcols >= 2) {+ const unsigned hstartcol = (numcols + !parity) >> 1;
+ // ORIGINAL (WRONG): m = (parity) ? hstartcol : (numcols - hstartcol);
+ const unsigned m = numcols - hstartcol;
+
+ /* Save the samples destined for the highpass channel. */
+ dstptr = buf;
+ srcptr = &a[!parity];
+ for (unsigned n = m; n > 0; --n) {+ *dstptr = *srcptr;
+ ++dstptr;
+ srcptr += 2;
+ }
+ /* Copy the appropriate samples into the lowpass channel. */
+ dstptr = &a[!parity];
+ srcptr = &a[2 - parity];
+ for (unsigned n = numcols - m - (!parity); n > 0; --n) {+ *dstptr = *srcptr;
+ ++dstptr;
+ srcptr += 2;
+ }
+ /* Copy the saved samples into the highpass channel. */
+ dstptr = &a[hstartcol];
+ srcptr = buf;
+ for (unsigned n = m; n > 0; --n) {+ *dstptr = *srcptr;
+ ++dstptr;
+ ++srcptr;
+ }
+ }
+
+ /* If the split buffer was allocated on the heap, free this memory. */
+ if (buf != splitbuf) {+ jas_free(buf);
+ }
+
+}
+
+static void jpc_qmfb_split_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride,
+ bool parity)
+{+
+ jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE * JPC_QMFB_COLGRPSIZE];
+ jpc_fix_t *buf = splitbuf;
+ jpc_fix_t *srcptr;
+ jpc_fix_t *dstptr;
+ register jpc_fix_t *srcptr2;
+ register jpc_fix_t *dstptr2;
+
+ /* Get a buffer. */
+ const size_t bufsize = JPC_CEILDIVPOW2(numrows, 1);
+ if (bufsize > QMFB_SPLITBUFSIZE) {+ if (!(buf = jas_alloc3(bufsize, JPC_QMFB_COLGRPSIZE,
+ sizeof(jpc_fix_t)))) {+ /* We have no choice but to commit suicide in this case. */
+ abort();
+ }
+ }
+
+ if (numrows >= 2) {+ const unsigned hstartrow = (numrows + !parity) >> 1;
+ // ORIGINAL (WRONG): m = (parity) ? hstartrow : (numrows - hstartrow);
+ const unsigned m = numrows - hstartrow;
+
+ /* Save the samples destined for the highpass channel. */
+ dstptr = buf;
+ srcptr = &a[(!parity) * stride];
+ for (unsigned n = m; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += JPC_QMFB_COLGRPSIZE;
+ srcptr += stride << 1;
+ }
+ /* Copy the appropriate samples into the lowpass channel. */
+ dstptr = &a[(!parity) * stride];
+ srcptr = &a[(2 - parity) * stride];
+ for (unsigned n = numrows - m - (!parity); n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += stride;
+ srcptr += stride << 1;
+ }
+ /* Copy the saved samples into the highpass channel. */
+ dstptr = &a[hstartrow * stride];
+ srcptr = buf;
+ for (unsigned n = m; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += stride;
+ srcptr += JPC_QMFB_COLGRPSIZE;
+ }
+ }
+
+ /* If the split buffer was allocated on the heap, free this memory. */
+ if (buf != splitbuf) {+ jas_free(buf);
+ }
+
+}
+
+static void jpc_qmfb_split_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols,
+ unsigned stride, bool parity)
+{+
+ jpc_fix_t splitbuf[QMFB_SPLITBUFSIZE * JPC_QMFB_COLGRPSIZE];
+ jpc_fix_t *buf = splitbuf;
+ jpc_fix_t *srcptr;
+ jpc_fix_t *dstptr;
+ register jpc_fix_t *srcptr2;
+ register jpc_fix_t *dstptr2;
+
+ /* Get a buffer. */
+ const size_t bufsize = JPC_CEILDIVPOW2(numrows, 1);
+ if (bufsize > QMFB_SPLITBUFSIZE) {+ if (!(buf = jas_alloc3(bufsize, numcols, sizeof(jpc_fix_t)))) {+ /* We have no choice but to commit suicide in this case. */
+ abort();
+ }
+ }
+
+ if (numrows >= 2) {+ const unsigned hstartcol = (numrows + !parity) >> 1;
+ // ORIGINAL (WRONG): m = (parity) ? hstartcol : (numrows - hstartcol);
+ const unsigned m = numrows - hstartcol;
+
+ /* Save the samples destined for the highpass channel. */
+ dstptr = buf;
+ srcptr = &a[(!parity) * stride];
+ for (unsigned n = m; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += numcols;
+ srcptr += stride << 1;
+ }
+ /* Copy the appropriate samples into the lowpass channel. */
+ dstptr = &a[(!parity) * stride];
+ srcptr = &a[(2 - parity) * stride];
+ for (unsigned n = numrows - m - (!parity); n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += stride;
+ srcptr += stride << 1;
+ }
+ /* Copy the saved samples into the highpass channel. */
+ dstptr = &a[hstartcol * stride];
+ srcptr = buf;
+ for (unsigned n = m; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += stride;
+ srcptr += numcols;
+ }
+ }
+
+ /* If the split buffer was allocated on the heap, free this memory. */
+ if (buf != splitbuf) {+ jas_free(buf);
+ }
+
+}
+
+static void jpc_qmfb_join_row(jpc_fix_t *a, unsigned numcols, bool parity)
+{+
+ jpc_fix_t joinbuf[QMFB_JOINBUFSIZE];
+ jpc_fix_t *buf = joinbuf;
+ register jpc_fix_t *srcptr;
+ register jpc_fix_t *dstptr;
+
+ /* Allocate memory for the join buffer from the heap. */
+ const size_t bufsize = JPC_CEILDIVPOW2(numcols, 1);
+ if (bufsize > QMFB_JOINBUFSIZE) {+ if (!(buf = jas_alloc2(bufsize, sizeof(jpc_fix_t)))) {+ /* We have no choice but to commit suicide. */
+ abort();
+ }
+ }
+
+ const unsigned hstartcol = (numcols + !parity) >> 1;
+
+ /* Save the samples from the lowpass channel. */
+ srcptr = &a[0];
+ dstptr = buf;
+ for (unsigned n = hstartcol; n > 0; --n) {+ *dstptr = *srcptr;
+ ++srcptr;
+ ++dstptr;
+ }
+ /* Copy the samples from the highpass channel into place. */
+ srcptr = &a[hstartcol];
+ dstptr = &a[!parity];
+ for (unsigned n = numcols - hstartcol; n > 0; --n) {+ *dstptr = *srcptr;
+ dstptr += 2;
+ ++srcptr;
+ }
+ /* Copy the samples from the lowpass channel into place. */
+ srcptr = buf;
+ dstptr = &a[parity];
+ for (unsigned n = hstartcol; n > 0; --n) {+ *dstptr = *srcptr;
+ dstptr += 2;
+ ++srcptr;
+ }
+
+ /* If the join buffer was allocated on the heap, free this memory. */
+ if (buf != joinbuf) {+ jas_free(buf);
+ }
+
+}
+
+static void jpc_qmfb_join_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride,
+ bool parity)
+{+
+ jpc_fix_t joinbuf[QMFB_JOINBUFSIZE * JPC_QMFB_COLGRPSIZE];
+ jpc_fix_t *buf = joinbuf;
+ jpc_fix_t *srcptr;
+ jpc_fix_t *dstptr;
+ register jpc_fix_t *srcptr2;
+ register jpc_fix_t *dstptr2;
+
+ /* Allocate memory for the join buffer from the heap. */
+ const size_t bufsize = JPC_CEILDIVPOW2(numrows, 1);
+ if (bufsize > QMFB_JOINBUFSIZE) {+ if (!(buf = jas_alloc3(bufsize, JPC_QMFB_COLGRPSIZE,
+ sizeof(jpc_fix_t)))) {+ /* We have no choice but to commit suicide. */
+ abort();
+ }
+ }
+
+ const unsigned hstartcol = (numrows + !parity) >> 1;
+
+ /* Save the samples from the lowpass channel. */
+ srcptr = &a[0];
+ dstptr = buf;
+ for (unsigned n = hstartcol; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ srcptr += stride;
+ dstptr += JPC_QMFB_COLGRPSIZE;
+ }
+ /* Copy the samples from the highpass channel into place. */
+ srcptr = &a[hstartcol * stride];
+ dstptr = &a[(!parity) * stride];
+ for (unsigned n = numrows - hstartcol; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += 2 * stride;
+ srcptr += stride;
+ }
+ /* Copy the samples from the lowpass channel into place. */
+ srcptr = buf;
+ dstptr = &a[parity * stride];
+ for (unsigned n = hstartcol; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += 2 * stride;
+ srcptr += JPC_QMFB_COLGRPSIZE;
+ }
+
+ /* If the join buffer was allocated on the heap, free this memory. */
+ if (buf != joinbuf) {+ jas_free(buf);
+ }
+
+}
+
+static void jpc_qmfb_join_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols,
+ unsigned stride, bool parity)
+{+
+ jpc_fix_t joinbuf[QMFB_JOINBUFSIZE * JPC_QMFB_COLGRPSIZE];
+ jpc_fix_t *buf = joinbuf;
+ jpc_fix_t *srcptr;
+ jpc_fix_t *dstptr;
+ register jpc_fix_t *srcptr2;
+ register jpc_fix_t *dstptr2;
+
+ /* Allocate memory for the join buffer from the heap. */
+ const size_t bufsize = JPC_CEILDIVPOW2(numrows, 1);
+ if (bufsize > QMFB_JOINBUFSIZE) {+ if (!(buf = jas_alloc3(bufsize, numcols, sizeof(jpc_fix_t)))) {+ /* We have no choice but to commit suicide. */
+ abort();
+ }
+ }
+
+ const unsigned hstartcol = (numrows + !parity) >> 1;
+
+ /* Save the samples from the lowpass channel. */
+ srcptr = &a[0];
+ dstptr = buf;
+ for (unsigned n = hstartcol; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ srcptr += stride;
+ dstptr += numcols;
+ }
+ /* Copy the samples from the highpass channel into place. */
+ srcptr = &a[hstartcol * stride];
+ dstptr = &a[(!parity) * stride];
+ for (unsigned n = numrows - hstartcol; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += 2 * stride;
+ srcptr += stride;
+ }
+ /* Copy the samples from the lowpass channel into place. */
+ srcptr = buf;
+ dstptr = &a[parity * stride];
+ for (unsigned n = hstartcol; n > 0; --n) {+ dstptr2 = dstptr;
+ srcptr2 = srcptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ *dstptr2 = *srcptr2;
+ ++dstptr2;
+ ++srcptr2;
+ }
+ dstptr += 2 * stride;
+ srcptr += numcols;
+ }
+
+ /* If the join buffer was allocated on the heap, free this memory. */
+ if (buf != joinbuf) {+ jas_free(buf);
+ }
+
+}
+
+/******************************************************************************\
+* 5/3 transform
+\******************************************************************************/
+
+static void jpc_ft_fwdlift_row(jpc_fix_t *a, unsigned numcols, bool parity)
+{+
+ register jpc_fix_t *lptr;
+ register jpc_fix_t *hptr;
+
+ const unsigned llen = (numcols + !parity) >> 1;
+ const bool end_parity = parity == (numcols & 1);
+
+ if (numcols > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (parity) {+ hptr[0] -= lptr[0];
+ ++hptr;
+ }
+ for (unsigned n = numcols - llen - parity - end_parity; n > 0; --n) {+ //hptr[0] -= (lptr[0] + lptr[1]) >> 1;
+ hptr[0] -= jpc_fix_asr(lptr[0] + lptr[1], 1);
+ ++hptr;
+ ++lptr;
+ }
+ if (end_parity) {+ hptr[0] -= lptr[0];
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (!parity) {+ //lptr[0] += (hptr[0] + 1) >> 1;
+ lptr[0] += jpc_fix_asr(hptr[0] + 1, 1);
+ ++lptr;
+ }
+ for (unsigned n = llen - (!parity) - (!end_parity); n > 0; --n) {+ //lptr[0] += (hptr[0] + hptr[1] + 2) >> 2;
+ lptr[0] += jpc_fix_asr(hptr[0] + hptr[1] + 2, 2);
+ ++lptr;
+ ++hptr;
+ }
+ if (!end_parity) {+ //lptr[0] += (hptr[0] + 1) >> 1;
+ lptr[0] += jpc_fix_asr(hptr[0] + 1, 1);
+ }
+
+ } else {+
+ if (parity) {+ lptr = &a[0];
+ //lptr[0] <<= 1;
+ lptr[0] = jpc_fix_asl(lptr[0], 1);
+ }
+
+ }
+
+}
+
+static void jpc_ft_fwdlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride, bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ hptr2[0] -= lptr2[0];
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //hptr2[0] -= (lptr2[0] + lptr2[stride]) >> 1;
+ hptr2[0] -= jpc_fix_asr(lptr2[0] + lptr2[stride], 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ hptr2[0] -= lptr2[0];
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] += (hptr2[0] + 1) >> 1;
+ lptr2[0] += jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] += (hptr2[0] + hptr2[stride] + 2) >> 2;
+ lptr2[0] += jpc_fix_asr(hptr2[0] + hptr2[stride] + 2, 2);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] += (hptr2[0] + 1) >> 1;
+ lptr2[0] += jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ } else {+
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] <<= 1;
+ lptr2[0] = jpc_fix_asl(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+
+ }
+
+}
+
+static void jpc_ft_fwdlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols, unsigned stride,
+ bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ hptr2[0] -= lptr2[0];
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //hptr2[0] -= (lptr2[0] + lptr2[stride]) >> 1;
+ hptr2[0] -= jpc_fix_asr(lptr2[0] + lptr2[stride], 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ hptr2[0] -= lptr2[0];
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] += (hptr2[0] + 1) >> 1;
+ lptr2[0] += jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] += (hptr2[0] + hptr2[stride] + 2) >> 2;
+ lptr2[0] += jpc_fix_asr(hptr2[0] + hptr2[stride] + 2, 2);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] += (hptr2[0] + 1) >> 1;
+ lptr2[0] += jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ } else {+
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] <<= 1;
+ lptr2[0] = jpc_fix_asl(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+
+ }
+
+}
+
+static void jpc_ft_invlift_row(jpc_fix_t *a, unsigned numcols, bool parity)
+{+
+ register jpc_fix_t *lptr;
+ register jpc_fix_t *hptr;
+
+ const unsigned llen = (numcols + !parity) >> 1;
+ const bool end_parity = parity == (numcols & 1);
+
+ if (numcols > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (!parity) {+ //lptr[0] -= (hptr[0] + 1) >> 1;
+ lptr[0] -= jpc_fix_asr(hptr[0] + 1, 1);
+ ++lptr;
+ }
+ for (unsigned n = llen - (!parity) - (!end_parity); n > 0; --n) {+ //lptr[0] -= (hptr[0] + hptr[1] + 2) >> 2;
+ lptr[0] -= jpc_fix_asr(hptr[0] + hptr[1] + 2, 2);
+ ++lptr;
+ ++hptr;
+ }
+ if (!end_parity) {+ //lptr[0] -= (hptr[0] + 1) >> 1;
+ lptr[0] -= jpc_fix_asr(hptr[0] + 1, 1);
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (parity) {+ hptr[0] += lptr[0];
+ ++hptr;
+ }
+ for (unsigned n = numcols - llen - parity - end_parity; n > 0; --n) {+ //hptr[0] += (lptr[0] + lptr[1]) >> 1;
+ hptr[0] += jpc_fix_asr(lptr[0] + lptr[1], 1);
+ ++hptr;
+ ++lptr;
+ }
+ if (end_parity) {+ hptr[0] += lptr[0];
+ }
+
+ } else {+
+ if (parity) {+ lptr = &a[0];
+ //lptr[0] >>= 1;
+ lptr[0] = jpc_fix_asr(lptr[0], 1);
+ }
+
+ }
+
+}
+
+static void jpc_ft_invlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride, bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] -= (hptr2[0] + 1) >> 1;
+ lptr2[0] -= jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] -= (hptr2[0] + hptr2[stride] + 2) >> 2;
+ lptr2[0] -= jpc_fix_asr(hptr2[0] + hptr2[stride] + 2, 2);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] -= (hptr2[0] + 1) >> 1;
+ lptr2[0] -= jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ hptr2[0] += lptr2[0];
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //hptr2[0] += (lptr2[0] + lptr2[stride]) >> 1;
+ hptr2[0] += jpc_fix_asr(lptr2[0] + lptr2[stride], 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ hptr2[0] += lptr2[0];
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ } else {+
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] >>= 1;
+ lptr2[0] = jpc_fix_asr(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+
+ }
+
+}
+
+static void jpc_ft_invlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols, unsigned stride,
+ bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] -= (hptr2[0] + 1) >> 1;
+ lptr2[0] -= jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] -= (hptr2[0] + hptr2[stride] + 2) >> 2;
+ lptr2[0] -= jpc_fix_asr(hptr2[0] + hptr2[stride] + 2, 2);
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] -= (hptr2[0] + 1) >> 1;
+ lptr2[0] -= jpc_fix_asr(hptr2[0] + 1, 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ hptr2[0] += lptr2[0];
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ //hptr2[0] += (lptr2[0] + lptr2[stride]) >> 1;
+ hptr2[0] += jpc_fix_asr(lptr2[0] + lptr2[stride], 1);
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ hptr2[0] += lptr2[0];
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ } else {+
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] >>= 1;
+ lptr2[0] = jpc_fix_asr(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+
+ }
+
+}
+
+static int jpc_ft_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
+ int stride)
+{+ const unsigned numrows = height;
+ const unsigned numcols = width;
+ const unsigned rowparity = ystart & 1;
+ const unsigned colparity = xstart & 1;
+ jpc_fix_t *startptr;
+
+ const unsigned maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
+ startptr = &a[0];
+ for (unsigned i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {+ jpc_qmfb_split_colgrp(startptr, numrows, stride, rowparity);
+ jpc_ft_fwdlift_colgrp(startptr, numrows, stride, rowparity);
+ startptr += JPC_QMFB_COLGRPSIZE;
+ }
+ if (maxcols < numcols) {+ jpc_qmfb_split_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ jpc_ft_fwdlift_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ }
+
+ startptr = &a[0];
+ for (unsigned i = 0; i < numrows; ++i) {+ jpc_qmfb_split_row(startptr, numcols, colparity);
+ jpc_ft_fwdlift_row(startptr, numcols, colparity);
+ startptr += stride;
+ }
+
+ return 0;
+
+}
+
+static int jpc_ft_synthesize(jpc_fix_t *a, int xstart, int ystart, int width, int height,
+ int stride)
+{+ const unsigned numrows = height;
+ const unsigned numcols = width;
+ const unsigned rowparity = ystart & 1;
+ const unsigned colparity = xstart & 1;
+
+ jpc_fix_t *startptr;
+
+ startptr = &a[0];
+ for (unsigned i = 0; i < numrows; ++i) {+ jpc_ft_invlift_row(startptr, numcols, colparity);
+ jpc_qmfb_join_row(startptr, numcols, colparity);
+ startptr += stride;
+ }
+
+ const unsigned maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
+ startptr = &a[0];
+ for (unsigned i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {+ jpc_ft_invlift_colgrp(startptr, numrows, stride, rowparity);
+ jpc_qmfb_join_colgrp(startptr, numrows, stride, rowparity);
+ startptr += JPC_QMFB_COLGRPSIZE;
+ }
+ if (maxcols < numcols) {+ jpc_ft_invlift_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ jpc_qmfb_join_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ }
+
+ return 0;
+
+}
+
+/******************************************************************************\
+* 9/7 transform
+\******************************************************************************/
+
+#define ALPHA (-1.586134342059924)
+#define BETA (-0.052980118572961)
+#define GAMMA (0.882911075530934)
+#define DELTA (0.443506852043971)
+#define LGAIN (1.0 / 1.23017410558578)
+#define HGAIN (1.0 / 1.62578613134411)
+
+static void jpc_ns_fwdlift_row(jpc_fix_t *a, unsigned numcols, bool parity)
+{+
+ register jpc_fix_t *lptr;
+ register jpc_fix_t *hptr;
+
+ const unsigned llen = (numcols + !parity) >> 1;
+ const bool end_parity = parity == (numcols & 1);
+
+ if (numcols > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (parity) {+ jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
+ lptr[0]));
+ ++hptr;
+ }
+ for (unsigned n = numcols - llen - parity - end_parity; n > 0; --n) {+ jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
+ jpc_fix_add(lptr[0], lptr[1])));
+ ++hptr;
+ ++lptr;
+ }
+ if (end_parity) {+ jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
+ lptr[0]));
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (!parity) {+ jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
+ hptr[0]));
+ ++lptr;
+ }
+ for (unsigned n = llen - (!parity) - (!end_parity); n > 0; --n) {+ jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(BETA),
+ jpc_fix_add(hptr[0], hptr[1])));
+ ++lptr;
+ ++hptr;
+ }
+ if (!end_parity) {+ jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
+ hptr[0]));
+ }
+
+ /* Apply the third lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (parity) {+ jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
+ lptr[0]));
+ ++hptr;
+ }
+ for (unsigned n = numcols - llen - parity - end_parity; n > 0; --n) {+ jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
+ jpc_fix_add(lptr[0], lptr[1])));
+ ++hptr;
+ ++lptr;
+ }
+ if (end_parity) {+ jpc_fix_pluseq(hptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
+ lptr[0]));
+ }
+
+ /* Apply the fourth lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen];
+ if (!parity) {+ jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
+ hptr[0]));
+ ++lptr;
+ }
+ for (unsigned n = llen - (!parity) - (!end_parity); n > 0; --n) {+ jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(DELTA),
+ jpc_fix_add(hptr[0], hptr[1])));
+ ++lptr;
+ ++hptr;
+ }
+ if (!end_parity) {+ jpc_fix_pluseq(lptr[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
+ hptr[0]));
+ }
+
+ /* Apply the scaling step. */
+#if defined(WT_DOSCALE)
+ lptr = &a[0];
+ for (unsigned n = llen; n > 0; --n) {+ lptr[0] = jpc_fix_mul(lptr[0], jpc_dbltofix(LGAIN));
+ ++lptr;
+ }
+ hptr = &a[llen];
+ for (unsigned n = numcols - llen; n > 0; --n) {+ hptr[0] = jpc_fix_mul(hptr[0], jpc_dbltofix(HGAIN));
+ ++hptr;
+ }
+#endif
+
+ } else {+
+#if defined(WT_LENONE)
+ if (parity) {+ lptr = &a[0];
+ //lptr[0] <<= 1;
+ lptr[0] = jpc_fix_asl(lptr[0], 1);
+ }
+#endif
+
+ }
+
+}
+
+static void jpc_ns_fwdlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride,
+ bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
+ lptr2[0]));
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
+ jpc_fix_add(lptr2[0], lptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
+ lptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
+ jpc_fix_add(hptr2[0], hptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the third lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
+ lptr2[0]));
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
+ jpc_fix_add(lptr2[0], lptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
+ lptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the fourth lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
+ jpc_fix_add(hptr2[0], hptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the scaling step. */
+#if defined(WT_DOSCALE)
+ lptr = &a[0];
+ for (unsigned n = llen; n > 0; --n) {+ lptr2 = lptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(LGAIN));
+ ++lptr2;
+ }
+ lptr += stride;
+ }
+ hptr = &a[llen * stride];
+ for (unsigned n = numrows - llen; n > 0; --n) {+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(HGAIN));
+ ++hptr2;
+ }
+ hptr += stride;
+ }
+#endif
+
+ } else {+
+#if defined(WT_LENONE)
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] <<= 1;
+ lptr2[0] = jpc_fix_asl(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+#endif
+
+ }
+
+}
+
+static void jpc_ns_fwdlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols,
+ unsigned stride, bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the first lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
+ lptr2[0]));
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(ALPHA),
+ jpc_fix_add(lptr2[0], lptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * ALPHA),
+ lptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the second lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(BETA),
+ jpc_fix_add(hptr2[0], hptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * BETA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the third lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
+ lptr2[0]));
+ ++hptr2;
+ ++lptr2;
+ }
+ hptr += stride;
+ }
+ for (unsigned n = numrows - llen - parity - end_parity; n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(GAMMA),
+ jpc_fix_add(lptr2[0], lptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ hptr += stride;
+ lptr += stride;
+ }
+ if (end_parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(hptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * GAMMA),
+ lptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the fourth lifting step. */
+ lptr = &a[0];
+ hptr = &a[llen * stride];
+ if (!parity) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ }
+ for (unsigned n = llen - (!parity) - (parity != (numrows & 1)); n > 0; --n) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(DELTA),
+ jpc_fix_add(hptr2[0], hptr2[stride])));
+ ++lptr2;
+ ++hptr2;
+ }
+ lptr += stride;
+ hptr += stride;
+ }
+ if (parity != (numrows & 1)) {+ lptr2 = lptr;
+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ jpc_fix_pluseq(lptr2[0], jpc_fix_mul(jpc_dbltofix(2.0 * DELTA),
+ hptr2[0]));
+ ++lptr2;
+ ++hptr2;
+ }
+ }
+
+ /* Apply the scaling step. */
+#if defined(WT_DOSCALE)
+ lptr = &a[0];
+ for (unsigned n = llen; n > 0; --n) {+ lptr2 = lptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(LGAIN));
+ ++lptr2;
+ }
+ lptr += stride;
+ }
+ hptr = &a[llen * stride];
+ for (unsigned n = numrows - llen; n > 0; --n) {+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(HGAIN));
+ ++hptr2;
+ }
+ hptr += stride;
+ }
+#endif
+
+ } else {+
+#if defined(WT_LENONE)
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] <<= 1;
+ lptr2[0] = jpc_fix_asl(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+#endif
+
+ }
+
+}
+
+#ifdef _MSC_VER
+/* MSVC doesn't support C99 "restrict" */
+#define restrict
+#endif
+
+JAS_FORCE_INLINE
+static void jpc_invlift_n(jpc_fix_t *restrict dest,
+ const jpc_fix_t *restrict src,
+ jpc_fix_t factor,
+ size_t n)
+{+ for (size_t i = 0; i < n; ++i)
+ jpc_fix_minuseq(dest[i], jpc_fix_mul(factor, src[i]));
+}
+
+JAS_FORCE_INLINE
+static void jpc_invlift_pair_stride(jpc_fix_t *restrict dest,
+ const jpc_fix_t *restrict src,
+ jpc_fix_t factor,
+ size_t n, size_t stride)
+{+ for (size_t i = 0; i < n; ++i)
+ jpc_fix_minuseq(dest[i],
+ jpc_fix_mul(factor,
+ jpc_fix_add(src[i], src[i + stride])));
+}
+
+JAS_FORCE_INLINE
+static void jpc_invlift_pair(jpc_fix_t *restrict dest,
+ const jpc_fix_t *restrict src,
+ jpc_fix_t factor,
+ size_t n)
+{+ jpc_invlift_pair_stride(dest, src, factor, n, 1);
+}
+
+static void jpc_invlift_pair_with_parity(jpc_fix_t *restrict dest,
+ const jpc_fix_t *restrict src,
+ jpc_fix_t factor,
+ jpc_fix_t border_factor,
+ size_t n,
+ bool start_parity, bool end_parity)
+{+ if (start_parity) {+ jpc_fix_minuseq(*dest, jpc_fix_mul(border_factor, *src));
+ ++dest;
+ }
+
+ n -= start_parity + end_parity;
+ jpc_invlift_pair(dest, src, factor, n);
+ dest += n;
+ src += n;
+
+ if (end_parity)
+ jpc_fix_minuseq(*dest, jpc_fix_mul(border_factor, *src));
+}
+
+static void jpc_invlift_column_with_parity(jpc_fix_t *restrict dest,
+ const jpc_fix_t *restrict src,
+ jpc_fix_t factor,
+ jpc_fix_t border_factor,
+ size_t n_columns,
+ size_t n_rows,
+ size_t stride,
+ bool start_parity, bool end_parity)
+{+ if (start_parity) {+ jpc_invlift_n(dest, src, border_factor, n_columns);
+ dest += stride;
+ }
+
+ n_rows -= start_parity + end_parity;
+ for (size_t i = 0; i < n_rows; ++i) {+ jpc_invlift_pair_stride(dest, src, factor,
+ n_columns, stride);
+ dest += stride;
+ src += stride;
+ }
+
+ if (end_parity)
+ jpc_invlift_n(dest, src, border_factor, n_columns);
+}
+
+static void jpc_ns_invlift_row(jpc_fix_t *a, unsigned numcols, bool parity)
+{+
+ register jpc_fix_t *lptr;
+ register jpc_fix_t *hptr;
+
+ const unsigned llen = (numcols + !parity) >> 1;
+ const bool end_parity = parity == (numcols & 1);
+
+ if (numcols > 1) {+
+ /* Apply the scaling step. */
+#if defined(WT_DOSCALE)
+ lptr = &a[0];
+ for (unsigned n = llen; n > 0; --n) {+ lptr[0] = jpc_fix_mul(lptr[0], jpc_dbltofix(1.0 / LGAIN));
+ ++lptr;
+ }
+ hptr = &a[llen];
+ for (unsigned n = numcols - llen; n > 0; --n) {+ hptr[0] = jpc_fix_mul(hptr[0], jpc_dbltofix(1.0 / HGAIN));
+ ++hptr;
+ }
+#endif
+
+ /* Apply the first lifting step. */
+ jpc_invlift_pair_with_parity(&a[0], &a[llen],
+ jpc_dbltofix(DELTA),
+ jpc_dbltofix(2 * DELTA),
+ llen,
+ !parity, !end_parity);
+
+ /* Apply the second lifting step. */
+ jpc_invlift_pair_with_parity(&a[llen], &a[0],
+ jpc_dbltofix(GAMMA),
+ jpc_dbltofix(2 * GAMMA),
+ numcols - llen,
+ parity, end_parity);
+
+ /* Apply the third lifting step. */
+ jpc_invlift_pair_with_parity(&a[0], &a[llen],
+ jpc_dbltofix(BETA),
+ jpc_dbltofix(2 * BETA),
+ llen, !parity, !end_parity);
+
+ /* Apply the fourth lifting step. */
+ jpc_invlift_pair_with_parity(&a[llen], &a[0],
+ jpc_dbltofix(ALPHA),
+ jpc_dbltofix(2 * ALPHA),
+ numcols - llen,
+ parity, end_parity);
+
+ } else {+
+#if defined(WT_LENONE)
+ if (parity) {+ lptr = &a[0];
+ //lptr[0] >>= 1;
+ lptr[0] = jpc_fix_asr(lptr[0], 1);
+ }
+#endif
+
+ }
+
+}
+
+static void jpc_ns_invlift_colgrp(jpc_fix_t *a, unsigned numrows, unsigned stride,
+ bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the scaling step. */
+#if defined(WT_DOSCALE)
+ lptr = &a[0];
+ for (unsigned n = llen; n > 0; --n) {+ lptr2 = lptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(1.0 / LGAIN));
+ ++lptr2;
+ }
+ lptr += stride;
+ }
+ hptr = &a[llen * stride];
+ for (unsigned n = numrows - llen; n > 0; --n) {+ hptr2 = hptr;
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(1.0 / HGAIN));
+ ++hptr2;
+ }
+ hptr += stride;
+ }
+#endif
+
+ /* Apply the first lifting step. */
+ jpc_invlift_column_with_parity(&a[0], &a[llen * stride],
+ jpc_dbltofix(DELTA),
+ jpc_dbltofix(2 * DELTA),
+ JPC_QMFB_COLGRPSIZE,
+ llen, stride,
+ !parity, !end_parity);
+
+ /* Apply the second lifting step. */
+ jpc_invlift_column_with_parity(&a[llen * stride], &a[0],
+ jpc_dbltofix(GAMMA),
+ jpc_dbltofix(2 * GAMMA),
+ JPC_QMFB_COLGRPSIZE,
+ numrows - llen, stride,
+ parity, end_parity);
+
+ /* Apply the third lifting step. */
+ jpc_invlift_column_with_parity(&a[0], &a[llen * stride],
+ jpc_dbltofix(BETA),
+ jpc_dbltofix(2 * BETA),
+ JPC_QMFB_COLGRPSIZE,
+ llen, stride,
+ !parity, !end_parity);
+
+ /* Apply the fourth lifting step. */
+ jpc_invlift_column_with_parity(&a[llen * stride], &a[0],
+ jpc_dbltofix(ALPHA),
+ jpc_dbltofix(2 * ALPHA),
+ JPC_QMFB_COLGRPSIZE,
+ numrows - llen, stride,
+ parity, end_parity);
+
+ } else {+
+#if defined(WT_LENONE)
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < JPC_QMFB_COLGRPSIZE; ++i) {+ //lptr2[0] >>= 1;
+ lptr2[0] = jpc_fix_asr(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+#endif
+
+ }
+
+}
+
+static void jpc_ns_invlift_colres(jpc_fix_t *a, unsigned numrows, unsigned numcols,
+ unsigned stride, bool parity)
+{+
+ jpc_fix_t *lptr;
+ jpc_fix_t *hptr;
+ register jpc_fix_t *lptr2;
+ register jpc_fix_t *hptr2;
+
+ const unsigned llen = (numrows + !parity) >> 1;
+ const bool end_parity = parity == (numrows & 1);
+
+ if (numrows > 1) {+
+ /* Apply the scaling step. */
+#if defined(WT_DOSCALE)
+ lptr = &a[0];
+ for (unsigned n = llen; n > 0; --n) {+ lptr2 = lptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ lptr2[0] = jpc_fix_mul(lptr2[0], jpc_dbltofix(1.0 / LGAIN));
+ ++lptr2;
+ }
+ lptr += stride;
+ }
+ hptr = &a[llen * stride];
+ for (unsigned n = numrows - llen; n > 0; --n) {+ hptr2 = hptr;
+ for (unsigned i = 0; i < numcols; ++i) {+ hptr2[0] = jpc_fix_mul(hptr2[0], jpc_dbltofix(1.0 / HGAIN));
+ ++hptr2;
+ }
+ hptr += stride;
+ }
+#endif
+
+ /* Apply the first lifting step. */
+ jpc_invlift_column_with_parity(&a[0], &a[llen * stride],
+ jpc_dbltofix(DELTA),
+ jpc_dbltofix(2 * DELTA),
+ numcols,
+ llen, stride,
+ !parity, !end_parity);
+
+ /* Apply the second lifting step. */
+ jpc_invlift_column_with_parity(&a[llen * stride], &a[0],
+ jpc_dbltofix(GAMMA),
+ jpc_dbltofix(2 * GAMMA),
+ numcols,
+ numrows - llen, stride,
+ parity, end_parity);
+
+ /* Apply the third lifting step. */
+ jpc_invlift_column_with_parity(&a[0], &a[llen * stride],
+ jpc_dbltofix(BETA),
+ jpc_dbltofix(2 * BETA),
+ numcols,
+ llen, stride,
+ !parity, !end_parity);
+
+ /* Apply the fourth lifting step. */
+ jpc_invlift_column_with_parity(&a[llen * stride], &a[0],
+ jpc_dbltofix(ALPHA),
+ jpc_dbltofix(2 * ALPHA),
+ numcols,
+ numrows - llen, stride,
+ parity, end_parity);
+
+ } else {+
+#if defined(WT_LENONE)
+ if (parity) {+ lptr2 = &a[0];
+ for (unsigned i = 0; i < numcols; ++i) {+ //lptr2[0] >>= 1;
+ lptr2[0] = jpc_fix_asr(lptr2[0], 1);
+ ++lptr2;
+ }
+ }
+#endif
+
+ }
+
+}
+
+static int jpc_ns_analyze(jpc_fix_t *a, int xstart, int ystart, int width, int height,
+ int stride)
+{+
+ const unsigned numrows = height;
+ const unsigned numcols = width;
+ const unsigned rowparity = ystart & 1;
+ const unsigned colparity = xstart & 1;
+ jpc_fix_t *startptr;
+
+ const unsigned maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
+ startptr = &a[0];
+ for (unsigned i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {+ jpc_qmfb_split_colgrp(startptr, numrows, stride, rowparity);
+ jpc_ns_fwdlift_colgrp(startptr, numrows, stride, rowparity);
+ startptr += JPC_QMFB_COLGRPSIZE;
+ }
+ if (maxcols < numcols) {+ jpc_qmfb_split_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ jpc_ns_fwdlift_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ }
+
+ startptr = &a[0];
+ for (unsigned i = 0; i < numrows; ++i) {+ jpc_qmfb_split_row(startptr, numcols, colparity);
+ jpc_ns_fwdlift_row(startptr, numcols, colparity);
+ startptr += stride;
+ }
+
+ return 0;
+
+}
+
+static int jpc_ns_synthesize(jpc_fix_t *a, int xstart, int ystart, int width,
+ int height, int stride)
+{+
+ const unsigned numrows = height;
+ const unsigned numcols = width;
+ const unsigned rowparity = ystart & 1;
+ const unsigned colparity = xstart & 1;
+ jpc_fix_t *startptr;
+
+ startptr = &a[0];
+ for (unsigned i = 0; i < numrows; ++i) {+ jpc_ns_invlift_row(startptr, numcols, colparity);
+ jpc_qmfb_join_row(startptr, numcols, colparity);
+ startptr += stride;
+ }
+
+ const unsigned maxcols = (numcols / JPC_QMFB_COLGRPSIZE) * JPC_QMFB_COLGRPSIZE;
+ startptr = &a[0];
+ for (unsigned i = 0; i < maxcols; i += JPC_QMFB_COLGRPSIZE) {+ jpc_ns_invlift_colgrp(startptr, numrows, stride, rowparity);
+ jpc_qmfb_join_colgrp(startptr, numrows, stride, rowparity);
+ startptr += JPC_QMFB_COLGRPSIZE;
+ }
+ if (maxcols < numcols) {+ jpc_ns_invlift_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ jpc_qmfb_join_colres(startptr, numrows, numcols - maxcols, stride,
+ rowparity);
+ }
+
+ return 0;
+
+}
+
--- /dev/null
+++ b/jpc_qmfb.h
@@ -1,0 +1,113 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2004 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Quadrature Mirror-Image Filter Bank (QMFB) Routines
+ *
+ * $Id$
+ */
+
+#ifndef JPC_QMFB_H
+#define JPC_QMFB_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_fix.h"
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/* QMFB IDs. */
+#define JPC_QMFB1D_FT 1 /* 5/3 */
+#define JPC_QMFB1D_NS 2 /* 9/7 */
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+#if !defined(JPC_QMFB_COLGRPSIZE)
+/* The number of columns to group together during the vertical processing
+stage of the wavelet transform. */
+/* The default value for this parameter is probably not optimal for
+any particular platform. Hopefully, it is not too unreasonable, however. */
+#define JPC_QMFB_COLGRPSIZE 16
+#endif
+
+typedef struct {+ int (*analyze)(jpc_fix_t *, int, int, int, int, int);
+ int (*synthesize)(jpc_fix_t *, int, int, int, int, int);
+ const double *lpenergywts;
+ const double *hpenergywts;
+} jpc_qmfb2d_t;
+
+extern const jpc_qmfb2d_t jpc_ft_qmfb2d;
+extern const jpc_qmfb2d_t jpc_ns_qmfb2d;
+
+#endif
--- /dev/null
+++ b/jpc_t1cod.c
@@ -1,0 +1,485 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_t1cod.h"
+#include "jpc_cod.h"
+#include "jpc_cs.h"
+#include "jpc_mqcod.h"
+#include "jpc_tsfb.h"
+
+#include "jasper/jas_math.h"
+
+JAS_ATTRIBUTE_CONST
+static double jpc_pow2i(int n);
+
+/******************************************************************************\
+* Global data.
+\******************************************************************************/
+
+uint_least8_t jpc_zcctxnolut[4 * 256];
+bool jpc_spblut[256];
+uint_least8_t jpc_scctxnolut[256];
+uint_least8_t jpc_magctxnolut[4096];
+
+jpc_fix_t jpc_signmsedec[1 << JPC_NMSEDEC_BITS];
+jpc_fix_t jpc_refnmsedec[1 << JPC_NMSEDEC_BITS];
+jpc_fix_t jpc_signmsedec0[1 << JPC_NMSEDEC_BITS];
+jpc_fix_t jpc_refnmsedec0[1 << JPC_NMSEDEC_BITS];
+
+jpc_mqctx_t jpc_mqctxs[JPC_NUMCTXS];
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+JAS_ATTRIBUTE_CONST
+static uint_least8_t jpc_getzcctxno(unsigned f, enum jpc_tsfb_orient orient);
+
+JAS_ATTRIBUTE_CONST
+static bool jpc_getspb(unsigned f);
+
+JAS_ATTRIBUTE_CONST
+static uint_least8_t jpc_getscctxno(unsigned f);
+
+JAS_ATTRIBUTE_CONST
+static uint_least8_t jpc_getmagctxno(unsigned f);
+
+static void jpc_initmqctxs(void);
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+enum jpc_passtype JPC_PASSTYPE(unsigned passno)
+{+ unsigned passtype = -1;
+ switch (passno % 3) {+ case 0:
+ passtype = JPC_CLNPASS;
+ break;
+ case 1:
+ passtype = JPC_SIGPASS;
+ break;
+ case 2:
+ passtype = JPC_REFPASS;
+ break;
+ default:
+ assert(0);
+ JAS_UNREACHABLE();
+ }
+ return passtype;
+}
+
+unsigned JPC_NOMINALGAIN(unsigned qmfbid, unsigned numlvls, unsigned lvlno, enum jpc_tsfb_orient orient)
+{+ /* Avoid compiler warnings about unused parameters. */
+ (void)numlvls;
+
+ if (qmfbid == JPC_COX_INS) {+ return 0;
+ }
+ assert(qmfbid == JPC_COX_RFT);
+ if (lvlno == 0) {+ assert(orient == JPC_TSFB_LL);
+ return 0;
+ } else {+ switch (orient) {+ case JPC_TSFB_LH:
+ case JPC_TSFB_HL:
+ return 1;
+ case JPC_TSFB_HH:
+ return 2;
+ default:
+ assert(false);
+ JAS_UNREACHABLE();
+ }
+ }
+ return -1;
+}
+
+/******************************************************************************\
+* Coding pass related functions.
+\******************************************************************************/
+
+enum jpc_segtype JPC_SEGTYPE(unsigned passno, unsigned firstpassno, bool bypass)
+{+ if (bypass) {+ enum jpc_passtype passtype = JPC_PASSTYPE(passno);
+ if (passtype == JPC_CLNPASS) {+ return JPC_SEG_MQ;
+ }
+ return ((passno < firstpassno + 10) ? JPC_SEG_MQ : JPC_SEG_RAW);
+ } else {+ return JPC_SEG_MQ;
+ }
+}
+
+unsigned JPC_SEGPASSCNT(unsigned passno, unsigned firstpassno, unsigned numpasses, bool bypass, bool termall)
+{+ unsigned ret = -1;
+
+ if (termall) {+ ret = 1;
+ } else if (bypass) {+ if (passno < firstpassno + 10) {+ ret = 10 - (passno - firstpassno);
+ } else {+ enum jpc_passtype passtype = JPC_PASSTYPE(passno);
+ switch (passtype) {+ case JPC_SIGPASS:
+ ret = 2;
+ break;
+ case JPC_REFPASS:
+ ret = 1;
+ break;
+ case JPC_CLNPASS:
+ ret = 1;
+ break;
+ default:
+ assert(0);
+ JAS_UNREACHABLE();
+ }
+ }
+ } else {+ ret = JPC_PREC * 3 - 2;
+ }
+ ret = JAS_MIN(ret, numpasses - passno);
+ return ret;
+}
+
+bool JPC_ISTERMINATED(unsigned passno, unsigned firstpassno, unsigned numpasses, bool termall,
+ bool lazy)
+{+ if (passno - firstpassno == numpasses - 1) {+ return true;
+ } else {+ unsigned n = JPC_SEGPASSCNT(passno, firstpassno, numpasses, lazy, termall);
+ return n <= 1;
+ }
+}
+
+/******************************************************************************\
+* Lookup table code.
+\******************************************************************************/
+
+void jpc_initluts()
+{+ float u;
+ float v;
+ float t;
+
+/* XXX - hack */
+jpc_initmqctxs();
+
+ for (unsigned orient = 0; orient < 4; ++orient) {+ for (unsigned i = 0; i < 256; ++i) {+ jpc_zcctxnolut[(orient << 8) | i] = jpc_getzcctxno(i, orient);
+ }
+ }
+
+ for (unsigned i = 0; i < 256; ++i) {+ jpc_spblut[i] = jpc_getspb(i << 4);
+ }
+
+ for (unsigned i = 0; i < 256; ++i) {+ jpc_scctxnolut[i] = jpc_getscctxno(i << 4);
+ }
+
+ for (unsigned refine = 0; refine < 2; ++refine) {+ for (unsigned i = 0; i < 2048; ++i) {+ jpc_magctxnolut[(refine << 11) + i] = jpc_getmagctxno((refine ? JPC_REFINE : 0) | i);
+ }
+ }
+
+ for (unsigned i = 0; i < (1 << JPC_NMSEDEC_BITS); ++i) {+ t = i * jpc_pow2i(-JPC_NMSEDEC_FRACBITS);
+ u = t;
+ v = t - 1.5f;
+ jpc_signmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+/* XXX - this calc is not correct */
+ jpc_signmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+ u = t - 1.0f;
+ if (i & (1 << (JPC_NMSEDEC_BITS - 1))) {+ v = t - 1.5f;
+ } else {+ v = t - 0.5f;
+ }
+ jpc_refnmsedec[i] = jpc_dbltofix(floor((u * u - v * v) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+/* XXX - this calc is not correct */
+ jpc_refnmsedec0[i] = jpc_dbltofix(floor((u * u) * jpc_pow2i(JPC_NMSEDEC_FRACBITS) + 0.5) / jpc_pow2i(JPC_NMSEDEC_FRACBITS));
+ }
+}
+
+static uint_least8_t jpc_getzcctxno(unsigned f, enum jpc_tsfb_orient orient)
+{+ assert(orient < 4);
+
+ unsigned n = -1;
+ unsigned t;
+ unsigned hv;
+
+ unsigned h = ((f & JPC_WSIG) != 0) + ((f & JPC_ESIG) != 0);
+ unsigned v = ((f & JPC_NSIG) != 0) + ((f & JPC_SSIG) != 0);
+ const unsigned d = ((f & JPC_NWSIG) != 0) + ((f & JPC_NESIG) != 0) + ((f & JPC_SESIG) != 0) + ((f & JPC_SWSIG) != 0);
+ switch (orient) {+ case JPC_TSFB_HL:
+ t = h;
+ h = v;
+ v = t;
+ /* fall through */
+ case JPC_TSFB_LL:
+ case JPC_TSFB_LH:
+ if (!h) {+ if (!v) {+ if (!d) {+ n = 0;
+ } else if (d == 1) {+ n = 1;
+ } else {+ n = 2;
+ }
+ } else if (v == 1) {+ n = 3;
+ } else {+ n = 4;
+ }
+ } else if (h == 1) {+ if (!v) {+ if (!d) {+ n = 5;
+ } else {+ n = 6;
+ }
+ } else {+ n = 7;
+ }
+ } else {+ n = 8;
+ }
+ break;
+ case JPC_TSFB_HH:
+ hv = h + v;
+ if (!d) {+ if (!hv) {+ n = 0;
+ } else if (hv == 1) {+ n = 1;
+ } else {+ n = 2;
+ }
+ } else if (d == 1) {+ if (!hv) {+ n = 3;
+ } else if (hv == 1) {+ n = 4;
+ } else {+ n = 5;
+ }
+ } else if (d == 2) {+ if (!hv) {+ n = 6;
+ } else {+ n = 7;
+ }
+ } else {+ n = 8;
+ }
+ break;
+
+ default:
+ assert(false);
+ JAS_UNREACHABLE();
+ }
+ assert(n < JPC_NUMZCCTXS);
+ return JPC_ZCCTXNO + n;
+}
+
+static bool jpc_getspb(unsigned f)
+{+ int hc;
+ int vc;
+ bool n;
+
+ hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG), 1) -
+ JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) + ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
+ vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG), 1) -
+ JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) + ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
+ if (!hc && !vc) {+ n = 0;
+ } else {+ n = (!(hc > 0 || (!hc && vc > 0)));
+ }
+ return n;
+}
+
+static uint_least8_t jpc_getscctxno(unsigned f)
+{+ int hc;
+ int vc;
+
+ hc = JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == JPC_ESIG) + ((f & (JPC_WSIG | JPC_WSGN)) == JPC_WSIG),
+ 1) - JAS_MIN(((f & (JPC_ESIG | JPC_ESGN)) == (JPC_ESIG | JPC_ESGN)) +
+ ((f & (JPC_WSIG | JPC_WSGN)) == (JPC_WSIG | JPC_WSGN)), 1);
+ vc = JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == JPC_NSIG) + ((f & (JPC_SSIG | JPC_SSGN)) == JPC_SSIG),
+ 1) - JAS_MIN(((f & (JPC_NSIG | JPC_NSGN)) == (JPC_NSIG | JPC_NSGN)) +
+ ((f & (JPC_SSIG | JPC_SSGN)) == (JPC_SSIG | JPC_SSGN)), 1);
+ assert(hc >= -1 && hc <= 1 && vc >= -1 && vc <= 1);
+ if (hc < 0) {+ hc = -hc;
+ vc = -vc;
+ }
+
+ unsigned n;
+ if (!hc) {+ if (vc == -1) {+ n = 1;
+ } else if (!vc) {+ n = 0;
+ } else {+ n = 1;
+ }
+ } else {+ assert(hc == 1);
+
+ if (vc == -1) {+ n = 2;
+ } else if (!vc) {+ n = 3;
+ } else {+ n = 4;
+ }
+ }
+ assert(n < JPC_NUMSCCTXS);
+ return JPC_SCCTXNO + n;
+}
+
+static uint_least8_t jpc_getmagctxno(unsigned f)
+{+ unsigned n;
+
+ if (!(f & JPC_REFINE)) {+ n = (f & (JPC_OTHSIGMSK)) ? 1 : 0;
+ } else {+ n = 2;
+ }
+
+ assert(n < JPC_NUMMAGCTXS);
+ return JPC_MAGCTXNO + n;
+}
+
+static void jpc_initctxs(jpc_mqctx_t *ctxs)
+{+ jpc_mqctx_t *ctx;
+
+ ctx = ctxs;
+ for (unsigned i = 0; i < JPC_NUMCTXS; ++i) {+ ctx->mps = 0;
+ switch (i) {+ case JPC_UCTXNO:
+ ctx->ind = 46;
+ break;
+ case JPC_ZCCTXNO:
+ ctx->ind = 4;
+ break;
+ case JPC_AGGCTXNO:
+ ctx->ind = 3;
+ break;
+ default:
+ ctx->ind = 0;
+ break;
+ }
+ ++ctx;
+ }
+}
+
+static void jpc_initmqctxs()
+{+ jpc_initctxs(jpc_mqctxs);
+}
+
+/* Calculate the real quantity exp2(n), where x is an integer. */
+static double jpc_pow2i(int n)
+{+ double x;
+ double a;
+
+ x = 1.0;
+ if (n < 0) {+ a = 0.5;
+ n = -n;
+ } else {+ a = 2.0;
+ }
+ while (--n >= 0) {+ x *= a;
+ }
+ return x;
+}
--- /dev/null
+++ b/jpc_t1cod.h
@@ -1,0 +1,319 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * $Id$
+ */
+
+#ifndef JPC_T1COD_H
+#define JPC_T1COD_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_fix.h"
+#include "jpc_mqcod.h"
+#include "jpc_tsfb.h"
+#include "jasper/jas_math.h"
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+/* The number of bits used to index into various lookup tables. */
+#define JPC_NMSEDEC_BITS 7
+#define JPC_NMSEDEC_FRACBITS (JPC_NMSEDEC_BITS - 1)
+
+/*
+ * Segment types.
+ */
+
+enum jpc_segtype {+ /** Invalid. */
+ JPC_SEG_INVALID,
+
+ /* MQ. */
+ JPC_SEG_MQ,
+
+ /* Raw. */
+ JPC_SEG_RAW,
+};
+
+/* The nominal word size. */
+#define JPC_PREC 32
+
+/* Tier-1 coding pass types. */
+enum jpc_passtype {+ JPC_SIGPASS, /*< significance */
+ JPC_REFPASS, /*< refinement */
+ JPC_CLNPASS, /*< cleanup */
+};
+
+/*
+ * Per-sample state information for tier-1 coding.
+ */
+
+/* The northeast neighbour has been found to be significant. */
+#define JPC_NESIG 0x0001
+/* The southeast neighbour has been found to be significant. */
+#define JPC_SESIG 0x0002
+/* The southwest neighbour has been found to be significant. */
+#define JPC_SWSIG 0x0004
+/* The northwest neighbour has been found to be significant. */
+#define JPC_NWSIG 0x0008
+/* The north neighbour has been found to be significant. */
+#define JPC_NSIG 0x0010
+/* The east neighbour has been found to be significant. */
+#define JPC_ESIG 0x0020
+/* The south neighbour has been found to be significant. */
+#define JPC_SSIG 0x0040
+/* The west neighbour has been found to be significant. */
+#define JPC_WSIG 0x0080
+/* The significance mask for 8-connected neighbours. */
+#define JPC_OTHSIGMSK \
+ (JPC_NSIG | JPC_NESIG | JPC_ESIG | JPC_SESIG | JPC_SSIG | JPC_SWSIG | JPC_WSIG | JPC_NWSIG)
+/* The significance mask for 4-connected neighbours. */
+#define JPC_PRIMSIGMSK (JPC_NSIG | JPC_ESIG | JPC_SSIG | JPC_WSIG)
+
+/* The north neighbour is negative in value. */
+#define JPC_NSGN 0x0100
+/* The east neighbour is negative in value. */
+#define JPC_ESGN 0x0200
+/* The south neighbour is negative in value. */
+#define JPC_SSGN 0x0400
+/* The west neighbour is negative in value. */
+#define JPC_WSGN 0x0800
+/* The sign mask for 4-connected neighbours. */
+#define JPC_SGNMSK (JPC_NSGN | JPC_ESGN | JPC_SSGN | JPC_WSGN)
+
+/* This sample has been found to be significant. */
+#define JPC_SIG 0x1000
+/* The sample has been refined. */
+#define JPC_REFINE 0x2000
+/* This sample has been processed during the significance pass. */
+#define JPC_VISIT 0x4000
+
+/* The number of aggregation contexts. */
+#define JPC_NUMAGGCTXS 1
+/* The number of zero coding contexts. */
+#define JPC_NUMZCCTXS 9
+/* The number of magnitude contexts. */
+#define JPC_NUMMAGCTXS 3
+/* The number of sign coding contexts. */
+#define JPC_NUMSCCTXS 5
+/* The number of uniform contexts. */
+#define JPC_NUMUCTXS 1
+
+/* The context ID for the first aggregation context. */
+#define JPC_AGGCTXNO 0
+/* The context ID for the first zero coding context. */
+#define JPC_ZCCTXNO (JPC_AGGCTXNO + JPC_NUMAGGCTXS)
+/* The context ID for the first magnitude context. */
+#define JPC_MAGCTXNO (JPC_ZCCTXNO + JPC_NUMZCCTXS)
+/* The context ID for the first sign coding context. */
+#define JPC_SCCTXNO (JPC_MAGCTXNO + JPC_NUMMAGCTXS)
+/* The context ID for the first uniform context. */
+#define JPC_UCTXNO (JPC_SCCTXNO + JPC_NUMSCCTXS)
+/* The total number of contexts. */
+#define JPC_NUMCTXS (JPC_UCTXNO + JPC_NUMUCTXS)
+
+/******************************************************************************\
+* External data.
+\******************************************************************************/
+
+/* These lookup tables are used by various macros/functions. */
+/* Do not access these lookup tables directly. */
+extern uint_least8_t jpc_zcctxnolut[];
+extern bool jpc_spblut[];
+extern uint_least8_t jpc_scctxnolut[];
+extern uint_least8_t jpc_magctxnolut[];
+extern jpc_fix_t jpc_refnmsedec[];
+extern jpc_fix_t jpc_signmsedec[];
+extern jpc_fix_t jpc_refnmsedec0[];
+extern jpc_fix_t jpc_signmsedec0[];
+
+/* The initial settings for the MQ contexts. */
+extern jpc_mqctx_t jpc_mqctxs[];
+
+/******************************************************************************\
+* Functions and macros.
+\******************************************************************************/
+
+/* Arithmetic shift right (with ability to shift left also). */
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t JPC_ASR(jpc_fix_t x, int n)
+{+ return n >= 0
+ ? x >> n
+ : x << -n;
+}
+
+/* Get the zero coding context. */
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JPC_GETZCCTXNO(unsigned f, enum jpc_tsfb_orient orient)
+{+ return jpc_zcctxnolut[((unsigned)orient << 8) | (f & JPC_OTHSIGMSK)];
+}
+
+/* Get the sign prediction bit. */
+JAS_ATTRIBUTE_CONST
+static inline bool JPC_GETSPB(unsigned f)
+{+ return jpc_spblut[(f & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4];
+}
+
+/* Get the sign coding context. */
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JPC_GETSCCTXNO(unsigned f)
+{+ return jpc_scctxnolut[(f & (JPC_PRIMSIGMSK | JPC_SGNMSK)) >> 4];
+}
+
+/* Get the magnitude context. */
+JAS_ATTRIBUTE_CONST
+static inline uint_least8_t JPC_GETMAGCTXNO(unsigned f)
+{+ return jpc_magctxnolut[(f & JPC_OTHSIGMSK) | (((f & JPC_REFINE) != 0) << 11)];
+}
+
+/* Get the normalized MSE reduction for significance passes. */
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t JPC_GETSIGNMSEDEC(jpc_fix_t x, int bitpos)
+{+ return bitpos > JPC_NMSEDEC_FRACBITS
+ ? jpc_signmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)]
+ : jpc_signmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)];
+}
+
+/* Get the normalized MSE reduction for refinement passes. */
+JAS_ATTRIBUTE_CONST
+static inline jpc_fix_t JPC_GETREFNMSEDEC(jpc_fix_t x, int bitpos)
+{+ return bitpos > JPC_NMSEDEC_FRACBITS
+ ? jpc_refnmsedec[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)]
+ : jpc_refnmsedec0[JPC_ASR(x, bitpos - JPC_NMSEDEC_FRACBITS) & JAS_ONES(JPC_NMSEDEC_BITS)];
+}
+
+/* Update the per-sample state information. */
+static inline void JPC_UPDATEFLAGS4(jpc_fix_t *fp, unsigned rowstep, bool s, bool vcausalflag)
+{+ jpc_fix_t *np = fp - rowstep;
+ jpc_fix_t *sp = fp + rowstep;
+ if (vcausalflag) {+ sp[-1] |= JPC_NESIG;
+ sp[1] |= JPC_NWSIG;
+ if (s) {+ *sp |= JPC_NSIG | JPC_NSGN;
+ fp[-1] |= JPC_ESIG | JPC_ESGN;
+ fp[1] |= JPC_WSIG | JPC_WSGN;
+ } else {+ *sp |= JPC_NSIG;
+ fp[-1] |= JPC_ESIG;
+ fp[1] |= JPC_WSIG;
+ }
+ } else {+ np[-1] |= JPC_SESIG;
+ np[1] |= JPC_SWSIG;
+ sp[-1] |= JPC_NESIG;
+ sp[1] |= JPC_NWSIG;
+ if (s) {+ *np |= JPC_SSIG | JPC_SSGN;
+ *sp |= JPC_NSIG | JPC_NSGN;
+ fp[-1] |= JPC_ESIG | JPC_ESGN;
+ fp[1] |= JPC_WSIG | JPC_WSGN;
+ } else {+ *np |= JPC_SSIG;
+ *sp |= JPC_NSIG;
+ fp[-1] |= JPC_ESIG;
+ fp[1] |= JPC_WSIG;
+ }
+ }
+}
+
+/* Initialize the lookup tables used by the codec. */
+void jpc_initluts(void);
+
+/* Get the nominal gain associated with a particular band. */
+JAS_ATTRIBUTE_CONST
+unsigned JPC_NOMINALGAIN(unsigned qmfbid, unsigned numlvls, unsigned lvlno, enum jpc_tsfb_orient orient);
+
+/* Get the coding pass type. */
+JAS_ATTRIBUTE_CONST
+enum jpc_passtype JPC_PASSTYPE(unsigned passno);
+
+/* Get the segment type. */
+JAS_ATTRIBUTE_CONST
+enum jpc_segtype JPC_SEGTYPE(unsigned passno, unsigned firstpassno, bool bypass);
+
+/* Get the number of coding passess in the segment. */
+JAS_ATTRIBUTE_CONST
+unsigned JPC_SEGPASSCNT(unsigned passno, unsigned firstpassno, unsigned numpasses, bool bypass,
+ bool termall);
+
+/* Is the coding pass terminated? */
+JAS_ATTRIBUTE_CONST
+bool JPC_ISTERMINATED(unsigned passno, unsigned firstpassno, unsigned numpasses, bool termall,
+ bool lazy);
+
+#endif
--- /dev/null
+++ b/jpc_t1dec.c
@@ -1,0 +1,799 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tier 1 Decoder
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_t1dec.h"
+#include "jpc_bs.h"
+#include "jpc_mqdec.h"
+#include "jpc_t1cod.h"
+#include "jpc_dec.h"
+
+#include "jasper/jas_stream.h"
+#include "jasper/jas_math.h"
+#include "jasper/jas_debug.h"
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static int jpc_dec_decodecblk(jpc_dec_tile_t *tile, jpc_dec_tcomp_t *tcomp, jpc_dec_band_t *band,
+ jpc_dec_cblk_t *cblk, int dopartial, int maxlyrs);
+static int dec_sigpass(jpc_mqdec_t *mqdec, unsigned bitpos, enum jpc_tsfb_orient orient,
+ bool vcausalflag, jas_matrix_t *flags, jas_matrix_t *data);
+static int dec_rawsigpass(jpc_bitstream_t *in, unsigned bitpos,
+ bool vcausalflag, jas_matrix_t *flags, jas_matrix_t *data);
+static int dec_refpass(jpc_mqdec_t *mqdec, unsigned bitpos,
+ jas_matrix_t *flags, jas_matrix_t *data);
+static int dec_rawrefpass(jpc_bitstream_t *in, unsigned bitpos,
+ jas_matrix_t *flags, jas_matrix_t *data);
+static int dec_clnpass(jpc_mqdec_t *mqdec, unsigned bitpos, enum jpc_tsfb_orient orient,
+ bool vcausalflag, bool segsymflag, jas_matrix_t *flags, jas_matrix_t *data);
+
+#ifndef NDEBUG
+static long t1dec_cnt = 0;
+#endif
+
+JAS_FORCE_INLINE
+static bool JPC_T1D_GETBIT(jpc_mqdec_t *mqdec, const char *passtypename, const char *symtypename)
+{+ bool v = jpc_mqdec_getbit(mqdec);
+#ifndef NDEBUG
+ if (jas_getdbglevel() >= 100) {+ jas_eprintf("index = %ld; passtype = %s; symtype = %s; sym = %d\n", t1dec_cnt, passtypename, symtypename, v);+ ++t1dec_cnt;
+ }
+#else
+ (void)passtypename;
+ (void)symtypename;
+#endif
+ return v;
+}
+
+JAS_FORCE_INLINE
+static bool JPC_T1D_GETBITNOSKEW(jpc_mqdec_t *mqdec, const char *passtypename, const char *symtypename)
+{+ return JPC_T1D_GETBIT(mqdec, passtypename, symtypename);
+}
+
+JAS_FORCE_INLINE
+static int JPC_T1D_RAWGETBIT(jpc_bitstream_t *bitstream, const char *passtypename, const char *symtypename)
+{+ int v = jpc_bitstream_getbit(bitstream);
+#ifndef NDEBUG
+ if (jas_getdbglevel() >= 100) {+ jas_eprintf("index = %ld; passtype = %s; symtype = %s; sym = %d\n", t1dec_cnt, passtypename, symtypename, v);+ ++t1dec_cnt;
+ }
+#else
+ (void)passtypename;
+ (void)symtypename;
+#endif
+ return v;
+}
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+int jpc_dec_decodecblks(jpc_dec_t *dec, jpc_dec_tile_t *tile)
+{+ jpc_dec_tcomp_t *tcomp;
+ jpc_dec_rlvl_t *rlvl;
+ jpc_dec_band_t *band;
+ jpc_dec_prc_t *prc;
+ jpc_dec_cblk_t *cblk;
+
+ unsigned compcnt;
+ for (compcnt = dec->numcomps, tcomp = tile->tcomps; compcnt > 0;
+ --compcnt, ++tcomp) {+ unsigned rlvlcnt;
+ for (rlvlcnt = tcomp->numrlvls, rlvl = tcomp->rlvls;
+ rlvlcnt > 0; --rlvlcnt, ++rlvl) {+ if (!rlvl->bands) {+ continue;
+ }
+ unsigned bandcnt;
+ for (bandcnt = rlvl->numbands, band = rlvl->bands;
+ bandcnt > 0; --bandcnt, ++band) {+ if (!band->data) {+ continue;
+ }
+ unsigned prccnt;
+ for (prccnt = rlvl->numprcs, prc = band->prcs;
+ prccnt > 0; --prccnt, ++prc) {+ if (!prc->cblks) {+ continue;
+ }
+ unsigned cblkcnt;
+ for (cblkcnt = prc->numcblks,
+ cblk = prc->cblks; cblkcnt > 0;
+ --cblkcnt, ++cblk) {+ if (jpc_dec_decodecblk(tile, tcomp,
+ band, cblk, 1, JPC_MAXLYRS)) {+ return -1;
+ }
+ }
+ }
+
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int jpc_dec_decodecblk(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 bpno;
+ int ret = -1;
+ int filldata;
+ int fillmask;
+
+ const size_t compno = tcomp - tile->tcomps;
+ const jpc_dec_ccp_t *const ccp = &tile->cp->ccps[compno];
+
+ /* The MQ decoder. */
+ jpc_mqdec_t *mqdec = NULL;
+
+ /* The raw bit stream decoder. */
+ jpc_bitstream_t *nulldec = NULL;
+
+ /* The per-sample state information for this code block. */
+ /* Note: matrix is assumed to be zeroed */
+ jas_matrix_t *const flags = jas_matrix_create(jas_matrix_numrows(cblk->data) + 2, jas_matrix_numcols(cblk->data) + 2);
+ if (!flags)
+ goto error;
+
+ seg = cblk->segs.head;
+ while (seg && (seg != cblk->curseg || dopartial) && (maxlyrs < 0 ||
+ seg->lyrno < (unsigned)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 (!mqdec) {+ if (!(mqdec = jpc_mqdec_create(JPC_NUMCTXS, 0))) {+ goto error;
+ }
+ jpc_mqdec_setctxs(mqdec, JPC_NUMCTXS, jpc_mqctxs);
+ }
+ jpc_mqdec_setinput(mqdec, seg->stream);
+ jpc_mqdec_init(mqdec);
+ } else {+ assert(seg->type == JPC_SEG_RAW);
+ if (!nulldec) {+ if (!(nulldec = jpc_bitstream_sopen(seg->stream, "r"))) {+ goto error;
+ }
+ }
+ }
+
+
+ for (unsigned i = 0; i < seg->numpasses; ++i) {+ if (cblk->numimsbs > band->numbps) {+ 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;
+}
+ enum jpc_passtype passtype = JPC_PASSTYPE(seg->passno + i);
+ assert(bpno >= 0 && bpno < 31);
+ switch (passtype) {+ case JPC_SIGPASS:
+ ret = (seg->type == JPC_SEG_MQ) ? dec_sigpass(mqdec, bpno, band->orient,
+ (ccp->cblkctx & JPC_COX_VSC) != 0,
+ flags, cblk->data) :
+ dec_rawsigpass(nulldec, bpno,
+ (ccp->cblkctx & JPC_COX_VSC) != 0,
+ flags, cblk->data);
+ break;
+ case JPC_REFPASS:
+ ret = (seg->type == JPC_SEG_MQ) ?
+ dec_refpass(mqdec, bpno,
+ flags, cblk->data) :
+ dec_rawrefpass(nulldec, bpno,
+ flags, cblk->data);
+ break;
+ case JPC_CLNPASS:
+ assert(seg->type == JPC_SEG_MQ);
+ ret = dec_clnpass(mqdec, bpno,
+ band->orient, (ccp->cblkctx &
+ JPC_COX_VSC) != 0, (ccp->cblkctx &
+ JPC_COX_SEGSYM) != 0, flags,
+ cblk->data);
+ break;
+ default:
+ assert(false);
+ JAS_UNREACHABLE();
+ }
+ /* Do we need to reset after each coding pass? */
+ if ((ccp->cblkctx & JPC_COX_RESET) && mqdec) {+ jpc_mqdec_setctxs(mqdec, JPC_NUMCTXS, jpc_mqctxs);
+ }
+
+ if (ret) {+ jas_eprintf("coding pass failed passtype=%d segtype=%d\n", passtype, seg->type);+ goto error;
+ }
+
+ }
+
+ 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 (ccp->cblkctx & JPC_COX_PTERM) {+ fillmask = 0x7f;
+ filldata = 0x2a;
+ } else {+ fillmask = 0;
+ filldata = 0;
+ }
+ if ((ret = jpc_bitstream_inalign(nulldec, fillmask,
+ filldata)) < 0) {+ goto error;
+ } else if (ret > 0) {+ jas_eprintf("warning: bad termination pattern detected\n");+ }
+ jpc_bitstream_close(nulldec);
+ 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:
+ if (mqdec)
+ jpc_mqdec_destroy(mqdec);
+ if (nulldec)
+ jpc_bitstream_close(nulldec);
+ if (flags)
+ jas_matrix_destroy(flags);
+ return 0;
+
+error:
+ if (mqdec)
+ jpc_mqdec_destroy(mqdec);
+ if (nulldec)
+ jpc_bitstream_close(nulldec);
+ if (flags)
+ jas_matrix_destroy(flags);
+ return -1;
+}
+
+/******************************************************************************\
+* Code for significance pass.
+\******************************************************************************/
+
+JAS_FORCE_INLINE
+static void jpc_sigpass_step(jpc_fix_t *fp, size_t frowstep, jpc_fix_t *dp, jpc_fix_t oneplushalf, enum jpc_tsfb_orient orient, jpc_mqdec_t *mqdec, bool vcausalflag)
+{+ const jpc_fix_t f = *(fp);
+ if ((f & JPC_OTHSIGMSK) && !(f & (JPC_SIG | JPC_VISIT))) {+ jpc_mqdec_setcurctx(mqdec, JPC_GETZCCTXNO(f, orient));
+
+ if (JPC_T1D_GETBIT(mqdec, "SIG", "ZC")) {+ jpc_mqdec_setcurctx(mqdec, JPC_GETSCCTXNO(f));
+ bool v = JPC_T1D_GETBIT(mqdec, "SIG", "SC");
+ v ^= JPC_GETSPB(f);
+ JPC_UPDATEFLAGS4(fp, frowstep, v, vcausalflag);
+ *fp |= JPC_SIG;
+ *dp = v ? -oneplushalf : oneplushalf;
+ }
+ *fp |= JPC_VISIT;
+ }
+}
+
+static int dec_sigpass(jpc_mqdec_t *mqdec, unsigned bitpos, enum jpc_tsfb_orient orient,
+ bool vcausalflag, jas_matrix_t *flags, jas_matrix_t *data)
+{+ int i;
+ jpc_fix_t *fp;
+ jpc_fix_t *fstripestart;
+ jpc_fix_t *fvscanstart;
+ jpc_fix_t *dp;
+ jpc_fix_t *dstripestart;
+ jpc_fix_t *dvscanstart;
+
+ const unsigned width = jas_matrix_numcols(data);
+ const unsigned height = jas_matrix_numrows(data);
+ const unsigned frowstep = jas_matrix_rowstep(flags);
+ const unsigned drowstep = jas_matrix_rowstep(data);
+ const unsigned fstripestep = frowstep << 2;
+ const unsigned dstripestep = drowstep << 2;
+
+ const jpc_fix_t one = (jpc_fix_t)1 << bitpos;
+ const jpc_fix_t half = one >> 1;
+ const jpc_fix_t oneplushalf = one | half;
+
+ fstripestart = jas_matrix_getref(flags, 1, 1);
+ dstripestart = jas_matrix_getref(data, 0, 0);
+ for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
+ dstripestart += dstripestep) {+ fvscanstart = fstripestart;
+ dvscanstart = dstripestart;
+ const unsigned vscanlen = JAS_MIN(i, 4);
+ for (unsigned j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {+ fp = fvscanstart;
+ dp = dvscanstart;
+ unsigned k = vscanlen;
+
+ /* Process first sample in vertical scan. */
+ jpc_sigpass_step(fp, frowstep, dp, oneplushalf,
+ orient, mqdec, vcausalflag);
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process second sample in vertical scan. */
+ jpc_sigpass_step(fp, frowstep, dp, oneplushalf,
+ orient, mqdec, 0);
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process third sample in vertical scan. */
+ jpc_sigpass_step(fp, frowstep, dp, oneplushalf,
+ orient, mqdec, 0);
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process fourth sample in vertical scan. */
+ jpc_sigpass_step(fp, frowstep, dp, oneplushalf,
+ orient, mqdec, 0);
+ }
+ }
+ return 0;
+}
+
+JAS_FORCE_INLINE
+static int jpc_rawsigpass_step(jpc_fix_t *fp, size_t frowstep, jpc_fix_t *dp, jpc_fix_t oneplushalf, jpc_bitstream_t *in, bool vcausalflag)
+{+ const jpc_fix_t f = *fp;
+ if ((f & JPC_OTHSIGMSK) && !(f & (JPC_SIG | JPC_VISIT))) {+ int v = JPC_T1D_RAWGETBIT(in, "SIG", "ZC");
+ if (v < 0) {+ return -1;
+ }
+ if (v) {+ v = JPC_T1D_RAWGETBIT(in, "SIG", "SC");
+ if (v < 0) {+ return -1;
+ }
+ JPC_UPDATEFLAGS4(fp, frowstep, v, vcausalflag);
+ *fp |= JPC_SIG;
+ *dp = v ? -oneplushalf : oneplushalf;
+ }
+ *fp |= JPC_VISIT;
+ }
+
+ return 0;
+}
+
+static int dec_rawsigpass(jpc_bitstream_t *in, unsigned bitpos, bool vcausalflag,
+ jas_matrix_t *flags, jas_matrix_t *data)
+{+ int i;
+ jpc_fix_t *fp;
+ jpc_fix_t *fstripestart;
+ jpc_fix_t *fvscanstart;
+ jpc_fix_t *dp;
+ jpc_fix_t *dstripestart;
+ jpc_fix_t *dvscanstart;
+
+ const unsigned width = jas_matrix_numcols(data);
+ const unsigned height = jas_matrix_numrows(data);
+ const unsigned frowstep = jas_matrix_rowstep(flags);
+ const unsigned drowstep = jas_matrix_rowstep(data);
+ const unsigned fstripestep = frowstep << 2;
+ const unsigned dstripestep = drowstep << 2;
+
+ const jpc_fix_t one = (jpc_fix_t)1 << bitpos;
+ const jpc_fix_t half = one >> 1;
+ const jpc_fix_t oneplushalf = one | half;
+
+ fstripestart = jas_matrix_getref(flags, 1, 1);
+ dstripestart = jas_matrix_getref(data, 0, 0);
+ for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
+ dstripestart += dstripestep) {+ fvscanstart = fstripestart;
+ dvscanstart = dstripestart;
+ const unsigned vscanlen = JAS_MIN(i, 4);
+ for (unsigned j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {+ fp = fvscanstart;
+ dp = dvscanstart;
+ unsigned k = vscanlen;
+
+ /* Process first sample in vertical scan. */
+ if (jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf, in, vcausalflag))
+ return -1;
+
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process second sample in vertical scan. */
+ if (jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf, in, 0))
+ return -1;
+
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process third sample in vertical scan. */
+ if (jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf, in, 0))
+ return -1;
+
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process fourth sample in vertical scan. */
+ jpc_rawsigpass_step(fp, frowstep, dp, oneplushalf,
+ in, 0);
+
+ }
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Code for refinement pass.
+\******************************************************************************/
+
+JAS_FORCE_INLINE
+static void jpc_refpass_step(jpc_fix_t *fp, jpc_fix_t *dp, jpc_fix_t poshalf, jpc_fix_t neghalf, jpc_mqdec_t *mqdec)
+{+ if (((*(fp)) & (JPC_SIG | JPC_VISIT)) == JPC_SIG) { \+ jpc_mqdec_setcurctx(mqdec, JPC_GETMAGCTXNO(*fp));
+ const bool v = JPC_T1D_GETBITNOSKEW(mqdec, "REF", "MR");
+ const jpc_fix_t t = v ? poshalf : neghalf;
+ *dp += *dp < 0 ? -t : t;
+ *fp |= JPC_REFINE;
+ }
+}
+
+static int dec_refpass(jpc_mqdec_t *mqdec, unsigned bitpos,
+ jas_matrix_t *flags, jas_matrix_t *data)
+{+ int i;
+ jpc_fix_t *fp;
+ jpc_fix_t *fstripestart;
+ jpc_fix_t *fvscanstart;
+ jpc_fix_t *dp;
+ jpc_fix_t *dstripestart;
+ jpc_fix_t *dvscanstart;
+
+ const unsigned width = jas_matrix_numcols(data);
+ const unsigned height = jas_matrix_numrows(data);
+ const unsigned frowstep = jas_matrix_rowstep(flags);
+ const unsigned drowstep = jas_matrix_rowstep(data);
+ const unsigned fstripestep = frowstep << 2;
+ const unsigned dstripestep = drowstep << 2;
+
+ const jpc_fix_t one = (jpc_fix_t)1 << bitpos;
+ const jpc_fix_t poshalf = one >> 1;
+ const jpc_fix_t neghalf = bitpos > 0 ? -poshalf : -1;
+
+ fstripestart = jas_matrix_getref(flags, 1, 1);
+ dstripestart = jas_matrix_getref(data, 0, 0);
+ for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
+ dstripestart += dstripestep) {+ fvscanstart = fstripestart;
+ dvscanstart = dstripestart;
+ const unsigned vscanlen = JAS_MIN(i, 4);
+ for (unsigned j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {+ fp = fvscanstart;
+ dp = dvscanstart;
+
+ for (unsigned k = 0; k < vscanlen; ++k) {+ jpc_refpass_step(fp, dp, poshalf, neghalf, mqdec);
+ fp += frowstep;
+ dp += drowstep;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int jpc_rawrefpass_step(jpc_fix_t *fp, jpc_fix_t *dp, jpc_fix_t poshalf, jpc_fix_t neghalf, jpc_bitstream_t *in)
+{+ if ((*fp & (JPC_SIG | JPC_VISIT)) == JPC_SIG) {+ int v = JPC_T1D_RAWGETBIT(in, "REF", "MAGREF");
+ if (v < 0) {+ return -1;
+ }
+ jpc_fix_t t = v ? poshalf : neghalf;
+ *dp += *dp < 0 ? -t : t;
+ *fp |= JPC_REFINE;
+ }
+
+ return 0;
+}
+
+static int dec_rawrefpass(jpc_bitstream_t *in, unsigned bitpos,
+ jas_matrix_t *flags, jas_matrix_t *data)
+{+ int i;
+ jpc_fix_t *fp;
+ jpc_fix_t *fstripestart;
+ jpc_fix_t *fvscanstart;
+ jpc_fix_t *dp;
+ jpc_fix_t *dstripestart;
+ jpc_fix_t *dvscanstart;
+
+ const unsigned width = jas_matrix_numcols(data);
+ const unsigned height = jas_matrix_numrows(data);
+ const unsigned frowstep = jas_matrix_rowstep(flags);
+ const unsigned drowstep = jas_matrix_rowstep(data);
+ const unsigned fstripestep = frowstep << 2;
+ const unsigned dstripestep = drowstep << 2;
+
+ const jpc_fix_t one = (jpc_fix_t)1 << bitpos;
+ const jpc_fix_t poshalf = one >> 1;
+ const jpc_fix_t neghalf = bitpos > 0 ? -poshalf : -1;
+
+ fstripestart = jas_matrix_getref(flags, 1, 1);
+ dstripestart = jas_matrix_getref(data, 0, 0);
+ for (i = height; i > 0; i -= 4, fstripestart += fstripestep,
+ dstripestart += dstripestep) {+ fvscanstart = fstripestart;
+ dvscanstart = dstripestart;
+ const unsigned vscanlen = JAS_MIN(i, 4);
+ for (unsigned j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {+ fp = fvscanstart;
+ dp = dvscanstart;
+
+ for (unsigned k = 0; k < vscanlen; ++k) {+ if (jpc_rawrefpass_step(fp, dp, poshalf, neghalf, in))
+ return -1;
+ fp += frowstep;
+ dp += drowstep;
+ }
+ }
+ }
+ return 0;
+}
+
+/******************************************************************************\
+* Code for cleanup pass.
+\******************************************************************************/
+
+#define jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient, mqdec, flabel, plabel, vcausalflag) \
+{ \+flabel \
+ if (!((f) & (JPC_SIG | JPC_VISIT))) { \+ jpc_mqdec_setcurctx((mqdec), JPC_GETZCCTXNO((f), (orient))); \
+ if (JPC_T1D_GETBIT((mqdec), "CLN", "ZC")) { \+plabel \
+ /* Coefficient is significant. */ \
+ jpc_mqdec_setcurctx((mqdec), JPC_GETSCCTXNO(f)); \
+ bool v = JPC_T1D_GETBIT((mqdec), "CLN", "SC"); \
+ v ^= JPC_GETSPB(f); \
+ *(dp) = (v) ? (-(jpc_fix_t)(oneplushalf)) : (jpc_fix_t)(oneplushalf); \
+ JPC_UPDATEFLAGS4((fp), (frowstep), v, (vcausalflag)); \
+ *(fp) |= JPC_SIG; \
+ } \
+ } \
+ /* XXX - Is this correct? Can aggregation cause some VISIT bits not to be reset? Check. */ \
+ *(fp) &= ~JPC_VISIT; \
+}
+
+static int dec_clnpass(jpc_mqdec_t *mqdec, unsigned bitpos, enum jpc_tsfb_orient orient,
+ bool vcausalflag, bool segsymflag, jas_matrix_t *flags, jas_matrix_t *data)
+{+ int f;
+
+ jpc_fix_t *fp;
+ jpc_fix_t *fstripestart;
+ jpc_fix_t *fvscanstart;
+
+ jpc_fix_t *dp;
+ jpc_fix_t *dstripestart;
+ jpc_fix_t *dvscanstart;
+
+ const jpc_fix_t one = (jpc_fix_t)1 << bitpos;
+ const jpc_fix_t half = one >> 1;
+ const jpc_fix_t oneplushalf = one | half;
+
+ const unsigned width = jas_matrix_numcols(data);
+ const unsigned height = jas_matrix_numrows(data);
+
+ const unsigned frowstep = jas_matrix_rowstep(flags);
+ const unsigned drowstep = jas_matrix_rowstep(data);
+ const unsigned fstripestep = frowstep << 2;
+ const unsigned dstripestep = drowstep << 2;
+
+ fstripestart = jas_matrix_getref(flags, 1, 1);
+ dstripestart = jas_matrix_getref(data, 0, 0);
+ for (unsigned i = 0; i < height; i += 4, fstripestart += fstripestep,
+ dstripestart += dstripestep) {+ fvscanstart = fstripestart;
+ dvscanstart = dstripestart;
+ const unsigned vscanlen = JAS_MIN(4, height - i);
+ for (unsigned j = width; j > 0; --j, ++fvscanstart, ++dvscanstart) {+ fp = fvscanstart;
+ unsigned k;
+ if (vscanlen >= 4 && (!((*fp) & (JPC_SIG | JPC_VISIT |
+ JPC_OTHSIGMSK))) && (fp += frowstep, !((*fp) & (JPC_SIG |
+ JPC_VISIT | JPC_OTHSIGMSK))) && (fp += frowstep, !((*fp) &
+ (JPC_SIG | JPC_VISIT | JPC_OTHSIGMSK))) && (fp += frowstep,
+ !((*fp) & (JPC_SIG | JPC_VISIT | JPC_OTHSIGMSK)))) {+
+ jpc_mqdec_setcurctx(mqdec, JPC_AGGCTXNO);
+ if (!JPC_T1D_GETBIT(mqdec, "CLN", "AGG")) {+ continue;
+ }
+ jpc_mqdec_setcurctx(mqdec, JPC_UCTXNO);
+ unsigned runlen = JPC_T1D_GETBITNOSKEW(mqdec, "CLN", "RL");
+ runlen = (runlen << 1) | JPC_T1D_GETBITNOSKEW(mqdec, "CLN", "RL");
+ f = *(fp = fvscanstart + frowstep * runlen);
+ dp = dvscanstart + drowstep * runlen;
+ k = vscanlen - runlen;
+ switch (runlen) {+ case 0:
+ goto clnpass_partial0;
+ case 1:
+ goto clnpass_partial1;
+ case 2:
+ goto clnpass_partial2;
+ case 3:
+ goto clnpass_partial3;
+ }
+ } else {+ f = *(fp = fvscanstart);
+ dp = dvscanstart;
+ k = vscanlen;
+ goto clnpass_full0;
+ }
+
+ /* Process first sample in vertical scan. */
+ jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
+ mqdec, clnpass_full0:, clnpass_partial0:,
+ vcausalflag);
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process second sample in vertical scan. */
+ f = *fp;
+ jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
+ mqdec, ;, clnpass_partial1:, 0);
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process third sample in vertical scan. */
+ f = *fp;
+ jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
+ mqdec, ;, clnpass_partial2:, 0);
+ if (--k <= 0) {+ continue;
+ }
+ fp += frowstep;
+ dp += drowstep;
+
+ /* Process fourth sample in vertical scan. */
+ f = *fp;
+ jpc_clnpass_step(f, fp, frowstep, dp, oneplushalf, orient,
+ mqdec, ;, clnpass_partial3:, 0);
+ }
+ }
+
+ if (segsymflag) {+ unsigned segsymval = 0;
+ jpc_mqdec_setcurctx(mqdec, JPC_UCTXNO);
+ segsymval = (segsymval << 1) | JPC_T1D_GETBITNOSKEW(mqdec, "CLN", "SEGSYM");
+ segsymval = (segsymval << 1) | JPC_T1D_GETBITNOSKEW(mqdec, "CLN", "SEGSYM");
+ segsymval = (segsymval << 1) | JPC_T1D_GETBITNOSKEW(mqdec, "CLN", "SEGSYM");
+ segsymval = (segsymval << 1) | JPC_T1D_GETBITNOSKEW(mqdec, "CLN", "SEGSYM");
+ if (segsymval != 0xa) {+ jas_eprintf("warning: bad segmentation symbol\n");+ }
+ }
+
+ return 0;
+}
--- /dev/null
+++ b/jpc_t1dec.h
@@ -1,0 +1,86 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tier 1 Decoder
+ *
+ * $Id$
+ */
+
+#ifndef JPC_T1DEC_H
+#define JPC_T1DEC_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_dec.h"
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Decode all of the code blocks for a particular tile. */
+int jpc_dec_decodecblks(jpc_dec_t *dec, jpc_dec_tile_t *tile);
+
+#endif
--- /dev/null
+++ b/jpc_t2cod.c
@@ -1,0 +1,702 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tier-2 Coding Library
+ *
+ * $Id$
+ */
+
+#include "jpc_t2cod.h"
+#include "jpc_cs.h"
+#include "jpc_math.h"
+
+#include "jasper/jas_math.h"
+#include "jasper/jas_malloc.h"
+
+static int jpc_pi_nextlrcp(jpc_pi_t *pi);
+static int jpc_pi_nextrlcp(jpc_pi_t *pi);
+static int jpc_pi_nextrpcl(jpc_pi_t *pi);
+static int jpc_pi_nextpcrl(jpc_pi_t *pi);
+static int jpc_pi_nextcprl(jpc_pi_t *pi);
+
+int jpc_pi_next(jpc_pi_t *pi)
+{+ int ret;
+
+ for (;;) {+
+ pi->valid = false;
+
+ if (!pi->pchg) {+ ++pi->pchgno;
+ pi->compno = 0;
+ pi->rlvlno = 0;
+ pi->prcno = 0;
+ pi->lyrno = 0;
+ pi->prgvolfirst = true;
+ if ((unsigned)pi->pchgno < jpc_pchglist_numpchgs(pi->pchglist)) {+ pi->pchg = jpc_pchglist_get(pi->pchglist, pi->pchgno);
+ } else if ((unsigned)pi->pchgno == jpc_pchglist_numpchgs(pi->pchglist)) {+ pi->pchg = &pi->defaultpchg;
+ } else {+ return 1;
+ }
+ }
+
+ const jpc_pchg_t *pchg = pi->pchg;
+ switch (pchg->prgord) {+ case JPC_COD_LRCPPRG:
+ ret = jpc_pi_nextlrcp(pi);
+ break;
+ case JPC_COD_RLCPPRG:
+ ret = jpc_pi_nextrlcp(pi);
+ break;
+ case JPC_COD_RPCLPRG:
+ ret = jpc_pi_nextrpcl(pi);
+ break;
+ case JPC_COD_PCRLPRG:
+ ret = jpc_pi_nextpcrl(pi);
+ break;
+ case JPC_COD_CPRLPRG:
+ ret = jpc_pi_nextcprl(pi);
+ break;
+ default:
+ ret = -1;
+ break;
+ }
+ if (!ret) {+ pi->valid = true;
+ ++pi->pktno;
+ return 0;
+ }
+ pi->pchg = 0;
+ }
+}
+
+static int jpc_pi_nextlrcp(register jpc_pi_t *pi)
+{+ unsigned *prclyrno;
+
+ const jpc_pchg_t *pchg = pi->pchg;
+ if (!pi->prgvolfirst) {+ prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
+ goto skip;
+ } else {+ pi->prgvolfirst = false;
+ }
+
+ for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno <
+ pchg->lyrnoend; ++pi->lyrno) {+ for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls &&
+ pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) {+ for (pi->compno = pchg->compnostart, pi->picomp =
+ &pi->picomps[pi->compno]; pi->compno < pi->numcomps
+ && pi->compno < pchg->compnoend; ++pi->compno,
+ ++pi->picomp) {+ if (pi->rlvlno >= pi->picomp->numrlvls) {+ continue;
+ }
+ pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
+ for (pi->prcno = 0, prclyrno =
+ pi->pirlvl->prclyrnos; pi->prcno <
+ pi->pirlvl->numprcs; ++pi->prcno,
+ ++prclyrno) {+ if (pi->lyrno >= *prclyrno) {+ *prclyrno = pi->lyrno;
+ ++(*prclyrno);
+ return 0;
+ }
+skip:
+ ;
+ }
+ }
+ }
+ }
+ return 1;
+}
+
+static int jpc_pi_nextrlcp(register jpc_pi_t *pi)
+{+ unsigned *prclyrno;
+
+ const jpc_pchg_t *pchg = pi->pchg;
+ if (!pi->prgvolfirst) {+ assert(pi->prcno < pi->pirlvl->numprcs);
+ prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
+ goto skip;
+ } else {+ pi->prgvolfirst = 0;
+ }
+
+ for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pi->maxrlvls &&
+ pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno) {+ for (pi->lyrno = 0; pi->lyrno < pi->numlyrs && pi->lyrno <
+ pchg->lyrnoend; ++pi->lyrno) {+ for (pi->compno = pchg->compnostart, pi->picomp =
+ &pi->picomps[pi->compno]; pi->compno < pi->numcomps &&
+ pi->compno < pchg->compnoend; ++pi->compno,
+ ++pi->picomp) {+ if (pi->rlvlno >= pi->picomp->numrlvls) {+ continue;
+ }
+ pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
+ for (pi->prcno = 0, prclyrno = pi->pirlvl->prclyrnos;
+ pi->prcno < pi->pirlvl->numprcs; ++pi->prcno, ++prclyrno) {+ if (pi->lyrno >= *prclyrno) {+ *prclyrno = pi->lyrno;
+ ++(*prclyrno);
+ return 0;
+ }
+skip:
+ ;
+ }
+ }
+ }
+ }
+ return 1;
+}
+
+static int jpc_pi_nextrpcl(register jpc_pi_t *pi)
+{+ unsigned rlvlno;
+ unsigned *prclyrno;
+ unsigned compno;
+ unsigned xstep;
+ unsigned ystep;
+ uint_fast32_t r;
+ uint_fast32_t rpx;
+ uint_fast32_t rpy;
+ uint_fast32_t trx0;
+ uint_fast32_t try0;
+
+ const jpc_pchg_t *pchg = pi->pchg;
+ if (!pi->prgvolfirst) {+ goto skip;
+ } else {+ pi->xstep = 0;
+ pi->ystep = 0;
+ const jpc_picomp_t *picomp;
+ for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
+ ++compno, ++picomp) {+ const jpc_pirlvl_t *pirlvl;
+ for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
+ picomp->numrlvls; ++rlvlno, ++pirlvl) {+ // Check for the potential for overflow problems.
+ if (pirlvl->prcwidthexpn + picomp->numrlvls >
+ JAS_UINTFAST32_NUMBITS - 2 ||
+ pirlvl->prcheightexpn + picomp->numrlvls >
+ JAS_UINTFAST32_NUMBITS - 2) {+ return -1;
+ }
+ xstep = picomp->hsamp * (JAS_CAST(uint_fast32_t, 1) <<
+ (pirlvl->prcwidthexpn + picomp->numrlvls - rlvlno - 1));
+ ystep = picomp->vsamp * (JAS_CAST(uint_fast32_t, 1) <<
+ (pirlvl->prcheightexpn + picomp->numrlvls - rlvlno - 1));
+ pi->xstep = (!pi->xstep) ? xstep : JAS_MIN(pi->xstep, xstep);
+ pi->ystep = (!pi->ystep) ? ystep : JAS_MIN(pi->ystep, ystep);
+ }
+ }
+ pi->prgvolfirst = 0;
+ }
+
+ if (pi->xstep == 0 || pi->ystep == 0)
+ /* avoid division by zero */
+ return -1;
+
+ for (pi->rlvlno = pchg->rlvlnostart; pi->rlvlno < pchg->rlvlnoend &&
+ pi->rlvlno < pi->maxrlvls; ++pi->rlvlno) {+ for (pi->y = pi->ystart; pi->y < pi->yend; pi->y +=
+ pi->ystep - (pi->y % pi->ystep)) {+ for (pi->x = pi->xstart; pi->x < pi->xend; pi->x +=
+ pi->xstep - (pi->x % pi->xstep)) {+ for (pi->compno = pchg->compnostart,
+ pi->picomp = &pi->picomps[pi->compno];
+ pi->compno < pchg->compnoend && pi->compno <
+ pi->numcomps; ++pi->compno, ++pi->picomp) {+ if (pi->rlvlno >= pi->picomp->numrlvls) {+ continue;
+ }
+ pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
+ if (pi->pirlvl->numprcs == 0) {+ continue;
+ }
+ r = pi->picomp->numrlvls - 1 - pi->rlvlno;
+ rpx = r + pi->pirlvl->prcwidthexpn;
+ rpy = r + pi->pirlvl->prcheightexpn;
+ trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r);
+ try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r);
+ if (((pi->x == pi->xstart &&
+ ((trx0 << r) % (JAS_CAST(uint_fast32_t, 1) << rpx)))
+ || !(pi->x % (pi->picomp->hsamp << rpx))) &&
+ ((pi->y == pi->ystart &&
+ ((try0 << r) % (JAS_CAST(uint_fast32_t, 1) << rpy)))
+ || !(pi->y % (pi->picomp->vsamp << rpy)))) {+ const unsigned prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x,
+ pi->picomp->hsamp << r), pi->pirlvl->prcwidthexpn) -
+ JPC_FLOORDIVPOW2(trx0, pi->pirlvl->prcwidthexpn);
+ const unsigned prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y,
+ pi->picomp->vsamp << r), pi->pirlvl->prcheightexpn) -
+ JPC_FLOORDIVPOW2(try0, pi->pirlvl->prcheightexpn);
+ pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind;
+ if (pi->prcno >= pi->pirlvl->numprcs) {+ return -1;
+ }
+
+ for (pi->lyrno = 0; pi->lyrno <
+ pi->numlyrs && pi->lyrno < pchg->lyrnoend; ++pi->lyrno) {+ prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
+ if (pi->lyrno >= *prclyrno) {+ ++(*prclyrno);
+ return 0;
+ }
+skip:
+ ;
+ }
+ }
+ }
+ }
+ }
+ }
+ return 1;
+}
+
+static int jpc_pi_nextpcrl(register jpc_pi_t *pi)
+{+ unsigned rlvlno;
+ unsigned *prclyrno;
+ unsigned compno;
+ unsigned xstep;
+ unsigned ystep;
+ uint_fast32_t trx0;
+ uint_fast32_t try0;
+ uint_fast32_t r;
+ uint_fast32_t rpx;
+ uint_fast32_t rpy;
+
+ const jpc_pchg_t *pchg = pi->pchg;
+ if (!pi->prgvolfirst) {+ goto skip;
+ } else {+ pi->xstep = 0;
+ pi->ystep = 0;
+ const jpc_picomp_t *picomp;
+ for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
+ ++compno, ++picomp) {+ const jpc_pirlvl_t *pirlvl;
+ for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
+ picomp->numrlvls; ++rlvlno, ++pirlvl) {+ // Check for the potential for overflow problems.
+ if (pirlvl->prcwidthexpn + picomp->numrlvls >
+ JAS_UINTFAST32_NUMBITS - 2 ||
+ pirlvl->prcheightexpn + picomp->numrlvls >
+ JAS_UINTFAST32_NUMBITS - 2) {+ return -1;
+ }
+ xstep = picomp->hsamp * (JAS_CAST(uint_fast32_t, 1) <<
+ (pirlvl->prcwidthexpn + picomp->numrlvls - rlvlno - 1));
+ ystep = picomp->vsamp * (JAS_CAST(uint_fast32_t, 1) <<
+ (pirlvl->prcheightexpn + picomp->numrlvls - rlvlno - 1));
+ pi->xstep = (!pi->xstep) ? xstep : JAS_MIN(pi->xstep, xstep);
+ pi->ystep = (!pi->ystep) ? ystep : JAS_MIN(pi->ystep, ystep);
+ }
+ }
+ pi->prgvolfirst = 0;
+ }
+
+ if (pi->xstep == 0 || pi->ystep == 0)
+ /* avoid division by zero */
+ return -1;
+
+ for (pi->y = pi->ystart; pi->y < pi->yend; pi->y += pi->ystep -
+ (pi->y % pi->ystep)) {+ for (pi->x = pi->xstart; pi->x < pi->xend; pi->x += pi->xstep -
+ (pi->x % pi->xstep)) {+ for (pi->compno = pchg->compnostart, pi->picomp =
+ &pi->picomps[pi->compno]; pi->compno < pi->numcomps
+ && pi->compno < pchg->compnoend; ++pi->compno,
+ ++pi->picomp) {+ for (pi->rlvlno = pchg->rlvlnostart,
+ pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
+ pi->rlvlno < pi->picomp->numrlvls &&
+ pi->rlvlno < pchg->rlvlnoend; ++pi->rlvlno,
+ ++pi->pirlvl) {+ if (pi->pirlvl->numprcs == 0) {+ continue;
+ }
+ r = pi->picomp->numrlvls - 1 - pi->rlvlno;
+ trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r);
+ try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r);
+ rpx = r + pi->pirlvl->prcwidthexpn;
+ rpy = r + pi->pirlvl->prcheightexpn;
+ if (((pi->x == pi->xstart &&
+ ((trx0 << r) % (JAS_CAST(uint_fast32_t, 1) << rpx))) ||
+ !(pi->x % (pi->picomp->hsamp << rpx))) &&
+ ((pi->y == pi->ystart &&
+ ((try0 << r) % (JAS_CAST(uint_fast32_t, 1) << rpy))) ||
+ !(pi->y % (pi->picomp->vsamp << rpy)))) {+ const unsigned prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x,
+ pi->picomp->hsamp << r), pi->pirlvl->prcwidthexpn) -
+ JPC_FLOORDIVPOW2(trx0, pi->pirlvl->prcwidthexpn);
+ const unsigned prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y,
+ pi->picomp->vsamp << r), pi->pirlvl->prcheightexpn) -
+ JPC_FLOORDIVPOW2(try0, pi->pirlvl->prcheightexpn);
+ pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind;
+ assert(pi->prcno < pi->pirlvl->numprcs);
+ for (pi->lyrno = 0; pi->lyrno < pi->numlyrs &&
+ pi->lyrno < pchg->lyrnoend;
+ ++pi->lyrno) {+ prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
+ if (pi->lyrno >= *prclyrno) {+ ++(*prclyrno);
+ return 0;
+ }
+skip:
+ ;
+ }
+ }
+ }
+ }
+ }
+ }
+ return 1;
+}
+
+static int jpc_pi_nextcprl(register jpc_pi_t *pi)
+{+ unsigned rlvlno;
+ unsigned *prclyrno;
+ uint_fast32_t trx0;
+ uint_fast32_t try0;
+ uint_fast32_t r;
+ uint_fast32_t rpx;
+ uint_fast32_t rpy;
+
+ const jpc_pchg_t *pchg = pi->pchg;
+ if (!pi->prgvolfirst) {+ goto skip;
+ } else {+ pi->prgvolfirst = 0;
+ }
+
+ if (pi->xstep == 0 || pi->ystep == 0)
+ /* avoid division by zero */
+ return -1;
+
+ for (pi->compno = pchg->compnostart, pi->picomp = &pi->picomps[pi->compno];
+ pi->compno < pchg->compnoend && pi->compno < pi->numcomps;
+ ++pi->compno, ++pi->picomp) {+ const jpc_pirlvl_t *pirlvl = pi->picomp->pirlvls;
+ // Check for the potential for overflow problems.
+ if (pirlvl->prcwidthexpn + pi->picomp->numrlvls >
+ JAS_UINTFAST32_NUMBITS - 2 ||
+ pirlvl->prcheightexpn + pi->picomp->numrlvls >
+ JAS_UINTFAST32_NUMBITS - 2) {+ return -1;
+ }
+ pi->xstep = pi->picomp->hsamp * (JAS_CAST(uint_fast32_t, 1) <<
+ (pirlvl->prcwidthexpn + pi->picomp->numrlvls - 1));
+ pi->ystep = pi->picomp->vsamp * (JAS_CAST(uint_fast32_t, 1) <<
+ (pirlvl->prcheightexpn + pi->picomp->numrlvls - 1));
+ for (rlvlno = 1, pirlvl = &pi->picomp->pirlvls[1];
+ rlvlno < pi->picomp->numrlvls; ++rlvlno, ++pirlvl) {+ pi->xstep = JAS_MIN(pi->xstep, pi->picomp->hsamp *
+ (JAS_CAST(uint_fast32_t, 1) << (pirlvl->prcwidthexpn +
+ pi->picomp->numrlvls - rlvlno - 1)));
+ pi->ystep = JAS_MIN(pi->ystep, pi->picomp->vsamp *
+ (JAS_CAST(uint_fast32_t, 1) << (pirlvl->prcheightexpn +
+ pi->picomp->numrlvls - rlvlno - 1)));
+ }
+ for (pi->y = pi->ystart; pi->y < pi->yend;
+ pi->y += pi->ystep - (pi->y % pi->ystep)) {+ for (pi->x = pi->xstart; pi->x < pi->xend;
+ pi->x += pi->xstep - (pi->x % pi->xstep)) {+ for (pi->rlvlno = pchg->rlvlnostart,
+ pi->pirlvl = &pi->picomp->pirlvls[pi->rlvlno];
+ pi->rlvlno < pi->picomp->numrlvls && pi->rlvlno <
+ pchg->rlvlnoend; ++pi->rlvlno, ++pi->pirlvl) {+ if (pi->pirlvl->numprcs == 0) {+ continue;
+ }
+ r = pi->picomp->numrlvls - 1 - pi->rlvlno;
+ trx0 = JPC_CEILDIV(pi->xstart, pi->picomp->hsamp << r);
+ try0 = JPC_CEILDIV(pi->ystart, pi->picomp->vsamp << r);
+ rpx = r + pi->pirlvl->prcwidthexpn;
+ rpy = r + pi->pirlvl->prcheightexpn;
+ if (((pi->x == pi->xstart &&
+ ((trx0 << r) % (JAS_CAST(uint_fast32_t, 1) << rpx))) ||
+ !(pi->x % (pi->picomp->hsamp << rpx))) &&
+ ((pi->y == pi->ystart &&
+ ((try0 << r) % (JAS_CAST(uint_fast32_t, 1) << rpy))) ||
+ !(pi->y % (pi->picomp->vsamp << rpy)))) {+ const unsigned prchind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->x,
+ pi->picomp->hsamp << r), pi->pirlvl->prcwidthexpn) -
+ JPC_FLOORDIVPOW2(trx0, pi->pirlvl->prcwidthexpn);
+ const unsigned prcvind = JPC_FLOORDIVPOW2(JPC_CEILDIV(pi->y,
+ pi->picomp->vsamp << r), pi->pirlvl->prcheightexpn) -
+ JPC_FLOORDIVPOW2(try0, pi->pirlvl->prcheightexpn);
+ pi->prcno = prcvind * pi->pirlvl->numhprcs + prchind;
+ assert(pi->prcno < pi->pirlvl->numprcs);
+ for (pi->lyrno = 0; pi->lyrno < pi->numlyrs &&
+ pi->lyrno < pchg->lyrnoend;
+ ++pi->lyrno) {+ prclyrno = &pi->pirlvl->prclyrnos[pi->prcno];
+ if (pi->lyrno >= *prclyrno) {+ ++(*prclyrno);
+ return 0;
+ }
+skip:
+ ;
+ }
+ }
+ }
+ }
+ }
+ }
+ return 1;
+}
+
+static void pirlvl_destroy(jpc_pirlvl_t *rlvl)
+{+ if (rlvl->prclyrnos) {+ jas_free(rlvl->prclyrnos);
+ }
+}
+
+static void jpc_picomp_destroy(jpc_picomp_t *picomp)
+{+ unsigned rlvlno;
+ jpc_pirlvl_t *pirlvl;
+ if (picomp->pirlvls) {+ for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
+ picomp->numrlvls; ++rlvlno, ++pirlvl) {+ pirlvl_destroy(pirlvl);
+ }
+ jas_free(picomp->pirlvls);
+ }
+}
+
+void jpc_pi_destroy(jpc_pi_t *pi)
+{+ jpc_picomp_t *picomp;
+ unsigned compno;
+ if (pi->picomps) {+ for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
+ ++compno, ++picomp) {+ jpc_picomp_destroy(picomp);
+ }
+ jas_free(pi->picomps);
+ }
+ if (pi->pchglist) {+ jpc_pchglist_destroy(pi->pchglist);
+ }
+ jas_free(pi);
+}
+
+jpc_pi_t *jpc_pi_create0()
+{+ jpc_pi_t *pi;
+ if (!(pi = jas_malloc(sizeof(jpc_pi_t)))) {+ return 0;
+ }
+ pi->picomps = 0;
+ pi->pchgno = 0;
+ if (!(pi->pchglist = jpc_pchglist_create())) {+ jas_free(pi);
+ return 0;
+ }
+ return pi;
+}
+
+int jpc_pi_addpchg(jpc_pi_t *pi, jpc_pocpchg_t *pchg)
+{+ return jpc_pchglist_insert(pi->pchglist, -1, pchg);
+}
+
+jpc_pchglist_t *jpc_pchglist_create()
+{+ jpc_pchglist_t *pchglist;
+ if (!(pchglist = jas_malloc(sizeof(jpc_pchglist_t)))) {+ return 0;
+ }
+ pchglist->numpchgs = 0;
+ pchglist->maxpchgs = 0;
+ pchglist->pchgs = 0;
+ return pchglist;
+}
+
+int jpc_pchglist_insert(jpc_pchglist_t *pchglist, int pchgno, jpc_pchg_t *pchg)
+{+ jpc_pchg_t **newpchgs;
+ if (pchgno < 0) {+ pchgno = pchglist->numpchgs;
+ }
+ if (pchglist->numpchgs >= pchglist->maxpchgs) {+ const unsigned newmaxpchgs = pchglist->maxpchgs + 128;
+ if (!(newpchgs = jas_realloc2(pchglist->pchgs, newmaxpchgs,
+ sizeof(jpc_pchg_t *)))) {+ return -1;
+ }
+ pchglist->maxpchgs = newmaxpchgs;
+ pchglist->pchgs = newpchgs;
+ }
+ for (unsigned i = pchglist->numpchgs; i > (unsigned)pchgno; --i) {+ pchglist->pchgs[i] = pchglist->pchgs[i - 1];
+ }
+ pchglist->pchgs[pchgno] = pchg;
+ ++pchglist->numpchgs;
+ return 0;
+}
+
+jpc_pchg_t *jpc_pchglist_remove(jpc_pchglist_t *pchglist, unsigned pchgno)
+{+ jpc_pchg_t *pchg;
+ assert(pchgno < pchglist->numpchgs);
+ pchg = pchglist->pchgs[pchgno];
+ for (unsigned i = pchgno + 1; i < pchglist->numpchgs; ++i) {+ pchglist->pchgs[i - 1] = pchglist->pchgs[i];
+ }
+ --pchglist->numpchgs;
+ return pchg;
+}
+
+jpc_pchg_t *jpc_pchg_copy(const jpc_pchg_t *pchg)
+{+ jpc_pchg_t *newpchg;
+ if (!(newpchg = jas_malloc(sizeof(jpc_pchg_t)))) {+ return 0;
+ }
+ *newpchg = *pchg;
+ return newpchg;
+}
+
+jpc_pchglist_t *jpc_pchglist_copy(const jpc_pchglist_t *pchglist)
+{+ jpc_pchglist_t *newpchglist;
+ jpc_pchg_t *newpchg;
+ if (!(newpchglist = jpc_pchglist_create())) {+ return 0;
+ }
+ for (unsigned pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) {+ if (!(newpchg = jpc_pchg_copy(pchglist->pchgs[pchgno])) ||
+ jpc_pchglist_insert(newpchglist, -1, newpchg)) {+ jpc_pchglist_destroy(newpchglist);
+ return 0;
+ }
+ }
+ return newpchglist;
+}
+
+void jpc_pchglist_destroy(jpc_pchglist_t *pchglist)
+{+ if (pchglist->pchgs) {+ for (unsigned pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) {+ jpc_pchg_destroy(pchglist->pchgs[pchgno]);
+ }
+ jas_free(pchglist->pchgs);
+ }
+ jas_free(pchglist);
+}
+
+void jpc_pchg_destroy(jpc_pchg_t *pchg)
+{+ jas_free(pchg);
+}
+
+const jpc_pchg_t *jpc_pchglist_get(const jpc_pchglist_t *pchglist, unsigned pchgno)
+{+ return pchglist->pchgs[pchgno];
+}
+
+unsigned jpc_pchglist_numpchgs(const jpc_pchglist_t *pchglist)
+{+ return pchglist->numpchgs;
+}
+
+int jpc_pi_init(jpc_pi_t *pi)
+{+ unsigned compno;
+ unsigned rlvlno;
+ unsigned prcno;
+ unsigned *prclyrno;
+
+ pi->prgvolfirst = 0;
+ pi->valid = 0;
+ pi->pktno = -1;
+ pi->pchgno = -1;
+ pi->pchg = 0;
+
+ const jpc_picomp_t *picomp;
+ for (compno = 0, picomp = pi->picomps; compno < pi->numcomps;
+ ++compno, ++picomp) {+ const jpc_pirlvl_t *pirlvl;
+ for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
+ picomp->numrlvls; ++rlvlno, ++pirlvl) {+ for (prcno = 0, prclyrno = pirlvl->prclyrnos;
+ prcno < pirlvl->numprcs; ++prcno, ++prclyrno) {+ *prclyrno = 0;
+ }
+ }
+ }
+ return 0;
+}
--- /dev/null
+++ b/jpc_t2cod.h
@@ -1,0 +1,301 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tier-2 Coding Library
+ *
+ * $Id$
+ */
+
+#ifndef JPC_T2COD_H
+#define JPC_T2COD_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_cs.h"
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+/* Progression change list. */
+
+typedef struct {+
+ /* The number of progression changes. */
+ unsigned numpchgs;
+
+ /* The maximum number of progression changes that can be accomodated
+ without growing the progression change array. */
+ unsigned maxpchgs;
+
+ /* The progression changes. */
+ jpc_pchg_t **pchgs;
+
+} jpc_pchglist_t;
+
+/* Packet iterator per-resolution-level information. */
+
+typedef struct {+
+ /* The number of precincts. */
+ unsigned numprcs;
+
+ /* The last layer processed for each precinct. */
+ unsigned *prclyrnos;
+
+ /* The precinct width exponent. */
+ unsigned prcwidthexpn;
+
+ /* The precinct height exponent. */
+ unsigned prcheightexpn;
+
+ /* The number of precincts spanning the resolution level in the horizontal
+ direction. */
+ unsigned numhprcs;
+
+} jpc_pirlvl_t;
+
+/* Packet iterator per-component information. */
+
+typedef struct {+
+ /* The number of resolution levels. */
+ unsigned numrlvls;
+
+ /* The per-resolution-level information. */
+ jpc_pirlvl_t *pirlvls;
+
+ /* The horizontal sampling period. */
+ uint_fast32_t hsamp;
+
+ /* The vertical sampling period. */
+ uint_fast32_t vsamp;
+
+} jpc_picomp_t;
+
+/* Packet iterator class. */
+
+typedef struct {+
+ /* The number of layers. */
+ unsigned numlyrs;
+
+ /* The number of resolution levels. */
+ unsigned maxrlvls;
+
+ /* The number of components. */
+ unsigned numcomps;
+
+ /* The per-component information. */
+ jpc_picomp_t *picomps;
+
+ /* The current component. */
+ jpc_picomp_t *picomp;
+
+ /* The current resolution level. */
+ jpc_pirlvl_t *pirlvl;
+
+ /* The number of the current component. */
+ unsigned compno;
+
+ /* The number of the current resolution level. */
+ unsigned rlvlno;
+
+ /* The number of the current precinct. */
+ unsigned prcno;
+
+ /* The number of the current layer. */
+ unsigned lyrno;
+
+ /* The x-coordinate of the current position. */
+ uint_fast32_t x;
+
+ /* The y-coordinate of the current position. */
+ uint_fast32_t y;
+
+ /* The horizontal step size. */
+ uint_fast32_t xstep;
+
+ /* The vertical step size. */
+ uint_fast32_t ystep;
+
+ /* The x-coordinate of the top-left corner of the tile on the reference
+ grid. */
+ uint_fast32_t xstart;
+
+ /* The y-coordinate of the top-left corner of the tile on the reference
+ grid. */
+ uint_fast32_t ystart;
+
+ /* The x-coordinate of the bottom-right corner of the tile on the
+ reference grid (plus one). */
+ uint_fast32_t xend;
+
+ /* The y-coordinate of the bottom-right corner of the tile on the
+ reference grid (plus one). */
+ uint_fast32_t yend;
+
+ /* The current progression change. */
+ const jpc_pchg_t *pchg;
+
+ /* The progression change list. */
+ jpc_pchglist_t *pchglist;
+
+ /* The progression to use in the absense of explicit specification. */
+ jpc_pchg_t defaultpchg;
+
+ /* The current progression change number. */
+ int pchgno;
+
+ /* Is this the first time in the current progression volume? */
+ bool prgvolfirst;
+
+ /* Is the current iterator value valid? */
+ bool valid;
+
+ /* The current packet number. */
+ int pktno;
+
+} jpc_pi_t;
+
+/******************************************************************************\
+* Functions/macros for packet iterators.
+\******************************************************************************/
+
+/* Create a packet iterator. */
+jpc_pi_t *jpc_pi_create0(void);
+
+/* Destroy a packet iterator. */
+void jpc_pi_destroy(jpc_pi_t *pi);
+
+/* Add a progression change to a packet iterator. */
+int jpc_pi_addpchg(jpc_pi_t *pi, jpc_pocpchg_t *pchg);
+
+/* Prepare a packet iterator for iteration. */
+int jpc_pi_init(jpc_pi_t *pi);
+
+/* Set the iterator to the first packet. */
+int jpc_pi_begin(jpc_pi_t *pi);
+
+/* Proceed to the next packet in sequence. */
+int jpc_pi_next(jpc_pi_t *pi);
+
+/* Get the index of the current packet. */
+#define jpc_pi_getind(pi) ((pi)->pktno)
+
+/* Get the component number of the current packet. */
+#define jpc_pi_cmptno(pi) ((pi)->compno)
+
+/* Get the resolution level of the current packet. */
+#define jpc_pi_rlvlno(pi) ((pi)->rlvlno)
+
+/* Get the layer number of the current packet. */
+#define jpc_pi_lyrno(pi) ((pi)->lyrno)
+
+/* Get the precinct number of the current packet. */
+#define jpc_pi_prcno(pi) ((pi)->prcno)
+
+/* Get the progression order for the current packet. */
+#define jpc_pi_prg(pi) ((pi)->pchg->prgord)
+
+/******************************************************************************\
+* Functions/macros for progression change lists.
+\******************************************************************************/
+
+/* Create a progression change list. */
+jpc_pchglist_t *jpc_pchglist_create(void);
+
+/* Destroy a progression change list. */
+void jpc_pchglist_destroy(jpc_pchglist_t *pchglist);
+
+/* Insert a new element into a progression change list. */
+int jpc_pchglist_insert(jpc_pchglist_t *pchglist, int pchgno, jpc_pchg_t *pchg);
+
+/* Remove an element from a progression change list. */
+jpc_pchg_t *jpc_pchglist_remove(jpc_pchglist_t *pchglist, unsigned pchgno);
+
+/* Get an element from a progression change list. */
+JAS_ATTRIBUTE_PURE
+const jpc_pchg_t *jpc_pchglist_get(const jpc_pchglist_t *pchglist, unsigned pchgno);
+
+/* Copy a progression change list. */
+jpc_pchglist_t *jpc_pchglist_copy(const jpc_pchglist_t *pchglist);
+
+/* Get the number of elements in a progression change list. */
+JAS_ATTRIBUTE_PURE
+unsigned jpc_pchglist_numpchgs(const jpc_pchglist_t *pchglist);
+
+/******************************************************************************\
+* Functions/macros for progression changes.
+\******************************************************************************/
+
+/* Destroy a progression change. */
+void jpc_pchg_destroy(jpc_pchg_t *pchg);
+
+/* Copy a progression change. */
+jpc_pchg_t *jpc_pchg_copy(const jpc_pchg_t *pchg);
+
+#endif
--- /dev/null
+++ b/jpc_t2dec.c
@@ -1,0 +1,603 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tier 2 Decoder
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_t2dec.h"
+#include "jpc_bs.h"
+#include "jpc_dec.h"
+#include "jpc_cs.h"
+#include "jpc_t1cod.h"
+#include "jpc_math.h"
+
+#include "jasper/jas_types.h"
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_math.h"
+#include "jasper/jas_stream.h"
+#include "jasper/jas_debug.h"
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+static long jpc_dec_lookahead(jas_stream_t *in);
+static int jpc_getcommacode(jpc_bitstream_t *in);
+static int jpc_getnumnewpasses(jpc_bitstream_t *in);
+static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int lvlno,
+ int prcno, unsigned lyrno);
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+static int jpc_getcommacode(jpc_bitstream_t *in)
+{+ int n;
+ int v;
+
+ n = 0;
+ for (;;) {+ if ((v = jpc_bitstream_getbit(in)) < 0) {+ return -1;
+ }
+ if (jpc_bitstream_eof(in)) {+ return -1;
+ }
+ if (!v) {+ break;
+ }
+ ++n;
+ }
+
+ return n;
+}
+
+static int jpc_getnumnewpasses(jpc_bitstream_t *in)
+{+ int n;
+
+ if ((n = jpc_bitstream_getbit(in)) > 0) {+ if ((n = jpc_bitstream_getbit(in)) > 0) {+ if ((n = jpc_bitstream_getbits(in, 2)) == 3) {+ if ((n = jpc_bitstream_getbits(in, 5)) == 31) {+ if ((n = jpc_bitstream_getbits(in, 7)) >= 0) {+ n += 36 + 1;
+ }
+ } else if (n >= 0) {+ n += 5 + 1;
+ }
+ } else if (n >= 0) {+ n += 2 + 1;
+ }
+ } else if (!n) {+ n += 2;
+ }
+ } else if (!n) {+ ++n;
+ }
+
+ return n;
+}
+
+static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int rlvlno,
+ int prcno, unsigned lyrno)
+{+ jpc_bitstream_t *inb;
+ jpc_dec_tcomp_t *tcomp;
+ jpc_dec_rlvl_t *rlvl;
+ jpc_dec_band_t *band;
+ jpc_dec_cblk_t *cblk;
+ int m;
+ jpc_tagtreenode_t *leaf;
+ int included;
+ int ret;
+ int numnewpasses;
+ jpc_dec_seg_t *seg;
+ int len;
+ int present;
+ jpc_ms_t *ms;
+ jpc_dec_tile_t *tile;
+ jpc_dec_ccp_t *ccp;
+ jpc_dec_cp_t *cp;
+ jpc_dec_prc_t *prc;
+ uint_fast32_t bodylen;
+ bool discard;
+
+ /* Avoid compiler warning about possible use of uninitialized
+ variable. */
+ bodylen = 0;
+
+ discard = (lyrno >= dec->maxlyrs);
+
+ tile = dec->curtile;
+ cp = tile->cp;
+ ccp = &cp->ccps[compno];
+
+ /*
+ * Decode the packet header.
+ */
+
+ /* Decode the SOP marker segment if present. */
+ if (cp->csty & JPC_COD_SOP) {+ if (jpc_dec_lookahead(in) == JPC_MS_SOP) {+ if (!(ms = jpc_getms(in, dec->cstate))) {+ return -1;
+ }
+ if (jpc_ms_gettype(ms) != JPC_MS_SOP) {+ jpc_ms_destroy(ms);
+ jas_eprintf("cannot get (SOP) marker segment\n");+ return -1;
+ }
+ unsigned int maxNsop = 65536;
+ /* checking the packet sequence number */
+ if (tile->pi->pktno % maxNsop != ms->parms.sop.seqno) {+ jas_eprintf("incorrect packet sequence number %d was found, but expected %d\n",+ ms->parms.sop.seqno, tile->pi->pktno % maxNsop);
+ jpc_ms_destroy(ms);
+ return -1;
+ }
+ jpc_ms_destroy(ms);
+ }
+ }
+
+ const uint_least64_t hdroffstart = jas_stream_getrwcount(pkthdrstream);
+
+ if (!(inb = jpc_bitstream_sopen(pkthdrstream, "r"))) {+ return -1;
+ }
+
+ if ((present = jpc_bitstream_getbit(inb)) < 0) {+ jpc_bitstream_close(inb);
+ return 1;
+ }
+ JAS_DBGLOG(10, ("\n", present));+ JAS_DBGLOG(10, ("present=%d ", present));+
+ /* Is the packet non-empty? */
+ if (present) {+ /* The packet is non-empty. */
+ tcomp = &tile->tcomps[compno];
+ rlvl = &tcomp->rlvls[rlvlno];
+ bodylen = 0;
+ unsigned bandno;
+ for (bandno = 0, band = rlvl->bands; bandno < (unsigned)rlvl->numbands;
+ ++bandno, ++band) {+ if (!band->data) {+ continue;
+ }
+ prc = &band->prcs[prcno];
+ if (!prc->cblks) {+ continue;
+ }
+ unsigned cblkno;
+ unsigned usedcblkcnt = 0;
+ for (cblkno = 0, cblk = prc->cblks; cblkno < (unsigned)prc->numcblks;
+ ++cblkno, ++cblk) {+ ++usedcblkcnt;
+ if (!cblk->numpasses) {+ leaf = jpc_tagtree_getleaf(prc->incltagtree, usedcblkcnt - 1);
+ if ((included = jpc_tagtree_decode(prc->incltagtree, leaf, lyrno + 1, inb)) < 0) {+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ } else {+ if ((included = jpc_bitstream_getbit(inb)) < 0) {+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ }
+ JAS_DBGLOG(10, ("\n"));+ JAS_DBGLOG(10, ("included=%d ", included));+ if (!included) {+ continue;
+ }
+ if (!cblk->numpasses) {+ unsigned i = 1;
+ leaf = jpc_tagtree_getleaf(prc->numimsbstagtree, usedcblkcnt - 1);
+ for (;;) {+ if ((ret = jpc_tagtree_decode(prc->numimsbstagtree, leaf, i, inb)) < 0) {+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ if (ret) {+ break;
+ }
+ ++i;
+ }
+ cblk->numimsbs = i - 1;
+ cblk->firstpassno = cblk->numimsbs * 3;
+ }
+ if ((numnewpasses = jpc_getnumnewpasses(inb)) < 0) {+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses));+ seg = cblk->curseg;
+ const unsigned savenumnewpasses = numnewpasses;
+ unsigned mycounter = 0;
+ if (numnewpasses > 0) {+ if (cblk->firstpassno > 10000) {+ /* workaround for
+ CVE-2016-9398: this
+ large value would
+ make
+ JPC_SEGPASSCNT()
+ return a negative
+ value, causing an
+ assertion failure
+ in
+ jpc_floorlog2() */
+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ if ((m = jpc_getcommacode(inb)) < 0) {+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ cblk->numlenbits += m;
+ JAS_DBGLOG(10, ("increment=%d ", m));+ while (numnewpasses > 0) {+ const unsigned passno = cblk->firstpassno + cblk->numpasses + mycounter;
+ if (passno >= 10000) {+ /* with this value,
+ JPC_SEGPASSCNT()
+ would return 0,
+ which is an illegal
+ value and would
+ later crash in
+ jpc_floorlog2() */
+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ /* XXX - the maxpasses is not set precisely but this doesn't matter... */
+ const unsigned maxpasses = JPC_SEGPASSCNT(passno, cblk->firstpassno, 10000, (ccp->cblkctx & JPC_COX_LAZY) != 0, (ccp->cblkctx & JPC_COX_TERMALL) != 0);
+ if (!discard && !seg) {+ if (!(seg = jpc_seg_alloc())) {+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ jpc_seglist_insert(&cblk->segs, cblk->segs.tail, seg);
+ if (!cblk->curseg) {+ cblk->curseg = seg;
+ }
+ seg->passno = passno;
+ seg->type = JPC_SEGTYPE(seg->passno, cblk->firstpassno, (ccp->cblkctx & JPC_COX_LAZY) != 0);
+ seg->maxpasses = maxpasses;
+ }
+ const unsigned n = JAS_MIN((unsigned)numnewpasses, maxpasses);
+ mycounter += n;
+ numnewpasses -= n;
+ if ((len = jpc_bitstream_getbits(inb, cblk->numlenbits + jpc_floorlog2(n))) < 0) {+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ JAS_DBGLOG(10, ("len=%d ", len));+ if (!discard) {+ seg->lyrno = lyrno;
+ seg->numpasses += n;
+ seg->cnt = len;
+ seg = seg->next;
+ }
+ bodylen += len;
+ }
+ }
+ cblk->numpasses += savenumnewpasses;
+ }
+ }
+
+ jpc_bitstream_inalign(inb, 0, 0);
+
+ } else {+ if (jpc_bitstream_inalign(inb, 0x7f, 0)) {+ jas_eprintf("alignment failed\n");+ jpc_bitstream_close(inb);
+ return -1;
+ }
+ }
+ jpc_bitstream_close(inb);
+
+ if (jas_getdbglevel() >= 5) {+ const uint_least64_t hdroffend = jas_stream_getrwcount(pkthdrstream);
+ const unsigned long hdrlen = hdroffend - hdroffstart;
+ jas_eprintf("hdrlen=%lu bodylen=%lu \n", (unsigned long) hdrlen,+ (unsigned long) bodylen);
+ }
+
+ if (cp->csty & JPC_COD_EPH) {+ if (!(ms = jpc_getms(pkthdrstream, dec->cstate))) {+ jas_eprintf("cannot get (EPH) marker segment\n");+ return -1;
+ }
+ if (jpc_ms_gettype(ms) != JPC_MS_EPH) {+ jpc_ms_destroy(ms);
+ jas_eprintf("missing EPH marker segment\n");+ return -1;
+ }
+ jpc_ms_destroy(ms);
+ }
+
+ /* decode the packet body. */
+
+ if (jas_getdbglevel() >= 1) {+ jas_eprintf("packet body offset=%06ld\n", (long) jas_stream_getrwcount(in));+ }
+
+ if (!discard) {+ tcomp = &tile->tcomps[compno];
+ rlvl = &tcomp->rlvls[rlvlno];
+ unsigned bandno;
+ for (bandno = 0, band = rlvl->bands; bandno < (unsigned)rlvl->numbands;
+ ++bandno, ++band) {+ if (!band->data) {+ continue;
+ }
+ prc = &band->prcs[prcno];
+ if (!prc->cblks) {+ continue;
+ }
+ unsigned cblkno;
+ for (cblkno = 0, cblk = prc->cblks; cblkno < (unsigned)prc->numcblks;
+ ++cblkno, ++cblk) {+ seg = cblk->curseg;
+ while (seg) {+ if (!seg->stream) {+ if (!(seg->stream = jas_stream_memopen(0, 0))) {+ return -1;
+ }
+ }
+#if 0
+jas_eprintf("lyrno=%02d, compno=%02d, lvlno=%02d, prcno=%02d, bandno=%02d, cblkno=%02d, passno=%02d numpasses=%02d cnt=%d numbps=%d, numimsbs=%d\n", lyrno, compno, rlvlno, prcno, band - rlvl->bands, cblk - prc->cblks, seg->passno, seg->numpasses, seg->cnt, band->numbps, cblk->numimsbs);+#endif
+ if (seg->cnt > 0) {+ if (jpc_getdata(in, seg->stream, seg->cnt) < 0) {+ return -1;
+ }
+ seg->cnt = 0;
+ }
+ if (seg->numpasses >= seg->maxpasses) {+ cblk->curseg = seg->next;
+ }
+ seg = seg->next;
+ }
+ }
+ }
+ } else {+ if (jas_stream_gobble(in, bodylen) != JAS_CAST(int, bodylen)) {+ return -1;
+ }
+ }
+ return 0;
+}
+
+/********************************************************************************************/
+/********************************************************************************************/
+
+int jpc_dec_decodepkts(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in)
+{+ jpc_dec_tile_t *tile;
+ jpc_pi_t *pi;
+ int ret;
+
+ tile = dec->curtile;
+ pi = tile->pi;
+ for (;;) {+ if (!tile->pkthdrstream || jas_stream_peekc(tile->pkthdrstream) == EOF) {+ switch (jpc_dec_lookahead(in)) {+ case JPC_MS_EOC:
+ case JPC_MS_SOT:
+ return 0;
+ case JPC_MS_SOP:
+ case JPC_MS_EPH:
+ case 0:
+ break;
+ default:
+ return -1;
+ }
+ }
+ if ((ret = jpc_pi_next(pi))) {+ return ret;
+ }
+ if (dec->maxpkts >= 0 && dec->numpkts >= (unsigned)dec->maxpkts) {+ jas_eprintf("warning: stopping decode prematurely as requested\n");+ return 0;
+ }
+ if (jas_getdbglevel() >= 1) {+ jas_eprintf("packet offset=%08ld prg=%d cmptno=%02d "+ "rlvlno=%02d prcno=%03d lyrno=%02d\n", (long)
+ jas_stream_getrwcount(in), jpc_pi_prg(pi), jpc_pi_cmptno(pi),
+ jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi));
+ }
+ if (jpc_dec_decodepkt(dec, pkthdrstream, in, jpc_pi_cmptno(pi),
+ jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) {+ return -1;
+ }
+ ++dec->numpkts;
+ }
+}
+
+jpc_pi_t *jpc_dec_pi_create(jpc_dec_t *dec, jpc_dec_tile_t *tile)
+{+ jpc_pi_t *pi;
+ unsigned compno;
+ jpc_picomp_t *picomp;
+ jpc_pirlvl_t *pirlvl;
+ jpc_dec_tcomp_t *tcomp;
+ unsigned rlvlno;
+ jpc_dec_rlvl_t *rlvl;
+ unsigned prcno;
+ unsigned *prclyrno;
+ jpc_dec_cmpt_t *cmpt;
+
+ if (!(pi = jpc_pi_create0())) {+ return 0;
+ }
+ pi->numcomps = dec->numcomps;
+ if (!(pi->picomps = jas_alloc2(pi->numcomps, sizeof(jpc_picomp_t)))) {+ jpc_pi_destroy(pi);
+ return 0;
+ }
+ for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno,
+ ++picomp) {+ picomp->pirlvls = 0;
+ }
+
+ for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps;
+ compno < pi->numcomps; ++compno, ++tcomp, ++picomp) {+ picomp->numrlvls = tcomp->numrlvls;
+ if (!(picomp->pirlvls = jas_alloc2(picomp->numrlvls,
+ sizeof(jpc_pirlvl_t)))) {+ jpc_pi_destroy(pi);
+ return 0;
+ }
+ for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
+ picomp->numrlvls; ++rlvlno, ++pirlvl) {+ pirlvl->prclyrnos = 0;
+ }
+ for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
+ rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {+/* XXX sizeof(long) should be sizeof different type */
+ pirlvl->numprcs = rlvl->numprcs;
+ if (!(pirlvl->prclyrnos = jas_alloc2(pirlvl->numprcs,
+ sizeof(long)))) {+ jpc_pi_destroy(pi);
+ return 0;
+ }
+ }
+ }
+
+ pi->maxrlvls = 0;
+ for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps, cmpt =
+ dec->cmpts; compno < pi->numcomps; ++compno, ++tcomp, ++picomp,
+ ++cmpt) {+ picomp->hsamp = cmpt->hstep;
+ picomp->vsamp = cmpt->vstep;
+ for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
+ rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {+ pirlvl->prcwidthexpn = rlvl->prcwidthexpn;
+ pirlvl->prcheightexpn = rlvl->prcheightexpn;
+ for (prcno = 0, prclyrno = pirlvl->prclyrnos;
+ prcno < pirlvl->numprcs; ++prcno, ++prclyrno) {+ *prclyrno = 0;
+ }
+ pirlvl->numhprcs = rlvl->numhprcs;
+ }
+ if (pi->maxrlvls < tcomp->numrlvls) {+ pi->maxrlvls = tcomp->numrlvls;
+ }
+ }
+
+ pi->numlyrs = tile->cp->numlyrs;
+ pi->xstart = tile->xstart;
+ pi->ystart = tile->ystart;
+ pi->xend = tile->xend;
+ pi->yend = tile->yend;
+
+ pi->picomp = 0;
+ pi->pirlvl = 0;
+ pi->x = 0;
+ pi->y = 0;
+ pi->compno = 0;
+ pi->rlvlno = 0;
+ pi->prcno = 0;
+ pi->lyrno = 0;
+ pi->xstep = 0;
+ pi->ystep = 0;
+
+ pi->pchgno = -1;
+
+ pi->defaultpchg.prgord = tile->cp->prgord;
+ pi->defaultpchg.compnostart = 0;
+ pi->defaultpchg.compnoend = pi->numcomps;
+ pi->defaultpchg.rlvlnostart = 0;
+ pi->defaultpchg.rlvlnoend = pi->maxrlvls;
+ pi->defaultpchg.lyrnoend = pi->numlyrs;
+ pi->pchg = 0;
+
+ pi->valid = 0;
+
+ return pi;
+}
+
+static long jpc_dec_lookahead(jas_stream_t *in)
+{+ uint_fast16_t x;
+ if (jpc_getuint16(in, &x)) {+ return -1;
+ }
+ if (jas_stream_ungetc(in, x & 0xff) == EOF ||
+ jas_stream_ungetc(in, x >> 8) == EOF) {+ return -1;
+ }
+ if (x >= JPC_MS_INMIN) {+ return x;
+ }
+ return 0;
+}
--- /dev/null
+++ b/jpc_t2dec.h
@@ -1,0 +1,93 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tier 2 Decoder
+ *
+ * $Id$
+ */
+
+#ifndef JPC_T2DEC_H
+#define JPC_T2DEC_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_stream.h"
+
+#include "jpc_dec.h"
+#include "jpc_t2cod.h"
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Decode the packets for a tile-part. */
+int jpc_dec_decodepkts(jpc_dec_t *dec, jas_stream_t *pkthdrstream,
+ jas_stream_t *in);
+
+/* Create a packet iterator for the decoder. */
+jpc_pi_t *jpc_dec_pi_create(jpc_dec_t *dec, jpc_dec_tile_t *tile);
+
+#endif
--- /dev/null
+++ b/jpc_tagtree.c
@@ -1,0 +1,386 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tag Tree Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_tagtree.h"
+
+#include "jasper/jas_malloc.h"
+#include "jasper/jas_stream.h"
+
+/******************************************************************************\
+* Prototypes.
+\******************************************************************************/
+
+static jpc_tagtree_t *jpc_tagtree_alloc(void);
+
+/******************************************************************************\
+* Code for creating and destroying tag trees.
+\******************************************************************************/
+
+/* Create a tag tree. */
+
+jpc_tagtree_t *jpc_tagtree_create(int numleafsh, int numleafsv)
+{+ int nplh[JPC_TAGTREE_MAXDEPTH];
+ int nplv[JPC_TAGTREE_MAXDEPTH];
+ jpc_tagtreenode_t *node;
+ jpc_tagtreenode_t *parentnode;
+ jpc_tagtreenode_t *parentnode0;
+ jpc_tagtree_t *tree;
+ int i;
+ int j;
+ int k;
+ int numlvls;
+ int n;
+
+ assert(numleafsh > 0 && numleafsv > 0);
+
+ if (!(tree = jpc_tagtree_alloc())) {+ return 0;
+ }
+ tree->numleafsh_ = numleafsh;
+ tree->numleafsv_ = numleafsv;
+
+ numlvls = 0;
+ nplh[0] = numleafsh;
+ nplv[0] = numleafsv;
+ do {+ n = nplh[numlvls] * nplv[numlvls];
+ nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
+ nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
+ tree->numnodes_ += n;
+ ++numlvls;
+ } while (n > 1);
+
+ if (!(tree->nodes_ = jas_alloc2(tree->numnodes_, sizeof(jpc_tagtreenode_t)))) {+ jpc_tagtree_destroy(tree);
+ return 0;
+ }
+
+ /* Initialize the parent links for all nodes in the tree. */
+
+ node = tree->nodes_;
+ parentnode = &tree->nodes_[tree->numleafsh_ * tree->numleafsv_];
+ parentnode0 = parentnode;
+
+ for (i = 0; i < numlvls - 1; ++i) {+ for (j = 0; j < nplv[i]; ++j) {+ k = nplh[i];
+ while (--k >= 0) {+ node->parent_ = parentnode;
+ ++node;
+ if (--k >= 0) {+ node->parent_ = parentnode;
+ ++node;
+ }
+ ++parentnode;
+ }
+ if ((j & 1) || j == nplv[i] - 1) {+ parentnode0 = parentnode;
+ } else {+ parentnode = parentnode0;
+ parentnode0 += nplh[i];
+ }
+ }
+ }
+ node->parent_ = 0;
+
+ /* Initialize the data values to something sane. */
+
+ jpc_tagtree_reset(tree);
+
+ return tree;
+}
+
+/* Destroy a tag tree. */
+
+void jpc_tagtree_destroy(jpc_tagtree_t *tree)
+{+ jas_free(tree->nodes_);
+ jas_free(tree);
+}
+
+static jpc_tagtree_t *jpc_tagtree_alloc()
+{+ jpc_tagtree_t *tree;
+
+ if (!(tree = jas_malloc(sizeof(jpc_tagtree_t)))) {+ return 0;
+ }
+ tree->numleafsh_ = 0;
+ tree->numleafsv_ = 0;
+ tree->numnodes_ = 0;
+ tree->nodes_ = 0;
+
+ return tree;
+}
+
+/******************************************************************************\
+* Code.
+\******************************************************************************/
+
+/* Copy state information from one tag tree to another. */
+
+void jpc_tagtree_copy(jpc_tagtree_t *dsttree, const jpc_tagtree_t *srctree)
+{+ int n;
+ jpc_tagtreenode_t *dstnode;
+
+ /* The two tag trees must have similar sizes. */
+ assert(srctree->numleafsh_ == dsttree->numleafsh_ &&
+ srctree->numleafsv_ == dsttree->numleafsv_);
+
+ n = srctree->numnodes_;
+ const jpc_tagtreenode_t *srcnode = srctree->nodes_;
+ dstnode = dsttree->nodes_;
+ while (--n >= 0) {+ dstnode->value_ = srcnode->value_;
+ dstnode->low_ = srcnode->low_;
+ dstnode->known_ = srcnode->known_;
+ ++dstnode;
+ ++srcnode;
+ }
+}
+
+/* Reset all of the state information associated with a tag tree. */
+
+void jpc_tagtree_reset(jpc_tagtree_t *tree)
+{+ int n;
+ jpc_tagtreenode_t *node;
+
+ n = tree->numnodes_;
+ node = tree->nodes_;
+
+ while (--n >= 0) {+ node->value_ = INT_MAX;
+ node->low_ = 0;
+ node->known_ = 0;
+ ++node;
+ }
+}
+
+/* Set the value associated with the specified leaf node, updating
+the other nodes as necessary. */
+
+void jpc_tagtree_setvalue(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
+ int value)
+{+ jpc_tagtreenode_t *node;
+
+ /* Avoid compiler warnings about unused parameters. */
+ USED(tree);
+
+ assert(value >= 0);
+
+ node = leaf;
+ while (node && node->value_ > value) {+ node->value_ = value;
+ node = node->parent_;
+ }
+}
+
+/* Get a particular leaf node. */
+
+jpc_tagtreenode_t *jpc_tagtree_getleaf(jpc_tagtree_t *tree, int n)
+{+ return &tree->nodes_[n];
+}
+
+/* Invoke the tag tree encoding procedure. */
+
+int jpc_tagtree_encode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
+ int threshold, jpc_bitstream_t *out)
+{+ jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1];
+ jpc_tagtreenode_t **stkptr;
+ jpc_tagtreenode_t *node;
+ int low;
+
+ /* Avoid compiler warnings about unused parameters. */
+ USED(tree);
+
+ assert(leaf);
+ assert(threshold >= 0);
+
+ /* Traverse to the root of the tree, recording the path taken. */
+ stkptr = stk;
+ node = leaf;
+ while (node->parent_) {+ *stkptr++ = node;
+ node = node->parent_;
+ }
+
+ low = 0;
+ for (;;) {+ if (low > node->low_) {+ /* Deferred propagation of the lower bound downward in
+ the tree. */
+ node->low_ = low;
+ } else {+ low = node->low_;
+ }
+
+ while (low < threshold) {+ if (low >= node->value_) {+ if (!node->known_) {+ if (jpc_bitstream_putbit(out, 1) == EOF) {+ return -1;
+ }
+ node->known_ = 1;
+ }
+ break;
+ }
+ if (jpc_bitstream_putbit(out, 0) == EOF) {+ return -1;
+ }
+ ++low;
+ }
+ node->low_ = low;
+ if (stkptr == stk) {+ break;
+ }
+ node = *--stkptr;
+
+ }
+ return (leaf->low_ < threshold) ? 1 : 0;
+
+}
+
+/* Invoke the tag tree decoding procedure. */
+
+int jpc_tagtree_decode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
+ int threshold, jpc_bitstream_t *in)
+{+ jpc_tagtreenode_t *stk[JPC_TAGTREE_MAXDEPTH - 1];
+ jpc_tagtreenode_t **stkptr;
+ jpc_tagtreenode_t *node;
+ int low;
+ int ret;
+
+ /* Avoid compiler warnings about unused parameters. */
+ USED(tree);
+
+ assert(threshold >= 0);
+
+ /* Traverse to the root of the tree, recording the path taken. */
+ stkptr = stk;
+ node = leaf;
+ while (node->parent_) {+ *stkptr++ = node;
+ node = node->parent_;
+ }
+
+ low = 0;
+ for (;;) {+ if (low > node->low_) {+ node->low_ = low;
+ } else {+ low = node->low_;
+ }
+ while (low < threshold && low < node->value_) {+ if ((ret = jpc_bitstream_getbit(in)) < 0) {+ return -1;
+ }
+ if (ret) {+ node->value_ = low;
+ } else {+ ++low;
+ }
+ }
+ node->low_ = low;
+ if (stkptr == stk) {+ break;
+ }
+ node = *--stkptr;
+ }
+
+ return (node->value_ < threshold) ? 1 : 0;
+}
+
+/******************************************************************************\
+* Code for debugging.
+\******************************************************************************/
+
+void jpc_tagtree_dump(const jpc_tagtree_t *tree, FILE *out)
+{+ int n;
+
+ const jpc_tagtreenode_t *node = tree->nodes_;
+ n = tree->numnodes_;
+ while (--n >= 0) {+ fprintf(out, "node %p, parent %p, value %d, lower %d, known %d\n",
+ (const void *) node, (const void *) node->parent_, node->value_, node->low_,
+ node->known_);
+ ++node;
+ }
+}
--- /dev/null
+++ b/jpc_tagtree.h
@@ -1,0 +1,165 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tag Tree Library
+ *
+ * $Id$
+ */
+
+#ifndef JPC_TAGTREE_H
+#define JPC_TAGTREE_H
+
+/******************************************************************************\
+* Includes
+\******************************************************************************/
+
+#include "jpc_bs.h"
+
+/******************************************************************************\
+* Constants
+\******************************************************************************/
+
+/* The maximum allowable depth for a tag tree. */
+#define JPC_TAGTREE_MAXDEPTH 32
+
+/******************************************************************************\
+* Types
+\******************************************************************************/
+
+/*
+ * Tag tree node.
+ */
+
+typedef struct jpc_tagtreenode_ {+
+ /* The parent of this node. */
+ struct jpc_tagtreenode_ *parent_;
+
+ /* The value associated with this node. */
+ int value_;
+
+ /* The lower bound on the value associated with this node. */
+ int low_;
+
+ /* A flag indicating if the value is known exactly. */
+ int known_;
+
+} jpc_tagtreenode_t;
+
+/*
+ * Tag tree.
+ */
+
+typedef struct {+
+ /* The number of leaves in the horizontal direction. */
+ int numleafsh_;
+
+ /* The number of leaves in the vertical direction. */
+ int numleafsv_;
+
+ /* The total number of nodes in the tree. */
+ int numnodes_;
+
+ /* The nodes. */
+ jpc_tagtreenode_t *nodes_;
+
+} jpc_tagtree_t;
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Create a tag tree. */
+jpc_tagtree_t *jpc_tagtree_create(int numleafsh, int numleafsv);
+
+/* Destroy a tag tree. */
+void jpc_tagtree_destroy(jpc_tagtree_t *tree);
+
+/* Copy data from one tag tree to another. */
+void jpc_tagtree_copy(jpc_tagtree_t *dsttree, const jpc_tagtree_t *srctree);
+
+/* Reset the tag tree state. */
+void jpc_tagtree_reset(jpc_tagtree_t *tree);
+
+/* Set the value associated with a particular leaf node of a tag tree. */
+void jpc_tagtree_setvalue(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
+ int value);
+
+/* Get a pointer to a particular leaf node. */
+JAS_ATTRIBUTE_PURE
+jpc_tagtreenode_t *jpc_tagtree_getleaf(jpc_tagtree_t *tree, int n);
+
+/* Invoke the tag tree decoding procedure. */
+int jpc_tagtree_decode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
+ int threshold, jpc_bitstream_t *in);
+
+/* Invoke the tag tree encoding procedure. */
+int jpc_tagtree_encode(jpc_tagtree_t *tree, jpc_tagtreenode_t *leaf,
+ int threshold, jpc_bitstream_t *out);
+
+/* Dump a tag tree (for debugging purposes). */
+void jpc_tagtree_dump(const jpc_tagtree_t *tree, FILE *out);
+
+#endif
--- /dev/null
+++ b/jpc_tsfb.c
@@ -1,0 +1,299 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2004 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tree-Structured Filter Bank (TSFB) Library
+ *
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jpc_tsfb.h"
+#include "jpc_cs.h"
+#include "jpc_math.h"
+#include "jpc_fix.h"
+
+#include "jasper/jas_seq.h"
+
+static int jpc_tsfb_analyze2(jpc_tsfb_t *tsfb, jpc_fix_t *a, int xstart, int ystart,
+ unsigned width, unsigned height, unsigned stride, unsigned numlvls);
+
+static int jpc_tsfb_synthesize2(jpc_tsfb_t *tsfb, jpc_fix_t *a, int xstart, int ystart,
+ unsigned width, unsigned height, unsigned stride, unsigned numlvls);
+
+static void jpc_tsfb_getbands2(jpc_tsfb_t *tsfb, int locxstart, int locystart,
+ int xstart, int ystart, int xend, int yend, jpc_tsfb_band_t **bands,
+ unsigned numlvls);
+
+/******************************************************************************\
+*
+\******************************************************************************/
+
+jpc_tsfb_t *jpc_cod_gettsfb(unsigned qmfbid, unsigned numlvls)
+{+ jpc_tsfb_t *tsfb;
+
+ if (!(tsfb = malloc(sizeof(jpc_tsfb_t))))
+ return 0;
+
+ if (numlvls > 0) {+ switch (qmfbid) {+ case JPC_COX_INS:
+ tsfb->qmfb = &jpc_ns_qmfb2d;
+ break;
+ default:
+ case JPC_COX_RFT:
+ tsfb->qmfb = &jpc_ft_qmfb2d;
+ break;
+ }
+ } else {+ tsfb->qmfb = 0;
+ }
+ tsfb->numlvls = numlvls;
+ return tsfb;
+}
+
+void jpc_tsfb_destroy(jpc_tsfb_t *tsfb)
+{+ free(tsfb);
+}
+
+int jpc_tsfb_analyze(jpc_tsfb_t *tsfb, jas_seq2d_t *a)
+{+ if (tsfb->numlvls == 0)
+ return 0;
+
+ return jpc_tsfb_analyze2(tsfb,
+ jas_seq2d_getref(a, jas_seq2d_xstart(a), jas_seq2d_ystart(a)),
+ jas_seq2d_xstart(a), jas_seq2d_ystart(a),
+ jas_seq2d_width(a), jas_seq2d_height(a),
+ jas_seq2d_rowstep(a), tsfb->numlvls - 1);
+}
+
+static int jpc_tsfb_analyze2(jpc_tsfb_t *tsfb, jpc_fix_t *a, int xstart, int ystart,
+ unsigned width, unsigned height, unsigned stride, unsigned numlvls)
+{+ if (width == 0 || height == 0)
+ return 0;
+
+ if ((*tsfb->qmfb->analyze)(a, xstart, ystart, width, height, stride))
+ return -1;
+
+ if (numlvls == 0)
+ return 0;
+
+ return jpc_tsfb_analyze2(tsfb, a,
+ JPC_CEILDIVPOW2(xstart, 1),
+ JPC_CEILDIVPOW2(ystart, 1),
+ JPC_CEILDIVPOW2(xstart + width, 1) - JPC_CEILDIVPOW2(xstart, 1),
+ JPC_CEILDIVPOW2(ystart + height, 1) - JPC_CEILDIVPOW2(ystart, 1),
+ stride, numlvls - 1);
+}
+
+int jpc_tsfb_synthesize(jpc_tsfb_t *tsfb, jas_seq2d_t *a)
+{+ if (tsfb->numlvls == 0 || jas_seq2d_empty(a))
+ return 0;
+
+ return jpc_tsfb_synthesize2(tsfb,
+ jas_seq2d_getref(a, jas_seq2d_xstart(a), jas_seq2d_ystart(a)),
+ jas_seq2d_xstart(a), jas_seq2d_ystart(a),
+ jas_seq2d_width(a), jas_seq2d_height(a),
+ jas_seq2d_rowstep(a),
+ tsfb->numlvls - 1);
+}
+
+static int jpc_tsfb_synthesize2(jpc_tsfb_t *tsfb, jpc_fix_t *a, int xstart, int ystart,
+ unsigned width, unsigned height, unsigned stride, unsigned numlvls)
+{+ if (numlvls > 0) {+ if (jpc_tsfb_synthesize2(tsfb, a, JPC_CEILDIVPOW2(xstart, 1),
+ JPC_CEILDIVPOW2(ystart, 1), JPC_CEILDIVPOW2(xstart + width,
+ 1) - JPC_CEILDIVPOW2(xstart, 1), JPC_CEILDIVPOW2(ystart +
+ height, 1) - JPC_CEILDIVPOW2(ystart, 1), stride, numlvls -
+ 1)) {+ return -1;
+ }
+ }
+
+ if (width == 0 || height == 0)
+ return 0;
+
+ return tsfb->qmfb->synthesize(a, xstart, ystart, width, height, stride);
+}
+
+int jpc_tsfb_getbands(jpc_tsfb_t *tsfb, uint_fast32_t xstart,
+ uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend,
+ jpc_tsfb_band_t *bands)
+{+ jpc_tsfb_band_t *band;
+
+ band = bands;
+ if (tsfb->numlvls > 0) {+ jpc_tsfb_getbands2(tsfb, xstart, ystart, xstart, ystart, xend, yend,
+ &band, tsfb->numlvls);
+ } else {+
+ band->xstart = xstart;
+ band->ystart = ystart;
+ band->xend = xend;
+ band->yend = yend;
+ band->locxstart = xstart;
+ band->locystart = ystart;
+ band->locxend = band->locxstart + band->xend - band->xstart;
+ band->locyend = band->locystart + band->yend - band->ystart;
+ band->orient = JPC_TSFB_LL;
+ band->synenergywt = JPC_FIX_ONE;
+ ++band;
+ }
+ return band - bands;
+}
+
+static void jpc_tsfb_getbands2(jpc_tsfb_t *tsfb, int locxstart, int locystart,
+ int xstart, int ystart, int xend, int yend, jpc_tsfb_band_t **bands,
+ unsigned numlvls)
+{+ int newxstart;
+ int newystart;
+ int newxend;
+ int newyend;
+ jpc_tsfb_band_t *band;
+
+ newxstart = JPC_CEILDIVPOW2(xstart, 1);
+ newystart = JPC_CEILDIVPOW2(ystart, 1);
+ newxend = JPC_CEILDIVPOW2(xend, 1);
+ newyend = JPC_CEILDIVPOW2(yend, 1);
+
+ if (numlvls > 0) {+
+ jpc_tsfb_getbands2(tsfb, locxstart, locystart, newxstart, newystart,
+ newxend, newyend, bands, numlvls - 1);
+
+ band = *bands;
+ band->xstart = JPC_FLOORDIVPOW2(xstart, 1);
+ band->ystart = newystart;
+ band->xend = JPC_FLOORDIVPOW2(xend, 1);
+ band->yend = newyend;
+ band->locxstart = locxstart + newxend - newxstart;
+ band->locystart = locystart;
+ band->locxend = band->locxstart + band->xend - band->xstart;
+ band->locyend = band->locystart + band->yend - band->ystart;
+ band->orient = JPC_TSFB_HL;
+ band->synenergywt = jpc_dbltofix(tsfb->qmfb->hpenergywts[
+ tsfb->numlvls - numlvls] * tsfb->qmfb->lpenergywts[
+ tsfb->numlvls - numlvls]);
+ ++(*bands);
+
+ band = *bands;
+ band->xstart = newxstart;
+ band->ystart = JPC_FLOORDIVPOW2(ystart, 1);
+ band->xend = newxend;
+ band->yend = JPC_FLOORDIVPOW2(yend, 1);
+ band->locxstart = locxstart;
+ band->locystart = locystart + newyend - newystart;
+ band->locxend = band->locxstart + band->xend - band->xstart;
+ band->locyend = band->locystart + band->yend - band->ystart;
+ band->orient = JPC_TSFB_LH;
+ band->synenergywt = jpc_dbltofix(tsfb->qmfb->lpenergywts[
+ tsfb->numlvls - numlvls] * tsfb->qmfb->hpenergywts[
+ tsfb->numlvls - numlvls]);
+ ++(*bands);
+
+ band = *bands;
+ band->xstart = JPC_FLOORDIVPOW2(xstart, 1);
+ band->ystart = JPC_FLOORDIVPOW2(ystart, 1);
+ band->xend = JPC_FLOORDIVPOW2(xend, 1);
+ band->yend = JPC_FLOORDIVPOW2(yend, 1);
+ band->locxstart = locxstart + newxend - newxstart;
+ band->locystart = locystart + newyend - newystart;
+ band->locxend = band->locxstart + band->xend - band->xstart;
+ band->locyend = band->locystart + band->yend - band->ystart;
+ band->orient = JPC_TSFB_HH;
+ band->synenergywt = jpc_dbltofix(tsfb->qmfb->hpenergywts[
+ tsfb->numlvls - numlvls] * tsfb->qmfb->hpenergywts[
+ tsfb->numlvls - numlvls]);
+ ++(*bands);
+
+ } else {+
+ band = *bands;
+ band->xstart = xstart;
+ band->ystart = ystart;
+ band->xend = xend;
+ band->yend = yend;
+ band->locxstart = locxstart;
+ band->locystart = locystart;
+ band->locxend = band->locxstart + band->xend - band->xstart;
+ band->locyend = band->locystart + band->yend - band->ystart;
+ band->orient = JPC_TSFB_LL;
+ band->synenergywt = jpc_dbltofix(tsfb->qmfb->lpenergywts[
+ tsfb->numlvls - numlvls - 1] * tsfb->qmfb->lpenergywts[
+ tsfb->numlvls - numlvls - 1]);
+ ++(*bands);
+
+ }
+
+}
--- /dev/null
+++ b/jpc_tsfb.h
@@ -1,0 +1,141 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2004 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * Tree-Structured Filter Bank (TSFB) Library
+ *
+ * $Id$
+ */
+
+#ifndef JPC_TSFB_H
+#define JPC_TSFB_H
+
+/******************************************************************************\
+* Includes.
+\******************************************************************************/
+
+#include "jasper/jas_seq.h"
+#include "jasper/jas_types.h"
+
+#include "jpc_fix.h"
+#include "jpc_qmfb.h"
+
+/******************************************************************************\
+* Constants.
+\******************************************************************************/
+
+#define JPC_TSFB_MAXBANDS (JPC_TSFB_MAXDEPTH * 3 + 1)
+#define JPC_TSFB_MAXDEPTH 32
+#define JPC_TSFB_RITIMODE JPC_QMFB1D_RITIMODE
+
+enum jpc_tsfb_orient {+ JPC_TSFB_LL = 0,
+ JPC_TSFB_LH = 1,
+ JPC_TSFB_HL = 2,
+ JPC_TSFB_HH = 3,
+};
+
+/******************************************************************************\
+* Types.
+\******************************************************************************/
+
+typedef struct {+ int xstart;
+ int ystart;
+ int xend;
+ int yend;
+ enum jpc_tsfb_orient orient;
+ int locxstart;
+ int locystart;
+ int locxend;
+ int locyend;
+ jpc_fix_t synenergywt;
+} jpc_tsfb_band_t;
+
+typedef struct {+ unsigned numlvls;
+ const jpc_qmfb2d_t *qmfb;
+} jpc_tsfb_t;
+
+/******************************************************************************\
+* Functions.
+\******************************************************************************/
+
+/* Create a TSFB. */
+jpc_tsfb_t *jpc_cod_gettsfb(unsigned qmfbid, unsigned numlevels);
+
+/* Destroy a TSFB. */
+void jpc_tsfb_destroy(jpc_tsfb_t *tsfb);
+
+/* Perform analysis. */
+int jpc_tsfb_analyze(jpc_tsfb_t *tsfb, jas_seq2d_t *x);
+
+/* Perform synthesis. */
+int jpc_tsfb_synthesize(jpc_tsfb_t *tsfb, jas_seq2d_t *x);
+
+/* Get band information for a TSFB. */
+int jpc_tsfb_getbands(jpc_tsfb_t *tsfb, uint_fast32_t xstart,
+ uint_fast32_t ystart, uint_fast32_t xend, uint_fast32_t yend,
+ jpc_tsfb_band_t *bands);
+
+#endif
--- /dev/null
+++ b/jpc_util.c
@@ -1,0 +1,186 @@
+/*
+ * Copyright (c) 1999-2000 Image Power, Inc. and the University of
+ * British Columbia.
+ * Copyright (c) 2001-2003 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+/*
+ * $Id$
+ */
+
+/******************************************************************************\
+* Includes
+\******************************************************************************/
+
+#include "jpc_util.h"
+#include "jpc_fix.h"
+
+#include "jasper/jas_math.h"
+#include "jasper/jas_malloc.h"
+
+/******************************************************************************\
+* Miscellaneous Functions
+\******************************************************************************/
+
+int jpc_atoaf(const char *s, int *numvalues, double **values)
+{+ static const char delim[] = ", \t\n";
+ char buf[4096];
+ int n;
+ double *vs;
+ char *cp;
+
+ strncpy(buf, s, sizeof(buf));
+ buf[sizeof(buf) - 1] = '\0';
+ n = 0;
+ if (strtok(buf, delim)) {+ ++n;
+ while ((cp = strtok(0, delim))) {+ if (*cp != '\0') {+ ++n;
+ }
+ }
+ }
+
+ if (n) {+ if (!(vs = jas_alloc2(n, sizeof(double)))) {+ return -1;
+ }
+
+ strncpy(buf, s, sizeof(buf));
+ buf[sizeof(buf) - 1] = '\0';
+ n = 0;
+ if ((cp = strtok(buf, delim))) {+ vs[n] = atof(cp);
+ ++n;
+ while ((cp = strtok(0, delim))) {+ if (*cp != '\0') {+ vs[n] = atof(cp);
+ ++n;
+ }
+ }
+ }
+ } else {+ vs = 0;
+ }
+
+ *numvalues = n;
+ *values = vs;
+
+ return 0;
+}
+
+jas_seq_t *jpc_seq_upsample(const jas_seq_t *x, int m)
+{+ jas_seq_t *z;
+ int i;
+
+ if (!(z = jas_seq_create(jas_seq_start(x) * m, (jas_seq_end(x) - 1) * m + 1)))
+ return 0;
+ for (i = jas_seq_start(z); i < jas_seq_end(z); i++) {+ *jas_seq_getref(z, i) = (!JAS_MOD(i, m)) ? jas_seq_get(x, i / m) :
+ jpc_inttofix(0);
+ }
+
+ return z;
+}
+
+jpc_fix_t jpc_seq_norm(const jas_seq_t *x)
+{+ jpc_fix_t s;
+ int i;
+
+ s = jpc_inttofix(0);
+ for (i = jas_seq_start(x); i < jas_seq_end(x); i++) {+ s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(x, i), jas_seq_get(x, i)));
+ }
+
+ return jpc_dbltofix(sqrt(jpc_fixtodbl(s)));
+}
+
+jas_seq_t *jpc_seq_conv(const jas_seq_t *x, const jas_seq_t *y)
+{+ int i;
+ int j;
+ int k;
+ jas_seq_t *z;
+ jpc_fix_t s;
+ jpc_fix_t v;
+
+ z = jas_seq_create(jas_seq_start(x) + jas_seq_start(y),
+ jas_seq_end(x) + jas_seq_end(y) - 1);
+ if (!z)
+ return NULL;
+ for (i = jas_seq_start(z); i < jas_seq_end(z); i++) {+ s = jpc_inttofix(0);
+ for (j = jas_seq_start(y); j < jas_seq_end(y); j++) {+ k = i - j;
+ if (k < jas_seq_start(x) || k >= jas_seq_end(x)) {+ v = JPC_FIX_ZERO;
+ } else {+ v = jas_seq_get(x, k);
+ }
+ s = jpc_fix_add(s, jpc_fix_mul(jas_seq_get(y, j), v));
+ }
+ *jas_seq_getref(z, i) = s;
+ }
+
+ return z;
+}
--- /dev/null
+++ b/jpc_util.h
@@ -1,0 +1,82 @@
+/*
+ * Copyright (c) 2001-2002 Michael David Adams.
+ * All rights reserved.
+ */
+
+/* __START_OF_JASPER_LICENSE__
+ *
+ * JasPer License Version 2.0
+ *
+ * Copyright (c) 2001-2006 Michael David Adams
+ * Copyright (c) 1999-2000 Image Power, Inc.
+ * Copyright (c) 1999-2000 The University of British Columbia
+ *
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person (the
+ * "User") obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ *
+ * 1. The above copyright notices and this permission notice (which
+ * includes the disclaimer below) shall be included in all copies or
+ * substantial portions of the Software.
+ *
+ * 2. The name of a copyright holder shall not be used to endorse or
+ * promote products derived from the Software without specific prior
+ * written permission.
+ *
+ * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ * LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+ * THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+ * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+ * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
+ * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
+ * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
+ * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
+ * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
+ * PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
+ * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
+ * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
+ * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
+ * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
+ * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
+ * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
+ * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
+ * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH+ * RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
+ * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
+ *
+ * __END_OF_JASPER_LICENSE__
+ */
+
+#ifndef JPC_UTIL_H
+#define JPC_UTIL_H
+
+#include "jpc_fix.h"
+
+#include "jasper/jas_seq.h"
+
+/* Parse a comma separated list of real numbers into an array of doubles. */
+int jpc_atoaf(const char *s, int *numvalues, double **values);
+
+/* Upsample a sequence. */
+jas_seq_t *jpc_seq_upsample(const jas_seq_t *seq, int n);
+
+/* Convolve two sequences. */
+jas_seq_t *jpc_seq_conv(const jas_seq_t *seq0, const jas_seq_t *seq1);
+
+/* Compute the norm of a sequence. */
+JAS_ATTRIBUTE_PURE
+jpc_fix_t jpc_seq_norm(const jas_seq_t *x);
+
+#endif
--- /dev/null
+++ b/mkfile
@@ -1,0 +1,18 @@
+</$objtype/mkfile
+
+BIN=/$objtype/bin
+TARG=jp2
+CFLAGS=$CFLAGS -p
+CLEANFILES=libjp29.a
+
+OFILES=\
+ jp2.$O\
+
+default:V: all
+
+</sys/src/cmd/mkone
+
+jp2.$O: libjp29.a
+
+libjp29.a:
+ mk -f mklib
--- /dev/null
+++ b/mklib
@@ -1,0 +1,36 @@
+</$objtype/mkfile
+LIB=libjp29.a
+CFLAGS=$CFLAGS -p
+
+OFILES=\
+ jas_cm.$O\
+ jas_debug.$O\
+ jas_icc.$O\
+ jas_iccdata.$O\
+ jas_image.$O\
+ jas_init.$O\
+ jas_malloc.$O\
+ jas_seq.$O\
+ jas_stream.$O\
+ jas_string.$O\
+ jp2_cod.$O\
+ jp2_dec.$O\
+ jpc_bs.$O\
+ jpc_cs.$O\
+ jpc_dec.$O\
+ jpc_math.$O\
+ jpc_mct.$O\
+ jpc_mqcod.$O\
+ jpc_mqdec.$O\
+ jpc_qmfb.$O\
+ jpc_t1cod.$O\
+ jpc_t1dec.$O\
+ jpc_t2cod.$O\
+ jpc_t2dec.$O\
+ jpc_tagtree.$O\
+ jpc_tsfb.$O\
+ jpc_util.$O\
+
+HFILES=\
+
+</sys/src/cmd/mklib