File: | IccXML/IccLibXML/IccUtilXml.cpp |
Warning: | line 144, column 12 Value stored to 'nAlloc' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /** @file |
2 | File: IccUtilXml.cpp |
3 | |
4 | Contains: Implementation of XML conversion utilities |
5 | |
6 | Version: V1 |
7 | |
8 | Copyright: (c) see ICC Software License |
9 | */ |
10 | |
11 | /* |
12 | * The ICC Software License, Version 0.2 |
13 | * |
14 | * |
15 | * Copyright (c) 2003-2012 The International Color Consortium. All rights |
16 | * reserved. |
17 | * |
18 | * Redistribution and use in source and binary forms, with or without |
19 | * modification, are permitted provided that the following conditions |
20 | * are met: |
21 | * |
22 | * 1. Redistributions of source code must retain the above copyright |
23 | * notice, this list of conditions and the following disclaimer. |
24 | * |
25 | * 2. Redistributions in binary form must reproduce the above copyright |
26 | * notice, this list of conditions and the following disclaimer in |
27 | * the documentation and/or other materials provided with the |
28 | * distribution. |
29 | * |
30 | * 3. In the absence of prior written permission, the names "ICC" and "The |
31 | * International Color Consortium" must not be used to imply that the |
32 | * ICC organization endorses or promotes products derived from this |
33 | * software. |
34 | * |
35 | * |
36 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
37 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
38 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
39 | * DISCLAIMED. IN NO EVENT SHALL THE INTERNATIONAL COLOR CONSORTIUM OR |
40 | * ITS CONTRIBUTING MEMBERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
41 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
42 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
43 | * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
44 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
45 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
46 | * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
47 | * SUCH DAMAGE. |
48 | * ==================================================================== |
49 | * |
50 | * This software consists of voluntary contributions made by many |
51 | * individuals on behalf of the The International Color Consortium. |
52 | * |
53 | * |
54 | * Membership in the ICC is encouraged when this software is used for |
55 | * commercial purposes. |
56 | * |
57 | * |
58 | * For more information on The International Color Consortium, please |
59 | * see <http://www.color.org/>. |
60 | * |
61 | * |
62 | */ |
63 | |
64 | #include <time.h> |
65 | #include "IccUtilXml.h" |
66 | #include "IccConvertUTF.h" |
67 | #include "IccTagFactory.h" |
68 | #include <iostream> |
69 | |
70 | #ifdef WIN32 |
71 | #include <windows.h> |
72 | #ifdef GetClassName |
73 | #undef GetClassName |
74 | #endif |
75 | #endif |
76 | #include <cstring> /* C strings strcpy, memcpy ... */ |
77 | #include <math.h> /* nanf */ |
78 | |
79 | |
80 | |
81 | CIccUTF16String::CIccUTF16String() |
82 | { |
83 | m_alloc=64; |
84 | m_len = 0; |
85 | m_str = (icUInt16Number*)calloc(m_alloc, sizeof(icUInt16Number)); |
86 | } |
87 | |
88 | CIccUTF16String::CIccUTF16String(const icUInt16Number *uzStr) |
89 | { |
90 | m_len = WStrlen(uzStr); |
91 | m_alloc = AllocSize(m_len); |
92 | |
93 | m_str = (icUInt16Number *)malloc(m_alloc*sizeof(icUInt16Number)); |
94 | memcpy(m_str, uzStr, m_len+1*sizeof(icUInt16Number)); |
95 | } |
96 | |
97 | CIccUTF16String::CIccUTF16String(const char *szStr) |
98 | { |
99 | size_t sizeSrc = strlen(szStr); |
100 | |
101 | if (sizeSrc) { |
102 | m_alloc = AllocSize(sizeSrc*2); |
103 | m_str = (UTF16 *)calloc(m_alloc, sizeof(icUInt16Number)); //overallocate to allow for up to 4 bytes per character |
104 | UTF16 *szDest = m_str; |
105 | icConvertUTF8toUTF16((const UTF8 **)&szStr, (const UTF8 *)&szStr[sizeSrc], &szDest, &szDest[m_alloc], lenientConversion); |
106 | if (m_str[0]==0xfeff) { |
107 | size_t i; |
108 | for (i=1; m_str[i]; i++) |
109 | m_str[i-1] = m_str[i]; |
110 | m_str[i-1] = 0; |
111 | } |
112 | m_len = WStrlen(m_str); |
113 | } |
114 | else { |
115 | m_alloc = 64; |
116 | m_len = 0; |
117 | m_str = (icUInt16Number*)calloc(m_alloc, sizeof(icUInt16Number)); |
118 | } |
119 | } |
120 | |
121 | CIccUTF16String::CIccUTF16String(const CIccUTF16String &str) |
122 | { |
123 | m_alloc = str.m_alloc; |
124 | m_len = str.m_len; |
125 | m_str = (icUInt16Number*)malloc(m_alloc*sizeof(icUInt16Number)); |
126 | |
127 | memcpy(m_str, str.m_str, (m_alloc)*sizeof(icUInt16Number)); |
128 | } |
129 | |
130 | CIccUTF16String::~CIccUTF16String() |
131 | { |
132 | free(m_str); |
133 | } |
134 | |
135 | void CIccUTF16String::Clear() |
136 | { |
137 | m_len = 0; |
138 | m_str[0] = 0; |
139 | } |
140 | |
141 | bool CIccUTF16String::Resize(size_t len) |
142 | { |
143 | if (len>m_alloc) { |
144 | size_t nAlloc = AllocSize(len); |
Value stored to 'nAlloc' during its initialization is never read | |
145 | |
146 | m_str = (icUInt16Number*)icRealloc(m_str, m_alloc*sizeof(icUInt16Number)); |
147 | |
148 | if (!m_str) { |
149 | m_len = 0; |
150 | return false; |
151 | } |
152 | } |
153 | |
154 | if (len>m_len) { |
155 | memset(&m_str[m_len], 0x0020, (len-m_len)*sizeof(icUInt16Number)); |
156 | } |
157 | m_len = len; |
158 | m_str[m_len] = 0; |
159 | return true; |
160 | } |
161 | |
162 | size_t CIccUTF16String::WStrlen(const icUInt16Number *uzStr) |
163 | { |
164 | size_t n=0; |
165 | while(uzStr[n]) n++; |
166 | |
167 | return n; |
168 | } |
169 | |
170 | CIccUTF16String& CIccUTF16String::operator=(const CIccUTF16String &wstr) |
171 | { |
172 | if (m_alloc<=wstr.m_alloc) { |
173 | m_str = (icUInt16Number*)icRealloc(m_str, m_alloc*sizeof(icUInt16Number)); |
174 | if (m_str) |
175 | m_alloc = wstr.m_alloc; |
176 | else |
177 | m_alloc = 0; |
178 | } |
179 | if (m_str) { |
180 | m_len = wstr.m_len; |
181 | |
182 | memcpy(m_str, wstr.m_str, (m_len+1)*sizeof(icUInt16Number)); |
183 | } |
184 | else { |
185 | m_len = 0; |
186 | } |
187 | |
188 | return *this; |
189 | } |
190 | |
191 | CIccUTF16String& CIccUTF16String::operator=(const char *szStr) |
192 | { |
193 | FromUtf8(szStr, 0); |
194 | |
195 | return *this; |
196 | } |
197 | |
198 | CIccUTF16String& CIccUTF16String::operator=(const icUInt16Number *uzStr) |
199 | { |
200 | size_t n = WStrlen(uzStr); |
201 | size_t nAlloc = AllocSize(n); |
202 | |
203 | if (m_alloc<=nAlloc) { |
204 | m_str = (icUInt16Number*)icRealloc(m_str, m_alloc*sizeof(icUInt16Number)); |
205 | if (m_str) |
206 | m_alloc = nAlloc; |
207 | else |
208 | m_alloc = 0; |
209 | } |
210 | if (m_str) { |
211 | m_len = n; |
212 | |
213 | memcpy(m_str, uzStr, (m_len+1)*sizeof(icUInt16Number)); |
214 | } |
215 | else { |
216 | m_len = 0; |
217 | } |
218 | |
219 | return *this; |
220 | } |
221 | |
222 | |
223 | bool CIccUTF16String::FromUtf8(const char *szStr, size_t sizeSrc) |
224 | { |
225 | if (!sizeSrc) |
226 | sizeSrc = strlen(szStr); |
227 | |
228 | if (sizeSrc) { |
229 | size_t nAlloc = AllocSize(sizeSrc*2); |
230 | if (m_alloc<=nAlloc) { |
231 | m_str = (icUInt16Number*)icRealloc(m_str, m_alloc*sizeof(icUInt16Number)); |
232 | m_alloc = nAlloc; |
233 | } |
234 | if (m_str) { |
235 | UTF16 *szDest = m_str; |
236 | icConvertUTF8toUTF16((const UTF8 **)&szStr, (const UTF8 *)&szStr[sizeSrc], &szDest, &szDest[m_alloc], lenientConversion); |
237 | if (m_str[0]==0xfeff) { |
238 | size_t i; |
239 | for (i=1; m_str[i]; i++) |
240 | m_str[i-1] = m_str[i]; |
241 | m_str[i-1] = 0; |
242 | } |
243 | m_len = WStrlen(m_str); |
244 | } |
245 | else { |
246 | m_len =0; |
247 | return false; |
248 | } |
249 | } |
250 | else { |
251 | m_len = 0; |
252 | m_str[0] = 0; |
253 | } |
254 | return true; |
255 | } |
256 | |
257 | const char *CIccUTF16String::ToUtf8(std::string &buf) |
258 | { |
259 | return icUtf16ToUtf8(buf, m_str, (int)m_len); |
260 | } |
261 | |
262 | const wchar_t *CIccUTF16String::ToWString(std::wstring &buf) |
263 | { |
264 | size_t i; |
265 | |
266 | buf.clear(); |
267 | |
268 | for (i=0; i<m_len; i++) { |
269 | buf += (wchar_t)m_str[i]; |
270 | } |
271 | |
272 | return buf.c_str(); |
273 | } |
274 | |
275 | const char *icFixXml(std::string &buf, const char *szStr) |
276 | { |
277 | buf = ""; |
278 | while (*szStr) { |
279 | switch (*szStr) { |
280 | case '\'': |
281 | buf += "'"; |
282 | break; |
283 | case '&': |
284 | buf += "&"; |
285 | break; |
286 | case '\"': |
287 | buf += """; |
288 | break; |
289 | case '<': |
290 | buf += "<"; |
291 | break; |
292 | case '>': |
293 | buf += ">"; |
294 | break; |
295 | default: |
296 | buf += *szStr; |
297 | } |
298 | szStr++; |
299 | } |
300 | |
301 | return buf.c_str(); |
302 | } |
303 | |
304 | const char *icFixXml(char *szDest, const char *szStr) |
305 | { |
306 | char *m_ptr = szDest; |
307 | |
308 | while (*szStr) { |
309 | switch (*szStr) { |
310 | case '\'': |
311 | strcpy(m_ptr, "'"); |
312 | m_ptr += 6; |
313 | break; |
314 | case '&': |
315 | strcpy(m_ptr, "&"); |
316 | m_ptr += 5; |
317 | break; |
318 | case '\"': |
319 | strcpy(m_ptr, """); |
320 | m_ptr += 6; |
321 | break; |
322 | case '<': |
323 | strcpy(m_ptr, "<"); |
324 | m_ptr += 4; |
325 | break; |
326 | case '>': |
327 | strcpy(m_ptr, ">"); |
328 | m_ptr += 4; |
329 | break; |
330 | default: |
331 | *m_ptr++ = *szStr; |
332 | } |
333 | szStr++; |
334 | } |
335 | *m_ptr = '\0'; |
336 | |
337 | return szDest; |
338 | } |
339 | |
340 | const char *icUtf16ToUtf8(std::string &buf, const icUInt16Number *szSrc, int sizeSrc/*=0*/) |
341 | { |
342 | if (!sizeSrc) { |
343 | sizeSrc = (int)CIccUTF16String::WStrlen(szSrc); |
344 | } |
345 | |
346 | int n = sizeSrc*4; |
347 | |
348 | if (n) { |
349 | char *szBuf = (char *)malloc(n+1); |
350 | char *szDest = szBuf; |
351 | icConvertUTF16toUTF8(&szSrc, &szSrc[sizeSrc], (UTF8**)&szDest, (UTF8*)&szDest[n+1], lenientConversion); |
352 | *szDest= '\0'; |
353 | |
354 | buf = szBuf; |
355 | free(szBuf); |
356 | } |
357 | else { |
358 | buf.clear(); |
359 | } |
360 | |
361 | return buf.c_str(); |
362 | } |
363 | |
364 | const unsigned short *icUtf8ToUtf16(CIccUTF16String &buf, const char *szSrc, int sizeSrc/*=0*/) |
365 | { |
366 | buf.FromUtf8(szSrc, sizeSrc); |
367 | |
368 | return buf.c_str(); |
369 | } |
370 | |
371 | const char *icAnsiToUtf8(std::string &buf, const char *szSrc) |
372 | { |
373 | #ifdef WIN32 |
374 | size_t len = strlen(szSrc)+1; |
375 | wchar_t *szUnicodeBuf = (wchar_t*)malloc(len*sizeof(icUInt16Number)*2); |
376 | char *szBuf = (char*)malloc(len*2); |
377 | |
378 | size_t n; |
379 | |
380 | n=MultiByteToWideChar(CP_ACP, 0, szSrc, (int)len-1, szUnicodeBuf, (int)len*2); |
381 | szUnicodeBuf[n] = '\0'; |
382 | |
383 | n = WideCharToMultiByte(CP_UTF8, 0, (const wchar_t*)szUnicodeBuf, (int)n, szBuf, (int)len*2, 0, NULL__null); |
384 | szBuf[n] = '\0'; |
385 | |
386 | buf = szBuf; |
387 | |
388 | free(szBuf); |
389 | free(szUnicodeBuf); |
390 | #else |
391 | buf = szSrc; |
392 | #endif |
393 | return buf.c_str(); |
394 | } |
395 | |
396 | const char *icUtf8ToAnsi(std::string &buf, const char *szSrc) |
397 | { |
398 | #ifdef WIN32 |
399 | size_t len = strlen(szSrc)+1; |
400 | wchar_t *szUnicodeBuf = (wchar_t*)malloc(len*sizeof(icUInt16Number)*2); |
401 | char *szBuf = (char*)malloc(len*2); |
402 | |
403 | size_t n; |
404 | |
405 | n=MultiByteToWideChar(CP_UTF8, 0, szSrc, (int)len, szUnicodeBuf, (int)len*2); |
406 | szUnicodeBuf[n] = '\0'; |
407 | |
408 | n = WideCharToMultiByte(CP_ACP, 0, (const wchar_t*)szUnicodeBuf, (int)n, szBuf, (int)len*2, "?", NULL__null); |
409 | szBuf[n] = '\0'; |
410 | |
411 | buf = szBuf; |
412 | |
413 | free(szBuf); |
414 | free(szUnicodeBuf); |
415 | #else |
416 | buf = szSrc; |
417 | #endif |
418 | return buf.c_str(); |
419 | } |
420 | |
421 | class CIccDumpXmlCLUT : public IIccCLUTExec |
422 | { |
423 | public: |
424 | CIccDumpXmlCLUT(std::string *xml, icConvertType nType, std::string blanks, icUInt16Number nSamples, icUInt8Number nPixelsPerRow) |
425 | { |
426 | m_xml = xml; |
427 | m_nType = nType; |
428 | m_blanks = blanks; |
429 | m_nSamples = nSamples; |
430 | m_nPixelsPerRow = nPixelsPerRow; |
431 | m_nCurPixel = 0; |
432 | } |
433 | |
434 | virtual void PixelOp(icFloatNumber* pGridAdr, icFloatNumber* pData) |
435 | { |
436 | if (!pData) { |
437 | std::cerr << "Error: pData is nullptr." << std::endl; |
438 | return; // Early return if pData is null |
439 | } |
440 | |
441 | int i; |
442 | char buf[128]; |
443 | |
444 | if (!(m_nCurPixel % m_nPixelsPerRow)) |
445 | *m_xml += m_blanks; |
446 | |
447 | switch(m_nType) { |
448 | case icConvert8Bit: |
449 | for (i=0; i<m_nSamples; i++) { |
450 | if (&pData[i] == nullptr) { // Check if accessing pData[i] is valid |
451 | std::cerr << "Error: pData[i] is out of bounds." << std::endl; |
452 | return; |
453 | } |
454 | sprintf(buf, " %3d", (icUInt8Number)(pData[i]*255.0 + 0.5)); |
455 | *m_xml += buf; |
456 | } |
457 | break; |
458 | case icConvert16Bit: |
459 | for (i=0; i<m_nSamples; i++) { |
460 | sprintf(buf, " %5d", (icUInt16Number)(pData[i]*65535.0 + 0.5)); |
461 | *m_xml += buf; |
462 | } |
463 | break; |
464 | case icConvertFloat: |
465 | default: |
466 | for (i=0; i<m_nSamples; i++) { |
467 | sprintf(buf, " %13.8f", pData[i]); |
468 | *m_xml += buf; |
469 | } |
470 | break; |
471 | } |
472 | m_nCurPixel++; |
473 | if (!(m_nCurPixel % m_nPixelsPerRow)) { |
474 | *m_xml += "\n"; |
475 | } |
476 | } |
477 | |
478 | void Finish() |
479 | { |
480 | if (m_nCurPixel % m_nPixelsPerRow) { |
481 | *m_xml += "\n"; |
482 | } |
483 | } |
484 | |
485 | std::string *m_xml; |
486 | icConvertType m_nType; |
487 | std::string m_blanks; |
488 | icUInt16Number m_nSamples; |
489 | icUInt8Number m_nPixelsPerRow; |
490 | icUInt32Number m_nCurPixel; |
491 | }; |
492 | |
493 | bool icCLUTDataToXml(std::string &xml, CIccCLUT *pCLUT, icConvertType nType, std::string blanks, |
494 | bool bSaveGridPoints/*=false*/) |
495 | { |
496 | char buf[128]; |
497 | int nStartType = nType; |
498 | if (nType == icConvertVariable) { |
499 | nType = pCLUT->GetPrecision()==1 ? icConvert8Bit : icConvert16Bit; |
500 | } |
501 | |
502 | if (bSaveGridPoints) { |
503 | xml += blanks + " <GridPoints>"; |
504 | int i; |
505 | |
506 | for (i=0; i<pCLUT->GetInputDim(); i++) { |
507 | if (i) |
508 | sprintf(buf, " %d", pCLUT->GridPoint(i)); |
509 | else |
510 | sprintf(buf, "%d", pCLUT->GridPoint(i)); |
511 | xml += buf; |
512 | } |
513 | xml += "</GridPoints>\n"; |
514 | } |
515 | |
516 | int nPixelsPerRow = pCLUT->GridPoint(0); |
517 | |
518 | // if the CLUT has no GridPoints, profile is invalid |
519 | if (nPixelsPerRow == 0) { |
520 | printf("\nError! - CLUT Table not found.\n"); |
521 | return false; |
522 | } |
523 | |
524 | CIccDumpXmlCLUT dumper(&xml, nType, blanks + " ", pCLUT->GetOutputChannels(), nPixelsPerRow); |
525 | |
526 | xml += blanks + " <TableData"; |
527 | |
528 | if (nStartType == icConvertVariable && nType == icConvert8Bit) { |
529 | sprintf(buf, " Precision=\"1\""); |
530 | xml += buf; |
531 | } |
532 | |
533 | xml += ">\n"; |
534 | |
535 | pCLUT->Iterate(&dumper); |
536 | |
537 | dumper.Finish(); |
538 | |
539 | xml += blanks + " </TableData>\n"; |
540 | |
541 | return true; |
542 | |
543 | } |
544 | |
545 | bool icCLUTToXml(std::string &xml, CIccCLUT *pCLUT, icConvertType nType, std::string blanks, |
546 | bool bSaveGridPoints/*=false*/, const char *szExtraAttrs/*=""*/, const char *szName/*="CLUT"*/) |
547 | { |
548 | char buf[128]; |
549 | xml += blanks + "<" + szName; |
550 | |
551 | if (!bSaveGridPoints) { |
552 | sprintf(buf, " GridGranularity=\"%d\"", pCLUT->GridPoint(0)); |
553 | xml += buf; |
554 | } |
555 | |
556 | if (szExtraAttrs && *szExtraAttrs) { |
557 | xml += szExtraAttrs; |
558 | } |
559 | xml += ">\n"; |
560 | |
561 | icCLUTDataToXml(xml, pCLUT, nType, blanks, bSaveGridPoints); |
562 | |
563 | xml += blanks + "</" + szName + ">\n"; |
564 | return true; |
565 | } |
566 | |
567 | icFloatNumber icXmlStrToFloat(const xmlChar *szStr) |
568 | { |
569 | float f=0.0; |
570 | sscanf((const char*)szStr, "%f", &f); |
571 | |
572 | return (icFloatNumber)f; |
573 | } |
574 | |
575 | icSignature icXmlStrToSig(const char *szStr) |
576 | { |
577 | return icGetSigVal(szStr); |
578 | } |
579 | |
580 | const char *icXmlAttrValue(xmlAttr *attr, const char *szDefault) |
581 | { |
582 | if (attr && attr->children && attr->children->type == XML_TEXT_NODE && attr->children->content) |
583 | return (const char*)attr->children->content; |
584 | |
585 | return szDefault; |
586 | } |
587 | |
588 | const char *icXmlAttrValue(xmlNode *pNode, const char *szName, const char *szDefault) |
589 | { |
590 | xmlAttr *attr = icXmlFindAttr(pNode, szName); |
591 | if (attr) { |
592 | return icXmlAttrValue(attr, szDefault); |
593 | } |
594 | return szDefault; |
595 | } |
596 | |
597 | icUInt32Number icXmlGetChildSigVal(xmlNode *pNode) |
598 | { |
599 | if (!pNode || !pNode->children || !pNode->children->content) |
600 | return 0; |
601 | |
602 | return icGetSigVal((const char*)pNode->children->content); |
603 | } |
604 | |
605 | static int hexValue(char c) |
606 | { |
607 | if (c>='0' && c<='9') |
608 | return c-'0'; |
609 | if (c>='A' && c<='F') |
610 | return c-'A'+10; |
611 | if (c>='a' && c<='f') |
612 | return c-'a'+10; |
613 | return -1; |
614 | } |
615 | |
616 | |
617 | icUInt32Number icXmlGetHexData(void *pBuf, const char *szText, icUInt32Number nBufSize) |
618 | { |
619 | unsigned char *pDest = (unsigned char*)pBuf; |
620 | icUInt32Number rv =0; |
621 | |
622 | while(*szText && rv<nBufSize) { |
623 | int c1=hexValue(szText[0]); |
624 | int c2=hexValue(szText[1]); |
625 | if (c1>=0 && c2>=0) { |
626 | *pDest = c1*16+ c2; |
627 | pDest++; |
628 | szText +=2; |
629 | rv++; |
630 | } |
631 | else { |
632 | szText++; |
633 | } |
634 | } |
635 | return rv; |
636 | } |
637 | |
638 | icUInt32Number icXmlGetHexDataSize(const char *szText) |
639 | { |
640 | icUInt32Number rv =0; |
641 | |
642 | while(*szText) { |
643 | int c1=hexValue(szText[0]); |
644 | int c2=hexValue(szText[1]); |
645 | if (c1>=0 && c2>=0) { |
646 | szText +=2; |
647 | rv++; |
648 | } |
649 | else { |
650 | szText++; |
651 | } |
652 | } |
653 | return rv; |
654 | } |
655 | |
656 | icUInt32Number icXmlDumpHexData(std::string &xml, std::string blanks, void *pBuf, icUInt32Number nBufSize) |
657 | { |
658 | icUInt8Number *m_ptr = (icUInt8Number *)pBuf; |
659 | char buf[15]; |
660 | icUInt32Number i; |
661 | |
662 | for (i=0; i<nBufSize; i++, m_ptr++) { |
663 | if (!(i%32)) { |
664 | if (i) |
665 | xml += "\n"; |
666 | xml += blanks; |
667 | } |
668 | sprintf(buf, "%02x", *m_ptr); |
669 | xml += buf; |
670 | } |
671 | if (i) { |
672 | xml += "\n"; |
673 | } |
674 | return i; |
675 | } |
676 | |
677 | xmlAttr *icXmlFindAttr(xmlNode *pNode, const char *szAttrName) |
678 | { |
679 | if (!pNode) return NULL__null; |
680 | |
681 | xmlAttr *attr; |
682 | |
683 | for (attr = pNode->properties; attr; attr = attr->next) { |
684 | if (attr->type != XML_ATTRIBUTE_NODE) |
685 | continue; |
686 | |
687 | if (!icXmlStrCmp(attr->name, szAttrName)strcmp((const char *)(attr->name), (const char*)(szAttrName ))) { |
688 | return attr; |
689 | } |
690 | } |
691 | |
692 | return NULL__null; |
693 | } |
694 | |
695 | xmlNode *icXmlFindNode(xmlNode *pNode, const char *szNodeName) |
696 | { |
697 | if (!pNode) return NULL__null; |
698 | |
699 | for (; pNode; pNode = pNode->next) { |
700 | if (pNode->type != XML_ELEMENT_NODE) |
701 | continue; |
702 | |
703 | if (!icXmlStrCmp(pNode->name, szNodeName)strcmp((const char *)(pNode->name), (const char*)(szNodeName ))) { |
704 | return pNode; |
705 | } |
706 | } |
707 | |
708 | return NULL__null; |
709 | } |
710 | |
711 | icUInt32Number icXmlNodeCount(xmlNode *pNode, const char *szNodeName) |
712 | { |
713 | icUInt32Number rv = 0; |
714 | for (; pNode; pNode = pNode->next) { |
715 | if (pNode->type == XML_ELEMENT_NODE && |
716 | !icXmlStrCmp(pNode->name, szNodeName)strcmp((const char *)(pNode->name), (const char*)(szNodeName ))) { |
717 | rv++; |
718 | } |
719 | } |
720 | return rv; |
721 | } |
722 | |
723 | icUInt32Number icXmlNodeCount2(xmlNode *pNode, const char *szNodeName1, const char *szNodeName2) |
724 | { |
725 | icUInt32Number rv = 0; |
726 | for (; pNode; pNode = pNode->next) { |
727 | if (pNode->type == XML_ELEMENT_NODE && |
728 | (!icXmlStrCmp(pNode->name, szNodeName1)strcmp((const char *)(pNode->name), (const char*)(szNodeName1 )) || !icXmlStrCmp(pNode->name, szNodeName2)strcmp((const char *)(pNode->name), (const char*)(szNodeName2 )))) { |
729 | rv++; |
730 | } |
731 | } |
732 | return rv; |
733 | } |
734 | |
735 | icUInt32Number icXmlNodeCount3(xmlNode *pNode, const char *szNodeName1, const char *szNodeName2, const char *szNodeName3) |
736 | { |
737 | icUInt32Number rv = 0; |
738 | for (; pNode; pNode = pNode->next) { |
739 | if (pNode->type == XML_ELEMENT_NODE && |
740 | (!icXmlStrCmp(pNode->name, szNodeName1)strcmp((const char *)(pNode->name), (const char*)(szNodeName1 )) || !icXmlStrCmp(pNode->name, szNodeName2)strcmp((const char *)(pNode->name), (const char*)(szNodeName2 )) || !icXmlStrCmp(pNode->name, szNodeName3)strcmp((const char *)(pNode->name), (const char*)(szNodeName3 )))) { |
741 | rv++; |
742 | } |
743 | } |
744 | return rv; |
745 | } |
746 | |
747 | template <class T, icTagTypeSignature Tsig> |
748 | CIccXmlArrayType<T, Tsig>::CIccXmlArrayType() |
749 | { |
750 | m_pBuf = NULL__null; |
751 | m_nSize = 0; |
752 | } |
753 | |
754 | template <class T, icTagTypeSignature Tsig> |
755 | CIccXmlArrayType<T, Tsig>::~CIccXmlArrayType() |
756 | { |
757 | if (m_pBuf) { |
758 | free(m_pBuf); |
759 | } |
760 | } |
761 | |
762 | template <class T, icTagTypeSignature Tsig> |
763 | bool CIccXmlArrayType<T, Tsig>::ParseArray(xmlNode *pNode) |
764 | { |
765 | char scanType[2]; |
766 | scanType[0] = (Tsig == icSigFloatArrayType((icTagTypeSignature)0x66637420) ? 'f' : 'n'); |
767 | scanType[1] = 0; |
768 | |
769 | icUInt32Number n = icXmlNodeCount(pNode, scanType); |
770 | |
771 | if (n) { |
772 | if (!SetSize(n)) |
773 | return false; |
774 | return ParseArray(m_pBuf, m_nSize, pNode); |
775 | } |
776 | |
777 | for ( ;pNode && pNode->type!= XML_TEXT_NODE; pNode=pNode->next); |
778 | |
779 | if (!pNode || !pNode->content) |
780 | return false; |
781 | |
782 | n = ParseTextCount((const char*)pNode->content); |
783 | |
784 | if (!n || !SetSize(n)) |
785 | return false; |
786 | |
787 | return ParseArray(m_pBuf, m_nSize, pNode); |
788 | } |
789 | |
790 | template <class T, icTagTypeSignature Tsig> |
791 | bool CIccXmlArrayType<T, Tsig>::ParseTextArray(const char *szText) |
792 | { |
793 | icUInt32Number n = ParseTextCount(szText); |
794 | |
795 | if (n) { |
796 | if (!SetSize(n)) |
797 | return false; |
798 | |
799 | return ParseText(m_pBuf, m_nSize, szText)==m_nSize; |
800 | } |
801 | |
802 | return false; |
803 | } |
804 | |
805 | template <class T, icTagTypeSignature Tsig> |
806 | bool CIccXmlArrayType<T, Tsig>::ParseTextArray(xmlNode *pNode) |
807 | { |
808 | if (pNode->children && pNode->children->type==XML_TEXT_NODE) { |
809 | return ParseTextArray((const char*)pNode->children->content); |
810 | } |
811 | return false; |
812 | } |
813 | |
814 | template <class T, icTagTypeSignature Tsig> |
815 | bool CIccXmlArrayType<T, Tsig>::ParseTextArrayNum(const char *szText, icUInt32Number num, std::string &parseStr) |
816 | { |
817 | icUInt32Number n = ParseTextCountNum(szText, num, parseStr); |
818 | if (n) { |
819 | if (!SetSize(n)) |
820 | return false; |
821 | return ParseText(m_pBuf, m_nSize, szText)==m_nSize; |
822 | } |
823 | |
824 | return false; |
825 | } |
826 | |
827 | template <class T, icTagTypeSignature Tsig> |
828 | bool CIccXmlArrayType<T, Tsig>::DumpArray(std::string &xml, std::string blanks, T *buf, icUInt32Number nBufSize, |
829 | icConvertType nType, icUInt8Number nColumns) |
830 | { |
831 | char str[200]; |
832 | |
833 | if (!nColumns) nColumns = 1; |
834 | icUInt32Number i; |
835 | |
836 | for (i=0; i<nBufSize; i++) { |
837 | if (!(i%nColumns)) { |
838 | xml += blanks; |
839 | } |
840 | else { |
841 | xml += " "; |
842 | } |
843 | |
844 | switch (Tsig) { |
845 | case icSigUInt8ArrayType: |
846 | switch (nType) { |
847 | case icConvert8Bit: |
848 | default: |
849 | sprintf(str, "%u", (icUInt8Number)buf[i]); |
850 | break; |
851 | |
852 | case icConvert16Bit: |
853 | sprintf(str, "%u", (icUInt16Number)((icFloatNumber)buf[i] * 65535.0 / 255.0 + 0.5)); |
854 | break; |
855 | |
856 | case icConvertFloat: |
857 | sprintf(str, "%.8f", (icFloatNumber)buf[i] / 255.0); |
858 | break; |
859 | } |
860 | break; |
861 | |
862 | case icSigUInt16ArrayType: |
863 | switch (nType) { |
864 | case icConvert8Bit: |
865 | sprintf(str, "%u", (icUInt16Number)((icFloatNumber)buf[i] * 255.0 / 65535.0 + 0.5)); |
866 | break; |
867 | |
868 | case icConvert16Bit: |
869 | default: |
870 | sprintf(str, "%u", (icUInt16Number)buf[i]); |
871 | break; |
872 | |
873 | case icConvertFloat: |
874 | sprintf(str, "%.8f", (icFloatNumber)buf[i] / 65535.0); |
875 | break; |
876 | } |
877 | break; |
878 | |
879 | case icSigUInt32ArrayType: |
880 | sprintf(str, "%u", (icUInt32Number)buf[i]); |
881 | break; |
882 | |
883 | case icSigUInt64ArrayType: |
884 | // unused |
885 | break; |
886 | |
887 | case icSigFloatArrayType((icTagTypeSignature)0x66637420): |
888 | case icSigFloat32ArrayType: |
889 | case icSigFloat64ArrayType: |
890 | switch (nType) { |
891 | case icConvert8Bit: |
892 | sprintf(str, "%u", (icUInt8Number)(buf[i] * 255.0 + 0.5)); |
893 | break; |
894 | |
895 | case icConvert16Bit: |
896 | sprintf(str, "%u", (icUInt16Number)(buf[i] * 65535.0 + 0.5)); |
897 | break; |
898 | |
899 | case icConvertFloat: |
900 | default: |
901 | sprintf(str, "%.8f", (icFloatNumber)buf[i]); |
902 | } |
903 | break; |
904 | } |
905 | xml += str; |
906 | if (i%nColumns == nColumns-1) { |
907 | xml += "\n"; |
908 | } |
909 | } |
910 | |
911 | if (i%nColumns) { |
912 | xml += "\n"; |
913 | } |
914 | |
915 | return true; |
916 | } |
917 | |
918 | // for multi-platform support |
919 | // replaced "_inline" with "inline" |
920 | static inline bool icIsNumChar(char c) |
921 | { |
922 | if ((c>='0' && c<='9') || c=='.' || c=='+' || c=='-' || c=='e' || c == 'n' || c == 'a') |
923 | return true; |
924 | return false; |
925 | } |
926 | |
927 | // function used when checking contents of a file |
928 | // count the number of entries. |
929 | template <class T, icTagTypeSignature Tsig> |
930 | icUInt32Number CIccXmlArrayType<T, Tsig>::ParseTextCountNum(const char *szText, icUInt32Number num, std::string &parseStr) |
931 | { |
932 | icUInt32Number n = 0; |
933 | bool bInNum = false; |
934 | //icUInt32Number count = 1; |
935 | |
936 | //while (*szText) { |
937 | for (icUInt32Number i=0; i<num; i++) { |
938 | if (icIsNumChar(*szText)) { |
939 | if (!bInNum) { |
940 | bInNum = true; |
941 | } |
942 | } |
943 | else if (bInNum && !strncmp(szText, "#QNAN", 5)) { //Handle 1.#QNAN000 (non a number) |
944 | i+=4; |
945 | szText+=4; |
946 | } |
947 | // an invalid character is encountered (not digit and not space) |
948 | else if (!isspace(*szText) && i <= num ){ |
949 | char line[100]; |
950 | sprintf(line, "Data '%c' in position %d is not a number. ", *szText, i); |
951 | parseStr += line; |
952 | return false; |
953 | } |
954 | else if (bInNum) { //char is a space |
955 | n++; |
956 | bInNum = false; |
957 | } |
958 | szText++; |
959 | //count++; |
960 | } |
961 | if (bInNum) { |
962 | n++; |
963 | } |
964 | |
965 | return n; |
966 | } |
967 | |
968 | template <class T, icTagTypeSignature Tsig> |
969 | icUInt32Number CIccXmlArrayType<T, Tsig>::ParseTextCount(const char *szText) |
970 | { |
971 | icUInt32Number n = 0; |
972 | bool bInNum = false; |
973 | |
974 | while (*szText) { |
975 | if (icIsNumChar(*szText)) { |
976 | if (!bInNum) { |
977 | bInNum = true; |
978 | } |
979 | } |
980 | else if (bInNum && !strncmp(szText, "#QNAN", 5)) { //Handle 1.#QNAN000 (non a number) |
981 | szText+=4; |
982 | } |
983 | else if (bInNum) { |
984 | n++; |
985 | bInNum = false; |
986 | } |
987 | szText++; |
988 | } |
989 | if (bInNum) { |
990 | n++; |
991 | } |
992 | |
993 | return n; |
994 | } |
995 | |
996 | template <class T, icTagTypeSignature Tsig> |
997 | icUInt32Number CIccXmlArrayType<T, Tsig>::ParseText(T* pBuf, icUInt32Number nSize, const char *szText) |
998 | { |
999 | icUInt32Number n = 0, b = 0; |
1000 | bool bInNum = false; |
1001 | char num[256]; |
1002 | |
1003 | while (*szText && n<nSize) { |
1004 | if (icIsNumChar(*szText)) { |
1005 | if (!bInNum) { |
1006 | bInNum = true; |
1007 | b=0; |
1008 | } |
1009 | num[b] = *szText; |
1010 | |
1011 | if (b+2<sizeof(num)) |
1012 | b++; |
1013 | } |
1014 | else if (bInNum) { |
1015 | num[b] = 0; |
1016 | if (!strncmp(num, "nan", 3) || !strncmp(num, "-nan", 4)) { |
1017 | pBuf[n] = (T)nanf(num); |
1018 | } |
1019 | else { |
1020 | pBuf[n] = (T)atof(num); |
1021 | } |
1022 | n++; |
1023 | bInNum = false; |
1024 | } |
1025 | szText++; |
1026 | } |
1027 | if (bInNum) { |
1028 | num[b] = 0; |
1029 | if (!strncmp(num, "nan", 3) || !strncmp(num, "-nan", 4)) { |
1030 | pBuf[n] = (T)nanf(num); |
1031 | } |
1032 | else { |
1033 | pBuf[n] = (T)atof(num); |
1034 | } |
1035 | n++; |
1036 | } |
1037 | |
1038 | return n; |
1039 | } |
1040 | |
1041 | template <class T, icTagTypeSignature Tsig> |
1042 | bool CIccXmlArrayType<T, Tsig>::ParseArray(T* pBuf, icUInt32Number nSize, xmlNode *pNode) |
1043 | { |
1044 | icUInt32Number n; |
1045 | if (Tsig==icSigFloatArrayType((icTagTypeSignature)0x66637420)) { |
1046 | n = icXmlNodeCount(pNode, "f"); |
1047 | |
1048 | if (!n) { |
1049 | if (pNode->type!=XML_TEXT_NODE || !pNode->content) |
1050 | return false; |
1051 | |
1052 | n = ParseTextCount((const char*)pNode->content); |
1053 | if (!n || n>nSize) |
1054 | return false; |
1055 | |
1056 | ParseText(pBuf, n, (const char*)pNode->content); |
1057 | } |
1058 | else { |
1059 | if (n>nSize) |
1060 | return false; |
1061 | |
1062 | icUInt32Number i; |
1063 | for (i=0; i<nSize && pNode; pNode = pNode->next) { |
1064 | if (pNode->type == XML_ELEMENT_NODE && |
1065 | !icXmlStrCmp(pNode->name, "f")strcmp((const char *)(pNode->name), (const char*)("f")) && |
1066 | pNode->children && |
1067 | pNode->children->content) { |
1068 | float f; |
1069 | sscanf((const char *)(pNode->children->content), "%f", &f); |
1070 | pBuf[i] = (T)f; |
1071 | i++; |
1072 | } |
1073 | } |
1074 | } |
1075 | } |
1076 | else { |
1077 | n = icXmlNodeCount(pNode, "n"); |
1078 | |
1079 | if (!n) { |
1080 | if (pNode->type!=XML_TEXT_NODE || !pNode->content) |
1081 | return false; |
1082 | |
1083 | n = ParseTextCount((const char *)pNode->content); |
1084 | if (!n || n>nSize) |
1085 | return false; |
1086 | |
1087 | n = ParseText(pBuf, n, (const char *)pNode->content); |
1088 | } |
1089 | else { |
1090 | if (n>nSize) |
1091 | return false; |
1092 | |
1093 | icUInt32Number i; |
1094 | for (i=0; i<nSize && pNode; pNode = pNode->next) { |
1095 | if (pNode->type == XML_ELEMENT_NODE && |
1096 | !icXmlStrCmp(pNode->name, "n")strcmp((const char *)(pNode->name), (const char*)("n")) && |
1097 | pNode->children && |
1098 | pNode->children->content) { |
1099 | pBuf[i] = (T)atol((const char *)(pNode->children->content)); |
1100 | i++; |
1101 | } |
1102 | } |
1103 | } |
1104 | } |
1105 | return nSize==n; |
1106 | } |
1107 | |
1108 | |
1109 | template <class T, icTagTypeSignature Tsig> |
1110 | bool CIccXmlArrayType<T, Tsig>::SetSize(icUInt32Number nSize) |
1111 | { |
1112 | if (m_pBuf) { |
1113 | free(m_pBuf); |
1114 | } |
1115 | m_pBuf = (T*)malloc(nSize * sizeof(T)); |
1116 | if (!m_pBuf) { |
1117 | m_nSize = 0; |
1118 | return false; |
1119 | } |
1120 | m_nSize = nSize; |
1121 | |
1122 | return true; |
1123 | } |
1124 | |
1125 | //Make sure typedef classes get built |
1126 | template class CIccXmlArrayType<icUInt8Number, icSigUInt8ArrayType>; |
1127 | template class CIccXmlArrayType<icUInt16Number, icSigUInt16ArrayType>; |
1128 | template class CIccXmlArrayType<icUInt32Number, icSigUInt32ArrayType>; |
1129 | template class CIccXmlArrayType<icUInt64Number, icSigUInt64ArrayType>; |
1130 | template class CIccXmlArrayType<icFloatNumber, icSigFloatArrayType((icTagTypeSignature)0x66637420)>; |
1131 | template class CIccXmlArrayType<icFloat32Number, icSigFloat32ArrayType>; |
1132 | template class CIccXmlArrayType<icFloat64Number, icSigFloat64ArrayType>; |
1133 | |
1134 | |
1135 | const icRenderingIntent icGetRenderingIntentValue (icChar *szRenderingIntent) |
1136 | { |
1137 | if (!strcmp(szRenderingIntent, "Perceptual")) |
1138 | return icPerceptual; |
1139 | else if (!strcmp(szRenderingIntent, "Media-relative colorimetric")) |
1140 | return icRelativeColorimetric; |
1141 | else if (!strcmp(szRenderingIntent, "Saturation")) |
1142 | return icSaturation; |
1143 | else if (!strcmp(szRenderingIntent, "ICC-absolute colorimetric")) |
1144 | return icAbsoluteColorimetric; |
1145 | |
1146 | return icPerceptual; |
1147 | } |
1148 | |
1149 | const icChar* icGetTagSigTypeName(icTagTypeSignature tagTypeSig) |
1150 | { |
1151 | const icChar *rv = CIccTagCreator::GetTagTypeSigName(tagTypeSig); |
1152 | |
1153 | // if the tag signature is not found, it is a custom type. |
1154 | if (!rv) |
1155 | return "PrivateType"; |
1156 | |
1157 | return rv; |
1158 | } |
1159 | |
1160 | icTagTypeSignature icGetTypeNameTagSig(const icChar* szTagType) |
1161 | { |
1162 | return CIccTagCreator::GetTagTypeNameSig(szTagType); |
1163 | |
1164 | } |
1165 | |
1166 | const icChar* icGetTagSigName(icTagSignature tagTypeSig) |
1167 | { |
1168 | const icChar *rv = CIccTagCreator::GetTagSigName(tagTypeSig); |
1169 | |
1170 | // if the tag signature is not found, it is a custom type. |
1171 | if (!rv) |
1172 | return "PrivateTag"; |
1173 | |
1174 | return rv; |
1175 | } |
1176 | |
1177 | icTagSignature icGetTagNameSig(const icChar *szName) |
1178 | { |
1179 | return CIccTagCreator::GetTagNameSig(szName); |
1180 | } |
1181 | |
1182 | |
1183 | icStandardObserver icGetNamedStandardObserverValue(const icChar* str) |
1184 | { |
1185 | if (!strcmp(str, "Unknown observer")) |
1186 | return icStdObsUnknown; |
1187 | |
1188 | if (!strcmp(str, "CIE 1931 standard colorimetric observer")) |
1189 | return icStdObs1931TwoDegrees; |
1190 | |
1191 | if (!strcmp(str, "CIE 1964 standard colorimetric observer")) |
1192 | return icStdObs1964TenDegrees; |
1193 | |
1194 | return icStdObsCustomicStdObsUnknown; |
1195 | } |
1196 | |
1197 | |
1198 | icMeasurementGeometry icGeNamedtMeasurementGeometryValue(const icChar* str) |
1199 | { |
1200 | if (!strcmp(str, "Geometry Unknown")) |
1201 | return icGeometryUnknown; |
1202 | |
1203 | if (!strcmp(str, "Geometry 0-45 or 45-0")) |
1204 | return icGeometry045or450; |
1205 | |
1206 | if (!strcmp(str, "Geometry 0-d or d-0")) |
1207 | return icGeometry0dord0; |
1208 | |
1209 | if (!strcmp(str, "Max Geometry")) |
1210 | return icMaxEnumGeometry((icMeasurementGeometry) 0xFFFFFFFF); |
1211 | |
1212 | return icGeometryUnknown; |
1213 | } |
1214 | |
1215 | icMeasurementFlare icGetNamedMeasurementFlareValue(const icChar * str) |
1216 | { |
1217 | if (!strcmp(str, "Flare 0")) |
1218 | return icFlare0; |
1219 | |
1220 | if (!strcmp(str, "Flare 100")) |
1221 | return icFlare100; |
1222 | |
1223 | if (!strcmp(str, "Max Flare")) |
1224 | return icMaxEnumFlare((icMeasurementFlare) 0xFFFFFFFF); |
1225 | |
1226 | return icFlare0; |
1227 | } |
1228 | |
1229 | icIlluminant icGetIlluminantValue(const icChar* str) |
1230 | { |
1231 | if (!strcmp(str, "Illuminant Unknown")) |
1232 | return icIlluminantUnknown; |
1233 | |
1234 | if (!strcmp(str, "Illuminant D50") || !strcmp(str, "D50")) |
1235 | return icIlluminantD50; |
1236 | |
1237 | if (!strcmp(str, "Illuminant D65") || !strcmp(str, "D65")) |
1238 | return icIlluminantD65; |
1239 | |
1240 | if (!strcmp(str, "Illuminant D93") || !strcmp(str, "D93")) |
1241 | return icIlluminantD93; |
1242 | |
1243 | if (!strcmp(str, "Illuminant F2") || !strcmp(str, "F2")) |
1244 | return icIlluminantF2; |
1245 | |
1246 | if (!strcmp(str, "Illuminant D55") || !strcmp(str, "D55")) |
1247 | return icIlluminantD55; |
1248 | |
1249 | if (!strcmp(str, "Illuminant A") || !strcmp(str, "A")) |
1250 | return icIlluminantA; |
1251 | |
1252 | if (!strcmp(str, "Illuminant EquiPowerE") || !strcmp(str, "Illuminant E") || !strcmp(str, "E")) |
1253 | return icIlluminantEquiPowerE; |
1254 | |
1255 | if (!strcmp(str, "Illuminant F8") || !strcmp(str, "F8")) |
1256 | return icIlluminantF8; |
1257 | |
1258 | if (!strcmp(str, "Illuminant Black Body") || !strcmp(str, "Black Body")) |
1259 | return icIlluminantBlackBody; |
1260 | |
1261 | if (!strcmp(str, "Illuminant Daylight") || !strcmp(str, "Daylight")) |
1262 | return icIlluminantDaylight; |
1263 | |
1264 | if (!strcmp(str, "Illuminant B") || !strcmp(str, "B")) |
1265 | return icIlluminantB; |
1266 | |
1267 | if (!strcmp(str, "Illuminant C") || !strcmp(str, "C")) |
1268 | return icIlluminantC; |
1269 | |
1270 | if (!strcmp(str, "Illuminant F1") || !strcmp(str, "F1")) |
1271 | return icIlluminantF1; |
1272 | |
1273 | if (!strcmp(str, "Illuminant F3") || !strcmp(str, "F3")) |
1274 | return icIlluminantF3; |
1275 | |
1276 | if (!strcmp(str, "Illuminant F4") || !strcmp(str, "F4")) |
1277 | return icIlluminantF4; |
1278 | |
1279 | if (!strcmp(str, "Illuminant F5") || !strcmp(str, "F5")) |
1280 | return icIlluminantF5; |
1281 | |
1282 | if (!strcmp(str, "Illuminant F6") || !strcmp(str, "F6")) |
1283 | return icIlluminantF6; |
1284 | |
1285 | if (!strcmp(str, "Illuminant F7") || !strcmp(str, "F7")) |
1286 | return icIlluminantF7; |
1287 | |
1288 | if (!strcmp(str, "Illuminant F9") || !strcmp(str, "F9")) |
1289 | return icIlluminantF9; |
1290 | |
1291 | if (!strcmp(str, "Illuminant F10") || !strcmp(str, "F10")) |
1292 | return icIlluminantF10; |
1293 | |
1294 | if (!strcmp(str, "Illuminant F11") || !strcmp(str, "F11")) |
1295 | return icIlluminantF11; |
1296 | |
1297 | if (!strcmp(str, "Illuminant F12") || !strcmp(str, "F12")) |
1298 | return icIlluminantF12; |
1299 | |
1300 | return icIlluminantCustomicIlluminantUnknown; |
1301 | } |
1302 | |
1303 | const icChar* icGetStandardObserverName(icStandardObserver str) |
1304 | { |
1305 | switch (str) { |
1306 | case icStdObsUnknown: |
1307 | return "Unknown Observer"; |
1308 | |
1309 | case icStdObs1931TwoDegrees: |
1310 | return "CIE 1931 standard colorimetric observer"; |
1311 | |
1312 | case icStdObs1964TenDegrees: |
1313 | return "CIE 1964 standard colorimetric observer"; |
1314 | |
1315 | default: |
1316 | return "Unknown Observer"; |
1317 | } |
1318 | } |
1319 | |
1320 | icDateTimeNumber icGetDateTimeValue(const icChar* str) |
1321 | { |
1322 | unsigned int day=0, month=0, year=0, hours=0, minutes=0, seconds=0; |
1323 | icDateTimeNumber dateTime; |
1324 | |
1325 | if (!stricmpstrcasecmp(str, "now")) { |
1326 | time_t rawtime; |
1327 | struct tm * timeinfo; |
1328 | |
1329 | time ( &rawtime ); |
1330 | timeinfo = localtime ( &rawtime ); |
1331 | year = timeinfo->tm_year+1900; |
1332 | month = timeinfo->tm_mon+1; |
1333 | day = timeinfo->tm_mday; |
1334 | hours = timeinfo->tm_hour; |
1335 | minutes = timeinfo->tm_min; |
1336 | seconds = timeinfo->tm_sec; |
1337 | } |
1338 | else { |
1339 | sscanf(str, "%d-%02d-%02dT%02d:%02d:%02d", &year, &month, &day, &hours, &minutes, &seconds); |
1340 | } |
1341 | |
1342 | dateTime.year = year; |
1343 | dateTime.month = month; |
1344 | dateTime.day = day; |
1345 | dateTime.hours = hours; |
1346 | dateTime.minutes = minutes; |
1347 | dateTime.seconds = seconds; |
1348 | |
1349 | return dateTime; |
1350 | } |
1351 | |
1352 | icUInt64Number icGetDeviceAttrValue(xmlNode *pNode) |
1353 | { |
1354 | icUInt64Number devAttr = 0; |
1355 | xmlAttr *attr = icXmlFindAttr(pNode, "ReflectiveOrTransparency"); |
1356 | if (attr && !strcmp(icXmlAttrValue(attr), "transparency")) { |
1357 | devAttr |= icTransparency0x00000001; |
1358 | } |
1359 | |
1360 | attr = icXmlFindAttr(pNode, "GlossyOrMatte"); |
1361 | if (attr && !strcmp(icXmlAttrValue(attr), "matte")) { |
1362 | devAttr |= icMatte0x00000002; |
1363 | } |
1364 | |
1365 | attr = icXmlFindAttr(pNode, "MediaPolarity"); |
1366 | if (attr && !strcmp(icXmlAttrValue(attr), "negative")) { |
1367 | devAttr |= icMediaNegative0x00000004; |
1368 | } |
1369 | |
1370 | attr = icXmlFindAttr(pNode, "MediaColour"); |
1371 | if (attr && !strcmp(icXmlAttrValue(attr), "blackAndWhite")) { |
1372 | devAttr |= icMediaBlackAndWhite0x00000008; |
1373 | } |
1374 | |
1375 | attr = icXmlFindAttr(pNode, "VendorSpecific"); |
1376 | if (attr) { |
1377 | icUInt64Number vendor; |
1378 | #if defined(__APPLE__1) |
1379 | sscanf(icXmlAttrValue(attr), "%llx", &vendor); |
1380 | #else |
1381 | sscanf(icXmlAttrValue(attr), "%I64x", &vendor); |
1382 | #endif |
1383 | devAttr |= vendor; |
1384 | } |
1385 | |
1386 | return devAttr; |
1387 | } |
1388 | |
1389 | icColorantEncoding icGetColorantValue(const icChar* str) |
1390 | { |
1391 | if (!strcmp(str, "ITU-R BT.709")) |
1392 | return icColorantITU; |
1393 | |
1394 | if (!strcmp(str, "SMPTE RP145-1994")) |
1395 | return icColorantSMPTE; |
1396 | |
1397 | if (!strcmp(str, "EBU Tech.3213-E")) |
1398 | return icColorantEBU; |
1399 | |
1400 | if (!strcmp(str, "P22")) |
1401 | return icColorantP22; |
1402 | |
1403 | return icColorantUnknown; |
1404 | } |
1405 | |
1406 | icMeasurementUnitSig icGetMeasurementValue(const icChar* str) |
1407 | { |
1408 | if (!strcmp(str, "Status A")) |
1409 | return icSigStatusA; |
1410 | |
1411 | if (!strcmp(str, "Status E")) |
1412 | return icSigStatusE; |
1413 | |
1414 | if (!strcmp(str, "Status I")) |
1415 | return icSigStatusI; |
1416 | |
1417 | if (!strcmp(str, "Status T")) |
1418 | return icSigStatusT; |
1419 | |
1420 | if (!strcmp(str, "Status M")) |
1421 | return icSigStatusM; |
1422 | |
1423 | if (!strcmp(str, "DIN with no polarizing filter")) |
1424 | return icSigDN; |
1425 | |
1426 | if (!strcmp(str, "DIN with polarizing filter")) |
1427 | return icSigDNP; |
1428 | |
1429 | if (!strcmp(str, "Narrow band DIN with no polarizing filter")) |
1430 | return icSigDNN; |
1431 | |
1432 | if (!strcmp(str, "Narrow band DIN with polarizing filter")) |
1433 | return icSigDNNP; |
1434 | |
1435 | return icSigStatusA; |
1436 | } |
1437 | |
1438 | const std::string icGetDeviceAttrName(icUInt64Number devAttr) |
1439 | { |
1440 | char line[256]; |
1441 | std::string xml; |
1442 | |
1443 | if (devAttr & icTransparency0x00000001) |
1444 | sprintf(line, "<DeviceAttributes ReflectiveOrTransparency=\"transparency\""); |
1445 | else |
1446 | sprintf(line, "<DeviceAttributes ReflectiveOrTransparency=\"reflective\""); |
1447 | xml += line; |
1448 | |
1449 | |
1450 | if (devAttr & icMatte0x00000002) |
1451 | sprintf(line, " GlossyOrMatte=\"matte\""); |
1452 | else |
1453 | sprintf(line, " GlossyOrMatte=\"glossy\""); |
1454 | xml += line; |
1455 | |
1456 | |
1457 | if (devAttr & icMediaNegative0x00000004) |
1458 | sprintf(line, " MediaPolarity=\"negative\""); |
1459 | else |
1460 | sprintf(line, " MediaPolarity=\"positive\""); |
1461 | xml += line; |
1462 | |
1463 | if (devAttr & icMediaBlackAndWhite0x00000008) |
1464 | sprintf(line, " MediaColour=\"blackAndwhite\""); |
1465 | else |
1466 | sprintf(line, " MediaColour=\"colour\""); |
1467 | xml += line; |
1468 | |
1469 | icUInt64Number otherAttr = ~((icUInt64Number)icTransparency0x00000001|icMatte0x00000002|icMediaNegative0x00000004|icMediaBlackAndWhite0x00000008); |
1470 | |
1471 | if (devAttr & otherAttr) { |
1472 | #if defined(__APPLE__1) |
1473 | sprintf(line, " VendorSpecific=\"%016llx\"", devAttr & otherAttr); |
1474 | #else |
1475 | sprintf(line, " VendorSpecific=\"%016I64x\"", devAttr & otherAttr); |
1476 | #endif |
1477 | xml += line; |
1478 | } |
1479 | |
1480 | xml += "/>\n"; |
1481 | |
1482 | return xml; |
1483 | } |
1484 | |
1485 | const std::string icGetHeaderFlagsName(icUInt32Number flags, bool bUsesMCS) |
1486 | { |
1487 | char line[256]; |
1488 | std::string xml; |
1489 | |
1490 | if (flags & icEmbeddedProfileTrue0x00000001) |
1491 | sprintf(line, "<ProfileFlags EmbeddedInFile=\"true\""); |
1492 | else |
1493 | sprintf(line, "<ProfileFlags EmbeddedInFile=\"false\""); |
1494 | xml += line; |
1495 | |
1496 | if (flags & icUseWithEmbeddedDataOnly0x00000002) |
1497 | sprintf(line, " UseWithEmbeddedDataOnly=\"true\""); |
1498 | else |
1499 | sprintf(line, " UseWithEmbeddedDataOnly=\"false\""); |
1500 | xml += line; |
1501 | |
1502 | icUInt32Number otherFlags = ~(icEmbeddedProfileTrue0x00000001|icUseWithEmbeddedDataOnly0x00000002); |
1503 | |
1504 | if (bUsesMCS) { |
1505 | if (flags & icMCSNeedsSubsetTrue0x00000004) |
1506 | sprintf(line, " MCSNeedsSubset=\"true\""); |
1507 | else |
1508 | sprintf(line, " MCSNeedsSubset=\"false\""); |
1509 | xml += line; |
1510 | |
1511 | otherFlags &= ~icMCSNeedsSubsetTrue0x00000004; |
1512 | } |
1513 | |
1514 | |
1515 | if (flags & otherFlags) { |
1516 | sprintf(line, " VendorFlags=\"%08x\"", flags & otherFlags); |
1517 | xml += line; |
1518 | } |
1519 | |
1520 | xml += "/>\n"; |
1521 | |
1522 | return xml; |
1523 | } |
1524 | |
1525 | const std::string icGetPadSpace(double value) |
1526 | { |
1527 | std::string space = ""; |
1528 | if ( value >=0 && value < 10) |
1529 | space = " "; |
1530 | if ( value >=10 && value < 100) |
1531 | space = " "; |
1532 | if ( value >=100 && value < 1000 ) |
1533 | space = " "; |
1534 | |
1535 | return space; |
1536 | } |
1537 |