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