vcs.maemo.org Git - opencv/blob - otherlibs/_graphics/src/libjasper/jas_cm.c

   1 /*
   2  * Copyright (c) 2002-2003 Michael David Adams.
   3  * All rights reserved.
   4  */
   5
   6 /* __START_OF_JASPER_LICENSE__
   7  *
   8  * JasPer License Version 2.0
   9  *
  10  * Copyright (c) 1999-2000 Image Power, Inc.
  11  * Copyright (c) 1999-2000 The University of British Columbia
  12  * Copyright (c) 2001-2003 Michael David Adams
  13  *
  14  * All rights reserved.
  15  *
  16  * Permission is hereby granted, free of charge, to any person (the
  17  * "User") obtaining a copy of this software and associated documentation
  18  * files (the "Software"), to deal in the Software without restriction,
  19  * including without limitation the rights to use, copy, modify, merge,
  20  * publish, distribute, and/or sell copies of the Software, and to permit
  21  * persons to whom the Software is furnished to do so, subject to the
  22  * following conditions:
  23  *
  24  * 1.  The above copyright notices and this permission notice (which
  25  * includes the disclaimer below) shall be included in all copies or
  26  * substantial portions of the Software.
  27  *
  28  * 2.  The name of a copyright holder shall not be used to endorse or
  29  * promote products derived from the Software without specific prior
  30  * written permission.
  31  *
  32  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
  33  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  34  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
  35  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  36  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  37  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
  38  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
  39  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
  40  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  41  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  42  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
  43  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
  44  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
  45  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
  46  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
  47  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
  48  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
  49  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
  50  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
  51  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
  52  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
  53  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
  54  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
  55  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
  56  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
  57  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
  58  *
  59  * __END_OF_JASPER_LICENSE__
  60  */
  61
  62 /*
  63  * Color Management
  64  *
  65  * $Id: jas_cm.c,v 1.1 2007/01/15 16:09:23 vp153 Exp $
  66  */
  67
  68 #include <jasper/jas_config.h>
  69 #include <math.h>
  70 #include <stdlib.h>
  71 #include <assert.h>
  72 #include <jasper/jas_cm.h>
  73 #include <jasper/jas_icc.h>
  74 #include <jasper/jas_init.h>
  75 #include <jasper/jas_stream.h>
  76 #include <jasper/jas_malloc.h>
  77 #include <jasper/jas_math.h>
  78
  79 static jas_cmprof_t *jas_cmprof_create(void);
  80 static void jas_cmshapmatlut_cleanup(jas_cmshapmatlut_t *);
  81 static jas_cmreal_t jas_cmshapmatlut_lookup(jas_cmshapmatlut_t *lut, jas_cmreal_t x);
  82
  83 static void jas_cmpxform_destroy(jas_cmpxform_t *pxform);
  84 static jas_cmpxform_t *jas_cmpxform_copy(jas_cmpxform_t *pxform);
  85
  86 static void jas_cmshapmat_destroy(jas_cmpxform_t *pxform);
  87 static int jas_cmshapmat_apply(jas_cmpxform_t *pxform, jas_cmreal_t *in,
  88   jas_cmreal_t *out, int cnt);
  89
  90 static int jas_cmputint(long **bufptr, int sgnd, int prec, long val);
  91 static int jas_cmgetint(long **bufptr, int sgnd, int prec, long *val);
  92 static int jas_cmpxformseq_append(jas_cmpxformseq_t *pxformseq,
  93   jas_cmpxformseq_t *othpxformseq);
  94 static int jas_cmpxformseq_appendcnvt(jas_cmpxformseq_t *pxformseq,
  95   int, int);
  96 static int jas_cmpxformseq_resize(jas_cmpxformseq_t *pxformseq, int n);
  97
  98 static int mono(jas_iccprof_t *prof, int op, jas_cmpxformseq_t **pxformseq);
  99 static int triclr(jas_iccprof_t *prof, int op, jas_cmpxformseq_t **retpxformseq);
 100
 101 static void jas_cmpxformseq_destroy(jas_cmpxformseq_t *pxformseq);
 102 static int jas_cmpxformseq_delete(jas_cmpxformseq_t *pxformseq, int i);
 103 static jas_cmpxformseq_t *jas_cmpxformseq_create(void);
 104 static jas_cmpxformseq_t *jas_cmpxformseq_copy(jas_cmpxformseq_t *pxformseq);
 105 static int jas_cmshapmat_invmat(jas_cmreal_t out[3][4], jas_cmreal_t in[3][4]);
 106 static int jas_cmpxformseq_insertpxform(jas_cmpxformseq_t *pxformseq,
 107   int i, jas_cmpxform_t *pxform);
 108
 109 #define SEQFWD(intent)  (intent)
 110 #define SEQREV(intent)  (4 + (intent))
 111 #define SEQSIM(intent)  (8 + (intent))
 112 #define SEQGAM          12
 113
 114 #define fwdpxformseq(prof, intent) \
 115   (((prof)->pxformseqs[SEQFWD(intent)]) ? \
 116   ((prof)->pxformseqs[SEQFWD(intent)]) : \
 117   ((prof)->pxformseqs[SEQFWD(0)]))
 118
 119 #define revpxformseq(prof, intent) \
 120   (((prof)->pxformseqs[SEQREV(intent)]) ? \
 121   ((prof)->pxformseqs[SEQREV(intent)]) : \
 122   ((prof)->pxformseqs[SEQREV(0)]))
 123
 124 #define simpxformseq(prof, intent) \
 125   (((prof)->pxformseqs[SEQSIM(intent)]) ? \
 126   ((prof)->pxformseqs[SEQSIM(intent)]) : \
 127   ((prof)->pxformseqs[SEQSIM(0)]))
 128
 129 #define gampxformseq(prof)      ((prof)->pxformseqs[SEQGAM])
 130
 131 static int icctoclrspc(int iccclrspc, int refflag);
 132 static jas_cmpxform_t *jas_cmpxform_create0(void);
 133 static jas_cmpxform_t *jas_cmpxform_createshapmat(void);
 134 static void jas_cmshapmatlut_init(jas_cmshapmatlut_t *lut);
 135 static int jas_cmshapmatlut_set(jas_cmshapmatlut_t *lut, jas_icccurv_t *curv);
 136
 137 static jas_cmpxformops_t shapmat_ops = {jas_cmshapmat_destroy, jas_cmshapmat_apply, 0};
 138 static jas_cmprof_t *jas_cmprof_createsycc(void);
 139
 140 /******************************************************************************\
 141 * Color profile class.
 142 \******************************************************************************/
 143
 144 jas_cmprof_t *jas_cmprof_createfromclrspc(int clrspc)
 145 {
 146         jas_iccprof_t *iccprof;
 147         jas_cmprof_t *prof;
 148
 149         iccprof = 0;
 150         prof = 0;
 151         switch (clrspc) {
 152         case JAS_CLRSPC_SYCBCR:
 153                 if (!(prof = jas_cmprof_createsycc()))
 154                         goto error;
 155                 break;
 156         default:
 157                 if (!(iccprof = jas_iccprof_createfromclrspc(clrspc)))
 158                         goto error;
 159                 if (!(prof = jas_cmprof_createfromiccprof(iccprof)))
 160                         goto error;
 161 #if 0
 162                 jas_iccprof_destroy(iccprof);
 163 #else
 164                 prof->iccprof = iccprof;
 165 #endif
 166                 if (!jas_clrspc_isgeneric(clrspc))
 167                         prof->clrspc = clrspc;
 168                 break;
 169         }
 170         return prof;
 171 error:
 172         if (iccprof)
 173                 jas_iccprof_destroy(iccprof);
 174         return 0;
 175 }
 176
 177 static jas_cmprof_t *jas_cmprof_createsycc()
 178 {
 179         jas_cmprof_t *prof;
 180         jas_cmpxform_t *fwdpxform;
 181         jas_cmpxform_t *revpxform;
 182         jas_cmshapmat_t *fwdshapmat;
 183         jas_cmshapmat_t *revshapmat;
 184         int i;
 185         int j;
 186
 187         if (!(prof = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB)))
 188                 goto error;
 189         prof->clrspc = JAS_CLRSPC_SYCBCR;
 190         assert(prof->numchans == 3 && prof->numrefchans == 3);
 191         assert(prof->refclrspc == JAS_CLRSPC_CIEXYZ);
 192         if (!(fwdpxform = jas_cmpxform_createshapmat()))
 193                 goto error;
 194         fwdpxform->numinchans = 3;
 195         fwdpxform->numoutchans = 3;
 196         fwdshapmat = &fwdpxform->data.shapmat;
 197         fwdshapmat->mono = 0;
 198         fwdshapmat->order = 0;
 199         fwdshapmat->useluts = 0;
 200         fwdshapmat->usemat = 1;
 201         fwdshapmat->mat[0][0] = 1.0;
 202         fwdshapmat->mat[0][1] = 0.0;
 203         fwdshapmat->mat[0][2] = 1.402;
 204         fwdshapmat->mat[1][0] = 1.0;
 205         fwdshapmat->mat[1][1] = -0.34413;
 206         fwdshapmat->mat[1][2] = -0.71414;
 207         fwdshapmat->mat[2][0] = 1.0;
 208         fwdshapmat->mat[2][1] = 1.772;
 209         fwdshapmat->mat[2][2] = 0.0;
 210         fwdshapmat->mat[0][3] = -0.5 * (1.402);
 211         fwdshapmat->mat[1][3] = -0.5 * (-0.34413 - 0.71414);
 212         fwdshapmat->mat[2][3] = -0.5 * (1.772);
 213         if (!(revpxform = jas_cmpxform_createshapmat()))
 214                 goto error;
 215         revpxform->numinchans = 3;
 216         revpxform->numoutchans = 3;
 217         revshapmat = &revpxform->data.shapmat;
 218         revshapmat->mono = 0;
 219         revshapmat->order = 1;
 220         revshapmat->useluts = 0;
 221         revshapmat->usemat = 1;
 222         jas_cmshapmat_invmat(revshapmat->mat, fwdshapmat->mat);
 223
 224         for (i = 0; i < JAS_CMXFORM_NUMINTENTS; ++i) {
 225                 j = SEQFWD(i);
 226                 if (prof->pxformseqs[j]) {
 227                         if (jas_cmpxformseq_insertpxform(prof->pxformseqs[j], 0,
 228                           fwdpxform))
 229                                 goto error;
 230                 }
 231                 j = SEQREV(i);
 232                 if (prof->pxformseqs[j]) {
 233                         if (jas_cmpxformseq_insertpxform(prof->pxformseqs[j],
 234                           -1, revpxform))
 235                                 goto error;
 236                 }
 237         }
 238
 239         jas_cmpxform_destroy(fwdpxform);
 240         jas_cmpxform_destroy(revpxform);
 241         return prof;
 242 error:
 243         return 0;
 244 }
 245
 246 jas_cmprof_t *jas_cmprof_createfromiccprof(jas_iccprof_t *iccprof)
 247 {
 248         jas_cmprof_t *prof;
 249         jas_icchdr_t icchdr;
 250         jas_cmpxformseq_t *fwdpxformseq;
 251         jas_cmpxformseq_t *revpxformseq;
 252
 253         if (!(prof = jas_cmprof_create()))
 254                 goto error;
 255         jas_iccprof_gethdr(iccprof, &icchdr);
 256         if (!(prof->iccprof = jas_iccprof_copy(iccprof)))
 257                 goto error;
 258         prof->clrspc = icctoclrspc(icchdr.colorspc, 0);
 259         prof->refclrspc = icctoclrspc(icchdr.refcolorspc, 1);
 260         prof->numchans = jas_clrspc_numchans(prof->clrspc);
 261         prof->numrefchans = jas_clrspc_numchans(prof->refclrspc);
 262
 263         if (prof->numchans == 1) {
 264                 if (mono(prof->iccprof, 0, &fwdpxformseq))
 265                         goto error;
 266                 if (mono(prof->iccprof, 1, &revpxformseq))
 267                         goto error;
 268         } else if (prof->numchans == 3) {
 269                 if (triclr(prof->iccprof, 0, &fwdpxformseq))
 270                         goto error;
 271                 if (triclr(prof->iccprof, 1, &revpxformseq))
 272                         goto error;
 273         }
 274         prof->pxformseqs[SEQFWD(0)] = fwdpxformseq;
 275         prof->pxformseqs[SEQREV(0)] = revpxformseq;
 276
 277 #if 0
 278         if (prof->numchans > 1) {
 279                 lut(prof->iccprof, 0, PER, &pxformseq);
 280                 pxformseqs_set(prof, SEQFWD(PER), pxformseq);
 281                 lut(prof->iccprof, 1, PER, &pxformseq);
 282                 pxformseqs_set(prof, SEQREV(PER), pxformseq);
 283                 lut(prof->iccprof, 0, CLR, &pxformseq);
 284                 pxformseqs_set(prof, SEQREV(CLR), pxformseq);
 285                 lut(prof->iccprof, 1, CLR, &pxformseq);
 286                 pxformseqs_set(prof, SEQREV(CLR), pxformseq);
 287                 lut(prof->iccprof, 0, SAT, &pxformseq);
 288                 pxformseqs_set(prof, SEQREV(SAT), pxformseq);
 289                 lut(prof->iccprof, 1, SAT, &pxformseq);
 290                 pxformseqs_set(prof, SEQREV(SAT), pxformseq);
 291         }
 292 #endif
 293
 294         return prof;
 295 error:
 296         return 0;
 297 }
 298
 299 static jas_cmprof_t *jas_cmprof_create()
 300 {
 301         int i;
 302         jas_cmprof_t *prof;
 303         if (!(prof = jas_malloc(sizeof(jas_cmprof_t))))
 304                 return 0;
 305         memset(prof, 0, sizeof(jas_cmprof_t));
 306         prof->iccprof = 0;
 307         for (i = 0; i < JAS_CMPROF_NUMPXFORMSEQS; ++i)
 308                 prof->pxformseqs[i] = 0;
 309         return prof;
 310 }
 311
 312 void jas_cmprof_destroy(jas_cmprof_t *prof)
 313 {
 314         int i;
 315         for (i = 0; i < JAS_CMPROF_NUMPXFORMSEQS; ++i) {
 316                 if (prof->pxformseqs[i]) {
 317                         jas_cmpxformseq_destroy(prof->pxformseqs[i]);
 318                         prof->pxformseqs[i] = 0;
 319                 }
 320         }
 321         if (prof->iccprof)
 322                 jas_iccprof_destroy(prof->iccprof);
 323         jas_free(prof);
 324 }
 325
 326 jas_cmprof_t *jas_cmprof_copy(jas_cmprof_t *prof)
 327 {
 328         jas_cmprof_t *newprof;
 329         int i;
 330
 331         if (!(newprof = jas_cmprof_create()))
 332                 goto error;
 333         newprof->clrspc = prof->clrspc;
 334         newprof->numchans = prof->numchans;
 335         newprof->refclrspc = prof->refclrspc;
 336         newprof->numrefchans = prof->numrefchans;
 337         newprof->iccprof = jas_iccprof_copy(prof->iccprof);
 338         for (i = 0; i < JAS_CMPROF_NUMPXFORMSEQS; ++i) {
 339                 if (prof->pxformseqs[i]) {
 340                         if (!(newprof->pxformseqs[i] = jas_cmpxformseq_copy(prof->pxformseqs[i])))
 341                                 goto error;
 342                 }
 343         }
 344         return newprof;
 345 error:
 346         return 0;
 347 }
 348
 349 /******************************************************************************\
 350 * Transform class.
 351 \******************************************************************************/
 352
 353 jas_cmxform_t *jas_cmxform_create(jas_cmprof_t *inprof, jas_cmprof_t *outprof,
 354   jas_cmprof_t *prfprof, int op, int intent, int optimize)
 355 {
 356         jas_cmxform_t *xform;
 357         jas_cmpxformseq_t *inpxformseq;
 358         jas_cmpxformseq_t *outpxformseq;
 359         jas_cmpxformseq_t *altoutpxformseq;
 360         jas_cmpxformseq_t *prfpxformseq;
 361         int prfintent;
 362
 363         /* Avoid compiler warnings about unused parameters. */
 364         optimize = 0;
 365
 366         prfintent = intent;
 367
 368         if (!(xform = jas_malloc(sizeof(jas_cmxform_t))))
 369                 goto error;
 370         if (!(xform->pxformseq = jas_cmpxformseq_create()))
 371                 goto error;
 372
 373         switch (op) {
 374         case JAS_CMXFORM_OP_FWD:
 375                 inpxformseq = fwdpxformseq(inprof, intent);
 376                 outpxformseq = revpxformseq(outprof, intent);
 377                 if (!inpxformseq || !outpxformseq)
 378                         goto error;
 379                 if (jas_cmpxformseq_append(xform->pxformseq, inpxformseq) ||
 380                   jas_cmpxformseq_appendcnvt(xform->pxformseq,
 381                   inprof->refclrspc, outprof->refclrspc) ||
 382                   jas_cmpxformseq_append(xform->pxformseq, outpxformseq))
 383                         goto error;
 384                 xform->numinchans = jas_clrspc_numchans(inprof->clrspc);
 385                 xform->numoutchans = jas_clrspc_numchans(outprof->clrspc);
 386                 break;
 387         case JAS_CMXFORM_OP_REV:
 388                 outpxformseq = fwdpxformseq(outprof, intent);
 389                 inpxformseq = revpxformseq(inprof, intent);
 390                 if (!outpxformseq || !inpxformseq)
 391                         goto error;
 392                 if (jas_cmpxformseq_append(xform->pxformseq, outpxformseq) ||
 393                   jas_cmpxformseq_appendcnvt(xform->pxformseq,
 394                   outprof->refclrspc, inprof->refclrspc) ||
 395                   jas_cmpxformseq_append(xform->pxformseq, inpxformseq))
 396                         goto error;
 397                 xform->numinchans = jas_clrspc_numchans(outprof->clrspc);
 398                 xform->numoutchans = jas_clrspc_numchans(inprof->clrspc);
 399                 break;
 400         case JAS_CMXFORM_OP_PROOF:
 401                 assert(prfprof);
 402                 inpxformseq = fwdpxformseq(inprof, intent);
 403                 prfpxformseq = fwdpxformseq(prfprof, prfintent);
 404                 if (!inpxformseq || !prfpxformseq)
 405                         goto error;
 406                 outpxformseq = simpxformseq(outprof, intent);
 407                 altoutpxformseq = 0;
 408                 if (!outpxformseq) {
 409                         outpxformseq = revpxformseq(outprof, intent);
 410                         altoutpxformseq = fwdpxformseq(outprof, intent);
 411                         if (!outpxformseq || !altoutpxformseq)
 412                                 goto error;
 413                 }
 414                 if (jas_cmpxformseq_append(xform->pxformseq, inpxformseq) ||
 415                   jas_cmpxformseq_appendcnvt(xform->pxformseq,
 416                   inprof->refclrspc, outprof->refclrspc))
 417                         goto error;
 418                 if (altoutpxformseq) {
 419                         if (jas_cmpxformseq_append(xform->pxformseq, outpxformseq) ||
 420                           jas_cmpxformseq_append(xform->pxformseq, altoutpxformseq))
 421                                 goto error;
 422                 } else {
 423                         if (jas_cmpxformseq_append(xform->pxformseq, outpxformseq))
 424                                 goto error;
 425                 }
 426                 if (jas_cmpxformseq_appendcnvt(xform->pxformseq,
 427                   outprof->refclrspc, inprof->refclrspc) ||
 428                   jas_cmpxformseq_append(xform->pxformseq, prfpxformseq))
 429                         goto error;
 430                 xform->numinchans = jas_clrspc_numchans(inprof->clrspc);
 431                 xform->numoutchans = jas_clrspc_numchans(prfprof->clrspc);
 432                 break;
 433         case JAS_CMXFORM_OP_GAMUT:
 434                 inpxformseq = fwdpxformseq(inprof, intent);
 435                 outpxformseq = gampxformseq(outprof);
 436                 if (!inpxformseq || !outpxformseq)
 437                         goto error;
 438                 if (jas_cmpxformseq_append(xform->pxformseq, inpxformseq) ||
 439                   jas_cmpxformseq_appendcnvt(xform->pxformseq,
 440                   inprof->refclrspc, outprof->refclrspc) ||
 441                   jas_cmpxformseq_append(xform->pxformseq, outpxformseq))
 442                         goto error;
 443                 xform->numinchans = jas_clrspc_numchans(inprof->clrspc);
 444                 xform->numoutchans = 1;
 445                 break;
 446         }
 447         return xform;
 448 error:
 449         return 0;
 450 }
 451
 452 #define APPLYBUFSIZ     2048
 453 int jas_cmxform_apply(jas_cmxform_t *xform, jas_cmpixmap_t *in, jas_cmpixmap_t *out)
 454 {
 455         jas_cmcmptfmt_t *fmt;
 456         jas_cmreal_t buf[2][APPLYBUFSIZ];
 457         jas_cmpxformseq_t *pxformseq;
 458         int i;
 459         int j;
 460         int width;
 461         int height;
 462         int total;
 463         int n;
 464         jas_cmreal_t *inbuf;
 465         jas_cmreal_t *outbuf;
 466         jas_cmpxform_t *pxform;
 467         long *dataptr;
 468         int maxchans;
 469         int bufmax;
 470         int m;
 471         int bias;
 472         jas_cmreal_t scale;
 473         long v;
 474         jas_cmreal_t *bufptr;
 475
 476         if (xform->numinchans > in->numcmpts || xform->numoutchans > out->numcmpts)
 477                 goto error;
 478
 479         fmt = &in->cmptfmts[0];
 480         width = fmt->width;
 481         height = fmt->height;
 482         for (i = 1; i < xform->numinchans; ++i) {
 483                 fmt = &in->cmptfmts[i];
 484                 if (fmt->width != width || fmt->height != height) {
 485                         goto error;
 486                 }
 487         }
 488         for (i = 0; i < xform->numoutchans; ++i) {
 489                 fmt = &out->cmptfmts[i];
 490                 if (fmt->width != width || fmt->height != height) {
 491                         goto error;
 492                 }
 493         }
 494
 495         maxchans = 0;
 496         pxformseq = xform->pxformseq;
 497         for (i = 0; i < pxformseq->numpxforms; ++i) {
 498                 pxform = pxformseq->pxforms[i];
 499                 if (pxform->numinchans > maxchans) {
 500                         maxchans = pxform->numinchans;
 501                 }
 502                 if (pxform->numoutchans > maxchans) {
 503                         maxchans = pxform->numoutchans;
 504                 }
 505         }
 506         bufmax = APPLYBUFSIZ / maxchans;
 507         assert(bufmax > 0);
 508
 509         total = width * height;
 510         n = 0;
 511         while (n < total) {
 512
 513                 inbuf = &buf[0][0];
 514                 m = JAS_MIN(total - n, bufmax);
 515
 516                 for (i = 0; i < xform->numinchans; ++i) {
 517                         fmt = &in->cmptfmts[i];
 518                         scale = (double)((1 << fmt->prec) - 1);
 519                         bias = fmt->sgnd ? (1 << (fmt->prec - 1)) : 0;
 520                         dataptr = &fmt->buf[n];
 521                         bufptr = &inbuf[i];
 522                         for (j = 0; j < m; ++j) {
 523                                 if (jas_cmgetint(&dataptr, fmt->sgnd, fmt->prec, &v))
 524                                         goto error;
 525                                 *bufptr = (v - bias) / scale;
 526                                 bufptr += xform->numinchans;
 527                         }
 528                 }
 529
 530                 inbuf = &buf[0][0];
 531                 outbuf = inbuf;
 532                 for (i = 0; i < pxformseq->numpxforms; ++i) {
 533                         pxform = pxformseq->pxforms[i];
 534                         if (pxform->numoutchans > pxform->numinchans) {
 535                                 outbuf = (inbuf == &buf[0][0]) ? &buf[1][0] : &buf[0][0];
 536                         } else {
 537                                 outbuf = inbuf;
 538                         }
 539                         if ((*pxform->ops->apply)(pxform, inbuf, outbuf, m))
 540                                 goto error;
 541                         inbuf = outbuf;
 542                 }
 543
 544                 for (i = 0; i < xform->numoutchans; ++i) {
 545                         fmt = &out->cmptfmts[i];
 546                         scale = (double)((1 << fmt->prec) - 1);
 547                         bias = fmt->sgnd ? (1 << (fmt->prec - 1)) : 0;
 548                         bufptr = &outbuf[i];
 549                         dataptr = &fmt->buf[n];
 550                         for (j = 0; j < m; ++j) {
 551                                 v = (*bufptr) * scale + bias;
 552                                 bufptr += xform->numoutchans;
 553                                 if (jas_cmputint(&dataptr, fmt->sgnd, fmt->prec, v))
 554                                         goto error;
 555                         }
 556                 }
 557
 558                 n += m;
 559         }
 560
 561         return 0;
 562 error:
 563         return -1;
 564 }
 565
 566 void jas_cmxform_destroy(jas_cmxform_t *xform)
 567 {
 568         if (xform->pxformseq)
 569                 jas_cmpxformseq_destroy(xform->pxformseq);
 570         jas_free(xform);
 571 }
 572
 573 /******************************************************************************\
 574 * Primitive transform sequence class.
 575 \******************************************************************************/
 576
 577 static jas_cmpxformseq_t *jas_cmpxformseq_create()
 578 {
 579         jas_cmpxformseq_t *pxformseq;
 580         pxformseq = 0;
 581         if (!(pxformseq = jas_malloc(sizeof(jas_cmpxformseq_t))))
 582                 goto error;
 583         pxformseq->pxforms = 0;
 584         pxformseq->numpxforms = 0;
 585         pxformseq->maxpxforms = 0;
 586         if (jas_cmpxformseq_resize(pxformseq, 16))
 587                 goto error;
 588         return pxformseq;
 589 error:
 590         if (pxformseq)
 591                 jas_cmpxformseq_destroy(pxformseq);
 592         return 0;
 593 }
 594
 595 static jas_cmpxformseq_t *jas_cmpxformseq_copy(jas_cmpxformseq_t *pxformseq)
 596 {
 597         jas_cmpxformseq_t *newpxformseq;
 598
 599         if (!(newpxformseq = jas_cmpxformseq_create()))
 600                 goto error;
 601         if (jas_cmpxformseq_append(newpxformseq, pxformseq))
 602                 goto error;
 603         return newpxformseq;
 604 error:
 605         return 0;
 606 }
 607
 608 static void jas_cmpxformseq_destroy(jas_cmpxformseq_t *pxformseq)
 609 {
 610         while (pxformseq->numpxforms > 0)
 611                 jas_cmpxformseq_delete(pxformseq, pxformseq->numpxforms - 1);
 612         if (pxformseq->pxforms)
 613                 jas_free(pxformseq->pxforms);
 614         jas_free(pxformseq);
 615 }
 616
 617 static int jas_cmpxformseq_delete(jas_cmpxformseq_t *pxformseq, int i)
 618 {
 619         assert(i >= 0 && i < pxformseq->numpxforms);
 620         if (i != pxformseq->numpxforms - 1)
 621                 abort();
 622         jas_cmpxform_destroy(pxformseq->pxforms[i]);
 623         pxformseq->pxforms[i] = 0;
 624         --pxformseq->numpxforms;
 625         return 0;
 626 }
 627
 628 static int jas_cmpxformseq_appendcnvt(jas_cmpxformseq_t *pxformseq,
 629   int dstclrspc, int srcclrspc)
 630 {
 631         if (dstclrspc == srcclrspc)
 632                 return 0;
 633         abort();
 634         /* Avoid compiler warnings about unused parameters. */
 635         pxformseq = 0;
 636         return -1;
 637 }
 638
 639 static int jas_cmpxformseq_insertpxform(jas_cmpxformseq_t *pxformseq,
 640   int i, jas_cmpxform_t *pxform)
 641 {
 642         jas_cmpxform_t *tmppxform;
 643         int n;
 644         if (i < 0)
 645                 i = pxformseq->numpxforms;
 646         assert(i >= 0 && i <= pxformseq->numpxforms);
 647         if (pxformseq->numpxforms >= pxformseq->maxpxforms) {
 648                 if (jas_cmpxformseq_resize(pxformseq, pxformseq->numpxforms +
 649                   16))
 650                         goto error;
 651         }
 652         assert(pxformseq->numpxforms < pxformseq->maxpxforms);
 653         if (!(tmppxform = jas_cmpxform_copy(pxform)))
 654                 goto error;
 655         n = pxformseq->numpxforms - i;
 656         if (n > 0) {
 657                 memmove(&pxformseq->pxforms[i + 1], &pxformseq->pxforms[i],
 658                   n * sizeof(jas_cmpxform_t *));
 659         }
 660         pxformseq->pxforms[i] = tmppxform;
 661         ++pxformseq->numpxforms;
 662         return 0;
 663 error:
 664         return -1;
 665 }
 666
 667 static int jas_cmpxformseq_append(jas_cmpxformseq_t *pxformseq,
 668   jas_cmpxformseq_t *othpxformseq)
 669 {
 670         int n;
 671         int i;
 672         jas_cmpxform_t *pxform;
 673         jas_cmpxform_t *othpxform;
 674         n = pxformseq->numpxforms + othpxformseq->numpxforms;
 675         if (n > pxformseq->maxpxforms) {
 676                 if (jas_cmpxformseq_resize(pxformseq, n))
 677                         goto error;
 678         }
 679         for (i = 0; i < othpxformseq->numpxforms; ++i) {
 680                 othpxform = othpxformseq->pxforms[i];
 681                 if (!(pxform = jas_cmpxform_copy(othpxform)))
 682                         goto error;
 683                 pxformseq->pxforms[pxformseq->numpxforms] = pxform;
 684                 ++pxformseq->numpxforms;
 685         }
 686         return 0;
 687 error:
 688         return -1;
 689 }
 690
 691 static int jas_cmpxformseq_resize(jas_cmpxformseq_t *pxformseq, int n)
 692 {
 693         jas_cmpxform_t **p;
 694         assert(n >= pxformseq->numpxforms);
 695         p = (!pxformseq->pxforms) ? jas_malloc(n * sizeof(jas_cmpxform_t *)) :
 696           jas_realloc(pxformseq->pxforms, n * sizeof(jas_cmpxform_t *));
 697         if (!p) {
 698                 return -1;
 699         }
 700         pxformseq->pxforms = p;
 701         pxformseq->maxpxforms = n;
 702         return 0;
 703 }
 704
 705 /******************************************************************************\
 706 * Primitive transform class.
 707 \******************************************************************************/
 708
 709 static jas_cmpxform_t *jas_cmpxform_create0()
 710 {
 711         jas_cmpxform_t *pxform;
 712         if (!(pxform = jas_malloc(sizeof(jas_cmpxform_t))))
 713                 return 0;
 714         memset(pxform, 0, sizeof(jas_cmpxform_t));
 715         pxform->refcnt = 0;
 716         pxform->ops = 0;
 717         return pxform;
 718 }
 719
 720 static void jas_cmpxform_destroy(jas_cmpxform_t *pxform)
 721 {
 722         if (--pxform->refcnt <= 0) {
 723                 (*pxform->ops->destroy)(pxform);
 724                 jas_free(pxform);
 725         }
 726 }
 727
 728 static jas_cmpxform_t *jas_cmpxform_copy(jas_cmpxform_t *pxform)
 729 {
 730         ++pxform->refcnt;
 731         return pxform;
 732 }
 733
 734 /******************************************************************************\
 735 * Shaper matrix class.
 736 \******************************************************************************/
 737
 738 static jas_cmpxform_t *jas_cmpxform_createshapmat()
 739 {
 740         int i;
 741         int j;
 742         jas_cmpxform_t *pxform;
 743         jas_cmshapmat_t *shapmat;
 744         if (!(pxform = jas_cmpxform_create0()))
 745                 return 0;
 746         pxform->ops = &shapmat_ops;
 747         shapmat = &pxform->data.shapmat;
 748         shapmat->mono = 0;
 749         shapmat->order = 0;
 750         shapmat->useluts = 0;
 751         shapmat->usemat = 0;
 752         for (i = 0; i < 3; ++i)
 753                 jas_cmshapmatlut_init(&shapmat->luts[i]);
 754         for (i = 0; i < 3; ++i) {
 755                 for (j = 0; j < 4; ++j)
 756                         shapmat->mat[i][j] = 0.0;
 757         }
 758         ++pxform->refcnt;
 759         return pxform;
 760 }
 761
 762 static void jas_cmshapmat_destroy(jas_cmpxform_t *pxform)
 763 {
 764         jas_cmshapmat_t *shapmat = &pxform->data.shapmat;
 765         int i;
 766         for (i = 0; i < 3; ++i)
 767                 jas_cmshapmatlut_cleanup(&shapmat->luts[i]);
 768 }
 769
 770 static int jas_cmshapmat_apply(jas_cmpxform_t *pxform, jas_cmreal_t *in,
 771   jas_cmreal_t *out, int cnt)
 772 {
 773         jas_cmshapmat_t *shapmat = &pxform->data.shapmat;
 774         jas_cmreal_t *src;
 775         jas_cmreal_t *dst;
 776         jas_cmreal_t a0;
 777         jas_cmreal_t a1;
 778         jas_cmreal_t a2;
 779         jas_cmreal_t b0;
 780         jas_cmreal_t b1;
 781         jas_cmreal_t b2;
 782         src = in;
 783         dst = out;
 784         if (!shapmat->mono) {
 785                 while (--cnt >= 0) {
 786                         a0 = *src++;
 787                         a1 = *src++;
 788                         a2 = *src++;
 789                         if (!shapmat->order && shapmat->useluts) {
 790                                 a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
 791                                 a1 = jas_cmshapmatlut_lookup(&shapmat->luts[1], a1);
 792                                 a2 = jas_cmshapmatlut_lookup(&shapmat->luts[2], a2);
 793                         }
 794                         if (shapmat->usemat) {
 795                                 b0 = shapmat->mat[0][0] * a0
 796                                   + shapmat->mat[0][1] * a1
 797                                   + shapmat->mat[0][2] * a2
 798                                   + shapmat->mat[0][3];
 799                                 b1 = shapmat->mat[1][0] * a0
 800                                   + shapmat->mat[1][1] * a1
 801                                   + shapmat->mat[1][2] * a2
 802                                   + shapmat->mat[1][3];
 803                                 b2 = shapmat->mat[2][0] * a0
 804                                   + shapmat->mat[2][1] * a1
 805                                   + shapmat->mat[2][2] * a2
 806                                   + shapmat->mat[2][3];
 807                                 a0 = b0;
 808                                 a1 = b1;
 809                                 a2 = b2;
 810                         }
 811                         if (shapmat->order && shapmat->useluts) {
 812                                 a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
 813                                 a1 = jas_cmshapmatlut_lookup(&shapmat->luts[1], a1);
 814                                 a2 = jas_cmshapmatlut_lookup(&shapmat->luts[2], a2);
 815                         }
 816                         *dst++ = a0;
 817                         *dst++ = a1;
 818                         *dst++ = a2;
 819                 }
 820         } else {
 821                 if (!shapmat->order) {
 822                         while (--cnt >= 0) {
 823                                 a0 = *src++;
 824                                 if (shapmat->useluts)
 825                                         a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
 826                                 a2 = a0 * shapmat->mat[2][0];
 827                                 a1 = a0 * shapmat->mat[1][0];
 828                                 a0 = a0 * shapmat->mat[0][0];
 829                                 *dst++ = a0;
 830                                 *dst++ = a1;
 831                                 *dst++ = a2;
 832                         }
 833                 } else {
 834 assert(0);
 835                         while (--cnt >= 0) {
 836                                 a0 = *src++;
 837                                 src++;
 838                                 src++;
 839                                 a0 = a0 * shapmat->mat[0][0];
 840                                 if (shapmat->useluts)
 841                                         a0 = jas_cmshapmatlut_lookup(&shapmat->luts[0], a0);
 842                                 *dst++ = a0;
 843                         }
 844                 }
 845         }
 846
 847         return 0;
 848 }
 849
 850 static void jas_cmshapmatlut_init(jas_cmshapmatlut_t *lut)
 851 {
 852         lut->data = 0;
 853         lut->size = 0;
 854 }
 855
 856 static void jas_cmshapmatlut_cleanup(jas_cmshapmatlut_t *lut)
 857 {
 858         if (lut->data) {
 859                 jas_free(lut->data);
 860                 lut->data = 0;
 861         }
 862         lut->size = 0;
 863 }
 864
 865 static double gammafn(double x, double gamma)
 866 {
 867         if (x == 0.0)
 868                 return 0.0;
 869         return pow(x, gamma);
 870 }
 871
 872 static int jas_cmshapmatlut_set(jas_cmshapmatlut_t *lut, jas_icccurv_t *curv)
 873 {
 874         jas_cmreal_t gamma;
 875         int i;
 876         gamma = 0;
 877         jas_cmshapmatlut_cleanup(lut);
 878         if (curv->numents == 0) {
 879                 lut->size = 2;
 880                 if (!(lut->data = jas_malloc(lut->size * sizeof(jas_cmreal_t))))
 881                         goto error;
 882                 lut->data[0] = 0.0;
 883                 lut->data[1] = 1.0;
 884         } else if (curv->numents == 1) {
 885                 lut->size = 256;
 886                 if (!(lut->data = jas_malloc(lut->size * sizeof(jas_cmreal_t))))
 887                         goto error;
 888                 gamma = curv->ents[0] / 256.0;
 889                 for (i = 0; i < lut->size; ++i) {
 890                         lut->data[i] = gammafn(i / (double) (lut->size - 1), gamma);
 891                 }
 892         } else {
 893                 lut->size = curv->numents;
 894                 if (!(lut->data = jas_malloc(lut->size * sizeof(jas_cmreal_t))))
 895                         goto error;
 896                 for (i = 0; i < lut->size; ++i) {
 897                         lut->data[i] = curv->ents[i] / 65535.0;
 898                 }
 899         }
 900         return 0;
 901 error:
 902         return -1;
 903 }
 904
 905 static jas_cmreal_t jas_cmshapmatlut_lookup(jas_cmshapmatlut_t *lut, jas_cmreal_t x)
 906 {
 907         jas_cmreal_t t;
 908         int lo;
 909         int hi;
 910         t = x * (lut->size - 1);
 911         lo = floor(t);
 912         if (lo < 0)
 913                 return lut->data[0];
 914         hi = ceil(t);
 915         if (hi >= lut->size)
 916                 return lut->data[lut->size - 1];
 917         return lut->data[lo] + (t - lo) * (lut->data[hi] - lut->data[lo]);
 918 }
 919
 920 static int jas_cmshapmatlut_invert(jas_cmshapmatlut_t *invlut,
 921   jas_cmshapmatlut_t *lut, int n)
 922 {
 923         int i;
 924         int j;
 925         int k;
 926         jas_cmreal_t ax;
 927         jas_cmreal_t ay;
 928         jas_cmreal_t bx;
 929         jas_cmreal_t by;
 930         jas_cmreal_t sx;
 931         jas_cmreal_t sy;
 932         assert(n >= 2);
 933         if (invlut->data) {
 934                 jas_free(invlut->data);
 935                 invlut->data = 0;
 936         }
 937         /* The sample values should be nondecreasing. */
 938         for (i = 1; i < lut->size; ++i) {
 939                 if (lut->data[i - 1] > lut->data[i]) {
 940                         assert(0);
 941                         return -1;
 942                 }
 943         }
 944         if (!(invlut->data = jas_malloc(n * sizeof(jas_cmreal_t))))
 945                 return -1;
 946         invlut->size = n;
 947         for (i = 0; i < invlut->size; ++i) {
 948                 sy = ((double) i) / (invlut->size - 1);
 949                 sx = 1.0;
 950                 for (j = 0; j < lut->size; ++j) {
 951                         ay = lut->data[j];
 952                         if (sy == ay) {
 953                                 for (k = j + 1; k < lut->size; ++k) {
 954                                         by = lut->data[k];
 955                                         if (by != sy)
 956                                                 break;
 957 #if 0
 958 assert(0);
 959 #endif
 960                                 }
 961                                 if (k < lut->size) {
 962                                         --k;
 963                                         ax = ((double) j) / (lut->size - 1);
 964                                         bx = ((double) k) / (lut->size - 1);
 965                                         sx = (ax + bx) / 2.0;
 966                                 }
 967                                 break;
 968                         }
 969                         if (j < lut->size - 1) {
 970                                 by = lut->data[j + 1];
 971                                 if (sy > ay && sy < by) {
 972                                         ax = ((double) j) / (lut->size - 1);
 973                                         bx = ((double) j + 1) / (lut->size - 1);
 974                                         sx = ax +
 975                                           (sy - ay) / (by - ay) * (bx - ax);
 976                                         break;
 977                                 }
 978                         }
 979                 }
 980                 invlut->data[i] = sx;
 981         }
 982 #if 0
 983 for (i=0;i<lut->size;++i)
 984         fprintf(stderr, "lut[%d]=%f ", i, lut->data[i]);
 985 for (i=0;i<invlut->size;++i)
 986         fprintf(stderr, "invlut[%d]=%f ", i, invlut->data[i]);
 987 #endif
 988         return 0;
 989 }
 990
 991 static int jas_cmshapmat_invmat(jas_cmreal_t out[3][4], jas_cmreal_t in[3][4])
 992 {
 993         jas_cmreal_t d;
 994         d = in[0][0] * (in[1][1] * in[2][2] - in[1][2] * in[2][1])
 995           - in[0][1] * (in[1][0] * in[2][2] - in[1][2] * in[2][0])
 996           + in[0][2] * (in[1][0] * in[2][1] - in[1][1] * in[2][0]);
 997 #if 0
 998 fprintf(stderr, "delta=%f\n", d);
 999 #endif
1000         if (JAS_ABS(d) < 1e-6)
1001                 return -1;
1002         out[0][0] = (in[1][1] * in[2][2] - in[1][2] * in[2][1]) / d;
1003         out[1][0] = -(in[1][0] * in[2][2] - in[1][2] * in[2][0]) / d;
1004         out[2][0] = (in[1][0] * in[2][1] - in[1][1] * in[2][0]) / d;
1005         out[0][1] = -(in[0][1] * in[2][2] - in[0][2] * in[2][1]) / d;
1006         out[1][1] = (in[0][0] * in[2][2] - in[0][2] * in[2][0]) / d;
1007         out[2][1] = -(in[0][0] * in[2][1] - in[0][1] * in[2][0]) / d;
1008         out[0][2] = (in[0][1] * in[1][2] - in[0][2] * in[1][1]) / d;
1009         out[1][2] = -(in[0][0] * in[1][2] - in[1][0] * in[0][2]) / d;
1010         out[2][2] = (in[0][0] * in[1][1] - in[0][1] * in[1][0]) / d;
1011         out[0][3] = -in[0][3];
1012         out[1][3] = -in[1][3];
1013         out[2][3] = -in[2][3];
1014 #if 0
1015 fprintf(stderr, "[ %f %f %f %f ]\n[ %f %f %f %f ]\n[ %f %f %f %f ]\n",
1016 in[0][0], in[0][1], in[0][2], in[0][3],
1017 in[1][0], in[1][1], in[1][2], in[1][3],
1018 in[2][0], in[2][1], in[2][2], in[2][3]);
1019 fprintf(stderr, "[ %f %f %f %f ]\n[ %f %f %f %f ]\n[ %f %f %f %f ]\n",
1020 out[0][0], out[0][1], out[0][2], out[0][3],
1021 out[1][0], out[1][1], out[1][2], out[1][3],
1022 out[2][0], out[2][1], out[2][2], out[2][3]);
1023 #endif
1024         return 0;
1025 }
1026
1027 /******************************************************************************\
1028 *
1029 \******************************************************************************/
1030
1031 static int icctoclrspc(int iccclrspc, int refflag)
1032 {
1033         if (refflag) {
1034                 switch (iccclrspc) {
1035                 case JAS_ICC_COLORSPC_XYZ:
1036                         return JAS_CLRSPC_CIEXYZ;
1037                 case JAS_ICC_COLORSPC_LAB:
1038                         return JAS_CLRSPC_CIELAB;
1039                 default:
1040                         abort();
1041                         break;
1042                 }
1043         } else {
1044                 switch (iccclrspc) {
1045                 case JAS_ICC_COLORSPC_YCBCR:
1046                         return JAS_CLRSPC_GENYCBCR;
1047                 case JAS_ICC_COLORSPC_RGB:
1048                         return JAS_CLRSPC_GENRGB;
1049                 case JAS_ICC_COLORSPC_GRAY:
1050                         return JAS_CLRSPC_GENGRAY;
1051                 default:
1052                         abort();
1053                         break;
1054                 }
1055         }
1056 }
1057
1058 static int mono(jas_iccprof_t *iccprof, int op, jas_cmpxformseq_t **retpxformseq)
1059 {
1060         jas_iccattrval_t *graytrc;
1061         jas_cmshapmat_t *shapmat;
1062         jas_cmpxform_t *pxform;
1063         jas_cmpxformseq_t *pxformseq;
1064         jas_cmshapmatlut_t lut;
1065
1066         jas_cmshapmatlut_init(&lut);
1067         if (!(graytrc = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_GRYTRC)) ||
1068           graytrc->type != JAS_ICC_TYPE_CURV)
1069                 goto error;
1070         if (!(pxform = jas_cmpxform_createshapmat()))
1071                 goto error;
1072         shapmat = &pxform->data.shapmat;
1073         if (!(pxformseq = jas_cmpxformseq_create()))
1074                 goto error;
1075         if (jas_cmpxformseq_insertpxform(pxformseq, -1, pxform))
1076                 goto error;
1077
1078         pxform->numinchans = 1;
1079         pxform->numoutchans = 3;
1080
1081         shapmat->mono = 1;
1082         shapmat->useluts = 1;
1083         shapmat->usemat = 1;
1084         if (!op) {
1085                 shapmat->order = 0;
1086                 shapmat->mat[0][0] = 0.9642;
1087                 shapmat->mat[1][0] = 1.0;
1088                 shapmat->mat[2][0] = 0.8249;
1089                 if (jas_cmshapmatlut_set(&shapmat->luts[0], &graytrc->data.curv))
1090                         goto error;
1091         } else {
1092                 shapmat->order = 1;
1093                 shapmat->mat[0][0] = 1.0 / 0.9642;
1094                 shapmat->mat[1][0] = 1.0;
1095                 shapmat->mat[2][0] = 1.0 / 0.8249;
1096                 jas_cmshapmatlut_init(&lut);
1097                 if (jas_cmshapmatlut_set(&lut, &graytrc->data.curv))
1098                         goto error;
1099                 if (jas_cmshapmatlut_invert(&shapmat->luts[0], &lut, lut.size))
1100                         goto error;
1101                 jas_cmshapmatlut_cleanup(&lut);
1102         }
1103         jas_iccattrval_destroy(graytrc);
1104         jas_cmpxform_destroy(pxform);
1105         *retpxformseq = pxformseq;
1106         return 0;
1107 error:
1108         return -1;
1109 }
1110
1111 static int triclr(jas_iccprof_t *iccprof, int op, jas_cmpxformseq_t **retpxformseq)
1112 {
1113         int i;
1114         jas_iccattrval_t *trcs[3];
1115         jas_iccattrval_t *cols[3];
1116         jas_cmshapmat_t *shapmat;
1117         jas_cmpxform_t *pxform;
1118         jas_cmpxformseq_t *pxformseq;
1119         jas_cmreal_t mat[3][4];
1120         jas_cmshapmatlut_t lut;
1121         jas_cmshapmatlut_init(&lut);
1122         for (i = 0; i < 3; ++i) {
1123                 trcs[i] = 0;
1124                 cols[i] = 0;
1125         }
1126         if (!(trcs[0] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_REDTRC)) ||
1127           !(trcs[1] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_GRNTRC)) ||
1128           !(trcs[2] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_BLUTRC)) ||
1129           !(cols[0] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_REDMATCOL)) ||
1130           !(cols[1] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_GRNMATCOL)) ||
1131           !(cols[2] = jas_iccprof_getattr(iccprof, JAS_ICC_TAG_BLUMATCOL)))
1132                 goto error;
1133         for (i = 0; i < 3; ++i) {
1134                 if (trcs[i]->type != JAS_ICC_TYPE_CURV ||
1135                   cols[i]->type != JAS_ICC_TYPE_XYZ)
1136                         goto error;
1137         }
1138         if (!(pxform = jas_cmpxform_createshapmat()))
1139                 goto error;
1140         pxform->numinchans = 3;
1141         pxform->numoutchans = 3;
1142         shapmat = &pxform->data.shapmat;
1143         if (!(pxformseq = jas_cmpxformseq_create()))
1144                 goto error;
1145         if (jas_cmpxformseq_insertpxform(pxformseq, -1, pxform))
1146                 goto error;
1147         shapmat->mono = 0;
1148         shapmat->useluts = 1;
1149         shapmat->usemat = 1;
1150         if (!op) {
1151                 shapmat->order = 0;
1152                 for (i = 0; i < 3; ++i) {
1153                         shapmat->mat[0][i] = cols[i]->data.xyz.x / 65536.0;
1154                         shapmat->mat[1][i] = cols[i]->data.xyz.y / 65536.0;
1155                         shapmat->mat[2][i] = cols[i]->data.xyz.z / 65536.0;
1156                 }
1157                 for (i = 0; i < 3; ++i)
1158                         shapmat->mat[i][3] = 0.0;
1159                 for (i = 0; i < 3; ++i) {
1160                         if (jas_cmshapmatlut_set(&shapmat->luts[i], &trcs[i]->data.curv))
1161                                 goto error;
1162                 }
1163         } else {
1164                 shapmat->order = 1;
1165                 for (i = 0; i < 3; ++i) {
1166                         mat[0][i] = cols[i]->data.xyz.x / 65536.0;
1167                         mat[1][i] = cols[i]->data.xyz.y / 65536.0;
1168                         mat[2][i] = cols[i]->data.xyz.z / 65536.0;
1169                 }
1170                 for (i = 0; i < 3; ++i)
1171                         mat[i][3] = 0.0;
1172                 if (jas_cmshapmat_invmat(shapmat->mat, mat))
1173                         goto error;
1174                 for (i = 0; i < 3; ++i) {
1175                         jas_cmshapmatlut_init(&lut);
1176                         if (jas_cmshapmatlut_set(&lut, &trcs[i]->data.curv))
1177                                 goto error;
1178                         if (jas_cmshapmatlut_invert(&shapmat->luts[i], &lut, lut.size))
1179                                 goto error;
1180                         jas_cmshapmatlut_cleanup(&lut);
1181                 }
1182         }
1183         for (i = 0; i < 3; ++i) {
1184                 jas_iccattrval_destroy(trcs[i]);
1185                 jas_iccattrval_destroy(cols[i]);
1186         }
1187         jas_cmpxform_destroy(pxform);
1188         *retpxformseq = pxformseq;
1189         return 0;
1190 error:
1191         return -1;
1192 }
1193
1194 static int jas_cmgetint(long **bufptr, int sgnd, int prec, long *val)
1195 {
1196         long v;
1197         int m;
1198         v = **bufptr;
1199         if (sgnd) {
1200                 m = (1 << (prec - 1));
1201                 if (v < -m || v >= m)
1202                         return -1;
1203         } else {
1204                 if (v < 0 || v >= (1 << prec))
1205                         return -1;
1206         }
1207         ++(*bufptr);
1208         *val = v;
1209         return 0;
1210 }
1211
1212 static int jas_cmputint(long **bufptr, int sgnd, int prec, long val)
1213 {
1214         int m;
1215         if (sgnd) {
1216                 m = (1 << (prec - 1));
1217                 if (val < -m || val >= m)
1218                         return -1;
1219         } else {
1220                 if (val < 0 || val >= (1 << prec))
1221                         return -1;
1222         }
1223         **bufptr = val;
1224         ++(*bufptr);
1225         return 0;
1226 }
1227
1228 int jas_clrspc_numchans(int clrspc)
1229 {
1230         switch (jas_clrspc_fam(clrspc)) {
1231         case JAS_CLRSPC_FAM_XYZ:
1232         case JAS_CLRSPC_FAM_LAB:
1233         case JAS_CLRSPC_FAM_RGB:
1234         case JAS_CLRSPC_FAM_YCBCR:
1235                 return 3;
1236                 break;
1237         case JAS_CLRSPC_FAM_GRAY:
1238                 return 1;
1239                 break;
1240         default:
1241                 abort();
1242                 break;
1243         }
1244 }
1245
1246 jas_iccprof_t *jas_iccprof_createfromcmprof(jas_cmprof_t *prof)
1247 {
1248         return jas_iccprof_copy(prof->iccprof);
1249 }