summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/jasper/src/libjasper/jpc/jpc_cs.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/jasper/src/libjasper/jpc/jpc_cs.c')
-rw-r--r--src/3rdparty/jasper/src/libjasper/jpc/jpc_cs.c1644
1 files changed, 0 insertions, 1644 deletions
diff --git a/src/3rdparty/jasper/src/libjasper/jpc/jpc_cs.c b/src/3rdparty/jasper/src/libjasper/jpc/jpc_cs.c
deleted file mode 100644
index f0f8e4d..0000000
--- a/src/3rdparty/jasper/src/libjasper/jpc/jpc_cs.c
+++ /dev/null
@@ -1,1644 +0,0 @@
-/*
- * 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 <stdlib.h>
-#include <assert.h>
-#include <ctype.h>
-
-#include "jasper/jas_malloc.h"
-#include "jasper/jas_debug.h"
-
-#include "jpc_cs.h"
-
-/******************************************************************************\
-* Types.
-\******************************************************************************/
-
-/* Marker segment table entry. */
-typedef struct {
- int id;
- char *name;
- jpc_msops_t ops;
-} jpc_mstabent_t;
-
-/******************************************************************************\
-* Local prototypes.
-\******************************************************************************/
-
-static 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 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", {0, jpc_unk_getparms, jpc_unk_putparms, 0}},
- {JPC_MS_PLM, "PLM", {0, 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", {0, 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;
- jpc_mstabent_t *mstabent;
- jas_stream_t *tmpstream;
-
- if (!(ms = jpc_ms_create(0))) {
- return 0;
- }
-
- /* Get the marker type. */
- if (jpc_getuint16(in, &ms->id) || ms->id < JPC_MS_MIN ||
- ms->id > JPC_MS_MAX) {
- jpc_ms_destroy(ms);
- return 0;
- }
-
- mstabent = jpc_mstab_lookup(ms->id);
- ms->ops = &mstabent->ops;
-
- /* Get the marker segment length and parameters if present. */
- /* Note: It is tacitly assumed that a marker segment cannot have
- parameters unless it has a length field. That is, there cannot
- be a parameters field without a length field and vice versa. */
- if (JPC_MS_HASPARMS(ms->id)) {
- /* Get the length of the marker segment. */
- if (jpc_getuint16(in, &ms->len) || ms->len < 3) {
- jpc_ms_destroy(ms);
- return 0;
- }
- /* Calculate the length of the marker segment parameters. */
- ms->len -= 2;
- /* Create and prepare a temporary memory stream from which to
- read the marker segment parameters. */
- /* Note: This approach provides a simple way of ensuring that
- we never read beyond the end of the marker segment (even if
- the marker segment length is errantly set too small). */
- if (!(tmpstream = jas_stream_memopen(0, 0))) {
- jpc_ms_destroy(ms);
- return 0;
- }
- if (jas_stream_copy(tmpstream, in, ms->len) ||
- jas_stream_seek(tmpstream, 0, SEEK_SET) < 0) {
- jas_stream_close(tmpstream);
- jpc_ms_destroy(ms);
- return 0;
- }
- /* Get the marker segment parameters. */
- if ((*ms->ops->getparms)(ms, cstate, tmpstream)) {
- ms->ops = 0;
- jpc_ms_destroy(ms);
- jas_stream_close(tmpstream);
- return 0;
- }
-
- if (jas_getdbglevel() > 0) {
- jpc_ms_dump(ms, stderr);
- }
-
- if (JAS_CAST(ulong, jas_stream_tell(tmpstream)) != ms->len) {
- jas_eprintf("warning: trailing garbage in marker segment (%ld bytes)\n",
- ms->len - jas_stream_tell(tmpstream));
- }
-
- /* Close the temporary stream. */
- jas_stream_close(tmpstream);
-
- } else {
- /* There are no marker segment parameters. */
- ms->len = 0;
-
- if (jas_getdbglevel() > 0) {
- jpc_ms_dump(ms, stderr);
- }
- }
-
- /* Update the code stream state information based on the type of
- marker segment read. */
- /* Note: This is a bit of a hack, but I'm not going to define another
- type of virtual function for this one special case. */
- if (ms->id == JPC_MS_SIZ) {
- cstate->numcomps = ms->parms.siz.numcomps;
- }
-
- return ms;
-}
-
-/* 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;
- 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)
-{
- jpc_mstabent_t *mstabent;
- mstabent = jpc_mstab_lookup(ms->id);
- fprintf(out, "type = 0x%04x (%s);", ms->id, mstabent->name);
- if (JPC_MS_HASPARMS(ms->id)) {
- fprintf(out, " len = %d;", 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. */
- cstate = 0;
-
- if (jpc_getuint16(in, &sot->tileno) ||
- jpc_getuint32(in, &sot->len) ||
- jpc_getuint8(in, &sot->partno) ||
- jpc_getuint8(in, &sot->numparts)) {
- 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. */
- cstate = 0;
-
- 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 = %d; len = %d; 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;
-
- /* Eliminate compiler warning about unused variables. */
- cstate = 0;
-
- 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)) {
- return -1;
- }
- if (!siz->width || !siz->height || !siz->tilewidth ||
- !siz->tileheight || !siz->numcomps) {
- return -1;
- }
- if (!(siz->comps = jas_malloc(siz->numcomps * sizeof(jpc_sizcomp_t)))) {
- return -1;
- }
- 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)) {
- jas_free(siz->comps);
- return -1;
- }
- siz->comps[i].sgnd = (tmp >> 7) & 1;
- siz->comps[i].prec = (tmp & 0x7f) + 1;
- }
- if (jas_stream_eof(in)) {
- jas_free(siz->comps);
- return -1;
- }
- return 0;
-}
-
-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. */
- cstate = 0;
-
- 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%02x;\n", siz->caps);
- fprintf(out, "width = %d; height = %d; xoff = %d; yoff = %d;\n",
- siz->width, siz->height, siz->xoff, siz->yoff);
- fprintf(out, "tilewidth = %d; tileheight = %d; tilexoff = %d; "
- "tileyoff = %d;\n", siz->tilewidth, siz->tileheight, siz->tilexoff,
- siz->tileyoff);
- 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 (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 = %d;\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 = %d; 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. */
- compparms = 0;
-}
-
-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. */
- ms = 0;
- cstate = 0;
-
- 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;
- }
- compparms->numrlvls = compparms->numdlvls + 1;
- if (prtflag) {
- for (i = 0; i < compparms->numrlvls; ++i) {
- if (jpc_getuint8(in, &tmp)) {
- jpc_cox_destroycompparms(compparms);
- return -1;
- }
- 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;
- } else {
- }
- if (jas_stream_eof(in)) {
- jpc_cox_destroycompparms(compparms);
- return -1;
- }
- return 0;
-}
-
-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. */
- ms = 0;
- cstate = 0;
-
- 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 = %d; 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, (unsigned) JPC_QCX_GETEXPN(qcd->compparms.stepsizes[i]),
- i, (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) {
- jpc_getuint8(in, &tmp);
- qcc->compno = tmp;
- --len;
- } else {
- jpc_getuint16(in, &qcc->compno);
- 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) {
- jpc_putuint8(out, qcc->compno);
- } else {
- jpc_putuint16(out, qcc->compno);
- }
- 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 = %d; 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. */
- cstate = 0;
-
- n = 0;
- jpc_getuint8(in, &tmp);
- ++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;
- }
- if (compparms->numstepsizes > 0) {
- compparms->stepsizes = jas_malloc(compparms->numstepsizes *
- sizeof(uint_fast16_t));
- assert(compparms->stepsizes);
- for (i = 0; i < compparms->numstepsizes; ++i) {
- if (compparms->qntsty == JPC_QCX_NOQNT) {
- jpc_getuint8(in, &tmp);
- compparms->stepsizes[i] = JPC_QCX_EXPN(tmp >> 3);
- } else {
- jpc_getuint16(in, &compparms->stepsizes[i]);
- }
- }
- } 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. */
- cstate = 0;
-
- jpc_putuint8(out, ((compparms->numguard & 7) << 5) | compparms->qntsty);
- for (i = 0; i < compparms->numstepsizes; ++i) {
- if (compparms->qntsty == JPC_QCX_NOQNT) {
- jpc_putuint8(out, JPC_QCX_GETEXPN(
- compparms->stepsizes[i]) << 3);
- } else {
- jpc_putuint16(out, compparms->stepsizes[i]);
- }
- }
- 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. */
- cstate = 0;
-
- 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. */
- cstate = 0;
-
- 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 = %d;\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. */
- cstate = 0;
-
- 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 * sizeof(unsigned char)))) {
- goto error;
- }
- if (JAS_CAST(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. */
- cstate = 0;
-
- if (JAS_CAST(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 = %d;\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. */
- cstate = 0;
-
- 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 * sizeof(unsigned char)))) {
- goto error;
- }
- if (jas_stream_read(in, (char *) ppt->data, ppt->len) != JAS_CAST(int, 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. */
- cstate = 0;
-
- if (jpc_putuint8(out, ppt->ind)) {
- return -1;
- }
- if (jas_stream_write(out, (char *) ppt->data, ppt->len) != JAS_CAST(int, 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 = %d;\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_malloc(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] = %d; ce[%d] = %d; ",
- pchgno, pchg->compnostart, pchgno, pchg->compnoend);
- fprintf(out, "rs[%d] = %d; re[%d] = %d; ",
- pchgno, pchg->rlvlnostart, pchgno, pchg->rlvlnoend);
- fprintf(out, "le[%d] = %d\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_malloc(cstate->numcomps * sizeof(uint_fast16_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. */
- cstate = 0;
-
- 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] = %d; voff[%d] = %d\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. */
- cstate = 0;
-
- 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) != JAS_CAST(int, 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. */
- cstate = 0;
-
- if (jpc_putuint16(out, com->regid)) {
- return -1;
- }
- if (jas_stream_write(out, com->data, com->len) != JAS_CAST(int, 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 = %d;\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;
-
- /* Eliminate compiler warning about unused variables. */
- cstate = 0;
-
- if (ms->len > 0) {
- if (!(unk->data = jas_malloc(ms->len * sizeof(unsigned char)))) {
- return -1;
- }
- if (jas_stream_read(in, (char *) unk->data, ms->len) != JAS_CAST(int, 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. */
- cstate = 0;
- ms = 0;
- out = 0;
-
- /* 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)
-{
- uint_fast16_t v;
- int c;
- if ((c = jas_stream_getc(in)) == EOF) {
- return -1;
- }
- v = c;
- if ((c = jas_stream_getc(in)) == EOF) {
- return -1;
- }
- v = (v << 8) | c;
- if (val) {
- *val = v;
- }
- 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)
-{
- uint_fast32_t v;
- int c;
- if ((c = jas_stream_getc(in)) == EOF) {
- return -1;
- }
- v = c;
- if ((c = jas_stream_getc(in)) == EOF) {
- return -1;
- }
- v = (v << 8) | c;
- if ((c = jas_stream_getc(in)) == EOF) {
- return -1;
- }
- v = (v << 8) | c;
- if ((c = jas_stream_getc(in)) == EOF) {
- return -1;
- }
- v = (v << 8) | c;
- if (val) {
- *val = v;
- }
- 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 jpc_mstabent_t *jpc_mstab_lookup(int id)
-{
- jpc_mstabent_t *mstabent;
- for (mstabent = jpc_mstab;; ++mstabent) {
- if (mstabent->id == id || mstabent->id < 0) {
- return mstabent;
- }
- }
- assert(0);
- return 0;
-}
-
-int jpc_validate(jas_stream_t *in)
-{
- int n;
- int i;
- unsigned char buf[2];
-
- assert(JAS_STREAM_MAXPUTBACK >= 2);
-
- if ((n = jas_stream_read(in, (char *) buf, 2)) < 0) {
- return -1;
- }
- for (i = n - 1; i >= 0; --i) {
- if (jas_stream_ungetc(in, buf[i]) == EOF) {
- return -1;
- }
- }
- if (n < 2) {
- 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);
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-09 09:31:40 +0000