/*

 * 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-2012 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"

// Allocates an empty multi profile element

cmsStage* CMSEXPORT _cmsStageAllocPlaceholder(cmsContext ContextID,

                                cmsStageSignature Type,

                                cmsUInt32Number InputChannels,

                                cmsUInt32Number OutputChannels,

                                _cmsStageEvalFn     EvalPtr,

                                _cmsStageDupElemFn  DupElemPtr,

                                _cmsStageFreeElemFn FreePtr,

                                void*             Data)

{

    cmsStage* ph = (cmsStage*) _cmsMallocZero(ContextID, sizeof(cmsStage));

    if (ph == NULL) return NULL;

    ph ->ContextID = ContextID;

    ph ->Type       = Type;

    ph ->Implements = Type;   // By default, no clue on what is implementing

    ph ->InputChannels  = InputChannels;

    ph ->OutputChannels = OutputChannels;

    ph ->EvalPtr        = EvalPtr;

    ph ->DupElemPtr     = DupElemPtr;

    ph ->FreePtr        = FreePtr;

    ph ->Data           = Data;

    return ph;

}

static

void EvaluateIdentity(const cmsFloat32Number In[],

                            cmsFloat32Number Out[],

                      const cmsStage *mpe)

{

    memmove(Out, In, mpe ->InputChannels * sizeof(cmsFloat32Number));

}

cmsStage* CMSEXPORT cmsStageAllocIdentity(cmsContext ContextID, cmsUInt32Number nChannels)

{

    return _cmsStageAllocPlaceholder(ContextID,

                                   cmsSigIdentityElemType,

                                   nChannels, nChannels,

                                   EvaluateIdentity,

                                   NULL,

                                   NULL,

                                   NULL);

 }

// Conversion functions. From floating point to 16 bits

static

void FromFloatTo16(const cmsFloat32Number In[], cmsUInt16Number Out[], cmsUInt32Number n)

{

    cmsUInt32Number i;

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

        Out[i] = _cmsQuickSaturateWord(In[i] * 65535.0);

    }

}

// From 16 bits to floating point

static

void From16ToFloat(const cmsUInt16Number In[], cmsFloat32Number Out[], cmsUInt32Number n)

{

    cmsUInt32Number i;

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

        Out[i] = (cmsFloat32Number) In[i] / 65535.0F;

    }

}

// This function is quite useful to analyze the structure of a LUT and retrieve the MPE elements

// that conform the LUT. It should be called with the LUT, the number of expected elements and

// then a list of expected types followed with a list of cmsFloat64Number pointers to MPE elements. If

// the function founds a match with current pipeline, it fills the pointers and returns TRUE

// if not, returns FALSE without touching anything. Setting pointers to NULL does bypass

// the storage process.

cmsBool  CMSEXPORT cmsPipelineCheckAndRetreiveStages(const cmsPipeline* Lut, cmsUInt32Number n, ...)

{

    va_list args;

    cmsUInt32Number i;

    cmsStage* mpe;

    cmsStageSignature Type;

    void** ElemPtr;

    // Make sure same number of elements

    if (cmsPipelineStageCount(Lut) != n) return FALSE;

    va_start(args, n);

    // Iterate across asked types

    mpe = Lut ->Elements;

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

        // Get asked type

        Type  = (cmsStageSignature)va_arg(args, cmsStageSignature);

        if (mpe ->Type != Type) {

            va_end(args);       // Mismatch. We are done.

            return FALSE;

        }

        mpe = mpe ->Next;

    }

    // Found a combination, fill pointers if not NULL

    mpe = Lut ->Elements;

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

        ElemPtr = va_arg(args, void**);

        if (ElemPtr != NULL)

            *ElemPtr = mpe;

        mpe = mpe ->Next;

    }

    va_end(args);

    return TRUE;

}

// Below there are implementations for several types of elements. Each type may be implemented by a

// evaluation function, a duplication function, a function to free resources and a constructor.

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

// Type cmsSigCurveSetElemType (curves)

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

cmsToneCurve** _cmsStageGetPtrToCurveSet(const cmsStage* mpe)

{

    _cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) mpe ->Data;

    return Data ->TheCurves;

}

static

void EvaluateCurves(const cmsFloat32Number In[],

                    cmsFloat32Number Out[],

                    const cmsStage *mpe)

{

    _cmsStageToneCurvesData* Data;

    cmsUInt32Number i;

    _cmsAssert(mpe != NULL);

    Data = (_cmsStageToneCurvesData*) mpe ->Data;

    if (Data == NULL) return;

    if (Data ->TheCurves == NULL) return;

    for (i=0; i < Data ->nCurves; i++) {

        Out[i] = cmsEvalToneCurveFloat(Data ->TheCurves[i], In[i]);

    }

}

static

void CurveSetElemTypeFree(cmsStage* mpe)

{

    _cmsStageToneCurvesData* Data;

    cmsUInt32Number i;

    _cmsAssert(mpe != NULL);

    Data = (_cmsStageToneCurvesData*) mpe ->Data;

    if (Data == NULL) return;

    if (Data ->TheCurves != NULL) {

        for (i=0; i < Data ->nCurves; i++) {

            if (Data ->TheCurves[i] != NULL)

                cmsFreeToneCurve(Data ->TheCurves[i]);

        }

    }

    _cmsFree(mpe ->ContextID, Data ->TheCurves);

    _cmsFree(mpe ->ContextID, Data);

}

static

void* CurveSetDup(cmsStage* mpe)

{

    _cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) mpe ->Data;

    _cmsStageToneCurvesData* NewElem;

    cmsUInt32Number i;

    NewElem = (_cmsStageToneCurvesData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageToneCurvesData));

    if (NewElem == NULL) return NULL;

    NewElem ->nCurves   = Data ->nCurves;

    NewElem ->TheCurves = (cmsToneCurve**) _cmsCalloc(mpe ->ContextID, NewElem ->nCurves, sizeof(cmsToneCurve*));

    if (NewElem ->TheCurves == NULL) goto Error;

    for (i=0; i < NewElem ->nCurves; i++) {

        // Duplicate each curve. It may fail.

        NewElem ->TheCurves[i] = cmsDupToneCurve(Data ->TheCurves[i]);

        if (NewElem ->TheCurves[i] == NULL) goto Error;

    }

    return (void*) NewElem;

Error:

    if (NewElem ->TheCurves != NULL) {

        for (i=0; i < NewElem ->nCurves; i++) {

            if (NewElem ->TheCurves[i])

                cmsFreeToneCurve(NewElem ->TheCurves[i]);

        }

    }

    _cmsFree(mpe ->ContextID, NewElem ->TheCurves);

    _cmsFree(mpe ->ContextID, NewElem);

    return NULL;

}

// Curves == NULL forces identity curves

cmsStage* CMSEXPORT cmsStageAllocToneCurves(cmsContext ContextID, cmsUInt32Number nChannels, cmsToneCurve* const Curves[])

{

    cmsUInt32Number i;

    _cmsStageToneCurvesData* NewElem;

    cmsStage* NewMPE;

    NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCurveSetElemType, nChannels, nChannels,

                                     EvaluateCurves, CurveSetDup, CurveSetElemTypeFree, NULL );

    if (NewMPE == NULL) return NULL;

    NewElem = (_cmsStageToneCurvesData*) _cmsMallocZero(ContextID, sizeof(_cmsStageToneCurvesData));

    if (NewElem == NULL) {

        cmsStageFree(NewMPE);

        return NULL;

    }

    NewMPE ->Data  = (void*) NewElem;

    NewElem ->nCurves   = nChannels;

    NewElem ->TheCurves = (cmsToneCurve**) _cmsCalloc(ContextID, nChannels, sizeof(cmsToneCurve*));

    if (NewElem ->TheCurves == NULL) {

        cmsStageFree(NewMPE);

        return NULL;

    }

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

        if (Curves == NULL) {

            NewElem ->TheCurves[i] = cmsBuildGamma(ContextID, 1.0);

        }

        else {

            NewElem ->TheCurves[i] = cmsDupToneCurve(Curves[i]);

        }

        if (NewElem ->TheCurves[i] == NULL) {

            cmsStageFree(NewMPE);

            return NULL;

        }

    }

   return NewMPE;

}

// Create a bunch of identity curves

cmsStage* _cmsStageAllocIdentityCurves(cmsContext ContextID, int nChannels)

{

    cmsStage* mpe = cmsStageAllocToneCurves(ContextID, nChannels, NULL);

    if (mpe == NULL) return NULL;

    mpe ->Implements = cmsSigIdentityElemType;

    return mpe;

}

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

// Type cmsSigMatrixElemType (Matrices)

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

// Special care should be taken here because precision loss. A temporary cmsFloat64Number buffer is being used

static

void EvaluateMatrix(const cmsFloat32Number In[],

                    cmsFloat32Number Out[],

                    const cmsStage *mpe)

{

    cmsUInt32Number i, j;

    _cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;

    cmsFloat64Number Tmp;

    // Input is already in 0..1.0 notation

    for (i=0; i < mpe ->OutputChannels; i++) {

        Tmp = 0;

        for (j=0; j < mpe->InputChannels; j++) {

            Tmp += In[j] * Data->Double[i*mpe->InputChannels + j];

        }

        if (Data ->Offset != NULL)

            Tmp += Data->Offset[i];

        Out[i] = (cmsFloat32Number) Tmp;

    }

    // Output in 0..1.0 domain

}

// Duplicate a yet-existing matrix element

static

void* MatrixElemDup(cmsStage* mpe)

{

    _cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;

    _cmsStageMatrixData* NewElem;

    cmsUInt32Number sz;

    NewElem = (_cmsStageMatrixData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageMatrixData));

    if (NewElem == NULL) return NULL;

    sz = mpe ->InputChannels * mpe ->OutputChannels;

    NewElem ->Double = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID, Data ->Double, sz * sizeof(cmsFloat64Number)) ;

    if (Data ->Offset)

        NewElem ->Offset = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID,

                                                Data ->Offset, mpe -> OutputChannels * sizeof(cmsFloat64Number)) ;

    return (void*) NewElem;

}

static

void MatrixElemTypeFree(cmsStage* mpe)

{

    _cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;

    if (Data == NULL)

        return;

    if (Data ->Double)

        _cmsFree(mpe ->ContextID, Data ->Double);

    if (Data ->Offset)

        _cmsFree(mpe ->ContextID, Data ->Offset);

    _cmsFree(mpe ->ContextID, mpe ->Data);

}

cmsStage*  CMSEXPORT cmsStageAllocMatrix(cmsContext ContextID, cmsUInt32Number Rows, cmsUInt32Number Cols,

                                     const cmsFloat64Number* Matrix, const cmsFloat64Number* Offset)

{

    cmsUInt32Number i, n;

    _cmsStageMatrixData* NewElem;

    cmsStage* NewMPE;

    n = Rows * Cols;

    // Check for overflow

    if (n == 0) return NULL;

    if (n >= UINT_MAX / Cols) return NULL;

    if (n >= UINT_MAX / Rows) return NULL;

    if (n < Rows || n < Cols) return NULL;

    NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigMatrixElemType, Cols, Rows,

                                     EvaluateMatrix, MatrixElemDup, MatrixElemTypeFree, NULL );

    if (NewMPE == NULL) return NULL;

    NewElem = (_cmsStageMatrixData*) _cmsMallocZero(ContextID, sizeof(_cmsStageMatrixData));

    if (NewElem == NULL) return NULL;

    NewElem ->Double = (cmsFloat64Number*) _cmsCalloc(ContextID, n, sizeof(cmsFloat64Number));

    if (NewElem->Double == NULL) {

        MatrixElemTypeFree(NewMPE);

        return NULL;

    }

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

        NewElem ->Double[i] = Matrix[i];

    }

    if (Offset != NULL) {

        NewElem ->Offset = (cmsFloat64Number*) _cmsCalloc(ContextID, Cols, sizeof(cmsFloat64Number));

        if (NewElem->Offset == NULL) {

           MatrixElemTypeFree(NewMPE);

           return NULL;

        }

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

                NewElem ->Offset[i] = Offset[i];

        }

    }

    NewMPE ->Data  = (void*) NewElem;

    return NewMPE;

}

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

// Type cmsSigCLutElemType

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

// Evaluate in true floating point

static

void EvaluateCLUTfloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)

{

    _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;

    Data -> Params ->Interpolation.LerpFloat(In, Out, Data->Params);

}

// Convert to 16 bits, evaluate, and back to floating point

static

void EvaluateCLUTfloatIn16(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)

{

    _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;

    cmsUInt16Number In16[MAX_STAGE_CHANNELS], Out16[MAX_STAGE_CHANNELS];

    _cmsAssert(mpe ->InputChannels  <= MAX_STAGE_CHANNELS);

    _cmsAssert(mpe ->OutputChannels <= MAX_STAGE_CHANNELS);

    FromFloatTo16(In, In16, mpe ->InputChannels);

    Data -> Params ->Interpolation.Lerp16(In16, Out16, Data->Params);

    From16ToFloat(Out16, Out,  mpe ->OutputChannels);

}

// Given an hypercube of b dimensions, with Dims[] number of nodes by dimension, calculate the total amount of nodes

static