thirdparty/liblcms2/src/cmsnamed.c

   1 //---------------------------------------------------------------------------------
   2 //
   3 //  Little Color Management System
   4 //  Copyright (c) 1998-2010 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 ntry 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     int 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     int 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
 182 // Add an ASCII entry.
 183 cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString)
 184 {
 185     cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString)+1;
 186     wchar_t* WStr;
 187     cmsBool  rc;
 188     cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
 189     cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
 190
 191     if (mlu == NULL) return FALSE;
 192
 193     WStr = (wchar_t*) _cmsCalloc(mlu ->ContextID, len,  sizeof(wchar_t));
 194     if (WStr == NULL) return FALSE;
 195
 196     for (i=0; i < len; i++)
 197         WStr[i] = (wchar_t) ASCIIString[i];
 198
 199     rc = AddMLUBlock(mlu, len  * sizeof(wchar_t), WStr, Lang, Cntry);
 200
 201     _cmsFree(mlu ->ContextID, WStr);
 202     return rc;
 203
 204 }
 205
 206 // We don't need any wcs support library
 207 static
 208 cmsUInt32Number mywcslen(const wchar_t *s)
 209 {
 210     const wchar_t *p;
 211
 212         p = s;
 213     while (*p)
 214         p++;
 215
 216     return (cmsUInt32Number)(p - s);
 217 }
 218
 219
 220 // Add a wide entry
 221 cmsBool  CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char Country[3], const wchar_t* WideString)
 222 {
 223     cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) Language);
 224     cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) Country);
 225     cmsUInt32Number len;
 226
 227     if (mlu == NULL) return FALSE;
 228         if (WideString == NULL) return FALSE;
 229
 230     len = (cmsUInt32Number) (mywcslen(WideString) + 1) * sizeof(wchar_t);
 231     return AddMLUBlock(mlu, len, WideString, Lang, Cntry);
 232 }
 233
 234 // Duplicating a MLU is as easy as copying all members
 235 cmsMLU* CMSEXPORT cmsMLUdup(const cmsMLU* mlu)
 236 {
 237         cmsMLU* NewMlu = NULL;
 238
 239         // Duplicating a NULL obtains a NULL
 240         if (mlu == NULL) return NULL;
 241
 242         NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries);
 243         if (NewMlu == NULL) return NULL;
 244
 245         // Should never happen
 246         if (NewMlu ->AllocatedEntries < mlu ->UsedEntries)
 247                 goto Error;
 248
 249         // Sanitize...
 250         if (NewMlu ->Entries == NULL || mlu ->Entries == NULL)  goto Error;
 251
 252         memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry));
 253         NewMlu ->UsedEntries = mlu ->UsedEntries;
 254
 255         // The MLU may be empty
 256         if (mlu ->PoolUsed == 0) {
 257                 NewMlu ->MemPool = NULL;
 258         }
 259         else {
 260                 // It is not empty
 261                 NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed);
 262                 if (NewMlu ->MemPool == NULL) goto Error;
 263         }
 264
 265         NewMlu ->PoolSize = mlu ->PoolUsed;
 266
 267         if (NewMlu ->MemPool == NULL || mlu ->MemPool == NULL) goto Error;
 268
 269         memmove(NewMlu ->MemPool, mlu->MemPool, mlu ->PoolUsed);
 270         NewMlu ->PoolUsed = mlu ->PoolUsed;
 271
 272         return NewMlu;
 273
 274 Error:
 275
 276         if (NewMlu != NULL) cmsMLUfree(NewMlu);
 277         return NULL;
 278 }
 279
 280 // Free any used memory
 281 void CMSEXPORT cmsMLUfree(cmsMLU* mlu)
 282 {
 283         if (mlu) {
 284
 285                 if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);
 286                 if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool);
 287
 288                 _cmsFree(mlu ->ContextID, mlu);
 289         }
 290 }
 291
 292
 293 // The algorithm first searches for an exact match of country and language, if not found it uses
 294 // the Language. If none is found, first entry is used instead.
 295 static
 296 const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
 297                                                           cmsUInt32Number *len,
 298                                                           cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode,
 299                                                           cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode)
 300 {
 301     int i;
 302     int Best = -1;
 303         _cmsMLUentry* v;
 304
 305     if (mlu == NULL) return NULL;
 306
 307     if (mlu -> AllocatedEntries <= 0) return NULL;
 308
 309     for (i=0; i < mlu ->UsedEntries; i++) {
 310
 311         v = mlu ->Entries + i;
 312
 313         if (v -> Language == LanguageCode) {
 314
 315             if (Best == -1) Best = i;
 316
 317             if (v -> Country == CountryCode) {
 318
 319                                 if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
 320                                 if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;
 321
 322                 if (len != NULL) *len = v ->Len;
 323
 324                 return (wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v -> StrW);        // Found exact match
 325             }
 326         }
 327     }
 328
 329     // No string found. Return First one
 330     if (Best == -1)
 331         Best = 0;
 332
 333          v = mlu ->Entries + Best;
 334
 335          if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
 336         if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;
 337
 338     if (len != NULL) *len   = v ->Len;
 339
 340         return(wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v ->StrW);
 341 }
 342
 343
 344 // Obtain an ASCII representation of the wide string. Setting buffer to NULL returns the len
 345 cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
 346                                                                            const char LanguageCode[3], const char CountryCode[3],
 347                                                                            char* Buffer, cmsUInt32Number BufferSize)
 348 {
 349     const wchar_t *Wide;
 350     cmsUInt32Number  StrLen = 0;
 351     cmsUInt32Number ASCIIlen, i;
 352
 353         cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
 354     cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
 355
 356         // Sanitize
 357     if (mlu == NULL) return 0;
 358
 359     // Get WideChar
 360     Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
 361     if (Wide == NULL) return 0;
 362
 363     ASCIIlen = StrLen / sizeof(wchar_t);
 364
 365     // Maybe we want only to know the len?
 366     if (Buffer == NULL) return ASCIIlen + 1; // Note the zero at the end
 367
 368     // No buffer size means no data
 369     if (BufferSize <= 0) return 0;
 370
 371     // Some clipping may be required
 372     if (BufferSize < ASCIIlen + 1)
 373         ASCIIlen = BufferSize - 1;
 374
 375     // Precess each character
 376     for (i=0; i < ASCIIlen; i++) {
 377
 378         if (Wide[i] == 0)
 379             Buffer[i] = 0;
 380         else
 381             Buffer[i] = (char) Wide[i];
 382     }
 383
 384         // We put a termination "\0"
 385     Buffer[ASCIIlen] = 0;
 386     return ASCIIlen + 1;
 387 }
 388
 389 // Obtain a wide representation of the MLU, on depending on current locale settings
 390 cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,
 391                                                                           const char LanguageCode[3], const char CountryCode[3],
 392                                                                           wchar_t* Buffer, cmsUInt32Number BufferSize)
 393 {
 394     const wchar_t *Wide;
 395     cmsUInt32Number  StrLen = 0;
 396
 397         cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
 398     cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
 399
 400         // Sanitize
 401     if (mlu == NULL) return 0;
 402
 403     Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
 404     if (Wide == NULL) return 0;
 405
 406     // Maybe we want only to know the len?
 407     if (Buffer == NULL) return StrLen + sizeof(wchar_t);
 408
 409   // No buffer size means no data
 410     if (BufferSize <= 0) return 0;
 411
 412     // Some clipping may be required
 413     if (BufferSize < StrLen + sizeof(wchar_t))
 414         StrLen = BufferSize - + sizeof(wchar_t);
 415
 416     memmove(Buffer, Wide, StrLen);
 417         Buffer[StrLen / sizeof(wchar_t)] = 0;
 418
 419     return StrLen + sizeof(wchar_t);
 420 }
 421
 422
 423 // Get also the language and country
 424 CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
 425                                                           const char LanguageCode[3], const char CountryCode[3],
 426                                                                                       char ObtainedLanguage[3], char ObtainedCountry[3])
 427 {
 428         const wchar_t *Wide;
 429
 430         cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);
 431     cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);
 432     cmsUInt16Number ObtLang, ObtCode;
 433
 434         // Sanitize
 435     if (mlu == NULL) return FALSE;
 436
 437     Wide = _cmsMLUgetWide(mlu, NULL, Lang, Cntry, &ObtLang, &ObtCode);
 438         if (Wide == NULL) return FALSE;
 439
 440         // Get used language and code
 441     *(cmsUInt16Number *)ObtainedLanguage = _cmsAdjustEndianess16(ObtLang);
 442         *(cmsUInt16Number *)ObtainedCountry  = _cmsAdjustEndianess16(ObtCode);
 443
 444         ObtainedLanguage[2] = ObtainedCountry[2] = 0;
 445         return TRUE;
 446 }
 447
 448
 449 // Named color lists --------------------------------------------------------------------------------------------
 450
 451 // Grow the list to keep at least NumElements
 452 static
 453 cmsBool  GrowNamedColorList(cmsNAMEDCOLORLIST* v)
 454 {
 455     cmsUInt32Number size;
 456     _cmsNAMEDCOLOR * NewPtr;
 457
 458     if (v == NULL) return FALSE;
 459
 460     if (v ->Allocated == 0)
 461         size = 64;   // Initial guess
 462     else
 463         size = v ->Allocated * 2;
 464
 465     // Keep a maximum color lists can grow, 100K entries seems reasonable
 466     if (size > 1024*100) return FALSE;
 467
 468     NewPtr = (_cmsNAMEDCOLOR*) _cmsRealloc(v ->ContextID, v ->List, size * sizeof(_cmsNAMEDCOLOR));
 469     if (NewPtr == NULL)
 470         return FALSE;
 471
 472     v ->List      = NewPtr;
 473     v ->Allocated = size;
 474     return TRUE;
 475 }
 476
 477 // Allocate a list for n elements
 478 cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUInt32Number n, cmsUInt32Number ColorantCount, const char* Prefix, const char* Suffix)
 479 {
 480     cmsNAMEDCOLORLIST* v = (cmsNAMEDCOLORLIST*) _cmsMallocZero(ContextID, sizeof(cmsNAMEDCOLORLIST));
 481
 482     if (v == NULL) return NULL;
 483
 484     v ->List      = NULL;
 485     v ->nColors   = 0;
 486     v ->ContextID  = ContextID;
 487
 488     while (v -> Allocated < n)
 489         GrowNamedColorList(v);
 490
 491     strncpy(v ->Prefix, Prefix, sizeof(v ->Prefix));
 492     strncpy(v ->Suffix, Suffix, sizeof(v ->Suffix));
 493     v -> ColorantCount = ColorantCount;
 494
 495     return v;
 496 }
 497
 498 // Free a list
 499 void CMSEXPORT cmsFreeNamedColorList(cmsNAMEDCOLORLIST* v)
 500 {
 501     if (v ->List) _cmsFree(v ->ContextID, v ->List);
 502     if (v) _cmsFree(v ->ContextID, v);
 503 }
 504
 505 cmsNAMEDCOLORLIST* CMSEXPORT cmsDupNamedColorList(const cmsNAMEDCOLORLIST* v)
 506 {
 507     cmsNAMEDCOLORLIST* NewNC;
 508
 509     if (v == NULL) return NULL;
 510
 511     NewNC= cmsAllocNamedColorList(v ->ContextID, v -> nColors, v ->ColorantCount, v ->Prefix, v ->Suffix);
 512     if (NewNC == NULL) return NULL;
 513
 514     // For really large tables we need this
 515     while (NewNC ->Allocated < v ->Allocated)
 516         GrowNamedColorList(NewNC);
 517
 518     memmove(NewNC ->Prefix, v ->Prefix, sizeof(v ->Prefix));
 519     memmove(NewNC ->Suffix, v ->Suffix, sizeof(v ->Suffix));
 520     NewNC ->ColorantCount = v ->ColorantCount;
 521     memmove(NewNC->List, v ->List, v->nColors * sizeof(_cmsNAMEDCOLOR));
 522     NewNC ->nColors = v ->nColors;
 523     return NewNC;
 524 }
 525
 526
 527 // Append a color to a list. List pointer may change if reallocated
 528 cmsBool  CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
 529                                        const char* Name,
 530                                        cmsUInt16Number PCS[3], cmsUInt16Number Colorant[cmsMAXCHANNELS])
 531 {
 532     cmsUInt32Number i;
 533
 534     if (NamedColorList == NULL) return FALSE;
 535
 536     if (NamedColorList ->nColors + 1 > NamedColorList ->Allocated) {
 537         if (!GrowNamedColorList(NamedColorList)) return FALSE;
 538     }
 539
 540     for (i=0; i < NamedColorList ->ColorantCount; i++)
 541         NamedColorList ->List[NamedColorList ->nColors].DeviceColorant[i] = Colorant == NULL? 0 : Colorant[i];
 542
 543     for (i=0; i < 3; i++)
 544         NamedColorList ->List[NamedColorList ->nColors].PCS[i] = PCS == NULL ? 0 : PCS[i];
 545
 546     if (Name != NULL)
 547         strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name,
 548                     sizeof(NamedColorList ->List[NamedColorList ->nColors].Name));
 549     else
 550         NamedColorList ->List[NamedColorList ->nColors].Name[0] = 0;
 551
 552
 553     NamedColorList ->nColors++;
 554     return TRUE;
 555 }
 556
 557 // Returns number of elements
 558 cmsUInt32Number CMSEXPORT cmsNamedColorCount(const cmsNAMEDCOLORLIST* NamedColorList)
 559 {
 560      if (NamedColorList == NULL) return 0;
 561      return NamedColorList ->nColors;
 562 }
 563
 564 // Info aboout a given color
 565 cmsBool  CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor,
 566                                      char* Name,
 567                                      char* Prefix,
 568                                      char* Suffix,
 569                                      cmsUInt16Number* PCS,
 570                                      cmsUInt16Number* Colorant)
 571 {
 572     if (NamedColorList == NULL) return FALSE;
 573
 574     if (nColor >= cmsNamedColorCount(NamedColorList)) return FALSE;
 575
 576     if (Name) strcpy(Name, NamedColorList->List[nColor].Name);
 577     if (Prefix) strcpy(Prefix, NamedColorList->Prefix);
 578     if (Suffix) strcpy(Suffix, NamedColorList->Suffix);
 579     if (PCS)
 580         memmove(PCS, NamedColorList ->List[nColor].PCS, 3*sizeof(cmsUInt16Number));
 581
 582     if (Colorant)
 583         memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant,
 584                                 sizeof(cmsUInt16Number) * NamedColorList ->ColorantCount);
 585
 586
 587     return TRUE;
 588 }
 589
 590 // Search for a given color name (no prefix or suffix)
 591 cmsInt32Number CMSEXPORT cmsNamedColorIndex(const cmsNAMEDCOLORLIST* NamedColorList, const char* Name)
 592 {
 593     int i, n;
 594
 595     if (NamedColorList == NULL) return -1;
 596     n = cmsNamedColorCount(NamedColorList);
 597     for (i=0; i < n; i++) {
 598         if (cmsstrcasecmp(Name,  NamedColorList->List[i].Name) == 0)
 599             return i;
 600     }
 601
 602     return -1;
 603 }
 604
 605 // MPE support -----------------------------------------------------------------------------------------------------------------
 606
 607 static
 608 void FreeNamedColorList(cmsStage* mpe)
 609 {
 610     cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
 611     cmsFreeNamedColorList(List);
 612 }
 613
 614 static
 615 void* DupNamedColorList(cmsStage* mpe)
 616 {
 617     cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
 618     return cmsDupNamedColorList(List);
 619 }
 620
 621 static
 622 void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
 623 {
 624     cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
 625     cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
 626     cmsUInt32Number j;
 627
 628     if (index >= NamedColorList-> nColors) {
 629         cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
 630     }
 631     else {
 632         for (j=0; j < NamedColorList ->ColorantCount; j++)
 633             Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0);
 634     }
 635 }
 636
 637
 638 // Named color lookup element
 639 cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList)
 640 {
 641     return _cmsStageAllocPlaceholder(NamedColorList ->ContextID,
 642                                            cmsSigNamedColorElemType,
 643                                                                    1, 3,
 644                                                                    EvalNamedColor,
 645                                                                    DupNamedColorList,
 646                                                                    FreeNamedColorList,
 647                                                                    cmsDupNamedColorList(NamedColorList));
 648
 649 }
 650
 651
 652 // Retrieve the named color list from a transform. Should be first element in the LUT
 653 cmsNAMEDCOLORLIST* CMSEXPORT cmsGetNamedColorList(cmsHTRANSFORM xform)
 654 {
 655     _cmsTRANSFORM* v = (_cmsTRANSFORM*) xform;
 656     cmsStage* mpe  = v ->Lut->Elements;
 657
 658     if (mpe ->Type != cmsSigNamedColorElemType) return NULL;
 659     return (cmsNAMEDCOLORLIST*) mpe ->Data;
 660 }
 661
 662
 663 // Profile sequence description routines -------------------------------------------------------------------------------------
 664
 665 cmsSEQ* CMSEXPORT cmsAllocProfileSequenceDescription(cmsContext ContextID, cmsUInt32Number n)
 666 {
 667     cmsSEQ* Seq;
 668     cmsUInt32Number i;
 669
 670     if (n == 0) return NULL;
 671
 672     // In a absolutely arbitrary way, I hereby decide to allow a maxim of 255 profiles linked
 673     // in a devicelink. It makes not sense anyway and may be used for exploits, so let's close the door!
 674     if (n > 255) return NULL;
 675
 676     Seq = (cmsSEQ*) _cmsMallocZero(ContextID, sizeof(cmsSEQ));
 677     if (Seq == NULL) return NULL;
 678
 679     Seq -> ContextID = ContextID;
 680     Seq -> seq      = (cmsPSEQDESC*) _cmsCalloc(ContextID, n, sizeof(cmsPSEQDESC));
 681     Seq -> n        = n;
 682
 683
 684     for (i=0; i < n; i++) {
 685         Seq -> seq[i].Manufacturer = NULL;
 686         Seq -> seq[i].Model        = NULL;
 687         Seq -> seq[i].Description  = NULL;
 688     }
 689
 690     return Seq;
 691 }
 692
 693 void CMSEXPORT cmsFreeProfileSequenceDescription(cmsSEQ* pseq)
 694 {
 695     cmsUInt32Number i;
 696
 697     for (i=0; i < pseq ->n; i++) {
 698         if (pseq ->seq[i].Manufacturer != NULL) cmsMLUfree(pseq ->seq[i].Manufacturer);
 699         if (pseq ->seq[i].Model != NULL) cmsMLUfree(pseq ->seq[i].Model);
 700         if (pseq ->seq[i].Description != NULL) cmsMLUfree(pseq ->seq[i].Description);
 701     }
 702
 703     if (pseq ->seq != NULL) _cmsFree(pseq ->ContextID, pseq ->seq);
 704     _cmsFree(pseq -> ContextID, pseq);
 705 }
 706
 707 cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq)
 708 {
 709     cmsSEQ *NewSeq;
 710     cmsUInt32Number i;
 711
 712     if (pseq == NULL)
 713         return NULL;
 714
 715     NewSeq = (cmsSEQ*) _cmsMalloc(pseq -> ContextID, sizeof(cmsSEQ));
 716     if (NewSeq == NULL) return NULL;
 717
 718
 719     NewSeq -> seq      = (cmsPSEQDESC*) _cmsCalloc(pseq ->ContextID, pseq ->n, sizeof(cmsPSEQDESC));
 720     if (NewSeq ->seq == NULL) goto Error;
 721
 722     NewSeq -> ContextID = pseq ->ContextID;
 723     NewSeq -> n        = pseq ->n;
 724
 725     for (i=0; i < pseq->n; i++) {
 726
 727         memmove(&NewSeq ->seq[i].attributes, &pseq ->seq[i].attributes, sizeof(cmsUInt64Number));
 728
 729         NewSeq ->seq[i].deviceMfg   = pseq ->seq[i].deviceMfg;
 730         NewSeq ->seq[i].deviceModel = pseq ->seq[i].deviceModel;
 731         memmove(&NewSeq ->seq[i].ProfileID, &pseq ->seq[i].ProfileID, sizeof(cmsProfileID));
 732         NewSeq ->seq[i].technology  = pseq ->seq[i].technology;
 733
 734         NewSeq ->seq[i].Manufacturer = cmsMLUdup(pseq ->seq[i].Manufacturer);
 735         NewSeq ->seq[i].Model        = cmsMLUdup(pseq ->seq[i].Model);
 736         NewSeq ->seq[i].Description  = cmsMLUdup(pseq ->seq[i].Description);
 737
 738     }
 739
 740     return NewSeq;
 741
 742 Error:
 743
 744     cmsFreeProfileSequenceDescription(NewSeq);
 745     return NULL;
 746 }
 747
 748
 749
 750