git.maemo.org Git - opencv/blob - otherlibs/_graphics/src/libjasper/jas_icc.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) 2001-2006 Michael David Adams
  11  * Copyright (c) 1999-2000 Image Power, Inc.
  12  * Copyright (c) 1999-2000 The University of British Columbia
  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 #include <assert.h>
  63 #include <jasper/jas_config.h>
  64 #include <jasper/jas_types.h>
  65 #include <jasper/jas_malloc.h>
  66 #include <jasper/jas_debug.h>
  67 #include <jasper/jas_icc.h>
  68 #include <jasper/jas_cm.h>
  69 #include <jasper/jas_stream.h>
  70 #include <jasper/jas_string.h>
  71
  72 #include <stdlib.h>
  73 #include <ctype.h>
  74
  75 #define jas_iccputuint8(out, val)       jas_iccputuint(out, 1, val)
  76 #define jas_iccputuint16(out, val)      jas_iccputuint(out, 2, val)
  77 #define jas_iccputsint32(out, val)      jas_iccputsint(out, 4, val)
  78 #define jas_iccputuint32(out, val)      jas_iccputuint(out, 4, val)
  79 #define jas_iccputuint64(out, val)      jas_iccputuint(out, 8, val)
  80
  81 static jas_iccattrval_t *jas_iccattrval_create0(void);
  82
  83 static int jas_iccgetuint(jas_stream_t *in, int n, ulonglong *val);
  84 static int jas_iccgetuint8(jas_stream_t *in, jas_iccuint8_t *val);
  85 static int jas_iccgetuint16(jas_stream_t *in, jas_iccuint16_t *val);
  86 static int jas_iccgetsint32(jas_stream_t *in, jas_iccsint32_t *val);
  87 static int jas_iccgetuint32(jas_stream_t *in, jas_iccuint32_t *val);
  88 static int jas_iccgetuint64(jas_stream_t *in, jas_iccuint64_t *val);
  89 static int jas_iccputuint(jas_stream_t *out, int n, ulonglong val);
  90 static int jas_iccputsint(jas_stream_t *out, int n, longlong val);
  91 static jas_iccprof_t *jas_iccprof_create(void);
  92 static int jas_iccprof_readhdr(jas_stream_t *in, jas_icchdr_t *hdr);
  93 static int jas_iccprof_writehdr(jas_stream_t *out, jas_icchdr_t *hdr);
  94 static int jas_iccprof_gettagtab(jas_stream_t *in, jas_icctagtab_t *tagtab);
  95 static void jas_iccprof_sorttagtab(jas_icctagtab_t *tagtab);
  96 static int jas_iccattrtab_lookup(jas_iccattrtab_t *attrtab, jas_iccuint32_t name);
  97 static jas_iccattrtab_t *jas_iccattrtab_copy(jas_iccattrtab_t *attrtab);
  98 static jas_iccattrvalinfo_t *jas_iccattrvalinfo_lookup(jas_iccsig_t name);
  99 static int jas_iccgettime(jas_stream_t *in, jas_icctime_t *time);
 100 static int jas_iccgetxyz(jas_stream_t *in, jas_iccxyz_t *xyz);
 101 static int jas_icctagtabent_cmp(const void *src, const void *dst);
 102
 103 static void jas_icccurv_destroy(jas_iccattrval_t *attrval);
 104 static int jas_icccurv_copy(jas_iccattrval_t *attrval,
 105   jas_iccattrval_t *othattrval);
 106 static int jas_icccurv_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 107   int cnt);
 108 static int jas_icccurv_getsize(jas_iccattrval_t *attrval);
 109 static int jas_icccurv_output(jas_iccattrval_t *attrval, jas_stream_t *out);
 110 static void jas_icccurv_dump(jas_iccattrval_t *attrval, FILE *out);
 111
 112 static void jas_icctxtdesc_destroy(jas_iccattrval_t *attrval);
 113 static int jas_icctxtdesc_copy(jas_iccattrval_t *attrval,
 114   jas_iccattrval_t *othattrval);
 115 static int jas_icctxtdesc_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 116   int cnt);
 117 static int jas_icctxtdesc_getsize(jas_iccattrval_t *attrval);
 118 static int jas_icctxtdesc_output(jas_iccattrval_t *attrval, jas_stream_t *out);
 119 static void jas_icctxtdesc_dump(jas_iccattrval_t *attrval, FILE *out);
 120
 121 static void jas_icctxt_destroy(jas_iccattrval_t *attrval);
 122 static int jas_icctxt_copy(jas_iccattrval_t *attrval,
 123   jas_iccattrval_t *othattrval);
 124 static int jas_icctxt_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 125   int cnt);
 126 static int jas_icctxt_getsize(jas_iccattrval_t *attrval);
 127 static int jas_icctxt_output(jas_iccattrval_t *attrval, jas_stream_t *out);
 128 static void jas_icctxt_dump(jas_iccattrval_t *attrval, FILE *out);
 129
 130 static int jas_iccxyz_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 131   int cnt);
 132 static int jas_iccxyz_getsize(jas_iccattrval_t *attrval);
 133 static int jas_iccxyz_output(jas_iccattrval_t *attrval, jas_stream_t *out);
 134 static void jas_iccxyz_dump(jas_iccattrval_t *attrval, FILE *out);
 135
 136 static jas_iccattrtab_t *jas_iccattrtab_create(void);
 137 static void jas_iccattrtab_destroy(jas_iccattrtab_t *tab);
 138 static int jas_iccattrtab_resize(jas_iccattrtab_t *tab, int maxents);
 139 static int jas_iccattrtab_add(jas_iccattrtab_t *attrtab, int i,
 140   jas_iccuint32_t name, jas_iccattrval_t *val);
 141 static int jas_iccattrtab_replace(jas_iccattrtab_t *attrtab, int i,
 142   jas_iccuint32_t name, jas_iccattrval_t *val);
 143 static void jas_iccattrtab_delete(jas_iccattrtab_t *attrtab, int i);
 144 static long jas_iccpadtomult(long x, long y);
 145 static int jas_iccattrtab_get(jas_iccattrtab_t *attrtab, int i,
 146   jas_iccattrname_t *name, jas_iccattrval_t **val);
 147 static int jas_iccprof_puttagtab(jas_stream_t *out, jas_icctagtab_t *tagtab);
 148
 149 static void jas_icclut16_destroy(jas_iccattrval_t *attrval);
 150 static int jas_icclut16_copy(jas_iccattrval_t *attrval,
 151   jas_iccattrval_t *othattrval);
 152 static int jas_icclut16_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 153   int cnt);
 154 static int jas_icclut16_getsize(jas_iccattrval_t *attrval);
 155 static int jas_icclut16_output(jas_iccattrval_t *attrval, jas_stream_t *out);
 156 static void jas_icclut16_dump(jas_iccattrval_t *attrval, FILE *out);
 157
 158 static void jas_icclut8_destroy(jas_iccattrval_t *attrval);
 159 static int jas_icclut8_copy(jas_iccattrval_t *attrval,
 160   jas_iccattrval_t *othattrval);
 161 static int jas_icclut8_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 162   int cnt);
 163 static int jas_icclut8_getsize(jas_iccattrval_t *attrval);
 164 static int jas_icclut8_output(jas_iccattrval_t *attrval, jas_stream_t *out);
 165 static void jas_icclut8_dump(jas_iccattrval_t *attrval, FILE *out);
 166
 167 static int jas_iccputtime(jas_stream_t *out, jas_icctime_t *ctime);
 168 static int jas_iccputxyz(jas_stream_t *out, jas_iccxyz_t *xyz);
 169
 170 static long jas_iccpowi(int x, int n);
 171
 172 static char *jas_iccsigtostr(int sig, char *buf);
 173
 174
 175 jas_iccattrvalinfo_t jas_iccattrvalinfos[] = {
 176         {JAS_ICC_TYPE_CURV, {jas_icccurv_destroy, jas_icccurv_copy,
 177           jas_icccurv_input, jas_icccurv_output, jas_icccurv_getsize,
 178           jas_icccurv_dump}},
 179         {JAS_ICC_TYPE_XYZ, {0, 0, jas_iccxyz_input, jas_iccxyz_output,
 180           jas_iccxyz_getsize, jas_iccxyz_dump}},
 181         {JAS_ICC_TYPE_TXTDESC, {jas_icctxtdesc_destroy,
 182           jas_icctxtdesc_copy, jas_icctxtdesc_input, jas_icctxtdesc_output,
 183           jas_icctxtdesc_getsize, jas_icctxtdesc_dump}},
 184         {JAS_ICC_TYPE_TXT, {jas_icctxt_destroy, jas_icctxt_copy,
 185           jas_icctxt_input, jas_icctxt_output, jas_icctxt_getsize,
 186           jas_icctxt_dump}},
 187         {JAS_ICC_TYPE_LUT8, {jas_icclut8_destroy, jas_icclut8_copy,
 188           jas_icclut8_input, jas_icclut8_output, jas_icclut8_getsize,
 189           jas_icclut8_dump}},
 190         {JAS_ICC_TYPE_LUT16, {jas_icclut16_destroy, jas_icclut16_copy,
 191           jas_icclut16_input, jas_icclut16_output, jas_icclut16_getsize,
 192           jas_icclut16_dump}},
 193         {0, {0, 0, 0, 0, 0, 0}}
 194 };
 195
 196 typedef struct {
 197         jas_iccuint32_t tag;
 198         char *name;
 199 } jas_icctaginfo_t;
 200
 201 /******************************************************************************\
 202 * profile class
 203 \******************************************************************************/
 204
 205 static jas_iccprof_t *jas_iccprof_create()
 206 {
 207         jas_iccprof_t *prof;
 208         prof = 0;
 209         if (!(prof = jas_malloc(sizeof(jas_iccprof_t)))) {
 210                 goto error;
 211         }
 212         if (!(prof->attrtab = jas_iccattrtab_create()))
 213                 goto error;
 214         memset(&prof->hdr, 0, sizeof(jas_icchdr_t));
 215         prof->tagtab.numents = 0;
 216         prof->tagtab.ents = 0;
 217         return prof;
 218 error:
 219         if (prof)
 220                 jas_iccprof_destroy(prof);
 221         return 0;
 222 }
 223
 224 jas_iccprof_t *jas_iccprof_copy(jas_iccprof_t *prof)
 225 {
 226         jas_iccprof_t *newprof;
 227         newprof = 0;
 228         if (!(newprof = jas_iccprof_create()))
 229                 goto error;
 230         newprof->hdr = prof->hdr;
 231         newprof->tagtab.numents = 0;
 232         newprof->tagtab.ents = 0;
 233         assert(newprof->attrtab);
 234         jas_iccattrtab_destroy(newprof->attrtab);
 235         if (!(newprof->attrtab = jas_iccattrtab_copy(prof->attrtab)))
 236                 goto error;
 237         return newprof;
 238 error:
 239         if (newprof)
 240                 jas_iccprof_destroy(newprof);
 241         return 0;
 242 }
 243
 244 void jas_iccprof_destroy(jas_iccprof_t *prof)
 245 {
 246         if (prof->attrtab)
 247                 jas_iccattrtab_destroy(prof->attrtab);
 248         if (prof->tagtab.ents)
 249                 jas_free(prof->tagtab.ents);
 250         jas_free(prof);
 251 }
 252
 253 void jas_iccprof_dump(jas_iccprof_t *prof, FILE *out)
 254 {
 255         jas_iccattrtab_dump(prof->attrtab, out);
 256 }
 257
 258 jas_iccprof_t *jas_iccprof_load(jas_stream_t *in)
 259 {
 260         jas_iccprof_t *prof;
 261         int numtags;
 262         long curoff;
 263         long reloff;
 264         long prevoff;
 265         jas_iccsig_t type;
 266         jas_iccattrval_t *attrval;
 267         jas_iccattrval_t *prevattrval;
 268         jas_icctagtabent_t *tagtabent;
 269         jas_iccattrvalinfo_t *attrvalinfo;
 270         int i;
 271         int len;
 272
 273         prof = 0;
 274         attrval = 0;
 275
 276         if (!(prof = jas_iccprof_create())) {
 277                 goto error;
 278         }
 279
 280         if (jas_iccprof_readhdr(in, &prof->hdr)) {
 281                 jas_eprintf("cannot get header\n");
 282                 goto error;
 283         }
 284         if (jas_iccprof_gettagtab(in, &prof->tagtab)) {
 285                 jas_eprintf("cannot get tab table\n");
 286                 goto error;
 287         }
 288         jas_iccprof_sorttagtab(&prof->tagtab);
 289
 290         numtags = prof->tagtab.numents;
 291         curoff = JAS_ICC_HDRLEN + 4 + 12 * numtags;
 292         prevoff = 0;
 293         prevattrval = 0;
 294         for (i = 0; i < numtags; ++i) {
 295                 tagtabent = &prof->tagtab.ents[i];
 296                 if (tagtabent->off == JAS_CAST(jas_iccuint32_t, prevoff)) {
 297                         if (prevattrval) {
 298                                 if (!(attrval = jas_iccattrval_clone(prevattrval)))
 299                                         goto error;
 300                                 if (jas_iccprof_setattr(prof, tagtabent->tag, attrval))
 301                                         goto error;
 302                                 jas_iccattrval_destroy(attrval);
 303                         } else {
 304 #if 0
 305                                 jas_eprintf("warning: skipping unknown tag type\n");
 306 #endif
 307                         }
 308                         continue;
 309                 }
 310                 reloff = tagtabent->off - curoff;
 311                 if (reloff > 0) {
 312                         if (jas_stream_gobble(in, reloff) != reloff)
 313                                 goto error;
 314                         curoff += reloff;
 315                 } else if (reloff < 0) {
 316                         /* This should never happen since we read the tagged
 317                         element data in a single pass. */
 318                         abort();
 319                 }
 320                 prevoff = curoff;
 321                 if (jas_iccgetuint32(in, &type)) {
 322                         goto error;
 323                 }
 324                 if (jas_stream_gobble(in, 4) != 4) {
 325                         goto error;
 326                 }
 327                 curoff += 8;
 328                 if (!(attrvalinfo = jas_iccattrvalinfo_lookup(type))) {
 329 #if 0
 330                         jas_eprintf("warning: skipping unknown tag type\n");
 331 #endif
 332                         prevattrval = 0;
 333                         continue;
 334                 }
 335                 if (!(attrval = jas_iccattrval_create(type))) {
 336                         goto error;
 337                 }
 338                 len = tagtabent->len - 8;
 339                 if ((*attrval->ops->input)(attrval, in, len)) {
 340                         goto error;
 341                 }
 342                 curoff += len;
 343                 if (jas_iccprof_setattr(prof, tagtabent->tag, attrval)) {
 344                         goto error;
 345                 }
 346                 prevattrval = attrval; /* This is correct, but slimey. */
 347                 jas_iccattrval_destroy(attrval);
 348                 attrval = 0;
 349         }
 350
 351         return prof;
 352
 353 error:
 354         if (prof)
 355                 jas_iccprof_destroy(prof);
 356         if (attrval)
 357                 jas_iccattrval_destroy(attrval);
 358         return 0;
 359 }
 360
 361 int jas_iccprof_save(jas_iccprof_t *prof, jas_stream_t *out)
 362 {
 363         long curoff;
 364         long reloff;
 365         long newoff;
 366         int i;
 367         int j;
 368         jas_icctagtabent_t *tagtabent;
 369         jas_icctagtabent_t *sharedtagtabent;
 370         jas_icctagtabent_t *tmptagtabent;
 371         jas_iccuint32_t attrname;
 372         jas_iccattrval_t *attrval;
 373         jas_icctagtab_t *tagtab;
 374
 375         tagtab = &prof->tagtab;
 376         if (!(tagtab->ents = jas_malloc(prof->attrtab->numattrs *
 377           sizeof(jas_icctagtabent_t))))
 378                 goto error;
 379         tagtab->numents = prof->attrtab->numattrs;
 380         curoff = JAS_ICC_HDRLEN + 4 + 12 * tagtab->numents;
 381         for (i = 0; i < JAS_CAST(int, tagtab->numents); ++i) {
 382                 tagtabent = &tagtab->ents[i];
 383                 if (jas_iccattrtab_get(prof->attrtab, i, &attrname, &attrval))
 384                         goto error;
 385                 assert(attrval->ops->output);
 386                 tagtabent->tag = attrname;
 387                 tagtabent->data = &attrval->data;
 388                 sharedtagtabent = 0;
 389                 for (j = 0; j < i; ++j) {
 390                         tmptagtabent = &tagtab->ents[j];
 391                         if (tagtabent->data == tmptagtabent->data) {
 392                                 sharedtagtabent = tmptagtabent;
 393                                 break;
 394                         }
 395                 }
 396                 if (sharedtagtabent) {
 397                         tagtabent->off = sharedtagtabent->off;
 398                         tagtabent->len = sharedtagtabent->len;
 399                         tagtabent->first = sharedtagtabent;
 400                 } else {
 401                         tagtabent->off = curoff;
 402                         tagtabent->len = (*attrval->ops->getsize)(attrval) + 8;
 403                         tagtabent->first = 0;
 404                         if (i < JAS_CAST(int, tagtab->numents - 1)) {
 405                                 curoff = jas_iccpadtomult(curoff + tagtabent->len, 4);
 406                         } else {
 407                                 curoff += tagtabent->len;
 408                         }
 409                 }
 410                 jas_iccattrval_destroy(attrval);
 411         }
 412         prof->hdr.size = curoff;
 413         if (jas_iccprof_writehdr(out, &prof->hdr))
 414                 goto error;
 415         if (jas_iccprof_puttagtab(out, &prof->tagtab))
 416                 goto error;
 417         curoff = JAS_ICC_HDRLEN + 4 + 12 * tagtab->numents;
 418         for (i = 0; i < JAS_CAST(int, tagtab->numents);) {
 419                 tagtabent = &tagtab->ents[i];
 420                 assert(curoff == JAS_CAST(long, tagtabent->off));
 421                 if (jas_iccattrtab_get(prof->attrtab, i, &attrname, &attrval))
 422                         goto error;
 423                 if (jas_iccputuint32(out, attrval->type) || jas_stream_pad(out,
 424                   4, 0) != 4)
 425                         goto error;
 426                 if ((*attrval->ops->output)(attrval, out))
 427                         goto error;
 428                 jas_iccattrval_destroy(attrval);
 429                 curoff += tagtabent->len;
 430                 ++i;
 431                 while (i < JAS_CAST(int, tagtab->numents) &&
 432                   tagtab->ents[i].first)
 433                         ++i;
 434                 newoff = (i < JAS_CAST(int, tagtab->numents)) ?
 435                   tagtab->ents[i].off : prof->hdr.size;
 436                 reloff = newoff - curoff;
 437                 assert(reloff >= 0);
 438                 if (reloff > 0) {
 439                         if (jas_stream_pad(out, reloff, 0) != reloff)
 440                                 goto error;
 441                         curoff += reloff;
 442                 }
 443         }
 444         return 0;
 445 error:
 446         /* XXX - need to free some resources here */
 447         return -1;
 448 }
 449
 450 static int jas_iccprof_writehdr(jas_stream_t *out, jas_icchdr_t *hdr)
 451 {
 452         if (jas_iccputuint32(out, hdr->size) ||
 453           jas_iccputuint32(out, hdr->cmmtype) ||
 454           jas_iccputuint32(out, hdr->version) ||
 455           jas_iccputuint32(out, hdr->clas) ||
 456           jas_iccputuint32(out, hdr->colorspc) ||
 457           jas_iccputuint32(out, hdr->refcolorspc) ||
 458           jas_iccputtime(out, &hdr->ctime) ||
 459           jas_iccputuint32(out, hdr->magic) ||
 460           jas_iccputuint32(out, hdr->platform) ||
 461           jas_iccputuint32(out, hdr->flags) ||
 462           jas_iccputuint32(out, hdr->maker) ||
 463           jas_iccputuint32(out, hdr->model) ||
 464           jas_iccputuint64(out, hdr->attr) ||
 465           jas_iccputuint32(out, hdr->intent) ||
 466           jas_iccputxyz(out, &hdr->illum) ||
 467           jas_iccputuint32(out, hdr->creator) ||
 468           jas_stream_pad(out, 44, 0) != 44)
 469                 return -1;
 470         return 0;
 471 }
 472
 473 static int jas_iccprof_puttagtab(jas_stream_t *out, jas_icctagtab_t *tagtab)
 474 {
 475         int i;
 476         jas_icctagtabent_t *tagtabent;
 477         if (jas_iccputuint32(out, tagtab->numents))
 478                 goto error;
 479         for (i = 0; i < JAS_CAST(int, tagtab->numents); ++i) {
 480                 tagtabent = &tagtab->ents[i];
 481                 if (jas_iccputuint32(out, tagtabent->tag) ||
 482                   jas_iccputuint32(out, tagtabent->off) ||
 483                   jas_iccputuint32(out, tagtabent->len))
 484                         goto error;
 485         }
 486         return 0;
 487 error:
 488         return -1;
 489 }
 490
 491 static int jas_iccprof_readhdr(jas_stream_t *in, jas_icchdr_t *hdr)
 492 {
 493         if (jas_iccgetuint32(in, &hdr->size) ||
 494           jas_iccgetuint32(in, &hdr->cmmtype) ||
 495           jas_iccgetuint32(in, &hdr->version) ||
 496           jas_iccgetuint32(in, &hdr->clas) ||
 497           jas_iccgetuint32(in, &hdr->colorspc) ||
 498           jas_iccgetuint32(in, &hdr->refcolorspc) ||
 499           jas_iccgettime(in, &hdr->ctime) ||
 500           jas_iccgetuint32(in, &hdr->magic) ||
 501           jas_iccgetuint32(in, &hdr->platform) ||
 502           jas_iccgetuint32(in, &hdr->flags) ||
 503           jas_iccgetuint32(in, &hdr->maker) ||
 504           jas_iccgetuint32(in, &hdr->model) ||
 505           jas_iccgetuint64(in, &hdr->attr) ||
 506           jas_iccgetuint32(in, &hdr->intent) ||
 507           jas_iccgetxyz(in, &hdr->illum) ||
 508           jas_iccgetuint32(in, &hdr->creator) ||
 509           jas_stream_gobble(in, 44) != 44)
 510                 return -1;
 511         return 0;
 512 }
 513
 514 static int jas_iccprof_gettagtab(jas_stream_t *in, jas_icctagtab_t *tagtab)
 515 {
 516         int i;
 517         jas_icctagtabent_t *tagtabent;
 518
 519         if (tagtab->ents) {
 520                 jas_free(tagtab->ents);
 521                 tagtab->ents = 0;
 522         }
 523         if (jas_iccgetuint32(in, &tagtab->numents))
 524                 goto error;
 525         if (!(tagtab->ents = jas_malloc(tagtab->numents *
 526           sizeof(jas_icctagtabent_t))))
 527                 goto error;
 528         tagtabent = tagtab->ents;
 529         for (i = 0; i < JAS_CAST(long, tagtab->numents); ++i) {
 530                 if (jas_iccgetuint32(in, &tagtabent->tag) ||
 531                 jas_iccgetuint32(in, &tagtabent->off) ||
 532                 jas_iccgetuint32(in, &tagtabent->len))
 533                         goto error;
 534                 ++tagtabent;
 535         }
 536         return 0;
 537 error:
 538         if (tagtab->ents) {
 539                 jas_free(tagtab->ents);
 540                 tagtab->ents = 0;
 541         }
 542         return -1;
 543 }
 544
 545 jas_iccattrval_t *jas_iccprof_getattr(jas_iccprof_t *prof,
 546   jas_iccattrname_t name)
 547 {
 548         int i;
 549         jas_iccattrval_t *attrval;
 550         if ((i = jas_iccattrtab_lookup(prof->attrtab, name)) < 0)
 551                 goto error;
 552         if (!(attrval = jas_iccattrval_clone(prof->attrtab->attrs[i].val)))
 553                 goto error;
 554         return attrval;
 555 error:
 556         return 0;
 557 }
 558
 559 int jas_iccprof_setattr(jas_iccprof_t *prof, jas_iccattrname_t name,
 560   jas_iccattrval_t *val)
 561 {
 562         int i;
 563         if ((i = jas_iccattrtab_lookup(prof->attrtab, name)) >= 0) {
 564                 if (val) {
 565                         if (jas_iccattrtab_replace(prof->attrtab, i, name, val))
 566                                 goto error;
 567                 } else {
 568                         jas_iccattrtab_delete(prof->attrtab, i);
 569                 }
 570         } else {
 571                 if (val) {
 572                         if (jas_iccattrtab_add(prof->attrtab, -1, name, val))
 573                                 goto error;
 574                 } else {
 575                         /* NOP */
 576                 }
 577         }
 578         return 0;
 579 error:
 580         return -1;
 581 }
 582
 583 int jas_iccprof_gethdr(jas_iccprof_t *prof, jas_icchdr_t *hdr)
 584 {
 585         *hdr = prof->hdr;
 586         return 0;
 587 }
 588
 589 int jas_iccprof_sethdr(jas_iccprof_t *prof, jas_icchdr_t *hdr)
 590 {
 591         prof->hdr = *hdr;
 592         return 0;
 593 }
 594
 595 static void jas_iccprof_sorttagtab(jas_icctagtab_t *tagtab)
 596 {
 597         qsort(tagtab->ents, tagtab->numents, sizeof(jas_icctagtabent_t),
 598           jas_icctagtabent_cmp);
 599 }
 600
 601 static int jas_icctagtabent_cmp(const void *src, const void *dst)
 602 {
 603         jas_icctagtabent_t *srctagtabent = JAS_CAST(jas_icctagtabent_t *, src);
 604         jas_icctagtabent_t *dsttagtabent = JAS_CAST(jas_icctagtabent_t *, dst);
 605         if (srctagtabent->off > dsttagtabent->off) {
 606                 return 1;
 607         } else if (srctagtabent->off < dsttagtabent->off) {
 608                 return -1;
 609         }
 610         return 0;
 611 }
 612
 613 static jas_iccattrvalinfo_t *jas_iccattrvalinfo_lookup(jas_iccsig_t type)
 614 {
 615         jas_iccattrvalinfo_t *info;
 616         info = jas_iccattrvalinfos;
 617         for (info = jas_iccattrvalinfos; info->type; ++info) {
 618                 if (info->type == type) {
 619                         return info;
 620                 }
 621         }
 622         return 0;
 623 }
 624
 625 static int jas_iccgettime(jas_stream_t *in, jas_icctime_t *time)
 626 {
 627         if (jas_iccgetuint16(in, &time->year) ||
 628           jas_iccgetuint16(in, &time->month) ||
 629           jas_iccgetuint16(in, &time->day) ||
 630           jas_iccgetuint16(in, &time->hour) ||
 631           jas_iccgetuint16(in, &time->min) ||
 632           jas_iccgetuint16(in, &time->sec)) {
 633                 return -1;
 634         }
 635         return 0;
 636 }
 637
 638 static int jas_iccgetxyz(jas_stream_t *in, jas_iccxyz_t *xyz)
 639 {
 640         if (jas_iccgetsint32(in, &xyz->x) ||
 641           jas_iccgetsint32(in, &xyz->y) ||
 642           jas_iccgetsint32(in, &xyz->z)) {
 643                 return -1;
 644         }
 645         return 0;
 646 }
 647
 648 static int jas_iccputtime(jas_stream_t *out, jas_icctime_t *time)
 649 {
 650         jas_iccputuint16(out, time->year);
 651         jas_iccputuint16(out, time->month);
 652         jas_iccputuint16(out, time->day);
 653         jas_iccputuint16(out, time->hour);
 654         jas_iccputuint16(out, time->min);
 655         jas_iccputuint16(out, time->sec);
 656         return 0;
 657 }
 658
 659 static int jas_iccputxyz(jas_stream_t *out, jas_iccxyz_t *xyz)
 660 {
 661         jas_iccputuint32(out, xyz->x);
 662         jas_iccputuint32(out, xyz->y);
 663         jas_iccputuint32(out, xyz->z);
 664         return 0;
 665 }
 666
 667 /******************************************************************************\
 668 * attribute table class
 669 \******************************************************************************/
 670
 671 static jas_iccattrtab_t *jas_iccattrtab_create()
 672 {
 673         jas_iccattrtab_t *tab;
 674         tab = 0;
 675         if (!(tab = jas_malloc(sizeof(jas_iccattrtab_t))))
 676                 goto error;
 677         tab->maxattrs = 0;
 678         tab->numattrs = 0;
 679         tab->attrs = 0;
 680         if (jas_iccattrtab_resize(tab, 32))
 681                 goto error;
 682         return tab;
 683 error:
 684         if (tab)
 685                 jas_iccattrtab_destroy(tab);
 686         return 0;
 687 }
 688
 689 static jas_iccattrtab_t *jas_iccattrtab_copy(jas_iccattrtab_t *attrtab)
 690 {
 691         jas_iccattrtab_t *newattrtab;
 692         int i;
 693         if (!(newattrtab = jas_iccattrtab_create()))
 694                 goto error;
 695         for (i = 0; i < attrtab->numattrs; ++i) {
 696                 if (jas_iccattrtab_add(newattrtab, i, attrtab->attrs[i].name,
 697                   attrtab->attrs[i].val))
 698                         goto error;
 699         }
 700         return newattrtab;
 701 error:
 702         return 0;
 703 }
 704
 705 static void jas_iccattrtab_destroy(jas_iccattrtab_t *tab)
 706 {
 707         if (tab->attrs) {
 708                 while (tab->numattrs > 0) {
 709                         jas_iccattrtab_delete(tab, 0);
 710                 }
 711                 jas_free(tab->attrs);
 712         }
 713         jas_free(tab);
 714 }
 715
 716 void jas_iccattrtab_dump(jas_iccattrtab_t *attrtab, FILE *out)
 717 {
 718         int i;
 719         jas_iccattr_t *attr;
 720         jas_iccattrval_t *attrval;
 721         jas_iccattrvalinfo_t *info;
 722         char buf[16];
 723         fprintf(out, "numattrs=%d\n", attrtab->numattrs);
 724         fprintf(out, "---\n");
 725         for (i = 0; i < attrtab->numattrs; ++i) {
 726                 attr = &attrtab->attrs[i];
 727                 attrval = attr->val;
 728                 info = jas_iccattrvalinfo_lookup(attrval->type);
 729                 if (!info) abort();
 730                 fprintf(out, "attrno=%d; attrname=\"%s\"(0x%08x); attrtype=\"%s\"(0x%08x)\n",
 731                   i,
 732                   jas_iccsigtostr(attr->name, &buf[0]),
 733                   attr->name,
 734                   jas_iccsigtostr(attrval->type, &buf[8]),
 735                   attrval->type
 736                   );
 737                 jas_iccattrval_dump(attrval, out);
 738                 fprintf(out, "---\n");
 739         }
 740 }
 741
 742 static int jas_iccattrtab_resize(jas_iccattrtab_t *tab, int maxents)
 743 {
 744         jas_iccattr_t *newattrs;
 745         assert(maxents >= tab->numattrs);
 746         newattrs = tab->attrs ? jas_realloc(tab->attrs, maxents *
 747           sizeof(jas_iccattr_t)) : jas_malloc(maxents * sizeof(jas_iccattr_t));
 748         if (!newattrs)
 749                 return -1;
 750         tab->attrs = newattrs;
 751         tab->maxattrs = maxents;
 752         return 0;
 753 }
 754
 755 static int jas_iccattrtab_add(jas_iccattrtab_t *attrtab, int i,
 756   jas_iccuint32_t name, jas_iccattrval_t *val)
 757 {
 758         int n;
 759         jas_iccattr_t *attr;
 760         jas_iccattrval_t *tmpattrval;
 761         tmpattrval = 0;
 762         if (i < 0) {
 763                 i = attrtab->numattrs;
 764         }
 765         assert(i >= 0 && i <= attrtab->numattrs);
 766         if (attrtab->numattrs >= attrtab->maxattrs) {
 767                 if (jas_iccattrtab_resize(attrtab, attrtab->numattrs + 32)) {
 768                         goto error;
 769                 }
 770         }
 771         if (!(tmpattrval = jas_iccattrval_clone(val)))
 772                 goto error;
 773         n = attrtab->numattrs - i;
 774         if (n > 0)
 775                 memmove(&attrtab->attrs[i + 1], &attrtab->attrs[i],
 776                   n * sizeof(jas_iccattr_t));
 777         attr = &attrtab->attrs[i];
 778         attr->name = name;
 779         attr->val = tmpattrval;
 780         ++attrtab->numattrs;
 781         return 0;
 782 error:
 783         if (tmpattrval)
 784                 jas_iccattrval_destroy(tmpattrval);
 785         return -1;
 786 }
 787
 788 static int jas_iccattrtab_replace(jas_iccattrtab_t *attrtab, int i,
 789   jas_iccuint32_t name, jas_iccattrval_t *val)
 790 {
 791         jas_iccattrval_t *newval;
 792         jas_iccattr_t *attr;
 793         if (!(newval = jas_iccattrval_clone(val)))
 794                 goto error;
 795         attr = &attrtab->attrs[i];
 796         jas_iccattrval_destroy(attr->val);
 797         attr->name = name;
 798         attr->val = newval;
 799         return 0;
 800 error:
 801         return -1;
 802 }
 803
 804 static void jas_iccattrtab_delete(jas_iccattrtab_t *attrtab, int i)
 805 {
 806         int n;
 807         jas_iccattrval_destroy(attrtab->attrs[i].val);
 808         if ((n = attrtab->numattrs - i - 1) > 0)
 809                 memmove(&attrtab->attrs[i], &attrtab->attrs[i + 1],
 810                   n * sizeof(jas_iccattr_t));
 811         --attrtab->numattrs;
 812 }
 813
 814 static int jas_iccattrtab_get(jas_iccattrtab_t *attrtab, int i,
 815   jas_iccattrname_t *name, jas_iccattrval_t **val)
 816 {
 817         jas_iccattr_t *attr;
 818         if (i < 0 || i >= attrtab->numattrs)
 819                 goto error;
 820         attr = &attrtab->attrs[i];
 821         *name = attr->name;
 822         if (!(*val = jas_iccattrval_clone(attr->val)))
 823                 goto error;
 824         return 0;
 825 error:
 826         return -1;
 827 }
 828
 829 static int jas_iccattrtab_lookup(jas_iccattrtab_t *attrtab,
 830   jas_iccuint32_t name)
 831 {
 832         int i;
 833         jas_iccattr_t *attr;
 834         for (i = 0; i < attrtab->numattrs; ++i) {
 835                 attr = &attrtab->attrs[i];
 836                 if (attr->name == name)
 837                         return i;
 838         }
 839         return -1;
 840 }
 841
 842 /******************************************************************************\
 843 * attribute value class
 844 \******************************************************************************/
 845
 846 jas_iccattrval_t *jas_iccattrval_create(jas_iccuint32_t type)
 847 {
 848         jas_iccattrval_t *attrval;
 849         jas_iccattrvalinfo_t *info;
 850
 851         if (!(info = jas_iccattrvalinfo_lookup(type)))
 852                 goto error;
 853         if (!(attrval = jas_iccattrval_create0()))
 854                 goto error;
 855         attrval->ops = &info->ops;
 856         attrval->type = type;
 857         ++attrval->refcnt;
 858         memset(&attrval->data, 0, sizeof(attrval->data));
 859         return attrval;
 860 error:
 861         return 0;
 862 }
 863
 864 jas_iccattrval_t *jas_iccattrval_clone(jas_iccattrval_t *attrval)
 865 {
 866         ++attrval->refcnt;
 867         return attrval;
 868 }
 869
 870 void jas_iccattrval_destroy(jas_iccattrval_t *attrval)
 871 {
 872 #if 0
 873 jas_eprintf("refcnt=%d\n", attrval->refcnt);
 874 #endif
 875         if (--attrval->refcnt <= 0) {
 876                 if (attrval->ops->destroy)
 877                         (*attrval->ops->destroy)(attrval);
 878                 jas_free(attrval);
 879         }
 880 }
 881
 882 void jas_iccattrval_dump(jas_iccattrval_t *attrval, FILE *out)
 883 {
 884         char buf[8];
 885         jas_iccsigtostr(attrval->type, buf);
 886         fprintf(out, "refcnt = %d; type = 0x%08x %s\n", attrval->refcnt,
 887           attrval->type, jas_iccsigtostr(attrval->type, &buf[0]));
 888         if (attrval->ops->dump) {
 889                 (*attrval->ops->dump)(attrval, out);
 890         }
 891 }
 892
 893 int jas_iccattrval_allowmodify(jas_iccattrval_t **attrvalx)
 894 {
 895         jas_iccattrval_t *newattrval;
 896         jas_iccattrval_t *attrval = *attrvalx;
 897         newattrval = 0;
 898         if (attrval->refcnt > 1) {
 899                 if (!(newattrval = jas_iccattrval_create0()))
 900                         goto error;
 901                 newattrval->ops = attrval->ops;
 902                 newattrval->type = attrval->type;
 903                 ++newattrval->refcnt;
 904                 if (newattrval->ops->copy) {
 905                         if ((*newattrval->ops->copy)(newattrval, attrval))
 906                                 goto error;
 907                 } else {
 908                         memcpy(&newattrval->data, &attrval->data,
 909                           sizeof(newattrval->data));
 910                 }
 911                 *attrvalx = newattrval;
 912         }
 913         return 0;
 914 error:
 915         if (newattrval) {
 916                 jas_free(newattrval);
 917         }
 918         return -1;
 919 }
 920
 921 static jas_iccattrval_t *jas_iccattrval_create0()
 922 {
 923         jas_iccattrval_t *attrval;
 924         if (!(attrval = jas_malloc(sizeof(jas_iccattrval_t))))
 925                 return 0;
 926         memset(attrval, 0, sizeof(jas_iccattrval_t));
 927         attrval->refcnt = 0;
 928         attrval->ops = 0;
 929         attrval->type = 0;
 930         return attrval;
 931 }
 932
 933 /******************************************************************************\
 934 *
 935 \******************************************************************************/
 936
 937 static int jas_iccxyz_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 938   int len)
 939 {
 940         if (len != 4 * 3) abort();
 941         return jas_iccgetxyz(in, &attrval->data.xyz);
 942 }
 943
 944 static int jas_iccxyz_output(jas_iccattrval_t *attrval, jas_stream_t *out)
 945 {
 946         jas_iccxyz_t *xyz = &attrval->data.xyz;
 947         if (jas_iccputuint32(out, xyz->x) ||
 948           jas_iccputuint32(out, xyz->y) ||
 949           jas_iccputuint32(out, xyz->z))
 950                 return -1;
 951         return 0;
 952 }
 953
 954 static int jas_iccxyz_getsize(jas_iccattrval_t *attrval)
 955 {
 956         /* Avoid compiler warnings about unused parameters. */
 957         attrval = 0;
 958
 959         return 12;
 960 }
 961
 962 static void jas_iccxyz_dump(jas_iccattrval_t *attrval, FILE *out)
 963 {
 964         jas_iccxyz_t *xyz = &attrval->data.xyz;
 965         fprintf(out, "(%f, %f, %f)\n", xyz->x / 65536.0, xyz->y / 65536.0, xyz->z / 65536.0);
 966 }
 967
 968 /******************************************************************************\
 969 * attribute table class
 970 \******************************************************************************/
 971
 972 static void jas_icccurv_destroy(jas_iccattrval_t *attrval)
 973 {
 974         jas_icccurv_t *curv = &attrval->data.curv;
 975         if (curv->ents)
 976                 jas_free(curv->ents);
 977 }
 978
 979 static int jas_icccurv_copy(jas_iccattrval_t *attrval,
 980   jas_iccattrval_t *othattrval)
 981 {
 982         /* Avoid compiler warnings about unused parameters. */
 983         attrval = 0;
 984         othattrval = 0;
 985
 986         /* Not yet implemented. */
 987         abort();
 988         return -1;
 989 }
 990
 991 static int jas_icccurv_input(jas_iccattrval_t *attrval, jas_stream_t *in,
 992   int cnt)
 993 {
 994         jas_icccurv_t *curv = &attrval->data.curv;
 995         unsigned int i;
 996
 997         curv->numents = 0;
 998         curv->ents = 0;
 999
1000         if (jas_iccgetuint32(in, &curv->numents))
1001                 goto error;
1002         if (!(curv->ents = jas_malloc(curv->numents * sizeof(jas_iccuint16_t))))
1003                 goto error;
1004         for (i = 0; i < curv->numents; ++i) {
1005                 if (jas_iccgetuint16(in, &curv->ents[i]))
1006                         goto error;
1007         }
1008
1009         if (JAS_CAST(int, 4 + 2 * curv->numents) != cnt)
1010                 goto error;
1011         return 0;
1012
1013 error:
1014         jas_icccurv_destroy(attrval);
1015         return -1;
1016 }
1017
1018 static int jas_icccurv_getsize(jas_iccattrval_t *attrval)
1019 {
1020         jas_icccurv_t *curv = &attrval->data.curv;
1021         return 4 + 2 * curv->numents;
1022 }
1023
1024 static int jas_icccurv_output(jas_iccattrval_t *attrval, jas_stream_t *out)
1025 {
1026         jas_icccurv_t *curv = &attrval->data.curv;
1027         unsigned int i;
1028
1029         if (jas_iccputuint32(out, curv->numents))
1030                 goto error;
1031         for (i = 0; i < curv->numents; ++i) {
1032                 if (jas_iccputuint16(out, curv->ents[i]))
1033                         goto error;
1034         }
1035         return 0;
1036 error:
1037         return -1;
1038 }
1039
1040 static void jas_icccurv_dump(jas_iccattrval_t *attrval, FILE *out)
1041 {
1042         int i;
1043         jas_icccurv_t *curv = &attrval->data.curv;
1044         fprintf(out, "number of entires = %d\n", curv->numents);
1045         if (curv->numents == 1) {
1046                 fprintf(out, "gamma = %f\n", curv->ents[0] / 256.0);
1047         } else {
1048                 for (i = 0; i < JAS_CAST(int, curv->numents); ++i) {
1049                         if (i < 3 || i >= JAS_CAST(int, curv->numents) - 3) {
1050                                 fprintf(out, "entry[%d] = %f\n", i, curv->ents[i] / 65535.0);
1051                         }
1052                 }
1053         }
1054 }
1055
1056 /******************************************************************************\
1057 *
1058 \******************************************************************************/
1059
1060 static void jas_icctxtdesc_destroy(jas_iccattrval_t *attrval)
1061 {
1062         jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
1063         if (txtdesc->ascdata)
1064                 jas_free(txtdesc->ascdata);
1065         if (txtdesc->ucdata)
1066                 jas_free(txtdesc->ucdata);
1067 }
1068
1069 static int jas_icctxtdesc_copy(jas_iccattrval_t *attrval,
1070   jas_iccattrval_t *othattrval)
1071 {
1072         jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
1073
1074         /* Avoid compiler warnings about unused parameters. */
1075         attrval = 0;
1076         othattrval = 0;
1077         txtdesc = 0;
1078
1079         /* Not yet implemented. */
1080         abort();
1081         return -1;
1082 }
1083
1084 static int jas_icctxtdesc_input(jas_iccattrval_t *attrval, jas_stream_t *in,
1085   int cnt)
1086 {
1087         int n;
1088         int c;
1089         jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
1090         txtdesc->ascdata = 0;
1091         txtdesc->ucdata = 0;
1092         if (jas_iccgetuint32(in, &txtdesc->asclen))
1093                 goto error;
1094         if (!(txtdesc->ascdata = jas_malloc(txtdesc->asclen)))
1095                 goto error;
1096         if (jas_stream_read(in, txtdesc->ascdata, txtdesc->asclen) !=
1097           JAS_CAST(int, txtdesc->asclen))
1098                 goto error;
1099         txtdesc->ascdata[txtdesc->asclen - 1] = '\0';
1100         if (jas_iccgetuint32(in, &txtdesc->uclangcode) ||
1101           jas_iccgetuint32(in, &txtdesc->uclen))
1102                 goto error;
1103         if (!(txtdesc->ucdata = jas_malloc(txtdesc->uclen * 2)))
1104                 goto error;
1105         if (jas_stream_read(in, txtdesc->ucdata, txtdesc->uclen * 2) !=
1106           JAS_CAST(int, txtdesc->uclen * 2))
1107                 goto error;
1108         if (jas_iccgetuint16(in, &txtdesc->sccode))
1109                 goto error;
1110         if ((c = jas_stream_getc(in)) == EOF)
1111                 goto error;
1112         txtdesc->maclen = c;
1113         if (jas_stream_read(in, txtdesc->macdata, 67) != 67)
1114                 goto error;
1115         txtdesc->asclen = strlen(txtdesc->ascdata) + 1;
1116 #define WORKAROUND_BAD_PROFILES
1117 #ifdef WORKAROUND_BAD_PROFILES
1118         n = txtdesc->asclen + txtdesc->uclen * 2 + 15 + 67;
1119         if (n > cnt) {
1120                 return -1;
1121         }
1122         if (n < cnt) {
1123                 if (jas_stream_gobble(in, cnt - n) != cnt - n)
1124                         goto error;
1125         }
1126 #else
1127         if (txtdesc->asclen + txtdesc->uclen * 2 + 15 + 67 != cnt)
1128                 return -1;
1129 #endif
1130         return 0;
1131 error:
1132         jas_icctxtdesc_destroy(attrval);
1133         return -1;
1134 }
1135
1136 static int jas_icctxtdesc_getsize(jas_iccattrval_t *attrval)
1137 {
1138         jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
1139         return strlen(txtdesc->ascdata) + 1 + txtdesc->uclen * 2 + 15 + 67;
1140 }
1141
1142 static int jas_icctxtdesc_output(jas_iccattrval_t *attrval, jas_stream_t *out)
1143 {
1144         jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
1145         if (jas_iccputuint32(out, txtdesc->asclen) ||
1146           jas_stream_puts(out, txtdesc->ascdata) ||
1147           jas_stream_putc(out, 0) == EOF ||
1148           jas_iccputuint32(out, txtdesc->uclangcode) ||
1149           jas_iccputuint32(out, txtdesc->uclen) ||
1150           jas_stream_write(out, txtdesc->ucdata, txtdesc->uclen * 2) != JAS_CAST(int, txtdesc->uclen * 2) ||
1151           jas_iccputuint16(out, txtdesc->sccode) ||
1152           jas_stream_putc(out, txtdesc->maclen) == EOF)
1153                 goto error;
1154         if (txtdesc->maclen > 0) {
1155                 if (jas_stream_write(out, txtdesc->macdata, 67) != 67)
1156                         goto error;
1157         } else {
1158                 if (jas_stream_pad(out, 67, 0) != 67)
1159                         goto error;
1160         }
1161         return 0;
1162 error:
1163         return -1;
1164 }
1165
1166 static void jas_icctxtdesc_dump(jas_iccattrval_t *attrval, FILE *out)
1167 {
1168         jas_icctxtdesc_t *txtdesc = &attrval->data.txtdesc;
1169         fprintf(out, "ascii = \"%s\"\n", txtdesc->ascdata);
1170         fprintf(out, "uclangcode = %d; uclen = %d\n", txtdesc->uclangcode,
1171           txtdesc->uclen);
1172         fprintf(out, "sccode = %d\n", txtdesc->sccode);
1173         fprintf(out, "maclen = %d\n", txtdesc->maclen);
1174 }
1175
1176 /******************************************************************************\
1177 *
1178 \******************************************************************************/
1179
1180 static void jas_icctxt_destroy(jas_iccattrval_t *attrval)
1181 {
1182         jas_icctxt_t *txt = &attrval->data.txt;
1183         if (txt->string)
1184                 jas_free(txt->string);
1185 }
1186
1187 static int jas_icctxt_copy(jas_iccattrval_t *attrval,
1188   jas_iccattrval_t *othattrval)
1189 {
1190         jas_icctxt_t *txt = &attrval->data.txt;
1191         jas_icctxt_t *othtxt = &othattrval->data.txt;
1192         if (!(txt->string = jas_strdup(othtxt->string)))
1193                 return -1;
1194         return 0;
1195 }
1196
1197 static int jas_icctxt_input(jas_iccattrval_t *attrval, jas_stream_t *in,
1198   int cnt)
1199 {
1200         jas_icctxt_t *txt = &attrval->data.txt;
1201         txt->string = 0;
1202         if (!(txt->string = jas_malloc(cnt)))
1203                 goto error;
1204         if (jas_stream_read(in, txt->string, cnt) != cnt)
1205                 goto error;
1206         txt->string[cnt - 1] = '\0';
1207         if (JAS_CAST(int, strlen(txt->string)) + 1 != cnt)
1208                 goto error;
1209         return 0;
1210 error:
1211         if (txt->string)
1212                 jas_free(txt->string);
1213         return -1;
1214 }
1215
1216 static int jas_icctxt_getsize(jas_iccattrval_t *attrval)
1217 {
1218         jas_icctxt_t *txt = &attrval->data.txt;
1219         return strlen(txt->string) + 1;
1220 }
1221
1222 static int jas_icctxt_output(jas_iccattrval_t *attrval, jas_stream_t *out)
1223 {
1224         jas_icctxt_t *txt = &attrval->data.txt;
1225         if (jas_stream_puts(out, txt->string) ||
1226           jas_stream_putc(out, 0) == EOF)
1227                 return -1;
1228         return 0;
1229 }
1230
1231 static void jas_icctxt_dump(jas_iccattrval_t *attrval, FILE *out)
1232 {
1233         jas_icctxt_t *txt = &attrval->data.txt;
1234         fprintf(out, "string = \"%s\"\n", txt->string);
1235 }
1236
1237 /******************************************************************************\
1238 *
1239 \******************************************************************************/
1240
1241 static void jas_icclut8_destroy(jas_iccattrval_t *attrval)
1242 {
1243         jas_icclut8_t *lut8 = &attrval->data.lut8;
1244         if (lut8->clut)
1245                 jas_free(lut8->clut);
1246         if (lut8->intabs)
1247                 jas_free(lut8->intabs);
1248         if (lut8->intabsbuf)
1249                 jas_free(lut8->intabsbuf);
1250         if (lut8->outtabs)
1251                 jas_free(lut8->outtabs);
1252         if (lut8->outtabsbuf)
1253                 jas_free(lut8->outtabsbuf);
1254 }
1255
1256 static int jas_icclut8_copy(jas_iccattrval_t *attrval,
1257   jas_iccattrval_t *othattrval)
1258 {
1259         jas_icclut8_t *lut8 = &attrval->data.lut8;
1260         /* Avoid compiler warnings about unused parameters. */
1261         attrval = 0;
1262         othattrval = 0;
1263         lut8 = 0;
1264         abort();
1265         return -1;
1266 }
1267
1268 static int jas_icclut8_input(jas_iccattrval_t *attrval, jas_stream_t *in,
1269   int cnt)
1270 {
1271         int i;
1272         int j;
1273         int clutsize;
1274         jas_icclut8_t *lut8 = &attrval->data.lut8;
1275         lut8->clut = 0;
1276         lut8->intabs = 0;
1277         lut8->intabsbuf = 0;
1278         lut8->outtabs = 0;
1279         lut8->outtabsbuf = 0;
1280         if (jas_iccgetuint8(in, &lut8->numinchans) ||
1281           jas_iccgetuint8(in, &lut8->numoutchans) ||
1282           jas_iccgetuint8(in, &lut8->clutlen) ||
1283           jas_stream_getc(in) == EOF)
1284                 goto error;
1285         for (i = 0; i < 3; ++i) {
1286                 for (j = 0; j < 3; ++j) {
1287                         if (jas_iccgetsint32(in, &lut8->e[i][j]))
1288                                 goto error;
1289                 }
1290         }
1291         if (jas_iccgetuint16(in, &lut8->numintabents) ||
1292           jas_iccgetuint16(in, &lut8->numouttabents))
1293                 goto error;
1294         clutsize = jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans;
1295         if (!(lut8->clut = jas_malloc(clutsize * sizeof(jas_iccuint8_t))) ||
1296           !(lut8->intabsbuf = jas_malloc(lut8->numinchans *
1297           lut8->numintabents * sizeof(jas_iccuint8_t))) ||
1298           !(lut8->intabs = jas_malloc(lut8->numinchans *
1299           sizeof(jas_iccuint8_t *))))
1300                 goto error;
1301         for (i = 0; i < lut8->numinchans; ++i)
1302                 lut8->intabs[i] = &lut8->intabsbuf[i * lut8->numintabents];
1303         if (!(lut8->outtabsbuf = jas_malloc(lut8->numoutchans *
1304           lut8->numouttabents * sizeof(jas_iccuint8_t))) ||
1305           !(lut8->outtabs = jas_malloc(lut8->numoutchans *
1306           sizeof(jas_iccuint8_t *))))
1307                 goto error;
1308         for (i = 0; i < lut8->numoutchans; ++i)
1309                 lut8->outtabs[i] = &lut8->outtabsbuf[i * lut8->numouttabents];
1310         for (i = 0; i < lut8->numinchans; ++i) {
1311                 for (j = 0; j < JAS_CAST(int, lut8->numintabents); ++j) {
1312                         if (jas_iccgetuint8(in, &lut8->intabs[i][j]))
1313                                 goto error;
1314                 }
1315         }
1316         for (i = 0; i < lut8->numoutchans; ++i) {
1317                 for (j = 0; j < JAS_CAST(int, lut8->numouttabents); ++j) {
1318                         if (jas_iccgetuint8(in, &lut8->outtabs[i][j]))
1319                                 goto error;
1320                 }
1321         }
1322         for (i = 0; i < clutsize; ++i) {
1323                 if (jas_iccgetuint8(in, &lut8->clut[i]))
1324                         goto error;
1325         }
1326         if (JAS_CAST(int, 44 + lut8->numinchans * lut8->numintabents +
1327           lut8->numoutchans * lut8->numouttabents +
1328           jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans) !=
1329           cnt)
1330                 goto error;
1331         return 0;
1332 error:
1333         jas_icclut8_destroy(attrval);
1334         return -1;
1335 }
1336
1337 static int jas_icclut8_getsize(jas_iccattrval_t *attrval)
1338 {
1339         jas_icclut8_t *lut8 = &attrval->data.lut8;
1340         return 44 + lut8->numinchans * lut8->numintabents +
1341           lut8->numoutchans * lut8->numouttabents +
1342           jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans;
1343 }
1344
1345 static int jas_icclut8_output(jas_iccattrval_t *attrval, jas_stream_t *out)
1346 {
1347         jas_icclut8_t *lut8 = &attrval->data.lut8;
1348         int i;
1349         int j;
1350         int n;
1351         lut8->clut = 0;
1352         lut8->intabs = 0;
1353         lut8->intabsbuf = 0;
1354         lut8->outtabs = 0;
1355         lut8->outtabsbuf = 0;
1356         if (jas_stream_putc(out, lut8->numinchans) == EOF ||
1357           jas_stream_putc(out, lut8->numoutchans) == EOF ||
1358           jas_stream_putc(out, lut8->clutlen) == EOF ||
1359           jas_stream_putc(out, 0) == EOF)
1360                 goto error;
1361         for (i = 0; i < 3; ++i) {
1362                 for (j = 0; j < 3; ++j) {
1363                         if (jas_iccputsint32(out, lut8->e[i][j]))
1364                                 goto error;
1365                 }
1366         }
1367         if (jas_iccputuint16(out, lut8->numintabents) ||
1368           jas_iccputuint16(out, lut8->numouttabents))
1369                 goto error;
1370         n = lut8->numinchans * lut8->numintabents;
1371         for (i = 0; i < n; ++i) {
1372                 if (jas_iccputuint8(out, lut8->intabsbuf[i]))
1373                         goto error;
1374         }
1375         n = lut8->numoutchans * lut8->numouttabents;
1376         for (i = 0; i < n; ++i) {
1377                 if (jas_iccputuint8(out, lut8->outtabsbuf[i]))
1378                         goto error;
1379         }
1380         n = jas_iccpowi(lut8->clutlen, lut8->numinchans) * lut8->numoutchans;
1381         for (i = 0; i < n; ++i) {
1382                 if (jas_iccputuint8(out, lut8->clut[i]))
1383                         goto error;
1384         }
1385         return 0;
1386 error:
1387         return -1;
1388 }
1389
1390 static void jas_icclut8_dump(jas_iccattrval_t *attrval, FILE *out)
1391 {
1392         jas_icclut8_t *lut8 = &attrval->data.lut8;
1393         int i;
1394         int j;
1395         fprintf(out, "numinchans=%d, numoutchans=%d, clutlen=%d\n",
1396           lut8->numinchans, lut8->numoutchans, lut8->clutlen);
1397         for (i = 0; i < 3; ++i) {
1398                 for (j = 0; j < 3; ++j) {
1399                         fprintf(out, "e[%d][%d]=%f ", i, j, lut8->e[i][j] / 65536.0);
1400                 }
1401                 fprintf(out, "\n");
1402         }
1403         fprintf(out, "numintabents=%d, numouttabents=%d\n",
1404           lut8->numintabents, lut8->numouttabents);
1405 }
1406
1407 /******************************************************************************\
1408 *
1409 \******************************************************************************/
1410
1411 static void jas_icclut16_destroy(jas_iccattrval_t *attrval)
1412 {
1413         jas_icclut16_t *lut16 = &attrval->data.lut16;
1414         if (lut16->clut)
1415                 jas_free(lut16->clut);
1416         if (lut16->intabs)
1417                 jas_free(lut16->intabs);
1418         if (lut16->intabsbuf)
1419                 jas_free(lut16->intabsbuf);
1420         if (lut16->outtabs)
1421                 jas_free(lut16->outtabs);
1422         if (lut16->outtabsbuf)
1423                 jas_free(lut16->outtabsbuf);
1424 }
1425
1426 static int jas_icclut16_copy(jas_iccattrval_t *attrval,
1427   jas_iccattrval_t *othattrval)
1428 {
1429         /* Avoid compiler warnings about unused parameters. */
1430         attrval = 0;
1431         othattrval = 0;
1432         /* Not yet implemented. */
1433         abort();
1434         return -1;
1435 }
1436
1437 static int jas_icclut16_input(jas_iccattrval_t *attrval, jas_stream_t *in,
1438   int cnt)
1439 {
1440         int i;
1441         int j;
1442         int clutsize;
1443         jas_icclut16_t *lut16 = &attrval->data.lut16;
1444         lut16->clut = 0;
1445         lut16->intabs = 0;
1446         lut16->intabsbuf = 0;
1447         lut16->outtabs = 0;
1448         lut16->outtabsbuf = 0;
1449         if (jas_iccgetuint8(in, &lut16->numinchans) ||
1450           jas_iccgetuint8(in, &lut16->numoutchans) ||
1451           jas_iccgetuint8(in, &lut16->clutlen) ||
1452           jas_stream_getc(in) == EOF)
1453                 goto error;
1454         for (i = 0; i < 3; ++i) {
1455                 for (j = 0; j < 3; ++j) {
1456                         if (jas_iccgetsint32(in, &lut16->e[i][j]))
1457                                 goto error;
1458                 }
1459         }
1460         if (jas_iccgetuint16(in, &lut16->numintabents) ||
1461           jas_iccgetuint16(in, &lut16->numouttabents))
1462                 goto error;
1463         clutsize = jas_iccpowi(lut16->clutlen, lut16->numinchans) * lut16->numoutchans;
1464         if (!(lut16->clut = jas_malloc(clutsize * sizeof(jas_iccuint16_t))) ||
1465           !(lut16->intabsbuf = jas_malloc(lut16->numinchans *
1466           lut16->numintabents * sizeof(jas_iccuint16_t))) ||
1467           !(lut16->intabs = jas_malloc(lut16->numinchans *
1468           sizeof(jas_iccuint16_t *))))
1469                 goto error;
1470         for (i = 0; i < lut16->numinchans; ++i)
1471                 lut16->intabs[i] = &lut16->intabsbuf[i * lut16->numintabents];
1472         if (!(lut16->outtabsbuf = jas_malloc(lut16->numoutchans *
1473           lut16->numouttabents * sizeof(jas_iccuint16_t))) ||
1474           !(lut16->outtabs = jas_malloc(lut16->numoutchans *
1475           sizeof(jas_iccuint16_t *))))
1476                 goto error;
1477         for (i = 0; i < lut16->numoutchans; ++i)
1478                 lut16->outtabs[i] = &lut16->outtabsbuf[i * lut16->numouttabents];
1479         for (i = 0; i < lut16->numinchans; ++i) {
1480                 for (j = 0; j < JAS_CAST(int, lut16->numintabents); ++j) {
1481                         if (jas_iccgetuint16(in, &lut16->intabs[i][j]))
1482                                 goto error;
1483                 }
1484         }
1485         for (i = 0; i < lut16->numoutchans; ++i) {
1486                 for (j = 0; j < JAS_CAST(int, lut16->numouttabents); ++j) {
1487                         if (jas_iccgetuint16(in, &lut16->outtabs[i][j]))
1488                                 goto error;
1489                 }
1490         }
1491         for (i = 0; i < clutsize; ++i) {
1492                 if (jas_iccgetuint16(in, &lut16->clut[i]))
1493                         goto error;
1494         }
1495         if (JAS_CAST(int, 44 + 2 * (lut16->numinchans * lut16->numintabents +
1496           lut16->numoutchans * lut16->numouttabents +
1497           jas_iccpowi(lut16->clutlen, lut16->numinchans) *
1498           lut16->numoutchans)) != cnt)
1499                 goto error;
1500         return 0;
1501 error:
1502         jas_icclut16_destroy(attrval);
1503         return -1;
1504 }
1505
1506 static int jas_icclut16_getsize(jas_iccattrval_t *attrval)
1507 {
1508         jas_icclut16_t *lut16 = &attrval->data.lut16;
1509         return 44 + 2 * (lut16->numinchans * lut16->numintabents +
1510           lut16->numoutchans * lut16->numouttabents +
1511           jas_iccpowi(lut16->clutlen, lut16->numinchans) * lut16->numoutchans);
1512 }
1513
1514 static int jas_icclut16_output(jas_iccattrval_t *attrval, jas_stream_t *out)
1515 {
1516         jas_icclut16_t *lut16 = &attrval->data.lut16;
1517         int i;
1518         int j;
1519         int n;
1520         if (jas_stream_putc(out, lut16->numinchans) == EOF ||
1521           jas_stream_putc(out, lut16->numoutchans) == EOF ||
1522           jas_stream_putc(out, lut16->clutlen) == EOF ||
1523           jas_stream_putc(out, 0) == EOF)
1524                 goto error;
1525         for (i = 0; i < 3; ++i) {
1526                 for (j = 0; j < 3; ++j) {
1527                         if (jas_iccputsint32(out, lut16->e[i][j]))
1528                                 goto error;
1529                 }
1530         }
1531         if (jas_iccputuint16(out, lut16->numintabents) ||
1532           jas_iccputuint16(out, lut16->numouttabents))
1533                 goto error;
1534         n = lut16->numinchans * lut16->numintabents;
1535         for (i = 0; i < n; ++i) {
1536                 if (jas_iccputuint16(out, lut16->intabsbuf[i]))
1537                         goto error;
1538         }
1539         n = lut16->numoutchans * lut16->numouttabents;
1540         for (i = 0; i < n; ++i) {
1541                 if (jas_iccputuint16(out, lut16->outtabsbuf[i]))
1542                         goto error;
1543         }
1544         n = jas_iccpowi(lut16->clutlen, lut16->numinchans) * lut16->numoutchans;
1545         for (i = 0; i < n; ++i) {
1546                 if (jas_iccputuint16(out, lut16->clut[i]))
1547                         goto error;
1548         }
1549         return 0;
1550 error:
1551         return -1;
1552 }
1553
1554 static void jas_icclut16_dump(jas_iccattrval_t *attrval, FILE *out)
1555 {
1556         jas_icclut16_t *lut16 = &attrval->data.lut16;
1557         int i;
1558         int j;
1559         fprintf(out, "numinchans=%d, numoutchans=%d, clutlen=%d\n",
1560           lut16->numinchans, lut16->numoutchans, lut16->clutlen);
1561         for (i = 0; i < 3; ++i) {
1562                 for (j = 0; j < 3; ++j) {
1563                         fprintf(out, "e[%d][%d]=%f ", i, j, lut16->e[i][j] / 65536.0);
1564                 }
1565                 fprintf(out, "\n");
1566         }
1567         fprintf(out, "numintabents=%d, numouttabents=%d\n",
1568           lut16->numintabents, lut16->numouttabents);
1569 }
1570
1571 /******************************************************************************\
1572 *
1573 \******************************************************************************/
1574
1575 static int jas_iccgetuint(jas_stream_t *in, int n, ulonglong *val)
1576 {
1577         int i;
1578         int c;
1579         ulonglong v;
1580         v = 0;
1581         for (i = n; i > 0; --i) {
1582                 if ((c = jas_stream_getc(in)) == EOF)
1583                         return -1;
1584                 v = (v << 8) | c;
1585         }
1586         *val = v;
1587         return 0;
1588 }
1589
1590 static int jas_iccgetuint8(jas_stream_t *in, jas_iccuint8_t *val)
1591 {
1592         int c;
1593         if ((c = jas_stream_getc(in)) == EOF)
1594                 return -1;
1595         *val = c;
1596         return 0;
1597 }
1598
1599 static int jas_iccgetuint16(jas_stream_t *in, jas_iccuint16_t *val)
1600 {
1601         ulonglong tmp;
1602         if (jas_iccgetuint(in, 2, &tmp))
1603                 return -1;
1604         *val = tmp;
1605         return 0;
1606 }
1607
1608 static int jas_iccgetsint32(jas_stream_t *in, jas_iccsint32_t *val)
1609 {
1610         ulonglong tmp;
1611         if (jas_iccgetuint(in, 4, &tmp))
1612                 return -1;
1613         *val = (tmp & 0x80000000) ? (-JAS_CAST(longlong, (((~tmp) &
1614           0x7fffffff) + 1))) : JAS_CAST(longlong, tmp);
1615         return 0;
1616 }
1617
1618 static int jas_iccgetuint32(jas_stream_t *in, jas_iccuint32_t *val)
1619 {
1620         ulonglong tmp;
1621         if (jas_iccgetuint(in, 4, &tmp))
1622                 return -1;
1623         *val = tmp;
1624         return 0;
1625 }
1626
1627 static int jas_iccgetuint64(jas_stream_t *in, jas_iccuint64_t *val)
1628 {
1629         ulonglong tmp;
1630         if (jas_iccgetuint(in, 8, &tmp))
1631                 return -1;
1632         *val = tmp;
1633         return 0;
1634 }
1635
1636 static int jas_iccputuint(jas_stream_t *out, int n, ulonglong val)
1637 {
1638         int i;
1639         int c;
1640         for (i = n; i > 0; --i) {
1641                 c = (val >> (8 * (i - 1))) & 0xff;
1642                 if (jas_stream_putc(out, c) == EOF)
1643                         return -1;
1644         }
1645         return 0;
1646 }
1647
1648 static int jas_iccputsint(jas_stream_t *out, int n, longlong val)
1649 {
1650         ulonglong tmp;
1651         tmp = (val < 0) ? (abort(), 0) : val;
1652         return jas_iccputuint(out, n, tmp);
1653 }
1654
1655 /******************************************************************************\
1656 *
1657 \******************************************************************************/
1658
1659 static char *jas_iccsigtostr(int sig, char *buf)
1660 {
1661         int n;
1662         int c;
1663         char *bufptr;
1664         bufptr = buf;
1665         for (n = 4; n > 0; --n) {
1666                 c = (sig >> 24) & 0xff;
1667                 if (isalpha(c) || isdigit(c)) {
1668                         *bufptr++ = c;
1669                 }
1670                 sig <<= 8;
1671         }
1672         *bufptr = '\0';
1673         return buf;
1674 }
1675
1676 static long jas_iccpadtomult(long x, long y)
1677 {
1678         return ((x + y - 1) / y) * y;
1679 }
1680
1681 static long jas_iccpowi(int x, int n)
1682 {
1683         long y;
1684         y = 1;
1685         while (--n >= 0)
1686                 y *= x;
1687         return y;
1688 }
1689
1690
1691 jas_iccprof_t *jas_iccprof_createfrombuf(uchar *buf, int len)
1692 {
1693         jas_stream_t *in;
1694         jas_iccprof_t *prof;
1695         if (!(in = jas_stream_memopen(JAS_CAST(char *, buf), len)))
1696                 goto error;
1697         if (!(prof = jas_iccprof_load(in)))
1698                 goto error;
1699         jas_stream_close(in);
1700         return prof;
1701 error:
1702         return 0;
1703 }
1704
1705 jas_iccprof_t *jas_iccprof_createfromclrspc(int clrspc)
1706 {
1707         jas_iccprof_t *prof;
1708         switch (clrspc) {
1709         case JAS_CLRSPC_SRGB:
1710                 prof = jas_iccprof_createfrombuf(jas_iccprofdata_srgb,
1711                   jas_iccprofdata_srgblen);
1712                 break;
1713         case JAS_CLRSPC_SGRAY:
1714                 prof = jas_iccprof_createfrombuf(jas_iccprofdata_sgray,
1715                   jas_iccprofdata_sgraylen);
1716                 break;
1717         default:
1718                 prof = 0;
1719                 break;
1720         }
1721         return prof;
1722 }