1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 // This file is available under and governed by the GNU General Public
  26 // License version 2 only, as published by the Free Software Foundation.
  27 // However, the following notice accompanied the original version of this
  28 // file:
  29 //
  30 //---------------------------------------------------------------------------------
  31 //
  32 //  Little Color Management System
  33 //  Copyright (c) 1998-2017 Marti Maria Saguer
  34 //
  35 // Permission is hereby granted, free of charge, to any person obtaining
  36 // a copy of this software and associated documentation files (the "Software"),
  37 // to deal in the Software without restriction, including without limitation
  38 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  39 // and/or sell copies of the Software, and to permit persons to whom the Software
  40 // is furnished to do so, subject to the following conditions:
  41 //
  42 // The above copyright notice and this permission notice shall be included in
  43 // all copies or substantial portions of the Software.
  44 //
  45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  46 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  47 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  48 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  49 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  50 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  51 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  52 //
  53 //---------------------------------------------------------------------------------
  54 //
  55 
  56 #include "lcms2_internal.h"
  57 
  58 // Generic I/O, tag dictionary management, profile struct
  59 
  60 // IOhandlers are abstractions used by littleCMS to read from whatever file, stream,
  61 // memory block or any storage. Each IOhandler provides implementations for read,
  62 // write, seek and tell functions. LittleCMS code deals with IO across those objects.
  63 // In this way, is easier to add support for new storage media.
  64 
  65 // NULL stream, for taking care of used space -------------------------------------
  66 
  67 // NULL IOhandler basically does nothing but keep track on how many bytes have been
  68 // written. This is handy when creating profiles, where the file size is needed in the
  69 // header. Then, whole profile is serialized across NULL IOhandler and a second pass
  70 // writes the bytes to the pertinent IOhandler.
  71 
  72 typedef struct {
  73     cmsUInt32Number Pointer;         // Points to current location
  74 } FILENULL;
  75 
  76 static
  77 cmsUInt32Number NULLRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
  78 {
  79     FILENULL* ResData = (FILENULL*) iohandler ->stream;
  80 
  81     cmsUInt32Number len = size * count;
  82     ResData -> Pointer += len;
  83     return count;
  84 
  85     cmsUNUSED_PARAMETER(Buffer);
  86 }
  87 
  88 static
  89 cmsBool  NULLSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)
  90 {
  91     FILENULL* ResData = (FILENULL*) iohandler ->stream;
  92 
  93     ResData ->Pointer = offset;
  94     return TRUE;
  95 }
  96 
  97 static
  98 cmsUInt32Number NULLTell(cmsIOHANDLER* iohandler)
  99 {
 100     FILENULL* ResData = (FILENULL*) iohandler ->stream;
 101     return ResData -> Pointer;
 102 }
 103 
 104 static
 105 cmsBool  NULLWrite(cmsIOHANDLER* iohandler, cmsUInt32Number size, const void *Ptr)
 106 {
 107     FILENULL* ResData = (FILENULL*) iohandler ->stream;
 108 
 109     ResData ->Pointer += size;
 110     if (ResData ->Pointer > iohandler->UsedSpace)
 111         iohandler->UsedSpace = ResData ->Pointer;
 112 
 113     return TRUE;
 114 
 115     cmsUNUSED_PARAMETER(Ptr);
 116 }
 117 
 118 static
 119 cmsBool  NULLClose(cmsIOHANDLER* iohandler)
 120 {
 121     FILENULL* ResData = (FILENULL*) iohandler ->stream;
 122 
 123     _cmsFree(iohandler ->ContextID, ResData);
 124     _cmsFree(iohandler ->ContextID, iohandler);
 125     return TRUE;
 126 }
 127 
 128 // The NULL IOhandler creator
 129 cmsIOHANDLER*  CMSEXPORT cmsOpenIOhandlerFromNULL(cmsContext ContextID)
 130 {
 131     struct _cms_io_handler* iohandler = NULL;
 132     FILENULL* fm = NULL;
 133 
 134     iohandler = (struct _cms_io_handler*) _cmsMallocZero(ContextID, sizeof(struct _cms_io_handler));
 135     if (iohandler == NULL) return NULL;
 136 
 137     fm = (FILENULL*) _cmsMallocZero(ContextID, sizeof(FILENULL));
 138     if (fm == NULL) goto Error;
 139 
 140     fm ->Pointer = 0;
 141 
 142     iohandler ->ContextID = ContextID;
 143     iohandler ->stream  = (void*) fm;
 144     iohandler ->UsedSpace = 0;
 145     iohandler ->ReportedSize = 0;
 146     iohandler ->PhysicalFile[0] = 0;
 147 
 148     iohandler ->Read    = NULLRead;
 149     iohandler ->Seek    = NULLSeek;
 150     iohandler ->Close   = NULLClose;
 151     iohandler ->Tell    = NULLTell;
 152     iohandler ->Write   = NULLWrite;
 153 
 154     return iohandler;
 155 
 156 Error:
 157     if (iohandler) _cmsFree(ContextID, iohandler);
 158     return NULL;
 159 
 160 }
 161 
 162 
 163 // Memory-based stream --------------------------------------------------------------
 164 
 165 // Those functions implements an iohandler which takes a block of memory as storage medium.
 166 
 167 typedef struct {
 168     cmsUInt8Number* Block;    // Points to allocated memory
 169     cmsUInt32Number Size;     // Size of allocated memory
 170     cmsUInt32Number Pointer;  // Points to current location
 171     int FreeBlockOnClose;     // As title
 172 
 173 } FILEMEM;
 174 
 175 static
 176 cmsUInt32Number MemoryRead(struct _cms_io_handler* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
 177 {
 178     FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
 179     cmsUInt8Number* Ptr;
 180     cmsUInt32Number len = size * count;
 181 
 182     if (ResData -> Pointer + len > ResData -> Size){
 183 
 184         len = (ResData -> Size - ResData -> Pointer);
 185         cmsSignalError(iohandler ->ContextID, cmsERROR_READ, "Read from memory error. Got %d bytes, block should be of %d bytes", len, count * size);
 186         return 0;
 187     }
 188 
 189     Ptr  = ResData -> Block;
 190     Ptr += ResData -> Pointer;
 191     memmove(Buffer, Ptr, len);
 192     ResData -> Pointer += len;
 193 
 194     return count;
 195 }
 196 
 197 // SEEK_CUR is assumed
 198 static
 199 cmsBool  MemorySeek(struct _cms_io_handler* iohandler, cmsUInt32Number offset)
 200 {
 201     FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
 202 
 203     if (offset > ResData ->Size) {
 204         cmsSignalError(iohandler ->ContextID, cmsERROR_SEEK,  "Too few data; probably corrupted profile");
 205         return FALSE;
 206     }
 207 
 208     ResData ->Pointer = offset;
 209     return TRUE;
 210 }
 211 
 212 // Tell for memory
 213 static
 214 cmsUInt32Number MemoryTell(struct _cms_io_handler* iohandler)
 215 {
 216     FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
 217 
 218     if (ResData == NULL) return 0;
 219     return ResData -> Pointer;
 220 }
 221 
 222 
 223 // Writes data to memory, also keeps used space for further reference.
 224 static
 225 cmsBool MemoryWrite(struct _cms_io_handler* iohandler, cmsUInt32Number size, const void *Ptr)
 226 {
 227     FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
 228 
 229     if (ResData == NULL) return FALSE; // Housekeeping
 230 
 231     // Check for available space. Clip.
 232     if (ResData->Pointer + size > ResData->Size) {
 233         size = ResData ->Size - ResData->Pointer;
 234     }
 235 
 236     if (size == 0) return TRUE;     // Write zero bytes is ok, but does nothing
 237 
 238     memmove(ResData ->Block + ResData ->Pointer, Ptr, size);
 239     ResData ->Pointer += size;
 240 
 241     if (ResData ->Pointer > iohandler->UsedSpace)
 242         iohandler->UsedSpace = ResData ->Pointer;
 243 
 244     return TRUE;
 245 }
 246 
 247 
 248 static
 249 cmsBool  MemoryClose(struct _cms_io_handler* iohandler)
 250 {
 251     FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
 252 
 253     if (ResData ->FreeBlockOnClose) {
 254 
 255         if (ResData ->Block) _cmsFree(iohandler ->ContextID, ResData ->Block);
 256     }
 257 
 258     _cmsFree(iohandler ->ContextID, ResData);
 259     _cmsFree(iohandler ->ContextID, iohandler);
 260 
 261     return TRUE;
 262 }
 263 
 264 // Create a iohandler for memory block. AccessMode=='r' assumes the iohandler is going to read, and makes
 265 // a copy of the memory block for letting user to free the memory after invoking open profile. In write
 266 // mode ("w"), Buffere points to the begin of memory block to be written.
 267 cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromMem(cmsContext ContextID, void *Buffer, cmsUInt32Number size, const char* AccessMode)
 268 {
 269     cmsIOHANDLER* iohandler = NULL;
 270     FILEMEM* fm = NULL;
 271 
 272     _cmsAssert(AccessMode != NULL);
 273 
 274     iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
 275     if (iohandler == NULL) return NULL;
 276 
 277     switch (*AccessMode) {
 278 
 279     case 'r':
 280         fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));
 281         if (fm == NULL) goto Error;
 282 
 283         if (Buffer == NULL) {
 284             cmsSignalError(ContextID, cmsERROR_READ, "Couldn't read profile from NULL pointer");
 285             goto Error;
 286         }
 287 
 288         fm ->Block = (cmsUInt8Number*) _cmsMalloc(ContextID, size);
 289         if (fm ->Block == NULL) {
 290 
 291             _cmsFree(ContextID, fm);
 292             _cmsFree(ContextID, iohandler);
 293             cmsSignalError(ContextID, cmsERROR_READ, "Couldn't allocate %ld bytes for profile", size);
 294             return NULL;
 295         }
 296 
 297 
 298         memmove(fm->Block, Buffer, size);
 299         fm ->FreeBlockOnClose = TRUE;
 300         fm ->Size    = size;
 301         fm ->Pointer = 0;
 302         iohandler -> ReportedSize = size;
 303         break;
 304 
 305     case 'w':
 306         fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));
 307         if (fm == NULL) goto Error;
 308 
 309         fm ->Block = (cmsUInt8Number*) Buffer;
 310         fm ->FreeBlockOnClose = FALSE;
 311         fm ->Size    = size;
 312         fm ->Pointer = 0;
 313         iohandler -> ReportedSize = 0;
 314         break;
 315 
 316     default:
 317         cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown access mode '%c'", *AccessMode);
 318         return NULL;
 319     }
 320 
 321     iohandler ->ContextID = ContextID;
 322     iohandler ->stream  = (void*) fm;
 323     iohandler ->UsedSpace = 0;
 324     iohandler ->PhysicalFile[0] = 0;
 325 
 326     iohandler ->Read    = MemoryRead;
 327     iohandler ->Seek    = MemorySeek;
 328     iohandler ->Close   = MemoryClose;
 329     iohandler ->Tell    = MemoryTell;
 330     iohandler ->Write   = MemoryWrite;
 331 
 332     return iohandler;
 333 
 334 Error:
 335     if (fm) _cmsFree(ContextID, fm);
 336     if (iohandler) _cmsFree(ContextID, iohandler);
 337     return NULL;
 338 }
 339 
 340 // File-based stream -------------------------------------------------------
 341 
 342 // Read count elements of size bytes each. Return number of elements read
 343 static
 344 cmsUInt32Number FileRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
 345 {
 346     cmsUInt32Number nReaded = (cmsUInt32Number) fread(Buffer, size, count, (FILE*) iohandler->stream);
 347 
 348     if (nReaded != count) {
 349             cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Read error. Got %d bytes, block should be of %d bytes", nReaded * size, count * size);
 350             return 0;
 351     }
 352 
 353     return nReaded;
 354 }
 355 
 356 // Position file pointer in the file
 357 static
 358 cmsBool  FileSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)
 359 {
 360     if (fseek((FILE*) iohandler ->stream, (long) offset, SEEK_SET) != 0) {
 361 
 362        cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Seek error; probably corrupted file");
 363        return FALSE;
 364     }
 365 
 366     return TRUE;
 367 }
 368 
 369 // Returns file pointer position or 0 on error, which is also a valid position.
 370 static
 371 cmsUInt32Number FileTell(cmsIOHANDLER* iohandler)
 372 {
 373     long t = ftell((FILE*)iohandler ->stream);
 374     if (t == -1L) {
 375         cmsSignalError(iohandler->ContextID, cmsERROR_FILE, "Tell error; probably corrupted file");
 376         return 0;
 377     }
 378 
 379     return (cmsUInt32Number)t;
 380 }
 381 
 382 // Writes data to stream, also keeps used space for further reference. Returns TRUE on success, FALSE on error
 383 static
 384 cmsBool  FileWrite(cmsIOHANDLER* iohandler, cmsUInt32Number size, const void* Buffer)
 385 {
 386     if (size == 0) return TRUE;  // We allow to write 0 bytes, but nothing is written
 387 
 388     iohandler->UsedSpace += size;
 389     return (fwrite(Buffer, size, 1, (FILE*)iohandler->stream) == 1);
 390 }
 391 
 392 // Closes the file
 393 static
 394 cmsBool  FileClose(cmsIOHANDLER* iohandler)
 395 {
 396     if (fclose((FILE*) iohandler ->stream) != 0) return FALSE;
 397     _cmsFree(iohandler ->ContextID, iohandler);
 398     return TRUE;
 399 }
 400 
 401 // Create a iohandler for disk based files.
 402 cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const char* FileName, const char* AccessMode)
 403 {
 404     cmsIOHANDLER* iohandler = NULL;
 405     FILE* fm = NULL;
 406     cmsInt32Number fileLen;
 407 
 408     _cmsAssert(FileName != NULL);
 409     _cmsAssert(AccessMode != NULL);
 410 
 411     iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
 412     if (iohandler == NULL) return NULL;
 413 
 414     switch (*AccessMode) {
 415 
 416     case 'r':
 417         fm = fopen(FileName, "rb");
 418         if (fm == NULL) {
 419             _cmsFree(ContextID, iohandler);
 420              cmsSignalError(ContextID, cmsERROR_FILE, "File '%s' not found", FileName);
 421             return NULL;
 422         }
 423         fileLen = cmsfilelength(fm);
 424         if (fileLen < 0)
 425         {
 426             fclose(fm);
 427             _cmsFree(ContextID, iohandler);
 428             cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of file '%s'", FileName);
 429             return NULL;
 430         }
 431 
 432         iohandler -> ReportedSize = (cmsUInt32Number) fileLen;
 433         break;
 434 
 435     case 'w':
 436         fm = fopen(FileName, "wb");
 437         if (fm == NULL) {
 438             _cmsFree(ContextID, iohandler);
 439              cmsSignalError(ContextID, cmsERROR_FILE, "Couldn't create '%s'", FileName);
 440             return NULL;
 441         }
 442         iohandler -> ReportedSize = 0;
 443         break;
 444 
 445     default:
 446         _cmsFree(ContextID, iohandler);
 447          cmsSignalError(ContextID, cmsERROR_FILE, "Unknown access mode '%c'", *AccessMode);
 448         return NULL;
 449     }
 450 
 451     iohandler ->ContextID = ContextID;
 452     iohandler ->stream = (void*) fm;
 453     iohandler ->UsedSpace = 0;
 454 
 455     // Keep track of the original file
 456     strncpy(iohandler -> PhysicalFile, FileName, sizeof(iohandler -> PhysicalFile)-1);
 457     iohandler -> PhysicalFile[sizeof(iohandler -> PhysicalFile)-1] = 0;
 458 
 459     iohandler ->Read    = FileRead;
 460     iohandler ->Seek    = FileSeek;
 461     iohandler ->Close   = FileClose;
 462     iohandler ->Tell    = FileTell;
 463     iohandler ->Write   = FileWrite;
 464 
 465     return iohandler;
 466 }
 467 
 468 // Create a iohandler for stream based files
 469 cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromStream(cmsContext ContextID, FILE* Stream)
 470 {
 471     cmsIOHANDLER* iohandler = NULL;
 472     cmsInt32Number fileSize;
 473 
 474     fileSize = cmsfilelength(Stream);
 475     if (fileSize < 0)
 476     {
 477         cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of stream");
 478         return NULL;
 479     }
 480 
 481     iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
 482     if (iohandler == NULL) return NULL;
 483 
 484     iohandler -> ContextID = ContextID;
 485     iohandler -> stream = (void*) Stream;
 486     iohandler -> UsedSpace = 0;
 487     iohandler -> ReportedSize = (cmsUInt32Number) fileSize;
 488     iohandler -> PhysicalFile[0] = 0;
 489 
 490     iohandler ->Read    = FileRead;
 491     iohandler ->Seek    = FileSeek;
 492     iohandler ->Close   = FileClose;
 493     iohandler ->Tell    = FileTell;
 494     iohandler ->Write   = FileWrite;
 495 
 496     return iohandler;
 497 }
 498 
 499 
 500 
 501 // Close an open IO handler
 502 cmsBool CMSEXPORT cmsCloseIOhandler(cmsIOHANDLER* io)
 503 {
 504     return io -> Close(io);
 505 }
 506 
 507 // -------------------------------------------------------------------------------------------------------
 508 
 509 cmsIOHANDLER* CMSEXPORT cmsGetProfileIOhandler(cmsHPROFILE hProfile)
 510 {
 511         _cmsICCPROFILE* Icc = (_cmsICCPROFILE*)hProfile;
 512 
 513         if (Icc == NULL) return NULL;
 514         return Icc->IOhandler;
 515 }
 516 
 517 // Creates an empty structure holding all required parameters
 518 cmsHPROFILE CMSEXPORT cmsCreateProfilePlaceholder(cmsContext ContextID)
 519 {
 520     time_t now = time(NULL);
 521     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) _cmsMallocZero(ContextID, sizeof(_cmsICCPROFILE));
 522     if (Icc == NULL) return NULL;
 523 
 524     Icc ->ContextID = ContextID;
 525 
 526     // Set it to empty
 527     Icc -> TagCount   = 0;
 528 
 529     // Set default version
 530     Icc ->Version =  0x02100000;
 531 
 532     // Set creation date/time
 533     memmove(&Icc ->Created, gmtime(&now), sizeof(Icc ->Created));
 534 
 535     // Create a mutex if the user provided proper plugin. NULL otherwise
 536     Icc ->UsrMutex = _cmsCreateMutex(ContextID);
 537 
 538     // Return the handle
 539     return (cmsHPROFILE) Icc;
 540 }
 541 
 542 cmsContext CMSEXPORT cmsGetProfileContextID(cmsHPROFILE hProfile)
 543 {
 544      _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
 545 
 546     if (Icc == NULL) return NULL;
 547     return Icc -> ContextID;
 548 }
 549 
 550 
 551 // Return the number of tags
 552 cmsInt32Number CMSEXPORT cmsGetTagCount(cmsHPROFILE hProfile)
 553 {
 554     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
 555     if (Icc == NULL) return -1;
 556 
 557     return  (cmsInt32Number) Icc->TagCount;
 558 }
 559 
 560 // Return the tag signature of a given tag number
 561 cmsTagSignature CMSEXPORT cmsGetTagSignature(cmsHPROFILE hProfile, cmsUInt32Number n)
 562 {
 563     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
 564 
 565     if (n > Icc->TagCount) return (cmsTagSignature) 0;  // Mark as not available
 566     if (n >= MAX_TABLE_TAG) return (cmsTagSignature) 0; // As double check
 567 
 568     return Icc ->TagNames[n];
 569 }
 570 
 571 
 572 static
 573 int SearchOneTag(_cmsICCPROFILE* Profile, cmsTagSignature sig)
 574 {
 575     int i;
 576 
 577     for (i=0; i < (int) Profile -> TagCount; i++) {
 578 
 579         if (sig == Profile -> TagNames[i])
 580             return i;
 581     }
 582 
 583     return -1;
 584 }
 585 
 586 // Search for a specific tag in tag dictionary. Returns position or -1 if tag not found.
 587 // If followlinks is turned on, then the position of the linked tag is returned
 588 int _cmsSearchTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, cmsBool lFollowLinks)
 589 {
 590     int n;
 591     cmsTagSignature LinkedSig;
 592 
 593     do {
 594 
 595         // Search for given tag in ICC profile directory
 596         n = SearchOneTag(Icc, sig);
 597         if (n < 0)
 598             return -1;        // Not found
 599 
 600         if (!lFollowLinks)
 601             return n;         // Found, don't follow links
 602 
 603         // Is this a linked tag?
 604         LinkedSig = Icc ->TagLinked[n];
 605 
 606         // Yes, follow link
 607         if (LinkedSig != (cmsTagSignature) 0) {
 608             sig = LinkedSig;
 609         }
 610 
 611     } while (LinkedSig != (cmsTagSignature) 0);
 612 
 613     return n;
 614 }
 615 
 616 // Deletes a tag entry
 617 
 618 static
 619 void _cmsDeleteTagByPos(_cmsICCPROFILE* Icc, int i)
 620 {
 621     _cmsAssert(Icc != NULL);
 622     _cmsAssert(i >= 0);
 623 
 624 
 625     if (Icc -> TagPtrs[i] != NULL) {
 626 
 627         // Free previous version
 628         if (Icc ->TagSaveAsRaw[i]) {
 629             _cmsFree(Icc ->ContextID, Icc ->TagPtrs[i]);
 630         }
 631         else {
 632             cmsTagTypeHandler* TypeHandler = Icc ->TagTypeHandlers[i];
 633 
 634             if (TypeHandler != NULL) {
 635 
 636                 cmsTagTypeHandler LocalTypeHandler = *TypeHandler;
 637                 LocalTypeHandler.ContextID = Icc ->ContextID;              // As an additional parameter
 638                 LocalTypeHandler.ICCVersion = Icc ->Version;
 639                 LocalTypeHandler.FreePtr(&LocalTypeHandler, Icc -> TagPtrs[i]);
 640                 Icc ->TagPtrs[i] = NULL;
 641             }
 642         }
 643 
 644     }
 645 }
 646 
 647 
 648 // Creates a new tag entry
 649 static
 650 cmsBool _cmsNewTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, int* NewPos)
 651 {
 652     int i;
 653 
 654     // Search for the tag
 655     i = _cmsSearchTag(Icc, sig, FALSE);
 656     if (i >= 0) {
 657 
 658         // Already exists? delete it
 659         _cmsDeleteTagByPos(Icc, i);
 660         *NewPos = i;
 661     }
 662     else  {
 663 
 664         // No, make a new one
 665 
 666         if (Icc -> TagCount >= MAX_TABLE_TAG) {
 667             cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", MAX_TABLE_TAG);
 668             return FALSE;
 669         }
 670 
 671         *NewPos = (int) Icc ->TagCount;
 672         Icc -> TagCount++;
 673     }
 674 
 675     return TRUE;
 676 }
 677 
 678 
 679 // Check existence
 680 cmsBool CMSEXPORT cmsIsTag(cmsHPROFILE hProfile, cmsTagSignature sig)
 681 {
 682        _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) (void*) hProfile;
 683        return _cmsSearchTag(Icc, sig, FALSE) >= 0;
 684 }
 685 
 686 
 687 
 688 // Enforces that the profile version is per. spec.
 689 // Operates on the big endian bytes from the profile.
 690 // Called before converting to platform endianness.
 691 // Byte 0 is BCD major version, so max 9.
 692 // Byte 1 is 2 BCD digits, one per nibble.
 693 // Reserved bytes 2 & 3 must be 0.
 694 static
 695 cmsUInt32Number _validatedVersion(cmsUInt32Number DWord)
 696 {
 697     cmsUInt8Number* pByte = (cmsUInt8Number*) &DWord;
 698     cmsUInt8Number temp1;
 699     cmsUInt8Number temp2;
 700 
 701     if (*pByte > 0x09) *pByte = (cmsUInt8Number) 0x09;
 702     temp1 = (cmsUInt8Number) (*(pByte+1) & 0xf0);
 703     temp2 = (cmsUInt8Number) (*(pByte+1) & 0x0f);
 704     if (temp1 > 0x90U) temp1 = 0x90U;
 705     if (temp2 > 0x09U) temp2 = 0x09U;
 706     *(pByte+1) = (cmsUInt8Number)(temp1 | temp2);
 707     *(pByte+2) = (cmsUInt8Number)0;
 708     *(pByte+3) = (cmsUInt8Number)0;
 709 
 710     return DWord;
 711 }
 712 
 713 // Read profile header and validate it
 714 cmsBool _cmsReadHeader(_cmsICCPROFILE* Icc)
 715 {
 716     cmsTagEntry Tag;
 717     cmsICCHeader Header;
 718     cmsUInt32Number i, j;
 719     cmsUInt32Number HeaderSize;
 720     cmsIOHANDLER* io = Icc ->IOhandler;
 721     cmsUInt32Number TagCount;
 722 
 723 
 724     // Read the header
 725     if (io -> Read(io, &Header, sizeof(cmsICCHeader), 1) != 1) {
 726         return FALSE;
 727     }
 728 
 729     // Validate file as an ICC profile
 730     if (_cmsAdjustEndianess32(Header.magic) != cmsMagicNumber) {
 731         cmsSignalError(Icc ->ContextID, cmsERROR_BAD_SIGNATURE, "not an ICC profile, invalid signature");
 732         return FALSE;
 733     }
 734 
 735     // Adjust endianness of the used parameters
 736     Icc -> DeviceClass     = (cmsProfileClassSignature) _cmsAdjustEndianess32(Header.deviceClass);
 737     Icc -> ColorSpace      = (cmsColorSpaceSignature)   _cmsAdjustEndianess32(Header.colorSpace);
 738     Icc -> PCS             = (cmsColorSpaceSignature)   _cmsAdjustEndianess32(Header.pcs);
 739 
 740     Icc -> RenderingIntent = _cmsAdjustEndianess32(Header.renderingIntent);
 741     Icc -> flags           = _cmsAdjustEndianess32(Header.flags);
 742     Icc -> manufacturer    = _cmsAdjustEndianess32(Header.manufacturer);
 743     Icc -> model           = _cmsAdjustEndianess32(Header.model);
 744     Icc -> creator         = _cmsAdjustEndianess32(Header.creator);
 745 
 746     _cmsAdjustEndianess64(&Icc -> attributes, &Header.attributes);
 747     Icc -> Version         = _cmsAdjustEndianess32(_validatedVersion(Header.version));
 748 
 749     // Get size as reported in header
 750     HeaderSize = _cmsAdjustEndianess32(Header.size);
 751 
 752     // Make sure HeaderSize is lower than profile size
 753     if (HeaderSize >= Icc ->IOhandler ->ReportedSize)
 754             HeaderSize = Icc ->IOhandler ->ReportedSize;
 755 
 756 
 757     // Get creation date/time
 758     _cmsDecodeDateTimeNumber(&Header.date, &Icc ->Created);
 759 
 760     // The profile ID are 32 raw bytes
 761     memmove(Icc ->ProfileID.ID32, Header.profileID.ID32, 16);
 762 
 763 
 764     // Read tag directory
 765     if (!_cmsReadUInt32Number(io, &TagCount)) return FALSE;
 766     if (TagCount > MAX_TABLE_TAG) {
 767 
 768         cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", TagCount);
 769         return FALSE;
 770     }
 771 
 772 
 773     // Read tag directory
 774     Icc -> TagCount = 0;
 775     for (i=0; i < TagCount; i++) {
 776 
 777         if (!_cmsReadUInt32Number(io, (cmsUInt32Number *) &Tag.sig)) return FALSE;
 778         if (!_cmsReadUInt32Number(io, &Tag.offset)) return FALSE;
 779         if (!_cmsReadUInt32Number(io, &Tag.size)) return FALSE;
 780 
 781         // Perform some sanity check. Offset + size should fall inside file.
 782         if (Tag.offset + Tag.size > HeaderSize ||
 783             Tag.offset + Tag.size < Tag.offset)
 784                   continue;
 785 
 786         Icc -> TagNames[Icc ->TagCount]   = Tag.sig;
 787         Icc -> TagOffsets[Icc ->TagCount] = Tag.offset;
 788         Icc -> TagSizes[Icc ->TagCount]   = Tag.size;
 789 
 790        // Search for links
 791         for (j=0; j < Icc ->TagCount; j++) {
 792 
 793             if ((Icc ->TagOffsets[j] == Tag.offset) &&
 794                 (Icc ->TagSizes[j]   == Tag.size)) {
 795 
 796                 Icc ->TagLinked[Icc ->TagCount] = Icc ->TagNames[j];
 797             }
 798 
 799         }
 800 
 801         Icc ->TagCount++;
 802     }
 803 
 804     return TRUE;
 805 }
 806 
 807 // Saves profile header
 808 cmsBool _cmsWriteHeader(_cmsICCPROFILE* Icc, cmsUInt32Number UsedSpace)
 809 {
 810     cmsICCHeader Header;
 811     cmsUInt32Number i;
 812     cmsTagEntry Tag;
 813     cmsUInt32Number Count;
 814 
 815     Header.size        = _cmsAdjustEndianess32(UsedSpace);
 816     Header.cmmId       = _cmsAdjustEndianess32(lcmsSignature);
 817     Header.version     = _cmsAdjustEndianess32(Icc ->Version);
 818 
 819     Header.deviceClass = (cmsProfileClassSignature) _cmsAdjustEndianess32(Icc -> DeviceClass);
 820     Header.colorSpace  = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Icc -> ColorSpace);
 821     Header.pcs         = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Icc -> PCS);
 822 
 823     //   NOTE: in v4 Timestamp must be in UTC rather than in local time
 824     _cmsEncodeDateTimeNumber(&Header.date, &Icc ->Created);
 825 
 826     Header.magic       = _cmsAdjustEndianess32(cmsMagicNumber);
 827 
 828 #ifdef CMS_IS_WINDOWS_
 829     Header.platform    = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMicrosoft);
 830 #else
 831     Header.platform    = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMacintosh);
 832 #endif
 833 
 834     Header.flags        = _cmsAdjustEndianess32(Icc -> flags);
 835     Header.manufacturer = _cmsAdjustEndianess32(Icc -> manufacturer);
 836     Header.model        = _cmsAdjustEndianess32(Icc -> model);
 837 
 838     _cmsAdjustEndianess64(&Header.attributes, &Icc -> attributes);
 839 
 840     // Rendering intent in the header (for embedded profiles)
 841     Header.renderingIntent = _cmsAdjustEndianess32(Icc -> RenderingIntent);
 842 
 843     // Illuminant is always D50
 844     Header.illuminant.X = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(cmsD50_XYZ()->X));
 845     Header.illuminant.Y = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(cmsD50_XYZ()->Y));
 846     Header.illuminant.Z = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(cmsD50_XYZ()->Z));
 847 
 848     // Created by LittleCMS (that's me!)
 849     Header.creator      = _cmsAdjustEndianess32(lcmsSignature);
 850 
 851     memset(&Header.reserved, 0, sizeof(Header.reserved));
 852 
 853     // Set profile ID. Endianness is always big endian
 854     memmove(&Header.profileID, &Icc ->ProfileID, 16);
 855 
 856     // Dump the header
 857     if (!Icc -> IOhandler->Write(Icc->IOhandler, sizeof(cmsICCHeader), &Header)) return FALSE;
 858 
 859     // Saves Tag directory
 860 
 861     // Get true count
 862     Count = 0;
 863     for (i=0;  i < Icc -> TagCount; i++) {
 864         if (Icc ->TagNames[i] != (cmsTagSignature) 0)
 865             Count++;
 866     }
 867 
 868     // Store number of tags
 869     if (!_cmsWriteUInt32Number(Icc ->IOhandler, Count)) return FALSE;
 870 
 871     for (i=0; i < Icc -> TagCount; i++) {
 872 
 873         if (Icc ->TagNames[i] == (cmsTagSignature) 0) continue;   // It is just a placeholder
 874 
 875         Tag.sig    = (cmsTagSignature) _cmsAdjustEndianess32((cmsUInt32Number) Icc -> TagNames[i]);
 876         Tag.offset = _cmsAdjustEndianess32((cmsUInt32Number) Icc -> TagOffsets[i]);
 877         Tag.size   = _cmsAdjustEndianess32((cmsUInt32Number) Icc -> TagSizes[i]);
 878 
 879         if (!Icc ->IOhandler -> Write(Icc-> IOhandler, sizeof(cmsTagEntry), &Tag)) return FALSE;
 880     }
 881 
 882     return TRUE;
 883 }
 884 
 885 // ----------------------------------------------------------------------- Set/Get several struct members
 886 
 887 
 888 cmsUInt32Number CMSEXPORT cmsGetHeaderRenderingIntent(cmsHPROFILE hProfile)
 889 {
 890     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 891     return Icc -> RenderingIntent;
 892 }
 893 
 894 void CMSEXPORT cmsSetHeaderRenderingIntent(cmsHPROFILE hProfile, cmsUInt32Number RenderingIntent)
 895 {
 896     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 897     Icc -> RenderingIntent = RenderingIntent;
 898 }
 899 
 900 cmsUInt32Number CMSEXPORT cmsGetHeaderFlags(cmsHPROFILE hProfile)
 901 {
 902     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 903     return (cmsUInt32Number) Icc -> flags;
 904 }
 905 
 906 void CMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, cmsUInt32Number Flags)
 907 {
 908     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 909     Icc -> flags = (cmsUInt32Number) Flags;
 910 }
 911 
 912 cmsUInt32Number CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile)
 913 {
 914     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 915     return Icc ->manufacturer;
 916 }
 917 
 918 void CMSEXPORT cmsSetHeaderManufacturer(cmsHPROFILE hProfile, cmsUInt32Number manufacturer)
 919 {
 920     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 921     Icc -> manufacturer = manufacturer;
 922 }
 923 
 924 cmsUInt32Number CMSEXPORT cmsGetHeaderCreator(cmsHPROFILE hProfile)
 925 {
 926     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 927     return Icc ->creator;
 928 }
 929 
 930 cmsUInt32Number CMSEXPORT cmsGetHeaderModel(cmsHPROFILE hProfile)
 931 {
 932     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 933     return Icc ->model;
 934 }
 935 
 936 void CMSEXPORT cmsSetHeaderModel(cmsHPROFILE hProfile, cmsUInt32Number model)
 937 {
 938     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 939     Icc -> model = model;
 940 }
 941 
 942 void CMSEXPORT cmsGetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number* Flags)
 943 {
 944     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 945     memmove(Flags, &Icc -> attributes, sizeof(cmsUInt64Number));
 946 }
 947 
 948 void CMSEXPORT cmsSetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number Flags)
 949 {
 950     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 951     memmove(&Icc -> attributes, &Flags, sizeof(cmsUInt64Number));
 952 }
 953 
 954 void CMSEXPORT cmsGetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)
 955 {
 956     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 957     memmove(ProfileID, Icc ->ProfileID.ID8, 16);
 958 }
 959 
 960 void CMSEXPORT cmsSetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)
 961 {
 962     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 963     memmove(&Icc -> ProfileID, ProfileID, 16);
 964 }
 965 
 966 cmsBool  CMSEXPORT cmsGetHeaderCreationDateTime(cmsHPROFILE hProfile, struct tm *Dest)
 967 {
 968     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 969     memmove(Dest, &Icc ->Created, sizeof(struct tm));
 970     return TRUE;
 971 }
 972 
 973 cmsColorSpaceSignature CMSEXPORT cmsGetPCS(cmsHPROFILE hProfile)
 974 {
 975     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 976     return Icc -> PCS;
 977 }
 978 
 979 void CMSEXPORT cmsSetPCS(cmsHPROFILE hProfile, cmsColorSpaceSignature pcs)
 980 {
 981     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 982     Icc -> PCS = pcs;
 983 }
 984 
 985 cmsColorSpaceSignature CMSEXPORT cmsGetColorSpace(cmsHPROFILE hProfile)
 986 {
 987     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 988     return Icc -> ColorSpace;
 989 }
 990 
 991 void CMSEXPORT cmsSetColorSpace(cmsHPROFILE hProfile, cmsColorSpaceSignature sig)
 992 {
 993     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
 994     Icc -> ColorSpace = sig;
 995 }
 996 
 997 cmsProfileClassSignature CMSEXPORT cmsGetDeviceClass(cmsHPROFILE hProfile)
 998 {
 999     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
1000     return Icc -> DeviceClass;
1001 }
1002 
1003 void CMSEXPORT cmsSetDeviceClass(cmsHPROFILE hProfile, cmsProfileClassSignature sig)
1004 {
1005     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
1006     Icc -> DeviceClass = sig;
1007 }
1008 
1009 cmsUInt32Number CMSEXPORT cmsGetEncodedICCversion(cmsHPROFILE hProfile)
1010 {
1011     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
1012     return Icc -> Version;
1013 }
1014 
1015 void CMSEXPORT cmsSetEncodedICCversion(cmsHPROFILE hProfile, cmsUInt32Number Version)
1016 {
1017     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
1018     Icc -> Version = Version;
1019 }
1020 
1021 // Get an hexadecimal number with same digits as v
1022 static
1023 cmsUInt32Number BaseToBase(cmsUInt32Number in, int BaseIn, int BaseOut)
1024 {
1025     char Buff[100];
1026     int i, len;
1027     cmsUInt32Number out;
1028 
1029     for (len=0; in > 0 && len < 100; len++) {
1030 
1031         Buff[len] = (char) (in % BaseIn);
1032         in /= BaseIn;
1033     }
1034 
1035     for (i=len-1, out=0; i >= 0; --i) {
1036         out = out * BaseOut + Buff[i];
1037     }
1038 
1039     return out;
1040 }
1041 
1042 void  CMSEXPORT cmsSetProfileVersion(cmsHPROFILE hProfile, cmsFloat64Number Version)
1043 {
1044     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
1045 
1046     // 4.2 -> 0x4200000
1047 
1048     Icc -> Version = BaseToBase((cmsUInt32Number) floor(Version * 100.0 + 0.5), 10, 16) << 16;
1049 }
1050 
1051 cmsFloat64Number CMSEXPORT cmsGetProfileVersion(cmsHPROFILE hProfile)
1052 {
1053     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;
1054     cmsUInt32Number n = Icc -> Version >> 16;
1055 
1056     return BaseToBase(n, 16, 10) / 100.0;
1057 }
1058 // --------------------------------------------------------------------------------------------------------------
1059 
1060 
1061 // Create profile from IOhandler
1062 cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandlerTHR(cmsContext ContextID, cmsIOHANDLER* io)
1063 {
1064     _cmsICCPROFILE* NewIcc;
1065     cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1066 
1067     if (hEmpty == NULL) return NULL;
1068 
1069     NewIcc = (_cmsICCPROFILE*) hEmpty;
1070 
1071     NewIcc ->IOhandler = io;
1072     if (!_cmsReadHeader(NewIcc)) goto Error;
1073     return hEmpty;
1074 
1075 Error:
1076     cmsCloseProfile(hEmpty);
1077     return NULL;
1078 }
1079 
1080 // Create profile from IOhandler
1081 cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandler2THR(cmsContext ContextID, cmsIOHANDLER* io, cmsBool write)
1082 {
1083     _cmsICCPROFILE* NewIcc;
1084     cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1085 
1086     if (hEmpty == NULL) return NULL;
1087 
1088     NewIcc = (_cmsICCPROFILE*) hEmpty;
1089 
1090     NewIcc ->IOhandler = io;
1091     if (write) {
1092 
1093         NewIcc -> IsWrite = TRUE;
1094         return hEmpty;
1095     }
1096 
1097     if (!_cmsReadHeader(NewIcc)) goto Error;
1098     return hEmpty;
1099 
1100 Error:
1101     cmsCloseProfile(hEmpty);
1102     return NULL;
1103 }
1104 
1105 
1106 // Create profile from disk file
1107 cmsHPROFILE CMSEXPORT cmsOpenProfileFromFileTHR(cmsContext ContextID, const char *lpFileName, const char *sAccess)
1108 {
1109     _cmsICCPROFILE* NewIcc;
1110     cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1111 
1112     if (hEmpty == NULL) return NULL;
1113 
1114     NewIcc = (_cmsICCPROFILE*) hEmpty;
1115 
1116     NewIcc ->IOhandler = cmsOpenIOhandlerFromFile(ContextID, lpFileName, sAccess);
1117     if (NewIcc ->IOhandler == NULL) goto Error;
1118 
1119     if (*sAccess == 'W' || *sAccess == 'w') {
1120 
1121         NewIcc -> IsWrite = TRUE;
1122 
1123         return hEmpty;
1124     }
1125 
1126     if (!_cmsReadHeader(NewIcc)) goto Error;
1127     return hEmpty;
1128 
1129 Error:
1130     cmsCloseProfile(hEmpty);
1131     return NULL;
1132 }
1133 
1134 
1135 cmsHPROFILE CMSEXPORT cmsOpenProfileFromFile(const char *ICCProfile, const char *sAccess)
1136 {
1137     return cmsOpenProfileFromFileTHR(NULL, ICCProfile, sAccess);
1138 }
1139 
1140 
1141 cmsHPROFILE  CMSEXPORT cmsOpenProfileFromStreamTHR(cmsContext ContextID, FILE* ICCProfile, const char *sAccess)
1142 {
1143     _cmsICCPROFILE* NewIcc;
1144     cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1145 
1146     if (hEmpty == NULL) return NULL;
1147 
1148     NewIcc = (_cmsICCPROFILE*) hEmpty;
1149 
1150     NewIcc ->IOhandler = cmsOpenIOhandlerFromStream(ContextID, ICCProfile);
1151     if (NewIcc ->IOhandler == NULL) goto Error;
1152 
1153     if (*sAccess == 'w') {
1154 
1155         NewIcc -> IsWrite = TRUE;
1156         return hEmpty;
1157     }
1158 
1159     if (!_cmsReadHeader(NewIcc)) goto Error;
1160     return hEmpty;
1161 
1162 Error:
1163     cmsCloseProfile(hEmpty);
1164     return NULL;
1165 
1166 }
1167 
1168 cmsHPROFILE  CMSEXPORT cmsOpenProfileFromStream(FILE* ICCProfile, const char *sAccess)
1169 {
1170     return cmsOpenProfileFromStreamTHR(NULL, ICCProfile, sAccess);
1171 }
1172 
1173 
1174 // Open from memory block
1175 cmsHPROFILE CMSEXPORT cmsOpenProfileFromMemTHR(cmsContext ContextID, const void* MemPtr, cmsUInt32Number dwSize)
1176 {
1177     _cmsICCPROFILE* NewIcc;
1178     cmsHPROFILE hEmpty;
1179 
1180     hEmpty = cmsCreateProfilePlaceholder(ContextID);
1181     if (hEmpty == NULL) return NULL;
1182 
1183     NewIcc = (_cmsICCPROFILE*) hEmpty;
1184 
1185     // Ok, in this case const void* is casted to void* just because open IO handler
1186     // shares read and writing modes. Don't abuse this feature!
1187     NewIcc ->IOhandler = cmsOpenIOhandlerFromMem(ContextID, (void*) MemPtr, dwSize, "r");
1188     if (NewIcc ->IOhandler == NULL) goto Error;
1189 
1190     if (!_cmsReadHeader(NewIcc)) goto Error;
1191 
1192     return hEmpty;
1193 
1194 Error:
1195     cmsCloseProfile(hEmpty);
1196     return NULL;
1197 }
1198 
1199 cmsHPROFILE CMSEXPORT cmsOpenProfileFromMem(const void* MemPtr, cmsUInt32Number dwSize)
1200 {
1201     return cmsOpenProfileFromMemTHR(NULL, MemPtr, dwSize);
1202 }
1203 
1204 
1205 
1206 // Dump tag contents. If the profile is being modified, untouched tags are copied from FileOrig
1207 static
1208 cmsBool SaveTags(_cmsICCPROFILE* Icc, _cmsICCPROFILE* FileOrig)
1209 {
1210     cmsUInt8Number* Data;
1211     cmsUInt32Number i;
1212     cmsUInt32Number Begin;
1213     cmsIOHANDLER* io = Icc ->IOhandler;
1214     cmsTagDescriptor* TagDescriptor;
1215     cmsTagTypeSignature TypeBase;
1216     cmsTagTypeSignature Type;
1217     cmsTagTypeHandler* TypeHandler;
1218     cmsFloat64Number   Version = cmsGetProfileVersion((cmsHPROFILE) Icc);
1219     cmsTagTypeHandler LocalTypeHandler;
1220 
1221     for (i=0; i < Icc -> TagCount; i++) {
1222 
1223         if (Icc ->TagNames[i] == (cmsTagSignature) 0) continue;
1224 
1225         // Linked tags are not written
1226         if (Icc ->TagLinked[i] != (cmsTagSignature) 0) continue;
1227 
1228         Icc -> TagOffsets[i] = Begin = io ->UsedSpace;
1229 
1230         Data = (cmsUInt8Number*)  Icc -> TagPtrs[i];
1231 
1232         if (!Data) {
1233 
1234             // Reach here if we are copying a tag from a disk-based ICC profile which has not been modified by user.
1235             // In this case a blind copy of the block data is performed
1236             if (FileOrig != NULL && Icc -> TagOffsets[i]) {
1237 
1238                 cmsUInt32Number TagSize   = FileOrig -> TagSizes[i];
1239                 cmsUInt32Number TagOffset = FileOrig -> TagOffsets[i];
1240                 void* Mem;
1241 
1242                 if (!FileOrig ->IOhandler->Seek(FileOrig ->IOhandler, TagOffset)) return FALSE;
1243 
1244                 Mem = _cmsMalloc(Icc ->ContextID, TagSize);
1245                 if (Mem == NULL) return FALSE;
1246 
1247                 if (FileOrig ->IOhandler->Read(FileOrig->IOhandler, Mem, TagSize, 1) != 1) return FALSE;
1248                 if (!io ->Write(io, TagSize, Mem)) return FALSE;
1249                 _cmsFree(Icc ->ContextID, Mem);
1250 
1251                 Icc -> TagSizes[i] = (io ->UsedSpace - Begin);
1252 
1253 
1254                 // Align to 32 bit boundary.
1255                 if (! _cmsWriteAlignment(io))
1256                     return FALSE;
1257             }
1258 
1259             continue;
1260         }
1261 
1262 
1263         // Should this tag be saved as RAW? If so, tagsizes should be specified in advance (no further cooking is done)
1264         if (Icc ->TagSaveAsRaw[i]) {
1265 
1266             if (io -> Write(io, Icc ->TagSizes[i], Data) != 1) return FALSE;
1267         }
1268         else {
1269 
1270             // Search for support on this tag
1271             TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, Icc -> TagNames[i]);
1272             if (TagDescriptor == NULL) continue;                        // Unsupported, ignore it
1273 
1274             if (TagDescriptor ->DecideType != NULL) {
1275 
1276                 Type = TagDescriptor ->DecideType(Version, Data);
1277             }
1278             else {
1279 
1280                 Type = TagDescriptor ->SupportedTypes[0];
1281             }
1282 
1283             TypeHandler =  _cmsGetTagTypeHandler(Icc->ContextID, Type);
1284 
1285             if (TypeHandler == NULL) {
1286                 cmsSignalError(Icc ->ContextID, cmsERROR_INTERNAL, "(Internal) no handler for tag %x", Icc -> TagNames[i]);
1287                 continue;
1288             }
1289 
1290             TypeBase = TypeHandler ->Signature;
1291             if (!_cmsWriteTypeBase(io, TypeBase))
1292                 return FALSE;
1293 
1294             LocalTypeHandler = *TypeHandler;
1295             LocalTypeHandler.ContextID  = Icc ->ContextID;
1296             LocalTypeHandler.ICCVersion = Icc ->Version;
1297             if (!LocalTypeHandler.WritePtr(&LocalTypeHandler, io, Data, TagDescriptor ->ElemCount)) {
1298 
1299                 char String[5];
1300 
1301                 _cmsTagSignature2String(String, (cmsTagSignature) TypeBase);
1302                 cmsSignalError(Icc ->ContextID, cmsERROR_WRITE, "Couldn't write type '%s'", String);
1303                 return FALSE;
1304             }
1305         }
1306 
1307 
1308         Icc -> TagSizes[i] = (io ->UsedSpace - Begin);
1309 
1310         // Align to 32 bit boundary.
1311         if (! _cmsWriteAlignment(io))
1312             return FALSE;
1313     }
1314 
1315 
1316     return TRUE;
1317 }
1318 
1319 
1320 // Fill the offset and size fields for all linked tags
1321 static
1322 cmsBool SetLinks( _cmsICCPROFILE* Icc)
1323 {
1324     cmsUInt32Number i;
1325 
1326     for (i=0; i < Icc -> TagCount; i++) {
1327 
1328         cmsTagSignature lnk = Icc ->TagLinked[i];
1329         if (lnk != (cmsTagSignature) 0) {
1330 
1331             int j = _cmsSearchTag(Icc, lnk, FALSE);
1332             if (j >= 0) {
1333 
1334                 Icc ->TagOffsets[i] = Icc ->TagOffsets[j];
1335                 Icc ->TagSizes[i]   = Icc ->TagSizes[j];
1336             }
1337 
1338         }
1339     }
1340 
1341     return TRUE;
1342 }
1343 
1344 // Low-level save to IOHANDLER. It returns the number of bytes used to
1345 // store the profile, or zero on error. io may be NULL and in this case
1346 // no data is written--only sizes are calculated
1347 cmsUInt32Number CMSEXPORT cmsSaveProfileToIOhandler(cmsHPROFILE hProfile, cmsIOHANDLER* io)
1348 {
1349     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1350     _cmsICCPROFILE Keep;
1351     cmsIOHANDLER* PrevIO = NULL;
1352     cmsUInt32Number UsedSpace;
1353     cmsContext ContextID;
1354 
1355     _cmsAssert(hProfile != NULL);
1356 
1357     if (!_cmsLockMutex(Icc->ContextID, Icc->UsrMutex)) return 0;
1358     memmove(&Keep, Icc, sizeof(_cmsICCPROFILE));
1359 
1360     ContextID = cmsGetProfileContextID(hProfile);
1361     PrevIO = Icc ->IOhandler = cmsOpenIOhandlerFromNULL(ContextID);
1362     if (PrevIO == NULL) {
1363         _cmsUnlockMutex(Icc->ContextID, Icc->UsrMutex);
1364         return 0;
1365     }
1366 
1367     // Pass #1 does compute offsets
1368 
1369     if (!_cmsWriteHeader(Icc, 0)) goto Error;
1370     if (!SaveTags(Icc, &Keep)) goto Error;
1371 
1372     UsedSpace = PrevIO ->UsedSpace;
1373 
1374     // Pass #2 does save to iohandler
1375 
1376     if (io != NULL) {
1377 
1378         Icc ->IOhandler = io;
1379         if (!SetLinks(Icc)) goto Error;
1380         if (!_cmsWriteHeader(Icc, UsedSpace)) goto Error;
1381         if (!SaveTags(Icc, &Keep)) goto Error;
1382     }
1383 
1384     memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
1385     if (!cmsCloseIOhandler(PrevIO))
1386         UsedSpace = 0; // As a error marker
1387 
1388     _cmsUnlockMutex(Icc->ContextID, Icc->UsrMutex);
1389 
1390     return UsedSpace;
1391 
1392 
1393 Error:
1394     cmsCloseIOhandler(PrevIO);
1395     memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
1396     _cmsUnlockMutex(Icc->ContextID, Icc->UsrMutex);
1397 
1398     return 0;
1399 }
1400 
1401 
1402 // Low-level save to disk.
1403 cmsBool  CMSEXPORT cmsSaveProfileToFile(cmsHPROFILE hProfile, const char* FileName)
1404 {
1405     cmsContext ContextID = cmsGetProfileContextID(hProfile);
1406     cmsIOHANDLER* io = cmsOpenIOhandlerFromFile(ContextID, FileName, "w");
1407     cmsBool rc;
1408 
1409     if (io == NULL) return FALSE;
1410 
1411     rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
1412     rc &= cmsCloseIOhandler(io);
1413 
1414     if (rc == FALSE) {          // remove() is C99 per 7.19.4.1
1415             remove(FileName);   // We have to IGNORE return value in this case
1416     }
1417     return rc;
1418 }
1419 
1420 // Same as anterior, but for streams
1421 cmsBool CMSEXPORT cmsSaveProfileToStream(cmsHPROFILE hProfile, FILE* Stream)
1422 {
1423     cmsBool rc;
1424     cmsContext ContextID = cmsGetProfileContextID(hProfile);
1425     cmsIOHANDLER* io = cmsOpenIOhandlerFromStream(ContextID, Stream);
1426 
1427     if (io == NULL) return FALSE;
1428 
1429     rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
1430     rc &= cmsCloseIOhandler(io);
1431 
1432     return rc;
1433 }
1434 
1435 
1436 // Same as anterior, but for memory blocks. In this case, a NULL as MemPtr means calculate needed space only
1437 cmsBool CMSEXPORT cmsSaveProfileToMem(cmsHPROFILE hProfile, void *MemPtr, cmsUInt32Number* BytesNeeded)
1438 {
1439     cmsBool rc;
1440     cmsIOHANDLER* io;
1441     cmsContext ContextID = cmsGetProfileContextID(hProfile);
1442 
1443     _cmsAssert(BytesNeeded != NULL);
1444 
1445     // Should we just calculate the needed space?
1446     if (MemPtr == NULL) {
1447 
1448            *BytesNeeded =  cmsSaveProfileToIOhandler(hProfile, NULL);
1449             return (*BytesNeeded == 0) ? FALSE : TRUE;
1450     }
1451 
1452     // That is a real write operation
1453     io =  cmsOpenIOhandlerFromMem(ContextID, MemPtr, *BytesNeeded, "w");
1454     if (io == NULL) return FALSE;
1455 
1456     rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
1457     rc &= cmsCloseIOhandler(io);
1458 
1459     return rc;
1460 }
1461 
1462 
1463 
1464 // Closes a profile freeing any involved resources
1465 cmsBool  CMSEXPORT cmsCloseProfile(cmsHPROFILE hProfile)
1466 {
1467     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1468     cmsBool  rc = TRUE;
1469     cmsUInt32Number i;
1470 
1471     if (!Icc) return FALSE;
1472 
1473     // Was open in write mode?
1474     if (Icc ->IsWrite) {
1475 
1476         Icc ->IsWrite = FALSE;      // Assure no further writing
1477         rc &= cmsSaveProfileToFile(hProfile, Icc ->IOhandler->PhysicalFile);
1478     }
1479 
1480     for (i=0; i < Icc -> TagCount; i++) {
1481 
1482         if (Icc -> TagPtrs[i]) {
1483 
1484             cmsTagTypeHandler* TypeHandler = Icc ->TagTypeHandlers[i];
1485 
1486             if (TypeHandler != NULL) {
1487                 cmsTagTypeHandler LocalTypeHandler = *TypeHandler;
1488 
1489                 LocalTypeHandler.ContextID = Icc ->ContextID;              // As an additional parameters
1490                 LocalTypeHandler.ICCVersion = Icc ->Version;
1491                 LocalTypeHandler.FreePtr(&LocalTypeHandler, Icc -> TagPtrs[i]);
1492             }
1493             else
1494                 _cmsFree(Icc ->ContextID, Icc ->TagPtrs[i]);
1495         }
1496     }
1497 
1498     if (Icc ->IOhandler != NULL) {
1499         rc &= cmsCloseIOhandler(Icc->IOhandler);
1500     }
1501 
1502     _cmsDestroyMutex(Icc->ContextID, Icc->UsrMutex);
1503 
1504     _cmsFree(Icc ->ContextID, Icc);   // Free placeholder memory
1505 
1506     return rc;
1507 }
1508 
1509 
1510 // -------------------------------------------------------------------------------------------------------------------
1511 
1512 
1513 // Returns TRUE if a given tag is supported by a plug-in
1514 static
1515 cmsBool IsTypeSupported(cmsTagDescriptor* TagDescriptor, cmsTagTypeSignature Type)
1516 {
1517     cmsUInt32Number i, nMaxTypes;
1518 
1519     nMaxTypes = TagDescriptor->nSupportedTypes;
1520     if (nMaxTypes >= MAX_TYPES_IN_LCMS_PLUGIN)
1521         nMaxTypes = MAX_TYPES_IN_LCMS_PLUGIN;
1522 
1523     for (i=0; i < nMaxTypes; i++) {
1524         if (Type == TagDescriptor ->SupportedTypes[i]) return TRUE;
1525     }
1526 
1527     return FALSE;
1528 }
1529 
1530 
1531 // That's the main read function
1532 void* CMSEXPORT cmsReadTag(cmsHPROFILE hProfile, cmsTagSignature sig)
1533 {
1534     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1535     cmsIOHANDLER* io = Icc ->IOhandler;
1536     cmsTagTypeHandler* TypeHandler;
1537     cmsTagTypeHandler LocalTypeHandler;
1538     cmsTagDescriptor*  TagDescriptor;
1539     cmsTagTypeSignature BaseType;
1540     cmsUInt32Number Offset, TagSize;
1541     cmsUInt32Number ElemCount;
1542     int n;
1543 
1544     if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return NULL;
1545 
1546     n = _cmsSearchTag(Icc, sig, TRUE);
1547     if (n < 0) goto Error;               // Not found, return NULL
1548 
1549 
1550     // If the element is already in memory, return the pointer
1551     if (Icc -> TagPtrs[n]) {
1552 
1553         if (Icc->TagTypeHandlers[n] == NULL) goto Error;
1554 
1555         // Sanity check
1556         BaseType = Icc->TagTypeHandlers[n]->Signature;
1557         if (BaseType == 0) goto Error;
1558 
1559         TagDescriptor = _cmsGetTagDescriptor(Icc->ContextID, sig);
1560         if (TagDescriptor == NULL) goto Error;
1561 
1562         if (!IsTypeSupported(TagDescriptor, BaseType)) goto Error;
1563 
1564         if (Icc ->TagSaveAsRaw[n]) goto Error;  // We don't support read raw tags as cooked
1565 
1566         _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1567         return Icc -> TagPtrs[n];
1568     }
1569 
1570     // We need to read it. Get the offset and size to the file
1571     Offset    = Icc -> TagOffsets[n];
1572     TagSize   = Icc -> TagSizes[n];
1573 
1574     if (TagSize < 8) goto Error;
1575 
1576     // Seek to its location
1577     if (!io -> Seek(io, Offset))
1578         goto Error;
1579 
1580     // Search for support on this tag
1581     TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
1582     if (TagDescriptor == NULL) {
1583 
1584         char String[5];
1585 
1586         _cmsTagSignature2String(String, sig);
1587 
1588         // An unknown element was found.
1589         cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown tag type '%s' found.", String);
1590         goto Error;     // Unsupported.
1591     }
1592 
1593     // if supported, get type and check if in list
1594     BaseType = _cmsReadTypeBase(io);
1595     if (BaseType == 0) goto Error;
1596 
1597     if (!IsTypeSupported(TagDescriptor, BaseType)) goto Error;
1598 
1599     TagSize  -= 8;       // Alredy read by the type base logic
1600 
1601     // Get type handler
1602     TypeHandler = _cmsGetTagTypeHandler(Icc ->ContextID, BaseType);
1603     if (TypeHandler == NULL) goto Error;
1604     LocalTypeHandler = *TypeHandler;
1605 
1606 
1607     // Read the tag
1608     Icc -> TagTypeHandlers[n] = TypeHandler;
1609 
1610     LocalTypeHandler.ContextID = Icc ->ContextID;
1611     LocalTypeHandler.ICCVersion = Icc ->Version;
1612     Icc -> TagPtrs[n] = LocalTypeHandler.ReadPtr(&LocalTypeHandler, io, &ElemCount, TagSize);
1613 
1614     // The tag type is supported, but something wrong happened and we cannot read the tag.
1615     // let know the user about this (although it is just a warning)
1616     if (Icc -> TagPtrs[n] == NULL) {
1617 
1618         char String[5];
1619 
1620         _cmsTagSignature2String(String, sig);
1621         cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "Corrupted tag '%s'", String);
1622         goto Error;
1623     }
1624 
1625     // This is a weird error that may be a symptom of something more serious, the number of
1626     // stored item is actually less than the number of required elements.
1627     if (ElemCount < TagDescriptor ->ElemCount) {
1628 
1629         char String[5];
1630 
1631         _cmsTagSignature2String(String, sig);
1632         cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "'%s' Inconsistent number of items: expected %d, got %d",
1633             String, TagDescriptor ->ElemCount, ElemCount);
1634     }
1635 
1636 
1637     // Return the data
1638     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1639     return Icc -> TagPtrs[n];
1640 
1641 
1642     // Return error and unlock tha data
1643 Error:
1644     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1645     return NULL;
1646 }
1647 
1648 
1649 // Get true type of data
1650 cmsTagTypeSignature _cmsGetTagTrueType(cmsHPROFILE hProfile, cmsTagSignature sig)
1651 {
1652     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1653     cmsTagTypeHandler* TypeHandler;
1654     int n;
1655 
1656     // Search for given tag in ICC profile directory
1657     n = _cmsSearchTag(Icc, sig, TRUE);
1658     if (n < 0) return (cmsTagTypeSignature) 0;                // Not found, return NULL
1659 
1660     // Get the handler. The true type is there
1661     TypeHandler =  Icc -> TagTypeHandlers[n];
1662     return TypeHandler ->Signature;
1663 }
1664 
1665 
1666 // Write a single tag. This just keeps track of the tak into a list of "to be written". If the tag is already
1667 // in that list, the previous version is deleted.
1668 cmsBool CMSEXPORT cmsWriteTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data)
1669 {
1670     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1671     cmsTagTypeHandler* TypeHandler = NULL;
1672     cmsTagTypeHandler LocalTypeHandler;
1673     cmsTagDescriptor* TagDescriptor = NULL;
1674     cmsTagTypeSignature Type;
1675     int i;
1676     cmsFloat64Number Version;
1677     char TypeString[5], SigString[5];
1678 
1679     if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return FALSE;
1680 
1681     // To delete tags.
1682     if (data == NULL) {
1683 
1684          // Delete the tag
1685          i = _cmsSearchTag(Icc, sig, FALSE);
1686          if (i >= 0) {
1687 
1688              // Use zero as a mark of deleted
1689              _cmsDeleteTagByPos(Icc, i);
1690              Icc ->TagNames[i] = (cmsTagSignature) 0;
1691              _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1692              return TRUE;
1693          }
1694          // Didn't find the tag
1695         goto Error;
1696     }
1697 
1698     if (!_cmsNewTag(Icc, sig, &i)) goto Error;
1699 
1700     // This is not raw
1701     Icc ->TagSaveAsRaw[i] = FALSE;
1702 
1703     // This is not a link
1704     Icc ->TagLinked[i] = (cmsTagSignature) 0;
1705 
1706     // Get information about the TAG.
1707     TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
1708     if (TagDescriptor == NULL){
1709          cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported tag '%x'", sig);
1710         goto Error;
1711     }
1712 
1713 
1714     // Now we need to know which type to use. It depends on the version.
1715     Version = cmsGetProfileVersion(hProfile);
1716 
1717     if (TagDescriptor ->DecideType != NULL) {
1718 
1719         // Let the tag descriptor to decide the type base on depending on
1720         // the data. This is useful for example on parametric curves, where
1721         // curves specified by a table cannot be saved as parametric and needs
1722         // to be casted to single v2-curves, even on v4 profiles.
1723 
1724         Type = TagDescriptor ->DecideType(Version, data);
1725     }
1726     else {
1727 
1728         Type = TagDescriptor ->SupportedTypes[0];
1729     }
1730 
1731     // Does the tag support this type?
1732     if (!IsTypeSupported(TagDescriptor, Type)) {
1733 
1734         _cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
1735         _cmsTagSignature2String(SigString,  sig);
1736 
1737         cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported type '%s' for tag '%s'", TypeString, SigString);
1738         goto Error;
1739     }
1740 
1741     // Does we have a handler for this type?
1742     TypeHandler =  _cmsGetTagTypeHandler(Icc->ContextID, Type);
1743     if (TypeHandler == NULL) {
1744 
1745         _cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
1746         _cmsTagSignature2String(SigString,  sig);
1747 
1748         cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported type '%s' for tag '%s'", TypeString, SigString);
1749         goto Error;           // Should never happen
1750     }
1751 
1752 
1753     // Fill fields on icc structure
1754     Icc ->TagTypeHandlers[i]  = TypeHandler;
1755     Icc ->TagNames[i]         = sig;
1756     Icc ->TagSizes[i]         = 0;
1757     Icc ->TagOffsets[i]       = 0;
1758 
1759     LocalTypeHandler = *TypeHandler;
1760     LocalTypeHandler.ContextID  = Icc ->ContextID;
1761     LocalTypeHandler.ICCVersion = Icc ->Version;
1762     Icc ->TagPtrs[i]            = LocalTypeHandler.DupPtr(&LocalTypeHandler, data, TagDescriptor ->ElemCount);
1763 
1764     if (Icc ->TagPtrs[i] == NULL)  {
1765 
1766         _cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
1767         _cmsTagSignature2String(SigString,  sig);
1768         cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "Malformed struct in type '%s' for tag '%s'", TypeString, SigString);
1769 
1770         goto Error;
1771     }
1772 
1773     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1774     return TRUE;
1775 
1776 Error:
1777     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1778     return FALSE;
1779 
1780 }
1781 
1782 // Read and write raw data. The only way those function would work and keep consistence with normal read and write
1783 // is to do an additional step of serialization. That means, readRaw would issue a normal read and then convert the obtained
1784 // data to raw bytes by using the "write" serialization logic. And vice-versa. I know this may end in situations where
1785 // raw data written does not exactly correspond with the raw data proposed to cmsWriteRaw data, but this approach allows
1786 // to write a tag as raw data and the read it as handled.
1787 
1788 cmsUInt32Number CMSEXPORT cmsReadRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, void* data, cmsUInt32Number BufferSize)
1789 {
1790     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1791     void *Object;
1792     int i;
1793     cmsIOHANDLER* MemIO;
1794     cmsTagTypeHandler* TypeHandler = NULL;
1795     cmsTagTypeHandler LocalTypeHandler;
1796     cmsTagDescriptor* TagDescriptor = NULL;
1797     cmsUInt32Number rc;
1798     cmsUInt32Number Offset, TagSize;
1799 
1800     if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
1801 
1802     // Search for given tag in ICC profile directory
1803     i = _cmsSearchTag(Icc, sig, TRUE);
1804     if (i < 0) goto Error;                 // Not found,
1805 
1806     // It is already read?
1807     if (Icc -> TagPtrs[i] == NULL) {
1808 
1809         // No yet, get original position
1810         Offset   = Icc ->TagOffsets[i];
1811         TagSize  = Icc ->TagSizes[i];
1812 
1813         // read the data directly, don't keep copy
1814         if (data != NULL) {
1815 
1816             if (BufferSize < TagSize)
1817                 TagSize = BufferSize;
1818 
1819             if (!Icc ->IOhandler ->Seek(Icc ->IOhandler, Offset)) goto Error;
1820             if (!Icc ->IOhandler ->Read(Icc ->IOhandler, data, 1, TagSize)) goto Error;
1821 
1822             _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1823             return TagSize;
1824         }
1825 
1826         _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1827         return Icc ->TagSizes[i];
1828     }
1829 
1830     // The data has been already read, or written. But wait!, maybe the user choosed to save as
1831     // raw data. In this case, return the raw data directly
1832     if (Icc ->TagSaveAsRaw[i]) {
1833 
1834         if (data != NULL)  {
1835 
1836             TagSize  = Icc ->TagSizes[i];
1837             if (BufferSize < TagSize)
1838                 TagSize = BufferSize;
1839 
1840             memmove(data, Icc ->TagPtrs[i], TagSize);
1841 
1842             _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1843             return TagSize;
1844         }
1845 
1846         _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1847         return Icc ->TagSizes[i];
1848     }
1849 
1850     // Already readed, or previously set by cmsWriteTag(). We need to serialize that
1851     // data to raw in order to maintain consistency.
1852 
1853     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1854     Object = cmsReadTag(hProfile, sig);
1855     if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
1856 
1857     if (Object == NULL) goto Error;
1858 
1859     // Now we need to serialize to a memory block: just use a memory iohandler
1860 
1861     if (data == NULL) {
1862         MemIO = cmsOpenIOhandlerFromNULL(cmsGetProfileContextID(hProfile));
1863     } else{
1864         MemIO = cmsOpenIOhandlerFromMem(cmsGetProfileContextID(hProfile), data, BufferSize, "w");
1865     }
1866     if (MemIO == NULL) goto Error;
1867 
1868     // Obtain type handling for the tag
1869     TypeHandler = Icc ->TagTypeHandlers[i];
1870     TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
1871     if (TagDescriptor == NULL) {
1872         cmsCloseIOhandler(MemIO);
1873         goto Error;
1874     }
1875 
1876     if (TypeHandler == NULL) goto Error;
1877 
1878     // Serialize
1879     LocalTypeHandler = *TypeHandler;
1880     LocalTypeHandler.ContextID  = Icc ->ContextID;
1881     LocalTypeHandler.ICCVersion = Icc ->Version;
1882 
1883     if (!_cmsWriteTypeBase(MemIO, TypeHandler ->Signature)) {
1884         cmsCloseIOhandler(MemIO);
1885         goto Error;
1886     }
1887 
1888     if (!LocalTypeHandler.WritePtr(&LocalTypeHandler, MemIO, Object, TagDescriptor ->ElemCount)) {
1889         cmsCloseIOhandler(MemIO);
1890         goto Error;
1891     }
1892 
1893     // Get Size and close
1894     rc = MemIO ->Tell(MemIO);
1895     cmsCloseIOhandler(MemIO);      // Ignore return code this time
1896 
1897     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1898     return rc;
1899 
1900 Error:
1901     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1902     return 0;
1903 }
1904 
1905 // Similar to the anterior. This function allows to write directly to the ICC profile any data, without
1906 // checking anything. As a rule, mixing Raw with cooked doesn't work, so writing a tag as raw and then reading
1907 // it as cooked without serializing does result into an error. If that is what you want, you will need to dump
1908 // the profile to memry or disk and then reopen it.
1909 cmsBool CMSEXPORT cmsWriteRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data, cmsUInt32Number Size)
1910 {
1911     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1912     int i;
1913 
1914     if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
1915 
1916     if (!_cmsNewTag(Icc, sig, &i)) {
1917         _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1918          return FALSE;
1919     }
1920 
1921     // Mark the tag as being written as RAW
1922     Icc ->TagSaveAsRaw[i] = TRUE;
1923     Icc ->TagNames[i]     = sig;
1924     Icc ->TagLinked[i]    = (cmsTagSignature) 0;
1925 
1926     // Keep a copy of the block
1927     Icc ->TagPtrs[i]  = _cmsDupMem(Icc ->ContextID, data, Size);
1928     Icc ->TagSizes[i] = Size;
1929 
1930     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1931 
1932     if (Icc->TagPtrs[i] == NULL) {
1933            Icc->TagNames[i] = (cmsTagSignature) 0;
1934            return FALSE;
1935     }
1936     return TRUE;
1937 }
1938 
1939 // Using this function you can collapse several tag entries to the same block in the profile
1940 cmsBool CMSEXPORT cmsLinkTag(cmsHPROFILE hProfile, cmsTagSignature sig, cmsTagSignature dest)
1941 {
1942     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1943     int i;
1944 
1945      if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return FALSE;
1946 
1947     if (!_cmsNewTag(Icc, sig, &i)) {
1948         _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1949         return FALSE;
1950     }
1951 
1952     // Keep necessary information
1953     Icc ->TagSaveAsRaw[i] = FALSE;
1954     Icc ->TagNames[i]     = sig;
1955     Icc ->TagLinked[i]    = dest;
1956 
1957     Icc ->TagPtrs[i]    = NULL;
1958     Icc ->TagSizes[i]   = 0;
1959     Icc ->TagOffsets[i] = 0;
1960 
1961     _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1962     return TRUE;
1963 }
1964 
1965 
1966 // Returns the tag linked to sig, in the case two tags are sharing same resource
1967 cmsTagSignature  CMSEXPORT cmsTagLinkedTo(cmsHPROFILE hProfile, cmsTagSignature sig)
1968 {
1969     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1970     int i;
1971 
1972     // Search for given tag in ICC profile directory
1973     i = _cmsSearchTag(Icc, sig, FALSE);
1974     if (i < 0) return (cmsTagSignature) 0;                 // Not found, return 0
1975 
1976     return Icc -> TagLinked[i];
1977 }