?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merged-in libcms2 v2.5
[AROS.git] / workbench / libs / lcms2 / src / cmsnamed.c
blobacfd1c8cf93a1a8b4ca6bd20cda455b76a72a7c1
1 //---------------------------------------------------------------------------------
2 //
3 // Little Color Management System
4 // Copyright (c) 1998-2012 Marti Maria Saguer
5 //
6 // Permission is hereby granted, free of charge, to any person obtaining
7 // a copy of this software and associated documentation files (the "Software"),
8 // to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 // and/or sell copies of the Software, and to permit persons to whom the Software
11 // is furnished to do so, subject to the following conditions:
12 //
13 // The above copyright notice and this permission notice shall be included in
14 // all copies or substantial portions of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
18 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 //
24 //---------------------------------------------------------------------------------
25 //
26
27 #include "lcms2_internal.h"
28
29 // 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 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
450 // Get the number of translations in the MLU object
451 cmsUInt32Number CMSEXPORT cmsMLUtranslationsCount(const cmsMLU* mlu)
452 {
453 if (mlu == NULL) return 0;
454 return mlu->UsedEntries;
455 }
456
457 // Get the language and country codes for a specific MLU index
458 cmsBool CMSEXPORT cmsMLUtranslationsCodes(const cmsMLU* mlu,
459 cmsUInt32Number idx,
460 char LanguageCode[3],
461 char CountryCode[3])
462 {
463 _cmsMLUentry *entry;
464
465 if (mlu == NULL) return FALSE;
466
467 if (idx >= (cmsUInt32Number) mlu->UsedEntries) return FALSE;
468
469 entry = &mlu->Entries[idx];
470
471 *(cmsUInt16Number *)LanguageCode = _cmsAdjustEndianess16(entry->Language);
472 *(cmsUInt16Number *)CountryCode = _cmsAdjustEndianess16(entry->Country);
473
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[32] = v->Suffix[32] = 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 == NULL) return;
533 if (v ->List) _cmsFree(v ->ContextID, v ->List);
534 _cmsFree(v ->ContextID, v);
535 }
536
537 cmsNAMEDCOLORLIST* CMSEXPORT cmsDupNamedColorList(const cmsNAMEDCOLORLIST* v)
538 {
539 cmsNAMEDCOLORLIST* NewNC;
540
541 if (v == NULL) return NULL;
542
543 NewNC= cmsAllocNamedColorList(v ->ContextID, v -> nColors, v ->ColorantCount, v ->Prefix, v ->Suffix);
544 if (NewNC == NULL) return NULL;
545
546 // For really large tables we need this
547 while (NewNC ->Allocated < v ->Allocated)
548 GrowNamedColorList(NewNC);
549
550 memmove(NewNC ->Prefix, v ->Prefix, sizeof(v ->Prefix));
551 memmove(NewNC ->Suffix, v ->Suffix, sizeof(v ->Suffix));
552 NewNC ->ColorantCount = v ->ColorantCount;
553 memmove(NewNC->List, v ->List, v->nColors * sizeof(_cmsNAMEDCOLOR));
554 NewNC ->nColors = v ->nColors;
555 return NewNC;
556 }
557
558
559 // Append a color to a list. List pointer may change if reallocated
560 cmsBool CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
561 const char* Name,
562 cmsUInt16Number PCS[3], cmsUInt16Number Colorant[cmsMAXCHANNELS])
563 {
564 cmsUInt32Number i;
565
566 if (NamedColorList == NULL) return FALSE;
567
568 if (NamedColorList ->nColors + 1 > NamedColorList ->Allocated) {
569 if (!GrowNamedColorList(NamedColorList)) return FALSE;
570 }
571
572 for (i=0; i < NamedColorList ->ColorantCount; i++)
573 NamedColorList ->List[NamedColorList ->nColors].DeviceColorant[i] = Colorant == NULL? 0 : Colorant[i];
574
575 for (i=0; i < 3; i++)
576 NamedColorList ->List[NamedColorList ->nColors].PCS[i] = PCS == NULL ? 0 : PCS[i];
577
578 if (Name != NULL) {
579
580 strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name, cmsMAX_PATH-1);
581 NamedColorList ->List[NamedColorList ->nColors].Name[cmsMAX_PATH-1] = 0;
582
583 }
584 else
585 NamedColorList ->List[NamedColorList ->nColors].Name[0] = 0;
586
587
588 NamedColorList ->nColors++;
589 return TRUE;
590 }
591
592 // Returns number of elements
593 cmsUInt32Number CMSEXPORT cmsNamedColorCount(const cmsNAMEDCOLORLIST* NamedColorList)
594 {
595 if (NamedColorList == NULL) return 0;
596 return NamedColorList ->nColors;
597 }
598
599 // Info aboout a given color
600 cmsBool CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor,
601 char* Name,
602 char* Prefix,
603 char* Suffix,
604 cmsUInt16Number* PCS,
605 cmsUInt16Number* Colorant)
606 {
607 if (NamedColorList == NULL) return FALSE;
608
609 if (nColor >= cmsNamedColorCount(NamedColorList)) return FALSE;
610
611 if (Name) strcpy(Name, NamedColorList->List[nColor].Name);
612 if (Prefix) strcpy(Prefix, NamedColorList->Prefix);
613 if (Suffix) strcpy(Suffix, NamedColorList->Suffix);
614 if (PCS)
615 memmove(PCS, NamedColorList ->List[nColor].PCS, 3*sizeof(cmsUInt16Number));
616
617 if (Colorant)
618 memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant,
619 sizeof(cmsUInt16Number) * NamedColorList ->ColorantCount);
620
621
622 return TRUE;
623 }
624
625 // Search for a given color name (no prefix or suffix)
626 cmsInt32Number CMSEXPORT cmsNamedColorIndex(const cmsNAMEDCOLORLIST* NamedColorList, const char* Name)
627 {
628 int i, n;
629
630 if (NamedColorList == NULL) return -1;
631 n = cmsNamedColorCount(NamedColorList);
632 for (i=0; i < n; i++) {
633 if (cmsstrcasecmp(Name, NamedColorList->List[i].Name) == 0)
634 return i;
635 }
636
637 return -1;
638 }
639
640 // MPE support -----------------------------------------------------------------------------------------------------------------
641
642 static
643 void FreeNamedColorList(cmsStage* mpe)
644 {
645 cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
646 cmsFreeNamedColorList(List);
647 }
648
649 static
650 void* DupNamedColorList(cmsStage* mpe)
651 {
652 cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
653 return cmsDupNamedColorList(List);
654 }
655
656 static
657 void EvalNamedColorPCS(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
658 {
659 cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
660 cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
661
662 if (index >= NamedColorList-> nColors) {
663 cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
664 }
665 else {
666
667 // Named color always uses Lab
668 Out[0] = (cmsFloat32Number) (NamedColorList->List[index].PCS[0] / 65535.0);
669 Out[1] = (cmsFloat32Number) (NamedColorList->List[index].PCS[1] / 65535.0);
670 Out[2] = (cmsFloat32Number) (NamedColorList->List[index].PCS[2] / 65535.0);
671 }
672 }
673
674 static
675 void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
676 {
677 cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
678 cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
679 cmsUInt32Number j;
680
681 if (index >= NamedColorList-> nColors) {
682 cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range; ignored", index);
683 }
684 else {
685 for (j=0; j < NamedColorList ->ColorantCount; j++)
686 Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0);
687 }
688 }
689
690
691 // Named color lookup element
692 cmsStage* _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList, cmsBool UsePCS)
693 {
694 return _cmsStageAllocPlaceholder(NamedColorList ->ContextID,
695 cmsSigNamedColorElemType,
696 1, UsePCS ? 3 : NamedColorList ->ColorantCount,
697 UsePCS ? EvalNamedColorPCS : EvalNamedColor,
698 DupNamedColorList,
699 FreeNamedColorList,
700 cmsDupNamedColorList(NamedColorList));
701
702 }
703
704
705 // Retrieve the named color list from a transform. Should be first element in the LUT
706 cmsNAMEDCOLORLIST* CMSEXPORT cmsGetNamedColorList(cmsHTRANSFORM xform)
707 {
708 _cmsTRANSFORM* v = (_cmsTRANSFORM*) xform;
709 cmsStage* mpe = v ->Lut->Elements;
710
711 if (mpe ->Type != cmsSigNamedColorElemType) return NULL;
712 return (cmsNAMEDCOLORLIST*) mpe ->Data;
713 }
714
715
716 // Profile sequence description routines -------------------------------------------------------------------------------------
717
718 cmsSEQ* CMSEXPORT cmsAllocProfileSequenceDescription(cmsContext ContextID, cmsUInt32Number n)
719 {
720 cmsSEQ* Seq;
721 cmsUInt32Number i;
722
723 if (n == 0) return NULL;
724
725 // In a absolutely arbitrary way, I hereby decide to allow a maxim of 255 profiles linked
726 // in a devicelink. It makes not sense anyway and may be used for exploits, so let's close the door!
727 if (n > 255) return NULL;
728
729 Seq = (cmsSEQ*) _cmsMallocZero(ContextID, sizeof(cmsSEQ));
730 if (Seq == NULL) return NULL;
731
732 Seq -> ContextID = ContextID;
733 Seq -> seq = (cmsPSEQDESC*) _cmsCalloc(ContextID, n, sizeof(cmsPSEQDESC));
734 Seq -> n = n;
735
736 if (Seq -> seq == NULL) {
737 _cmsFree(ContextID, Seq);
738 return NULL;
739 }
740
741 for (i=0; i < n; i++) {
742 Seq -> seq[i].Manufacturer = NULL;
743 Seq -> seq[i].Model = NULL;
744 Seq -> seq[i].Description = NULL;
745 }
746
747 return Seq;
748 }
749
750 void CMSEXPORT cmsFreeProfileSequenceDescription(cmsSEQ* pseq)
751 {
752 cmsUInt32Number i;
753
754 for (i=0; i < pseq ->n; i++) {
755 if (pseq ->seq[i].Manufacturer != NULL) cmsMLUfree(pseq ->seq[i].Manufacturer);
756 if (pseq ->seq[i].Model != NULL) cmsMLUfree(pseq ->seq[i].Model);
757 if (pseq ->seq[i].Description != NULL) cmsMLUfree(pseq ->seq[i].Description);
758 }
759
760 if (pseq ->seq != NULL) _cmsFree(pseq ->ContextID, pseq ->seq);
761 _cmsFree(pseq -> ContextID, pseq);
762 }
763
764 cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq)
765 {
766 cmsSEQ *NewSeq;
767 cmsUInt32Number i;
768
769 if (pseq == NULL)
770 return NULL;
771
772 NewSeq = (cmsSEQ*) _cmsMalloc(pseq -> ContextID, sizeof(cmsSEQ));
773 if (NewSeq == NULL) return NULL;
774
775
776 NewSeq -> seq = (cmsPSEQDESC*) _cmsCalloc(pseq ->ContextID, pseq ->n, sizeof(cmsPSEQDESC));
777 if (NewSeq ->seq == NULL) goto Error;
778
779 NewSeq -> ContextID = pseq ->ContextID;
780 NewSeq -> n = pseq ->n;
781
782 for (i=0; i < pseq->n; i++) {
783
784 memmove(&NewSeq ->seq[i].attributes, &pseq ->seq[i].attributes, sizeof(cmsUInt64Number));
785
786 NewSeq ->seq[i].deviceMfg = pseq ->seq[i].deviceMfg;
787 NewSeq ->seq[i].deviceModel = pseq ->seq[i].deviceModel;
788 memmove(&NewSeq ->seq[i].ProfileID, &pseq ->seq[i].ProfileID, sizeof(cmsProfileID));
789 NewSeq ->seq[i].technology = pseq ->seq[i].technology;
790
791 NewSeq ->seq[i].Manufacturer = cmsMLUdup(pseq ->seq[i].Manufacturer);
792 NewSeq ->seq[i].Model = cmsMLUdup(pseq ->seq[i].Model);
793 NewSeq ->seq[i].Description = cmsMLUdup(pseq ->seq[i].Description);
794
795 }
796
797 return NewSeq;
798
799 Error:
800
801 cmsFreeProfileSequenceDescription(NewSeq);
802 return NULL;
803 }
804
805 // Dictionaries --------------------------------------------------------------------------------------------------------
806
807 // Dictionaries are just very simple linked lists
808
809
810 typedef struct _cmsDICT_struct {
811 cmsDICTentry* head;
812 cmsContext ContextID;
813 } _cmsDICT;
814
815
816 // Allocate an empty dictionary
817 cmsHANDLE CMSEXPORT cmsDictAlloc(cmsContext ContextID)
818 {
819 _cmsDICT* dict = (_cmsDICT*) _cmsMallocZero(ContextID, sizeof(_cmsDICT));
820 if (dict == NULL) return NULL;
821
822 dict ->ContextID = ContextID;
823 return (cmsHANDLE) dict;
824
825 }
826
827 // Dispose resources
828 void CMSEXPORT cmsDictFree(cmsHANDLE hDict)
829 {
830 _cmsDICT* dict = (_cmsDICT*) hDict;
831 cmsDICTentry *entry, *next;
832
833 _cmsAssert(dict != NULL);
834
835 // Walk the list freeing all nodes
836 entry = dict ->head;
837 while (entry != NULL) {
838
839 if (entry ->DisplayName != NULL) cmsMLUfree(entry ->DisplayName);
840 if (entry ->DisplayValue != NULL) cmsMLUfree(entry ->DisplayValue);
841 if (entry ->Name != NULL) _cmsFree(dict ->ContextID, entry -> Name);
842 if (entry ->Value != NULL) _cmsFree(dict ->ContextID, entry -> Value);
843
844 // Don't fall in the habitual trap...
845 next = entry ->Next;
846 _cmsFree(dict ->ContextID, entry);
847
848 entry = next;
849 }
850
851 _cmsFree(dict ->ContextID, dict);
852 }
853
854
855 // Duplicate a wide char string
856 static
857 wchar_t* DupWcs(cmsContext ContextID, const wchar_t* ptr)
858 {
859 if (ptr == NULL) return NULL;
860 return (wchar_t*) _cmsDupMem(ContextID, ptr, (mywcslen(ptr) + 1) * sizeof(wchar_t));
861 }
862
863 // Add a new entry to the linked list
864 cmsBool CMSEXPORT cmsDictAddEntry(cmsHANDLE hDict, const wchar_t* Name, const wchar_t* Value, const cmsMLU *DisplayName, const cmsMLU *DisplayValue)
865 {
866 _cmsDICT* dict = (_cmsDICT*) hDict;
867 cmsDICTentry *entry;
868
869 _cmsAssert(dict != NULL);
870 _cmsAssert(Name != NULL);
871
872 entry = (cmsDICTentry*) _cmsMallocZero(dict ->ContextID, sizeof(cmsDICTentry));
873 if (entry == NULL) return FALSE;
874
875 entry ->DisplayName = cmsMLUdup(DisplayName);
876 entry ->DisplayValue = cmsMLUdup(DisplayValue);
877 entry ->Name = DupWcs(dict ->ContextID, Name);
878 entry ->Value = DupWcs(dict ->ContextID, Value);
879
880 entry ->Next = dict ->head;
881 dict ->head = entry;
882
883 return TRUE;
884 }
885
886
887 // Duplicates an existing dictionary
888 cmsHANDLE CMSEXPORT cmsDictDup(cmsHANDLE hDict)
889 {
890 _cmsDICT* old_dict = (_cmsDICT*) hDict;
891 cmsHANDLE hNew;
892 cmsDICTentry *entry;
893
894 _cmsAssert(old_dict != NULL);
895
896 hNew = cmsDictAlloc(old_dict ->ContextID);
897 if (hNew == NULL) return NULL;
898
899 // Walk the list freeing all nodes
900 entry = old_dict ->head;
901 while (entry != NULL) {
902
903 if (!cmsDictAddEntry(hNew, entry ->Name, entry ->Value, entry ->DisplayName, entry ->DisplayValue)) {
904
905 cmsDictFree(hNew);
906 return NULL;
907 }
908
909 entry = entry -> Next;
910 }
911
912 return hNew;
913 }
914
915 // Get a pointer to the linked list
916 const cmsDICTentry* CMSEXPORT cmsDictGetEntryList(cmsHANDLE hDict)
917 {
918 _cmsDICT* dict = (_cmsDICT*) hDict;
919
920 if (dict == NULL) return NULL;
921 return dict ->head;
922 }
923
924 // Helper For external languages
925 const cmsDICTentry* CMSEXPORT cmsDictNextEntry(const cmsDICTentry* e)
926 {
927 if (e == NULL) return NULL;
928 return e ->Next;
929 }
Mirror of AROS' svn.