src/gdcmjasper/src/libjasper/base/jas_image.c

   1 /*
   2  * Copyright (c) 1999-2000 Image Power, Inc. and the University of
   3  *   British Columbia.
   4  * Copyright (c) 2001-2003 Michael David Adams.
   5  * All rights reserved.
   6  */
   7
   8 /* __START_OF_JASPER_LICENSE__
   9  *
  10  * JasPer License Version 2.0
  11  *
  12  * Copyright (c) 1999-2000 Image Power, Inc.
  13  * Copyright (c) 1999-2000 The University of British Columbia
  14  * Copyright (c) 2001-2003 Michael David Adams
  15  *
  16  * All rights reserved.
  17  *
  18  * Permission is hereby granted, free of charge, to any person (the
  19  * "User") obtaining a copy of this software and associated documentation
  20  * files (the "Software"), to deal in the Software without restriction,
  21  * including without limitation the rights to use, copy, modify, merge,
  22  * publish, distribute, and/or sell copies of the Software, and to permit
  23  * persons to whom the Software is furnished to do so, subject to the
  24  * following conditions:
  25  *
  26  * 1.  The above copyright notices and this permission notice (which
  27  * includes the disclaimer below) shall be included in all copies or
  28  * substantial portions of the Software.
  29  *
  30  * 2.  The name of a copyright holder shall not be used to endorse or
  31  * promote products derived from the Software without specific prior
  32  * written permission.
  33  *
  34  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  35  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  36  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
  37  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  38  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  39  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
  40  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
  41  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
  42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
  45  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
  46  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
  47  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
  48  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
  49  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
  50  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
  51  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
  52  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
  53  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
  54  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
  55  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
  56  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
  57  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  58  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  59  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
  60  *
  61  * __END_OF_JASPER_LICENSE__
  62  */
  63
  64 /*
  65  * Image Library
  66  *
  67  * $Id: jas_image.c,v 1.1 2005/05/22 18:32:59 malaterre Exp $
  68  */
  69
  70 /******************************************************************************\
  71 * Includes.
  72 \******************************************************************************/
  73
  74 #include <stdlib.h>
  75 #include <stdio.h>
  76 #include <string.h>
  77 #include <assert.h>
  78 #include <ctype.h>
  79
  80 #include "jasper/jas_math.h"
  81 #include "jasper/jas_image.h"
  82 #include "jasper/jas_malloc.h"
  83 #include "jasper/jas_string.h"
  84
  85 /******************************************************************************\
  86 * Types.
  87 \******************************************************************************/
  88
  89 #define  FLOORDIV(x, y) ((x) / (y))
  90
  91 /******************************************************************************\
  92 * Local prototypes.
  93 \******************************************************************************/
  94
  95 static jas_image_cmpt_t *jas_image_cmpt_create0(void);
  96 static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt);
  97 static jas_image_cmpt_t *jas_image_cmpt_create(uint_fast32_t tlx, uint_fast32_t tly,
  98   uint_fast32_t hstep, uint_fast32_t vstep, uint_fast32_t width, uint_fast32_t
  99   height, uint_fast16_t depth, bool sgnd, uint_fast32_t inmem);
 100 static void jas_image_setbbox(jas_image_t *image);
 101 static jas_image_cmpt_t *jas_image_cmpt_copy(jas_image_cmpt_t *cmpt);
 102 static int jas_image_growcmpts(jas_image_t *image, int maxcmpts);
 103 static uint_fast32_t inttobits(jas_seqent_t v, int prec, bool sgnd);
 104 static jas_seqent_t bitstoint(uint_fast32_t v, int prec, bool sgnd);
 105 static int putint(jas_stream_t *out, int sgnd, int prec, long val);
 106 static int getint(jas_stream_t *in, int sgnd, int prec, long *val);
 107 static void jas_image_calcbbox2(jas_image_t *image, jas_image_coord_t *tlx,
 108   jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry);
 109 static long uptomult(long x, long y);
 110 static long downtomult(long x, long y);
 111 static long convert(long val, int oldsgnd, int oldprec, int newsgnd,
 112   int newprec);
 113 static void jas_image_calcbbox2(jas_image_t *image, jas_image_coord_t *tlx,
 114   jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry);
 115
 116 /******************************************************************************\
 117 * Global data.
 118 \******************************************************************************/
 119
 120 static int jas_image_numfmts = 0;
 121 static jas_image_fmtinfo_t jas_image_fmtinfos[JAS_IMAGE_MAXFMTS];
 122
 123 /******************************************************************************\
 124 * Create and destroy operations.
 125 \******************************************************************************/
 126
 127 jas_image_t *jas_image_create(int numcmpts, jas_image_cmptparm_t *cmptparms,
 128   int clrspc)
 129 {
 130   jas_image_t *image;
 131   uint_fast32_t rawsize;
 132   uint_fast32_t inmem;
 133   int cmptno;
 134   jas_image_cmptparm_t *cmptparm;
 135
 136   if (!(image = jas_image_create0())) {
 137     return 0;
 138   }
 139
 140   image->clrspc_ = clrspc;
 141   image->maxcmpts_ = numcmpts;
 142   image->inmem_ = true;
 143
 144   /* Allocate memory for the per-component information. */
 145   if (!(image->cmpts_ = jas_malloc(image->maxcmpts_ *
 146     sizeof(jas_image_cmpt_t *)))) {
 147     jas_image_destroy(image);
 148     return 0;
 149   }
 150   /* Initialize in case of failure. */
 151   for (cmptno = 0; cmptno < image->maxcmpts_; ++cmptno) {
 152     image->cmpts_[cmptno] = 0;
 153   }
 154
 155   /* Compute the approximate raw size of the image. */
 156   rawsize = 0;
 157   for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno,
 158     ++cmptparm) {
 159     rawsize += cmptparm->width * cmptparm->height *
 160       (cmptparm->prec + 7) / 8;
 161   }
 162   /* Decide whether to buffer the image data in memory, based on the
 163     raw size of the image. */
 164   inmem = (rawsize < JAS_IMAGE_INMEMTHRESH);
 165
 166   /* Create the individual image components. */
 167   for (cmptno = 0, cmptparm = cmptparms; cmptno < numcmpts; ++cmptno,
 168     ++cmptparm) {
 169     if (!(image->cmpts_[cmptno] = jas_image_cmpt_create(cmptparm->tlx,
 170       cmptparm->tly, cmptparm->hstep, cmptparm->vstep,
 171       cmptparm->width, cmptparm->height, cmptparm->prec,
 172       cmptparm->sgnd, inmem))) {
 173       jas_image_destroy(image);
 174       return 0;
 175     }
 176     ++image->numcmpts_;
 177   }
 178
 179   /* Determine the bounding box for all of the components on the
 180     reference grid (i.e., the image area) */
 181   jas_image_setbbox(image);
 182
 183   return image;
 184 }
 185
 186 jas_image_t *jas_image_create0()
 187 {
 188   jas_image_t *image;
 189
 190   if (!(image = jas_malloc(sizeof(jas_image_t)))) {
 191     return 0;
 192   }
 193
 194   image->tlx_ = 0;
 195   image->tly_ = 0;
 196   image->brx_ = 0;
 197   image->bry_ = 0;
 198   image->clrspc_ = JAS_CLRSPC_UNKNOWN;
 199   image->numcmpts_ = 0;
 200   image->maxcmpts_ = 0;
 201   image->cmpts_ = 0;
 202   image->inmem_ = true;
 203   image->cmprof_ = 0;
 204
 205   return image;
 206 }
 207
 208 jas_image_t *jas_image_copy(jas_image_t *image)
 209 {
 210   jas_image_t *newimage;
 211   int cmptno;
 212
 213   newimage = jas_image_create0();
 214   if (jas_image_growcmpts(newimage, image->numcmpts_)) {
 215     goto error;
 216   }
 217   for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
 218     if (!(newimage->cmpts_[cmptno] = jas_image_cmpt_copy(image->cmpts_[cmptno]))) {
 219       goto error;
 220     }
 221     ++newimage->numcmpts_;
 222   }
 223
 224   jas_image_setbbox(newimage);
 225
 226   if (image->cmprof_) {
 227     if (!(newimage->cmprof_ = jas_cmprof_copy(image->cmprof_)))
 228       goto error;
 229   }
 230
 231   return newimage;
 232 error:
 233   if (newimage) {
 234     jas_image_destroy(newimage);
 235   }
 236   return 0;
 237 }
 238
 239 static jas_image_cmpt_t *jas_image_cmpt_create0()
 240 {
 241   jas_image_cmpt_t *cmpt;
 242   if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) {
 243     return 0;
 244   }
 245   memset(cmpt, 0, sizeof(jas_image_cmpt_t));
 246   cmpt->type_ = JAS_IMAGE_CT_UNKNOWN;
 247   return cmpt;
 248 }
 249
 250 static jas_image_cmpt_t *jas_image_cmpt_copy(jas_image_cmpt_t *cmpt)
 251 {
 252   jas_image_cmpt_t *newcmpt;
 253
 254   if (!(newcmpt = jas_image_cmpt_create0())) {
 255     return 0;
 256   }
 257   newcmpt->tlx_ = cmpt->tlx_;
 258   newcmpt->tly_ = cmpt->tly_;
 259   newcmpt->hstep_ = cmpt->hstep_;
 260   newcmpt->vstep_ = cmpt->vstep_;
 261   newcmpt->width_ = cmpt->width_;
 262   newcmpt->height_ = cmpt->height_;
 263   newcmpt->prec_ = cmpt->prec_;
 264   newcmpt->sgnd_ = cmpt->sgnd_;
 265   newcmpt->cps_ = cmpt->cps_;
 266   newcmpt->type_ = cmpt->type_;
 267   if (!(newcmpt->stream_ = jas_stream_memopen(0, 0))) {
 268     return 0;
 269   }
 270   if (jas_stream_seek(cmpt->stream_, 0, SEEK_SET)) {
 271     return 0;
 272   }
 273   if (jas_stream_copy(newcmpt->stream_, cmpt->stream_, -1)) {
 274     return 0;
 275   }
 276   if (jas_stream_seek(newcmpt->stream_, 0, SEEK_SET)) {
 277     return 0;
 278   }
 279   return newcmpt;
 280 }
 281
 282 void jas_image_destroy(jas_image_t *image)
 283 {
 284   int i;
 285
 286   if (image->cmpts_) {
 287     for (i = 0; i < image->numcmpts_; ++i) {
 288       jas_image_cmpt_destroy(image->cmpts_[i]);
 289       image->cmpts_[i] = 0;
 290     }
 291     jas_free(image->cmpts_);
 292   }
 293   if (image->cmprof_)
 294     jas_cmprof_destroy(image->cmprof_);
 295   jas_free(image);
 296 }
 297
 298 static jas_image_cmpt_t *jas_image_cmpt_create(uint_fast32_t tlx, uint_fast32_t tly,
 299   uint_fast32_t hstep, uint_fast32_t vstep, uint_fast32_t width, uint_fast32_t
 300   height, uint_fast16_t depth, bool sgnd, uint_fast32_t inmem)
 301 {
 302   jas_image_cmpt_t *cmpt;
 303   long size;
 304
 305   if (!(cmpt = jas_malloc(sizeof(jas_image_cmpt_t)))) {
 306     return 0;
 307   }
 308
 309   cmpt->tlx_ = tlx;
 310   cmpt->tly_ = tly;
 311   cmpt->hstep_ = hstep;
 312   cmpt->vstep_ = vstep;
 313   cmpt->width_ = width;
 314   cmpt->height_ = height;
 315   cmpt->prec_ = depth;
 316   cmpt->sgnd_ = sgnd;
 317   cmpt->stream_ = 0;
 318   cmpt->cps_ = (depth + 7) / 8;
 319
 320   size = cmpt->width_ * cmpt->height_ * cmpt->cps_;
 321   cmpt->stream_ = (inmem) ? jas_stream_memopen(0, size) : jas_stream_tmpfile();
 322   if (!cmpt->stream_) {
 323     jas_image_cmpt_destroy(cmpt);
 324     return 0;
 325   }
 326
 327   /* Zero the component data.  This isn't necessary, but it is
 328   convenient for debugging purposes. */
 329   if (jas_stream_seek(cmpt->stream_, size - 1, SEEK_SET) < 0 ||
 330     jas_stream_putc(cmpt->stream_, 0) == EOF ||
 331     jas_stream_seek(cmpt->stream_, 0, SEEK_SET) < 0) {
 332     jas_image_cmpt_destroy(cmpt);
 333     return 0;
 334   }
 335
 336   return cmpt;
 337 }
 338
 339 static void jas_image_cmpt_destroy(jas_image_cmpt_t *cmpt)
 340 {
 341   if (cmpt->stream_) {
 342     jas_stream_close(cmpt->stream_);
 343   }
 344   jas_free(cmpt);
 345 }
 346
 347 /******************************************************************************\
 348 * Load and save operations.
 349 \******************************************************************************/
 350
 351 jas_image_t *jas_image_decode(jas_stream_t *in, int fmt, char *optstr)
 352 {
 353   jas_image_fmtinfo_t *fmtinfo;
 354   jas_image_t *image;
 355
 356   image = 0;
 357
 358   /* If possible, try to determine the format of the input data. */
 359   if (fmt < 0) {
 360     if ((fmt = jas_image_getfmt(in)) < 0)
 361       goto error;
 362   }
 363
 364   /* Is it possible to decode an image represented in this format? */
 365   if (!(fmtinfo = jas_image_lookupfmtbyid(fmt)))
 366     goto error;
 367   if (!fmtinfo->ops.decode)
 368     goto error;
 369
 370   /* Decode the image. */
 371   if (!(image = (*fmtinfo->ops.decode)(in, optstr)))
 372     goto error;
 373
 374   /* Create a color profile if needed. */
 375   if (!jas_clrspc_isunknown(image->clrspc_) &&
 376     !jas_clrspc_isgeneric(image->clrspc_) && !image->cmprof_) {
 377     if (!(image->cmprof_ =
 378       jas_cmprof_createfromclrspc(jas_image_clrspc(image))))
 379       goto error;
 380   }
 381
 382   return image;
 383 error:
 384   if (image)
 385     jas_image_destroy(image);
 386   return 0;
 387 }
 388
 389 int jas_image_encode(jas_image_t *image, jas_stream_t *out, int fmt, char *optstr)
 390 {
 391   jas_image_fmtinfo_t *fmtinfo;
 392   if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) {
 393     return -1;
 394   }
 395   return (fmtinfo->ops.encode) ? (*fmtinfo->ops.encode)(image, out,
 396     optstr) : (-1);
 397 }
 398
 399 /******************************************************************************\
 400 * Component read and write operations.
 401 \******************************************************************************/
 402
 403 int jas_image_readcmpt(jas_image_t *image, int cmptno, jas_image_coord_t x,
 404   jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
 405   jas_matrix_t *data)
 406 {
 407   jas_image_cmpt_t *cmpt;
 408   jas_image_coord_t i;
 409   jas_image_coord_t j;
 410   int k;
 411   jas_seqent_t v;
 412   int c;
 413   jas_seqent_t *dr;
 414   jas_seqent_t *d;
 415   int drs;
 416
 417   if (cmptno < 0 || cmptno >= image->numcmpts_) {
 418     return -1;
 419   }
 420
 421   cmpt = image->cmpts_[cmptno];
 422   if (x >= cmpt->width_ || y >= cmpt->height_ ||
 423     x + width > cmpt->width_ ||
 424     y + height > cmpt->height_) {
 425     return -1;
 426   }
 427
 428   if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) {
 429     if (jas_matrix_resize(data, height, width)) {
 430       return -1;
 431     }
 432   }
 433
 434   dr = jas_matrix_getref(data, 0, 0);
 435   drs = jas_matrix_rowstep(data);
 436   for (i = 0; i < height; ++i, dr += drs) {
 437     d = dr;
 438     if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
 439       * cmpt->cps_, SEEK_SET) < 0) {
 440       return -1;
 441     }
 442     for (j = width; j > 0; --j, ++d) {
 443       v = 0;
 444       for (k = cmpt->cps_; k > 0; --k) {
 445         if ((c = jas_stream_getc(cmpt->stream_)) == EOF) {
 446           return -1;
 447         }
 448         v = (v << 8) | (c & 0xff);
 449       }
 450       *d = bitstoint(v, cmpt->prec_, cmpt->sgnd_);
 451     }
 452   }
 453
 454   return 0;
 455 }
 456
 457 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,
 458   jas_image_coord_t height, jas_matrix_t *data)
 459 {
 460   jas_image_cmpt_t *cmpt;
 461   jas_image_coord_t i;
 462   jas_image_coord_t j;
 463   jas_seqent_t *d;
 464   jas_seqent_t *dr;
 465   int drs;
 466   jas_seqent_t v;
 467   int k;
 468   int c;
 469
 470   if (cmptno < 0 || cmptno >= image->numcmpts_) {
 471     return -1;
 472   }
 473
 474   cmpt = image->cmpts_[cmptno];
 475   if (x >= cmpt->width_ || y >= cmpt->height_ ||
 476     x + width > cmpt->width_ ||
 477     y + height > cmpt->height_) {
 478     return -1;
 479   }
 480
 481   if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) {
 482     return -1;
 483   }
 484
 485   dr = jas_matrix_getref(data, 0, 0);
 486   drs = jas_matrix_rowstep(data);
 487   for (i = 0; i < height; ++i, dr += drs) {
 488     d = dr;
 489     if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
 490       * cmpt->cps_, SEEK_SET) < 0) {
 491       return -1;
 492     }
 493     for (j = width; j > 0; --j, ++d) {
 494       v = inttobits(*d, cmpt->prec_, cmpt->sgnd_);
 495       for (k = cmpt->cps_; k > 0; --k) {
 496         c = (v >> (8 * (cmpt->cps_ - 1))) & 0xff;
 497         if (jas_stream_putc(cmpt->stream_,
 498           (unsigned char) c) == EOF) {
 499           return -1;
 500         }
 501         v <<= 8;
 502       }
 503     }
 504   }
 505
 506   return 0;
 507 }
 508
 509 /******************************************************************************\
 510 * File format operations.
 511 \******************************************************************************/
 512
 513 void jas_image_clearfmts()
 514 {
 515   int i;
 516   jas_image_fmtinfo_t *fmtinfo;
 517   for (i = 0; i < jas_image_numfmts; ++i) {
 518     fmtinfo = &jas_image_fmtinfos[i];
 519     if (fmtinfo->name) {
 520       jas_free(fmtinfo->name);
 521       fmtinfo->name = 0;
 522     }
 523     if (fmtinfo->ext) {
 524       jas_free(fmtinfo->ext);
 525       fmtinfo->ext = 0;
 526     }
 527     if (fmtinfo->desc) {
 528       jas_free(fmtinfo->desc);
 529       fmtinfo->desc = 0;
 530     }
 531   }
 532   jas_image_numfmts = 0;
 533 }
 534
 535 int jas_image_addfmt(int id, char *name, char *ext, char *desc,
 536   jas_image_fmtops_t *ops)
 537 {
 538   jas_image_fmtinfo_t *fmtinfo;
 539   assert(id >= 0 && name && ext && ops);
 540   if (jas_image_numfmts >= JAS_IMAGE_MAXFMTS) {
 541     return -1;
 542   }
 543   fmtinfo = &jas_image_fmtinfos[jas_image_numfmts];
 544   fmtinfo->id = id;
 545   if (!(fmtinfo->name = jas_strdup(name))) {
 546     return -1;
 547   }
 548   if (!(fmtinfo->ext = jas_strdup(ext))) {
 549     jas_free(fmtinfo->name);
 550     return -1;
 551   }
 552   if (!(fmtinfo->desc = jas_strdup(desc))) {
 553     jas_free(fmtinfo->name);
 554     jas_free(fmtinfo->ext);
 555     return -1;
 556   }
 557   fmtinfo->ops = *ops;
 558   ++jas_image_numfmts;
 559   return 0;
 560 }
 561
 562 int jas_image_strtofmt(char *name)
 563 {
 564   jas_image_fmtinfo_t *fmtinfo;
 565   if (!(fmtinfo = jas_image_lookupfmtbyname(name))) {
 566     return -1;
 567   }
 568   return fmtinfo->id;
 569 }
 570
 571 char *jas_image_fmttostr(int fmt)
 572 {
 573   jas_image_fmtinfo_t *fmtinfo;
 574   if (!(fmtinfo = jas_image_lookupfmtbyid(fmt))) {
 575     return 0;
 576   }
 577   return fmtinfo->name;
 578 }
 579
 580 int jas_image_getfmt(jas_stream_t *in)
 581 {
 582   jas_image_fmtinfo_t *fmtinfo;
 583   int found;
 584   int i;
 585
 586   /* Check for data in each of the supported formats. */
 587   found = 0;
 588   for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i,
 589     ++fmtinfo) {
 590     if (fmtinfo->ops.validate) {
 591       /* Is the input data valid for this format? */
 592       if (!(*fmtinfo->ops.validate)(in)) {
 593         found = 1;
 594         break;
 595       }
 596     }
 597   }
 598   return found ? fmtinfo->id : (-1);
 599 }
 600
 601 int jas_image_fmtfromname(char *name)
 602 {
 603   int i;
 604   char *ext;
 605   jas_image_fmtinfo_t *fmtinfo;
 606   /* Get the file name extension. */
 607   if (!(ext = strrchr(name, '.'))) {
 608     return -1;
 609   }
 610   ++ext;
 611   /* Try to find a format that uses this extension. */
 612   for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i,
 613     ++fmtinfo) {
 614     /* Do we have a match? */
 615     if (!strcmp(ext, fmtinfo->ext)) {
 616       return fmtinfo->id;
 617     }
 618   }
 619   return -1;
 620 }
 621
 622 /******************************************************************************\
 623 * Miscellaneous operations.
 624 \******************************************************************************/
 625
 626 uint_fast32_t jas_image_rawsize(jas_image_t *image)
 627 {
 628   uint_fast32_t rawsize;
 629   int cmptno;
 630   jas_image_cmpt_t *cmpt;
 631
 632   rawsize = 0;
 633   for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
 634     cmpt = image->cmpts_[cmptno];
 635     rawsize += (cmpt->width_ * cmpt->height_ * cmpt->prec_ +
 636       7) / 8;
 637   }
 638   return rawsize;
 639 }
 640
 641 void jas_image_delcmpt(jas_image_t *image, int cmptno)
 642 {
 643   if (cmptno >= image->numcmpts_) {
 644     return;
 645   }
 646   jas_image_cmpt_destroy(image->cmpts_[cmptno]);
 647   if (cmptno < image->numcmpts_) {
 648     memmove(&image->cmpts_[cmptno], &image->cmpts_[cmptno + 1],
 649       (image->numcmpts_ - 1 - cmptno) * sizeof(jas_image_cmpt_t *));
 650   }
 651   --image->numcmpts_;
 652
 653   jas_image_setbbox(image);
 654 }
 655
 656 int jas_image_addcmpt(jas_image_t *image, int cmptno,
 657   jas_image_cmptparm_t *cmptparm)
 658 {
 659   jas_image_cmpt_t *newcmpt;
 660   if (cmptno < 0)
 661     cmptno = image->numcmpts_;
 662   assert(cmptno >= 0 && cmptno <= image->numcmpts_);
 663   if (image->numcmpts_ >= image->maxcmpts_) {
 664     if (jas_image_growcmpts(image, image->maxcmpts_ + 128)) {
 665       return -1;
 666     }
 667   }
 668   if (!(newcmpt = jas_image_cmpt_create(cmptparm->tlx,
 669     cmptparm->tly, cmptparm->hstep, cmptparm->vstep,
 670     cmptparm->width, cmptparm->height, cmptparm->prec,
 671     cmptparm->sgnd, 1))) {
 672     return -1;
 673   }
 674   if (cmptno < image->numcmpts_) {
 675     memmove(&image->cmpts_[cmptno + 1], &image->cmpts_[cmptno],
 676       (image->numcmpts_ - cmptno) * sizeof(jas_image_cmpt_t *));
 677   }
 678   image->cmpts_[cmptno] = newcmpt;
 679   ++image->numcmpts_;
 680
 681   jas_image_setbbox(image);
 682
 683   return 0;
 684 }
 685
 686 jas_image_fmtinfo_t *jas_image_lookupfmtbyid(int id)
 687 {
 688   int i;
 689   jas_image_fmtinfo_t *fmtinfo;
 690
 691   for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) {
 692     if (fmtinfo->id == id) {
 693       return fmtinfo;
 694     }
 695   }
 696   return 0;
 697 }
 698
 699 jas_image_fmtinfo_t *jas_image_lookupfmtbyname(const char *name)
 700 {
 701   int i;
 702   jas_image_fmtinfo_t *fmtinfo;
 703
 704   for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i, ++fmtinfo) {
 705     if (!strcmp(fmtinfo->name, name)) {
 706       return fmtinfo;
 707     }
 708   }
 709   return 0;
 710 }
 711
 712
 713
 714
 715
 716 static uint_fast32_t inttobits(jas_seqent_t v, int prec, bool sgnd)
 717 {
 718   uint_fast32_t ret;
 719   ret = ((sgnd && v < 0) ? ((1 << prec) + v) : v) & JAS_ONES(prec);
 720   return ret;
 721 }
 722
 723 static jas_seqent_t bitstoint(uint_fast32_t v, int prec, bool sgnd)
 724 {
 725   jas_seqent_t ret;
 726   v &= JAS_ONES(prec);
 727   ret = (sgnd && (v & (1 << (prec - 1)))) ? (v - (1 << prec)) : v;
 728   return ret;
 729 }
 730
 731 static void jas_image_setbbox(jas_image_t *image)
 732 {
 733   jas_image_cmpt_t *cmpt;
 734   int cmptno;
 735   int_fast32_t x;
 736   int_fast32_t y;
 737
 738   if (image->numcmpts_ > 0) {
 739     /* Determine the bounding box for all of the components on the
 740       reference grid (i.e., the image area) */
 741     cmpt = image->cmpts_[0];
 742     image->tlx_ = cmpt->tlx_;
 743     image->tly_ = cmpt->tly_;
 744     image->brx_ = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1;
 745     image->bry_ = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1;
 746     for (cmptno = 1; cmptno < image->numcmpts_; ++cmptno) {
 747       cmpt = image->cmpts_[cmptno];
 748       if (image->tlx_ > cmpt->tlx_) {
 749         image->tlx_ = cmpt->tlx_;
 750       }
 751       if (image->tly_ > cmpt->tly_) {
 752         image->tly_ = cmpt->tly_;
 753       }
 754       x = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1) + 1;
 755       if (image->brx_ < x) {
 756         image->brx_ = x;
 757       }
 758       y = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1) + 1;
 759       if (image->bry_ < y) {
 760         image->bry_ = y;
 761       }
 762     }
 763   } else {
 764     image->tlx_ = 0;
 765     image->tly_ = 0;
 766     image->brx_ = 0;
 767     image->bry_ = 0;
 768   }
 769 }
 770
 771 static int jas_image_growcmpts(jas_image_t *image, int maxcmpts)
 772 {
 773   jas_image_cmpt_t **newcmpts;
 774   int cmptno;
 775
 776   newcmpts = (!image->cmpts_) ? jas_malloc(maxcmpts * sizeof(jas_image_cmpt_t *)) :
 777     jas_realloc(image->cmpts_, maxcmpts * sizeof(jas_image_cmpt_t *));
 778   if (!newcmpts) {
 779     return -1;
 780   }
 781   image->cmpts_ = newcmpts;
 782   image->maxcmpts_ = maxcmpts;
 783   for (cmptno = image->numcmpts_; cmptno < image->maxcmpts_; ++cmptno) {
 784     image->cmpts_[cmptno] = 0;
 785   }
 786   return 0;
 787 }
 788
 789 int jas_image_copycmpt(jas_image_t *dstimage, int dstcmptno, jas_image_t *srcimage,
 790   int srccmptno)
 791 {
 792   jas_image_cmpt_t *newcmpt;
 793   if (dstimage->numcmpts_ >= dstimage->maxcmpts_) {
 794     if (jas_image_growcmpts(dstimage, dstimage->maxcmpts_ + 128)) {
 795       return -1;
 796     }
 797   }
 798   if (!(newcmpt = jas_image_cmpt_copy(srcimage->cmpts_[srccmptno]))) {
 799     return -1;
 800   }
 801   if (dstcmptno < dstimage->numcmpts_) {
 802     memmove(&dstimage->cmpts_[dstcmptno + 1], &dstimage->cmpts_[dstcmptno],
 803       (dstimage->numcmpts_ - dstcmptno) * sizeof(jas_image_cmpt_t *));
 804   }
 805   dstimage->cmpts_[dstcmptno] = newcmpt;
 806   ++dstimage->numcmpts_;
 807
 808   jas_image_setbbox(dstimage);
 809   return 0;
 810 }
 811
 812 void jas_image_dump(jas_image_t *image, FILE *out)
 813 {
 814   long buf[1024];
 815   int cmptno;
 816   int n;
 817   int i;
 818   int width;
 819   int height;
 820   jas_image_cmpt_t *cmpt;
 821   for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
 822     cmpt = image->cmpts_[cmptno];
 823     fprintf(out, "prec=%d, sgnd=%d, cmpttype=%d\n", cmpt->prec_,
 824       cmpt->sgnd_, cmpt->type_);
 825     width = jas_image_cmptwidth(image, cmptno);
 826     height = jas_image_cmptheight(image, cmptno);
 827     n = JAS_MIN(16, width);
 828     if (jas_image_readcmpt2(image, cmptno, 0, 0, n, 1, buf)) {
 829       abort();
 830     }
 831     for (i = 0; i < n; ++i) {
 832       fprintf(out, " f(%d,%d)=%ld", i, 0, buf[i]);
 833     }
 834     fprintf(out, "\n");
 835     if (jas_image_readcmpt2(image, cmptno, width - n, height - 1, n, 1, buf)) {
 836       abort();
 837     }
 838     for (i = 0; i < n; ++i) {
 839       fprintf(out, " f(%d,%d)=%ld", width - n + i, height - 1, buf[i]);
 840     }
 841     fprintf(out, "\n");
 842   }
 843 }
 844
 845 int jas_image_depalettize(jas_image_t *image, int cmptno, int numlutents,
 846   int_fast32_t *lutents, int dtype, int newcmptno)
 847 {
 848   jas_image_cmptparm_t cmptparms;
 849   int_fast32_t v;
 850   int i;
 851   int j;
 852   jas_image_cmpt_t *cmpt;
 853
 854   cmpt = image->cmpts_[cmptno];
 855   cmptparms.tlx = cmpt->tlx_;
 856   cmptparms.tly = cmpt->tly_;
 857   cmptparms.hstep = cmpt->hstep_;
 858   cmptparms.vstep = cmpt->vstep_;
 859   cmptparms.width = cmpt->width_;
 860   cmptparms.height = cmpt->height_;
 861   cmptparms.prec = JAS_IMAGE_CDT_GETPREC(dtype);
 862   cmptparms.sgnd = JAS_IMAGE_CDT_GETSGND(dtype);
 863
 864   if (jas_image_addcmpt(image, newcmptno, &cmptparms)) {
 865     return -1;
 866   }
 867   if (newcmptno <= cmptno) {
 868     ++cmptno;
 869     cmpt = image->cmpts_[cmptno];
 870   }
 871
 872   for (j = 0; j < cmpt->height_; ++j) {
 873     for (i = 0; i < cmpt->width_; ++i) {
 874       v = jas_image_readcmptsample(image, cmptno, i, j);
 875       if (v < 0) {
 876         v = 0;
 877       } else if (v >= numlutents) {
 878         v = numlutents - 1;
 879       }
 880       jas_image_writecmptsample(image, newcmptno, i, j,
 881         lutents[v]);
 882     }
 883   }
 884   return 0;
 885 }
 886
 887 int jas_image_readcmptsample(jas_image_t *image, int cmptno, int x, int y)
 888 {
 889   jas_image_cmpt_t *cmpt;
 890   uint_fast32_t v;
 891   int k;
 892   int c;
 893
 894   cmpt = image->cmpts_[cmptno];
 895
 896   if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_,
 897     SEEK_SET) < 0) {
 898     return -1;
 899   }
 900   v = 0;
 901   for (k = cmpt->cps_; k > 0; --k) {
 902     if ((c = jas_stream_getc(cmpt->stream_)) == EOF) {
 903       return -1;
 904     }
 905     v = (v << 8) | (c & 0xff);
 906   }
 907   return bitstoint(v, cmpt->prec_, cmpt->sgnd_);
 908 }
 909
 910 void jas_image_writecmptsample(jas_image_t *image, int cmptno, int x, int y,
 911   int_fast32_t v)
 912 {
 913   jas_image_cmpt_t *cmpt;
 914   uint_fast32_t t;
 915   int k;
 916   int c;
 917
 918   cmpt = image->cmpts_[cmptno];
 919
 920   if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * y + x) * cmpt->cps_,
 921     SEEK_SET) < 0) {
 922     return;
 923   }
 924   t = inttobits(v, cmpt->prec_, cmpt->sgnd_);
 925   for (k = cmpt->cps_; k > 0; --k) {
 926     c = (t >> (8 * (cmpt->cps_ - 1))) & 0xff;
 927     if (jas_stream_putc(cmpt->stream_, (unsigned char) c) == EOF) {
 928       return;
 929     }
 930     t <<= 8;
 931   }
 932 }
 933
 934 int jas_image_getcmptbytype(jas_image_t *image, int ctype)
 935 {
 936   int cmptno;
 937
 938   for (cmptno = 0; cmptno < image->numcmpts_; ++cmptno) {
 939     if (image->cmpts_[cmptno]->type_ == ctype) {
 940       return cmptno;
 941     }
 942   }
 943   return -1;
 944 }
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961 /***********************************************/
 962 /***********************************************/
 963 /***********************************************/
 964 /***********************************************/
 965
 966 int jas_image_readcmpt2(jas_image_t *image, int cmptno, jas_image_coord_t x,
 967   jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
 968   long *buf)
 969 {
 970   jas_image_cmpt_t *cmpt;
 971   jas_image_coord_t i;
 972   jas_image_coord_t j;
 973   long v;
 974   long *bufptr;
 975
 976   if (cmptno < 0 || cmptno >= image->numcmpts_)
 977     goto error;
 978   cmpt = image->cmpts_[cmptno];
 979   if (x < 0 || x >= cmpt->width_ || y < 0 || y >= cmpt->height_ ||
 980     width < 0 || height < 0 || x + width > cmpt->width_ ||
 981     y + height > cmpt->height_)
 982     goto error;
 983
 984   bufptr = buf;
 985   for (i = 0; i < height; ++i) {
 986     if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
 987       * cmpt->cps_, SEEK_SET) < 0)
 988       goto error;
 989     for (j = 0; j < width; ++j) {
 990       if (getint(cmpt->stream_, cmpt->sgnd_, cmpt->prec_, &v))
 991         goto error;
 992       *bufptr++ = v;
 993     }
 994   }
 995
 996   return 0;
 997 error:
 998   return -1;
 999 }
