/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

// This file is available under and governed by the GNU General Public

// License version 2 only, as published by the Free Software Foundation.

// However, the following notice accompanied the original version of this

// file:

//

//

//  Little cms

//  Copyright (C) 1998-2006 Marti Maria

//

// Permission is hereby granted, free of charge, to any person obtaining

// a copy of this software and associated documentation files (the "Software"),

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the Software

// is furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO

// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//

// Generic I/O, tag dictionary management, profile struct

#include "lcms.h"

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

typedef struct {

                LPBYTE Block;           // Points to allocated memory

                size_t Size;            // Size of allocated memory

                int Pointer;            // Points to current location

                int FreeBlockOnClose;   // As title

                } FILEMEM;

static

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

{

    FILEMEM* fm = (FILEMEM*) malloc(sizeof(FILEMEM));

    ZeroMemory(fm, sizeof(FILEMEM));

    if (Mode == 'r') {

        fm ->Block   = (LPBYTE) malloc(Size);

        if (fm ->Block == NULL) {

            free(fm);

            return NULL;

        }

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

        fm ->FreeBlockOnClose = TRUE;

    }

    else {

        fm ->Block = Block;

        fm ->FreeBlockOnClose = FALSE;

    }

    fm ->Size    = Size;

    fm ->Pointer = 0;

    return (LPVOID) fm;

}

static

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

{

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

     LPBYTE Ptr;

     size_t len = size * count;

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

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

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

     }

    Ptr  = ResData -> Block;

    Ptr += ResData -> Pointer;

    CopyMemory(buffer, Ptr, len);

    ResData -> Pointer += (int) len;

    return count;

}

// SEEK_CUR is assumed

static

BOOL MemorySeek(struct _lcms_iccprofile_struct* Icc, size_t offset)

{

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

    if (offset > ResData ->Size) {

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

         return TRUE;

    }

    ResData ->Pointer = (DWORD) offset;

    return FALSE;

}

// FTell

static

size_t MemoryTell(struct _lcms_iccprofile_struct* Icc)

{

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

    return ResData -> Pointer;

}

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

static

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

{

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

       if (size == 0) return TRUE;

       if (ResData != NULL)

           CopyMemory(ResData ->Block + Icc ->UsedSpace, Ptr, size);

       Icc->UsedSpace += size;

       return TRUE;

}

static

BOOL MemoryClose(struct _lcms_iccprofile_struct* Icc)

{

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

    if (ResData ->FreeBlockOnClose) {

        if (ResData ->Block) free(ResData ->Block);

    }

    free(ResData);

    return 0;

}

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

static

LPVOID FileOpen(const char* filename)

{

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

}

static

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

{

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

    if (nReaded != count) {

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

            return 0;

    }

    return nReaded;

}

static

BOOL FileSeek(struct _lcms_iccprofile_struct* Icc, size_t offset)

{

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

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

       return TRUE;

    }

    return FALSE;

}

static

size_t FileTell(struct _lcms_iccprofile_struct* Icc)

{

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

}

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

static

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

{

       if (size == 0) return TRUE;

       Icc->UsedSpace += size;

       if (Icc->stream == NULL) {

              return TRUE;

       }

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

}

static

BOOL FileClose(struct _lcms_iccprofile_struct* Icc)

{

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

}

// ----------------------------------------------------------------------------------------------------

// Creates an empty structure holding all required parameters

cmsHPROFILE _cmsCreateProfilePlaceholder(void)

{

    LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) malloc(sizeof(LCMSICCPROFILE));

    if (Icc == NULL) return NULL;

    // Empty values

    ZeroMemory(Icc, sizeof(LCMSICCPROFILE));

    // Make sure illuminant is correct

    Icc ->Illuminant = *cmsD50_XYZ();

    // Set it to empty

    Icc -> TagCount   = 0;

    // Return the handle

    return (cmsHPROFILE) Icc;

}

// Return the number of tags

icInt32Number LCMSEXPORT cmsGetTagCount(cmsHPROFILE hProfile)

{

    LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) hProfile;

    return  Icc->TagCount;

}

// Return the tag signature of a given tag number

icTagSignature LCMSEXPORT cmsGetTagSignature(cmsHPROFILE hProfile, icInt32Number n)

{

    LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) hProfile;

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

    return Icc ->TagNames[n];

}

// Search for a specific tag in tag dictionary

// Returns position or -1 if tag not found

icInt32Number _cmsSearchTag(LPLCMSICCPROFILE Profile, icTagSignature sig, BOOL lSignalError)

{

       icInt32Number i;

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

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

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

                            return i;

       }

       if (lSignalError)

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

       return -1;

}

// Check existance

BOOL LCMSEXPORT cmsIsTag(cmsHPROFILE hProfile, icTagSignature sig)

{

       LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;

       return _cmsSearchTag(Icc, sig, FALSE) >= 0;

}

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

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

