/* * 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 <stdlib.h>#include <stdio.h>#include <string.h>#include <assert.h>#include <ctype.h>#include "jasper/jas_math.h"#include "jasper/jas_image.h"#include "jasper/jas_malloc.h"#include "jasper/jas_string.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(uint_fast32_t tlx, uint_fast32_t tly,  uint_fast32_t hstep, uint_fast32_t vstep, uint_fast32_t width, uint_fast32_t  height, uint_fast16_t depth, bool sgnd, uint_fast32_t 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, int maxcmpts);static uint_fast32_t inttobits(jas_seqent_t v, int prec, bool sgnd);static jas_seqent_t bitstoint(uint_fast32_t v, int prec, bool sgnd);static int putint(jas_stream_t *out, int sgnd, int prec, long val);static int getint(jas_stream_t *in, int sgnd, int prec, long *val);static void jas_image_calcbbox2(jas_image_t *image, jas_image_coord_t *tlx,  jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry);static long uptomult(long x, long y);static long downtomult(long x, long y);static long convert(long val, int oldsgnd, int oldprec, int newsgnd,  int newprec);static void jas_image_calcbbox2(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 int 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(int numcmpts, jas_image_cmptparm_t *cmptparms,  int clrspc){	jas_image_t *image;	uint_fast32_t rawsize;	uint_fast32_t inmem;	int cmptno;	jas_image_cmptparm_t *cmptparm;	if (!(image = jas_image_create0())) {		return 0;	}	image->clrspc_ = clrspc;	image->maxcmpts_ = numcmpts;	image->inmem_ = true;	/* Allocate memory for the per-component information. */	if (!(image->cmpts_ = jas_malloc(image->maxcmpts_ *	  sizeof(jas_image_cmpt_t *)))) {		jas_image_destroy(image);		return 0;	}	/* Initialize in case of failure. */	for (cmptno = 0; cmptno < image->maxcmpts_; ++cmptno) {		image->cmpts_[cmptno] = 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);	/* Create the individual image components. */	for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno,	  ++cmptparm) {		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))) {			jas_image_destroy(image);			return 0;		}		++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;}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;	int cmptno;	newimage = jas_image_create0();	if (jas_image_growcmpts(newimage, image->numcmpts_)) {		goto error;	}	for (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))) {		return 0;	}	if (jas_stream_seek(cmpt->stream_, 0, SEEK_SET)) {		return 0;	}	if (jas_stream_copy(newcmpt->stream_, cmpt->stream_, -1)) {		return 0;	}	if (jas_stream_seek(newcmpt->stream_, 0, SEEK_SET)) {		return 0;	}	return newcmpt;}void jas_image_destroy(jas_image_t *image){	int i;	if (image->cmpts_) {		for (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(uint_fast32_t tlx, uint_fast32_t tly,  uint_fast32_t hstep, uint_fast32_t vstep, uint_fast32_t width, uint_fast32_t  height, uint_fast16_t depth, bool sgnd, uint_fast32_t inmem){	jas_image_cmpt_t *cmpt;	long size;	if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) {		return 0;	}	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;	size = cmpt->width_ * cmpt->height_ * cmpt->cps_;	cmpt->stream_ = (inmem) ? jas_stream_memopen(0, size) : jas_stream_tmpfile();	if (!cmpt->stream_) {		jas_image_cmpt_destroy(cmpt);		return 0;	}	/* Zero the component data.  This isn't necessary, but it is	convenient for debugging purposes. */	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) {		jas_image_cmpt_destroy(cmpt);		return 0;	}	return cmpt;}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, char *optstr){	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)			goto error;	}	/* Is it possible to decode an image represented in this format? */	if (!(fmtinfo = jas_image_lookupfmtbyid(fmt)))		goto error;	if (!fmtinfo->ops.decode)		goto error;	/* Decode the image. */	if (!(image = (*fmtinfo->ops.decode)(in, optstr)))		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))))			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, char *optstr){	jas_image_fmtinfo_t *fmtinfo;	if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) {		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, int 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;	int k;	jas_seqent_t v;	int c;	jas_seqent_t *dr;	jas_seqent_t *d;	int drs;	if (cmptno < 0 || 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) != height || jas_matrix_numcols(data) != width) {		if (jas_matrix_resize(data, height, width)) {			return -1;		}	}	dr = jas_matrix_getref(data, 0, 0);	drs = jas_matrix_rowstep(data);	for (i = 0; i < height; ++i, dr += drs) {		d = dr;		if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)		  * cmpt->cps_, SEEK_SET) < 0) {			return -1;		}		for (j = width; j > 0; --j, ++d) {			v = 0;			for (k = cmpt->cps_; k > 0; --k) {				if ((c = jas_stream_getc(cmpt->stream_)) == EOF) {					return -1;				}				v = (v << 8) | (c & 0xff);			}			*d = bitstoint(v, cmpt->prec_, cmpt->sgnd_);		}	}	return 0;}int jas_image_writecmpt(jas_image_t *image, int 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 *d;	jas_seqent_t *dr;	int drs;	jas_seqent_t v;	int k;	int c;	if (cmptno < 0 || 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) != height || jas_matrix_numcols(data) != width) {