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