{

    LPVOID Ptr;

    icInt32Number i;

    i = _cmsSearchTag(Icc, sig, FALSE);

    if (i >=0) {

        if (Icc -> TagPtrs[i]) free(Icc -> TagPtrs[i]);

    }

    else  {

        i = Icc -> TagCount;

        Icc -> TagCount++;

        if (Icc ->TagCount >= MAX_TABLE_TAG) {

            cmsSignalError(LCMS_ERRC_ABORTED, "Too many tags (%d)", MAX_TABLE_TAG);

            Icc ->TagCount = MAX_TABLE_TAG-1;

        }

    }

    Ptr = malloc(size);

    CopyMemory(Ptr, Init, size);

    Icc ->TagNames[i] = sig;

    Icc ->TagSizes[i] = size;

    Icc ->TagPtrs[i]  = Ptr;

    return Ptr;

}

// Creates a profile from file read placeholder

LPLCMSICCPROFILE _cmsCreateProfileFromFilePlaceholder(const char* FileName)

{

    LPLCMSICCPROFILE NewIcc;

    LPVOID ICCfile = FileOpen(FileName);

    if (ICCfile == NULL) {

              cmsSignalError(LCMS_ERRC_ABORTED, "File '%s' not found", FileName);

              return NULL;

    }

    NewIcc = (LPLCMSICCPROFILE) _cmsCreateProfilePlaceholder();

    if (NewIcc == NULL) return NULL;

    strncpy(NewIcc -> PhysicalFile, FileName, MAX_PATH-1);

    NewIcc ->stream = ICCfile;

    NewIcc ->Read  = FileRead;

    NewIcc ->Seek  = FileSeek;

    NewIcc ->Tell  = FileTell;

    NewIcc ->Close = FileClose;

    NewIcc ->Write = NULL;

    NewIcc ->IsWrite = FALSE;

    return NewIcc;

}

// Creates a profile from memory read placeholder

LPLCMSICCPROFILE _cmsCreateProfileFromMemPlaceholder(LPVOID MemPtr, DWORD dwSize)

{

    LPLCMSICCPROFILE NewIcc;

    LPVOID ICCfile = MemoryOpen((LPBYTE) MemPtr, (size_t) dwSize, 'r');

    if (ICCfile == NULL) {

        cmsSignalError(LCMS_ERRC_ABORTED, "Couldn't allocate %ld bytes for profile", dwSize);

        return NULL;

    }

    NewIcc = (LPLCMSICCPROFILE) _cmsCreateProfilePlaceholder();

    if (NewIcc == NULL) return NULL;

    NewIcc -> PhysicalFile[0] = 0;

    NewIcc ->stream = ICCfile;

    NewIcc ->Read  = MemoryRead;

    NewIcc ->Seek  = MemorySeek;

    NewIcc ->Tell  = MemoryTell;

    NewIcc ->Close = MemoryClose;

    NewIcc ->Write = NULL;

    NewIcc ->IsWrite = FALSE;

    return NewIcc;

}

// Turn a placeholder into file writter

void _cmsSetSaveToDisk(LPLCMSICCPROFILE Icc, const char* FileName)

{

    if (FileName == NULL) {

          Icc ->stream = NULL;

    }

    else {

          Icc ->stream = fopen(FileName, "wb");

          if (Icc ->stream == NULL)

                cmsSignalError(LCMS_ERRC_ABORTED, "Couldn't write to file '%s'", FileName);

    }

    Icc ->Write = FileWrite;   // Save to disk

    Icc ->Close = FileClose;

}

// Turn a  placeholder into memory writter

void _cmsSetSaveToMemory(LPLCMSICCPROFILE Icc, LPVOID MemPtr, size_t dwSize)

{

    if (MemPtr == NULL) {

        Icc ->stream = NULL;

    }

    else {

        Icc ->stream = (FILEMEM*) MemoryOpen((LPBYTE) MemPtr, dwSize, 'w');

        if (Icc ->stream == NULL)

                cmsSignalError(LCMS_ERRC_ABORTED, "Couldn't write to memory");

    }

    Icc ->Write = MemoryWrite;

    Icc ->Close = MemoryClose;

}

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

BOOL LCMSEXPORT cmsTakeMediaWhitePoint(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)

{

     LPLCMSICCPROFILE    Icc = (LPLCMSICCPROFILE) hProfile;

     *Dest = Icc -> MediaWhitePoint;

     return TRUE;

}

BOOL LCMSEXPORT cmsTakeMediaBlackPoint(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)

{

      LPLCMSICCPROFILE    Icc = (LPLCMSICCPROFILE) hProfile;

      *Dest = Icc -> MediaBlackPoint;

      return TRUE;

}

BOOL  LCMSEXPORT cmsTakeIluminant(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)

{

       LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;

       *Dest = Icc -> Illuminant;

       return TRUE;

}

int LCMSEXPORT cmsTakeRenderingIntent(cmsHPROFILE hProfile)

{

       LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;

       return (int) Icc -> RenderingIntent;

}

void LCMSEXPORT cmsSetRenderingIntent(cmsHPROFILE hProfile, int RenderingIntent)

{

    LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;

    Icc -> RenderingIntent = (icRenderingIntent) RenderingIntent;

}

DWORD LCMSEXPORT cmsTakeHeaderFlags(cmsHPROFILE hProfile)

{

       LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;

       return (DWORD) Icc -> flags;

}

void LCMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, DWORD Flags)

{

    LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;

    Icc -> flags = (icUInt32Number) Flags;

}

DWORD LCMSEXPORT cmsTakeHeaderAttributes(cmsHPROFILE hProfile)

{

       LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;

       return (DWORD) Icc -> attributes;