/*

 * 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.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 Color Management System

//  Copyright (c) 1998-2016 Marti Maria Saguer

//

// 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.

//

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

//

#include "lcms2_internal.h"

// Tag Serialization  -----------------------------------------------------------------------------

// This file implements every single tag and tag type as described in the ICC spec. Some types

// have been deprecated, like ncl and Data. There is no implementation for those types as there

// are no profiles holding them. The programmer can also extend this list by defining his own types

// by using the appropriate plug-in. There are three types of plug ins regarding that. First type

// allows to define new tags using any existing type. Next plug-in type allows to define new types

// and the third one is very specific: allows to extend the number of elements in the multiprocessing

// elements special type.

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

// Some broken types

#define cmsCorbisBrokenXYZtype    ((cmsTagTypeSignature) 0x17A505B8)

#define cmsMonacoBrokenCurveType  ((cmsTagTypeSignature) 0x9478ee00)

// This is the linked list that keeps track of the defined types

typedef struct _cmsTagTypeLinkedList_st {

    cmsTagTypeHandler Handler;

    struct _cmsTagTypeLinkedList_st* Next;

} _cmsTagTypeLinkedList;

// Some macros to define callbacks.

#define READ_FN(x)  Type_##x##_Read

#define WRITE_FN(x) Type_##x##_Write

#define FREE_FN(x)  Type_##x##_Free

#define DUP_FN(x)   Type_##x##_Dup

// Helper macro to define a handler. Callbacks do have a fixed naming convention.

#define TYPE_HANDLER(t, x)  { (t), READ_FN(x), WRITE_FN(x), DUP_FN(x), FREE_FN(x), NULL, 0 }

// Helper macro to define a MPE handler. Callbacks do have a fixed naming convention

#define TYPE_MPE_HANDLER(t, x)  { (t), READ_FN(x), WRITE_FN(x), GenericMPEdup, GenericMPEfree, NULL, 0 }

// Register a new type handler. This routine is shared between normal types and MPE. LinkedList points to the optional list head

static

cmsBool RegisterTypesPlugin(cmsContext id, cmsPluginBase* Data, _cmsMemoryClient pos)

{

    cmsPluginTagType* Plugin = (cmsPluginTagType*) Data;

    _cmsTagTypePluginChunkType* ctx = ( _cmsTagTypePluginChunkType*) _cmsContextGetClientChunk(id, pos);

    _cmsTagTypeLinkedList *pt;

    // Calling the function with NULL as plug-in would unregister the plug in.

    if (Data == NULL) {

        // There is no need to set free the memory, as pool is destroyed as a whole.

        ctx ->TagTypes = NULL;

        return TRUE;

    }

    // Registering happens in plug-in memory pool.

    pt = (_cmsTagTypeLinkedList*) _cmsPluginMalloc(id, sizeof(_cmsTagTypeLinkedList));

    if (pt == NULL) return FALSE;

    pt ->Handler   = Plugin ->Handler;

    pt ->Next      = ctx ->TagTypes;

    ctx ->TagTypes = pt;

    return TRUE;

}

// Return handler for a given type or NULL if not found. Shared between normal types and MPE. It first tries the additons

// made by plug-ins and then the built-in defaults.

static

cmsTagTypeHandler* GetHandler(cmsTagTypeSignature sig, _cmsTagTypeLinkedList* PluginLinkedList, _cmsTagTypeLinkedList* DefaultLinkedList)

{

    _cmsTagTypeLinkedList* pt;

    for (pt = PluginLinkedList;

         pt != NULL;

         pt = pt ->Next) {

            if (sig == pt -> Handler.Signature) return &pt ->Handler;

    }

    for (pt = DefaultLinkedList;

         pt != NULL;

         pt = pt ->Next) {

            if (sig == pt -> Handler.Signature) return &pt ->Handler;

    }

    return NULL;

}

// Auxiliary to convert UTF-32 to UTF-16 in some cases

static

cmsBool _cmsWriteWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, const wchar_t* Array)

{

    cmsUInt32Number i;

    _cmsAssert(io != NULL);

    _cmsAssert(!(Array == NULL && n > 0));

    for (i=0; i < n; i++) {

        if (!_cmsWriteUInt16Number(io, (cmsUInt16Number) Array[i])) return FALSE;

    }

    return TRUE;

}

// Auxiliary to read an array of wchar_t

static

cmsBool _cmsReadWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, wchar_t* Array)

{

    cmsUInt32Number i;

    cmsUInt16Number tmp;

    _cmsAssert(io != NULL);

    for (i=0; i < n; i++) {

        if (Array != NULL) {

            if (!_cmsReadUInt16Number(io, &tmp)) return FALSE;

            Array[i] = (wchar_t) tmp;

        }

        else {

            if (!_cmsReadUInt16Number(io, NULL)) return FALSE;

        }

    }

    return TRUE;

}

// To deal with position tables

typedef cmsBool (* PositionTableEntryFn)(struct _cms_typehandler_struct* self,

                                             cmsIOHANDLER* io,

                                             void* Cargo,

                                             cmsUInt32Number n,

                                             cmsUInt32Number SizeOfTag);

// Helper function to deal with position tables as described in ICC spec 4.3

// A table of n elements is readed, where first comes n records containing offsets and sizes and

// then a block containing the data itself. This allows to reuse same data in more than one entry

static

cmsBool ReadPositionTable(struct _cms_typehandler_struct* self,

                              cmsIOHANDLER* io,

                              cmsUInt32Number Count,

                              cmsUInt32Number BaseOffset,

                              void *Cargo,

                              PositionTableEntryFn ElementFn)

{

    cmsUInt32Number i;

    cmsUInt32Number *ElementOffsets = NULL, *ElementSizes = NULL;

    // Let's take the offsets to each element

    ElementOffsets = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));

    if (ElementOffsets == NULL) goto Error;

    ElementSizes = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));

    if (ElementSizes == NULL) goto Error;

    for (i=0; i < Count; i++) {

        if (!_cmsReadUInt32Number(io, &ElementOffsets[i])) goto Error;

        if (!_cmsReadUInt32Number(io, &ElementSizes[i])) goto Error;

        ElementOffsets[i] += BaseOffset;

    }

    // Seek to each element and read it

    for (i=0; i < Count; i++) {

        if (!io -> Seek(io, ElementOffsets[i])) goto Error;

        // This is the reader callback

        if (!ElementFn(self, io, Cargo, i, ElementSizes[i])) goto Error;

    }

    // Success

    if (ElementOffsets != NULL) _cmsFree(io ->ContextID, ElementOffsets);

    if (ElementSizes != NULL) _cmsFree(io ->ContextID, ElementSizes);

    return TRUE;

Error:

    if (ElementOffsets != NULL) _cmsFree(io ->ContextID, ElementOffsets);

    if (ElementSizes != NULL) _cmsFree(io ->ContextID, ElementSizes);

    return FALSE;

}

// Same as anterior, but for write position tables

static

cmsBool WritePositionTable(struct _cms_typehandler_struct* self,

                               cmsIOHANDLER* io,

                               cmsUInt32Number SizeOfTag,

                               cmsUInt32Number Count,

                               cmsUInt32Number BaseOffset,

                               void *Cargo,

                               PositionTableEntryFn ElementFn)

{

    cmsUInt32Number i;

    cmsUInt32Number DirectoryPos, CurrentPos, Before;

    cmsUInt32Number *ElementOffsets = NULL, *ElementSizes = NULL;

     // Create table

    ElementOffsets = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));

    if (ElementOffsets == NULL) goto Error;

    ElementSizes = (cmsUInt32Number *) _cmsCalloc(io ->ContextID, Count, sizeof(cmsUInt32Number));

    if (ElementSizes == NULL) goto Error;

    // Keep starting position of curve offsets

    DirectoryPos = io ->Tell(io);

    // Write a fake directory to be filled latter on

    for (i=0; i < Count; i++) {

        if (!_cmsWriteUInt32Number(io, 0)) goto Error;  // Offset

        if (!_cmsWriteUInt32Number(io, 0)) goto Error;  // size

    }

    // Write each element. Keep track of the size as well.

    for (i=0; i < Count; i++) {

        Before = io ->Tell(io);

        ElementOffsets[i] = Before - BaseOffset;

        // Callback to write...

        if (!ElementFn(self, io, Cargo, i, SizeOfTag)) goto Error;

        // Now the size

        ElementSizes[i] = io ->Tell(io) - Before;

    }

    // Write the directory

    CurrentPos = io ->Tell(io);

    if (!io ->Seek(io, DirectoryPos)) goto Error;

    for (i=0; i <  Count; i++) {

        if (!_cmsWriteUInt32Number(io, ElementOffsets[i])) goto Error;

        if (!_cmsWriteUInt32Number(io, ElementSizes[i])) goto Error;

    }

    if (!io ->Seek(io, CurrentPos)) goto Error;

    if (ElementOffsets != NULL) _cmsFree(io ->ContextID, ElementOffsets);

    if (ElementSizes != NULL) _cmsFree(io ->ContextID, ElementSizes);

    return TRUE;

Error:

    if (ElementOffsets != NULL) _cmsFree(io ->ContextID, ElementOffsets);

    if (ElementSizes != NULL) _cmsFree(io ->ContextID, ElementSizes);

    return FALSE;

}

// ********************************************************************************

// Type XYZ. Only one value is allowed

// ********************************************************************************

//The XYZType contains an array of three encoded values for the XYZ tristimulus

//values. Tristimulus values must be non-negative. The signed encoding allows for

//implementation optimizations by minimizing the number of fixed formats.

static

void *Type_XYZ_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)

{

    cmsCIEXYZ* xyz;

    *nItems = 0;

    xyz = (cmsCIEXYZ*) _cmsMallocZero(self ->ContextID, sizeof(cmsCIEXYZ));

    if (xyz == NULL) return NULL;

    if (!_cmsReadXYZNumber(io, xyz)) {

        _cmsFree(self ->ContextID, xyz);

        return NULL;

    }

    *nItems = 1;

    return (void*) xyz;

    cmsUNUSED_PARAMETER(SizeOfTag);

}

static

cmsBool  Type_XYZ_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)

{

    return _cmsWriteXYZNumber(io, (cmsCIEXYZ*) Ptr);

    cmsUNUSED_PARAMETER(nItems);

    cmsUNUSED_PARAMETER(self);

}

static

void* Type_XYZ_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n)

{

    return _cmsDupMem(self ->ContextID, Ptr, sizeof(cmsCIEXYZ));

    cmsUNUSED_PARAMETER(n);

}

static

void Type_XYZ_Free(struct _cms_typehandler_struct* self, void *Ptr)

{

    _cmsFree(self ->ContextID, Ptr);

}

static

cmsTagTypeSignature DecideXYZtype(cmsFloat64Number ICCVersion, const void *Data)

{

    return cmsSigXYZType;

    cmsUNUSED_PARAMETER(ICCVersion);

    cmsUNUSED_PARAMETER(Data);

}

// ********************************************************************************

// Type chromaticity. Only one value is allowed

// ********************************************************************************

// The chromaticity tag type provides basic chromaticity data and type of

// phosphors or colorants of a monitor to applications and utilities.

static

void *Type_Chromaticity_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)

{

    cmsCIExyYTRIPLE* chrm;

    cmsUInt16Number nChans, Table;

    *nItems = 0;

    chrm =  (cmsCIExyYTRIPLE*) _cmsMallocZero(self ->ContextID, sizeof(cmsCIExyYTRIPLE));

    if (chrm == NULL) return NULL;

    if (!_cmsReadUInt16Number(io, &nChans)) goto Error;

    // Let's recover from a bug introduced in early versions of lcms1

    if (nChans == 0 && SizeOfTag == 32) {

        if (!_cmsReadUInt16Number(io, NULL)) goto Error;

        if (!_cmsReadUInt16Number(io, &nChans)) goto Error;

    }

    if (nChans != 3) goto Error;

    if (!_cmsReadUInt16Number(io, &Table)) goto Error;

    if (!_cmsRead15Fixed16Number(io, &chrm ->Red.x)) goto Error;

    if (!_cmsRead15Fixed16Number(io, &chrm ->Red.y)) goto Error;

    chrm ->Red.Y = 1.0;

    if (!_cmsRead15Fixed16Number(io, &chrm ->Green.x)) goto Error;

    if (!_cmsRead15Fixed16Number(io, &chrm ->Green.y)) goto Error;

    chrm ->Green.Y = 1.0;

    if (!_cmsRead15Fixed16Number(io, &chrm ->Blue.x)) goto Error;

    if (!_cmsRead15Fixed16Number(io, &chrm ->Blue.y)) goto Error;

    chrm ->Blue.Y = 1.0;

    *nItems = 1;

    return (void*) chrm;

Error:

    _cmsFree(self ->ContextID, (void*) chrm);

    return NULL;

    cmsUNUSED_PARAMETER(SizeOfTag);

}

static

cmsBool  SaveOneChromaticity(cmsFloat64Number x, cmsFloat64Number y, cmsIOHANDLER* io)

{

    if (!_cmsWriteUInt32Number(io, _cmsDoubleTo15Fixed16(x))) return FALSE;

    if (!_cmsWriteUInt32Number(io, _cmsDoubleTo15Fixed16(y))) return FALSE;

    return TRUE;

}

static

cmsBool  Type_Chromaticity_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)

{

    cmsCIExyYTRIPLE* chrm = (cmsCIExyYTRIPLE*) Ptr;

    if (!_cmsWriteUInt16Number(io, 3)) return FALSE;        // nChannels

    if (!_cmsWriteUInt16Number(io, 0)) return FALSE;        // Table

    if (!SaveOneChromaticity(chrm -> Red.x,   chrm -> Red.y, io)) return FALSE;

    if (!SaveOneChromaticity(chrm -> Green.x, chrm -> Green.y, io)) return FALSE;

    if (!SaveOneChromaticity(chrm -> Blue.x,  chrm -> Blue.y, io)) return FALSE;

    return TRUE;

    cmsUNUSED_PARAMETER(nItems);

    cmsUNUSED_PARAMETER(self);

}

static

void* Type_Chromaticity_Dup(struct _cms_typehandler_struct* self, const void *Ptr, cmsUInt32Number n)

{

    return _cmsDupMem(self ->ContextID, Ptr, sizeof(cmsCIExyYTRIPLE));

    cmsUNUSED_PARAMETER(n);

}

static

void Type_Chromaticity_Free(struct _cms_typehandler_struct* self, void* Ptr)

{

    _cmsFree(self ->ContextID, Ptr);

}

// ********************************************************************************

// Type cmsSigColorantOrderType

// ********************************************************************************

// This is an optional tag which specifies the laydown order in which colorants will

// be printed on an n-colorant device. The laydown order may be the same as the

// channel generation order listed in the colorantTableTag or the channel order of a

// colour space such as CMYK, in which case this tag is not needed. When this is not

// the case (for example, ink-towers sometimes use the order KCMY), this tag may be

// used to specify the laydown order of the colorants.

static

void *Type_ColorantOrderType_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsUInt32Number* nItems, cmsUInt32Number SizeOfTag)

{

    cmsUInt8Number* ColorantOrder;

    cmsUInt32Number Count;

    *nItems = 0;

    if (!_cmsReadUInt32Number(io, &Count)) return NULL;

    if (Count > cmsMAXCHANNELS) return NULL;

    ColorantOrder = (cmsUInt8Number*) _cmsCalloc(self ->ContextID, cmsMAXCHANNELS, sizeof(cmsUInt8Number));

    if (ColorantOrder == NULL) return NULL;

    // We use FF as end marker

    memset(ColorantOrder, 0xFF, cmsMAXCHANNELS * sizeof(cmsUInt8Number));

    if (io ->Read(io, ColorantOrder, sizeof(cmsUInt8Number), Count) != Count) {

        _cmsFree(self ->ContextID, (void*) ColorantOrder);

        return NULL;

    }

    *nItems = 1;

    return (void*) ColorantOrder;

    cmsUNUSED_PARAMETER(SizeOfTag);

}

static

cmsBool Type_ColorantOrderType_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)

{

    cmsUInt8Number*  ColorantOrder = (cmsUInt8Number*) Ptr;

    cmsUInt32Number i, sz, Count;

    // Get the length

    for (Count=i=0; i < cmsMAXCHANNELS; i++) {

        if (ColorantOrder[i] != 0xFF) Count++;

    }

    if (!_cmsWriteUInt32Number(io, Count)) return FALSE;

    sz = Count * sizeof(cmsUInt8Number);

    if (!io -> Write(io, sz, ColorantOrder)) return FALSE;