thirdparty/liblcms2/src/cmsnamed.c

   1 //---------------------------------------------------------------------------------
   2 //
   3 //  Little Color Management System
   4 //  Copyright (c) 1998-2016 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 // Multilocalized unicode objects. That is an attempt to encapsulate i18n.
  30
  31
  32 // Allocates an empty multi localizad unicode object
  33 cmsMLU* CMSEXPORT cmsMLUalloc(cmsContext ContextID, cmsUInt32Number nItems)
  34 {
  35     cmsMLU* mlu;
  36
  37     // nItems should be positive if given
  38     if (nItems <= 0) nItems = 2;
  39
  40     // Create the container
  41     mlu = (cmsMLU*) _cmsMallocZero(ContextID, sizeof(cmsMLU));
  42     if (mlu == NULL) return NULL;
  43
  44     mlu ->ContextID = ContextID;
  45
  46     // Create entry array
  47     mlu ->Entries = (_cmsMLUentry*) _cmsCalloc(ContextID, nItems, sizeof(_cmsMLUentry));
  48     if (mlu ->Entries == NULL) {
  49         _cmsFree(ContextID, mlu);
  50         return NULL;
  51     }
  52
  53     // Ok, keep indexes up to date
  54     mlu ->AllocatedEntries    = nItems;
  55     mlu ->UsedEntries         = 0;
  56
  57     return mlu;
  58 }
  59
  60
  61 // Grows a mempool table for a MLU. Each time this function is called, mempool size is multiplied times two.
  62 static
  63 cmsBool GrowMLUpool(cmsMLU* mlu)
  64 {
  65     cmsUInt32Number size;
  66     void *NewPtr;
  67
  68     // Sanity check
  69     if (mlu == NULL) return FALSE;
  70
  71     if (mlu ->PoolSize == 0)
  72         size = 256;
  73     else
  74         size = mlu ->PoolSize * 2;
  75
  76     // Check for overflow
  77     if (size < mlu ->PoolSize) return FALSE;
  78
  79     // Reallocate the pool
  80     NewPtr = _cmsRealloc(mlu ->ContextID, mlu ->MemPool, size);
  81     if (NewPtr == NULL) return FALSE;
  82
  83
  84     mlu ->MemPool  = NewPtr;
  85     mlu ->PoolSize = size;
  86
  87     return TRUE;
  88 }
  89
  90
  91 // Grows a entry table for a MLU. Each time this function is called, table size is multiplied times two.
  92 static
  93 cmsBool GrowMLUtable(cmsMLU* mlu)
  94 {
  95     cmsUInt32Number AllocatedEntries;
  96     _cmsMLUentry *NewPtr;
  97
  98     // Sanity check
  99     if (mlu == NULL) return FALSE;
 100
 101     AllocatedEntries = mlu ->AllocatedEntries * 2;
 102
 103     // Check for overflow
 104     if (AllocatedEntries / 2 != mlu ->AllocatedEntries) return FALSE;
 105
 106     // Reallocate the memory
 107     NewPtr = (_cmsMLUentry*)_cmsRealloc(mlu ->ContextID, mlu ->Entries, AllocatedEntries*sizeof(_cmsMLUentry));
 108     if (NewPtr == NULL) return FALSE;
 109
 110     mlu ->Entries          = NewPtr;
 111     mlu ->AllocatedEntries = AllocatedEntries;
 112
 113     return TRUE;
 114 }
 115
 116
 117 // Search for a specific entry in the structure. Language and Country are used.
 118 static
 119 int SearchMLUEntry(cmsMLU* mlu, cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
 120 {
 121     cmsUInt32Number i;
 122
 123     // Sanity check
 124     if (mlu == NULL) return -1;
 125
 126     // Iterate whole table
 127     for (i=0; i < mlu ->UsedEntries; i++) {
 128
 129         if (mlu ->Entries[i].Country  == CountryCode &&
 130             mlu ->Entries[i].Language == LanguageCode) return i;
 131     }
 132
 133     // Not found
 134     return -1;
 135 }
 136
 137 // Add a block of characters to the intended MLU. Language and country are specified.
 138 // Only one entry for Language/country pair is allowed.
 139 static
 140 cmsBool AddMLUBlock(cmsMLU* mlu, cmsUInt32Number size, const wchar_t *Block,
 141                      cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
 142 {
 143     cmsUInt32Number Offset;
 144     cmsUInt8Number* Ptr;
 145
 146     // Sanity check
 147     if (mlu == NULL) return FALSE;
 148
 149     // Is there any room available?
 150     if (mlu ->UsedEntries >= mlu ->AllocatedEntries) {
 151         if (!GrowMLUtable(mlu)) return FALSE;
 152     }
 153
 154     // Only one ASCII string
 155     if (SearchMLUEntry(mlu, LanguageCode, CountryCode) >= 0) return FALSE;  // Only one  is allowed!
 156
 157     // Check for size
 158     while ((mlu ->PoolSize - mlu ->PoolUsed) < size) {
 159
 160             if (!GrowMLUpool(mlu)) return FALSE;
 161     }
 162
 163     Offset = mlu ->PoolUsed;
 164
 165     Ptr = (cmsUInt8Number*) mlu ->MemPool;
 166     if (Ptr == NULL) return FALSE;
 167
 168     // Set the entry
 169     memmove(Ptr + Offset, Block, size);
 170     mlu ->PoolUsed += size;
 171
 172     mlu ->Entries[mlu ->UsedEntries].StrW     = Offset;
 173     mlu ->Entries[mlu ->UsedEntries].Len      = size;
 174     mlu ->Entries[mlu ->UsedEntries].Country  = CountryCode;
 175     mlu ->Entries[mlu ->UsedEntries].Language = LanguageCode;
 176     mlu ->UsedEntries++;
 177
 178     return TRUE;
 179 }
 180
 181 // Convert from a 3-char code to a cmsUInt16Number. It is done inthis way because some
 182 // compilers don't properly align beginning of strings
 183
 184 static
 185 cmsUInt16Number strTo16(const char str[3])
 186 {
 187     cmsUInt16Number n = ((cmsUInt16Number) str[0] << 8) | str[1];
 188
 189     return n;  // Always big endian in this case
 190 }
 191
 192 static
 193 void strFrom16(char str[3], cmsUInt16Number n)
 194 {
 195     // Assiming this would be aligned
 196     union {
 197
 198        cmsUInt16Number n;
 199        char str[2];
 200
 201     } c;
 202
 203     c.n = n;  // Always big endian in this case
 204
 205     str[0] = c.str[0]; str[1] = c.str[1]; str[2] = 0;
 206
 207 }
 208
 209 // Add an ASCII entry. Do not add any \0 termination (ICC1v43_2010-12.pdf page 61)
 210 cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString)
 211 {
 212     cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString);
 213     wchar_t* WStr;
 214     cmsBool  rc;
 215     cmsUInt16Number Lang  = strTo16(LanguageCode);
 216     cmsUInt16Number Cntry = strTo16(CountryCode);
 217
 218     if (mlu == NULL) return FALSE;
 219
 220     WStr = (wchar_t*) _cmsCalloc(mlu ->ContextID, len,  sizeof(wchar_t));
 221     if (WStr == NULL) return FALSE;
 222
 223     for (i=0; i < len; i++)
 224         WStr[i] = (wchar_t) ASCIIString[i];
 225
 226     rc = AddMLUBlock(mlu, len  * sizeof(wchar_t), WStr, Lang, Cntry);
 227
 228     _cmsFree(mlu ->ContextID, WStr);
 229     return rc;
 230
 231 }
 232
 233 // We don't need any wcs support library
 234 static
 235 cmsUInt32Number mywcslen(const wchar_t *s)
 236 {
 237     const wchar_t *p;
 238
 239     p = s;
 240     while (*p)
 241         p++;
 242
 243     return (cmsUInt32Number)(p - s);
 244 }
 245
 246 // Add a wide entry. Do not add any \0 terminator (ICC1v43_2010-12.pdf page 61)
 247 cmsBool  CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char Country[3], const wchar_t* WideString)
 248 {
 249     cmsUInt16Number Lang  = strTo16(Language);
 250     cmsUInt16Number Cntry = strTo16(Country);
 251     cmsUInt32Number len;
 252
 253     if (mlu == NULL) return FALSE;
 254     if (WideString == NULL) return FALSE;
 255
 256     len = (cmsUInt32Number) (mywcslen(WideString)) * sizeof(wchar_t);
 257     return AddMLUBlock(mlu, len, WideString, Lang, Cntry);
 258 }
 259
 260 // Duplicating a MLU is as easy as copying all members
 261 cmsMLU* CMSEXPORT cmsMLUdup(const cmsMLU* mlu)
 262 {
 263     cmsMLU* NewMlu = NULL;
 264
 265     // Duplicating a NULL obtains a NULL
 266     if (mlu == NULL) return NULL;
 267
 268     NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries);
 269     if (NewMlu == NULL) return NULL;
 270
 271     // Should never happen
 272     if (NewMlu ->AllocatedEntries < mlu ->UsedEntries)
 273         goto Error;
 274
 275     // Sanitize...
 276     if (NewMlu ->Entries == NULL || mlu ->Entries == NULL)  goto Error;
 277
 278     memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry));
 279     NewMlu ->UsedEntries = mlu ->UsedEntries;
 280
 281     // The MLU may be empty
 282     if (mlu ->PoolUsed == 0) {
 283         NewMlu ->MemPool = NULL;
 284     }
 285     else {
 286         // It is not empty
 287         NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed);
 288         if (NewMlu ->MemPool == NULL) goto Error;
 289     }
 290
 291     NewMlu ->PoolSize = mlu ->PoolUsed;
 292
 293     if (NewMlu ->MemPool == NULL || mlu ->MemPool == NULL) goto Error;
 294
 295     memmove(NewMlu ->MemPool, mlu->MemPool, mlu ->PoolUsed);
 296     NewMlu ->PoolUsed = mlu ->PoolUsed;
 297
 298     return NewMlu;
 299
 300 Error:
 301
 302     if (NewMlu != NULL) cmsMLUfree(NewMlu);
 303     return NULL;
 304 }
 305
 306 // Free any used memory
 307 void CMSEXPORT cmsMLUfree(cmsMLU* mlu)
 308 {
 309     if (mlu) {
 310
 311         if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);
 312         if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool);
 313
 314         _cmsFree(mlu ->ContextID, mlu);
 315     }
 316 }
 317
 318
 319 // The algorithm first searches for an exact match of country and language, if not found it uses
 320 // the Language. If none is found, first entry is used instead.
 321 static
 322 const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
 323                               cmsUInt32Number *len,
 324                               cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode,
 325                               cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode)
 326 {
 327     cmsUInt32Number i;
 328     cmsInt32Number Best = -1;
 329     _cmsMLUentry* v;
 330
 331     if (mlu == NULL) return NULL;
 332
 333     if (mlu -> AllocatedEntries <= 0) return NULL;
 334
 335     for (i=0; i < mlu ->UsedEntries; i++) {
 336
 337         v = mlu ->Entries + i;
 338
 339         if (v -> Language == LanguageCode) {
 340
 341             if (Best == -1) Best = i;
 342
 343             if (v -> Country == CountryCode) {
 344
 345                 if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
 346                 if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;
 347
 348                 if (len != NULL) *len = v ->Len;
 349
 350                 return (wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v -> StrW);        // Found exact match
 351             }
 352         }
 353     }
 354
 355     // No string found. Return First one
 356     if (Best == -1)
 357         Best = 0;
 358
 359     v = mlu ->Entries + Best;
 360
 361     if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
 362     if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;
 363
 364     if (len != NULL) *len   = v ->Len;
 365
 366     return(wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v ->StrW);
 367 }
 368
 369
 370 // Obtain an ASCII representation of the wide string. Setting buffer to NULL returns the len
 371 cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
 372                                        const char LanguageCode[3], const char CountryCode[3],
 373                                        char* Buffer, cmsUInt32Number BufferSize)
 374 {
 375     const wchar_t *Wide;
 376     cmsUInt32Number  StrLen = 0;
 377     cmsUInt32Number ASCIIlen, i;
 378
 379     cmsUInt16Number Lang  = strTo16(LanguageCode);
 380     cmsUInt16Number Cntry = strTo16(CountryCode);
 381
 382     // Sanitize
 383     if (mlu == NULL) return 0;
 384
 385     // Get WideChar
 386     Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
 387     if (Wide == NULL) return 0;
 388
 389     ASCIIlen = StrLen / sizeof(wchar_t);
 390
 391     // Maybe we want only to know the len?
 392     if (Buffer == NULL) return ASCIIlen + 1; // Note the zero at the end
 393
 394     // No buffer size means no data
 395     if (BufferSize <= 0) return 0;
 396
 397     // Some clipping may be required
 398     if (BufferSize < ASCIIlen + 1)
 399         ASCIIlen = BufferSize - 1;
 400
 401     // Precess each character
 402     for (i=0; i < ASCIIlen; i++) {
 403
 404         if (Wide[i] == 0)
 405             Buffer[i] = 0;
 406         else
 407             Buffer[i] = (char) Wide[i];
 408     }
 409
 410     // We put a termination "\0"
 411     Buffer[ASCIIlen] = 0;
 412     return ASCIIlen + 1;
 413 }
 414
 415 // Obtain a wide representation of the MLU, on depending on current locale settings
 416 cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,
 417                                       const char LanguageCode[3], const char CountryCode[3],
 418                                       wchar_t* Buffer, cmsUInt32Number BufferSize)
 419 {
 420     const wchar_t *Wide;
 421     cmsUInt32Number  StrLen = 0;
 422
 423     cmsUInt16Number Lang  = strTo16(LanguageCode);
 424     cmsUInt16Number Cntry = strTo16(CountryCode);
 425
 426     // Sanitize
 427     if (mlu == NULL) return 0;
 428
 429     Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
 430     if (Wide == NULL) return 0;
 431
 432     // Maybe we want only to know the len?
 433     if (Buffer == NULL) return StrLen + sizeof(wchar_t);
 434
 435   // No buffer size means no data
 436     if (BufferSize <= 0) return 0;
 437
 438     // Some clipping may be required
 439     if (BufferSize < StrLen + sizeof(wchar_t))
 440         StrLen = BufferSize - + sizeof(wchar_t);
 441
 442     memmove(Buffer, Wide, StrLen);
 443     Buffer[StrLen / sizeof(wchar_t)] = 0;
 444
 445     return StrLen + sizeof(wchar_t);
 446 }
 447
 448
 449 // Get also the language and country
 450 CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
 451                                               const char LanguageCode[3], const char CountryCode[3],
 452                                               char ObtainedLanguage[3], char ObtainedCountry[3])
 453 {
 454     const wchar_t *Wide;
 455
 456     cmsUInt16Number Lang  = strTo16(LanguageCode);
 457     cmsUInt16Number Cntry = strTo16(CountryCode);
 458     cmsUInt16Number ObtLang, ObtCode;
 459
 460     // Sanitize
 461     if (mlu == NULL) return FALSE;
 462
 463     Wide = _cmsMLUgetWide(mlu, NULL, Lang, Cntry, &ObtLang, &ObtCode);
 464     if (Wide == NULL) return FALSE;
 465
 466     // Get used language and code
 467     strFrom16(ObtainedLanguage, ObtLang);
 468     strFrom16(ObtainedCountry, ObtCode);
 469
 470     return TRUE;
 471 }
 472
 473
 474
 475 // Get the number of translations in the MLU object
 476 cmsUInt32Number CMSEXPORT cmsMLUtranslationsCount(const cmsMLU* mlu)
 477 {
 478     if (mlu == NULL) return 0;
 479     return mlu->UsedEntries;
 480 }
 481
 482 // Get the language and country codes for a specific MLU index
 483 cmsBool CMSEXPORT cmsMLUtranslationsCodes(const cmsMLU* mlu,
 484                                           cmsUInt32Number idx,
 485                                           char LanguageCode[3],
 486                                           char CountryCode[3])
 487 {
 488     _cmsMLUentry *entry;
 489
 490     if (mlu == NULL) return FALSE;
 491
 492     if (idx >= mlu->UsedEntries) return FALSE;
 493
 494     entry = &mlu->Entries[idx];
 495
 496     strFrom16(LanguageCode, entry->Language);
 497     strFrom16(CountryCode, entry->Country);
 498
 499     return TRUE;
 500 }
 501
 502
 503 // Named color lists --------------------------------------------------------------------------------------------
 504
 505 // Grow the list to keep at least NumElements
 506 static
 507 cmsBool  GrowNamedColorList(cmsNAMEDCOLORLIST* v)
 508 {
 509     cmsUInt32Number size;
 510     _cmsNAMEDCOLOR * NewPtr;
 511
 512     if (v == NULL) return FALSE;
 513
 514     if (v ->Allocated == 0)
 515         size = 64;   // Initial guess
 516     else
 517         size = v ->Allocated * 2;
 518
 519     // Keep a maximum color lists can grow, 100K entries seems reasonable
 520     if (size > 1024*100) return FALSE;
 521
 522     NewPtr = (_cmsNAMEDCOLOR*) _cmsRealloc(v ->ContextID, v ->List, size * sizeof(_cmsNAMEDCOLOR));
 523     if (NewPtr == NULL)
 524         return FALSE;
 525
 526     v ->List      = NewPtr;
 527     v ->Allocated = size;
 528     return TRUE;
 529 }
 530
 531 // Allocate a list for n elements
 532 cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUInt32Number n, cmsUInt32Number ColorantCount, const char* Prefix, const char* Suffix)
 533 {
 534     cmsNAMEDCOLORLIST* v = (cmsNAMEDCOLORLIST*) _cmsMallocZero(ContextID, sizeof(cmsNAMEDCOLORLIST));
 535
 536     if (v == NULL) return NULL;
 537
 538     v ->List      = NULL;
 539     v ->nColors   = 0;
 540     v ->ContextID  = ContextID;
 541
 542     while (v -> Allocated < n){
 543         if (!GrowNamedColorList(v)) return NULL;
 544     }
 545
 546     strncpy(v ->Prefix, Prefix, sizeof(v ->Prefix)-1);
 547     strncpy(v ->Suffix, Suffix, sizeof(v ->Suffix)-1);
 548     v->Prefix[32] = v->Suffix[32] = 0;
 549
 550     v -> ColorantCount = ColorantCount;
 551
 552     return v;
 553 }
 554
 555 // Free a list
 556 void CMSEXPORT cmsFreeNamedColorList(cmsNAMEDCOLORLIST* v)
 557 {
 558     if (v == NULL) return;
 559     if (v ->List) _cmsFree(v ->ContextID, v ->List);
 560     _cmsFree(v ->ContextID, v);
 561 }
 562
 563 cmsNAMEDCOLORLIST* CMSEXPORT cmsDupNamedColorList(const cmsNAMEDCOLORLIST* v)
 564 {
 565     cmsNAMEDCOLORLIST* NewNC;
 566
 567     if (v == NULL) return NULL;
 568
 569     NewNC= cmsAllocNamedColorList(v ->ContextID, v -> nColors, v ->ColorantCount, v ->Prefix, v ->Suffix);
 570     if (NewNC == NULL) return NULL;
 571
 572     // For really large tables we need this
 573     while (NewNC ->Allocated < v ->Allocated){
 574         if (!GrowNamedColorList(NewNC)) return NULL;
 575     }
 576
 577     memmove(NewNC ->Prefix, v ->Prefix, sizeof(v ->Prefix));
 578     memmove(NewNC ->Suffix, v ->Suffix, sizeof(v ->Suffix));
 579     NewNC ->ColorantCount = v ->ColorantCount;
 580     memmove(NewNC->List, v ->List, v->nColors * sizeof(_cmsNAMEDCOLOR));
 581     NewNC ->nColors = v ->nColors;
 582     return NewNC;
 583 }
 584
 585
 586 // Append a color to a list. List pointer may change if reallocated
 587 cmsBool  CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
 588                                        const char* Name,
 589                                        cmsUInt16Number PCS[3], cmsUInt16Number Colorant[cmsMAXCHANNELS])
 590 {
 591     cmsUInt32Number i;
 592
 593     if (NamedColorList == NULL) return FALSE;
 594
 595     if (NamedColorList ->nColors + 1 > NamedColorList ->Allocated) {
 596         if (!GrowNamedColorList(NamedColorList)) return FALSE;
 597     }
 598
 599     for (i=0; i < NamedColorList ->ColorantCount; i++)
 600         NamedColorList ->List[NamedColorList ->nColors].DeviceColorant[i] = Colorant == NULL? 0 : Colorant[i];
 601
 602     for (i=0; i < 3; i++)
 603         NamedColorList ->List[NamedColorList ->nColors].PCS[i] = PCS == NULL ? 0 : PCS[i];
 604
 605     if (Name != NULL) {
 606
 607         strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name, cmsMAX_PATH-1);
 608         NamedColorList ->List[NamedColorList ->nColors].Name[cmsMAX_PATH-1] = 0;
 609
 610     }
 611     else
 612         NamedColorList ->List[NamedColorList ->nColors].Name[0] = 0;
 613
 614
 615     NamedColorList ->nColors++;
 616     return TRUE;
 617 }
 618
 619 // Returns number of elements
 620 cmsUInt32Number CMSEXPORT cmsNamedColorCount(const cmsNAMEDCOLORLIST* NamedColorList)
 621 {
 622      if (NamedColorList == NULL) return 0;
 623      return NamedColorList ->nColors;
 624 }
 625
 626 // Info aboout a given color
 627 cmsBool  CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor,
 628                                      char* Name,
 629                                      char* Prefix,
 630                                      char* Suffix,
 631                                      cmsUInt16Number* PCS,
 632                                      cmsUInt16Number* Colorant)
 633 {
 634     if (NamedColorList == NULL) return FALSE;
 635
 636     if (nColor >= cmsNamedColorCount(NamedColorList)) return FALSE;
 637
 638     if (Name) strcpy(Name, NamedColorList->List[nColor].Name);
 639     if (Prefix) strcpy(Prefix, NamedColorList->Prefix);
 640     if (Suffix) strcpy(Suffix, NamedColorList->Suffix);
 641     if (PCS)
 642         memmove(PCS, NamedColorList ->List[nColor].PCS, 3*sizeof(cmsUInt16Number));
 643
 644     if (Colorant)
 645         memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant,
 646                                 sizeof(cmsUInt16Number) * NamedColorList ->ColorantCount);
 647
 648
 649     return TRUE;
 650 }
 651
 652 // Search for a given color name (no prefix or suffix)
 653 cmsInt32Number CMSEXPORT cmsNamedColorIndex(const cmsNAMEDCOLORLIST* NamedColorList, const char* Name)
 654 {
 655     int i, n;
 656
 657     if (NamedColorList == NULL) return -1;
 658     n = cmsNamedColorCount(NamedColorList);
 659     for (i=0; i < n; i++) {
 660         if (cmsstrcasecmp(Name,  NamedColorList->List[i].Name) == 0)
 661             return i;
 662     }
 663
 664     return -1;
 665 }
 666
 667 // MPE support -----------------------------------------------------------------------------------------------------------------
 668
 669 static
 670 void FreeNamedColorList(cmsStage* mpe)
 671 {
 672     cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
 673     cmsFreeNamedColorList(List);
 674 }
 675
 676 static
 677 void* DupNamedColorList(cmsStage* mpe)
 678 {
 679     cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
 680     return cmsDupNamedColorList(List);
 681 }
 682
 683 static
 684 void EvalNamedColorPCS(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
 685 {
 686     cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
 687     cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
 688
 689     if (index >= NamedColorList-> nColors) {
 690         cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
 691     }
 692     else {
 693
 694             // Named color always uses Lab
 695             Out[0] = (cmsFloat32Number) (NamedColorList->List[index].PCS[0] / 65535.0);
 696             Out[1] = (cmsFloat32Number) (NamedColorList->List[index].PCS[1] / 65535.0);
 697             Out[2] = (cmsFloat32Number) (NamedColorList->List[index].PCS[2] / 65535.0);
 698     }
 699 }
 700
 701 static
 702 void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
 703 {
 704     cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
 705     cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
 706     cmsUInt32Number j;
 707
 708     if (index >= NamedColorList-> nColors) {
 709         cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
 710     }
 711     else {
 712         for (j=0; j < NamedColorList ->ColorantCount; j++)
 713             Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0);
 714     }
 715 }
 716
 717
 718 // Named color lookup element
 719 cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList, cmsBool UsePCS)
 720 {
 721     return _cmsStageAllocPlaceholder(NamedColorList ->ContextID,
 722                                    cmsSigNamedColorElemType,
 723                                    1, UsePCS ? 3 : NamedColorList ->ColorantCount,
 724                                    UsePCS ? EvalNamedColorPCS : EvalNamedColor,
 725                                    DupNamedColorList,
 726                                    FreeNamedColorList,
 727                                    cmsDupNamedColorList(NamedColorList));
 728
 729 }
 730
 731
 732 // Retrieve the named color list from a transform. Should be first element in the LUT
 733 cmsNAMEDCOLORLIST* CMSEXPORT cmsGetNamedColorList(cmsHTRANSFORM xform)
 734 {
 735     _cmsTRANSFORM* v = (_cmsTRANSFORM*) xform;
 736     cmsStage* mpe  = v ->Lut->Elements;
 737
 738     if (mpe ->Type != cmsSigNamedColorElemType) return NULL;
 739     return (cmsNAMEDCOLORLIST*) mpe ->Data;
 740 }
 741
 742
 743 // Profile sequence description routines -------------------------------------------------------------------------------------
 744
 745 cmsSEQ* CMSEXPORT cmsAllocProfileSequenceDescription(cmsContext ContextID, cmsUInt32Number n)
 746 {
 747     cmsSEQ* Seq;
 748     cmsUInt32Number i;
 749
 750     if (n == 0) return NULL;
 751
 752     // In a absolutely arbitrary way, I hereby decide to allow a maxim of 255 profiles linked
 753     // in a devicelink. It makes not sense anyway and may be used for exploits, so let's close the door!
 754     if (n > 255) return NULL;
 755
 756     Seq = (cmsSEQ*) _cmsMallocZero(ContextID, sizeof(cmsSEQ));
 757     if (Seq == NULL) return NULL;
 758
 759     Seq -> ContextID = ContextID;
 760     Seq -> seq      = (cmsPSEQDESC*) _cmsCalloc(ContextID, n, sizeof(cmsPSEQDESC));
 761     Seq -> n        = n;
 762
 763     if (Seq -> seq == NULL) {
 764         _cmsFree(ContextID, Seq);
 765         return NULL;
 766     }
 767
 768     for (i=0; i < n; i++) {
 769         Seq -> seq[i].Manufacturer = NULL;
 770         Seq -> seq[i].Model        = NULL;
 771         Seq -> seq[i].Description  = NULL;
 772     }
 773
 774     return Seq;
 775 }
 776
 777 void CMSEXPORT cmsFreeProfileSequenceDescription(cmsSEQ* pseq)
 778 {
 779     cmsUInt32Number i;
 780
 781     for (i=0; i < pseq ->n; i++) {
 782         if (pseq ->seq[i].Manufacturer != NULL) cmsMLUfree(pseq ->seq[i].Manufacturer);
 783         if (pseq ->seq[i].Model != NULL) cmsMLUfree(pseq ->seq[i].Model);
 784         if (pseq ->seq[i].Description != NULL) cmsMLUfree(pseq ->seq[i].Description);
 785     }
 786
 787     if (pseq ->seq != NULL) _cmsFree(pseq ->ContextID, pseq ->seq);
 788     _cmsFree(pseq -> ContextID, pseq);
 789 }
 790
 791 cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq)
 792 {
 793     cmsSEQ *NewSeq;
 794     cmsUInt32Number i;
 795
 796     if (pseq == NULL)
 797         return NULL;
 798
 799     NewSeq = (cmsSEQ*) _cmsMalloc(pseq -> ContextID, sizeof(cmsSEQ));
 800     if (NewSeq == NULL) return NULL;
 801
 802
 803     NewSeq -> seq      = (cmsPSEQDESC*) _cmsCalloc(pseq ->ContextID, pseq ->n, sizeof(cmsPSEQDESC));
 804     if (NewSeq ->seq == NULL) goto Error;
 805
 806     NewSeq -> ContextID = pseq ->ContextID;
 807     NewSeq -> n        = pseq ->n;
 808
 809     for (i=0; i < pseq->n; i++) {
 810
 811         memmove(&NewSeq ->seq[i].attributes, &pseq ->seq[i].attributes, sizeof(cmsUInt64Number));
 812
 813         NewSeq ->seq[i].deviceMfg   = pseq ->seq[i].deviceMfg;
 814         NewSeq ->seq[i].deviceModel = pseq ->seq[i].deviceModel;
 815         memmove(&NewSeq ->seq[i].ProfileID, &pseq ->seq[i].ProfileID, sizeof(cmsProfileID));
 816         NewSeq ->seq[i].technology  = pseq ->seq[i].technology;
 817
 818         NewSeq ->seq[i].Manufacturer = cmsMLUdup(pseq ->seq[i].Manufacturer);
 819         NewSeq ->seq[i].Model        = cmsMLUdup(pseq ->seq[i].Model);
 820         NewSeq ->seq[i].Description  = cmsMLUdup(pseq ->seq[i].Description);
 821
 822     }
 823
 824     return NewSeq;
 825
 826 Error:
 827
 828     cmsFreeProfileSequenceDescription(NewSeq);
 829     return NULL;
 830 }
 831
 832 // Dictionaries --------------------------------------------------------------------------------------------------------
 833
 834 // Dictionaries are just very simple linked lists
 835
 836
 837 typedef struct _cmsDICT_struct {
 838     cmsDICTentry* head;
 839     cmsContext ContextID;
 840 } _cmsDICT;
 841
 842
 843 // Allocate an empty dictionary
 844 cmsHANDLE CMSEXPORT cmsDictAlloc(cmsContext ContextID)
 845 {
 846     _cmsDICT* dict = (_cmsDICT*) _cmsMallocZero(ContextID, sizeof(_cmsDICT));
 847     if (dict == NULL) return NULL;
 848
 849     dict ->ContextID = ContextID;
 850     return (cmsHANDLE) dict;
 851
 852 }
 853
 854 // Dispose resources
 855 void CMSEXPORT cmsDictFree(cmsHANDLE hDict)
 856 {
 857     _cmsDICT* dict = (_cmsDICT*) hDict;
 858     cmsDICTentry *entry, *next;
 859
 860     _cmsAssert(dict != NULL);
 861
 862     // Walk the list freeing all nodes
 863     entry = dict ->head;
 864     while (entry != NULL) {
 865
 866             if (entry ->DisplayName  != NULL) cmsMLUfree(entry ->DisplayName);
 867             if (entry ->DisplayValue != NULL) cmsMLUfree(entry ->DisplayValue);
 868             if (entry ->Name != NULL) _cmsFree(dict ->ContextID, entry -> Name);
 869             if (entry ->Value != NULL) _cmsFree(dict ->ContextID, entry -> Value);
 870
 871             // Don't fall in the habitual trap...
 872             next = entry ->Next;
 873             _cmsFree(dict ->ContextID, entry);
 874
 875             entry = next;
 876     }
 877
 878     _cmsFree(dict ->ContextID, dict);
 879 }
 880
 881
 882 // Duplicate a wide char string
 883 static
 884 wchar_t* DupWcs(cmsContext ContextID, const wchar_t* ptr)
 885 {
 886     if (ptr == NULL) return NULL;
 887     return (wchar_t*) _cmsDupMem(ContextID, ptr, (mywcslen(ptr) + 1) * sizeof(wchar_t));
 888 }
 889
 890 // Add a new entry to the linked list
 891 cmsBool CMSEXPORT cmsDictAddEntry(cmsHANDLE hDict, const wchar_t* Name, const wchar_t* Value, const cmsMLU *DisplayName, const cmsMLU *DisplayValue)
 892 {
 893     _cmsDICT* dict = (_cmsDICT*) hDict;
 894     cmsDICTentry *entry;
 895
 896     _cmsAssert(dict != NULL);
 897     _cmsAssert(Name != NULL);
 898
 899     entry = (cmsDICTentry*) _cmsMallocZero(dict ->ContextID, sizeof(cmsDICTentry));
 900     if (entry == NULL) return FALSE;
 901
 902     entry ->DisplayName  = cmsMLUdup(DisplayName);
 903     entry ->DisplayValue = cmsMLUdup(DisplayValue);
 904     entry ->Name         = DupWcs(dict ->ContextID, Name);
 905     entry ->Value        = DupWcs(dict ->ContextID, Value);
 906
 907     entry ->Next = dict ->head;
 908     dict ->head = entry;
 909
 910     return TRUE;
 911 }
 912
 913
 914 // Duplicates an existing dictionary
 915 cmsHANDLE CMSEXPORT cmsDictDup(cmsHANDLE hDict)
 916 {
 917     _cmsDICT* old_dict = (_cmsDICT*) hDict;
 918     cmsHANDLE hNew;
 919     cmsDICTentry *entry;
 920
 921     _cmsAssert(old_dict != NULL);
 922
 923     hNew  = cmsDictAlloc(old_dict ->ContextID);
 924     if (hNew == NULL) return NULL;
 925
 926     // Walk the list freeing all nodes
 927     entry = old_dict ->head;
 928     while (entry != NULL) {
 929
 930         if (!cmsDictAddEntry(hNew, entry ->Name, entry ->Value, entry ->DisplayName, entry ->DisplayValue)) {
 931
 932             cmsDictFree(hNew);
 933             return NULL;
 934         }
 935
 936         entry = entry -> Next;
 937     }
 938
 939     return hNew;
 940 }
 941
 942 // Get a pointer to the linked list
 943 const cmsDICTentry* CMSEXPORT cmsDictGetEntryList(cmsHANDLE hDict)
 944 {
 945     _cmsDICT* dict = (_cmsDICT*) hDict;
 946
 947     if (dict == NULL) return NULL;
 948     return dict ->head;
 949 }
 950
 951 // Helper For external languages
 952 const cmsDICTentry* CMSEXPORT cmsDictNextEntry(const cmsDICTentry* e)
 953 {
 954      if (e == NULL) return NULL;
 955      return e ->Next;
 956 }