1000
1001 int jas_image_writecmpt2(jas_image_t *image, int cmptno, jas_image_coord_t x,
1002   jas_image_coord_t y, jas_image_coord_t width, jas_image_coord_t height,
1003   long *buf)
1004 {
1005   jas_image_cmpt_t *cmpt;
1006   jas_image_coord_t i;
1007   jas_image_coord_t j;
1008   long v;
1009   long *bufptr;
1010
1011   if (cmptno < 0 || cmptno >= image->numcmpts_)
1012     goto error;
1013   cmpt = image->cmpts_[cmptno];
1014   if (x < 0 || x >= cmpt->width_ || y < 0 || y >= cmpt->height_ ||
1015     width < 0 || height < 0 || x + width > cmpt->width_ ||
1016     y + height > cmpt->height_)
1017     goto error;
1018
1019   bufptr = buf;
1020   for (i = 0; i < height; ++i) {
1021     if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
1022       * cmpt->cps_, SEEK_SET) < 0)
1023       goto error;
1024     for (j = 0; j < width; ++j) {
1025       v = *bufptr++;
1026       if (putint(cmpt->stream_, cmpt->sgnd_, cmpt->prec_, v))
1027         goto error;
1028     }
1029   }
1030
1031   return 0;
1032 error:
1033   return -1;
1034 }
1035
1036 int jas_image_sampcmpt(jas_image_t *image, int cmptno, int newcmptno,
1037   jas_image_coord_t ho, jas_image_coord_t vo, jas_image_coord_t hs,
1038   jas_image_coord_t vs, int sgnd, int prec)
1039 {
1040   jas_image_cmpt_t *oldcmpt;
1041   jas_image_cmpt_t *newcmpt;
1042   int width;
1043   int height;
1044   jas_image_coord_t tlx;
1045   jas_image_coord_t tly;
1046   jas_image_coord_t brx;
1047   jas_image_coord_t bry;
1048   int i;
1049   int j;
1050   jas_image_cmptparm_t cmptparm;
1051   jas_image_coord_t ax;
1052   jas_image_coord_t ay;
1053   jas_image_coord_t bx;
1054   jas_image_coord_t by;
1055   jas_image_coord_t d0;
1056   jas_image_coord_t d1;
1057   jas_image_coord_t d2;
1058   jas_image_coord_t d3;
1059   jas_image_coord_t oldx;
1060   jas_image_coord_t oldy;
1061   jas_image_coord_t x;
1062   jas_image_coord_t y;
1063   long v;
1064   jas_image_coord_t cmptbrx;
1065   jas_image_coord_t cmptbry;
1066
1067   assert(cmptno >= 0 && cmptno < image->numcmpts_);
1068   oldcmpt = image->cmpts_[cmptno];
1069   assert(oldcmpt->tlx_ == 0 && oldcmpt->tly_ == 0);
1070   jas_image_calcbbox2(image, &tlx, &tly, &brx, &bry);
1071   width = FLOORDIV(brx - ho + hs, hs);
1072   height = FLOORDIV(bry - vo + vs, vs);
1073   cmptparm.tlx = ho;
1074   cmptparm.tly = vo;
1075   cmptparm.hstep = hs;
1076   cmptparm.vstep = vs;
1077   cmptparm.width = width;
1078   cmptparm.height = height;
1079   cmptparm.prec = prec;
1080   cmptparm.sgnd = sgnd;
1081   if (jas_image_addcmpt(image, newcmptno, &cmptparm))
1082     goto error;
1083 cmptbrx = oldcmpt->tlx_ + (oldcmpt->width_ - 1) * oldcmpt->hstep_;
1084 cmptbry = oldcmpt->tly_ + (oldcmpt->height_ - 1) * oldcmpt->vstep_;
1085   newcmpt = image->cmpts_[newcmptno];
1086   jas_stream_rewind(newcmpt->stream_);
1087   for (i = 0; i < height; ++i) {
1088     y = newcmpt->tly_ + newcmpt->vstep_ * i;
1089     for (j = 0; j < width; ++j) {
1090       x = newcmpt->tlx_ + newcmpt->hstep_ * j;
1091       ax = downtomult(x - oldcmpt->tlx_, oldcmpt->hstep_) + oldcmpt->tlx_;
1092       ay = downtomult(y - oldcmpt->tly_, oldcmpt->vstep_) + oldcmpt->tly_;
1093       bx = uptomult(x - oldcmpt->tlx_, oldcmpt->hstep_) + oldcmpt->tlx_;
1094       if (bx > cmptbrx)
1095         bx = cmptbrx;
1096       by = uptomult(y - oldcmpt->tly_, oldcmpt->vstep_) + oldcmpt->tly_;
1097       if (by > cmptbry)
1098         by = cmptbry;
1099       d0 = (ax - x) * (ax - x) + (ay - y) * (ay - y);
1100       d1 = (bx - x) * (bx - x) + (ay - y) * (ay - y);
1101       d2 = (bx - x) * (bx - x) + (by - y) * (by - y);
1102       d3 = (ax - x) * (ax - x) + (by - y) * (by - y);
1103       if (d0 <= d1 && d0 <= d2 && d0 <= d3) {
1104         oldx = (ax - oldcmpt->tlx_) / oldcmpt->hstep_;
1105         oldy = (ay - oldcmpt->tly_) / oldcmpt->vstep_;
1106       } else if (d1 <= d0 && d1 <= d2 && d1 <= d3) {
1107         oldx = (bx - oldcmpt->tlx_) / oldcmpt->hstep_;
1108         oldy = (ay - oldcmpt->tly_) / oldcmpt->vstep_;
1109       } else if (d2 <= d0 && d2 <= d1 && d1 <= d3) {
1110         oldx = (bx - oldcmpt->tlx_) / oldcmpt->hstep_;
1111         oldy = (by - oldcmpt->tly_) / oldcmpt->vstep_;
1112       } else {
1113         oldx = (ax - oldcmpt->tlx_) / oldcmpt->hstep_;
1114         oldy = (by - oldcmpt->tly_) / oldcmpt->vstep_;
1115       }
1116       assert(oldx >= 0 && oldx < oldcmpt->width_ &&
1117         oldy >= 0 && oldy < oldcmpt->height_);
1118       if (jas_stream_seek(oldcmpt->stream_, oldcmpt->cps_ *
1119         (oldy * oldcmpt->width_ + oldx), SEEK_SET) < 0)
1120         goto error;
1121       if (getint(oldcmpt->stream_, oldcmpt->sgnd_,
1122         oldcmpt->prec_, &v))
1123         goto error;
1124       if (newcmpt->prec_ != oldcmpt->prec_ ||
1125         newcmpt->sgnd_ != oldcmpt->sgnd_) {
1126         v = convert(v, oldcmpt->sgnd_, oldcmpt->prec_,
1127           newcmpt->sgnd_, newcmpt->prec_);
1128       }
1129       if (putint(newcmpt->stream_, newcmpt->sgnd_,
1130         newcmpt->prec_, v))
1131         goto error;
1132     }
1133   }
1134   return 0;
1135 error:
1136   return -1;
1137 }
1138
1139 int jas_image_ishomosamp(jas_image_t *image)
1140 {
1141   jas_image_coord_t hstep;
1142   jas_image_coord_t vstep;
1143   int result;
1144   int i;
1145   hstep = jas_image_cmpthstep(image, 0);
1146   vstep = jas_image_cmptvstep(image, 0);
1147   result = 1;
1148   for (i = 0; i < image->numcmpts_; ++i) {
1149     if (jas_image_cmpthstep(image, i) != hstep ||
1150       jas_image_cmptvstep(image, i) != vstep) {
1151       result = 0;
1152       break;
1153     }
1154   }
1155   return result;
1156 }
1157
1158 /* Note: This function defines a bounding box differently. */
1159 static void jas_image_calcbbox2(jas_image_t *image, jas_image_coord_t *tlx,
1160   jas_image_coord_t *tly, jas_image_coord_t *brx, jas_image_coord_t *bry)
1161 {
1162   jas_image_cmpt_t *cmpt;
1163   jas_image_coord_t tmptlx;
1164   jas_image_coord_t tmptly;
1165   jas_image_coord_t tmpbrx;
1166   jas_image_coord_t tmpbry;
1167   jas_image_coord_t t;
1168   int i;
1169   if (image->numcmpts_ > 0) {
1170     cmpt = image->cmpts_[0];
1171     tmptlx = cmpt->tlx_;
1172     tmptly = cmpt->tly_;
1173     tmpbrx = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1);
1174     tmpbry = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1);
1175     for (i = 0; i < image->numcmpts_; ++i) {
1176       cmpt = image->cmpts_[i];
1177       if (cmpt->tlx_ < tmptlx)
1178         tmptlx = cmpt->tlx_;
1179       if (cmpt->tly_ < tmptly)
1180         tmptly = cmpt->tly_;
1181       t = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1);
1182       if (t > tmpbrx)
1183         tmpbrx = t;
1184       t = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1);
1185       if (t > tmpbry)
1186         tmpbry = t;
1187     }
1188   } else {
1189     tmptlx = 0;
1190     tmptly = 0;
1191     tmpbrx = -1;
1192     tmpbry = -1;
1193   }
1194   *tlx = tmptlx;
1195   *tly = tmptly;
1196   *brx = tmpbrx;
1197   *bry = tmpbry;
1198 }
1199
1200
1201
1202 static int getint(jas_stream_t *in, int sgnd, int prec, long *val)
1203 {
1204   long v;
1205   int n;
1206   int c;
1207   n = (prec + 7) / 8;
1208   v = 0;
1209   while (--n >= 0) {
1210     if ((c = jas_stream_getc(in)) == EOF)
1211       return -1;
1212     v = (v << 8) | c;
1213   }
1214   v &= ((1 << prec) - 1);
1215   if (sgnd) {
1216     /* XXX - Do something here. */
1217     abort();
1218   } else {
1219     *val = v;
1220   }
1221   return 0;
1222 }
1223
1224 static int putint(jas_stream_t *out, int sgnd, int prec, long val)
1225 {
1226   int n;
1227   int c;
1228   if (sgnd) {
1229     /* XXX - Do something here. */
1230     abort();
1231   }
1232   val &= (1 << prec) - 1;
1233   n = (prec + 7) / 8;
1234   while (--n >= 0) {
1235     c = (val >> (n * 8)) & 0xff;
1236     if (jas_stream_putc(out, c) != c)
1237       return -1;
1238   }
1239   return 0;
1240 }
1241
1242 static long convert(long val, int oldsgnd, int oldprec, int newsgnd,
1243   int newprec)
1244 {
1245   if (newsgnd != oldsgnd) {
1246   }
1247   if (newprec != oldprec) {
1248     if (newprec > oldprec) {
1249       val <<= newprec - oldprec;
1250     } else if (oldprec > newprec) {
1251       val >>= oldprec - newprec;
1252     }
1253   }
1254   return val;
1255 }
1256
1257 static long downtomult(long x, long y)
1258 {
1259   assert(x >= 0);
1260   return (x / y) * y;
1261 }
1262
1263 static long uptomult(long x, long y)
1264 {
1265   assert(x >= 0);
1266   return ((x + y - 1) / y) * y;
1267 }
1268
1269 jas_image_t *jas_image_chclrspc(jas_image_t *image, jas_cmprof_t *outprof,
1270   int intent)
1271 {
1272   jas_image_t *inimage;
1273   int minhstep;
1274   int minvstep;
1275   int i;
1276   int j;
1277   int k;
1278   int n;
1279   int hstep;
1280   int vstep;
1281   int numinauxchans;
1282   int numoutauxchans;
1283   int numinclrchans;
1284   int numoutclrchans;
1285   int prec;
1286   jas_image_t *outimage;
1287   int cmpttype;
1288   int numoutchans;
1289   jas_cmprof_t *inprof;
1290   jas_cmprof_t *tmpprof;
1291   jas_image_cmptparm_t cmptparm;
1292   int width;
1293   int height;
1294   jas_cmxform_t *xform;
1295   jas_cmpixmap_t inpixmap;
1296   jas_cmpixmap_t outpixmap;
1297   jas_cmcmptfmt_t *incmptfmts;
1298   jas_cmcmptfmt_t *outcmptfmts;
1299
1300 #if 0
1301 fprintf(stderr, "IMAGE\n");
1302 jas_image_dump(image, stderr);
1303 #endif
1304
1305   if (!(inimage = jas_image_copy(image)))
1306     goto error;
1307   image = 0;
1308
1309   if (!jas_image_ishomosamp(inimage)) {
1310     minhstep = jas_image_cmpthstep(inimage, 0);
1311     minvstep = jas_image_cmptvstep(inimage, 0);
1312     for (i = 1; i < jas_image_numcmpts(inimage); ++i) {
1313       hstep = jas_image_cmpthstep(inimage, i);
1314       vstep = jas_image_cmptvstep(inimage, i);
1315       if (hstep < minhstep)
1316         minhstep = hstep;
1317       if (vstep < minvstep)
1318         minvstep = vstep;
1319     }
1320     n = jas_image_numcmpts(inimage);
1321     for (i = 0; i < n; ++i) {
1322       cmpttype = jas_image_cmpttype(inimage, i);
1323       if (jas_image_sampcmpt(inimage, i, i + 1, 0, 0, minhstep, minvstep, jas_image_cmptsgnd(inimage, i), jas_image_cmptprec(inimage, i)))
1324         goto error;
1325       jas_image_setcmpttype(inimage, i + 1, cmpttype);
1326       jas_image_delcmpt(inimage, i);
1327     }
1328   }
1329
1330   width = jas_image_cmptwidth(inimage, 0);
1331   height = jas_image_cmptheight(inimage, 0);
1332   hstep = jas_image_cmpthstep(inimage, 0);
1333   vstep = jas_image_cmptvstep(inimage, 0);
1334
1335   inprof = jas_image_cmprof(inimage);
1336   assert(inprof);
1337   numinclrchans = jas_clrspc_numchans(jas_cmprof_clrspc(inprof));
1338   numinauxchans = jas_image_numcmpts(inimage) - numinclrchans;
1339   numoutclrchans = jas_clrspc_numchans(jas_cmprof_clrspc(outprof));
1340   numoutauxchans = 0;
1341   numoutchans = numoutclrchans + numoutauxchans;
1342   prec = 8;
1343
1344   if (!(outimage = jas_image_create0()))
1345     goto error;
1346
1347   /* Create a component for each of the colorants. */
1348   for (i = 0; i < numoutclrchans; ++i) {
1349     cmptparm.tlx = 0;
1350     cmptparm.tly = 0;
1351     cmptparm.hstep = hstep;
1352     cmptparm.vstep = vstep;
1353     cmptparm.width = width;
1354     cmptparm.height = height;
1355     cmptparm.prec = prec;
1356     cmptparm.sgnd = 0;
1357     if (jas_image_addcmpt(outimage, -1, &cmptparm))
1358       goto error;
1359     jas_image_setcmpttype(outimage, i, JAS_IMAGE_CT_COLOR(i));
1360   }
1361 #if 0
1362   /* Copy the auxiliary components without modification. */
1363   for (i = 0; i < jas_image_numcmpts(inimage); ++i) {
1364     if (!ISCOLOR(jas_image_cmpttype(inimage, i))) {
1365       jas_image_copycmpt(outimage, -1, inimage, i);
1366 /* XXX - need to specify laydown of component on ref. grid */
1367     }
1368   }
1369 #endif
1370
1371   if (!(tmpprof = jas_cmprof_copy(outprof)))
1372     goto error;
1373   assert(!jas_image_cmprof(outimage));
1374   jas_image_setcmprof(outimage, tmpprof);
1375   tmpprof = 0;
1376   jas_image_setclrspc(outimage, jas_cmprof_clrspc(outprof));
1377
1378   if (!(xform = jas_cmxform_create(inprof, outprof, 0, JAS_CMXFORM_OP_FWD, intent, 0)))
1379     goto error;
1380
1381   inpixmap.numcmpts = numinclrchans;
1382   incmptfmts = malloc(numinclrchans * sizeof(jas_cmcmptfmt_t));
1383   assert(incmptfmts);
1384   inpixmap.cmptfmts = incmptfmts;
1385   for (i = 0; i < numinclrchans; ++i) {
1386     j = jas_image_getcmptbytype(inimage, JAS_IMAGE_CT_COLOR(i));
1387     assert(j >= 0);
1388     if (!(incmptfmts[i].buf = malloc(width * sizeof(long))))
1389       goto error;
1390     incmptfmts[i].prec = jas_image_cmptprec(inimage, j);
1391     incmptfmts[i].sgnd = jas_image_cmptsgnd(inimage, j);
1392     incmptfmts[i].width = width;
1393     incmptfmts[i].height = 1;
1394   }
1395
1396   outpixmap.numcmpts = numoutclrchans;
1397   outcmptfmts = malloc(numoutclrchans * sizeof(jas_cmcmptfmt_t));
1398   assert(outcmptfmts);
1399   outpixmap.cmptfmts = outcmptfmts;
1400
1401   for (i = 0; i < numoutclrchans; ++i) {
1402     j = jas_image_getcmptbytype(outimage, JAS_IMAGE_CT_COLOR(i));
1403     assert(j >= 0);
1404     if (!(outcmptfmts[i].buf = malloc(width * sizeof(long))))
1405       goto error;
1406     outcmptfmts[i].prec = jas_image_cmptprec(outimage, j);
1407     outcmptfmts[i].sgnd = jas_image_cmptsgnd(outimage, j);
1408     outcmptfmts[i].width = width;
1409     outcmptfmts[i].height = 1;
1410   }
1411
1412   for (i = 0; i < height; ++i) {
1413     for (j = 0; j < numinclrchans; ++j) {
1414       k = jas_image_getcmptbytype(inimage, JAS_IMAGE_CT_COLOR(j));
1415       if (jas_image_readcmpt2(inimage, k, 0, i, width, 1, incmptfmts[j].buf))
1416         goto error;
1417     }
1418     jas_cmxform_apply(xform, &inpixmap, &outpixmap);
1419     for (j = 0; j < numoutclrchans; ++j) {
1420       k = jas_image_getcmptbytype(outimage, JAS_IMAGE_CT_COLOR(j));
1421       if (jas_image_writecmpt2(outimage, k, 0, i, width, 1, outcmptfmts[j].buf))
1422         goto error;
1423     }
1424   }
1425
1426   for (i = 0; i < numoutclrchans; ++i)
1427     jas_free(outcmptfmts[i].buf);
1428   jas_free(outcmptfmts);
1429   for (i = 0; i < numinclrchans; ++i)
1430     jas_free(incmptfmts[i].buf);
1431   jas_free(incmptfmts);
1432   jas_cmxform_destroy(xform);
1433   jas_image_destroy(inimage);
1434
1435 #if 0
1436 fprintf(stderr, "INIMAGE\n");
1437 jas_image_dump(inimage, stderr);
1438 fprintf(stderr, "OUTIMAGE\n");
1439 jas_image_dump(outimage, stderr);
1440 #endif
1441   return outimage;
1442 error:
1443   return 0;
1444 }