?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Backout bug 449422.
[wine-gecko.git] / modules / lcms / src / cmsio1.c
blobf4bdc2c3e615f203854aaeb1a646ddea31f89aa7
1 //
2 // Little cms
3 // Copyright (C) 1998-2007 Marti Maria
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining
6 // a copy of this software and associated documentation files (the "Software"),
7 // to deal in the Software without restriction, including without limitation
8 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 // and/or sell copies of the Software, and to permit persons to whom the Software
10 // is furnished to do so, subject to the following conditions:
11 //
12 // The above copyright notice and this permission notice shall be included in
13 // all copies or substantial portions of the Software.
14 //
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
17 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22
23 // ICC profile serialization
24
25
26 #include "lcms.h"
27
28 // ----------------------------------------------------------------- Tag Serialization
29
30 // Alignment of ICC file format uses 4 bytes DWORD
31
32 #define ALIGNLONG(x) (((x)+3) & ~(3)) // Aligns to DWORD boundary
33
34
35 static int GlobalLanguageCode; // Language & country descriptors, for ICC 4.0 support
36 static int GlobalCountryCode;
37
38
39 #ifdef __BEOS__
40 # define USE_CUSTOM_SWAB 1
41 #endif
42
43
44 #ifdef USE_CUSTOM_SWAB
45
46 // Replacement to swab function, thanks to YNOP
47 // for providing the BeOS port
48 //
49 // from: @(#)swab.c 5.10 (Berkeley) 3/6/91
50
51 static
52 void xswab(const void *from, void *to, size_t len)
53 {
54 register unsigned long temp;
55 register int n;
56 register char *fp, *tp;
57
58 n = (len >> 1) + 1;
59 fp = (char *)from;
60 tp = (char *)to;
61 #define STEP temp = *fp++,*tp++ = *fp++,*tp++ = temp
62 /* round to multiple of 8 */
63 while ((--n) & 07)
64 STEP;
65 n >>= 3;
66 while (--n >= 0) {
67
68 STEP; STEP; STEP; STEP;
69 STEP; STEP; STEP; STEP;
70 }
71 #undef STEP
72 }
73 #else
74 #define xswab swab
75 #endif
76
77
78 //
79 // Little-Endian to Big-Endian
80 //
81
82 #ifdef USE_BIG_ENDIAN
83 #define AdjustEndianess16(a)
84 #define AdjustEndianess32(a)
85 #define AdjustEndianessArray16(a, b)
86 #else
87
88 static
89 void AdjustEndianess16(LPBYTE pByte)
90 {
91 BYTE tmp;
92
93 tmp = pByte[0];
94 pByte[0] = pByte[1];
95 pByte[1] = tmp;
96 }
97
98 static
99 void AdjustEndianess32(LPBYTE pByte)
100 {
101 BYTE temp1;
102 BYTE temp2;
103
104 temp1 = *pByte++;
105 temp2 = *pByte++;
106 *(pByte-1) = *pByte;
107 *pByte++ = temp2;
108 *(pByte-3) = *pByte;
109 *pByte = temp1;
110 }
111
112
113 // swap bytes in a array of words
114
115 static
116 void AdjustEndianessArray16(LPWORD p, size_t num_words)
117 {
118 xswab((char*) p, (char*)p, (int) num_words * sizeof(WORD));
119 }
120
121 #endif
122
123
124 // Transports to properly encoded values - note that icc profiles does use
125 // big endian notation.
126
127 static
128 icInt32Number TransportValue32(icInt32Number Value)
129 {
130 icInt32Number Temp = Value;
131
132 AdjustEndianess32((LPBYTE) &Temp);
133 return Temp;
134 }
135
136 static
137 WORD TransportValue16(WORD Value)
138 {
139 WORD Temp = Value;
140
141 AdjustEndianess16((LPBYTE) &Temp);
142 return Temp;
143 }
144
145
146 // from Fixed point 8.8 to double
147
148 static
149 double Convert8Fixed8(WORD fixed8)
150 {
151 BYTE msb, lsb;
152
153 lsb = (BYTE) (fixed8 & 0xff);
154 msb = (BYTE) (((WORD) fixed8 >> 8) & 0xff);
155
156 return (double) ((double) msb + ((double) lsb / 256.0));
157 }
158
159
160 // from Fixed point 15.16 to double
161 static
162 double Convert15Fixed16(icS15Fixed16Number fix32)
163 {
164 double floater, sign, mid, hack;
165 int Whole, FracPart;
166
167
168 AdjustEndianess32((LPBYTE) &fix32);
169
170 sign = (fix32 < 0 ? -1 : 1);
171 fix32 = abs(fix32);
172
173 Whole = LOWORD(fix32 >> 16);
174 FracPart = LOWORD(fix32 & 0x0000ffffL);
175
176 hack = 65536.0;
177 mid = (double) FracPart / hack;
178 floater = (double) Whole + mid;
179
180 return sign * floater;
181 }
182
183
184 // Auxiliar-- read base and return type
185
186 static
187 icTagTypeSignature ReadBase(LPLCMSICCPROFILE Icc)
188 {
189 icTagBase Base;
190
191 Icc -> Read(&Base, sizeof(icTagBase), 1, Icc);
192 AdjustEndianess32((LPBYTE) &Base.sig);
193
194 return Base.sig;
195 }
196
197
198 static
199 void DecodeDateTimeNumber(const icDateTimeNumber *Source, struct tm *Dest)
200 {
201 Dest->tm_sec = TransportValue16(Source->seconds);
202 Dest->tm_min = TransportValue16(Source->minutes);
203 Dest->tm_hour = TransportValue16(Source->hours);
204 Dest->tm_mday = TransportValue16(Source->day);
205 Dest->tm_mon = TransportValue16(Source->month) - 1;
206 Dest->tm_year = TransportValue16(Source->year) - 1900;
207 Dest->tm_wday = -1;
208 Dest->tm_yday = -1;
209 Dest->tm_isdst = 0;
210 }
211
212 static
213 void EncodeDateTimeNumber(icDateTimeNumber *Dest, const struct tm *Source)
214 {
215 Dest->seconds = TransportValue16((WORD) Source->tm_sec);
216 Dest->minutes = TransportValue16((WORD) Source->tm_min);
217 Dest->hours = TransportValue16((WORD) Source->tm_hour);
218 Dest->day = TransportValue16((WORD) Source->tm_mday);
219 Dest->month = TransportValue16((WORD) (Source->tm_mon + 1));
220 Dest->year = TransportValue16((WORD) (Source->tm_year + 1900));
221 }
222
223
224 // Jun-21-2000: Some profiles (those that comes with W2K) comes
225 // with the media white (media black?) x 100. Add a sanity check
226
227 static
228 void NormalizeXYZ(LPcmsCIEXYZ Dest)
229 {
230 while (Dest -> X > 2. &&
231 Dest -> Y > 2. &&
232 Dest -> Z > 2.) {
233
234 Dest -> X /= 10.;
235 Dest -> Y /= 10.;
236 Dest -> Z /= 10.;
237 }
238 }
239
240 // Evaluates a XYZ tristimulous across chromatic adaptation matrix
241
242 static
243 void EvalCHRM(LPcmsCIEXYZ Dest, LPMAT3 Chrm, LPcmsCIEXYZ Src)
244 {
245 VEC3 d, s;
246
247 s.n[VX] = Src -> X;
248 s.n[VY] = Src -> Y;
249 s.n[VZ] = Src -> Z;
250
251 MAT3eval(&d, Chrm, &s);
252
253 Dest ->X = d.n[VX];
254 Dest ->Y = d.n[VY];
255 Dest ->Z = d.n[VZ];
256
257 }
258
259
260 // Read profile header and validate it
261
262 static
263 LPLCMSICCPROFILE ReadHeader(LPLCMSICCPROFILE Icc, LCMSBOOL lIsFromMemory)
264 {
265 icTag Tag;
266 icHeader Header;
267 icInt32Number TagCount, i;
268
269 if (Icc -> Read(&Header, sizeof(icHeader), 1, Icc) != 1)
270 goto ErrorCleanup;
271
272 // Convert endian
273
274 AdjustEndianess32((LPBYTE) &Header.size);
275 AdjustEndianess32((LPBYTE) &Header.cmmId);
276 AdjustEndianess32((LPBYTE) &Header.version);
277 AdjustEndianess32((LPBYTE) &Header.deviceClass);
278 AdjustEndianess32((LPBYTE) &Header.colorSpace);
279 AdjustEndianess32((LPBYTE) &Header.pcs);
280 AdjustEndianess32((LPBYTE) &Header.magic);
281 AdjustEndianess32((LPBYTE) &Header.flags);
282 AdjustEndianess32((LPBYTE) &Header.attributes[0]);
283 AdjustEndianess32((LPBYTE) &Header.renderingIntent);
284
285 // Validate it
286
287 if (Header.magic != icMagicNumber) goto ErrorCleanup;
288
289 if (Icc ->Read(&TagCount, sizeof(icInt32Number), 1, Icc) != 1)
290 goto ErrorCleanup;
291
292 AdjustEndianess32((LPBYTE) &TagCount);
293
294 Icc -> DeviceClass = Header.deviceClass;
295 Icc -> ColorSpace = Header.colorSpace;
296 Icc -> PCS = Header.pcs;
297 Icc -> RenderingIntent = (icRenderingIntent) Header.renderingIntent;
298 Icc -> flags = Header.flags;
299 Icc -> attributes = Header.attributes[0];
300 Icc -> Illuminant.X = Convert15Fixed16(Header.illuminant.X);
301 Icc -> Illuminant.Y = Convert15Fixed16(Header.illuminant.Y);
302 Icc -> Illuminant.Z = Convert15Fixed16(Header.illuminant.Z);
303 Icc -> Version = Header.version;
304
305 // Get creation date/time
306
307 DecodeDateTimeNumber(&Header.date, &Icc ->Created);
308
309 // Fix illuminant, some profiles are broken in this field!
310
311 Icc ->Illuminant = *cmsD50_XYZ();
312
313 // The profile ID are 16 raw bytes
314
315 CopyMemory(Icc ->ProfileID, Header.reserved, 16);
316
317 // Get rid of possible wrong profiles
318
319 NormalizeXYZ(&Icc -> Illuminant);
320
321 // Read tag directory
322
323 if (TagCount > MAX_TABLE_TAG) {
324
325 cmsSignalError(LCMS_ERRC_ABORTED, "Too many tags (%d)", TagCount);
326 goto ErrorCleanup;
327 }
328
329 Icc -> TagCount = TagCount;
330 for (i=0; i < TagCount; i++) {
331
332 if (Icc ->Read(&Tag, sizeof(icTag), 1, Icc) != 1)
333 goto ErrorCleanup;
334
335 AdjustEndianess32((LPBYTE) &Tag.offset);
336 AdjustEndianess32((LPBYTE) &Tag.size);
337 AdjustEndianess32((LPBYTE) &Tag.sig); // Signature
338
339 // Perform some sanity check. Offset + size should fall inside file.
340
341 if (Tag.offset + Tag.size > Header.size) goto ErrorCleanup;
342
343 Icc -> TagNames[i] = Tag.sig;
344 Icc -> TagOffsets[i] = Tag.offset;
345 Icc -> TagSizes[i] = Tag.size;
346 }
347
348 return Icc;
349
350
351 ErrorCleanup:
352
353 Icc ->Close(Icc);
354
355 if (lIsFromMemory)
356 cmsSignalError(LCMS_ERRC_ABORTED, "Corrupted memory profile");
357 else
358 cmsSignalError(LCMS_ERRC_ABORTED, "Corrupted profile: '%s'", Icc->PhysicalFile);
359
360
361 _cmsFree(Icc);
362 return NULL;
363 }
364
365
366
367
368 static
369 unsigned int uipow(unsigned int a, unsigned int b) {
370 unsigned int rv = 1;
371 for (; b > 0; b--)
372 rv *= a;
373 return rv;
374 }
375
376
377
378 // Convert between notations.
379
380 #define TO16_TAB(x) (WORD) (((x) << 8) | (x))
381
382
383 // LUT8 can come only in Lab space. There is a fatal flaw in
384 // converting from Lut8 to Lut16. Due to particular encoding
385 // of Lab, different actions should be taken from input and
386 // output Lab8 LUTS. For input, is as easy as applying a << 8,
387 // since numbers comes in fixed point. However, for output LUT
388 // things goes a bit more complex.... LUT 16 is supposed to
389 // have a domain of 0..ff00, so we should remap the LUT in order
390 // to get things working. Affected signatures are B2Axx tags,
391 // preview and gamut.
392
393 // I do solve it by multiplying input matrix by:
394 //
395 // | 0xffff/0xff00 0 0 |
396 // | 0 0xffff/0xff00 0 |
397 // | 0 0 0xffff/0xff00 |
398 //
399 // The input values got then remapped to adequate domain
400
401 static
402 void FixLUT8(LPLUT Lut, icTagSignature sig, size_t nTabSize)
403 {
404 MAT3 Fixup, Original, Result;
405 LPWORD PtrW;
406 size_t i;
407
408 switch (sig) {
409
410
411 case icSigBToA0Tag:
412 case icSigBToA1Tag:
413 case icSigBToA2Tag:
414 case icSigGamutTag:
415 case icSigPreview0Tag:
416 case icSigPreview1Tag:
417 case icSigPreview2Tag:
418
419
420 VEC3init(&Fixup.v[0], (double) 0xFFFF/0xFF00, 0, 0);
421 VEC3init(&Fixup.v[1], 0, (double) 0xFFFF/0xFF00, 0);
422 VEC3init(&Fixup.v[2], 0, 0, (double) 0xFFFF/0xFF00);
423
424
425 MAT3fromFix(&Original, &Lut->Matrix);
426 MAT3per(&Result, &Original, &Fixup);
427 MAT3toFix(&Lut->Matrix, &Result);
428
429 Lut -> wFlags |= LUT_HASMATRIX;
430 break;
431
432 // For input, clear low part since this has to be
433 // Lab in fixed point
434
435 default:
436
437 PtrW = Lut -> T;
438 for (i = 0; i < nTabSize; i++) {
439
440 *PtrW++ &= 0xFF00;
441 }
442 }
443
444 }
445
446 // On Lab -> Lab abstract or Lab identities, fix both sides of LUT
447
448 static
449 void FixLUT8bothSides(LPLUT Lut, size_t nTabSize)
450 {
451 MAT3 Fixup, Original, Result;
452 LPWORD PtrW;
453 size_t i;
454
455 VEC3init(&Fixup.v[0], (double) 0xFFFF/0xFF00, 0, 0);
456 VEC3init(&Fixup.v[1], 0, (double) 0xFFFF/0xFF00, 0);
457 VEC3init(&Fixup.v[2], 0, 0, (double) 0xFFFF/0xFF00);
458
459 MAT3fromFix(&Original, &Lut->Matrix);
460 MAT3per(&Result, &Original, &Fixup);
461 MAT3toFix(&Lut->Matrix, &Result);
462
463 Lut -> wFlags |= LUT_HASMATRIX;
464
465 PtrW = Lut -> T;
466 for (i = 0; i < nTabSize; i++) {
467
468 *PtrW++ &= 0xFF00;
469 }
470
471 }
472
473
474 // The infamous LUT 8
475
476 static
477 LCMSBOOL ReadLUT8(LPLCMSICCPROFILE Icc, LPLUT NewLUT, icTagSignature sig)
478 {
479 icLut8 LUT8;
480 LPBYTE Temp;
481 size_t nTabSize;
482 unsigned int i, j;
483 unsigned int AllLinear;
484 LPWORD PtrW;
485
486 if (Icc ->Read(&LUT8, sizeof(icLut8) - SIZEOF_UINT8_ALIGNED, 1, Icc) != 1) return FALSE;
487
488 NewLUT -> wFlags = LUT_HASTL1|LUT_HASTL2|LUT_HAS3DGRID;
489 NewLUT -> cLutPoints = LUT8.clutPoints;
490 NewLUT -> InputChan = LUT8.inputChan;
491 NewLUT -> OutputChan = LUT8.outputChan;
492 NewLUT -> InputEntries = 256;
493 NewLUT -> OutputEntries = 256;
494
495 // Do some checking
496 if (NewLUT -> cLutPoints > 100) NewLUT ->cLutPoints = 100;
497 if (NewLUT -> InputChan > MAXCHANNELS) NewLUT -> InputChan = MAXCHANNELS;
498 if (NewLUT -> OutputChan > MAXCHANNELS) NewLUT -> OutputChan = MAXCHANNELS;
499
500 AdjustEndianess32((LPBYTE) &LUT8.e00);
501 AdjustEndianess32((LPBYTE) &LUT8.e01);
502 AdjustEndianess32((LPBYTE) &LUT8.e02);
503 AdjustEndianess32((LPBYTE) &LUT8.e10);
504 AdjustEndianess32((LPBYTE) &LUT8.e11);
505 AdjustEndianess32((LPBYTE) &LUT8.e12);
506 AdjustEndianess32((LPBYTE) &LUT8.e20);
507 AdjustEndianess32((LPBYTE) &LUT8.e21);
508 AdjustEndianess32((LPBYTE) &LUT8.e22);
509
510
511 // Matrix handling
512
513 NewLUT -> Matrix.v[0].n[0] = (Fixed32) LUT8.e00;
514 NewLUT -> Matrix.v[0].n[1] = (Fixed32) LUT8.e01;
515 NewLUT -> Matrix.v[0].n[2] = (Fixed32) LUT8.e02;
516 NewLUT -> Matrix.v[1].n[0] = (Fixed32) LUT8.e10;
517 NewLUT -> Matrix.v[1].n[1] = (Fixed32) LUT8.e11;
518 NewLUT -> Matrix.v[1].n[2] = (Fixed32) LUT8.e12;
519 NewLUT -> Matrix.v[2].n[0] = (Fixed32) LUT8.e20;
520 NewLUT -> Matrix.v[2].n[1] = (Fixed32) LUT8.e21;
521 NewLUT -> Matrix.v[2].n[2] = (Fixed32) LUT8.e22;
522
523
524 // Only operates if not identity...
525
526 if ((NewLUT -> InputChan == 3) && !MAT3isIdentity(&NewLUT -> Matrix, 0.0001)) {
527
528 NewLUT -> wFlags |= LUT_HASMATRIX;
529 }
530
531
532 // Copy input tables
533
534 Temp = (LPBYTE) _cmsMalloc(256);
535 if (Temp == NULL) return FALSE;
536
537 AllLinear = 0;
538 for (i=0; i < NewLUT -> InputChan; i++) {
539
540 PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * 256);
541 if (PtrW == NULL) {
542 _cmsFree(Temp);
543 return FALSE;
544 }
545
546 NewLUT -> L1[i] = PtrW;
547 if (Icc ->Read(Temp, 1, 256, Icc) != 256) {
548 _cmsFree(Temp);
549 return FALSE;
550 }
551
552 for (j=0; j < 256; j++)
553 PtrW[j] = TO16_TAB(Temp[j]);
554 AllLinear += cmsIsLinear(NewLUT -> L1[i], NewLUT -> InputEntries);
555 }
556
557 // Linear input, so ignore full step
558
559 if (AllLinear == NewLUT -> InputChan) {
560
561 NewLUT -> wFlags &= ~LUT_HASTL1;
562 }
563
564 _cmsFree(Temp);
565
566 // Copy 3D CLUT
567
568 nTabSize = (NewLUT -> OutputChan * uipow(NewLUT->cLutPoints,
569 NewLUT->InputChan));
570
571 if (nTabSize > 0) {
572
573 PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * nTabSize);
574 if (PtrW == NULL) return FALSE;
575
576 Temp = (LPBYTE) _cmsMalloc(nTabSize);
577 if (Temp == NULL) {
578 _cmsFree(PtrW);
579 return FALSE;
580 }
581
582 if (Icc ->Read(Temp, 1, nTabSize, Icc) != nTabSize) {
583 _cmsFree(Temp);
584 _cmsFree(PtrW);
585 return FALSE;
586 }
587
588 NewLUT -> T = PtrW;
589 NewLUT -> Tsize = (unsigned int) (nTabSize * sizeof(WORD));
590
591 for (i = 0; i < nTabSize; i++) {
592
593 *PtrW++ = TO16_TAB(Temp[i]);
594 }
595 _cmsFree(Temp);
596 }
597 else {
598 NewLUT ->T = NULL;
599 NewLUT ->Tsize = 0;
600 NewLUT ->wFlags &= ~LUT_HAS3DGRID;
601 }
602
603
604 // Copy output tables
605
606 Temp = (LPBYTE) _cmsMalloc(256);
607 if (Temp == NULL) {
608 return FALSE;
609 }
610
611 AllLinear = 0;
612 for (i=0; i < NewLUT -> OutputChan; i++) {
613
614 PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * 256);
615 if (PtrW == NULL) {
616 _cmsFree(Temp);
617 return FALSE;
618 }
619
620 NewLUT -> L2[i] = PtrW;
621 if (Icc ->Read(Temp, 1, 256, Icc) != 256) {
622 _cmsFree(Temp);
623 return FALSE;
624 }
625
626 for (j=0; j < 256; j++)
627 PtrW[j] = TO16_TAB(Temp[j]);
628 AllLinear += cmsIsLinear(NewLUT -> L2[i], 256);
629 }
630
631 // Linear input, so ignore full step
632
633 if (AllLinear == NewLUT -> OutputChan) {
634
635 NewLUT -> wFlags &= ~LUT_HASTL2;
636 }
637
638
639 _cmsFree(Temp);
640
641 cmsCalcL16Params(NewLUT -> InputEntries, &NewLUT -> In16params);
642 cmsCalcL16Params(NewLUT -> OutputEntries, &NewLUT -> Out16params);
643 cmsCalcCLUT16Params(NewLUT -> cLutPoints, NewLUT -> InputChan,
644 NewLUT -> OutputChan,
645 &NewLUT -> CLut16params);
646 // Fixup
647
648 if (Icc ->PCS == icSigLabData) {
649
650 // Abstract or Lab identity
651
652 if (Icc -> ColorSpace == icSigLabData)
653
654 FixLUT8bothSides(NewLUT, nTabSize);
655 else
656 FixLUT8(NewLUT, sig, nTabSize);
657
658
659 // Now some additional fixup. Lab encoding on 8 bit makes
660 // impossible to place gray axis on a exact node. However,
661 // some profiles does claim to do that. Poor lcms will try
662 // to detect such condition and fix up "on the fly".
663
664 {
665 LPWORD WhiteLab, ExpectedWhite;
666 WORD WhiteFixed[MAXCHANNELS], WhiteUnfixed[MAXCHANNELS];
667 int j, nChannels;
668 double Dist, DistFixed, DistUnfixed;
669
670 _cmsEndPointsBySpace(icSigLabData, &WhiteLab, NULL, NULL);
671
672 if (_cmsEndPointsBySpace(Icc -> ColorSpace,
673 &ExpectedWhite, NULL, &nChannels)) {
674
675 // 1.- Find white obtained by both combinations
676
677 NewLUT -> FixGrayAxes = FALSE;
678 cmsEvalLUT(NewLUT, WhiteLab, WhiteUnfixed);
679
680 NewLUT -> FixGrayAxes = TRUE;
681 cmsEvalLUT(NewLUT, WhiteLab, WhiteFixed);
682
683 // 2.- Which method gives closer white?
684
685 DistFixed = DistUnfixed = 0;
686 for (j=0; j < nChannels; j++) {
687
688 Dist = ExpectedWhite[j] - WhiteFixed[j];
689 DistFixed += Dist*Dist;
690 Dist = ExpectedWhite[j] - WhiteUnfixed[j];
691 DistUnfixed += Dist*Dist;
692 }
693
694 // 3.- Decide method
695
696 if (sqrt(DistFixed) < sqrt(DistUnfixed))
697 NewLUT -> FixGrayAxes = TRUE;
698 else
699 NewLUT -> FixGrayAxes = FALSE;
700 }
701
702 }
703
704 }
705
706 return TRUE;
707 }
708
709
710
711
712 // Case LUT 16
713
714 static
715 LCMSBOOL ReadLUT16(LPLCMSICCPROFILE Icc, LPLUT NewLUT)
716 {
717 icLut16 LUT16;
718 size_t nTabSize;
719 unsigned int i;
720 unsigned int AllLinear;
721 LPWORD PtrW;
722
723
724 if (Icc ->Read(&LUT16, sizeof(icLut16)- SIZEOF_UINT16_ALIGNED, 1, Icc) != 1)
725 return FALSE;
726
727 NewLUT -> wFlags = LUT_HASTL1 | LUT_HASTL2 | LUT_HAS3DGRID;
728 NewLUT -> cLutPoints = LUT16.clutPoints;
729 NewLUT -> InputChan = LUT16.inputChan;
730 NewLUT -> OutputChan = LUT16.outputChan;
731
732 AdjustEndianess16((LPBYTE) &LUT16.inputEnt);
733 AdjustEndianess16((LPBYTE) &LUT16.outputEnt);
734
735 NewLUT -> InputEntries = LUT16.inputEnt;
736 NewLUT -> OutputEntries = LUT16.outputEnt;
737
738
739 // Matrix handling
740
741 AdjustEndianess32((LPBYTE) &LUT16.e00);
742 AdjustEndianess32((LPBYTE) &LUT16.e01);
743 AdjustEndianess32((LPBYTE) &LUT16.e02);
744 AdjustEndianess32((LPBYTE) &LUT16.e10);
745 AdjustEndianess32((LPBYTE) &LUT16.e11);
746 AdjustEndianess32((LPBYTE) &LUT16.e12);
747 AdjustEndianess32((LPBYTE) &LUT16.e20);
748 AdjustEndianess32((LPBYTE) &LUT16.e21);
749 AdjustEndianess32((LPBYTE) &LUT16.e22);
750
751 NewLUT -> Matrix.v[0].n[0] = (Fixed32) LUT16.e00;
752 NewLUT -> Matrix.v[0].n[1] = (Fixed32) LUT16.e01;
753 NewLUT -> Matrix.v[0].n[2] = (Fixed32) LUT16.e02;
754 NewLUT -> Matrix.v[1].n[0] = (Fixed32) LUT16.e10;
755 NewLUT -> Matrix.v[1].n[1] = (Fixed32) LUT16.e11;
756 NewLUT -> Matrix.v[1].n[2] = (Fixed32) LUT16.e12;
757 NewLUT -> Matrix.v[2].n[0] = (Fixed32) LUT16.e20;
758 NewLUT -> Matrix.v[2].n[1] = (Fixed32) LUT16.e21;
759 NewLUT -> Matrix.v[2].n[2] = (Fixed32) LUT16.e22;
760
761 // Only operates if not identity...
762
763 if ((NewLUT -> InputChan == 3) && !MAT3isIdentity(&NewLUT -> Matrix, 0.0001)) {
764
765 NewLUT -> wFlags |= LUT_HASMATRIX;
766 }
767
768
769 // Copy input tables
770
771 AllLinear = 0;
772 for (i=0; i < NewLUT -> InputChan; i++) {
773
774 PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * NewLUT -> InputEntries);
775 if (PtrW == NULL) return FALSE;
776
777 NewLUT -> L1[i] = PtrW;
778 if (Icc ->Read(PtrW, sizeof(WORD), NewLUT -> InputEntries, Icc) != NewLUT -> InputEntries) {
779 return FALSE;
780 }
781
782 AdjustEndianessArray16(PtrW, NewLUT -> InputEntries);
783 AllLinear += cmsIsLinear(NewLUT -> L1[i], NewLUT -> InputEntries);
784 }
785
786 // Linear input, so ignore full step
787
788 if (AllLinear == NewLUT -> InputChan) {
789
790 NewLUT -> wFlags &= ~LUT_HASTL1;
791 }
792
793
794 // Copy 3D CLUT
795
796 nTabSize = (NewLUT -> OutputChan * uipow(NewLUT->cLutPoints,
797 NewLUT->InputChan));
798 if (nTabSize > 0) {
799
800 PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * nTabSize);
801 if (PtrW == NULL) {
802 _cmsFree(PtrW);
803 return FALSE;
804 }
805
806 NewLUT -> T = PtrW;
807 NewLUT -> Tsize = (unsigned int) (nTabSize * sizeof(WORD));
808
809 if (Icc -> Read(PtrW, sizeof(WORD), nTabSize, Icc) != nTabSize) {
810 return FALSE;
811 }
812
813 AdjustEndianessArray16(NewLUT -> T, nTabSize);
814 }
815 else {
816 NewLUT ->T = NULL;
817 NewLUT ->Tsize = 0;
818 NewLUT -> wFlags &= ~LUT_HAS3DGRID;
819 }
820
821 // Copy output tables
822
823 AllLinear = 0;
824 for (i=0; i < NewLUT -> OutputChan; i++) {
825
826 PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * NewLUT -> OutputEntries);
827 if (PtrW == NULL) {
828 return FALSE;
829 }
830
831 NewLUT -> L2[i] = PtrW;
832 if (Icc ->Read(PtrW, sizeof(WORD), NewLUT -> OutputEntries, Icc) != NewLUT -> OutputEntries) {
833 return FALSE;
834 }
835
836 AdjustEndianessArray16(PtrW, NewLUT -> OutputEntries);
837 AllLinear += cmsIsLinear(NewLUT -> L2[i], NewLUT -> OutputEntries);
838 }
839
840 // Linear output, ignore step
841
842 if (AllLinear == NewLUT -> OutputChan)
843 {
844 NewLUT -> wFlags &= ~LUT_HASTL2;
845 }
846
847
848 cmsCalcL16Params(NewLUT -> InputEntries, &NewLUT -> In16params);
849 cmsCalcL16Params(NewLUT -> OutputEntries, &NewLUT -> Out16params);
850 cmsCalcCLUT16Params(NewLUT -> cLutPoints, NewLUT -> InputChan,
851 NewLUT -> OutputChan,
852 &NewLUT -> CLut16params);
853
854 return TRUE;
855 }
856
857
858 // This is a shared routine for reading curves. It can handle v2 curves
859 // as linear, single gamma and table-based as well as v4 parametric curves.
860
861 static
862 LPGAMMATABLE ReadCurve(LPLCMSICCPROFILE Icc)
863 {
864 icUInt32Number Count;
865 LPGAMMATABLE NewGamma;
866 icTagTypeSignature BaseType;
867 int n;
868
869
870 BaseType = ReadBase(Icc);
871 switch (BaseType) {
872
873
874 case ((icTagTypeSignature) 0x9478ee00): // Monaco 2 profiler is BROKEN!
875 case icSigCurveType:
876
877 if (Icc ->Read(&Count, sizeof(icUInt32Number), 1, Icc) != 1) return NULL;
878 AdjustEndianess32((LPBYTE) &Count);
879
880 switch (Count) {
881
882 case 0: // Linear.
883
884 NewGamma = cmsAllocGamma(2);
885 if (!NewGamma) return NULL;
886 NewGamma -> GammaTable[0] = 0;
887 NewGamma -> GammaTable[1] = 0xFFFF;
888 return NewGamma;
889
890 case 1: // Specified as the exponent of gamma function
891 {
892 WORD SingleGammaFixed;
893
894 if (Icc ->Read(&SingleGammaFixed, sizeof(WORD), 1, Icc) != 1) return NULL;
895 AdjustEndianess16((LPBYTE) &SingleGammaFixed);
896 return cmsBuildGamma(4096, Convert8Fixed8(SingleGammaFixed));
897 }
898
899 default: { // Curve
900
901 NewGamma = cmsAllocGamma(Count);
902 if (!NewGamma) return NULL;
903
904 if (Icc ->Read(NewGamma -> GammaTable, sizeof(WORD), Count, Icc) != Count)
905 return NULL;
906 AdjustEndianessArray16(NewGamma -> GammaTable, Count);
907 return NewGamma;
908 }
909 }
910 break;
911
912
913 // Parametric curves
914 case icSigParametricCurveType: {
915
916 int ParamsByType[] = { 1, 3, 4, 5, 7 };
917 double Params[10];
918 icS15Fixed16Number Num;
919 icUInt32Number Reserved;
920 icUInt16Number Type;
921 int i;
922
923 if (Icc -> Read(&Type, sizeof(icUInt16Number), 1, Icc) != 1) return NULL;
924 if (Icc -> Read(&Reserved, sizeof(icUInt16Number), 1, Icc) != 1) return NULL;
925
926 AdjustEndianess16((LPBYTE) &Type);
927 if (Type > 4) {
928
929 cmsSignalError(LCMS_ERRC_ABORTED, "Unknown parametric curve type '%d' found.", Type);
930 return NULL;
931 }
932
933 ZeroMemory(Params, 10* sizeof(double));
934 n = ParamsByType[Type];
935
936 for (i=0; i < n; i++) {
937 Num = 0;
938 if (Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc) != 1) return NULL;
939 Params[i] = Convert15Fixed16(Num);
940 }
941
942
943 NewGamma = cmsBuildParametricGamma(4096, Type+1, Params);
944 return NewGamma;
945 }
946
947
948 default:
949 cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature '%lx' found.", BaseType);
950 return NULL;
951 }
952
953 }
954
955
956 // Similar to anterior, but curve is reversed
957
958 static
959 LPGAMMATABLE ReadCurveReversed(LPLCMSICCPROFILE Icc)
960 {
961
962 icTagTypeSignature BaseType;
963 LPGAMMATABLE NewGamma, ReturnGamma;
964 icUInt32Number Count;
965 int n;
966
967
968 BaseType = ReadBase(Icc);
969
970 switch (BaseType) {
971
972
973 case 0x9478ee00L: // Monaco 2 profiler is BROKEN!
974 case icSigCurveType:
975
976 if (Icc -> Read(&Count, sizeof(icUInt32Number), 1, Icc) != 1) return NULL;
977 AdjustEndianess32((LPBYTE) &Count);
978
979
980 switch (Count) {
981
982 case 0: // Linear, reverse is same.
983
984 NewGamma = cmsAllocGamma(2);
985 if (!NewGamma) return NULL;
986
987 NewGamma -> GammaTable[0] = 0;
988 NewGamma -> GammaTable[1] = 0xFFFF;
989 return NewGamma;
990
991 case 1: {
992 WORD SingleGammaFixed;
993
994 if (Icc -> Read(&SingleGammaFixed, sizeof(WORD), 1, Icc) != 1) return NULL;
995 AdjustEndianess16((LPBYTE) &SingleGammaFixed);
996 return cmsBuildGamma(4096, 1./Convert8Fixed8(SingleGammaFixed));
997 }
998
999 default: { // Curve. Do our best to trying to reverse the curve
1000
1001 NewGamma = cmsAllocGamma(Count);
1002 if (!NewGamma) return NULL;
1003
1004 if (Icc -> Read(NewGamma -> GammaTable, sizeof(WORD), Count, Icc) != Count)
1005 return NULL;
1006
1007 AdjustEndianessArray16(NewGamma -> GammaTable, Count);
1008
1009 if (Count < 256)
1010 Count = 256; // Reverse of simple curve has not necesarely to be simple
1011
1012 ReturnGamma = cmsReverseGamma(Count, NewGamma);
1013 cmsFreeGamma(NewGamma);
1014
1015 return ReturnGamma;
1016 }
1017 }
1018 break;
1019
1020
1021 // Parametric curves
1022 case icSigParametricCurveType: {
1023
1024 int ParamsByType[] = { 1, 3, 4, 5, 7 };
1025 double Params[10];
1026 icS15Fixed16Number Num;
1027 icUInt32Number Reserved;
1028 icUInt16Number Type;
1029 int i;
1030
1031
1032 if (Icc -> Read(&Type, sizeof(icUInt16Number), 1, Icc) != 1) return NULL;
1033 if (Icc -> Read(&Reserved, sizeof(icUInt16Number), 1, Icc) != 1) return NULL;
1034
1035 AdjustEndianess16((LPBYTE) &Type);
1036 if (Type > 4) {
1037
1038 cmsSignalError(LCMS_ERRC_ABORTED, "Unknown parametric curve type '%d' found.", Type);
1039 return NULL;
1040 }
1041
1042 ZeroMemory(Params, 10* sizeof(double));
1043 n = ParamsByType[Type];
1044
1045 for (i=0; i < n; i++) {
1046 if (Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc) != 1) return NULL;
1047 Params[i] = Convert15Fixed16(Num);
1048 }
1049
1050
1051 // Negative type as a mark of reversed curve
1052 NewGamma = cmsBuildParametricGamma(4096, -(Type+1), Params);
1053 return NewGamma;
1054 }
1055
1056
1057 default:
1058 cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature '%lx' found.", BaseType);
1059 return NULL;
1060 }
1061
1062 }
1063
1064
1065 // V4 stuff. Read matrix for LutAtoB and LutBtoA
1066
1067 static
1068 LCMSBOOL ReadMatrixOffset(LPLCMSICCPROFILE Icc, size_t Offset, LPLUT NewLUT, DWORD dwFlags)
1069 {
1070
1071 icS15Fixed16Number All[12];
1072 int i;
1073 MAT3 m;
1074 VEC3 o;
1075
1076 if (Icc -> Seek(Icc, Offset)) return FALSE;
1077
1078 if (Icc ->Read(All, sizeof(icS15Fixed16Number), 12, Icc) != 12)
1079 return FALSE;
1080
1081 for (i=0; i < 12; i++)
1082 AdjustEndianess32((LPBYTE) &All[i]);
1083
1084
1085 m.v[0].n[0] = FIXED_TO_DOUBLE((Fixed32) All[0]);
1086 m.v[0].n[1] = FIXED_TO_DOUBLE((Fixed32) All[1]);
1087 m.v[0].n[2] = FIXED_TO_DOUBLE((Fixed32) All[2]);
1088 m.v[1].n[0] = FIXED_TO_DOUBLE((Fixed32) All[3]);
1089 m.v[1].n[1] = FIXED_TO_DOUBLE((Fixed32) All[4]);
1090 m.v[1].n[2] = FIXED_TO_DOUBLE((Fixed32) All[5]);
1091 m.v[2].n[0] = FIXED_TO_DOUBLE((Fixed32) All[6]);
1092 m.v[2].n[1] = FIXED_TO_DOUBLE((Fixed32) All[7]);
1093 m.v[2].n[2] = FIXED_TO_DOUBLE((Fixed32) All[8]);
1094
1095 o.n[0] = FIXED_TO_DOUBLE((Fixed32) All[9]);
1096 o.n[1] = FIXED_TO_DOUBLE((Fixed32) All[10]);
1097 o.n[2] = FIXED_TO_DOUBLE((Fixed32) All[11]);
1098
1099 cmsSetMatrixLUT4(NewLUT, &m, &o, dwFlags);
1100
1101 return TRUE;
1102 }
1103
1104
1105 // V4 stuff. Read CLUT part for LutAtoB and LutBtoA
1106
1107 static
1108 LCMSBOOL ReadCLUT(LPLCMSICCPROFILE Icc, size_t Offset, LPLUT NewLUT)
1109 {
1110
1111 icCLutStruct CLUT;
1112
1113 if (Icc -> Seek(Icc, Offset)) return FALSE;
1114 if (Icc ->Read(&CLUT, sizeof(icCLutStruct), 1, Icc) != 1) return FALSE;
1115
1116
1117 cmsAlloc3DGrid(NewLUT, CLUT.gridPoints[0], NewLUT ->InputChan,
1118 NewLUT ->OutputChan);
1119
1120 // Precission can be 1 or 2 bytes
1121
1122 if (CLUT.prec == 1) {
1123
1124 BYTE v;
1125 unsigned int i;
1126
1127 for (i=0; i < NewLUT->Tsize / sizeof(WORD); i++) {
1128 if (Icc ->Read(&v, sizeof(BYTE), 1, Icc) != 1) return FALSE;
1129 NewLUT->T[i] = TO16_TAB(v);
1130 }
1131
1132 }
1133 else
1134 if (CLUT.prec == 2) {
1135
1136 size_t n = NewLUT->Tsize / sizeof(WORD);
1137
1138 if (Icc ->Read(NewLUT ->T, sizeof(WORD), n, Icc) != n) return FALSE;
1139 AdjustEndianessArray16(NewLUT ->T, NewLUT->Tsize / sizeof(WORD));
1140 }
1141 else {
1142 cmsSignalError(LCMS_ERRC_ABORTED, "Unknow precission of '%d'", CLUT.prec);
1143 return FALSE;
1144 }
1145
1146 return TRUE;
1147 }
1148
1149
1150 static
1151 void SkipAlignment(LPLCMSICCPROFILE Icc)
1152 {
1153 BYTE Buffer[4];
1154 size_t At = Icc ->Tell(Icc);
1155 int BytesToNextAlignedPos = (int) (At % 4);
1156
1157 Icc ->Read(Buffer, 1, BytesToNextAlignedPos, Icc);
1158 }
1159
1160 // Read a set of curves from specific offset
1161 static
1162 LCMSBOOL ReadSetOfCurves(LPLCMSICCPROFILE Icc, size_t Offset, LPLUT NewLUT, int nLocation)
1163 {
1164 LPGAMMATABLE Curves[MAXCHANNELS];
1165 unsigned int i, nCurves;
1166
1167 if (Icc -> Seek(Icc, Offset)) return FALSE;
1168
1169 if (nLocation == 1 || nLocation == 3)
1170
1171 nCurves = NewLUT ->InputChan;
1172 else
1173 nCurves = NewLUT ->OutputChan;
1174
1175 for (i=0; i < nCurves; i++) {
1176
1177 Curves[i] = ReadCurve(Icc);
1178 if (Curves[i] == NULL) return FALSE;
1179 SkipAlignment(Icc);
1180
1181 }
1182
1183 NewLUT = cmsAllocLinearTable(NewLUT, Curves, nLocation);
1184
1185 for (i=0; i < nCurves; i++)
1186 cmsFreeGamma(Curves[i]);
1187
1188 return TRUE;
1189
1190 }
1191
1192 // V4 stuff. LutAtoB type
1193 //
1194 // [L1] -> [CLUT] -> [L4] -> [Mat4] -> [Ofs4] -> [L2]
1195 //
1196 // Mat, Mat3, Ofs3, L3 are missing
1197 // L1 = A curves
1198 // L4 = M curves
1199 // L2 = B curves
1200
1201 static
1202 LCMSBOOL ReadLUT_A2B(LPLCMSICCPROFILE Icc, LPLUT NewLUT, size_t BaseOffset, icTagSignature sig)
1203 {
1204 icLutAtoB LUT16;
1205
1206 if (Icc ->Read(&LUT16, sizeof(icLutAtoB), 1, Icc) != 1) return FALSE;
1207
1208 NewLUT -> InputChan = LUT16.inputChan;
1209 NewLUT -> OutputChan = LUT16.outputChan;
1210
1211 AdjustEndianess32((LPBYTE) &LUT16.offsetB);
1212 AdjustEndianess32((LPBYTE) &LUT16.offsetMat);
1213 AdjustEndianess32((LPBYTE) &LUT16.offsetM);
1214 AdjustEndianess32((LPBYTE) &LUT16.offsetC);
1215 AdjustEndianess32((LPBYTE) &LUT16.offsetA);
1216
1217 if (LUT16.offsetB != 0)
1218 ReadSetOfCurves(Icc, BaseOffset + LUT16.offsetB, NewLUT, 2);
1219
1220 if (LUT16.offsetMat != 0)
1221 ReadMatrixOffset(Icc, BaseOffset + LUT16.offsetMat, NewLUT, LUT_HASMATRIX4);
1222
1223
1224 if (LUT16.offsetM != 0)
1225 ReadSetOfCurves(Icc, BaseOffset + LUT16.offsetM, NewLUT, 4);
1226
1227 if (LUT16.offsetC != 0)
1228 ReadCLUT(Icc, BaseOffset + LUT16.offsetC, NewLUT);
1229
1230 if (LUT16.offsetA!= 0)
1231 ReadSetOfCurves(Icc, BaseOffset + LUT16.offsetA, NewLUT, 1);
1232
1233 // Convert to v2 PCS
1234
1235 if (Icc ->PCS == icSigLabData) {
1236
1237 switch (sig) {
1238
1239 case icSigAToB0Tag:
1240 case icSigAToB1Tag:
1241 case icSigAToB2Tag:
1242 case icSigGamutTag:
1243 case icSigPreview0Tag:
1244 case icSigPreview1Tag:
1245 case icSigPreview2Tag:
1246
1247 NewLUT ->wFlags |= LUT_V4_INPUT_EMULATE_V2;
1248 break;
1249
1250 default:;
1251 }
1252 }
1253
1254
1255 return TRUE;
1256 }
1257
1258 // V4 stuff. LutBtoA type
1259
1260 static
1261 LCMSBOOL ReadLUT_B2A(LPLCMSICCPROFILE Icc, LPLUT NewLUT, size_t BaseOffset, icTagSignature sig)
1262 {
1263 icLutBtoA LUT16;
1264
1265 if (Icc ->Read(&LUT16, sizeof(icLutBtoA), 1, Icc) != 1) return FALSE;
1266
1267 NewLUT -> InputChan = LUT16.inputChan;
1268 NewLUT -> OutputChan = LUT16.outputChan;
1269
1270 AdjustEndianess32((LPBYTE) &LUT16.offsetB);
1271 AdjustEndianess32((LPBYTE) &LUT16.offsetMat);
1272 AdjustEndianess32((LPBYTE) &LUT16.offsetM);
1273 AdjustEndianess32((LPBYTE) &LUT16.offsetC);
1274 AdjustEndianess32((LPBYTE) &LUT16.offsetA);
1275
1276
1277 if (LUT16.offsetB != 0)
1278 ReadSetOfCurves(Icc, BaseOffset + LUT16.offsetB, NewLUT, 1);
1279
1280 if (LUT16.offsetMat != 0)
1281 ReadMatrixOffset(Icc, BaseOffset + LUT16.offsetMat, NewLUT, LUT_HASMATRIX3);
1282
1283 if (LUT16.offsetM != 0)
1284 ReadSetOfCurves(Icc, BaseOffset + LUT16.offsetM, NewLUT, 3);
1285
1286 if (LUT16.offsetC != 0)
1287 ReadCLUT(Icc, BaseOffset + LUT16.offsetC, NewLUT);
1288
1289 if (LUT16.offsetA!= 0)
1290 ReadSetOfCurves(Icc, BaseOffset + LUT16.offsetA, NewLUT, 2);
1291
1292
1293 // Convert to v2 PCS
1294
1295 if (Icc ->PCS == icSigLabData) {
1296
1297 switch (sig) {
1298
1299 case icSigBToA0Tag:
1300 case icSigBToA1Tag:
1301 case icSigBToA2Tag:
1302 case icSigGamutTag:
1303 case icSigPreview0Tag:
1304 case icSigPreview1Tag:
1305 case icSigPreview2Tag:
1306
1307 NewLUT ->wFlags |= LUT_V4_OUTPUT_EMULATE_V2;
1308 break;
1309
1310 default:;
1311 }
1312 }
1313
1314 return TRUE;
1315 }
1316
1317 // CLUT main reader
1318
1319 LPLUT LCMSEXPORT cmsReadICCLut(cmsHPROFILE hProfile, icTagSignature sig)
1320 {
1321
1322 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1323 icTagTypeSignature BaseType;
1324 int n;
1325 size_t offset;
1326 LPLUT NewLUT;
1327
1328 n = _cmsSearchTag(Icc, sig, TRUE);
1329 if (n < 0)
1330 return NULL;
1331
1332
1333 // If is in memory, the LUT is already there, so throw a copy
1334 if (Icc -> TagPtrs[n]) {
1335
1336 return cmsDupLUT((LPLUT) Icc ->TagPtrs[n]);
1337 }
1338
1339 offset = Icc -> TagOffsets[n];
1340
1341 if (Icc -> Seek(Icc, offset))
1342 return NULL;
1343
1344 BaseType = ReadBase(Icc);
1345
1346
1347 NewLUT = cmsAllocLUT();
1348 if (!NewLUT) {
1349
1350 cmsSignalError(LCMS_ERRC_ABORTED, "cmsAllocLUT() failed");
1351 return NULL;
1352 }
1353
1354
1355 switch (BaseType) {
1356
1357 case icSigLut8Type: if (!ReadLUT8(Icc, NewLUT, sig)) {
1358 cmsFreeLUT(NewLUT);
1359 return NULL;
1360 }
1361 break;
1362
1363 case icSigLut16Type: if (!ReadLUT16(Icc, NewLUT)) {
1364 cmsFreeLUT(NewLUT);
1365 return NULL;
1366 }
1367 break;
1368
1369 case icSiglutAtoBType: if (!ReadLUT_A2B(Icc, NewLUT, offset, sig)) {
1370 cmsFreeLUT(NewLUT);
1371 return NULL;
1372 }
1373 break;
1374
1375 case icSiglutBtoAType: if (!ReadLUT_B2A(Icc, NewLUT, offset, sig)) {
1376 cmsFreeLUT(NewLUT);
1377 return NULL;
1378 }
1379 break;
1380
1381 default: cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature %lx found.", BaseType);
1382 cmsFreeLUT(NewLUT);
1383 return NULL;
1384 }
1385
1386
1387 return NewLUT;
1388 }
1389
1390
1391 // Sets the language & country preferences. Used only in ICC 4.0 profiles
1392
1393 void LCMSEXPORT cmsSetLanguage(const char LanguageCode[4], const char CountryCode[4])
1394 {
1395
1396 int LanguageCodeInt = *(int *) LanguageCode;
1397 int CountryCodeInt = *(int *) CountryCode;
1398
1399 AdjustEndianess32((LPBYTE) &LanguageCodeInt);
1400 AdjustEndianess32((LPBYTE) &CountryCodeInt);
1401
1402 GlobalLanguageCode = LanguageCodeInt;
1403 GlobalCountryCode = CountryCodeInt;
1404 }
1405
1406
1407
1408 // Some tags (e.g, 'pseq') can have text tags embedded. This function
1409 // handles such special case. Returns -1 on error, or the number of bytes left on success.
1410
1411 static
1412 int ReadEmbeddedTextTag(LPLCMSICCPROFILE Icc, size_t size, char* Name, size_t size_max)
1413 {
1414 icTagTypeSignature BaseType;
1415
1416
1417 BaseType = ReadBase(Icc);
1418 size -= sizeof(icTagBase);
1419
1420 switch (BaseType) {
1421
1422 case icSigTextDescriptionType: {
1423
1424 icUInt32Number AsciiCount;
1425 icUInt32Number i, UnicodeCode, UnicodeCount;
1426 icUInt16Number ScriptCodeCode, Dummy;
1427 icUInt8Number ScriptCodeCount;
1428
1429 if (Icc ->Read(&AsciiCount, sizeof(icUInt32Number), 1, Icc) != 1) return -1;
1430
1431 if (size < sizeof(icUInt32Number)) return (int) size;
1432 size -= sizeof(icUInt32Number);
1433
1434 AdjustEndianess32((LPBYTE) &AsciiCount);
1435 Icc ->Read(Name, 1,
1436 (AsciiCount >= size_max) ? (size_max-1) : AsciiCount, Icc);
1437
1438 if (size < AsciiCount) return (int) size;
1439 size -= AsciiCount;
1440
1441 // Skip Unicode code
1442
1443 if (Icc ->Read(&UnicodeCode, sizeof(icUInt32Number), 1, Icc) != 1) return -1;
1444 if (size < sizeof(icUInt32Number)) return (int) size;
1445 size -= sizeof(icUInt32Number);
1446
1447 if (Icc ->Read(&UnicodeCount, sizeof(icUInt32Number), 1, Icc) != 1) return -1;
1448 if (size < sizeof(icUInt32Number)) return (int) size;
1449 size -= sizeof(icUInt32Number);
1450
1451 AdjustEndianess32((LPBYTE) &UnicodeCount);
1452
1453 if (UnicodeCount > size) return (int) size;
1454
1455 for (i=0; i < UnicodeCount; i++) {
1456 size_t nread = Icc ->Read(&Dummy, sizeof(icUInt16Number), 1, Icc);
1457 if (nread != 1) return (int) size;
1458 size -= sizeof(icUInt16Number);
1459 }
1460
1461 // Skip ScriptCode code
1462
1463 if (Icc ->Read(&ScriptCodeCode, sizeof(icUInt16Number), 1, Icc) != 1) return -1;
1464 size -= sizeof(icUInt16Number);
1465 if (Icc ->Read(&ScriptCodeCount, sizeof(icUInt8Number), 1, Icc) != 1) return -1;
1466 size -= sizeof(icUInt8Number);
1467
1468 // Should remain 67 bytes as filler
1469
1470 if (size < 67) return (int) size;
1471
1472 for (i=0; i < 67; i++) {
1473 size_t nread = Icc ->Read(&Dummy, sizeof(icUInt8Number), 1, Icc);
1474 if (nread != 1) return (int) size;
1475 size --;
1476 }
1477 }
1478 break;
1479
1480
1481 case icSigCopyrightTag: // Broken profiles from agfa does store copyright info in such type
1482 case icSigTextType:
1483 {
1484 char Dummy;
1485 size_t i, Missing = 0;
1486
1487 if (size >= size_max) {
1488
1489 Missing = size - size_max + 1;
1490 size = size_max - 1;
1491 }
1492
1493 if (Icc -> Read(Name, 1, size, Icc) != size) return -1;
1494
1495 for (i=0; i < Missing; i++)
1496 Icc -> Read(&Dummy, 1, 1, Icc);
1497 }
1498 break;
1499
1500 // MultiLocalizedUnicodeType, V4 only
1501
1502 case icSigMultiLocalizedUnicodeType: {
1503
1504 icUInt32Number Count, RecLen;
1505 icUInt16Number Language, Country;
1506 icUInt32Number ThisLen, ThisOffset;
1507 size_t Offset = 0;
1508 size_t Len = 0;
1509 size_t i;
1510 wchar_t* wchar = L"";
1511
1512
1513 if (Icc ->Read(&Count, sizeof(icUInt32Number), 1, Icc) != 1) return -1;
1514 AdjustEndianess32((LPBYTE) &Count);
1515 if (Icc ->Read(&RecLen, sizeof(icUInt32Number), 1, Icc) != 1) return -1;
1516 AdjustEndianess32((LPBYTE) &RecLen);
1517
1518 if (RecLen != 12) {
1519
1520 cmsSignalError(LCMS_ERRC_ABORTED, "multiLocalizedUnicodeType of len != 12 is not supported.");
1521 return -1;
1522 }
1523
1524 for (i=0; i < Count; i++) {
1525
1526 if (Icc ->Read(&Language, sizeof(icUInt16Number), 1, Icc) != 1) return -1;
1527 AdjustEndianess16((LPBYTE) &Language);
1528 if (Icc ->Read(&Country, sizeof(icUInt16Number), 1, Icc) != 1) return -1;
1529 AdjustEndianess16((LPBYTE) &Country);
1530
1531 if (Icc ->Read(&ThisLen, sizeof(icUInt32Number), 1, Icc) != 1) return -1;
1532 AdjustEndianess32((LPBYTE) &ThisLen);
1533
1534 if (Icc ->Read(&ThisOffset, sizeof(icUInt32Number), 1, Icc) != 1) return -1;
1535 AdjustEndianess32((LPBYTE) &ThisOffset);
1536
1537 if (Language == GlobalLanguageCode || Offset == 0) {
1538
1539 Len = ThisLen; Offset = ThisOffset;
1540 if (Country == GlobalCountryCode)
1541 break; // Found
1542 }
1543
1544 }
1545
1546
1547 if (Offset == 0) {
1548
1549 strcpy(Name, "(no info)");
1550 break;
1551 }
1552
1553 // Compute true offset
1554 Offset -= 12 * Count + 8 + sizeof(icTagBase);
1555
1556 // Skip unused bytes
1557 for (i=0; i < Offset; i++) {
1558
1559 char Discard;
1560 Icc ->Read(&Discard, 1, 1, Icc);
1561 }
1562
1563
1564 // Bound len
1565 if (Len < 0) Len = 0;
1566 if (Len > 20*1024) Len = 20 * 1024;
1567
1568 wchar = (wchar_t*) _cmsMalloc(Len+2);
1569 if (!wchar) return -1;
1570
1571 if (Icc ->Read(wchar, 1, Len, Icc) != Len) return -1;
1572 AdjustEndianessArray16((LPWORD) wchar, Len / 2);
1573
1574 wchar[Len / 2] = L'\0';
1575 i = wcstombs(Name, wchar, size_max );
1576 if (i == ((size_t) -1)) {
1577
1578 Name[0] = 0; // Error
1579 }
1580
1581 _cmsFree((void*) wchar);
1582 }
1583 break;
1584
1585 default:
1586 cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature %lx found.", BaseType);
1587 return -1;
1588 }
1589
1590 return (int) size;
1591 }
1592
1593
1594 // Take an ASCII item. Takes at most LCMS_DESC_MAX
1595
1596
1597 int LCMSEXPORT cmsReadICCTextEx(cmsHPROFILE hProfile, icTagSignature sig, char *Name, size_t size_max)
1598 {
1599 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1600 size_t offset, size;
1601 int n;
1602
1603 n = _cmsSearchTag(Icc, sig, TRUE);
1604 if (n < 0)
1605 return -1;
1606
1607 if (Icc -> TagPtrs[n]) {
1608
1609 CopyMemory(Name, Icc -> TagPtrs[n], Icc -> TagSizes[n]);
1610 return (int) Icc -> TagSizes[n];
1611 }
1612
1613 offset = Icc -> TagOffsets[n];
1614 size = Icc -> TagSizes[n];
1615
1616 if (Icc -> Seek(Icc, offset))
1617 return -1;
1618
1619 return ReadEmbeddedTextTag(Icc, size, Name, size_max);
1620 }
1621
1622 // Keep compatibility with older versions
1623
1624 int LCMSEXPORT cmsReadICCText(cmsHPROFILE hProfile, icTagSignature sig, char *Text)
1625 {
1626 return cmsReadICCTextEx(hProfile, sig, Text, LCMS_DESC_MAX);
1627 }
1628
1629
1630 // Take an XYZ item
1631
1632 static
1633 int ReadICCXYZ(cmsHPROFILE hProfile, icTagSignature sig, LPcmsCIEXYZ Value, LCMSBOOL lIsFatal)
1634 {
1635 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1636 icTagTypeSignature BaseType;
1637 size_t offset;
1638 int n;
1639 icXYZNumber XYZ;
1640
1641 n = _cmsSearchTag(Icc, sig, FALSE);
1642 if (n < 0)
1643 return -1;
1644
1645 if (Icc -> TagPtrs[n]) {
1646
1647 CopyMemory(Value, Icc -> TagPtrs[n], Icc -> TagSizes[n]);
1648 return (int) Icc -> TagSizes[n];
1649 }
1650
1651 offset = Icc -> TagOffsets[n];
1652
1653 if (Icc -> Seek(Icc, offset))
1654 return -1;
1655
1656
1657 BaseType = ReadBase(Icc);
1658
1659 switch (BaseType) {
1660
1661
1662 case 0x7c3b10cL: // Some apple broken embedded profiles does not have correct type
1663 case icSigXYZType:
1664
1665 Icc ->Read(&XYZ, sizeof(icXYZNumber), 1, Icc);
1666 Value -> X = Convert15Fixed16(XYZ.X);
1667 Value -> Y = Convert15Fixed16(XYZ.Y);
1668 Value -> Z = Convert15Fixed16(XYZ.Z);
1669 break;
1670
1671 // Aug/21-2001 - Monaco 2 does have WRONG values.
1672
1673 default:
1674 if (lIsFatal)
1675 cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature %lx found.", BaseType);
1676 return -1;
1677 }
1678
1679 return 1;
1680 }
1681
1682
1683 // Read a icSigS15Fixed16ArrayType (currently only a 3x3 matrix)
1684
1685 static
1686 int ReadICCXYZArray(cmsHPROFILE hProfile, icTagSignature sig, LPMAT3 v)
1687 {
1688 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1689 icTagTypeSignature BaseType;
1690 size_t offset, sz;
1691 int i, n;
1692 icXYZNumber XYZ[3];
1693 cmsCIEXYZ XYZdbl[3];
1694
1695
1696 n = _cmsSearchTag(Icc, sig, FALSE);
1697 if (n < 0)
1698 return -1; // Not found
1699
1700 if (Icc -> TagPtrs[n]) {
1701
1702 CopyMemory(v, Icc -> TagPtrs[n], Icc -> TagSizes[n]);
1703 return (int) Icc -> TagSizes[n];
1704 }
1705
1706 offset = Icc -> TagOffsets[n];
1707
1708 if (Icc -> Seek(Icc, offset))
1709 return -1;
1710
1711 BaseType = ReadBase(Icc);
1712
1713 switch (BaseType) {
1714
1715 case icSigS15Fixed16ArrayType:
1716
1717 sz = Icc ->TagSizes[n] / sizeof(icXYZNumber);
1718
1719 if (sz != 3) {
1720 cmsSignalError(LCMS_ERRC_ABORTED, "Bad array size of %d entries.", sz);
1721 return -1;
1722 }
1723
1724 Icc ->Read(XYZ, sizeof(icXYZNumber), 3, Icc);
1725
1726 for (i=0; i < 3; i++) {
1727
1728 XYZdbl[i].X = Convert15Fixed16(XYZ[i].X);
1729 XYZdbl[i].Y = Convert15Fixed16(XYZ[i].Y);
1730 XYZdbl[i].Z = Convert15Fixed16(XYZ[i].Z);
1731 }
1732
1733 CopyMemory(v, XYZdbl, 3*sizeof(cmsCIEXYZ));
1734 break;
1735
1736 default:
1737 cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature %lx found.", BaseType);
1738 return -1;
1739
1740 }
1741
1742 return sizeof(MAT3);
1743 }
1744
1745
1746
1747 // Primaries are to be in xyY notation
1748
1749 LCMSBOOL LCMSEXPORT cmsTakeColorants(LPcmsCIEXYZTRIPLE Dest, cmsHPROFILE hProfile)
1750 {
1751 if (ReadICCXYZ(hProfile, icSigRedColorantTag, &Dest -> Red, TRUE) < 0) return FALSE;
1752 if (ReadICCXYZ(hProfile, icSigGreenColorantTag, &Dest -> Green, TRUE) < 0) return FALSE;
1753 if (ReadICCXYZ(hProfile, icSigBlueColorantTag, &Dest -> Blue, TRUE) < 0) return FALSE;
1754
1755 return TRUE;
1756 }
1757
1758
1759 LCMSBOOL cmsReadICCMatrixRGB2XYZ(LPMAT3 r, cmsHPROFILE hProfile)
1760 {
1761 cmsCIEXYZTRIPLE Primaries;
1762
1763 if (!cmsTakeColorants(&Primaries, hProfile)) return FALSE;
1764
1765 VEC3init(&r -> v[0], Primaries.Red.X, Primaries.Green.X, Primaries.Blue.X);
1766 VEC3init(&r -> v[1], Primaries.Red.Y, Primaries.Green.Y, Primaries.Blue.Y);
1767 VEC3init(&r -> v[2], Primaries.Red.Z, Primaries.Green.Z, Primaries.Blue.Z);
1768
1769 return TRUE;
1770
1771 }
1772
1773
1774 // Always return a suitable matrix
1775
1776 LCMSBOOL cmsReadChromaticAdaptationMatrix(LPMAT3 r, cmsHPROFILE hProfile)
1777 {
1778
1779 if (ReadICCXYZArray(hProfile, icSigChromaticAdaptationTag, r) < 0) {
1780
1781 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1782
1783 // For display profiles, revert to bradford. Else take identity.
1784
1785 MAT3identity(r);
1786
1787 // Emissive devices have non-identity chad
1788
1789 if ((cmsGetDeviceClass(hProfile) == icSigDisplayClass) ||
1790 cmsTakeHeaderFlags(hProfile) & icTransparency) {
1791
1792 // NULL for cone defaults to Bradford, from media to D50
1793 cmsAdaptationMatrix(r, NULL, &Icc ->MediaWhitePoint, &Icc ->Illuminant);
1794 }
1795 }
1796
1797 return TRUE;
1798 }
1799
1800
1801
1802 LPGAMMATABLE LCMSEXPORT cmsReadICCGamma(cmsHPROFILE hProfile, icTagSignature sig)
1803 {
1804 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1805 size_t offset;
1806 int n;
1807
1808
1809 n = _cmsSearchTag(Icc, sig, TRUE);
1810 if (n < 0)
1811 return NULL;
1812
1813 if (Icc -> TagPtrs[n]) {
1814
1815 return cmsDupGamma((LPGAMMATABLE) Icc -> TagPtrs[n]);
1816 }
1817
1818 offset = Icc -> TagOffsets[n];
1819
1820 if (Icc -> Seek(Icc, offset))
1821 return NULL;
1822
1823 return ReadCurve(Icc);
1824
1825 }
1826
1827
1828 // Some ways have analytical revese. This function accounts for that
1829
1830 LPGAMMATABLE LCMSEXPORT cmsReadICCGammaReversed(cmsHPROFILE hProfile, icTagSignature sig)
1831 {
1832 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1833 size_t offset;
1834 int n;
1835
1836
1837 n = _cmsSearchTag(Icc, sig, TRUE);
1838 if (n < 0)
1839 return NULL;
1840
1841 if (Icc -> TagPtrs[n]) {
1842
1843 return cmsReverseGamma(256, (LPGAMMATABLE) Icc -> TagPtrs[n]);
1844 }
1845
1846 offset = Icc -> TagOffsets[n];
1847
1848 if (Icc -> Seek(Icc, offset))
1849 return NULL;
1850
1851 return ReadCurveReversed(Icc);
1852 }
1853
1854 // Check Named color header
1855
1856 static
1857 LCMSBOOL CheckHeader(LPcmsNAMEDCOLORLIST v, icNamedColor2* nc2)
1858 {
1859 if (v ->Prefix[0] == 0 && v ->Suffix[0] == 0 && v ->ColorantCount == 0) return TRUE;
1860
1861 if (stricmp(v ->Prefix, (const char*) nc2 ->prefix) != 0) return FALSE;
1862 if (stricmp(v ->Suffix, (const char*) nc2 ->suffix) != 0) return FALSE;
1863
1864 return ((int) v ->ColorantCount == (int) nc2 ->nDeviceCoords);
1865 }
1866
1867 // Read named color list
1868
1869 int cmsReadICCnamedColorList(cmsHTRANSFORM xform, cmsHPROFILE hProfile, icTagSignature sig)
1870 {
1871 _LPcmsTRANSFORM v = (_LPcmsTRANSFORM) xform;
1872 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1873 int n;
1874 icTagTypeSignature BaseType;
1875 size_t offset;
1876
1877 n = _cmsSearchTag(Icc, sig, TRUE);
1878 if (n < 0)
1879 return 0;
1880
1881 if (Icc -> TagPtrs[n]) {
1882
1883 // This replaces actual named color list.
1884 size_t size = Icc -> TagSizes[n];
1885
1886 if (v ->NamedColorList) cmsFreeNamedColorList(v ->NamedColorList);
1887 v -> NamedColorList = (LPcmsNAMEDCOLORLIST) _cmsMalloc(size);
1888 CopyMemory(v -> NamedColorList, Icc ->TagPtrs[n], size);
1889 return v ->NamedColorList->nColors;
1890 }
1891
1892 offset = Icc -> TagOffsets[n];
1893
1894 if (Icc -> Seek(Icc, offset))
1895 return 0;
1896
1897 BaseType = ReadBase(Icc);
1898
1899 switch (BaseType) {
1900
1901 // I never have seen one of these. Probably is not worth of implementing.
1902
1903 case icSigNamedColorType: {
1904
1905 cmsSignalError(LCMS_ERRC_WARNING, "Ancient named color profiles are not supported.");
1906 return 0;
1907 }
1908
1909 // The named color struct
1910
1911 case icSigNamedColor2Type: {
1912
1913 icNamedColor2 nc2;
1914 unsigned int i, j;
1915
1916 if (Icc -> Read(&nc2, sizeof(icNamedColor2) - SIZEOF_UINT8_ALIGNED, 1, Icc) != 1) return 0;
1917 AdjustEndianess32((LPBYTE) &nc2.vendorFlag);
1918 AdjustEndianess32((LPBYTE) &nc2.count);
1919 AdjustEndianess32((LPBYTE) &nc2.nDeviceCoords);
1920
1921 if (!CheckHeader(v->NamedColorList, &nc2)) {
1922 cmsSignalError(LCMS_ERRC_WARNING, "prefix/suffix/device for named color profiles mismatch.");
1923 return 0;
1924 }
1925
1926 if (nc2.nDeviceCoords > MAXCHANNELS) {
1927 cmsSignalError(LCMS_ERRC_WARNING, "Too many device coordinates.");
1928 return 0;
1929 }
1930
1931 strncpy(v ->NamedColorList->Prefix, (const char*) nc2.prefix, 32);
1932 strncpy(v ->NamedColorList->Suffix, (const char*) nc2.suffix, 32);
1933 v ->NamedColorList->Prefix[32] = v->NamedColorList->Suffix[32] = 0;
1934
1935 v ->NamedColorList ->ColorantCount = nc2.nDeviceCoords;
1936
1937 for (i=0; i < nc2.count; i++) {
1938
1939 WORD PCS[3];
1940 WORD Colorant[MAXCHANNELS];
1941 char Root[33];
1942
1943 ZeroMemory(Colorant, sizeof(WORD) * MAXCHANNELS);
1944 Icc -> Read(Root, 1, 32, Icc);
1945 Icc -> Read(PCS, 3, sizeof(WORD), Icc);
1946
1947 for (j=0; j < 3; j++)
1948 AdjustEndianess16((LPBYTE) &PCS[j]);
1949
1950 Icc -> Read(Colorant, sizeof(WORD), nc2.nDeviceCoords, Icc);
1951
1952 for (j=0; j < nc2.nDeviceCoords; j++)
1953 AdjustEndianess16((LPBYTE) &Colorant[j]);
1954
1955 cmsAppendNamedColor(v, Root, PCS, Colorant);
1956 }
1957
1958 return v ->NamedColorList->nColors;
1959 }
1960 break;
1961
1962 default:
1963 cmsSignalError(LCMS_ERRC_WARNING, "Bad tag signature '%lx' found.", BaseType);
1964 return 0;
1965 }
1966
1967 // It would never reach here
1968 // return 0;
1969 }
1970
1971
1972
1973 // Read colorant tables
1974
1975 LPcmsNAMEDCOLORLIST LCMSEXPORT cmsReadColorantTable(cmsHPROFILE hProfile, icTagSignature sig)
1976 {
1977 icInt32Number n, Count, i;
1978 size_t offset;
1979 icTagTypeSignature BaseType;
1980 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
1981 LPcmsNAMEDCOLORLIST List;
1982
1983 n = _cmsSearchTag(Icc, sig, FALSE);
1984 if (n < 0)
1985 return NULL; // Not found
1986
1987 if (Icc -> TagPtrs[n]) {
1988
1989 size_t size = Icc -> TagSizes[n];
1990 void* v = _cmsMalloc(size);
1991
1992 if (v == NULL) return NULL;
1993 CopyMemory(v, Icc -> TagPtrs[n], size);
1994 return (LPcmsNAMEDCOLORLIST) v;
1995 }
1996
1997
1998 offset = Icc -> TagOffsets[n];
1999
2000 if (Icc -> Seek(Icc, offset))
2001 return NULL;
2002
2003 BaseType = ReadBase(Icc);
2004
2005 if (BaseType != icSigColorantTableType) {
2006 cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature '%lx' found.", BaseType);
2007 return NULL;
2008 }
2009
2010
2011 if (Icc ->Read(&Count, sizeof(icUInt32Number), 1, Icc) != 1) return NULL;
2012 AdjustEndianess32((LPBYTE) &Count);
2013
2014 if (Count > MAXCHANNELS) {
2015 cmsSignalError(LCMS_ERRC_ABORTED, "Too many colorants '%lx'", Count);
2016 return NULL;
2017 }
2018
2019 List = cmsAllocNamedColorList(Count);
2020 for (i=0; i < Count; i++) {
2021
2022 if (!Icc ->Read(List->List[i].Name, 1, 32 , Icc)) goto Error;
2023 if (!Icc ->Read(List->List[i].PCS, sizeof(icUInt16Number), 3, Icc)) goto Error;
2024 AdjustEndianessArray16(List->List[i].PCS, 3);
2025 }
2026
2027 return List;
2028
2029 Error:
2030 cmsFreeNamedColorList(List);
2031 return NULL;
2032
2033 }
2034
2035
2036
2037 // Uncooked manufacturer
2038
2039 const char* LCMSEXPORT cmsTakeManufacturer(cmsHPROFILE hProfile)
2040 {
2041
2042 static char Manufacturer[LCMS_DESC_MAX] = "";
2043
2044 Manufacturer[0] = 0;
2045
2046 if (cmsIsTag(hProfile, icSigDeviceMfgDescTag)) {
2047
2048 cmsReadICCTextEx(hProfile, icSigDeviceMfgDescTag, Manufacturer, LCMS_DESC_MAX);
2049 }
2050
2051 return Manufacturer;
2052 }
2053
2054 // Uncooked model
2055
2056 const char* LCMSEXPORT cmsTakeModel(cmsHPROFILE hProfile)
2057 {
2058
2059 static char Model[LCMS_DESC_MAX] = "";
2060
2061 Model[0] = 0;
2062
2063 if (cmsIsTag(hProfile, icSigDeviceModelDescTag)) {
2064
2065 cmsReadICCTextEx(hProfile, icSigDeviceModelDescTag, Model, LCMS_DESC_MAX);
2066 }
2067
2068 return Model;
2069 }
2070
2071
2072 const char* LCMSEXPORT cmsTakeCopyright(cmsHPROFILE hProfile)
2073 {
2074
2075 static char Copyright[LCMS_DESC_MAX] = "";
2076
2077 Copyright[0] = 0;
2078 if (cmsIsTag(hProfile, icSigCopyrightTag)) {
2079
2080 cmsReadICCTextEx(hProfile, icSigCopyrightTag, Copyright, LCMS_DESC_MAX);
2081 }
2082
2083 return Copyright;
2084 }
2085
2086
2087 // We compute name with model - manufacturer
2088
2089 const char* LCMSEXPORT cmsTakeProductName(cmsHPROFILE hProfile)
2090 {
2091 static char Name[LCMS_DESC_MAX*2+4];
2092 char Manufacturer[LCMS_DESC_MAX], Model[LCMS_DESC_MAX];
2093
2094 Name[0] = '\0';
2095 Manufacturer[0] = Model[0] = '\0';
2096
2097 if (cmsIsTag(hProfile, icSigDeviceMfgDescTag)) {
2098
2099 cmsReadICCTextEx(hProfile, icSigDeviceMfgDescTag, Manufacturer, LCMS_DESC_MAX);
2100 }
2101
2102 if (cmsIsTag(hProfile, icSigDeviceModelDescTag)) {
2103
2104 cmsReadICCTextEx(hProfile, icSigDeviceModelDescTag, Model, LCMS_DESC_MAX);
2105 }
2106
2107 if (!Manufacturer[0] && !Model[0]) {
2108
2109 if (cmsIsTag(hProfile, icSigProfileDescriptionTag)) {
2110
2111 cmsReadICCTextEx(hProfile, icSigProfileDescriptionTag, Name, LCMS_DESC_MAX);
2112 return Name;
2113 }
2114 else return "{no name}";
2115 }
2116
2117
2118 if (!Manufacturer[0] ||
2119 strncmp(Model, Manufacturer, 8) == 0 || strlen(Model) > 30)
2120 strcpy(Name, Model);
2121 else
2122 sprintf(Name, "%s - %s", Model, Manufacturer);
2123
2124 return Name;
2125
2126 }
2127
2128
2129 // We compute desc with manufacturer - model
2130
2131 const char* LCMSEXPORT cmsTakeProductDesc(cmsHPROFILE hProfile)
2132 {
2133 static char Name[2048];
2134
2135 if (cmsIsTag(hProfile, icSigProfileDescriptionTag)) {
2136
2137 cmsReadICCText(hProfile, icSigProfileDescriptionTag, Name);
2138 }
2139 else return cmsTakeProductName(hProfile);
2140
2141 if (strncmp(Name, "Copyrig", 7) == 0)
2142 return cmsTakeProductName(hProfile);
2143
2144 return Name;
2145 }
2146
2147
2148 const char* LCMSEXPORT cmsTakeProductInfo(cmsHPROFILE hProfile)
2149 {
2150 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
2151
2152 static char Info[4096];
2153
2154 Info[0] = '\0';
2155
2156 if (cmsIsTag(hProfile, icSigProfileDescriptionTag))
2157 {
2158 char Desc[1024];
2159
2160 cmsReadICCText(hProfile, icSigProfileDescriptionTag, Desc);
2161 strcat(Info, Desc);
2162 strcat(Info, "\r\n\r\n");
2163 }
2164
2165
2166 if (cmsIsTag(hProfile, icSigCopyrightTag))
2167 {
2168 char Copyright[LCMS_DESC_MAX];
2169
2170 cmsReadICCText(hProfile, icSigCopyrightTag, Copyright);
2171 strcat(Info, Copyright);
2172 strcat(Info, "\r\n\r\n");
2173 }
2174
2175
2176
2177 // KODAK private tag... But very useful
2178
2179 #define K007 (icTagSignature)0x4B303037
2180
2181 // MonCal
2182
2183 if (cmsIsTag(hProfile, K007))
2184 {
2185 char MonCal[LCMS_DESC_MAX];
2186
2187 cmsReadICCText(hProfile, K007, MonCal);
2188 strcat(Info, MonCal);
2189 strcat(Info, "\r\n\r\n");
2190 }
2191 else
2192 {
2193 cmsCIEXYZ WhitePt;
2194 char WhiteStr[1024];
2195
2196 cmsTakeMediaWhitePoint(&WhitePt, hProfile);
2197 _cmsIdentifyWhitePoint(WhiteStr, &WhitePt);
2198 strcat(WhiteStr, "\r\n\r\n");
2199 strcat(Info, WhiteStr);
2200 }
2201
2202
2203 if (Icc -> stream) {
2204 strcat(Info, Icc -> PhysicalFile);
2205 }
2206 return Info;
2207 }
2208
2209 // Extract the target data as a big string. Does not signal if tag is not present.
2210
2211 LCMSBOOL LCMSEXPORT cmsTakeCharTargetData(cmsHPROFILE hProfile, char** Data, size_t* len)
2212 {
2213 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
2214 int n;
2215
2216 *Data = NULL;
2217 *len = 0;
2218
2219 n = _cmsSearchTag(Icc, icSigCharTargetTag, FALSE);
2220 if (n < 0) return FALSE;
2221
2222
2223 *len = Icc -> TagSizes[n];
2224
2225 // Make sure that is reasonable (600K)
2226 if (*len > 600*1024) *len = 600*1024;
2227
2228 *Data = (char*) _cmsMalloc(*len + 1); // Plus zero marker
2229
2230 if (!*Data) {
2231
2232 cmsSignalError(LCMS_ERRC_ABORTED, "Out of memory allocating CharTarget space!");
2233 return FALSE;
2234 }
2235
2236 if (cmsReadICCTextEx(hProfile, icSigCharTargetTag, *Data, *len) < 0)
2237 return FALSE;
2238
2239 (*Data)[*len] = 0; // Force a zero marker. Shouldn't be needed, but is
2240 // here to simplify things.
2241
2242 return TRUE;
2243 }
2244
2245
2246
2247
2248 LCMSBOOL LCMSEXPORT cmsTakeCalibrationDateTime(struct tm *Dest, cmsHPROFILE hProfile)
2249 {
2250 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
2251 int n;
2252
2253 n = _cmsSearchTag(Icc, icSigCalibrationDateTimeTag, FALSE);
2254 if (n < 0) return FALSE;
2255
2256 if (Icc ->TagPtrs[n]) {
2257
2258 CopyMemory(Dest, Icc ->TagPtrs[n], sizeof(struct tm));
2259 }
2260 else
2261 {
2262 icDateTimeNumber timestamp;
2263
2264 if (Icc -> Seek(Icc, Icc -> TagOffsets[n] + sizeof(icTagBase)))
2265 return FALSE;
2266
2267 if (Icc ->Read(&timestamp, 1, sizeof(icDateTimeNumber), Icc) != sizeof(icDateTimeNumber))
2268 return FALSE;
2269
2270 DecodeDateTimeNumber(&timestamp, Dest);
2271 }
2272
2273
2274 return TRUE;
2275 }
2276
2277
2278
2279 // PSEQ Tag, used in devicelink profiles
2280
2281 LPcmsSEQ LCMSEXPORT cmsReadProfileSequenceDescription(cmsHPROFILE hProfile)
2282 {
2283 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
2284 int n;
2285 icUInt32Number i, Count;
2286 icDescStruct DescStruct;
2287 icTagTypeSignature BaseType;
2288 size_t size, offset;
2289 LPcmsSEQ OutSeq;
2290
2291
2292 n = _cmsSearchTag(Icc, icSigProfileSequenceDescTag, FALSE);
2293 if (n < 0) return NULL;
2294
2295 size = Icc -> TagSizes[n];
2296 if (size < 12) return NULL;
2297
2298 if (Icc -> TagPtrs[n]) {
2299
2300 OutSeq = (LPcmsSEQ) _cmsMalloc(size);
2301 if (OutSeq == NULL) return NULL;
2302 CopyMemory(OutSeq, Icc ->TagPtrs[n], size);
2303 return OutSeq;
2304 }
2305
2306 offset = Icc -> TagOffsets[n];
2307
2308 if (Icc -> Seek(Icc, offset))
2309 return NULL;
2310
2311 BaseType = ReadBase(Icc);
2312
2313 if (BaseType != icSigProfileSequenceDescType) return NULL;
2314
2315 Icc ->Read(&Count, sizeof(icUInt32Number), 1, Icc);
2316 AdjustEndianess32((LPBYTE) &Count);
2317
2318 size = sizeof(int) + Count * sizeof(cmsPSEQDESC);
2319 OutSeq = (LPcmsSEQ) _cmsMalloc(size);
2320 if (OutSeq == NULL) return NULL;
2321
2322 OutSeq ->n = Count;
2323
2324 // Get structures as well
2325
2326 for (i=0; i < Count; i++) {
2327
2328 LPcmsPSEQDESC sec = &OutSeq -> seq[i];
2329
2330 Icc -> Read(&DescStruct, sizeof(icDescStruct) - SIZEOF_UINT8_ALIGNED, 1, Icc);
2331
2332 AdjustEndianess32((LPBYTE) &DescStruct.deviceMfg);
2333 AdjustEndianess32((LPBYTE) &DescStruct.deviceModel);
2334 AdjustEndianess32((LPBYTE) &DescStruct.technology);
2335 AdjustEndianess32((LPBYTE) &DescStruct.attributes[0]);
2336 AdjustEndianess32((LPBYTE) &DescStruct.attributes[1]);
2337
2338 sec ->attributes[0] = DescStruct.attributes[0];
2339 sec ->attributes[1] = DescStruct.attributes[1];
2340 sec ->deviceMfg = DescStruct.deviceMfg;
2341 sec ->deviceModel = DescStruct.deviceModel;
2342 sec ->technology = DescStruct.technology;
2343
2344 if (ReadEmbeddedTextTag(Icc, size, sec ->Manufacturer, LCMS_DESC_MAX) < 0) return NULL;
2345 if (ReadEmbeddedTextTag(Icc, size, sec ->Model, LCMS_DESC_MAX) < 0) return NULL;
2346
2347 }
2348
2349 return OutSeq;
2350 }
2351
2352
2353 void LCMSEXPORT cmsFreeProfileSequenceDescription(LPcmsSEQ pseq)
2354 {
2355 if (pseq)
2356 _cmsFree(pseq);
2357 }
2358
2359
2360
2361
2362
2363 // Read a few tags that are hardly required
2364
2365
2366 static
2367 void ReadCriticalTags(LPLCMSICCPROFILE Icc)
2368 {
2369 cmsHPROFILE hProfile = (cmsHPROFILE) Icc;
2370
2371 if (Icc ->Version >= 0x4000000) {
2372
2373 // v4 profiles
2374
2375 MAT3 ChrmCanonical;
2376
2377 if (ReadICCXYZ(hProfile,
2378 icSigMediaWhitePointTag,
2379 &Icc ->MediaWhitePoint, FALSE) < 0) {
2380
2381 Icc ->MediaWhitePoint = *cmsD50_XYZ();
2382 }
2383
2384 // Read media black
2385
2386 if (ReadICCXYZ(hProfile,
2387 icSigMediaBlackPointTag,
2388 &Icc ->MediaBlackPoint, FALSE) < 0) {
2389
2390 Icc ->MediaBlackPoint.X = 0;
2391 Icc ->MediaBlackPoint.Y = 0;
2392 Icc ->MediaBlackPoint.X = 0;
2393
2394 }
2395
2396 NormalizeXYZ(&Icc ->MediaWhitePoint);
2397 NormalizeXYZ(&Icc ->MediaBlackPoint);
2398
2399 if (ReadICCXYZArray(hProfile,
2400 icSigChromaticAdaptationTag,
2401 &ChrmCanonical) > 0) {
2402
2403 MAT3inverse(&ChrmCanonical, &Icc ->ChromaticAdaptation);
2404
2405 }
2406 else {
2407
2408 MAT3identity(&Icc ->ChromaticAdaptation);
2409 }
2410
2411
2412 // Convert media white, black to absolute under original illuminant
2413
2414 EvalCHRM(&Icc ->MediaWhitePoint, &Icc ->ChromaticAdaptation, &Icc ->MediaWhitePoint);
2415 EvalCHRM(&Icc ->MediaBlackPoint, &Icc ->ChromaticAdaptation, &Icc ->MediaBlackPoint);
2416
2417
2418 }
2419 else {
2420
2421 // v2 profiles
2422
2423 // Read media white
2424
2425 if (ReadICCXYZ(hProfile,
2426 icSigMediaWhitePointTag,
2427 &Icc ->MediaWhitePoint, FALSE) < 0) {
2428
2429 Icc ->MediaWhitePoint = *cmsD50_XYZ();
2430 }
2431
2432 // Read media black
2433
2434 if (ReadICCXYZ(hProfile,
2435 icSigMediaBlackPointTag,
2436 &Icc ->MediaBlackPoint, FALSE) < 0) {
2437
2438 Icc ->MediaBlackPoint.X = 0;
2439 Icc ->MediaBlackPoint.Y = 0;
2440 Icc ->MediaBlackPoint.X = 0;
2441
2442 }
2443
2444 NormalizeXYZ(&Icc ->MediaWhitePoint);
2445 NormalizeXYZ(&Icc ->MediaBlackPoint);
2446
2447
2448 // Take Bradford as default for Display profiles only.
2449
2450 if (cmsGetDeviceClass(hProfile) == icSigDisplayClass) {
2451
2452
2453 cmsAdaptationMatrix(&Icc -> ChromaticAdaptation,
2454 NULL,
2455 &Icc -> Illuminant,
2456 &Icc -> MediaWhitePoint);
2457 }
2458 else
2459 MAT3identity(&Icc ->ChromaticAdaptation);
2460
2461 }
2462
2463 }
2464
2465
2466 // Create profile from disk file
2467
2468 cmsHPROFILE LCMSEXPORT cmsOpenProfileFromFile(const char *lpFileName, const char *sAccess)
2469 {
2470 LPLCMSICCPROFILE NewIcc;
2471 cmsHPROFILE hEmpty;
2472
2473
2474 // Open for write means an empty profile
2475
2476 if (*sAccess == 'W' || *sAccess == 'w') {
2477
2478 hEmpty = _cmsCreateProfilePlaceholder();
2479 NewIcc = (LPLCMSICCPROFILE) (LPSTR) hEmpty;
2480 NewIcc -> IsWrite = TRUE;
2481 strncpy(NewIcc ->PhysicalFile, lpFileName, MAX_PATH-1);
2482 NewIcc ->PhysicalFile[MAX_PATH-1] = 0;
2483
2484 // Save LUT as 8 bit
2485
2486 sAccess++;
2487 if (*sAccess == '8') NewIcc ->SaveAs8Bits = TRUE;
2488
2489 return hEmpty;
2490 }
2491
2492
2493 // Open for read means a file placeholder
2494
2495 NewIcc = _cmsCreateProfileFromFilePlaceholder(lpFileName);
2496 if (!NewIcc) return NULL;
2497
2498 if (!ReadHeader(NewIcc, FALSE)) return NULL;
2499
2500 ReadCriticalTags(NewIcc);
2501
2502 return (cmsHPROFILE) (LPSTR) NewIcc;
2503 }
2504
2505
2506
2507
2508 // Open from memory block
2509
2510 cmsHPROFILE LCMSEXPORT cmsOpenProfileFromMem(LPVOID MemPtr, DWORD dwSize)
2511 {
2512 LPLCMSICCPROFILE NewIcc;
2513
2514
2515 NewIcc = _cmsCreateProfileFromMemPlaceholder(MemPtr, dwSize);
2516 if (!NewIcc) return NULL;
2517
2518 if (!ReadHeader(NewIcc, TRUE)) return NULL;
2519
2520 ReadCriticalTags(NewIcc);
2521
2522 return (cmsHPROFILE) (LPSTR) NewIcc;
2523
2524 }
2525
2526
2527
2528 LCMSBOOL LCMSEXPORT cmsCloseProfile(cmsHPROFILE hProfile)
2529 {
2530 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
2531 LCMSBOOL rc = TRUE;
2532 icInt32Number i;
2533
2534 if (!Icc) return FALSE;
2535
2536 // Was open in write mode?
2537 if (Icc ->IsWrite) {
2538
2539 Icc ->IsWrite = FALSE; // Assure no further writting
2540 rc = _cmsSaveProfile(hProfile, Icc ->PhysicalFile);
2541 }
2542
2543 for (i=0; i < Icc -> TagCount; i++) {
2544
2545 if (Icc -> TagPtrs[i])
2546 free(Icc -> TagPtrs[i]);
2547 }
2548
2549 if (Icc -> stream != NULL) { // Was a memory (i.e. not serialized) profile?
2550 Icc -> Close(Icc); // No, close the stream
2551 }
2552
2553 free(Icc); // Free placeholder memory
2554
2555 return rc;
2556 }
2557
2558
2559
2560 // Write profile ------------------------------------------------------------
2561
2562
2563
2564 static
2565 LCMSBOOL SaveWordsTable(int nEntries, LPWORD Tab, LPLCMSICCPROFILE Icc)
2566 {
2567 size_t nTabSize = sizeof(WORD) * nEntries;
2568 LPWORD PtrW = (LPWORD) _cmsMalloc(nTabSize);
2569 LCMSBOOL rc;
2570
2571 if (!PtrW) return FALSE;
2572 CopyMemory(PtrW, Tab, nTabSize);
2573 AdjustEndianessArray16(PtrW, nEntries);
2574 rc = Icc ->Write(Icc, nTabSize, PtrW);
2575 free(PtrW);
2576
2577 return rc;
2578 }
2579
2580
2581
2582 // Saves profile header
2583
2584 static
2585 LCMSBOOL SaveHeader(LPLCMSICCPROFILE Icc)
2586 {
2587 icHeader Header;
2588 time_t now = time(NULL);
2589
2590 Header.size = TransportValue32((icInt32Number) Icc ->UsedSpace);
2591 Header.cmmId = TransportValue32(lcmsSignature);
2592 Header.version = TransportValue32((icInt32Number) 0x02300000);
2593 Header.deviceClass = (icProfileClassSignature) TransportValue32(Icc -> DeviceClass);
2594 Header.colorSpace = (icColorSpaceSignature) TransportValue32(Icc -> ColorSpace);
2595 Header.pcs = (icColorSpaceSignature) TransportValue32(Icc -> PCS);
2596
2597 // NOTE: in v4 Timestamp must be in UTC rather than in local time
2598 EncodeDateTimeNumber(&Header.date, gmtime(&now));
2599
2600 Header.magic = TransportValue32(icMagicNumber);
2601
2602 #ifdef NON_WINDOWS
2603 Header.platform = (icPlatformSignature)TransportValue32(icSigMacintosh);
2604 #else
2605 Header.platform = (icPlatformSignature)TransportValue32(icSigMicrosoft);
2606 #endif
2607
2608 Header.flags = TransportValue32(Icc -> flags);
2609 Header.manufacturer = TransportValue32(lcmsSignature);
2610 Header.model = TransportValue32(0);
2611 Header.attributes[0]= TransportValue32(Icc -> attributes);
2612 Header.attributes[1]= TransportValue32(0);
2613
2614 Header.renderingIntent = TransportValue32(Icc -> RenderingIntent);
2615
2616 // Illuminant is D50
2617
2618 Header.illuminant.X = TransportValue32(DOUBLE_TO_FIXED(Icc -> Illuminant.X));
2619 Header.illuminant.Y = TransportValue32(DOUBLE_TO_FIXED(Icc -> Illuminant.Y));
2620 Header.illuminant.Z = TransportValue32(DOUBLE_TO_FIXED(Icc -> Illuminant.Z));
2621
2622 Header.creator = TransportValue32(lcmsSignature);
2623
2624 ZeroMemory(&Header.reserved, sizeof(Header.reserved));
2625
2626 // Set profile ID
2627 CopyMemory(Header.reserved, Icc ->ProfileID, 16);
2628
2629
2630 Icc ->UsedSpace = 0; // Mark as begin-of-file
2631
2632 return Icc ->Write(Icc, sizeof(icHeader), &Header);
2633 }
2634
2635
2636
2637 // Setup base marker
2638
2639 static
2640 LCMSBOOL SetupBase(icTagTypeSignature sig, LPLCMSICCPROFILE Icc)
2641 {
2642 icTagBase Base;
2643
2644 Base.sig = (icTagTypeSignature) TransportValue32(sig);
2645 ZeroMemory(&Base.reserved, sizeof(Base.reserved));
2646 return Icc -> Write(Icc, sizeof(icTagBase), &Base);
2647 }
2648
2649
2650 // Store a XYZ tag
2651
2652 static
2653 LCMSBOOL SaveXYZNumber(LPcmsCIEXYZ Value, LPLCMSICCPROFILE Icc)
2654 {
2655
2656 icXYZNumber XYZ;
2657
2658 if (!SetupBase(icSigXYZType, Icc)) return FALSE;
2659
2660 XYZ.X = TransportValue32(DOUBLE_TO_FIXED(Value -> X));
2661 XYZ.Y = TransportValue32(DOUBLE_TO_FIXED(Value -> Y));
2662 XYZ.Z = TransportValue32(DOUBLE_TO_FIXED(Value -> Z));
2663
2664
2665 return Icc -> Write(Icc, sizeof(icXYZNumber), &XYZ);
2666 }
2667
2668
2669 // Store a XYZ array.
2670
2671 static
2672 LCMSBOOL SaveXYZArray(int n, LPcmsCIEXYZ Value, LPLCMSICCPROFILE Icc)
2673 {
2674 int i;
2675 icXYZNumber XYZ;
2676
2677 if (!SetupBase(icSigS15Fixed16ArrayType, Icc)) return FALSE;
2678
2679 for (i=0; i < n; i++) {
2680
2681 XYZ.X = TransportValue32(DOUBLE_TO_FIXED(Value -> X));
2682 XYZ.Y = TransportValue32(DOUBLE_TO_FIXED(Value -> Y));
2683 XYZ.Z = TransportValue32(DOUBLE_TO_FIXED(Value -> Z));
2684
2685 if (!Icc -> Write(Icc, sizeof(icXYZNumber), &XYZ)) return FALSE;
2686
2687 Value++;
2688 }
2689
2690 return TRUE;
2691 }
2692
2693
2694
2695 // Save a gamma structure as a table
2696
2697 static
2698 LCMSBOOL SaveGammaTable(LPGAMMATABLE Gamma, LPLCMSICCPROFILE Icc)
2699 {
2700 icInt32Number Count;
2701
2702 if (!SetupBase(icSigCurveType, Icc)) return FALSE;
2703
2704 Count = TransportValue32(Gamma->nEntries);
2705
2706 if (!Icc ->Write(Icc, sizeof(icInt32Number), &Count)) return FALSE;
2707
2708 return SaveWordsTable(Gamma->nEntries, Gamma ->GammaTable, Icc);
2709 }
2710
2711
2712 // Save a gamma structure as a one-value
2713
2714 static
2715 LCMSBOOL SaveGammaOneValue(LPGAMMATABLE Gamma, LPLCMSICCPROFILE Icc)
2716 {
2717 icInt32Number Count;
2718 Fixed32 GammaFixed32;
2719 WORD GammaFixed8;
2720
2721 if (!SetupBase(icSigCurveType, Icc)) return FALSE;
2722
2723 Count = TransportValue32(1);
2724 if (!Icc ->Write(Icc, sizeof(icInt32Number), &Count)) return FALSE;
2725
2726 GammaFixed32 = DOUBLE_TO_FIXED(Gamma ->Seed.Params[0]);
2727 GammaFixed8 = (WORD) ((GammaFixed32 >> 8) & 0xFFFF);
2728 GammaFixed8 = TransportValue16(GammaFixed8);
2729
2730 return Icc ->Write(Icc, sizeof(icInt16Number), &GammaFixed8);
2731 }
2732
2733 // Save a gamma structure as a parametric gamma
2734
2735 static
2736 LCMSBOOL SaveGammaParametric(LPGAMMATABLE Gamma, LPLCMSICCPROFILE Icc)
2737 {
2738 icUInt16Number Type, Reserved;
2739 int i, nParams;
2740 int ParamsByType[] = { 1, 3, 4, 5, 7 };
2741
2742 if (!SetupBase(icSigParametricCurveType, Icc)) return FALSE;
2743
2744 nParams = ParamsByType[Gamma -> Seed.Type];
2745
2746 Type = (icUInt16Number) TransportValue16((WORD) Gamma -> Seed. Type);
2747 Reserved = (icUInt16Number) TransportValue16((WORD) 0);
2748
2749 Icc -> Write(Icc, sizeof(icInt16Number), &Type);
2750 Icc -> Write(Icc, sizeof(icUInt16Number), &Reserved);
2751
2752 for (i=0; i < nParams; i++) {
2753
2754 icInt32Number val = TransportValue32(DOUBLE_TO_FIXED(Gamma -> Seed.Params[i]));
2755 Icc ->Write(Icc, sizeof(icInt32Number), &val);
2756 }
2757
2758
2759 return TRUE;
2760
2761 }
2762
2763
2764 // Save a gamma table
2765
2766 static
2767 LCMSBOOL SaveGamma(LPGAMMATABLE Gamma, LPLCMSICCPROFILE Icc)
2768 {
2769 // Is the gamma curve type supported by ICC format?
2770
2771 if (Gamma -> Seed.Type < 0 || Gamma -> Seed.Type > 5 ||
2772
2773 // has been modified by user?
2774
2775 _cmsCrc32OfGammaTable(Gamma) != Gamma -> Seed.Crc32) {
2776
2777 return SaveGammaTable(Gamma, Icc);
2778 }
2779
2780 if (Gamma -> Seed.Type == 1) return SaveGammaOneValue(Gamma, Icc);
2781
2782 // Only v4 profiles are allowed to hold parametric curves
2783
2784 if (cmsGetProfileICCversion((cmsHPROFILE) Icc) >= 0x4000000)
2785 return SaveGammaParametric(Gamma, Icc);
2786
2787 // Defaults to save as table
2788
2789 return SaveGammaTable(Gamma, Icc);
2790
2791 }
2792
2793
2794
2795
2796 // Save an DESC Tag
2797
2798 static
2799 LCMSBOOL SaveDescription(const char *Text, LPLCMSICCPROFILE Icc)
2800 {
2801
2802 icUInt32Number len, Count, TotalSize, AlignedSize;
2803 char Filler[256];
2804
2805 len = (icUInt32Number) (strlen(Text) + 1);
2806
2807 // * icInt8Number desc[count] * NULL terminated ascii string
2808 // * icUInt32Number ucLangCode; * UniCode language code
2809 // * icUInt32Number ucCount; * UniCode description length
2810 // * icInt16Number ucDesc[ucCount];* The UniCode description
2811 // * icUInt16Number scCode; * ScriptCode code
2812 // * icUInt8Number scCount; * ScriptCode count
2813 // * icInt8Number scDesc[67]; * ScriptCode Description
2814
2815 TotalSize = sizeof(icTagBase) + sizeof(icUInt32Number) + len +
2816 sizeof(icUInt32Number) + sizeof(icUInt32Number) +
2817 sizeof(icUInt16Number) + sizeof(icUInt8Number) + 67;
2818
2819 AlignedSize = TotalSize; // Can be unaligned!!
2820
2821 if (!SetupBase(icSigTextDescriptionType, Icc)) return FALSE;
2822 AlignedSize -= sizeof(icTagBase);
2823
2824 Count = TransportValue32(len);
2825 if (!Icc ->Write(Icc, sizeof(icUInt32Number), &Count)) return FALSE;
2826 AlignedSize -= sizeof(icUInt32Number);
2827
2828 if (!Icc ->Write(Icc, len, (LPVOID)Text)) return FALSE;
2829 AlignedSize -= len;
2830
2831 if (AlignedSize < 0)
2832 AlignedSize = 0;
2833 if (AlignedSize > 255)
2834 AlignedSize = 255;
2835
2836 ZeroMemory(Filler, AlignedSize);
2837 if (!Icc ->Write(Icc, AlignedSize, Filler)) return FALSE;
2838
2839 return TRUE;
2840 }
2841
2842 // Save an ASCII Tag
2843
2844 static
2845 LCMSBOOL SaveText(const char *Text, LPLCMSICCPROFILE Icc)
2846 {
2847 size_t len = strlen(Text) + 1;
2848
2849 if (!SetupBase(icSigTextType, Icc)) return FALSE;
2850 if (!Icc ->Write(Icc, len, (LPVOID) Text)) return FALSE;
2851 return TRUE;
2852 }
2853
2854
2855 // Save one of these new chromaticity values
2856
2857 static
2858 LCMSBOOL SaveOneChromaticity(double x, double y, LPLCMSICCPROFILE Icc)
2859 {
2860 Fixed32 xf, yf;
2861
2862 xf = TransportValue32(DOUBLE_TO_FIXED(x));
2863 yf = TransportValue32(DOUBLE_TO_FIXED(y));
2864
2865 if (!Icc ->Write(Icc, sizeof(Fixed32), &xf)) return FALSE;
2866 if (!Icc ->Write(Icc, sizeof(Fixed32), &yf)) return FALSE;
2867
2868 return TRUE;
2869 }
2870
2871
2872 // New tag added in Addendum II of old spec.
2873
2874 static
2875 LCMSBOOL SaveChromaticities(LPcmsCIExyYTRIPLE chrm, LPLCMSICCPROFILE Icc)
2876 {
2877 WORD nChans, Table;
2878
2879 if (!SetupBase(icSigChromaticityType, Icc)) return FALSE;
2880
2881 nChans = TransportValue16(3);
2882 if (!Icc ->Write(Icc, sizeof(WORD) , &nChans)) return FALSE;
2883 Table = TransportValue16(0);
2884 if (!Icc ->Write(Icc, sizeof(WORD) , &Table)) return FALSE;
2885
2886 if (!SaveOneChromaticity(chrm -> Red.x, chrm -> Red.y, Icc)) return FALSE;
2887 if (!SaveOneChromaticity(chrm -> Green.x, chrm -> Green.y, Icc)) return FALSE;
2888 if (!SaveOneChromaticity(chrm -> Blue.x, chrm -> Blue.y, Icc)) return FALSE;
2889
2890 return TRUE;
2891 }
2892
2893
2894 static
2895 LCMSBOOL SaveSequenceDescriptionTag(LPcmsSEQ seq, LPLCMSICCPROFILE Icc)
2896 {
2897 icUInt32Number nSeqs;
2898 icDescStruct DescStruct;
2899 int i, n = seq ->n;
2900 LPcmsPSEQDESC pseq = seq ->seq;
2901
2902 if (!SetupBase(icSigProfileSequenceDescType, Icc)) return FALSE;
2903
2904 nSeqs = TransportValue32(n);
2905
2906 if (!Icc ->Write(Icc, sizeof(icUInt32Number) , &nSeqs)) return FALSE;
2907
2908 for (i=0; i < n; i++) {
2909
2910 LPcmsPSEQDESC sec = pseq + i;
2911
2912
2913 DescStruct.deviceMfg = (icTagTypeSignature) TransportValue32(sec ->deviceMfg);
2914 DescStruct.deviceModel = (icTagTypeSignature) TransportValue32(sec ->deviceModel);
2915 DescStruct.technology = (icTechnologySignature) TransportValue32(sec ->technology);
2916 DescStruct.attributes[0]= TransportValue32(sec ->attributes[0]);
2917 DescStruct.attributes[1]= TransportValue32(sec ->attributes[1]);
2918
2919 if (!Icc ->Write(Icc, sizeof(icDescStruct) - SIZEOF_UINT8_ALIGNED, &DescStruct)) return FALSE;
2920
2921 if (!SaveDescription(sec ->Manufacturer, Icc)) return FALSE;
2922 if (!SaveDescription(sec ->Model, Icc)) return FALSE;
2923 }
2924
2925 return TRUE;
2926 }
2927
2928
2929 // Saves a timestamp tag
2930
2931 static
2932 LCMSBOOL SaveDateTimeNumber(const struct tm *DateTime, LPLCMSICCPROFILE Icc)
2933 {
2934 icDateTimeNumber Dest;
2935
2936 if (!SetupBase(icSigDateTimeType, Icc)) return FALSE;
2937 EncodeDateTimeNumber(&Dest, DateTime);
2938 if (!Icc ->Write(Icc, sizeof(icDateTimeNumber), &Dest)) return FALSE;
2939
2940 return TRUE;
2941 }
2942
2943
2944 // Saves a named color list into a named color profile
2945 static
2946 LCMSBOOL SaveNamedColorList(LPcmsNAMEDCOLORLIST NamedColorList, LPLCMSICCPROFILE Icc)
2947 {
2948
2949 icUInt32Number vendorFlag; // Bottom 16 bits for IC use
2950 icUInt32Number count; // Count of named colors
2951 icUInt32Number nDeviceCoords; // Num of device coordinates
2952 char prefix[32]; // Prefix for each color name
2953 char suffix[32]; // Suffix for each color name
2954 int i;
2955
2956 if (!SetupBase(icSigNamedColor2Type, Icc)) return FALSE;
2957
2958 vendorFlag = TransportValue32(0);
2959 count = TransportValue32(NamedColorList ->nColors);
2960 nDeviceCoords = TransportValue32(NamedColorList ->ColorantCount);
2961
2962 strncpy(prefix, (const char*) NamedColorList->Prefix, 32);
2963 strncpy(suffix, (const char*) NamedColorList->Suffix, 32);
2964
2965 suffix[31] = prefix[31] = 0;
2966
2967 if (!Icc ->Write(Icc, sizeof(icUInt32Number), &vendorFlag)) return FALSE;
2968 if (!Icc ->Write(Icc, sizeof(icUInt32Number), &count)) return FALSE;
2969 if (!Icc ->Write(Icc, sizeof(icUInt32Number), &nDeviceCoords)) return FALSE;
2970 if (!Icc ->Write(Icc, 32 , prefix)) return FALSE;
2971 if (!Icc ->Write(Icc, 32 , suffix)) return FALSE;
2972
2973 for (i=0; i < NamedColorList ->nColors; i++) {
2974
2975 icUInt16Number PCS[3];
2976 icUInt16Number Colorant[MAXCHANNELS];
2977 char root[32];
2978 LPcmsNAMEDCOLOR Color;
2979 int j;
2980
2981 Color = NamedColorList ->List + i;
2982
2983 strncpy(root, Color ->Name, 32);
2984 Color ->Name[32] = 0;
2985
2986 if (!Icc ->Write(Icc, 32 , root)) return FALSE;
2987
2988 for (j=0; j < 3; j++)
2989 PCS[j] = TransportValue16(Color ->PCS[j]);
2990
2991 if (!Icc ->Write(Icc, 3 * sizeof(icUInt16Number), PCS)) return FALSE;
2992
2993 for (j=0; j < NamedColorList ->ColorantCount; j++)
2994 Colorant[j] = TransportValue16(Color ->DeviceColorant[j]);
2995
2996 if (!Icc ->Write(Icc,
2997 NamedColorList ->ColorantCount * sizeof(icUInt16Number), Colorant)) return FALSE;
2998 }
2999
3000
3001 return TRUE;
3002 }
3003
3004
3005
3006 // Saves a colorant table. It is using the named color structure for simplicity sake
3007
3008 static
3009 LCMSBOOL SaveColorantTable(LPcmsNAMEDCOLORLIST NamedColorList, LPLCMSICCPROFILE Icc)
3010 {
3011 icUInt32Number count; // Count of named colors
3012 int i;
3013
3014 if (!SetupBase(icSigColorantTableType, Icc)) return FALSE;
3015
3016 count = TransportValue32(NamedColorList ->nColors);
3017
3018 if (!Icc ->Write(Icc, sizeof(icUInt32Number), &count)) return FALSE;
3019
3020 for (i=0; i < NamedColorList ->nColors; i++) {
3021
3022 icUInt16Number PCS[3];
3023 icInt8Number root[33];
3024 LPcmsNAMEDCOLOR Color;
3025 int j;
3026
3027 Color = NamedColorList ->List + i;
3028
3029 strncpy((char*) root, Color ->Name, 32);
3030 root[32] = 0;
3031
3032 if (!Icc ->Write(Icc, 32 , root)) return FALSE;
3033
3034 for (j=0; j < 3; j++)
3035 PCS[j] = TransportValue16(Color ->PCS[j]);
3036
3037 if (!Icc ->Write(Icc, 3 * sizeof(icUInt16Number), PCS)) return FALSE;
3038
3039 }
3040
3041
3042 return TRUE;
3043 }
3044
3045 // Does serialization of LUT16 and writes it.
3046
3047 static
3048 LCMSBOOL SaveLUT(const LUT* NewLUT, LPLCMSICCPROFILE Icc)
3049 {
3050 icLut16 LUT16;
3051 unsigned int i;
3052 size_t nTabSize;
3053 WORD NullTbl[2] = { 0, 0xFFFFU};
3054
3055
3056 if (!SetupBase(icSigLut16Type, Icc)) return FALSE;
3057
3058 LUT16.clutPoints = (icUInt8Number) NewLUT -> cLutPoints;
3059 LUT16.inputChan = (icUInt8Number) NewLUT -> InputChan;
3060 LUT16.outputChan = (icUInt8Number) NewLUT -> OutputChan;
3061
3062 LUT16.inputEnt = TransportValue16((WORD) ((NewLUT -> wFlags & LUT_HASTL1) ? NewLUT -> InputEntries : 2));
3063 LUT16.outputEnt = TransportValue16((WORD) ((NewLUT -> wFlags & LUT_HASTL2) ? NewLUT -> OutputEntries : 2));
3064
3065 if (NewLUT -> wFlags & LUT_HASMATRIX) {
3066
3067 LUT16.e00 = TransportValue32(NewLUT -> Matrix.v[0].n[0]);
3068 LUT16.e01 = TransportValue32(NewLUT -> Matrix.v[0].n[1]);
3069 LUT16.e02 = TransportValue32(NewLUT -> Matrix.v[0].n[2]);
3070 LUT16.e10 = TransportValue32(NewLUT -> Matrix.v[1].n[0]);
3071 LUT16.e11 = TransportValue32(NewLUT -> Matrix.v[1].n[1]);
3072 LUT16.e12 = TransportValue32(NewLUT -> Matrix.v[1].n[2]);
3073 LUT16.e20 = TransportValue32(NewLUT -> Matrix.v[2].n[0]);
3074 LUT16.e21 = TransportValue32(NewLUT -> Matrix.v[2].n[1]);
3075 LUT16.e22 = TransportValue32(NewLUT -> Matrix.v[2].n[2]);
3076 }
3077 else {
3078
3079 LUT16.e00 = TransportValue32(DOUBLE_TO_FIXED(1));
3080 LUT16.e01 = TransportValue32(DOUBLE_TO_FIXED(0));
3081 LUT16.e02 = TransportValue32(DOUBLE_TO_FIXED(0));
3082 LUT16.e10 = TransportValue32(DOUBLE_TO_FIXED(0));
3083 LUT16.e11 = TransportValue32(DOUBLE_TO_FIXED(1));
3084 LUT16.e12 = TransportValue32(DOUBLE_TO_FIXED(0));
3085 LUT16.e20 = TransportValue32(DOUBLE_TO_FIXED(0));
3086 LUT16.e21 = TransportValue32(DOUBLE_TO_FIXED(0));
3087 LUT16.e22 = TransportValue32(DOUBLE_TO_FIXED(1));
3088 }
3089
3090
3091 // Save header
3092
3093 Icc -> Write(Icc, sizeof(icLut16)- SIZEOF_UINT16_ALIGNED, &LUT16);
3094
3095 // The prelinearization table
3096
3097 for (i=0; i < NewLUT -> InputChan; i++) {
3098
3099 if (NewLUT -> wFlags & LUT_HASTL1) {
3100
3101 if (!SaveWordsTable(NewLUT -> InputEntries,
3102 NewLUT -> L1[i], Icc)) return FALSE;
3103
3104 }
3105 else Icc -> Write(Icc, sizeof(WORD)* 2, NullTbl);
3106 }
3107
3108
3109 nTabSize = (NewLUT -> OutputChan * uipow(NewLUT->cLutPoints,
3110 NewLUT->InputChan));
3111 // The 3D CLUT.
3112
3113 if (nTabSize > 0) {
3114
3115 if (!SaveWordsTable((int) nTabSize, NewLUT -> T, Icc)) return FALSE;
3116 }
3117 // The postlinearization table
3118
3119 for (i=0; i < NewLUT -> OutputChan; i++) {
3120
3121 if (NewLUT -> wFlags & LUT_HASTL2) {
3122
3123 if (!SaveWordsTable(NewLUT -> OutputEntries,
3124 NewLUT -> L2[i], Icc)) return FALSE;
3125 }
3126 else Icc -> Write(Icc, sizeof(WORD)* 2, NullTbl);
3127
3128 }
3129
3130 return TRUE;
3131 }
3132
3133
3134
3135 // Does serialization of LUT8 and writes it
3136
3137 static
3138 LCMSBOOL SaveLUT8(const LUT* NewLUT, LPLCMSICCPROFILE Icc)
3139 {
3140 icLut8 LUT8;
3141 unsigned int i, j;
3142 size_t nTabSize;
3143 BYTE val;
3144
3145 // Sanity check
3146
3147 if (NewLUT -> wFlags & LUT_HASTL1) {
3148
3149 if (NewLUT -> InputEntries != 256) {
3150 cmsSignalError(LCMS_ERRC_ABORTED, "LUT8 needs 256 entries on prelinearization");
3151 return FALSE;
3152 }
3153
3154 }
3155
3156
3157 if (NewLUT -> wFlags & LUT_HASTL2) {
3158
3159 if (NewLUT -> OutputEntries != 256) {
3160 cmsSignalError(LCMS_ERRC_ABORTED, "LUT8 needs 256 entries on postlinearization");
3161 return FALSE;
3162 }
3163 }
3164
3165
3166
3167 if (!SetupBase(icSigLut8Type, Icc)) return FALSE;
3168
3169 LUT8.clutPoints = (icUInt8Number) NewLUT -> cLutPoints;
3170 LUT8.inputChan = (icUInt8Number) NewLUT -> InputChan;
3171 LUT8.outputChan = (icUInt8Number) NewLUT -> OutputChan;
3172
3173
3174 if (NewLUT -> wFlags & LUT_HASMATRIX) {
3175
3176 LUT8.e00 = TransportValue32(NewLUT -> Matrix.v[0].n[0]);
3177 LUT8.e01 = TransportValue32(NewLUT -> Matrix.v[0].n[1]);
3178 LUT8.e02 = TransportValue32(NewLUT -> Matrix.v[0].n[2]);
3179 LUT8.e10 = TransportValue32(NewLUT -> Matrix.v[1].n[0]);
3180 LUT8.e11 = TransportValue32(NewLUT -> Matrix.v[1].n[1]);
3181 LUT8.e12 = TransportValue32(NewLUT -> Matrix.v[1].n[2]);
3182 LUT8.e20 = TransportValue32(NewLUT -> Matrix.v[2].n[0]);
3183 LUT8.e21 = TransportValue32(NewLUT -> Matrix.v[2].n[1]);
3184 LUT8.e22 = TransportValue32(NewLUT -> Matrix.v[2].n[2]);
3185 }
3186 else {
3187
3188 LUT8.e00 = TransportValue32(DOUBLE_TO_FIXED(1));
3189 LUT8.e01 = TransportValue32(DOUBLE_TO_FIXED(0));
3190 LUT8.e02 = TransportValue32(DOUBLE_TO_FIXED(0));
3191 LUT8.e10 = TransportValue32(DOUBLE_TO_FIXED(0));
3192 LUT8.e11 = TransportValue32(DOUBLE_TO_FIXED(1));
3193 LUT8.e12 = TransportValue32(DOUBLE_TO_FIXED(0));
3194 LUT8.e20 = TransportValue32(DOUBLE_TO_FIXED(0));
3195 LUT8.e21 = TransportValue32(DOUBLE_TO_FIXED(0));
3196 LUT8.e22 = TransportValue32(DOUBLE_TO_FIXED(1));
3197 }
3198
3199
3200 // Save header
3201
3202 Icc -> Write(Icc, sizeof(icLut8)- SIZEOF_UINT8_ALIGNED, &LUT8);
3203
3204 // The prelinearization table
3205
3206 for (i=0; i < NewLUT -> InputChan; i++) {
3207
3208 for (j=0; j < 256; j++) {
3209
3210 if (NewLUT -> wFlags & LUT_HASTL1)
3211 val = (BYTE) floor(NewLUT ->L1[i][j] / 257.0 + .5);
3212 else
3213 val = (BYTE) j;
3214
3215 Icc ->Write(Icc, 1, &val);
3216 }
3217
3218 }
3219
3220
3221 nTabSize = (NewLUT -> OutputChan * uipow(NewLUT->cLutPoints,
3222 NewLUT->InputChan));
3223 // The 3D CLUT.
3224
3225 for (j=0; j < nTabSize; j++) {
3226
3227 val = (BYTE) floor(NewLUT ->T[j] / 257.0 + .5);
3228 Icc ->Write(Icc, 1, &val);
3229 }
3230
3231 // The postlinearization table
3232
3233 for (i=0; i < NewLUT -> OutputChan; i++) {
3234
3235 for (j=0; j < 256; j++) {
3236
3237 if (NewLUT -> wFlags & LUT_HASTL2)
3238 val = (BYTE) floor(NewLUT ->L2[i][j] / 257.0 + .5);
3239 else
3240 val = (BYTE) j;
3241
3242 Icc ->Write(Icc, 1, &val);
3243 }
3244
3245 }
3246
3247 return TRUE;
3248 }
3249
3250
3251
3252 // Set the LUT bitdepth to be saved
3253
3254 void LCMSEXPORT _cmsSetLUTdepth(cmsHPROFILE hProfile, int depth)
3255 {
3256 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
3257
3258 switch (depth) {
3259
3260 case 8: Icc ->SaveAs8Bits = TRUE; break;
3261 case 16: Icc ->SaveAs8Bits = FALSE; break;
3262
3263 default:
3264 cmsSignalError(LCMS_ERRC_ABORTED, "%d is an unsupported as bitdepth, use 8 or 16 only.", depth);
3265 }
3266 }
3267
3268
3269 // Saves Tag directory
3270
3271 static
3272 LCMSBOOL SaveTagDirectory(LPLCMSICCPROFILE Icc)
3273 {
3274 icInt32Number i;
3275 icTag Tag;
3276 icInt32Number Count = 0;
3277
3278 // Get true count
3279 for (i=0; i < Icc -> TagCount; i++) {
3280 if (Icc ->TagNames[i] != 0)
3281 Count++;
3282 }
3283
3284 Count = TransportValue32(Count);
3285 if (!Icc ->Write(Icc, sizeof(icInt32Number) , &Count)) return FALSE;
3286
3287 for (i=0; i < Icc -> TagCount; i++) {
3288
3289 if (Icc ->TagNames[i] == 0) continue;
3290
3291 Tag.sig = (icTagSignature)TransportValue32(Icc -> TagNames[i]);
3292 Tag.offset = TransportValue32((icInt32Number) Icc -> TagOffsets[i]);
3293 Tag.size = TransportValue32((icInt32Number) Icc -> TagSizes[i]);
3294
3295 if (!Icc ->Write(Icc, sizeof(icTag), &Tag)) return FALSE;
3296 }
3297
3298 return TRUE;
3299 }
3300
3301
3302 // Dump tag contents
3303
3304 static
3305 LCMSBOOL SaveTags(LPLCMSICCPROFILE Icc, LPLCMSICCPROFILE FileOrig)
3306 {
3307
3308 LPBYTE Data;
3309 icInt32Number i;
3310 size_t Begin;
3311 size_t AlignedSpace, FillerSize;
3312
3313
3314 for (i=0; i < Icc -> TagCount; i++) {
3315
3316 if (Icc ->TagNames[i] == 0) continue;
3317
3318 // Align to DWORD boundary, following new spec.
3319
3320 AlignedSpace = ALIGNLONG(Icc ->UsedSpace);
3321 FillerSize = AlignedSpace - Icc ->UsedSpace;
3322 if (FillerSize > 0) {
3323
3324 BYTE Filler[20];
3325
3326 ZeroMemory(Filler, 16);
3327 if (!Icc ->Write(Icc, FillerSize, Filler)) return FALSE;
3328 }
3329
3330
3331 Icc -> TagOffsets[i] = Begin = Icc ->UsedSpace;
3332 Data = (LPBYTE) Icc -> TagPtrs[i];
3333 if (!Data) {
3334
3335 // Reach here if we are copying a tag from a disk-based ICC profile which has not been modified by user.
3336 // In this case a blind copy of the block data is performed
3337
3338 if (Icc -> TagOffsets[i]) {
3339
3340 size_t TagSize = FileOrig -> TagSizes[i];
3341 size_t TagOffset = FileOrig -> TagOffsets[i];
3342 void* Mem;
3343
3344 if (FileOrig ->Seek(FileOrig, TagOffset)) return FALSE;
3345
3346 Mem = _cmsMalloc(TagSize);
3347
3348 if (FileOrig ->Read(Mem, TagSize, 1, FileOrig) != 1) return FALSE;
3349 if (!Icc ->Write(Icc, TagSize, Mem)) return FALSE;
3350
3351 Icc -> TagSizes[i] = (Icc ->UsedSpace - Begin);
3352 free(Mem);
3353 }
3354
3355 continue;
3356 }
3357
3358
3359 switch (Icc -> TagNames[i]) {
3360
3361 case icSigProfileDescriptionTag:
3362 case icSigDeviceMfgDescTag:
3363 case icSigDeviceModelDescTag:
3364 if (!SaveDescription((const char *) Data, Icc)) return FALSE;
3365 break;
3366
3367 case icSigRedColorantTag:
3368 case icSigGreenColorantTag:
3369 case icSigBlueColorantTag:
3370 case icSigMediaWhitePointTag:
3371 case icSigMediaBlackPointTag:
3372 if (!SaveXYZNumber((LPcmsCIEXYZ) Data, Icc)) return FALSE;
3373 break;
3374
3375
3376 case icSigRedTRCTag:
3377 case icSigGreenTRCTag:
3378 case icSigBlueTRCTag:
3379 case icSigGrayTRCTag:
3380 if (!SaveGamma((LPGAMMATABLE) Data, Icc)) return FALSE;
3381 break;
3382
3383 case icSigCharTargetTag:
3384 case icSigCopyrightTag:
3385 if (!SaveText((const char *) Data, Icc)) return FALSE;
3386 break;
3387
3388 case icSigChromaticityTag:
3389 if (!SaveChromaticities((LPcmsCIExyYTRIPLE) Data, Icc)) return FALSE;
3390 break;
3391
3392 // Save LUT
3393
3394 case icSigAToB0Tag:
3395 case icSigAToB1Tag:
3396 case icSigAToB2Tag:
3397 case icSigBToA0Tag:
3398 case icSigBToA1Tag:
3399 case icSigBToA2Tag:
3400 case icSigGamutTag:
3401 case icSigPreview0Tag:
3402 case icSigPreview1Tag:
3403 case icSigPreview2Tag:
3404
3405 if (Icc ->SaveAs8Bits) {
3406
3407 if (!SaveLUT8((LPLUT) Data, Icc)) return FALSE;
3408 }
3409 else {
3410
3411 if (!SaveLUT((LPLUT) Data, Icc)) return FALSE;
3412 }
3413 break;
3414
3415 case icSigProfileSequenceDescTag:
3416 if (!SaveSequenceDescriptionTag((LPcmsSEQ) Data, Icc)) return FALSE;
3417 break;
3418
3419
3420 case icSigNamedColor2Tag:
3421 if (!SaveNamedColorList((LPcmsNAMEDCOLORLIST) Data, Icc)) return FALSE;
3422 break;
3423
3424
3425 case icSigCalibrationDateTimeTag:
3426 if (!SaveDateTimeNumber((struct tm *) Data, Icc)) return FALSE;
3427 break;
3428
3429
3430 case icSigColorantTableTag:
3431 case icSigColorantTableOutTag:
3432 if (!SaveColorantTable((LPcmsNAMEDCOLORLIST) Data, Icc)) return FALSE;
3433 break;
3434
3435
3436 case icSigChromaticAdaptationTag:
3437 if (!SaveXYZArray(3, (LPcmsCIEXYZ) Data, Icc)) return FALSE;
3438 break;
3439
3440 default:
3441 return FALSE;
3442 }
3443
3444 Icc -> TagSizes[i] = (Icc ->UsedSpace - Begin);
3445 }
3446
3447
3448
3449 return TRUE;
3450 }
3451
3452
3453
3454 // Add tags to profile structure
3455
3456 LCMSBOOL LCMSEXPORT cmsAddTag(cmsHPROFILE hProfile, icTagSignature sig, const void* Tag)
3457 {
3458 LCMSBOOL rc;
3459
3460 switch (sig) {
3461
3462 case icSigCharTargetTag:
3463 case icSigCopyrightTag:
3464 case icSigProfileDescriptionTag:
3465 case icSigDeviceMfgDescTag:
3466 case icSigDeviceModelDescTag:
3467 rc = _cmsAddTextTag(hProfile, sig, (const char*) Tag);
3468 break;
3469
3470 case icSigRedColorantTag:
3471 case icSigGreenColorantTag:
3472 case icSigBlueColorantTag:
3473 case icSigMediaWhitePointTag:
3474 case icSigMediaBlackPointTag:
3475 rc = _cmsAddXYZTag(hProfile, sig, (const cmsCIEXYZ*) Tag);
3476 break;
3477
3478 case icSigRedTRCTag:
3479 case icSigGreenTRCTag:
3480 case icSigBlueTRCTag:
3481 case icSigGrayTRCTag:
3482 rc = _cmsAddGammaTag(hProfile, sig, (LPGAMMATABLE) Tag);
3483 break;
3484
3485 case icSigAToB0Tag:
3486 case icSigAToB1Tag:
3487 case icSigAToB2Tag:
3488 case icSigBToA0Tag:
3489 case icSigBToA1Tag:
3490 case icSigBToA2Tag:
3491 case icSigGamutTag:
3492 case icSigPreview0Tag:
3493 case icSigPreview1Tag:
3494 case icSigPreview2Tag:
3495 rc = _cmsAddLUTTag(hProfile, sig, Tag);
3496 break;
3497
3498 case icSigChromaticityTag:
3499 rc = _cmsAddChromaticityTag(hProfile, sig, (LPcmsCIExyYTRIPLE) Tag);
3500 break;
3501
3502 case icSigProfileSequenceDescTag:
3503 rc = _cmsAddSequenceDescriptionTag(hProfile, sig, (LPcmsSEQ) Tag);
3504 break;
3505
3506 case icSigNamedColor2Tag:
3507 rc = _cmsAddNamedColorTag(hProfile, sig, (LPcmsNAMEDCOLORLIST) Tag);
3508 break;
3509
3510 case icSigCalibrationDateTimeTag:
3511 rc = _cmsAddDateTimeTag(hProfile, sig, (struct tm*) Tag);
3512 break;
3513
3514 case icSigColorantTableTag:
3515 case icSigColorantTableOutTag:
3516 rc = _cmsAddColorantTableTag(hProfile, sig, (LPcmsNAMEDCOLORLIST) Tag);
3517 break;
3518
3519
3520 case icSigChromaticAdaptationTag:
3521 rc = _cmsAddChromaticAdaptationTag(hProfile, sig, (const cmsCIEXYZ*) Tag);
3522 break;
3523
3524 default:
3525 cmsSignalError(LCMS_ERRC_ABORTED, "cmsAddTag: Tag '%x' is unsupported", sig);
3526 return FALSE;
3527 }
3528
3529 // Check for critical tags
3530
3531 switch (sig) {
3532
3533 case icSigMediaWhitePointTag:
3534 case icSigMediaBlackPointTag:
3535 case icSigChromaticAdaptationTag:
3536
3537 ReadCriticalTags((LPLCMSICCPROFILE) hProfile);
3538 break;
3539
3540 default:;
3541 }
3542
3543 return rc;
3544
3545 }
3546
3547 // Low-level save to disk. It closes the profile on exit
3548
3549 LCMSBOOL LCMSEXPORT _cmsSaveProfile(cmsHPROFILE hProfile, const char* FileName)
3550 {
3551 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
3552 LCMSICCPROFILE Keep;
3553 LCMSBOOL rc;
3554
3555 CopyMemory(&Keep, Icc, sizeof(LCMSICCPROFILE));
3556 _cmsSetSaveToDisk(Icc, NULL);
3557
3558 // Pass #1 does compute offsets
3559
3560 if (!SaveHeader(Icc)) return FALSE;
3561 if (!SaveTagDirectory(Icc)) return FALSE;
3562 if (!SaveTags(Icc, &Keep)) return FALSE;
3563
3564
3565 _cmsSetSaveToDisk(Icc, FileName);
3566
3567
3568 // Pass #2 does save to file
3569
3570 if (!SaveHeader(Icc)) goto CleanUp;
3571 if (!SaveTagDirectory(Icc)) goto CleanUp;
3572 if (!SaveTags(Icc, &Keep)) goto CleanUp;
3573
3574 rc = (Icc ->Close(Icc) == 0);
3575 CopyMemory(Icc, &Keep, sizeof(LCMSICCPROFILE));
3576 return rc;
3577
3578
3579 CleanUp:
3580
3581 Icc ->Close(Icc);
3582 unlink(FileName);
3583 CopyMemory(Icc, &Keep, sizeof(LCMSICCPROFILE));
3584 return FALSE;
3585 }
3586
3587
3588 // Low-level save from open stream
3589 LCMSBOOL LCMSEXPORT _cmsSaveProfileToMem(cmsHPROFILE hProfile, void *MemPtr,
3590 size_t* BytesNeeded)
3591 {
3592 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
3593 LCMSICCPROFILE Keep;
3594
3595
3596 CopyMemory(&Keep, Icc, sizeof(LCMSICCPROFILE));
3597
3598 _cmsSetSaveToMemory(Icc, NULL, 0);
3599
3600 // Pass #1 does compute offsets
3601
3602 if (!SaveHeader(Icc)) return FALSE;
3603 if (!SaveTagDirectory(Icc)) return FALSE;
3604 if (!SaveTags(Icc, &Keep)) return FALSE;
3605
3606 if (!MemPtr) {
3607
3608 // update BytesSaved so caller knows how many bytes are needed for MemPtr
3609 *BytesNeeded = Icc ->UsedSpace;
3610 CopyMemory(Icc, &Keep, sizeof(LCMSICCPROFILE));
3611 return TRUE;
3612 }
3613
3614 if (*BytesNeeded < Icc ->UsedSpace) {
3615
3616 // need at least UsedSpace in MemPtr to continue
3617 CopyMemory(Icc, &Keep, sizeof(LCMSICCPROFILE));
3618 return FALSE;
3619 }
3620
3621 _cmsSetSaveToMemory(Icc, MemPtr, *BytesNeeded);
3622
3623
3624 // Pass #2 does save to file into supplied stream
3625 if (!SaveHeader(Icc)) goto CleanUp;
3626 if (!SaveTagDirectory(Icc)) goto CleanUp;
3627 if (!SaveTags(Icc, &Keep)) goto CleanUp;
3628
3629 // update BytesSaved so caller knows how many bytes put into stream
3630 *BytesNeeded = Icc ->UsedSpace;
3631
3632 Icc ->Close(Icc);
3633 CopyMemory(Icc, &Keep, sizeof(LCMSICCPROFILE));
3634 return TRUE;
3635
3636 CleanUp:
3637
3638 Icc ->Close(Icc);
3639 CopyMemory(Icc, &Keep, sizeof(LCMSICCPROFILE));
3640 return FALSE;
3641 }
3642
Wine Gecko package