1/*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25// This file is available under and governed by the GNU General Public
26// License version 2 only, as published by the Free Software Foundation.
27// However, the following notice accompanied the original version of this
28// file:
29//
30//---------------------------------------------------------------------------------
31//
32// Little Color Management System
33// Copyright (c) 1998-2017 Marti Maria Saguer
34//
35// Permission is hereby granted, free of charge, to any person obtaining
36// a copy of this software and associated documentation files (the "Software"),
37// to deal in the Software without restriction, including without limitation
38// the rights to use, copy, modify, merge, publish, distribute, sublicense,
39// and/or sell copies of the Software, and to permit persons to whom the Software
40// is furnished to do so, subject to the following conditions:
41//
42// The above copyright notice and this permission notice shall be included in
43// all copies or substantial portions of the Software.
44//
45// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
46// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
47// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
48// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
49// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
50// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
51// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
52//
53//---------------------------------------------------------------------------------
54//
55
56#include "lcms2_internal.h"
57
58// Generic I/O, tag dictionary management, profile struct
59
60// IOhandlers are abstractions used by littleCMS to read from whatever file, stream,
61// memory block or any storage. Each IOhandler provides implementations for read,
62// write, seek and tell functions. LittleCMS code deals with IO across those objects.
63// In this way, is easier to add support for new storage media.
64
65// NULL stream, for taking care of used space -------------------------------------
66
67// NULL IOhandler basically does nothing but keep track on how many bytes have been
68// written. This is handy when creating profiles, where the file size is needed in the
69// header. Then, whole profile is serialized across NULL IOhandler and a second pass
70// writes the bytes to the pertinent IOhandler.
71
72typedef struct {
73 cmsUInt32Number Pointer; // Points to current location
74} FILENULL;
75
76static
77cmsUInt32Number NULLRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
78{
79 FILENULL* ResData = (FILENULL*) iohandler ->stream;
80
81 cmsUInt32Number len = size * count;
82 ResData -> Pointer += len;
83 return count;
84
85 cmsUNUSED_PARAMETER(Buffer);
86}
87
88static
89cmsBool NULLSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)
90{
91 FILENULL* ResData = (FILENULL*) iohandler ->stream;
92
93 ResData ->Pointer = offset;
94 return TRUE;
95}
96
97static
98cmsUInt32Number NULLTell(cmsIOHANDLER* iohandler)
99{
100 FILENULL* ResData = (FILENULL*) iohandler ->stream;
101 return ResData -> Pointer;
102}
103
104static
105cmsBool NULLWrite(cmsIOHANDLER* iohandler, cmsUInt32Number size, const void *Ptr)
106{
107 FILENULL* ResData = (FILENULL*) iohandler ->stream;
108
109 ResData ->Pointer += size;
110 if (ResData ->Pointer > iohandler->UsedSpace)
111 iohandler->UsedSpace = ResData ->Pointer;
112
113 return TRUE;
114
115 cmsUNUSED_PARAMETER(Ptr);
116}
117
118static
119cmsBool NULLClose(cmsIOHANDLER* iohandler)
120{
121 FILENULL* ResData = (FILENULL*) iohandler ->stream;
122
123 _cmsFree(iohandler ->ContextID, ResData);
124 _cmsFree(iohandler ->ContextID, iohandler);
125 return TRUE;
126}
127
128// The NULL IOhandler creator
129cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromNULL(cmsContext ContextID)
130{
131 struct _cms_io_handler* iohandler = NULL;
132 FILENULL* fm = NULL;
133
134 iohandler = (struct _cms_io_handler*) _cmsMallocZero(ContextID, sizeof(struct _cms_io_handler));
135 if (iohandler == NULL) return NULL;
136
137 fm = (FILENULL*) _cmsMallocZero(ContextID, sizeof(FILENULL));
138 if (fm == NULL) goto Error;
139
140 fm ->Pointer = 0;
141
142 iohandler ->ContextID = ContextID;
143 iohandler ->stream = (void*) fm;
144 iohandler ->UsedSpace = 0;
145 iohandler ->ReportedSize = 0;
146 iohandler ->PhysicalFile[0] = 0;
147
148 iohandler ->Read = NULLRead;
149 iohandler ->Seek = NULLSeek;
150 iohandler ->Close = NULLClose;
151 iohandler ->Tell = NULLTell;
152 iohandler ->Write = NULLWrite;
153
154 return iohandler;
155
156Error:
157 if (iohandler) _cmsFree(ContextID, iohandler);
158 return NULL;
159
160}
161
162
163// Memory-based stream --------------------------------------------------------------
164
165// Those functions implements an iohandler which takes a block of memory as storage medium.
166
167typedef struct {
168 cmsUInt8Number* Block; // Points to allocated memory
169 cmsUInt32Number Size; // Size of allocated memory
170 cmsUInt32Number Pointer; // Points to current location
171 int FreeBlockOnClose; // As title
172
173} FILEMEM;
174
175static
176cmsUInt32Number MemoryRead(struct _cms_io_handler* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
177{
178 FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
179 cmsUInt8Number* Ptr;
180 cmsUInt32Number len = size * count;
181
182 if (ResData -> Pointer + len > ResData -> Size){
183
184 len = (ResData -> Size - ResData -> Pointer);
185 cmsSignalError(iohandler ->ContextID, cmsERROR_READ, "Read from memory error. Got %d bytes, block should be of %d bytes", len, count * size);
186 return 0;
187 }
188
189 Ptr = ResData -> Block;
190 Ptr += ResData -> Pointer;
191 memmove(Buffer, Ptr, len);
192 ResData -> Pointer += len;
193
194 return count;
195}
196
197// SEEK_CUR is assumed
198static
199cmsBool MemorySeek(struct _cms_io_handler* iohandler, cmsUInt32Number offset)
200{
201 FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
202
203 if (offset > ResData ->Size) {
204 cmsSignalError(iohandler ->ContextID, cmsERROR_SEEK, "Too few data; probably corrupted profile");
205 return FALSE;
206 }
207
208 ResData ->Pointer = offset;
209 return TRUE;
210}
211
212// Tell for memory
213static
214cmsUInt32Number MemoryTell(struct _cms_io_handler* iohandler)
215{
216 FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
217
218 if (ResData == NULL) return 0;
219 return ResData -> Pointer;
220}
221
222
223// Writes data to memory, also keeps used space for further reference.
224static
225cmsBool MemoryWrite(struct _cms_io_handler* iohandler, cmsUInt32Number size, const void *Ptr)
226{
227 FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
228
229 if (ResData == NULL) return FALSE; // Housekeeping
230
231 // Check for available space. Clip.
232 if (ResData->Pointer + size > ResData->Size) {
233 size = ResData ->Size - ResData->Pointer;
234 }
235
236 if (size == 0) return TRUE; // Write zero bytes is ok, but does nothing
237
238 memmove(ResData ->Block + ResData ->Pointer, Ptr, size);
239 ResData ->Pointer += size;
240
241 if (ResData ->Pointer > iohandler->UsedSpace)
242 iohandler->UsedSpace = ResData ->Pointer;
243
244 return TRUE;
245}
246
247
248static
249cmsBool MemoryClose(struct _cms_io_handler* iohandler)
250{
251 FILEMEM* ResData = (FILEMEM*) iohandler ->stream;
252
253 if (ResData ->FreeBlockOnClose) {
254
255 if (ResData ->Block) _cmsFree(iohandler ->ContextID, ResData ->Block);
256 }
257
258 _cmsFree(iohandler ->ContextID, ResData);
259 _cmsFree(iohandler ->ContextID, iohandler);
260
261 return TRUE;
262}
263
264// Create a iohandler for memory block. AccessMode=='r' assumes the iohandler is going to read, and makes
265// a copy of the memory block for letting user to free the memory after invoking open profile. In write
266// mode ("w"), Buffere points to the begin of memory block to be written.
267cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromMem(cmsContext ContextID, void *Buffer, cmsUInt32Number size, const char* AccessMode)
268{
269 cmsIOHANDLER* iohandler = NULL;
270 FILEMEM* fm = NULL;
271
272 _cmsAssert(AccessMode != NULL);
273
274 iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
275 if (iohandler == NULL) return NULL;
276
277 switch (*AccessMode) {
278
279 case 'r':
280 fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));
281 if (fm == NULL) goto Error;
282
283 if (Buffer == NULL) {
284 cmsSignalError(ContextID, cmsERROR_READ, "Couldn't read profile from NULL pointer");
285 goto Error;
286 }
287
288 fm ->Block = (cmsUInt8Number*) _cmsMalloc(ContextID, size);
289 if (fm ->Block == NULL) {
290
291 _cmsFree(ContextID, fm);
292 _cmsFree(ContextID, iohandler);
293 cmsSignalError(ContextID, cmsERROR_READ, "Couldn't allocate %ld bytes for profile", size);
294 return NULL;
295 }
296
297
298 memmove(fm->Block, Buffer, size);
299 fm ->FreeBlockOnClose = TRUE;
300 fm ->Size = size;
301 fm ->Pointer = 0;
302 iohandler -> ReportedSize = size;
303 break;
304
305 case 'w':
306 fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));
307 if (fm == NULL) goto Error;
308
309 fm ->Block = (cmsUInt8Number*) Buffer;
310 fm ->FreeBlockOnClose = FALSE;
311 fm ->Size = size;
312 fm ->Pointer = 0;
313 iohandler -> ReportedSize = 0;
314 break;
315
316 default:
317 cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown access mode '%c'", *AccessMode);
318 return NULL;
319 }
320
321 iohandler ->ContextID = ContextID;
322 iohandler ->stream = (void*) fm;
323 iohandler ->UsedSpace = 0;
324 iohandler ->PhysicalFile[0] = 0;
325
326 iohandler ->Read = MemoryRead;
327 iohandler ->Seek = MemorySeek;
328 iohandler ->Close = MemoryClose;
329 iohandler ->Tell = MemoryTell;
330 iohandler ->Write = MemoryWrite;
331
332 return iohandler;
333
334Error:
335 if (fm) _cmsFree(ContextID, fm);
336 if (iohandler) _cmsFree(ContextID, iohandler);
337 return NULL;
338}
339
340// File-based stream -------------------------------------------------------
341
342// Read count elements of size bytes each. Return number of elements read
343static
344cmsUInt32Number FileRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)
345{
346 cmsUInt32Number nReaded = (cmsUInt32Number) fread(Buffer, size, count, (FILE*) iohandler->stream);
347
348 if (nReaded != count) {
349 cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Read error. Got %d bytes, block should be of %d bytes", nReaded * size, count * size);
350 return 0;
351 }
352
353 return nReaded;
354}
355
356// Position file pointer in the file
357static
358cmsBool FileSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)
359{
360 if (fseek((FILE*) iohandler ->stream, (long) offset, SEEK_SET) != 0) {
361
362 cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Seek error; probably corrupted file");
363 return FALSE;
364 }
365
366 return TRUE;
367}
368
369// Returns file pointer position or 0 on error, which is also a valid position.
370static
371cmsUInt32Number FileTell(cmsIOHANDLER* iohandler)
372{
373 long t = ftell((FILE*)iohandler ->stream);
374 if (t == -1L) {
375 cmsSignalError(iohandler->ContextID, cmsERROR_FILE, "Tell error; probably corrupted file");
376 return 0;
377 }
378
379 return (cmsUInt32Number)t;
380}
381
382// Writes data to stream, also keeps used space for further reference. Returns TRUE on success, FALSE on error
383static
384cmsBool FileWrite(cmsIOHANDLER* iohandler, cmsUInt32Number size, const void* Buffer)
385{
386 if (size == 0) return TRUE; // We allow to write 0 bytes, but nothing is written
387
388 iohandler->UsedSpace += size;
389 return (fwrite(Buffer, size, 1, (FILE*)iohandler->stream) == 1);
390}
391
392// Closes the file
393static
394cmsBool FileClose(cmsIOHANDLER* iohandler)
395{
396 if (fclose((FILE*) iohandler ->stream) != 0) return FALSE;
397 _cmsFree(iohandler ->ContextID, iohandler);
398 return TRUE;
399}
400
401// Create a iohandler for disk based files.
402cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const char* FileName, const char* AccessMode)
403{
404 cmsIOHANDLER* iohandler = NULL;
405 FILE* fm = NULL;
406 cmsInt32Number fileLen;
407
408 _cmsAssert(FileName != NULL);
409 _cmsAssert(AccessMode != NULL);
410
411 iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
412 if (iohandler == NULL) return NULL;
413
414 switch (*AccessMode) {
415
416 case 'r':
417 fm = fopen(FileName, "rb");
418 if (fm == NULL) {
419 _cmsFree(ContextID, iohandler);
420 cmsSignalError(ContextID, cmsERROR_FILE, "File '%s' not found", FileName);
421 return NULL;
422 }
423 fileLen = cmsfilelength(fm);
424 if (fileLen < 0)
425 {
426 fclose(fm);
427 _cmsFree(ContextID, iohandler);
428 cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of file '%s'", FileName);
429 return NULL;
430 }
431
432 iohandler -> ReportedSize = (cmsUInt32Number) fileLen;
433 break;
434
435 case 'w':
436 fm = fopen(FileName, "wb");
437 if (fm == NULL) {
438 _cmsFree(ContextID, iohandler);
439 cmsSignalError(ContextID, cmsERROR_FILE, "Couldn't create '%s'", FileName);
440 return NULL;
441 }
442 iohandler -> ReportedSize = 0;
443 break;
444
445 default:
446 _cmsFree(ContextID, iohandler);
447 cmsSignalError(ContextID, cmsERROR_FILE, "Unknown access mode '%c'", *AccessMode);
448 return NULL;
449 }
450
451 iohandler ->ContextID = ContextID;
452 iohandler ->stream = (void*) fm;
453 iohandler ->UsedSpace = 0;
454
455 // Keep track of the original file
456 strncpy(iohandler -> PhysicalFile, FileName, sizeof(iohandler -> PhysicalFile)-1);
457 iohandler -> PhysicalFile[sizeof(iohandler -> PhysicalFile)-1] = 0;
458
459 iohandler ->Read = FileRead;
460 iohandler ->Seek = FileSeek;
461 iohandler ->Close = FileClose;
462 iohandler ->Tell = FileTell;
463 iohandler ->Write = FileWrite;
464
465 return iohandler;
466}
467
468// Create a iohandler for stream based files
469cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromStream(cmsContext ContextID, FILE* Stream)
470{
471 cmsIOHANDLER* iohandler = NULL;
472 cmsInt32Number fileSize;
473
474 fileSize = cmsfilelength(Stream);
475 if (fileSize < 0)
476 {
477 cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of stream");
478 return NULL;
479 }
480
481 iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
482 if (iohandler == NULL) return NULL;
483
484 iohandler -> ContextID = ContextID;
485 iohandler -> stream = (void*) Stream;
486 iohandler -> UsedSpace = 0;
487 iohandler -> ReportedSize = (cmsUInt32Number) fileSize;
488 iohandler -> PhysicalFile[0] = 0;
489
490 iohandler ->Read = FileRead;
491 iohandler ->Seek = FileSeek;
492 iohandler ->Close = FileClose;
493 iohandler ->Tell = FileTell;
494 iohandler ->Write = FileWrite;
495
496 return iohandler;
497}
498
499
500
501// Close an open IO handler
502cmsBool CMSEXPORT cmsCloseIOhandler(cmsIOHANDLER* io)
503{
504 return io -> Close(io);
505}
506
507// -------------------------------------------------------------------------------------------------------
508
509cmsIOHANDLER* CMSEXPORT cmsGetProfileIOhandler(cmsHPROFILE hProfile)
510{
511 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*)hProfile;
512
513 if (Icc == NULL) return NULL;
514 return Icc->IOhandler;
515}
516
517// Creates an empty structure holding all required parameters
518cmsHPROFILE CMSEXPORT cmsCreateProfilePlaceholder(cmsContext ContextID)
519{
520 time_t now = time(NULL);
521 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) _cmsMallocZero(ContextID, sizeof(_cmsICCPROFILE));
522 if (Icc == NULL) return NULL;
523
524 Icc ->ContextID = ContextID;
525
526 // Set it to empty
527 Icc -> TagCount = 0;
528
529 // Set default version
530 Icc ->Version = 0x02100000;
531
532 // Set creation date/time
533 memmove(&Icc ->Created, gmtime(&now), sizeof(Icc ->Created));
534
535 // Create a mutex if the user provided proper plugin. NULL otherwise
536 Icc ->UsrMutex = _cmsCreateMutex(ContextID);
537
538 // Return the handle
539 return (cmsHPROFILE) Icc;
540}
541
542cmsContext CMSEXPORT cmsGetProfileContextID(cmsHPROFILE hProfile)
543{
544 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
545
546 if (Icc == NULL) return NULL;
547 return Icc -> ContextID;
548}
549
550
551// Return the number of tags
552cmsInt32Number CMSEXPORT cmsGetTagCount(cmsHPROFILE hProfile)
553{
554 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
555 if (Icc == NULL) return -1;
556
557 return (cmsInt32Number) Icc->TagCount;
558}
559
560// Return the tag signature of a given tag number
561cmsTagSignature CMSEXPORT cmsGetTagSignature(cmsHPROFILE hProfile, cmsUInt32Number n)
562{
563 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
564
565 if (n > Icc->TagCount) return (cmsTagSignature) 0; // Mark as not available
566 if (n >= MAX_TABLE_TAG) return (cmsTagSignature) 0; // As double check
567
568 return Icc ->TagNames[n];
569}
570
571
572static
573int SearchOneTag(_cmsICCPROFILE* Profile, cmsTagSignature sig)
574{
575 int i;
576
577 for (i=0; i < (int) Profile -> TagCount; i++) {
578
579 if (sig == Profile -> TagNames[i])
580 return i;
581 }
582
583 return -1;
584}
585
586// Search for a specific tag in tag dictionary. Returns position or -1 if tag not found.
587// If followlinks is turned on, then the position of the linked tag is returned
588int _cmsSearchTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, cmsBool lFollowLinks)
589{
590 int n;
591 cmsTagSignature LinkedSig;
592
593 do {
594
595 // Search for given tag in ICC profile directory
596 n = SearchOneTag(Icc, sig);
597 if (n < 0)
598 return -1; // Not found
599
600 if (!lFollowLinks)
601 return n; // Found, don't follow links
602
603 // Is this a linked tag?
604 LinkedSig = Icc ->TagLinked[n];
605
606 // Yes, follow link
607 if (LinkedSig != (cmsTagSignature) 0) {
608 sig = LinkedSig;
609 }
610
611 } while (LinkedSig != (cmsTagSignature) 0);
612
613 return n;
614}
615
616// Deletes a tag entry
617
618static
619void _cmsDeleteTagByPos(_cmsICCPROFILE* Icc, int i)
620{
621 _cmsAssert(Icc != NULL);
622 _cmsAssert(i >= 0);
623
624
625 if (Icc -> TagPtrs[i] != NULL) {
626
627 // Free previous version
628 if (Icc ->TagSaveAsRaw[i]) {
629 _cmsFree(Icc ->ContextID, Icc ->TagPtrs[i]);
630 }
631 else {
632 cmsTagTypeHandler* TypeHandler = Icc ->TagTypeHandlers[i];
633
634 if (TypeHandler != NULL) {
635
636 cmsTagTypeHandler LocalTypeHandler = *TypeHandler;
637 LocalTypeHandler.ContextID = Icc ->ContextID; // As an additional parameter
638 LocalTypeHandler.ICCVersion = Icc ->Version;
639 LocalTypeHandler.FreePtr(&LocalTypeHandler, Icc -> TagPtrs[i]);
640 Icc ->TagPtrs[i] = NULL;
641 }
642 }
643
644 }
645}
646
647
648// Creates a new tag entry
649static
650cmsBool _cmsNewTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, int* NewPos)
651{
652 int i;
653
654 // Search for the tag
655 i = _cmsSearchTag(Icc, sig, FALSE);
656 if (i >= 0) {
657
658 // Already exists? delete it
659 _cmsDeleteTagByPos(Icc, i);
660 *NewPos = i;
661 }
662 else {
663
664 // No, make a new one
665
666 if (Icc -> TagCount >= MAX_TABLE_TAG) {
667 cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", MAX_TABLE_TAG);
668 return FALSE;
669 }
670
671 *NewPos = (int) Icc ->TagCount;
672 Icc -> TagCount++;
673 }
674
675 return TRUE;
676}
677
678
679// Check existence
680cmsBool CMSEXPORT cmsIsTag(cmsHPROFILE hProfile, cmsTagSignature sig)
681{
682 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) (void*) hProfile;
683 return _cmsSearchTag(Icc, sig, FALSE) >= 0;
684}
685
686
687
688// Enforces that the profile version is per. spec.
689// Operates on the big endian bytes from the profile.
690// Called before converting to platform endianness.
691// Byte 0 is BCD major version, so max 9.
692// Byte 1 is 2 BCD digits, one per nibble.
693// Reserved bytes 2 & 3 must be 0.
694static
695cmsUInt32Number _validatedVersion(cmsUInt32Number DWord)
696{
697 cmsUInt8Number* pByte = (cmsUInt8Number*) &DWord;
698 cmsUInt8Number temp1;
699 cmsUInt8Number temp2;
700
701 if (*pByte > 0x09) *pByte = (cmsUInt8Number) 0x09;
702 temp1 = (cmsUInt8Number) (*(pByte+1) & 0xf0);
703 temp2 = (cmsUInt8Number) (*(pByte+1) & 0x0f);
704 if (temp1 > 0x90U) temp1 = 0x90U;
705 if (temp2 > 0x09U) temp2 = 0x09U;
706 *(pByte+1) = (cmsUInt8Number)(temp1 | temp2);
707 *(pByte+2) = (cmsUInt8Number)0;
708 *(pByte+3) = (cmsUInt8Number)0;
709
710 return DWord;
711}
712
713// Read profile header and validate it
714cmsBool _cmsReadHeader(_cmsICCPROFILE* Icc)
715{
716 cmsTagEntry Tag;
717 cmsICCHeader Header;
718 cmsUInt32Number i, j;
719 cmsUInt32Number HeaderSize;
720 cmsIOHANDLER* io = Icc ->IOhandler;
721 cmsUInt32Number TagCount;
722
723
724 // Read the header
725 if (io -> Read(io, &Header, sizeof(cmsICCHeader), 1) != 1) {
726 return FALSE;
727 }
728
729 // Validate file as an ICC profile
730 if (_cmsAdjustEndianess32(Header.magic) != cmsMagicNumber) {
731 cmsSignalError(Icc ->ContextID, cmsERROR_BAD_SIGNATURE, "not an ICC profile, invalid signature");
732 return FALSE;
733 }
734
735 // Adjust endianness of the used parameters
736 Icc -> DeviceClass = (cmsProfileClassSignature) _cmsAdjustEndianess32(Header.deviceClass);
737 Icc -> ColorSpace = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Header.colorSpace);
738 Icc -> PCS = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Header.pcs);
739
740 Icc -> RenderingIntent = _cmsAdjustEndianess32(Header.renderingIntent);
741 Icc -> flags = _cmsAdjustEndianess32(Header.flags);
742 Icc -> manufacturer = _cmsAdjustEndianess32(Header.manufacturer);
743 Icc -> model = _cmsAdjustEndianess32(Header.model);
744 Icc -> creator = _cmsAdjustEndianess32(Header.creator);
745
746 _cmsAdjustEndianess64(&Icc -> attributes, &Header.attributes);
747 Icc -> Version = _cmsAdjustEndianess32(_validatedVersion(Header.version));
748
749 // Get size as reported in header
750 HeaderSize = _cmsAdjustEndianess32(Header.size);
751
752 // Make sure HeaderSize is lower than profile size
753 if (HeaderSize >= Icc ->IOhandler ->ReportedSize)
754 HeaderSize = Icc ->IOhandler ->ReportedSize;
755
756
757 // Get creation date/time
758 _cmsDecodeDateTimeNumber(&Header.date, &Icc ->Created);
759
760 // The profile ID are 32 raw bytes
761 memmove(Icc ->ProfileID.ID32, Header.profileID.ID32, 16);
762
763
764 // Read tag directory
765 if (!_cmsReadUInt32Number(io, &TagCount)) return FALSE;
766 if (TagCount > MAX_TABLE_TAG) {
767
768 cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", TagCount);
769 return FALSE;
770 }
771
772
773 // Read tag directory
774 Icc -> TagCount = 0;
775 for (i=0; i < TagCount; i++) {
776
777 if (!_cmsReadUInt32Number(io, (cmsUInt32Number *) &Tag.sig)) return FALSE;
778 if (!_cmsReadUInt32Number(io, &Tag.offset)) return FALSE;
779 if (!_cmsReadUInt32Number(io, &Tag.size)) return FALSE;
780
781 // Perform some sanity check. Offset + size should fall inside file.
782 if (Tag.offset + Tag.size > HeaderSize ||
783 Tag.offset + Tag.size < Tag.offset)
784 continue;
785
786 Icc -> TagNames[Icc ->TagCount] = Tag.sig;
787 Icc -> TagOffsets[Icc ->TagCount] = Tag.offset;
788 Icc -> TagSizes[Icc ->TagCount] = Tag.size;
789
790 // Search for links
791 for (j=0; j < Icc ->TagCount; j++) {
792
793 if ((Icc ->TagOffsets[j] == Tag.offset) &&
794 (Icc ->TagSizes[j] == Tag.size)) {
795
796 Icc ->TagLinked[Icc ->TagCount] = Icc ->TagNames[j];
797 }
798
799 }
800
801 Icc ->TagCount++;
802 }
803
804 return TRUE;
805}
806
807// Saves profile header
808cmsBool _cmsWriteHeader(_cmsICCPROFILE* Icc, cmsUInt32Number UsedSpace)
809{
810 cmsICCHeader Header;
811 cmsUInt32Number i;
812 cmsTagEntry Tag;
813 cmsUInt32Number Count;
814
815 Header.size = _cmsAdjustEndianess32(UsedSpace);
816 Header.cmmId = _cmsAdjustEndianess32(lcmsSignature);
817 Header.version = _cmsAdjustEndianess32(Icc ->Version);
818
819 Header.deviceClass = (cmsProfileClassSignature) _cmsAdjustEndianess32(Icc -> DeviceClass);
820 Header.colorSpace = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Icc -> ColorSpace);
821 Header.pcs = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Icc -> PCS);
822
823 // NOTE: in v4 Timestamp must be in UTC rather than in local time
824 _cmsEncodeDateTimeNumber(&Header.date, &Icc ->Created);
825
826 Header.magic = _cmsAdjustEndianess32(cmsMagicNumber);
827
828#ifdef CMS_IS_WINDOWS_
829 Header.platform = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMicrosoft);
830#else
831 Header.platform = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMacintosh);
832#endif
833
834 Header.flags = _cmsAdjustEndianess32(Icc -> flags);
835 Header.manufacturer = _cmsAdjustEndianess32(Icc -> manufacturer);
836 Header.model = _cmsAdjustEndianess32(Icc -> model);
837
838 _cmsAdjustEndianess64(&Header.attributes, &Icc -> attributes);
839
840 // Rendering intent in the header (for embedded profiles)
841 Header.renderingIntent = _cmsAdjustEndianess32(Icc -> RenderingIntent);
842
843 // Illuminant is always D50
844 Header.illuminant.X = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(cmsD50_XYZ()->X));
845 Header.illuminant.Y = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(cmsD50_XYZ()->Y));
846 Header.illuminant.Z = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(cmsD50_XYZ()->Z));
847
848 // Created by LittleCMS (that's me!)
849 Header.creator = _cmsAdjustEndianess32(lcmsSignature);
850
851 memset(&Header.reserved, 0, sizeof(Header.reserved));
852
853 // Set profile ID. Endianness is always big endian
854 memmove(&Header.profileID, &Icc ->ProfileID, 16);
855
856 // Dump the header
857 if (!Icc -> IOhandler->Write(Icc->IOhandler, sizeof(cmsICCHeader), &Header)) return FALSE;
858
859 // Saves Tag directory
860
861 // Get true count
862 Count = 0;
863 for (i=0; i < Icc -> TagCount; i++) {
864 if (Icc ->TagNames[i] != (cmsTagSignature) 0)
865 Count++;
866 }
867
868 // Store number of tags
869 if (!_cmsWriteUInt32Number(Icc ->IOhandler, Count)) return FALSE;
870
871 for (i=0; i < Icc -> TagCount; i++) {
872
873 if (Icc ->TagNames[i] == (cmsTagSignature) 0) continue; // It is just a placeholder
874
875 Tag.sig = (cmsTagSignature) _cmsAdjustEndianess32((cmsUInt32Number) Icc -> TagNames[i]);
876 Tag.offset = _cmsAdjustEndianess32((cmsUInt32Number) Icc -> TagOffsets[i]);
877 Tag.size = _cmsAdjustEndianess32((cmsUInt32Number) Icc -> TagSizes[i]);
878
879 if (!Icc ->IOhandler -> Write(Icc-> IOhandler, sizeof(cmsTagEntry), &Tag)) return FALSE;
880 }
881
882 return TRUE;
883}
884
885// ----------------------------------------------------------------------- Set/Get several struct members
886
887
888cmsUInt32Number CMSEXPORT cmsGetHeaderRenderingIntent(cmsHPROFILE hProfile)
889{
890 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
891 return Icc -> RenderingIntent;
892}
893
894void CMSEXPORT cmsSetHeaderRenderingIntent(cmsHPROFILE hProfile, cmsUInt32Number RenderingIntent)
895{
896 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
897 Icc -> RenderingIntent = RenderingIntent;
898}
899
900cmsUInt32Number CMSEXPORT cmsGetHeaderFlags(cmsHPROFILE hProfile)
901{
902 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
903 return (cmsUInt32Number) Icc -> flags;
904}
905
906void CMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, cmsUInt32Number Flags)
907{
908 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
909 Icc -> flags = (cmsUInt32Number) Flags;
910}
911
912cmsUInt32Number CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile)
913{
914 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
915 return Icc ->manufacturer;
916}
917
918void CMSEXPORT cmsSetHeaderManufacturer(cmsHPROFILE hProfile, cmsUInt32Number manufacturer)
919{
920 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
921 Icc -> manufacturer = manufacturer;
922}
923
924cmsUInt32Number CMSEXPORT cmsGetHeaderCreator(cmsHPROFILE hProfile)
925{
926 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
927 return Icc ->creator;
928}
929
930cmsUInt32Number CMSEXPORT cmsGetHeaderModel(cmsHPROFILE hProfile)
931{
932 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
933 return Icc ->model;
934}
935
936void CMSEXPORT cmsSetHeaderModel(cmsHPROFILE hProfile, cmsUInt32Number model)
937{
938 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
939 Icc -> model = model;
940}
941
942void CMSEXPORT cmsGetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number* Flags)
943{
944 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
945 memmove(Flags, &Icc -> attributes, sizeof(cmsUInt64Number));
946}
947
948void CMSEXPORT cmsSetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number Flags)
949{
950 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
951 memmove(&Icc -> attributes, &Flags, sizeof(cmsUInt64Number));
952}
953
954void CMSEXPORT cmsGetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)
955{
956 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
957 memmove(ProfileID, Icc ->ProfileID.ID8, 16);
958}
959
960void CMSEXPORT cmsSetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)
961{
962 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
963 memmove(&Icc -> ProfileID, ProfileID, 16);
964}
965
966cmsBool CMSEXPORT cmsGetHeaderCreationDateTime(cmsHPROFILE hProfile, struct tm *Dest)
967{
968 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
969 memmove(Dest, &Icc ->Created, sizeof(struct tm));
970 return TRUE;
971}
972
973cmsColorSpaceSignature CMSEXPORT cmsGetPCS(cmsHPROFILE hProfile)
974{
975 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
976 return Icc -> PCS;
977}
978
979void CMSEXPORT cmsSetPCS(cmsHPROFILE hProfile, cmsColorSpaceSignature pcs)
980{
981 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
982 Icc -> PCS = pcs;
983}
984
985cmsColorSpaceSignature CMSEXPORT cmsGetColorSpace(cmsHPROFILE hProfile)
986{
987 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
988 return Icc -> ColorSpace;
989}
990
991void CMSEXPORT cmsSetColorSpace(cmsHPROFILE hProfile, cmsColorSpaceSignature sig)
992{
993 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
994 Icc -> ColorSpace = sig;
995}
996
997cmsProfileClassSignature CMSEXPORT cmsGetDeviceClass(cmsHPROFILE hProfile)
998{
999 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1000 return Icc -> DeviceClass;
1001}
1002
1003void CMSEXPORT cmsSetDeviceClass(cmsHPROFILE hProfile, cmsProfileClassSignature sig)
1004{
1005 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1006 Icc -> DeviceClass = sig;
1007}
1008
1009cmsUInt32Number CMSEXPORT cmsGetEncodedICCversion(cmsHPROFILE hProfile)
1010{
1011 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1012 return Icc -> Version;
1013}
1014
1015void CMSEXPORT cmsSetEncodedICCversion(cmsHPROFILE hProfile, cmsUInt32Number Version)
1016{
1017 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1018 Icc -> Version = Version;
1019}
1020
1021// Get an hexadecimal number with same digits as v
1022static
1023cmsUInt32Number BaseToBase(cmsUInt32Number in, int BaseIn, int BaseOut)
1024{
1025 char Buff[100];
1026 int i, len;
1027 cmsUInt32Number out;
1028
1029 for (len=0; in > 0 && len < 100; len++) {
1030
1031 Buff[len] = (char) (in % BaseIn);
1032 in /= BaseIn;
1033 }
1034
1035 for (i=len-1, out=0; i >= 0; --i) {
1036 out = out * BaseOut + Buff[i];
1037 }
1038
1039 return out;
1040}
1041
1042void CMSEXPORT cmsSetProfileVersion(cmsHPROFILE hProfile, cmsFloat64Number Version)
1043{
1044 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1045
1046 // 4.2 -> 0x4200000
1047
1048 Icc -> Version = BaseToBase((cmsUInt32Number) floor(Version * 100.0 + 0.5), 10, 16) << 16;
1049}
1050
1051cmsFloat64Number CMSEXPORT cmsGetProfileVersion(cmsHPROFILE hProfile)
1052{
1053 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1054 cmsUInt32Number n = Icc -> Version >> 16;
1055
1056 return BaseToBase(n, 16, 10) / 100.0;
1057}
1058// --------------------------------------------------------------------------------------------------------------
1059
1060
1061// Create profile from IOhandler
1062cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandlerTHR(cmsContext ContextID, cmsIOHANDLER* io)
1063{
1064 _cmsICCPROFILE* NewIcc;
1065 cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1066
1067 if (hEmpty == NULL) return NULL;
1068
1069 NewIcc = (_cmsICCPROFILE*) hEmpty;
1070
1071 NewIcc ->IOhandler = io;
1072 if (!_cmsReadHeader(NewIcc)) goto Error;
1073 return hEmpty;
1074
1075Error:
1076 cmsCloseProfile(hEmpty);
1077 return NULL;
1078}
1079
1080// Create profile from IOhandler
1081cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandler2THR(cmsContext ContextID, cmsIOHANDLER* io, cmsBool write)
1082{
1083 _cmsICCPROFILE* NewIcc;
1084 cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1085
1086 if (hEmpty == NULL) return NULL;
1087
1088 NewIcc = (_cmsICCPROFILE*) hEmpty;
1089
1090 NewIcc ->IOhandler = io;
1091 if (write) {
1092
1093 NewIcc -> IsWrite = TRUE;
1094 return hEmpty;
1095 }
1096
1097 if (!_cmsReadHeader(NewIcc)) goto Error;
1098 return hEmpty;
1099
1100Error:
1101 cmsCloseProfile(hEmpty);
1102 return NULL;
1103}
1104
1105
1106// Create profile from disk file
1107cmsHPROFILE CMSEXPORT cmsOpenProfileFromFileTHR(cmsContext ContextID, const char *lpFileName, const char *sAccess)
1108{
1109 _cmsICCPROFILE* NewIcc;
1110 cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1111
1112 if (hEmpty == NULL) return NULL;
1113
1114 NewIcc = (_cmsICCPROFILE*) hEmpty;
1115
1116 NewIcc ->IOhandler = cmsOpenIOhandlerFromFile(ContextID, lpFileName, sAccess);
1117 if (NewIcc ->IOhandler == NULL) goto Error;
1118
1119 if (*sAccess == 'W' || *sAccess == 'w') {
1120
1121 NewIcc -> IsWrite = TRUE;
1122
1123 return hEmpty;
1124 }
1125
1126 if (!_cmsReadHeader(NewIcc)) goto Error;
1127 return hEmpty;
1128
1129Error:
1130 cmsCloseProfile(hEmpty);
1131 return NULL;
1132}
1133
1134
1135cmsHPROFILE CMSEXPORT cmsOpenProfileFromFile(const char *ICCProfile, const char *sAccess)
1136{
1137 return cmsOpenProfileFromFileTHR(NULL, ICCProfile, sAccess);
1138}
1139
1140
1141cmsHPROFILE CMSEXPORT cmsOpenProfileFromStreamTHR(cmsContext ContextID, FILE* ICCProfile, const char *sAccess)
1142{
1143 _cmsICCPROFILE* NewIcc;
1144 cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);
1145
1146 if (hEmpty == NULL) return NULL;
1147
1148 NewIcc = (_cmsICCPROFILE*) hEmpty;
1149
1150 NewIcc ->IOhandler = cmsOpenIOhandlerFromStream(ContextID, ICCProfile);
1151 if (NewIcc ->IOhandler == NULL) goto Error;
1152
1153 if (*sAccess == 'w') {
1154
1155 NewIcc -> IsWrite = TRUE;
1156 return hEmpty;
1157 }
1158
1159 if (!_cmsReadHeader(NewIcc)) goto Error;
1160 return hEmpty;
1161
1162Error:
1163 cmsCloseProfile(hEmpty);
1164 return NULL;
1165
1166}
1167
1168cmsHPROFILE CMSEXPORT cmsOpenProfileFromStream(FILE* ICCProfile, const char *sAccess)
1169{
1170 return cmsOpenProfileFromStreamTHR(NULL, ICCProfile, sAccess);
1171}
1172
1173
1174// Open from memory block
1175cmsHPROFILE CMSEXPORT cmsOpenProfileFromMemTHR(cmsContext ContextID, const void* MemPtr, cmsUInt32Number dwSize)
1176{
1177 _cmsICCPROFILE* NewIcc;
1178 cmsHPROFILE hEmpty;
1179
1180 hEmpty = cmsCreateProfilePlaceholder(ContextID);
1181 if (hEmpty == NULL) return NULL;
1182
1183 NewIcc = (_cmsICCPROFILE*) hEmpty;
1184
1185 // Ok, in this case const void* is casted to void* just because open IO handler
1186 // shares read and writing modes. Don't abuse this feature!
1187 NewIcc ->IOhandler = cmsOpenIOhandlerFromMem(ContextID, (void*) MemPtr, dwSize, "r");
1188 if (NewIcc ->IOhandler == NULL) goto Error;
1189
1190 if (!_cmsReadHeader(NewIcc)) goto Error;
1191
1192 return hEmpty;
1193
1194Error:
1195 cmsCloseProfile(hEmpty);
1196 return NULL;
1197}
1198
1199cmsHPROFILE CMSEXPORT cmsOpenProfileFromMem(const void* MemPtr, cmsUInt32Number dwSize)
1200{
1201 return cmsOpenProfileFromMemTHR(NULL, MemPtr, dwSize);
1202}
1203
1204
1205
1206// Dump tag contents. If the profile is being modified, untouched tags are copied from FileOrig
1207static
1208cmsBool SaveTags(_cmsICCPROFILE* Icc, _cmsICCPROFILE* FileOrig)
1209{
1210 cmsUInt8Number* Data;
1211 cmsUInt32Number i;
1212 cmsUInt32Number Begin;
1213 cmsIOHANDLER* io = Icc ->IOhandler;
1214 cmsTagDescriptor* TagDescriptor;
1215 cmsTagTypeSignature TypeBase;
1216 cmsTagTypeSignature Type;
1217 cmsTagTypeHandler* TypeHandler;
1218 cmsFloat64Number Version = cmsGetProfileVersion((cmsHPROFILE) Icc);
1219 cmsTagTypeHandler LocalTypeHandler;
1220
1221 for (i=0; i < Icc -> TagCount; i++) {
1222
1223 if (Icc ->TagNames[i] == (cmsTagSignature) 0) continue;
1224
1225 // Linked tags are not written
1226 if (Icc ->TagLinked[i] != (cmsTagSignature) 0) continue;
1227
1228 Icc -> TagOffsets[i] = Begin = io ->UsedSpace;
1229
1230 Data = (cmsUInt8Number*) Icc -> TagPtrs[i];
1231
1232 if (!Data) {
1233
1234 // Reach here if we are copying a tag from a disk-based ICC profile which has not been modified by user.
1235 // In this case a blind copy of the block data is performed
1236 if (FileOrig != NULL && Icc -> TagOffsets[i]) {
1237
1238 cmsUInt32Number TagSize = FileOrig -> TagSizes[i];
1239 cmsUInt32Number TagOffset = FileOrig -> TagOffsets[i];
1240 void* Mem;
1241
1242 if (!FileOrig ->IOhandler->Seek(FileOrig ->IOhandler, TagOffset)) return FALSE;
1243
1244 Mem = _cmsMalloc(Icc ->ContextID, TagSize);
1245 if (Mem == NULL) return FALSE;
1246
1247 if (FileOrig ->IOhandler->Read(FileOrig->IOhandler, Mem, TagSize, 1) != 1) return FALSE;
1248 if (!io ->Write(io, TagSize, Mem)) return FALSE;
1249 _cmsFree(Icc ->ContextID, Mem);
1250
1251 Icc -> TagSizes[i] = (io ->UsedSpace - Begin);
1252
1253
1254 // Align to 32 bit boundary.
1255 if (! _cmsWriteAlignment(io))
1256 return FALSE;
1257 }
1258
1259 continue;
1260 }
1261
1262
1263 // Should this tag be saved as RAW? If so, tagsizes should be specified in advance (no further cooking is done)
1264 if (Icc ->TagSaveAsRaw[i]) {
1265
1266 if (io -> Write(io, Icc ->TagSizes[i], Data) != 1) return FALSE;
1267 }
1268 else {
1269
1270 // Search for support on this tag
1271 TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, Icc -> TagNames[i]);
1272 if (TagDescriptor == NULL) continue; // Unsupported, ignore it
1273
1274 if (TagDescriptor ->DecideType != NULL) {
1275
1276 Type = TagDescriptor ->DecideType(Version, Data);
1277 }
1278 else {
1279
1280 Type = TagDescriptor ->SupportedTypes[0];
1281 }
1282
1283 TypeHandler = _cmsGetTagTypeHandler(Icc->ContextID, Type);
1284
1285 if (TypeHandler == NULL) {
1286 cmsSignalError(Icc ->ContextID, cmsERROR_INTERNAL, "(Internal) no handler for tag %x", Icc -> TagNames[i]);
1287 continue;
1288 }
1289
1290 TypeBase = TypeHandler ->Signature;
1291 if (!_cmsWriteTypeBase(io, TypeBase))
1292 return FALSE;
1293
1294 LocalTypeHandler = *TypeHandler;
1295 LocalTypeHandler.ContextID = Icc ->ContextID;
1296 LocalTypeHandler.ICCVersion = Icc ->Version;
1297 if (!LocalTypeHandler.WritePtr(&LocalTypeHandler, io, Data, TagDescriptor ->ElemCount)) {
1298
1299 char String[5];
1300
1301 _cmsTagSignature2String(String, (cmsTagSignature) TypeBase);
1302 cmsSignalError(Icc ->ContextID, cmsERROR_WRITE, "Couldn't write type '%s'", String);
1303 return FALSE;
1304 }
1305 }
1306
1307
1308 Icc -> TagSizes[i] = (io ->UsedSpace - Begin);
1309
1310 // Align to 32 bit boundary.
1311 if (! _cmsWriteAlignment(io))
1312 return FALSE;
1313 }
1314
1315
1316 return TRUE;
1317}
1318
1319
1320// Fill the offset and size fields for all linked tags
1321static
1322cmsBool SetLinks( _cmsICCPROFILE* Icc)
1323{
1324 cmsUInt32Number i;
1325
1326 for (i=0; i < Icc -> TagCount; i++) {
1327
1328 cmsTagSignature lnk = Icc ->TagLinked[i];
1329 if (lnk != (cmsTagSignature) 0) {
1330
1331 int j = _cmsSearchTag(Icc, lnk, FALSE);
1332 if (j >= 0) {
1333
1334 Icc ->TagOffsets[i] = Icc ->TagOffsets[j];
1335 Icc ->TagSizes[i] = Icc ->TagSizes[j];
1336 }
1337
1338 }
1339 }
1340
1341 return TRUE;
1342}
1343
1344// Low-level save to IOHANDLER. It returns the number of bytes used to
1345// store the profile, or zero on error. io may be NULL and in this case
1346// no data is written--only sizes are calculated
1347cmsUInt32Number CMSEXPORT cmsSaveProfileToIOhandler(cmsHPROFILE hProfile, cmsIOHANDLER* io)
1348{
1349 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1350 _cmsICCPROFILE Keep;
1351 cmsIOHANDLER* PrevIO = NULL;
1352 cmsUInt32Number UsedSpace;
1353 cmsContext ContextID;
1354
1355 _cmsAssert(hProfile != NULL);
1356
1357 if (!_cmsLockMutex(Icc->ContextID, Icc->UsrMutex)) return 0;
1358 memmove(&Keep, Icc, sizeof(_cmsICCPROFILE));
1359
1360 ContextID = cmsGetProfileContextID(hProfile);
1361 PrevIO = Icc ->IOhandler = cmsOpenIOhandlerFromNULL(ContextID);
1362 if (PrevIO == NULL) {
1363 _cmsUnlockMutex(Icc->ContextID, Icc->UsrMutex);
1364 return 0;
1365 }
1366
1367 // Pass #1 does compute offsets
1368
1369 if (!_cmsWriteHeader(Icc, 0)) goto Error;
1370 if (!SaveTags(Icc, &Keep)) goto Error;
1371
1372 UsedSpace = PrevIO ->UsedSpace;
1373
1374 // Pass #2 does save to iohandler
1375
1376 if (io != NULL) {
1377
1378 Icc ->IOhandler = io;
1379 if (!SetLinks(Icc)) goto Error;
1380 if (!_cmsWriteHeader(Icc, UsedSpace)) goto Error;
1381 if (!SaveTags(Icc, &Keep)) goto Error;
1382 }
1383
1384 memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
1385 if (!cmsCloseIOhandler(PrevIO))
1386 UsedSpace = 0; // As a error marker
1387
1388 _cmsUnlockMutex(Icc->ContextID, Icc->UsrMutex);
1389
1390 return UsedSpace;
1391
1392
1393Error:
1394 cmsCloseIOhandler(PrevIO);
1395 memmove(Icc, &Keep, sizeof(_cmsICCPROFILE));
1396 _cmsUnlockMutex(Icc->ContextID, Icc->UsrMutex);
1397
1398 return 0;
1399}
1400
1401
1402// Low-level save to disk.
1403cmsBool CMSEXPORT cmsSaveProfileToFile(cmsHPROFILE hProfile, const char* FileName)
1404{
1405 cmsContext ContextID = cmsGetProfileContextID(hProfile);
1406 cmsIOHANDLER* io = cmsOpenIOhandlerFromFile(ContextID, FileName, "w");
1407 cmsBool rc;
1408
1409 if (io == NULL) return FALSE;
1410
1411 rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
1412 rc &= cmsCloseIOhandler(io);
1413
1414 if (rc == FALSE) { // remove() is C99 per 7.19.4.1
1415 remove(FileName); // We have to IGNORE return value in this case
1416 }
1417 return rc;
1418}
1419
1420// Same as anterior, but for streams
1421cmsBool CMSEXPORT cmsSaveProfileToStream(cmsHPROFILE hProfile, FILE* Stream)
1422{
1423 cmsBool rc;
1424 cmsContext ContextID = cmsGetProfileContextID(hProfile);
1425 cmsIOHANDLER* io = cmsOpenIOhandlerFromStream(ContextID, Stream);
1426
1427 if (io == NULL) return FALSE;
1428
1429 rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
1430 rc &= cmsCloseIOhandler(io);
1431
1432 return rc;
1433}
1434
1435
1436// Same as anterior, but for memory blocks. In this case, a NULL as MemPtr means calculate needed space only
1437cmsBool CMSEXPORT cmsSaveProfileToMem(cmsHPROFILE hProfile, void *MemPtr, cmsUInt32Number* BytesNeeded)
1438{
1439 cmsBool rc;
1440 cmsIOHANDLER* io;
1441 cmsContext ContextID = cmsGetProfileContextID(hProfile);
1442
1443 _cmsAssert(BytesNeeded != NULL);
1444
1445 // Should we just calculate the needed space?
1446 if (MemPtr == NULL) {
1447
1448 *BytesNeeded = cmsSaveProfileToIOhandler(hProfile, NULL);
1449 return (*BytesNeeded == 0) ? FALSE : TRUE;
1450 }
1451
1452 // That is a real write operation
1453 io = cmsOpenIOhandlerFromMem(ContextID, MemPtr, *BytesNeeded, "w");
1454 if (io == NULL) return FALSE;
1455
1456 rc = (cmsSaveProfileToIOhandler(hProfile, io) != 0);
1457 rc &= cmsCloseIOhandler(io);
1458
1459 return rc;
1460}
1461
1462
1463
1464// Closes a profile freeing any involved resources
1465cmsBool CMSEXPORT cmsCloseProfile(cmsHPROFILE hProfile)
1466{
1467 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1468 cmsBool rc = TRUE;
1469 cmsUInt32Number i;
1470
1471 if (!Icc) return FALSE;
1472
1473 // Was open in write mode?
1474 if (Icc ->IsWrite) {
1475
1476 Icc ->IsWrite = FALSE; // Assure no further writing
1477 rc &= cmsSaveProfileToFile(hProfile, Icc ->IOhandler->PhysicalFile);
1478 }
1479
1480 for (i=0; i < Icc -> TagCount; i++) {
1481
1482 if (Icc -> TagPtrs[i]) {
1483
1484 cmsTagTypeHandler* TypeHandler = Icc ->TagTypeHandlers[i];
1485
1486 if (TypeHandler != NULL) {
1487 cmsTagTypeHandler LocalTypeHandler = *TypeHandler;
1488
1489 LocalTypeHandler.ContextID = Icc ->ContextID; // As an additional parameters
1490 LocalTypeHandler.ICCVersion = Icc ->Version;
1491 LocalTypeHandler.FreePtr(&LocalTypeHandler, Icc -> TagPtrs[i]);
1492 }
1493 else
1494 _cmsFree(Icc ->ContextID, Icc ->TagPtrs[i]);
1495 }
1496 }
1497
1498 if (Icc ->IOhandler != NULL) {
1499 rc &= cmsCloseIOhandler(Icc->IOhandler);
1500 }
1501
1502 _cmsDestroyMutex(Icc->ContextID, Icc->UsrMutex);
1503
1504 _cmsFree(Icc ->ContextID, Icc); // Free placeholder memory
1505
1506 return rc;
1507}
1508
1509
1510// -------------------------------------------------------------------------------------------------------------------
1511
1512
1513// Returns TRUE if a given tag is supported by a plug-in
1514static
1515cmsBool IsTypeSupported(cmsTagDescriptor* TagDescriptor, cmsTagTypeSignature Type)
1516{
1517 cmsUInt32Number i, nMaxTypes;
1518
1519 nMaxTypes = TagDescriptor->nSupportedTypes;
1520 if (nMaxTypes >= MAX_TYPES_IN_LCMS_PLUGIN)
1521 nMaxTypes = MAX_TYPES_IN_LCMS_PLUGIN;
1522
1523 for (i=0; i < nMaxTypes; i++) {
1524 if (Type == TagDescriptor ->SupportedTypes[i]) return TRUE;
1525 }
1526
1527 return FALSE;
1528}
1529
1530
1531// That's the main read function
1532void* CMSEXPORT cmsReadTag(cmsHPROFILE hProfile, cmsTagSignature sig)
1533{
1534 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1535 cmsIOHANDLER* io = Icc ->IOhandler;
1536 cmsTagTypeHandler* TypeHandler;
1537 cmsTagTypeHandler LocalTypeHandler;
1538 cmsTagDescriptor* TagDescriptor;
1539 cmsTagTypeSignature BaseType;
1540 cmsUInt32Number Offset, TagSize;
1541 cmsUInt32Number ElemCount;
1542 int n;
1543
1544 if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return NULL;
1545
1546 n = _cmsSearchTag(Icc, sig, TRUE);
1547 if (n < 0) goto Error; // Not found, return NULL
1548
1549
1550 // If the element is already in memory, return the pointer
1551 if (Icc -> TagPtrs[n]) {
1552
1553 if (Icc->TagTypeHandlers[n] == NULL) goto Error;
1554
1555 // Sanity check
1556 BaseType = Icc->TagTypeHandlers[n]->Signature;
1557 if (BaseType == 0) goto Error;
1558
1559 TagDescriptor = _cmsGetTagDescriptor(Icc->ContextID, sig);
1560 if (TagDescriptor == NULL) goto Error;
1561
1562 if (!IsTypeSupported(TagDescriptor, BaseType)) goto Error;
1563
1564 if (Icc ->TagSaveAsRaw[n]) goto Error; // We don't support read raw tags as cooked
1565
1566 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1567 return Icc -> TagPtrs[n];
1568 }
1569
1570 // We need to read it. Get the offset and size to the file
1571 Offset = Icc -> TagOffsets[n];
1572 TagSize = Icc -> TagSizes[n];
1573
1574 if (TagSize < 8) goto Error;
1575
1576 // Seek to its location
1577 if (!io -> Seek(io, Offset))
1578 goto Error;
1579
1580 // Search for support on this tag
1581 TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
1582 if (TagDescriptor == NULL) {
1583
1584 char String[5];
1585
1586 _cmsTagSignature2String(String, sig);
1587
1588 // An unknown element was found.
1589 cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknown tag type '%s' found.", String);
1590 goto Error; // Unsupported.
1591 }
1592
1593 // if supported, get type and check if in list
1594 BaseType = _cmsReadTypeBase(io);
1595 if (BaseType == 0) goto Error;
1596
1597 if (!IsTypeSupported(TagDescriptor, BaseType)) goto Error;
1598
1599 TagSize -= 8; // Alredy read by the type base logic
1600
1601 // Get type handler
1602 TypeHandler = _cmsGetTagTypeHandler(Icc ->ContextID, BaseType);
1603 if (TypeHandler == NULL) goto Error;
1604 LocalTypeHandler = *TypeHandler;
1605
1606
1607 // Read the tag
1608 Icc -> TagTypeHandlers[n] = TypeHandler;
1609
1610 LocalTypeHandler.ContextID = Icc ->ContextID;
1611 LocalTypeHandler.ICCVersion = Icc ->Version;
1612 Icc -> TagPtrs[n] = LocalTypeHandler.ReadPtr(&LocalTypeHandler, io, &ElemCount, TagSize);
1613
1614 // The tag type is supported, but something wrong happened and we cannot read the tag.
1615 // let know the user about this (although it is just a warning)
1616 if (Icc -> TagPtrs[n] == NULL) {
1617
1618 char String[5];
1619
1620 _cmsTagSignature2String(String, sig);
1621 cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "Corrupted tag '%s'", String);
1622 goto Error;
1623 }
1624
1625 // This is a weird error that may be a symptom of something more serious, the number of
1626 // stored item is actually less than the number of required elements.
1627 if (ElemCount < TagDescriptor ->ElemCount) {
1628
1629 char String[5];
1630
1631 _cmsTagSignature2String(String, sig);
1632 cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "'%s' Inconsistent number of items: expected %d, got %d",
1633 String, TagDescriptor ->ElemCount, ElemCount);
1634 }
1635
1636
1637 // Return the data
1638 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1639 return Icc -> TagPtrs[n];
1640
1641
1642 // Return error and unlock tha data
1643Error:
1644 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1645 return NULL;
1646}
1647
1648
1649// Get true type of data
1650cmsTagTypeSignature _cmsGetTagTrueType(cmsHPROFILE hProfile, cmsTagSignature sig)
1651{
1652 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1653 cmsTagTypeHandler* TypeHandler;
1654 int n;
1655
1656 // Search for given tag in ICC profile directory
1657 n = _cmsSearchTag(Icc, sig, TRUE);
1658 if (n < 0) return (cmsTagTypeSignature) 0; // Not found, return NULL
1659
1660 // Get the handler. The true type is there
1661 TypeHandler = Icc -> TagTypeHandlers[n];
1662 return TypeHandler ->Signature;
1663}
1664
1665
1666// Write a single tag. This just keeps track of the tak into a list of "to be written". If the tag is already
1667// in that list, the previous version is deleted.
1668cmsBool CMSEXPORT cmsWriteTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data)
1669{
1670 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1671 cmsTagTypeHandler* TypeHandler = NULL;
1672 cmsTagTypeHandler LocalTypeHandler;
1673 cmsTagDescriptor* TagDescriptor = NULL;
1674 cmsTagTypeSignature Type;
1675 int i;
1676 cmsFloat64Number Version;
1677 char TypeString[5], SigString[5];
1678
1679 if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return FALSE;
1680
1681 // To delete tags.
1682 if (data == NULL) {
1683
1684 // Delete the tag
1685 i = _cmsSearchTag(Icc, sig, FALSE);
1686 if (i >= 0) {
1687
1688 // Use zero as a mark of deleted
1689 _cmsDeleteTagByPos(Icc, i);
1690 Icc ->TagNames[i] = (cmsTagSignature) 0;
1691 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1692 return TRUE;
1693 }
1694 // Didn't find the tag
1695 goto Error;
1696 }
1697
1698 if (!_cmsNewTag(Icc, sig, &i)) goto Error;
1699
1700 // This is not raw
1701 Icc ->TagSaveAsRaw[i] = FALSE;
1702
1703 // This is not a link
1704 Icc ->TagLinked[i] = (cmsTagSignature) 0;
1705
1706 // Get information about the TAG.
1707 TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
1708 if (TagDescriptor == NULL){
1709 cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported tag '%x'", sig);
1710 goto Error;
1711 }
1712
1713
1714 // Now we need to know which type to use. It depends on the version.
1715 Version = cmsGetProfileVersion(hProfile);
1716
1717 if (TagDescriptor ->DecideType != NULL) {
1718
1719 // Let the tag descriptor to decide the type base on depending on
1720 // the data. This is useful for example on parametric curves, where
1721 // curves specified by a table cannot be saved as parametric and needs
1722 // to be casted to single v2-curves, even on v4 profiles.
1723
1724 Type = TagDescriptor ->DecideType(Version, data);
1725 }
1726 else {
1727
1728 Type = TagDescriptor ->SupportedTypes[0];
1729 }
1730
1731 // Does the tag support this type?
1732 if (!IsTypeSupported(TagDescriptor, Type)) {
1733
1734 _cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
1735 _cmsTagSignature2String(SigString, sig);
1736
1737 cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported type '%s' for tag '%s'", TypeString, SigString);
1738 goto Error;
1739 }
1740
1741 // Does we have a handler for this type?
1742 TypeHandler = _cmsGetTagTypeHandler(Icc->ContextID, Type);
1743 if (TypeHandler == NULL) {
1744
1745 _cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
1746 _cmsTagSignature2String(SigString, sig);
1747
1748 cmsSignalError(Icc ->ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported type '%s' for tag '%s'", TypeString, SigString);
1749 goto Error; // Should never happen
1750 }
1751
1752
1753 // Fill fields on icc structure
1754 Icc ->TagTypeHandlers[i] = TypeHandler;
1755 Icc ->TagNames[i] = sig;
1756 Icc ->TagSizes[i] = 0;
1757 Icc ->TagOffsets[i] = 0;
1758
1759 LocalTypeHandler = *TypeHandler;
1760 LocalTypeHandler.ContextID = Icc ->ContextID;
1761 LocalTypeHandler.ICCVersion = Icc ->Version;
1762 Icc ->TagPtrs[i] = LocalTypeHandler.DupPtr(&LocalTypeHandler, data, TagDescriptor ->ElemCount);
1763
1764 if (Icc ->TagPtrs[i] == NULL) {
1765
1766 _cmsTagSignature2String(TypeString, (cmsTagSignature) Type);
1767 _cmsTagSignature2String(SigString, sig);
1768 cmsSignalError(Icc ->ContextID, cmsERROR_CORRUPTION_DETECTED, "Malformed struct in type '%s' for tag '%s'", TypeString, SigString);
1769
1770 goto Error;
1771 }
1772
1773 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1774 return TRUE;
1775
1776Error:
1777 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1778 return FALSE;
1779
1780}
1781
1782// Read and write raw data. The only way those function would work and keep consistence with normal read and write
1783// is to do an additional step of serialization. That means, readRaw would issue a normal read and then convert the obtained
1784// data to raw bytes by using the "write" serialization logic. And vice-versa. I know this may end in situations where
1785// raw data written does not exactly correspond with the raw data proposed to cmsWriteRaw data, but this approach allows
1786// to write a tag as raw data and the read it as handled.
1787
1788cmsUInt32Number CMSEXPORT cmsReadRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, void* data, cmsUInt32Number BufferSize)
1789{
1790 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1791 void *Object;
1792 int i;
1793 cmsIOHANDLER* MemIO;
1794 cmsTagTypeHandler* TypeHandler = NULL;
1795 cmsTagTypeHandler LocalTypeHandler;
1796 cmsTagDescriptor* TagDescriptor = NULL;
1797 cmsUInt32Number rc;
1798 cmsUInt32Number Offset, TagSize;
1799
1800 if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
1801
1802 // Search for given tag in ICC profile directory
1803 i = _cmsSearchTag(Icc, sig, TRUE);
1804 if (i < 0) goto Error; // Not found,
1805
1806 // It is already read?
1807 if (Icc -> TagPtrs[i] == NULL) {
1808
1809 // No yet, get original position
1810 Offset = Icc ->TagOffsets[i];
1811 TagSize = Icc ->TagSizes[i];
1812
1813 // read the data directly, don't keep copy
1814 if (data != NULL) {
1815
1816 if (BufferSize < TagSize)
1817 TagSize = BufferSize;
1818
1819 if (!Icc ->IOhandler ->Seek(Icc ->IOhandler, Offset)) goto Error;
1820 if (!Icc ->IOhandler ->Read(Icc ->IOhandler, data, 1, TagSize)) goto Error;
1821
1822 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1823 return TagSize;
1824 }
1825
1826 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1827 return Icc ->TagSizes[i];
1828 }
1829
1830 // The data has been already read, or written. But wait!, maybe the user choosed to save as
1831 // raw data. In this case, return the raw data directly
1832 if (Icc ->TagSaveAsRaw[i]) {
1833
1834 if (data != NULL) {
1835
1836 TagSize = Icc ->TagSizes[i];
1837 if (BufferSize < TagSize)
1838 TagSize = BufferSize;
1839
1840 memmove(data, Icc ->TagPtrs[i], TagSize);
1841
1842 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1843 return TagSize;
1844 }
1845
1846 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1847 return Icc ->TagSizes[i];
1848 }
1849
1850 // Already readed, or previously set by cmsWriteTag(). We need to serialize that
1851 // data to raw in order to maintain consistency.
1852
1853 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1854 Object = cmsReadTag(hProfile, sig);
1855 if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
1856
1857 if (Object == NULL) goto Error;
1858
1859 // Now we need to serialize to a memory block: just use a memory iohandler
1860
1861 if (data == NULL) {
1862 MemIO = cmsOpenIOhandlerFromNULL(cmsGetProfileContextID(hProfile));
1863 } else{
1864 MemIO = cmsOpenIOhandlerFromMem(cmsGetProfileContextID(hProfile), data, BufferSize, "w");
1865 }
1866 if (MemIO == NULL) goto Error;
1867
1868 // Obtain type handling for the tag
1869 TypeHandler = Icc ->TagTypeHandlers[i];
1870 TagDescriptor = _cmsGetTagDescriptor(Icc-> ContextID, sig);
1871 if (TagDescriptor == NULL) {
1872 cmsCloseIOhandler(MemIO);
1873 goto Error;
1874 }
1875
1876 if (TypeHandler == NULL) goto Error;
1877
1878 // Serialize
1879 LocalTypeHandler = *TypeHandler;
1880 LocalTypeHandler.ContextID = Icc ->ContextID;
1881 LocalTypeHandler.ICCVersion = Icc ->Version;
1882
1883 if (!_cmsWriteTypeBase(MemIO, TypeHandler ->Signature)) {
1884 cmsCloseIOhandler(MemIO);
1885 goto Error;
1886 }
1887
1888 if (!LocalTypeHandler.WritePtr(&LocalTypeHandler, MemIO, Object, TagDescriptor ->ElemCount)) {
1889 cmsCloseIOhandler(MemIO);
1890 goto Error;
1891 }
1892
1893 // Get Size and close
1894 rc = MemIO ->Tell(MemIO);
1895 cmsCloseIOhandler(MemIO); // Ignore return code this time
1896
1897 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1898 return rc;
1899
1900Error:
1901 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1902 return 0;
1903}
1904
1905// Similar to the anterior. This function allows to write directly to the ICC profile any data, without
1906// checking anything. As a rule, mixing Raw with cooked doesn't work, so writing a tag as raw and then reading
1907// it as cooked without serializing does result into an error. If that is what you want, you will need to dump
1908// the profile to memry or disk and then reopen it.
1909cmsBool CMSEXPORT cmsWriteRawTag(cmsHPROFILE hProfile, cmsTagSignature sig, const void* data, cmsUInt32Number Size)
1910{
1911 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1912 int i;
1913
1914 if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return 0;
1915
1916 if (!_cmsNewTag(Icc, sig, &i)) {
1917 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1918 return FALSE;
1919 }
1920
1921 // Mark the tag as being written as RAW
1922 Icc ->TagSaveAsRaw[i] = TRUE;
1923 Icc ->TagNames[i] = sig;
1924 Icc ->TagLinked[i] = (cmsTagSignature) 0;
1925
1926 // Keep a copy of the block
1927 Icc ->TagPtrs[i] = _cmsDupMem(Icc ->ContextID, data, Size);
1928 Icc ->TagSizes[i] = Size;
1929
1930 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1931
1932 if (Icc->TagPtrs[i] == NULL) {
1933 Icc->TagNames[i] = (cmsTagSignature) 0;
1934 return FALSE;
1935 }
1936 return TRUE;
1937}
1938
1939// Using this function you can collapse several tag entries to the same block in the profile
1940cmsBool CMSEXPORT cmsLinkTag(cmsHPROFILE hProfile, cmsTagSignature sig, cmsTagSignature dest)
1941{
1942 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1943 int i;
1944
1945 if (!_cmsLockMutex(Icc->ContextID, Icc ->UsrMutex)) return FALSE;
1946
1947 if (!_cmsNewTag(Icc, sig, &i)) {
1948 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1949 return FALSE;
1950 }
1951
1952 // Keep necessary information
1953 Icc ->TagSaveAsRaw[i] = FALSE;
1954 Icc ->TagNames[i] = sig;
1955 Icc ->TagLinked[i] = dest;
1956
1957 Icc ->TagPtrs[i] = NULL;
1958 Icc ->TagSizes[i] = 0;
1959 Icc ->TagOffsets[i] = 0;
1960
1961 _cmsUnlockMutex(Icc->ContextID, Icc ->UsrMutex);
1962 return TRUE;
1963}
1964
1965
1966// Returns the tag linked to sig, in the case two tags are sharing same resource
1967cmsTagSignature CMSEXPORT cmsTagLinkedTo(cmsHPROFILE hProfile, cmsTagSignature sig)
1968{
1969 _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;
1970 int i;
1971
1972 // Search for given tag in ICC profile directory
1973 i = _cmsSearchTag(Icc, sig, FALSE);
1974 if (i < 0) return (cmsTagSignature) 0; // Not found, return 0
1975
1976 return Icc -> TagLinked[i];
1977}
1978