/*

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

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

// Optimization for 8 bits, Shaper-CLUT (3 inputs only)

typedef struct {

    cmsContext ContextID;

    const cmsInterpParams* p;   // Tetrahedrical interpolation parameters. This is a not-owned pointer.

    cmsUInt16Number rx[256], ry[256], rz[256];

    cmsUInt32Number X0[256], Y0[256], Z0[256];  // Precomputed nodes and offsets for 8-bit input data

} Prelin8Data;

// Generic optimization for 16 bits Shaper-CLUT-Shaper (any inputs)

typedef struct {

    cmsContext ContextID;

    // Number of channels

    int nInputs;

    int nOutputs;

    _cmsInterpFn16 EvalCurveIn16[MAX_INPUT_DIMENSIONS];       // The maximum number of input channels is known in advance

    cmsInterpParams*  ParamsCurveIn16[MAX_INPUT_DIMENSIONS];

    _cmsInterpFn16 EvalCLUT;            // The evaluator for 3D grid

    const cmsInterpParams* CLUTparams;  // (not-owned pointer)

    _cmsInterpFn16* EvalCurveOut16;       // Points to an array of curve evaluators in 16 bits (not-owned pointer)

    cmsInterpParams**  ParamsCurveOut16;  // Points to an array of references to interpolation params (not-owned pointer)

} Prelin16Data;

// Optimization for matrix-shaper in 8 bits. Numbers are operated in n.14 signed, tables are stored in 1.14 fixed

typedef cmsInt32Number cmsS1Fixed14Number;   // Note that this may hold more than 16 bits!

#define DOUBLE_TO_1FIXED14(x) ((cmsS1Fixed14Number) floor((x) * 16384.0 + 0.5))

typedef struct {

    cmsContext ContextID;

    cmsS1Fixed14Number Shaper1R[256];  // from 0..255 to 1.14  (0.0...1.0)

    cmsS1Fixed14Number Shaper1G[256];

    cmsS1Fixed14Number Shaper1B[256];

    cmsS1Fixed14Number Mat[3][3];     // n.14 to n.14 (needs a saturation after that)

    cmsS1Fixed14Number Off[3];

    cmsUInt16Number Shaper2R[16385];    // 1.14 to 0..255

    cmsUInt16Number Shaper2G[16385];

    cmsUInt16Number Shaper2B[16385];

} MatShaper8Data;

// Curves, optimization is shared between 8 and 16 bits

typedef struct {

    cmsContext ContextID;

    int nCurves;                  // Number of curves

    int nElements;                // Elements in curves

    cmsUInt16Number** Curves;     // Points to a dynamically  allocated array

} Curves16Data;

// Simple optimizations ----------------------------------------------------------------------------------------------------------

// Remove an element in linked chain

static

void _RemoveElement(cmsStage** head)

{

    cmsStage* mpe = *head;

    cmsStage* next = mpe ->Next;

    *head = next;

    cmsStageFree(mpe);

}

// Remove all identities in chain. Note that pt actually is a double pointer to the element that holds the pointer.

static

cmsBool _Remove1Op(cmsPipeline* Lut, cmsStageSignature UnaryOp)

{

    cmsStage** pt = &Lut ->Elements;

    cmsBool AnyOpt = FALSE;

    while (*pt != NULL) {

        if ((*pt) ->Implements == UnaryOp) {

            _RemoveElement(pt);

            AnyOpt = TRUE;

        }

        else

            pt = &((*pt) -> Next);

    }

    return AnyOpt;

}

// Same, but only if two adjacent elements are found

static

cmsBool _Remove2Op(cmsPipeline* Lut, cmsStageSignature Op1, cmsStageSignature Op2)

{

    cmsStage** pt1;

    cmsStage** pt2;

    cmsBool AnyOpt = FALSE;

    pt1 = &Lut ->Elements;

    if (*pt1 == NULL) return AnyOpt;

    while (*pt1 != NULL) {

        pt2 = &((*pt1) -> Next);

        if (*pt2 == NULL) return AnyOpt;

        if ((*pt1) ->Implements == Op1 && (*pt2) ->Implements == Op2) {

            _RemoveElement(pt2);

            _RemoveElement(pt1);

            AnyOpt = TRUE;

        }

        else

            pt1 = &((*pt1) -> Next);

    }

    return AnyOpt;

}

// Preoptimize just gets rif of no-ops coming paired. Conversion from v2 to v4 followed

// by a v4 to v2 and vice-versa. The elements are then discarded.

static

cmsBool PreOptimize(cmsPipeline* Lut)

{

    cmsBool AnyOpt = FALSE, Opt;

    do {

        Opt = FALSE;

        // Remove all identities

        Opt |= _Remove1Op(Lut, cmsSigIdentityElemType);

        // Remove XYZ2Lab followed by Lab2XYZ

        Opt |= _Remove2Op(Lut, cmsSigXYZ2LabElemType, cmsSigLab2XYZElemType);

        // Remove Lab2XYZ followed by XYZ2Lab

        Opt |= _Remove2Op(Lut, cmsSigLab2XYZElemType, cmsSigXYZ2LabElemType);

        // Remove V4 to V2 followed by V2 to V4

        Opt |= _Remove2Op(Lut, cmsSigLabV4toV2, cmsSigLabV2toV4);

        // Remove V2 to V4 followed by V4 to V2

        Opt |= _Remove2Op(Lut, cmsSigLabV2toV4, cmsSigLabV4toV2);

        // Remove float pcs Lab conversions

        Opt |= _Remove2Op(Lut, cmsSigLab2FloatPCS, cmsSigFloatPCS2Lab);

        // Remove float pcs Lab conversions

        Opt |= _Remove2Op(Lut, cmsSigXYZ2FloatPCS, cmsSigFloatPCS2XYZ);

        if (Opt) AnyOpt = TRUE;

    } while (Opt);

    return AnyOpt;

}

static

void Eval16nop1D(register const cmsUInt16Number Input[],

                 register cmsUInt16Number Output[],

                 register const struct _cms_interp_struc* p)

{

    Output[0] = Input[0];

    cmsUNUSED_PARAMETER(p);

}

static

void PrelinEval16(register const cmsUInt16Number Input[],

                  register cmsUInt16Number Output[],

                  register const void* D)

{

    Prelin16Data* p16 = (Prelin16Data*) D;

    cmsUInt16Number  StageABC[MAX_INPUT_DIMENSIONS];

    cmsUInt16Number  StageDEF[cmsMAXCHANNELS];

    int i;

    for (i=0; i < p16 ->nInputs; i++) {

        p16 ->EvalCurveIn16[i](&Input[i], &StageABC[i], p16 ->ParamsCurveIn16[i]);

    }

    p16 ->EvalCLUT(StageABC, StageDEF, p16 ->CLUTparams);

    for (i=0; i < p16 ->nOutputs; i++) {

        p16 ->EvalCurveOut16[i](&StageDEF[i], &Output[i], p16 ->ParamsCurveOut16[i]);

    }

}

static

void PrelinOpt16free(cmsContext ContextID, void* ptr)

{

    Prelin16Data* p16 = (Prelin16Data*) ptr;

    _cmsFree(ContextID, p16 ->EvalCurveOut16);

    _cmsFree(ContextID, p16 ->ParamsCurveOut16);

    _cmsFree(ContextID, p16);

}

static

void* Prelin16dup(cmsContext ContextID, const void* ptr)

{

    Prelin16Data* p16 = (Prelin16Data*) ptr;

    Prelin16Data* Duped = _cmsDupMem(ContextID, p16, sizeof(Prelin16Data));

    if (Duped == NULL) return NULL;

    Duped ->EvalCurveOut16   = _cmsDupMem(ContextID, p16 ->EvalCurveOut16, p16 ->nOutputs * sizeof(_cmsInterpFn16));

    Duped ->ParamsCurveOut16 = _cmsDupMem(ContextID, p16 ->ParamsCurveOut16, p16 ->nOutputs * sizeof(cmsInterpParams* ));

    return Duped;

}

static

Prelin16Data* PrelinOpt16alloc(cmsContext ContextID,

                               const cmsInterpParams* ColorMap,

                               int nInputs, cmsToneCurve** In,

                               int nOutputs, cmsToneCurve** Out )

{

    int i;

    Prelin16Data* p16 = _cmsMallocZero(ContextID, sizeof(Prelin16Data));

    if (p16 == NULL) return NULL;

    p16 ->nInputs = nInputs;

    p16 -> nOutputs = nOutputs;

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

        if (In == NULL) {

            p16 -> ParamsCurveIn16[i] = NULL;

            p16 -> EvalCurveIn16[i] = Eval16nop1D;

        }

        else {

            p16 -> ParamsCurveIn16[i] = In[i] ->InterpParams;

            p16 -> EvalCurveIn16[i] = p16 ->ParamsCurveIn16[i]->Interpolation.Lerp16;

        }

    }

    p16 ->CLUTparams = ColorMap;

    p16 ->EvalCLUT   = ColorMap ->Interpolation.Lerp16;

    p16 -> EvalCurveOut16 = (_cmsInterpFn16*) _cmsCalloc(ContextID, nOutputs, sizeof(_cmsInterpFn16));

    p16 -> ParamsCurveOut16 = (cmsInterpParams**) _cmsCalloc(ContextID, nOutputs, sizeof(cmsInterpParams* ));

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

        if (Out == NULL) {

            p16 ->ParamsCurveOut16[i] = NULL;

            p16 -> EvalCurveOut16[i] = Eval16nop1D;

        }

        else {

            p16 ->ParamsCurveOut16[i] = Out[i] ->InterpParams;

            p16 -> EvalCurveOut16[i] = p16 ->ParamsCurveOut16[i]->Interpolation.Lerp16;

        }

    }

    return p16;

}

// Resampling ---------------------------------------------------------------------------------

#define PRELINEARIZATION_POINTS 4096

// Sampler implemented by another LUT. This is a clean way to precalculate the devicelink 3D CLUT for

// almost any transform. We use floating point precision and then convert from floating point to 16 bits.

static

int XFormSampler16(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)

{

    cmsPipeline* Lut = (cmsPipeline*) Cargo;

    cmsFloat32Number InFloat[cmsMAXCHANNELS], OutFloat[cmsMAXCHANNELS];

    cmsUInt32Number i;

    _cmsAssert(Lut -> InputChannels < cmsMAXCHANNELS);

    _cmsAssert(Lut -> OutputChannels < cmsMAXCHANNELS);

    // From 16 bit to floating point

    for (i=0; i < Lut ->InputChannels; i++)

        InFloat[i] = (cmsFloat32Number) (In[i] / 65535.0);

    // Evaluate in floating point

    cmsPipelineEvalFloat(InFloat, OutFloat, Lut);

    // Back to 16 bits representation

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

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

    // Always succeed

    return TRUE;

}

// Try to see if the curves of a given MPE are linear

static

cmsBool AllCurvesAreLinear(cmsStage* mpe)

{

    cmsToneCurve** Curves;

    cmsUInt32Number i, n;

    Curves = _cmsStageGetPtrToCurveSet(mpe);

    if (Curves == NULL) return FALSE;

    n = cmsStageOutputChannels(mpe);

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

        if (!cmsIsToneCurveLinear(Curves[i])) return FALSE;

    }

    return TRUE;

}

// This function replaces a specific node placed in "At" by the "Value" numbers. Its purpose

// is to fix scum dot on broken profiles/transforms. Works on 1, 3 and 4 channels

static

cmsBool  PatchLUT(cmsStage* CLUT, cmsUInt16Number At[], cmsUInt16Number Value[],

                  int nChannelsOut, int nChannelsIn)

{

    _cmsStageCLutData* Grid = (_cmsStageCLutData*) CLUT ->Data;

    cmsInterpParams* p16  = Grid ->Params;

    cmsFloat64Number px, py, pz, pw;

    int        x0, y0, z0, w0;

    int        i, index;

    if (CLUT -> Type != cmsSigCLutElemType) {

        cmsSignalError(CLUT->ContextID, cmsERROR_INTERNAL, "(internal) Attempt to PatchLUT on non-lut stage");

        return FALSE;

    }

    if (nChannelsIn == 4) {

        px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;

        py = ((cmsFloat64Number) At[1] * (p16->Domain[1])) / 65535.0;

        pz = ((cmsFloat64Number) At[2] * (p16->Domain[2])) / 65535.0;

        pw = ((cmsFloat64Number) At[3] * (p16->Domain[3])) / 65535.0;

        x0 = (int) floor(px);

        y0 = (int) floor(py);

        z0 = (int) floor(pz);

        w0 = (int) floor(pw);

        if (((px - x0) != 0) ||

            ((py - y0) != 0) ||

            ((pz - z0) != 0) ||

            ((pw - w0) != 0)) return FALSE; // Not on exact node

        index = p16 -> opta[3] * x0 +

                p16 -> opta[2] * y0 +

                p16 -> opta[1] * z0 +

                p16 -> opta[0] * w0;

    }

    else

        if (nChannelsIn == 3) {

            px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;

            py = ((cmsFloat64Number) At[1] * (p16->Domain[1])) / 65535.0;

            pz = ((cmsFloat64Number) At[2] * (p16->Domain[2])) / 65535.0;

            x0 = (int) floor(px);

            y0 = (int) floor(py);

            z0 = (int) floor(pz);

            if (((px - x0) != 0) ||

                ((py - y0) != 0) ||

                ((pz - z0) != 0)) return FALSE;  // Not on exact node

            index = p16 -> opta[2] * x0 +

                    p16 -> opta[1] * y0 +

                    p16 -> opta[0] * z0;

        }

        else

            if (nChannelsIn == 1) {

                px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;

                x0 = (int) floor(px);

                if (((px - x0) != 0)) return FALSE; // Not on exact node

                index = p16 -> opta[0] * x0;

            }

            else {

                cmsSignalError(CLUT->ContextID, cmsERROR_INTERNAL, "(internal) %d Channels are not supported on PatchLUT", nChannelsIn);

                return FALSE;

            }

            for (i=0; i < nChannelsOut; i++)

                Grid -> Tab.T[index + i] = Value[i];

            return TRUE;

}

// Auxiliar, to see if two values are equal or very different

static

cmsBool WhitesAreEqual(int n, cmsUInt16Number White1[], cmsUInt16Number White2[] )

{

    int i;

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

        if (abs(White1[i] - White2[i]) > 0xf000) return TRUE;  // Values are so extremly different that the fixup should be avoided

        if (White1[i] != White2[i]) return FALSE;

    }

    return TRUE;

}

// Locate the node for the white point and fix it to pure white in order to avoid scum dot.

static

cmsBool FixWhiteMisalignment(cmsPipeline* Lut, cmsColorSpaceSignature EntryColorSpace, cmsColorSpaceSignature ExitColorSpace)

{

    cmsUInt16Number *WhitePointIn, *WhitePointOut;

    cmsUInt16Number  WhiteIn[cmsMAXCHANNELS], WhiteOut[cmsMAXCHANNELS], ObtainedOut[cmsMAXCHANNELS];

    cmsUInt32Number i, nOuts, nIns;

    cmsStage *PreLin = NULL, *CLUT = NULL, *PostLin = NULL;

    if (!_cmsEndPointsBySpace(EntryColorSpace,

        &WhitePointIn, NULL, &nIns)) return FALSE;

    if (!_cmsEndPointsBySpace(ExitColorSpace,

        &WhitePointOut, NULL, &nOuts)) return FALSE;

    // It needs to be fixed?

    if (Lut ->InputChannels != nIns) return FALSE;

    if (Lut ->OutputChannels != nOuts) return FALSE;

    cmsPipelineEval16(WhitePointIn, ObtainedOut, Lut);

    if (WhitesAreEqual(nOuts, WhitePointOut, ObtainedOut)) return TRUE; // whites already match

    // Check if the LUT comes as Prelin, CLUT or Postlin. We allow all combinations

    if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, &PreLin, &CLUT, &PostLin))

        if (!cmsPipelineCheckAndRetreiveStages(Lut, 2, cmsSigCurveSetElemType, cmsSigCLutElemType, &PreLin, &CLUT))

            if (!cmsPipelineCheckAndRetreiveStages(Lut, 2, cmsSigCLutElemType, cmsSigCurveSetElemType, &CLUT, &PostLin))

                if (!cmsPipelineCheckAndRetreiveStages(Lut, 1, cmsSigCLutElemType, &CLUT))

                    return FALSE;

    // We need to interpolate white points of both, pre and post curves

    if (PreLin) {