src/cmsio0.c

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