31 //  Little cms

    32 //  Little Color Management System

    32 //  Copyright (C) 1998-2007 Marti Maria

    33 //  Copyright (c) 1998-2010 Marti Maria Saguer

    55 

    60 // IOhandlers are abstractions used by littleCMS to read from whatever file, stream,

    56 

    61 // memory block or any storage. Each IOhandler provides implementations for read,

    57 #include "lcms.h"

    62 // write, seek and tell functions. LittleCMS code deals with IO across those objects.

    58 

    63 // In this way, is easier to add support for new storage media.

    59 

    64 

    60 // Memory-based stream ---------------------------------------------------

    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.

    63                 LPBYTE Block;           // Points to allocated memory

    73     cmsUInt32Number Pointer;         // Points to current location

    64                 size_t Size;            // Size of allocated memory

    74 } FILENULL;

    65                 size_t Pointer;         // Points to current location

    75 

    66                 int FreeBlockOnClose;   // As title

    76 static

    67 

    77 cmsUInt32Number NULLRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)

    68                 } FILEMEM;

    78 {

    69 

    79     FILENULL* ResData = (FILENULL*) iohandler ->stream;

    70 static

    80 

    71 LPVOID MemoryOpen(LPBYTE Block, size_t Size, char Mode)

    81     cmsUInt32Number len = size * count;

    72 {

    82     ResData -> Pointer += len;

    73     FILEMEM* fm = (FILEMEM*) _cmsMalloc(sizeof(FILEMEM));

    83     return count;

    74     if (fm == NULL) return NULL;

    84 

    75 

    85     cmsUNUSED_PARAMETER(Buffer);

    76     ZeroMemory(fm, sizeof(FILEMEM));

    86 }

    77 

    87 

    78     if (Mode == 'r') {

    88 static

    79 

    89 cmsBool  NULLSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)

    80         fm ->Block   = (LPBYTE) _cmsMalloc(Size);

    90 {

    91     FILENULL* ResData = (FILENULL*) iohandler ->stream;

    92 

    93     ResData ->Pointer = offset;

    94     return TRUE;

    95 }

    96 

    97 static

    98 cmsUInt32Number NULLTell(cmsIOHANDLER* iohandler)

    99 {

   100     FILENULL* ResData = (FILENULL*) iohandler ->stream;

   101     return ResData -> Pointer;

   102 }

   103 

   104 static

   105 cmsBool  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 

   118 static

   119 cmsBool  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

   129 cmsIOHANDLER*  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 ->PhysicalFile[0] = 0;

   146 

   147     iohandler ->Read    = NULLRead;

   148     iohandler ->Seek    = NULLSeek;

   149     iohandler ->Close   = NULLClose;

   150     iohandler ->Tell    = NULLTell;

   151     iohandler ->Write   = NULLWrite;

   152 

   153     return iohandler;

   154 

   155 Error:

   156     if (fm) _cmsFree(ContextID, fm);

   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 

   167 typedef 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 

   175 static

   176 cmsUInt32Number 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

   198 static

   199 cmsBool  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

   213 static

   214 cmsUInt32Number 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.

   224 static

   225 cmsBool  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     if (size == 0) return TRUE;     // Write zero bytes is ok, but does nothing

   232 

   233     memmove(ResData ->Block + ResData ->Pointer, Ptr, size);

   234     ResData ->Pointer += size;

   235 

   236     if (ResData ->Pointer > iohandler->UsedSpace)

   237         iohandler->UsedSpace = ResData ->Pointer;

   238 

   239 

   240     iohandler->UsedSpace += size;

   241 

   242     return TRUE;

   243 }

   244 

   245 

   246 static

   247 cmsBool  MemoryClose(struct _cms_io_handler* iohandler)

   248 {

   249     FILEMEM* ResData = (FILEMEM*) iohandler ->stream;

   250 

   251     if (ResData ->FreeBlockOnClose) {

   252 

   253         if (ResData ->Block) _cmsFree(iohandler ->ContextID, ResData ->Block);

   254     }

   255 

   256     _cmsFree(iohandler ->ContextID, ResData);

   257     _cmsFree(iohandler ->ContextID, iohandler);

   258 

   259     return TRUE;

   260 }

   261 

   262 // Create a iohandler for memory block. AccessMode=='r' assumes the iohandler is going to read, and makes

   263 // a copy of the memory block for letting user to free the memory after invoking open profile. In write

   264 // mode ("w"), Buffere points to the begin of memory block to be written.

   265 cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromMem(cmsContext ContextID, void *Buffer, cmsUInt32Number size, const char* AccessMode)

   266 {

   267     cmsIOHANDLER* iohandler = NULL;

   268     FILEMEM* fm = NULL;

   269 

   270     _cmsAssert(AccessMode != NULL);

   271 

   272     iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));

   273     if (iohandler == NULL) return NULL;

   274 

   275     switch (*AccessMode) {

   276 

   277     case 'r':

   278         fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));

   279         if (fm == NULL) goto Error;

   280 

   281         if (Buffer == NULL) {

   282             cmsSignalError(ContextID, cmsERROR_READ, "Couldn't read profile from NULL pointer");

   283             goto Error;

   284         }

   285 

   286         fm ->Block = (cmsUInt8Number*) _cmsMalloc(ContextID, size);

    82              _cmsFree(fm);

   288 

   289             _cmsFree(ContextID, fm);

   290             _cmsFree(ContextID, iohandler);

   291             cmsSignalError(ContextID, cmsERROR_READ, "Couldn't allocate %ld bytes for profile", size);

    86         CopyMemory(fm->Block, Block, Size);

   295 

   296         memmove(fm->Block, Buffer, size);

    88     }

   298         fm ->Size    = size;

    89     else {

   299         fm ->Pointer = 0;

    90         fm ->Block = Block;

   300         break;

   301 

   302     case 'w':

   303         fm = (FILEMEM*) _cmsMallocZero(ContextID, sizeof(FILEMEM));

   304         if (fm == NULL) goto Error;

   305 

   306         fm ->Block = (cmsUInt8Number*) Buffer;

    92     }

   308         fm ->Size    = size;

    93 

   309         fm ->Pointer = 0;

    94     fm ->Size    = Size;

   310         break;

    95     fm ->Pointer = 0;

   311 

    96 

   312     default:

    97     return (LPVOID) fm;

   313         cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unknow access mode '%c'", *AccessMode);

    98 }

   314         return NULL;

    99 

   315     }

   100 

   316 

   101 static

   317     iohandler ->ContextID = ContextID;

   102 size_t MemoryRead(LPVOID buffer, size_t size, size_t count, struct _lcms_iccprofile_struct* Icc)

   318     iohandler ->stream  = (void*) fm;

   103 {

   319     iohandler ->UsedSpace = 0;

   104      FILEMEM* ResData = (FILEMEM*) Icc ->stream;

   320     iohandler ->PhysicalFile[0] = 0;

   105      LPBYTE Ptr;

   321 

   106      size_t len = size * count;

   322     iohandler ->Read    = MemoryRead;

   107      size_t extent = ResData -> Pointer + len;

   323     iohandler ->Seek    = MemorySeek;

   108 

   324     iohandler ->Close   = MemoryClose;

   109         if (len == 0) {

   325     iohandler ->Tell    = MemoryTell;

   110                 return 0;

   326     iohandler ->Write   = MemoryWrite;

   327 

   328     return iohandler;

   329 

   330 Error:

   331     if (fm) _cmsFree(ContextID, fm);

   332     if (iohandler) _cmsFree(ContextID, iohandler);

   333     return NULL;

   334 }

   335 

   336 // File-based stream -------------------------------------------------------

   337 

   338 // Read count elements of size bytes each. Return number of elements read

   339 static

   340 cmsUInt32Number FileRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number size, cmsUInt32Number count)

   341 {

   342     cmsUInt32Number nReaded = (cmsUInt32Number) fread(Buffer, size, count, (FILE*) iohandler->stream);

   343 

   344     if (nReaded != count) {

   345             cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Read error. Got %d bytes, block should be of %d bytes", nReaded * size, count * size);

   346             return 0;

   347     }

   348 

   349     return nReaded;

   350 }

   351 

   352 // Postion file pointer in the file

   353 static

   354 cmsBool  FileSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)

   355 {

   356     if (fseek((FILE*) iohandler ->stream, (long) offset, SEEK_SET) != 0) {

   357 

   358        cmsSignalError(iohandler ->ContextID, cmsERROR_FILE, "Seek error; probably corrupted file");

   359        return FALSE;

   360     }

   361 

   362     return TRUE;

   363 }

   364 

   365 // Returns file pointer position

   366 static

   367 cmsUInt32Number FileTell(cmsIOHANDLER* iohandler)

   368 {

   369     return ftell((FILE*)iohandler ->stream);

   370 }

   371 

   372 // Writes data to stream, also keeps used space for further reference. Returns TRUE on success, FALSE on error

   373 static

   374 cmsBool  FileWrite(cmsIOHANDLER* iohandler, cmsUInt32Number size, const void* Buffer)

   375 {

   376        if (size == 0) return TRUE;  // We allow to write 0 bytes, but nothing is written

   377 

   378        iohandler->UsedSpace += size;

   379        return (fwrite(Buffer, size, 1, (FILE*) iohandler->stream) == 1);

   380 }

   381 

   382 // Closes the file

   383 static

   384 cmsBool  FileClose(cmsIOHANDLER* iohandler)

   385 {

   386     if (fclose((FILE*) iohandler ->stream) != 0) return FALSE;

   387     _cmsFree(iohandler ->ContextID, iohandler);

   388     return TRUE;

   389 }

   390 

   391 // Create a iohandler for disk based files. if FileName is NULL, then 'stream' member is also set

   392 // to NULL and no real writting is performed. This only happens in writting access mode

   393 cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const char* FileName, const char* AccessMode)

   394 {

   395     cmsIOHANDLER* iohandler = NULL;

   396     FILE* fm = NULL;

   397 

   398     iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));

   399     if (iohandler == NULL) return NULL;

   400 

   401     switch (*AccessMode) {

   402 

   403     case 'r':

   404         fm = fopen(FileName, "rb");

   405         if (fm == NULL) {

   406             _cmsFree(ContextID, iohandler);

   407              cmsSignalError(ContextID, cmsERROR_FILE, "File '%s' not found", FileName);

   408             return NULL;

   112 

   410         break;

   113         if (len / size != count) {

   411 

   114           cmsSignalError(LCMS_ERRC_ABORTED, "Read from memory error. Integer overflow with count / size.");

   412     case 'w':

   115           return 0;

   413         fm = fopen(FileName, "wb");

   116       }

   414         if (fm == NULL) {

   117 

   415             _cmsFree(ContextID, iohandler);

   118       if (extent < len || extent < ResData -> Pointer) {

   416              cmsSignalError(ContextID, cmsERROR_FILE, "Couldn't create '%s'", FileName);

   119           cmsSignalError(LCMS_ERRC_ABORTED, "Read from memory error. Integer overflow with len.");

   417             return NULL;

   120           return 0;

   418         }

   121       }

   419         break;

   122 

   420 

   123       if (ResData -> Pointer + len > ResData -> Size) {

   421     default:

   124 

   422         _cmsFree(ContextID, iohandler);

   125          len = (ResData -> Size - ResData -> Pointer);

   423          cmsSignalError(ContextID, cmsERROR_FILE, "Unknow access mode '%c'", *AccessMode);

   126          cmsSignalError(LCMS_ERRC_ABORTED, "Read from memory error. Got %d bytes, block should be of %d bytes", len * size, count * size);

   424         return NULL;

   127          return 0;

   425     }

   128      }

   426 

   129 

   427     iohandler ->ContextID = ContextID;

   130     Ptr  = ResData -> Block;

   428     iohandler ->stream = (void*) fm;

   131     Ptr += ResData -> Pointer;

   429     iohandler ->UsedSpace = 0;

   132     CopyMemory(buffer, Ptr, len);

   430 

   133     ResData -> Pointer += (int) len;

   431     // Keep track of the original file

   134 

   432     if (FileName != NULL)  {

   135     return count;

   433 

   136 }

   434         strncpy(iohandler -> PhysicalFile, FileName, sizeof(iohandler -> PhysicalFile)-1);

   137 

   435         iohandler -> PhysicalFile[sizeof(iohandler -> PhysicalFile)-1] = 0;

   138 // SEEK_CUR is assumed

   436     }

   139 

   437 

   140 static

   438     iohandler ->Read    = FileRead;

   141 LCMSBOOL MemorySeek(struct _lcms_iccprofile_struct* Icc, size_t offset)

   439     iohandler ->Seek    = FileSeek;

   142 {

   440     iohandler ->Close   = FileClose;

   143     FILEMEM* ResData = (FILEMEM*) Icc ->stream;

   441     iohandler ->Tell    = FileTell;

   144 

   442     iohandler ->Write   = FileWrite;

   145     if (offset > ResData ->Size) {

   443 

   146          cmsSignalError(LCMS_ERRC_ABORTED,  "Pointer error; probably corrupted file");

   444     return iohandler;

   147          return TRUE;

   445 }

   148     }

   446 

   149 

   447 // Create a iohandler for stream based files

   150     ResData ->Pointer = (DWORD) offset;

   448 cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromStream(cmsContext ContextID, FILE* Stream)

   151     return FALSE;

   449 {

   152 }

   450     cmsIOHANDLER* iohandler = NULL;

   153 

   451 

   154 // FTell

   452     iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));

   155 

   453     if (iohandler == NULL) return NULL;

   156 static

   454 

   157 size_t MemoryTell(struct _lcms_iccprofile_struct* Icc)

   455     iohandler -> ContextID = ContextID;

   158 {

   456     iohandler -> stream = (void*) Stream;

   159     FILEMEM* ResData = (FILEMEM*) Icc ->stream;

   457     iohandler -> UsedSpace = 0;

   160 

   458     iohandler -> PhysicalFile[0] = 0;

   161     return ResData -> Pointer;

   459 

   162 }

   460     iohandler ->Read    = FileRead;

   163 

   461     iohandler ->Seek    = FileSeek;

   164 

   462     iohandler ->Close   = FileClose;

   165 // Writes data to memory, also keeps used space for further reference. NO CHECK IS PERFORMED

   463     iohandler ->Tell    = FileTell;

   166 

   464     iohandler ->Write   = FileWrite;

   167 static

   465 

   168 LCMSBOOL MemoryWrite(struct _lcms_iccprofile_struct* Icc, size_t size, void *Ptr)

   466     return iohandler;

   169 {

   467 }

   170         FILEMEM* ResData = (FILEMEM*) Icc ->stream;

   468 

   171 

   469 

   172        if (size == 0) return TRUE;

   470 

   173 

   471 // Close an open IO handler

   174        if (ResData != NULL)

   472 cmsBool CMSEXPORT cmsCloseIOhandler(cmsIOHANDLER* io)

   175            CopyMemory(ResData ->Block + ResData ->Pointer, Ptr, size);

   473 {

   176 

   474     return io -> Close(io);

   177        ResData->Pointer += size;

   475 }

   178        Icc->UsedSpace += size;

   476 

   179 

   477 // -------------------------------------------------------------------------------------------------------

   180        return TRUE;

   181 }

   182 

   183 

   184 static

   185 LCMSBOOL MemoryGrow(struct _lcms_iccprofile_struct* Icc, size_t size)

   186 {

   187     FILEMEM* ResData = (FILEMEM*) Icc->stream;

   188 

   189     void* newBlock = NULL;

   190 

   191     /* Follow same policies as functions in lcms.h  */

   192     if (ResData->Size + size < 0) return NULL;

   193     if (ResData->Size + size > ((size_t)1024*1024*500)) return NULL;

   194 

   195     newBlock = realloc(ResData->Block, ResData->Size + size);

   196 

   197     if (!newBlock) {

   198         return FALSE;

   199     }

   200     ResData->Block = newBlock;

   201     ResData->Size += size;

   202     return TRUE;

   203 }

   204 

   205 

   206 static

   207 LCMSBOOL MemoryClose(struct _lcms_iccprofile_struct* Icc)

   208 {

   209     FILEMEM* ResData = (FILEMEM*) Icc ->stream;

   210 

   211     if (ResData ->FreeBlockOnClose) {

   212 

   213         if (ResData ->Block)  _cmsFree(ResData ->Block);

   214     }

   215      _cmsFree(ResData);

   216     return 0;

   217 }

   218 

   219 

   220 // File-based stream -------------------------------------------------------

   221 

   222 static

   223 LPVOID FileOpen(const char* filename)

   224 {

   225     return (void*) fopen(filename, "rb");

   226 }

   227 

   228 static

   229 size_t FileRead(void *buffer, size_t size, size_t count, struct _lcms_iccprofile_struct* Icc)

   230 {

   231     size_t nReaded = fread(buffer, size, count, (FILE*) Icc->stream);

   232     if (nReaded != count) {

   233             cmsSignalError(LCMS_ERRC_ABORTED, "Read error. Got %d bytes, block should be of %d bytes", nReaded * size, count * size);

   234             return 0;

   235     }

   236 

   237     return nReaded;

   238 }

   239 

   240 

   241 static

   242 LCMSBOOL FileSeek(struct _lcms_iccprofile_struct* Icc, size_t offset)

   243 {

   244     if (fseek((FILE*) Icc ->stream, (long) offset, SEEK_SET) != 0) {

   245 

   246        cmsSignalError(LCMS_ERRC_ABORTED, "Seek error; probably corrupted file");

   247        return TRUE;

   248     }

   249 

   250     return FALSE;

   251 }

   252 

   253 

   254 static

   255 size_t FileTell(struct _lcms_iccprofile_struct* Icc)

   256 {

   257     return ftell((FILE*) Icc ->stream);

   258 }

   259 

   260 // Writes data to stream, also keeps used space for further reference

   261 

   262 

   263 static

   264 LCMSBOOL FileWrite(struct _lcms_iccprofile_struct* Icc, size_t size, LPVOID Ptr)

   265 {

   266        if (size == 0) return TRUE;

   267 

   268        Icc->UsedSpace += size;

   269 

   270        if (Icc->stream == NULL) {

   271 

   272               return TRUE;

   273        }

   274 

   275        return (fwrite(Ptr, size, 1, (FILE*) Icc->stream) == 1);

   276 }

   277 

   278 

   279 static

   280 LCMSBOOL FileGrow(struct _lcms_iccprofile_struct* Icc, size_t size)

   281 {

   282   return TRUE;

   283 }

   284 

   285 

   286 static

   287 LCMSBOOL FileClose(struct _lcms_iccprofile_struct* Icc)

   288 {

   289     return fclose((FILE*) Icc ->stream);

   290 }

   291 

   292 // ----------------------------------------------------------------------------------------------------

   293 

   296 

   480 cmsHPROFILE CMSEXPORT cmsCreateProfilePlaceholder(cmsContext ContextID)

   297 cmsHPROFILE _cmsCreateProfilePlaceholder(void)

   481 {

   298 {

   482     time_t now = time(NULL);

   299 

   483     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) _cmsMallocZero(ContextID, sizeof(_cmsICCPROFILE));

   300     LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) _cmsMalloc(sizeof(LCMSICCPROFILE));

   303     // Empty values

   486     Icc ->ContextID = ContextID;

   304     ZeroMemory(Icc, sizeof(LCMSICCPROFILE));

   305 

   306     // Make sure illuminant is correct

   307     Icc ->Illuminant = *cmsD50_XYZ();

   318 icInt32Number LCMSEXPORT cmsGetTagCount(cmsHPROFILE hProfile)

   511 cmsInt32Number CMSEXPORT cmsGetTagCount(cmsHPROFILE hProfile)

   319 {

   512 {

   320     LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) hProfile;

   513     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;

   514     if (Icc == NULL) return -1;

   515 

   325 icTagSignature LCMSEXPORT cmsGetTagSignature(cmsHPROFILE hProfile, icInt32Number n)

   520 cmsTagSignature CMSEXPORT cmsGetTagSignature(cmsHPROFILE hProfile, cmsUInt32Number n)

   326 {

   521 {

   327     LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) hProfile;

   522     _cmsICCPROFILE* Icc = (_cmsICCPROFILE*) hProfile;

   328 

   523 

   329     if (n < 0 || n > Icc->TagCount) return (icTagSignature) 0;  // Mark as not available

   524     if (n > Icc->TagCount) return (cmsTagSignature) 0;  // Mark as not available

   525     if (n >= MAX_TABLE_TAG) return (cmsTagSignature) 0; // As double check

   335 // Search for a specific tag in tag dictionary

   531 static

   336 // Returns position or -1 if tag not found

   532 int SearchOneTag(_cmsICCPROFILE* Profile, cmsTagSignature sig)

   337 

   533 {

   338 icInt32Number _cmsSearchTag(LPLCMSICCPROFILE Profile, icTagSignature sig, LCMSBOOL lSignalError)

   534     cmsUInt32Number i;

   339 {

   535 

   340        icInt32Number i;

   536     for (i=0; i < Profile -> TagCount; i++) {

   341 

   537 

   342        if (sig == 0) return -1;     // 0 identifies a special tag holding raw memory.

   538         if (sig == Profile -> TagNames[i])

   343 

   539             return i;

   344        for (i=0; i < Profile -> TagCount; i++) {

   540     }

   345 

   541 

   346               if (sig == Profile -> TagNames[i])

   542     return -1;

   347                             return i;

   543 }

   348        }

   544 

   349 

   545 // Search for a specific tag in tag dictionary. Returns position or -1 if tag not found.

   350        if (lSignalError)

   546 // If followlinks is turned on, then the position of the linked tag is returned

   351             cmsSignalError(LCMS_ERRC_ABORTED, "Tag '%lx' not found", sig);

   547 int _cmsSearchTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, cmsBool lFollowLinks)

   352 

   548 {

   353        return -1;

   549     int n;

   550     cmsTagSignature LinkedSig;

   551 

   552     do {

   553 

   554         // Search for given tag in ICC profile directory

   555         n = SearchOneTag(Icc, sig);

   556         if (n < 0)

   557             return -1;        // Not found

   558 

   559         if (!lFollowLinks)

   560             return n;         // Found, don't follow links

   561 

   562         // Is this a linked tag?

   563         LinkedSig = Icc ->TagLinked[n];

   564 

   565         // Yes, follow link

   566         if (LinkedSig != (cmsTagSignature) 0) {

   567             sig = LinkedSig;

   568         }

   569 

   570     } while (LinkedSig != (cmsTagSignature) 0);

   571 

   572     return n;

   573 }

   574 

   575 

   576 // Create a new tag entry

   577 

   578 static

   579 cmsBool _cmsNewTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, int* NewPos)

   580 {

   581     int i;

   582 

   583     // Search for the tag

   584     i = _cmsSearchTag(Icc, sig, FALSE);

   585 

   586     // Now let's do it easy. If the tag has been already written, that's an error

   587     if (i >= 0) {

   588         cmsSignalError(Icc ->ContextID, cmsERROR_ALREADY_DEFINED, "Tag '%x' already exists", sig);

   589         return FALSE;

   590     }

   591     else  {

   592 

   593         // New one

   594 

   595         if (Icc -> TagCount >= MAX_TABLE_TAG) {

   596             cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", MAX_TABLE_TAG);

   597             return FALSE;

   598         }

   599 

   600         *NewPos = Icc ->TagCount;

   601         Icc -> TagCount++;

   602     }

   603 

   604     return TRUE;

   358 

   609 cmsBool CMSEXPORT cmsIsTag(cmsHPROFILE hProfile, cmsTagSignature sig)

   359 LCMSBOOL LCMSEXPORT cmsIsTag(cmsHPROFILE hProfile, icTagSignature sig)

   610 {

   360 {

   611        _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) (void*) hProfile;

   361        LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;

   366 

   616 // Read profile header and validate it

   367 // Search for a particular tag, replace if found or add new one else

   617 cmsBool _cmsReadHeader(_cmsICCPROFILE* Icc)

   368 

   618 {

   369 LPVOID _cmsInitTag(LPLCMSICCPROFILE Icc, icTagSignature sig, size_t size, const void* Init)

   619     cmsTagEntry Tag;

   370 {

   620     cmsICCHeader Header;

   371     LPVOID Ptr;

   621     cmsUInt32Number i, j;

   372     icInt32Number i;

   622     cmsUInt32Number HeaderSize;

   623     cmsIOHANDLER* io = Icc ->IOhandler;

   624     cmsUInt32Number TagCount;

   625 

   626 

   627     // Read the header

   628     if (io -> Read(io, &Header, sizeof(cmsICCHeader), 1) != 1) {

   629         return FALSE;

   630     }

   631 

   632     // Validate file as an ICC profile

   633     if (_cmsAdjustEndianess32(Header.magic) != cmsMagicNumber) {

   634         cmsSignalError(Icc ->ContextID, cmsERROR_BAD_SIGNATURE, "not an ICC profile, invalid signature");

   635         return FALSE;

   636     }

   637 

   638     // Adjust endianess of the used parameters

   639     Icc -> DeviceClass     = (cmsProfileClassSignature) _cmsAdjustEndianess32(Header.deviceClass);

   640     Icc -> ColorSpace      = (cmsColorSpaceSignature)   _cmsAdjustEndianess32(Header.colorSpace);

   641     Icc -> PCS             = (cmsColorSpaceSignature)   _cmsAdjustEndianess32(Header.pcs);

   642     Icc -> RenderingIntent = _cmsAdjustEndianess32(Header.renderingIntent);

   643     Icc -> flags           = _cmsAdjustEndianess32(Header.flags);

   644     Icc -> manufacturer    = _cmsAdjustEndianess32(Header.manufacturer);

   645     Icc -> model           = _cmsAdjustEndianess32(Header.model);

   646     _cmsAdjustEndianess64(&Icc -> attributes, Header.attributes);

   647     Icc -> Version         = _cmsAdjustEndianess32(Header.version);

   648 

   649     // Get size as reported in header

   650     HeaderSize = _cmsAdjustEndianess32(Header.size);

   651 

   652     // Get creation date/time

   653     _cmsDecodeDateTimeNumber(&Header.date, &Icc ->Created);

   654 

   655     // The profile ID are 32 raw bytes

   656     memmove(Icc ->ProfileID.ID32, Header.profileID.ID32, 16);

   657 

   658 

   659     // Read tag directory

   660     if (!_cmsReadUInt32Number(io, &TagCount)) return FALSE;

   661     if (TagCount > MAX_TABLE_TAG) {

   662 

   663         cmsSignalError(Icc ->ContextID, cmsERROR_RANGE, "Too many tags (%d)", TagCount);

   664         return FALSE;

   665     }

   666 

   667     // Read tag directory

   668     Icc -> TagCount = 0;

   669     for (i=0; i < TagCount; i++) {

   670 

   671         if (!_cmsReadUInt32Number(io, (cmsUInt32Number *) &Tag.sig)) return FALSE;

   672         if (!_cmsReadUInt32Number(io, &Tag.offset)) return FALSE;

   673         if (!_cmsReadUInt32Number(io, &Tag.size)) return FALSE;

   674 

   675         // Perform some sanity check. Offset + size should fall inside file.

   676         if (Tag.offset + Tag.size > HeaderSize)

   677                   continue;

   678 

   679         Icc -> TagNames[Icc ->TagCount]   = Tag.sig;

   680         Icc -> TagOffsets[Icc ->TagCount] = Tag.offset;

   681         Icc -> TagSizes[Icc ->TagCount]   = Tag.size;

   682 

   683        // Search for links

   684         for (j=0; j < Icc ->TagCount; j++) {

   685 

   686             if ((Icc ->TagOffsets[j] == Tag.offset) &&

   687                 (Icc ->TagSizes[j]   == Tag.size)) {

   688 

   689                 Icc ->TagLinked[Icc ->TagCount] = Icc ->TagNames[j];

   690             }

   691 

   692         }

   693 

   694         Icc ->TagCount++;

   695     }

   696 

   697     return TRUE;

   698 }

   699 

   700 // Saves profile header

   701 cmsBool _cmsWriteHeader(_cmsICCPROFILE* Icc, cmsUInt32Number UsedSpace)

   702 {

   703     cmsICCHeader Header;

   704     cmsUInt32Number i;

   705     cmsTagEntry Tag;

   706     cmsInt32Number Count = 0;

   707 

   708     Header.size        = _cmsAdjustEndianess32(UsedSpace);

   709     Header.cmmId       = _cmsAdjustEndianess32(lcmsSignature);

   710     Header.version     = _cmsAdjustEndianess32(Icc ->Version);

   711 

   712     Header.deviceClass = (cmsProfileClassSignature) _cmsAdjustEndianess32(Icc -> DeviceClass);

   713     Header.colorSpace  = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Icc -> ColorSpace);

   714     Header.pcs         = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Icc -> PCS);

   715 

   716     //   NOTE: in v4 Timestamp must be in UTC rather than in local time

   717     _cmsEncodeDateTimeNumber(&Header.date, &Icc ->Created);

   718 

   719     Header.magic       = _cmsAdjustEndianess32(cmsMagicNumber);

   720 

   721 #ifdef CMS_IS_WINDOWS_

   722     Header.platform    = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMicrosoft);

   723 #else

   724     Header.platform    = (cmsPlatformSignature) _cmsAdjustEndianess32(cmsSigMacintosh);

   725 #endif

   726 

   727     Header.flags        = _cmsAdjustEndianess32(Icc -> flags);

   728     Header.manufacturer = _cmsAdjustEndianess32(Icc -> manufacturer);

   729     Header.model        = _cmsAdjustEndianess32(Icc -> model);

   730 

   731     _cmsAdjustEndianess64(&Header.attributes, Icc -> attributes);

   732 

   733     // Rendering intent in the header (for embedded profiles)

   734     Header.renderingIntent = _cmsAdjustEndianess32(Icc -> RenderingIntent);

   735 

   736     // Illuminant is always D50

   737     Header.illuminant.X = _cmsAdjustEndianess32(_cmsDoubleTo15Fixed16(cmsD50_XYZ()->X));

   738     Header.illuminant.Y = _cmsAdjustEndianess32(_cmsDoubleTo15Fixed16(cmsD50_XYZ()->Y));

   739     Header.illuminant.Z = _cmsAdjustEndianess32(_cmsDoubleTo15Fixed16(cmsD50_XYZ()->Z));

   740 

   741     // Created by LittleCMS (that's me!)

   742     Header.creator      = _cmsAdjustEndianess32(lcmsSignature);

   743 

   744     memset(&Header.reserved, 0, sizeof(Header.reserved));

   745 

   746     // Set profile ID. Endianess is always big endian

   747     memmove(&Header.profileID, &Icc ->ProfileID, 16);

   748 

   749     // Dump the header

   750     if (!Icc -> IOhandler->Write(Icc->IOhandler, sizeof(cmsICCHeader), &Header)) return FALSE;

   751 

   752     // Saves Tag directory

   753 

   754     // Get true count

   755     for (i=0;  i < Icc -> TagCount; i++) {

   756         if (Icc ->TagNames[i] != 0)

   757             Count++;

   758     }

   759 

   760     // Store number of tags

   761     if (!_cmsWriteUInt32Number(Icc ->IOhandler, Count)) return FALSE;

   762 

   763     for (i=0; i < Icc -> TagCount; i++) {

   764 

   765         if (Icc ->TagNames[i] == 0) continue;   // It is just a placeholder

   766 

   767         Tag.sig    = (cmsTagSignature) _cmsAdjustEndianess32((cmsInt32Number) Icc -> TagNames[i]);

   768         Tag.offset = _cmsAdjustEndianess32((cmsInt32Number) Icc -> TagOffsets[i]);

   769         Tag.size   = _cmsAdjustEndianess32((cmsInt32Number) Icc -> TagSizes[i]);

   770 

   771         if (!Icc ->IOhandler -> Write(Icc-> IOhandler, sizeof(cmsTagEntry), &Tag)) return FALSE;

   772     }

   773 

   774     return TRUE;

   775 }

   776 

   777 // ----------------------------------------------------------------------- Set/Get several struct members

   778 

   779 

   780 cmsUInt32Number CMSEXPORT cmsGetHeaderRenderingIntent(cmsHPROFILE hProfile)

   781 {

   782     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   783     return Icc -> RenderingIntent;

   784 }

   785 

   786 void CMSEXPORT cmsSetHeaderRenderingIntent(cmsHPROFILE hProfile, cmsUInt32Number RenderingIntent)

   787 {

   788     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   789     Icc -> RenderingIntent = RenderingIntent;

   790 }

   791 

   792 cmsUInt32Number CMSEXPORT cmsGetHeaderFlags(cmsHPROFILE hProfile)

   793 {

   794     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   795     return (cmsUInt32Number) Icc -> flags;

   796 }

   797 

   798 void CMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, cmsUInt32Number Flags)

   799 {

   800     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   801     Icc -> flags = (cmsUInt32Number) Flags;

   802 }

   803 

   804 cmsUInt32Number CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile)

   805 {

   806     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   807     return (cmsUInt32Number) Icc ->manufacturer;

   808 }

   809 

   810 void CMSEXPORT cmsSetHeaderManufacturer(cmsHPROFILE hProfile, cmsUInt32Number manufacturer)

   811 {

   812     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   813     Icc -> manufacturer = (cmsUInt32Number) manufacturer;

   814 }

   815 

   816 cmsUInt32Number CMSEXPORT cmsGetHeaderModel(cmsHPROFILE hProfile)

   817 {

   818     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   819     return (cmsUInt32Number) Icc ->model;

   820 }

   821 

   822 void CMSEXPORT cmsSetHeaderModel(cmsHPROFILE hProfile, cmsUInt32Number model)

   823 {

   824     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   825     Icc -> manufacturer = (cmsUInt32Number) model;

   826 }

   827 

   828 

   829 void CMSEXPORT cmsGetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number* Flags)

   830 {

   831     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   832     memmove(Flags, &Icc -> attributes, sizeof(cmsUInt64Number));

   833 }

   834 

   835 void CMSEXPORT cmsSetHeaderAttributes(cmsHPROFILE hProfile, cmsUInt64Number Flags)

   836 {

   837     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   838     memmove(&Icc -> attributes, &Flags, sizeof(cmsUInt64Number));

   839 }

   840 

   841 void CMSEXPORT cmsGetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)

   842 {

   843     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   844     memmove(ProfileID, Icc ->ProfileID.ID8, 16);

   845 }

   846 

   847 void CMSEXPORT cmsSetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID)

   848 {

   849     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   850     memmove(&Icc -> ProfileID, ProfileID, 16);

   851 }

   852 

   853 cmsBool  CMSEXPORT cmsGetHeaderCreationDateTime(cmsHPROFILE hProfile, struct tm *Dest)

   854 {

   855     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   856     memmove(Dest, &Icc ->Created, sizeof(struct tm));

   857     return TRUE;

   858 }

   859 

   860 cmsColorSpaceSignature CMSEXPORT cmsGetPCS(cmsHPROFILE hProfile)

   861 {

   862     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   863     return Icc -> PCS;

   864 }

   865 

   866 void CMSEXPORT cmsSetPCS(cmsHPROFILE hProfile, cmsColorSpaceSignature pcs)

   867 {

   868     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   869     Icc -> PCS = pcs;

   870 }

   871 

   872 cmsColorSpaceSignature CMSEXPORT cmsGetColorSpace(cmsHPROFILE hProfile)

   873 {

   874     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   875     return Icc -> ColorSpace;

   876 }

   877 

   878 void CMSEXPORT cmsSetColorSpace(cmsHPROFILE hProfile, cmsColorSpaceSignature sig)

   879 {

   880     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   881     Icc -> ColorSpace = sig;

   882 }

   883 

   884 cmsProfileClassSignature CMSEXPORT cmsGetDeviceClass(cmsHPROFILE hProfile)

   885 {

   886     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   887     return Icc -> DeviceClass;

   888 }

   889 

   890 void CMSEXPORT cmsSetDeviceClass(cmsHPROFILE hProfile, cmsProfileClassSignature sig)

   891 {

   892     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   893     Icc -> DeviceClass = sig;

   894 }

   895 

   896 cmsUInt32Number CMSEXPORT cmsGetEncodedICCversion(cmsHPROFILE hProfile)

   897 {

   898     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   899     return Icc -> Version;

   900 }

   901 

   902 void CMSEXPORT cmsSetEncodedICCversion(cmsHPROFILE hProfile, cmsUInt32Number Version)

   903 {

   904     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   905     Icc -> Version = Version;

   906 }

   907 

   908 // Get an hexadecimal number with same digits as v

   909 static

   910 cmsUInt32Number BaseToBase(cmsUInt32Number in, int BaseIn, int BaseOut)

   911 {

   912     char Buff[100];

   913     int i, len;

   914     cmsUInt32Number out;

   915 

   916     for (len=0; in > 0 && len < 100; len++) {

   917 

   918         Buff[len] = (char) (in % BaseIn);

   919         in /= BaseIn;

   920     }

   921 

   922     for (i=len-1, out=0; i >= 0; --i) {

   923         out = out * BaseOut + Buff[i];

   924     }

   925 

   926     return out;

   927 }

   928 

   929 void  CMSEXPORT cmsSetProfileVersion(cmsHPROFILE hProfile, cmsFloat64Number Version)

   930 {

   931     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   932 

   933     // 4.2 -> 0x4200000

   934 

   935     Icc -> Version = BaseToBase((cmsUInt32Number) floor(Version * 100.0), 10, 16) << 16;

   936 }

   937 

   938 cmsFloat64Number CMSEXPORT cmsGetProfileVersion(cmsHPROFILE hProfile)

   939 {

   940     _cmsICCPROFILE*  Icc = (_cmsICCPROFILE*) hProfile;

   941     cmsUInt32Number n = Icc -> Version >> 16;

   942 

   943     return BaseToBase(n, 16, 10) / 100.0;

   944 }

   945 // --------------------------------------------------------------------------------------------------------------

   946 

   947 

   948 // Create profile from IOhandler

   949 cmsHPROFILE CMSEXPORT cmsOpenProfileFromIOhandlerTHR(cmsContext ContextID, cmsIOHANDLER* io)

   950 {

   951     _cmsICCPROFILE* NewIcc;

   952     cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);

   953 

   954     if (hEmpty == NULL) return NULL;

   955 

   956     NewIcc = (_cmsICCPROFILE*) hEmpty;

   957 

   958     NewIcc ->IOhandler = io;

   959     if (!_cmsReadHeader(NewIcc)) goto Error;

   960     return hEmpty;

   961 

   962 Error:

   963     cmsCloseProfile(hEmpty);

   964     return NULL;

   965 }

   966 

   967 // Create profile from disk file

   968 cmsHPROFILE CMSEXPORT cmsOpenProfileFromFileTHR(cmsContext ContextID, const char *lpFileName, const char *sAccess)

   969 {

   970     _cmsICCPROFILE* NewIcc;

   971     cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);

   972 

   973     if (hEmpty == NULL) return NULL;

   974 

   975     NewIcc = (_cmsICCPROFILE*) hEmpty;

   976 

   977     NewIcc ->IOhandler = cmsOpenIOhandlerFromFile(ContextID, lpFileName, sAccess);

   978     if (NewIcc ->IOhandler == NULL) goto Error;

   979 

   980     if (*sAccess == 'W' || *sAccess == 'w') {

   981 

   982         NewIcc -> IsWrite = TRUE;

   983 

   984         return hEmpty;

   985     }

   986 

   987     if (!_cmsReadHeader(NewIcc)) goto Error;

   988     return hEmpty;

   989 

   990 Error:

   991     cmsCloseProfile(hEmpty);

   992     return NULL;

   993 }

   994 

   995 

   996 cmsHPROFILE CMSEXPORT cmsOpenProfileFromFile(const char *ICCProfile, const char *sAccess)

   997 {

   998     return cmsOpenProfileFromFileTHR(NULL, ICCProfile, sAccess);

   999 }

  1000 

  1001 

  1002 cmsHPROFILE  CMSEXPORT cmsOpenProfileFromStreamTHR(cmsContext ContextID, FILE* ICCProfile, const char *sAccess)

  1003 {

  1004     _cmsICCPROFILE* NewIcc;

  1005     cmsHPROFILE hEmpty = cmsCreateProfilePlaceholder(ContextID);

  1006 

  1007     if (hEmpty == NULL) return NULL;

  1008 

  1009     NewIcc = (_cmsICCPROFILE*) hEmpty;

  1010 

  1011     NewIcc ->IOhandler = cmsOpenIOhandlerFromStream(ContextID, ICCProfile);

  1012     if (NewIcc ->IOhandler == NULL) goto Error;

  1013 

  1014     if (*sAccess == 'w') {

  1015 

  1016         NewIcc -> IsWrite = TRUE;

  1017         return hEmpty;

  1018     }

  1019 

  1020     if (!_cmsReadHeader(NewIcc)) goto Error;

  1021     return hEmpty;

  1022 

  1023 Error:

  1024     cmsCloseProfile(hEmpty);

  1025     return NULL;

  1026 

  1027 }

  1028 

  1029 cmsHPROFILE  CMSEXPORT cmsOpenProfileFromStream(FILE* ICCProfile, const char *sAccess)

  1030 {

  1031     return cmsOpenProfileFromStreamTHR(NULL, ICCProfile, sAccess);

  1032 }

  1033 

  1034 

  1035 // Open from memory block

  1036 cmsHPROFILE CMSEXPORT cmsOpenProfileFromMemTHR(cmsContext ContextID, const void* MemPtr, cmsUInt32Number dwSize)

  1037 {

  1038     _cmsICCPROFILE* NewIcc;

  1039     cmsHPROFILE hEmpty;

  1040 

  1041     hEmpty = cmsCreateProfilePlaceholder(ContextID);

  1042     if (hEmpty == NULL) return NULL;

  1043 

  1044     NewIcc = (_cmsICCPROFILE*) hEmpty;

  1045 

  1046     // Ok, in this case const void* is casted to void* just because open IO handler

  1047     // shares read and writting modes. Don't abuse this feature!