/*

 * 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

//

// 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 "lcms.h"

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

static volatile int GlobalBlackPreservationStrategy = 0;

// Quantize a value 0 <= i < MaxSamples

WORD _cmsQuantizeVal(double i, int MaxSamples)

{

       double x;

       x = ((double) i * 65535.) / (double) (MaxSamples - 1);

       return (WORD) floor(x + .5);

}

// Is a table linear?

int cmsIsLinear(WORD Table[], int nEntries)

{

       register int i;

       int diff;

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

           diff = abs((int) Table[i] - (int) _cmsQuantizeVal(i, nEntries));

           if (diff > 3)

                     return 0;

       }

       return 1;

}

// pow() restricted to integer

static

int ipow(int base, int exp)

{

        int res = base;

        while (--exp)

               res *= base;

        return res;

}

// Given n, 0<=n<=clut^dim, returns the colorant.

static

int ComponentOf(int n, int clut, int nColorant)

{

        if (nColorant <= 0)

                return (n % clut);

        n /= ipow(clut, nColorant);

        return (n % clut);

}

// This routine does a sweep on whole input space, and calls its callback

// function on knots. returns TRUE if all ok, FALSE otherwise.

{

   int i, t, nTotalPoints, Colorant, index;

   WORD In[MAXCHANNELS], Out[MAXCHANNELS];

   nTotalPoints = ipow(Lut->cLutPoints, Lut -> InputChan);

   index = 0;

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

        for (t=0; t < (int) Lut -> InputChan; t++) {

                Colorant =  ComponentOf(i, Lut -> cLutPoints, (Lut -> InputChan - t  - 1 ));

                In[t]    = _cmsQuantizeVal(Colorant, Lut -> cLutPoints);

        }

        if (dwFlags & SAMPLER_HASTL1) {

                 for (t=0; t < (int) Lut -> InputChan; t++)

                     In[t] = cmsReverseLinearInterpLUT16(In[t],

                                                Lut -> L1[t],

                                                &Lut -> In16params);

        }

             for (t=0; t < (int) Lut -> OutputChan; t++)

        if (!Sampler(In, Out, Cargo))

                return FALSE;

        if (!(dwFlags & SAMPLER_INSPECT)) {

            if (dwFlags & SAMPLER_HASTL2) {

                for (t=0; t < (int) Lut -> OutputChan; t++)

                     Out[t] = cmsReverseLinearInterpLUT16(Out[t],

                                                   Lut -> L2[t],

                                                   &Lut -> Out16params);

                }

            for (t=0; t < (int) Lut -> OutputChan; t++)

                        Lut->T[index + t] = Out[t];

        }

        index += Lut -> OutputChan;

    }

    return TRUE;

}

// choose reasonable resolution

int _cmsReasonableGridpointsByColorspace(icColorSpaceSignature Colorspace, DWORD dwFlags)

{

    int nChannels;

    // Already specified?

    if (dwFlags & 0x00FF0000) {

            // Yes, grab'em

            return (dwFlags >> 16) & 0xFF;

    }

    nChannels = _cmsChannelsOf(Colorspace);

    // HighResPrecalc is maximum resolution

    if (dwFlags & cmsFLAGS_HIGHRESPRECALC) {

        if (nChannels > 4)

                return 7;       // 7 for Hifi

        if (nChannels == 4)     // 23 for CMYK

                return 23;

        return 49;      // 49 for RGB and others

    }

    // LowResPrecal is stripped resolution

    if (dwFlags & cmsFLAGS_LOWRESPRECALC) {

        if (nChannels > 4)

                return 6;       // 6 for Hifi

        if (nChannels == 1)

                return 33;      // For monochrome

        return 17;              // 17 for remaining

    }

    // Default values

    if (nChannels > 4)

                return 7;       // 7 for Hifi

    if (nChannels == 4)

                return 17;      // 17 for CMYK

    return 33;                  // 33 for RGB

}

// Sampler implemented by another transform. This is a clean way to

// precalculate the devicelink 3D CLUT for almost any transform

static

int XFormSampler(register WORD In[], register WORD Out[], register LPVOID Cargo)

{

        cmsDoTransform((cmsHTRANSFORM) Cargo, In, Out, 1);

        return TRUE;

}

// This routine does compute the devicelink CLUT containing whole

// transform. Handles any channel number.

LPLUT _cmsPrecalculateDeviceLink(cmsHTRANSFORM h, DWORD dwFlags)

{

       _LPcmsTRANSFORM p = (_LPcmsTRANSFORM) h;

       LPLUT Grid;

       int nGridPoints;

       DWORD dwFormatIn, dwFormatOut;

       int ChannelsIn, ChannelsOut;

       LPLUT SaveGamutLUT;

       // Remove any gamut checking

       SaveGamutLUT = p ->Gamut;

       p ->Gamut = NULL;

       ChannelsIn   = _cmsChannelsOf(p -> EntryColorSpace);

       ChannelsOut  = _cmsChannelsOf(p -> ExitColorSpace);

       nGridPoints = _cmsReasonableGridpointsByColorspace(p -> EntryColorSpace, dwFlags);

       Grid =  cmsAllocLUT();

       if (!Grid) return NULL;

       Grid = cmsAlloc3DGrid(Grid, nGridPoints, ChannelsIn, ChannelsOut);

       // Compute device link on 16-bit basis

       dwFormatIn   = (CHANNELS_SH(ChannelsIn)|BYTES_SH(2));

       dwFormatOut  = (CHANNELS_SH(ChannelsOut)|BYTES_SH(2));

       // Fix gamut & gamma possible mismatches.

       if (!(dwFlags & cmsFLAGS_NOPRELINEARIZATION)) {

           cmsHTRANSFORM hOne[1];

           hOne[0] = h;

           _cmsComputePrelinearizationTablesFromXFORM(hOne, 1, Grid);

       }

       // Attention to this typecast! we can take the luxury to

       // do this since cmsHTRANSFORM is only an alias to a pointer

       // to the transform struct.

       if (!cmsSample3DGrid(Grid, XFormSampler, (LPVOID) p, Grid -> wFlags)) {

                cmsFreeLUT(Grid);

       }

       return Grid;

}

// Sampler for Black-preserving CMYK->CMYK transforms

typedef struct {

                cmsHTRANSFORM cmyk2cmyk;

                cmsHTRANSFORM cmyk2Lab;

                LPGAMMATABLE  KTone;

                L16PARAMS     KToneParams;

                LPLUT         LabK2cmyk;

                double        MaxError;

                cmsHTRANSFORM hRoundTrip;

                int           MaxTAC;

                cmsHTRANSFORM hProofOutput;

    } BPCARGO, *LPBPCARGO;

// Preserve black only if that is the only ink used

static

int BlackPreservingGrayOnlySampler(register WORD In[], register WORD Out[], register LPVOID Cargo)

{

    BPCARGO* bp = (LPBPCARGO) Cargo;

    // If going across black only, keep black only

    if (In[0] == 0 && In[1] == 0 && In[2] == 0) {

        // TAC does not apply because it is black ink!

        Out[0] = Out[1] = Out[2] = 0;

        Out[3] = cmsLinearInterpLUT16(In[3], bp->KTone ->GammaTable, &bp->KToneParams);

        return 1;

    }

    // Keep normal transform for other colors

    cmsDoTransform(bp ->cmyk2cmyk, In, Out, 1);

    return 1;

}

static

int BlackPreservingSampler(register WORD In[], register WORD Out[], register LPVOID Cargo)

{

    WORD LabK[4];

    double SumCMY, SumCMYK, Error;

    cmsCIELab ColorimetricLab, BlackPreservingLab;

    BPCARGO* bp = (LPBPCARGO) Cargo;

    // Get the K across Tone curve

    LabK[3] = cmsLinearInterpLUT16(In[3], bp->KTone ->GammaTable, &bp->KToneParams);

    // If going across black only, keep black only

    if (In[0] == 0 && In[1] == 0 && In[2] == 0) {

        Out[0] = Out[1] = Out[2] = 0;

        Out[3] = LabK[3];

        return 1;

    }

    // Try the original transform, maybe K is already ok (valid on K=0)

    cmsDoTransform(bp ->cmyk2cmyk, In, Out, 1);

    if (Out[3] == LabK[3]) return 1;

    // No, mesure and keep Lab measurement for further usage

    cmsDoTransform(bp->hProofOutput, Out, &ColorimetricLab, 1);

    // Is not black only and the transform doesn't keep black.

    // Obtain the Lab of CMYK. After that we have Lab + K

    cmsDoTransform(bp ->cmyk2Lab, In, LabK, 1);

    // Obtain the corresponding CMY using reverse interpolation.

    // As a seed, we use the colorimetric CMY

    cmsEvalLUTreverse(bp ->LabK2cmyk, LabK, Out, Out);

    // Estimate the error

    cmsDoTransform(bp->hProofOutput, Out, &BlackPreservingLab, 1);

    Error = cmsDeltaE(&ColorimetricLab, &BlackPreservingLab);

    // Apply TAC if needed

    SumCMY   = Out[0]  + Out[1] + Out[2];

    SumCMYK  = SumCMY + Out[3];

    if (SumCMYK > bp ->MaxTAC) {

        double Ratio = 1 - ((SumCMYK - bp->MaxTAC) / SumCMY);

        if (Ratio < 0)

                  Ratio = 0;

        Out[0] = (WORD) floor(Out[0] * Ratio + 0.5);     // C

        Out[1] = (WORD) floor(Out[1] * Ratio + 0.5);     // M

        Out[2] = (WORD) floor(Out[2] * Ratio + 0.5);     // Y

    }

    return 1;

}

// Sample whole gamut to estimate maximum TAC

#ifdef _MSC_VER

#pragma warning(disable : 4100)

#endif

static

int EstimateTAC(register WORD In[], register WORD Out[], register LPVOID Cargo)

{

    BPCARGO* bp = (LPBPCARGO) Cargo;

    WORD RoundTrip[4];

    int Sum;

    cmsDoTransform(bp->hRoundTrip, In, RoundTrip, 1);

    Sum = RoundTrip[0] + RoundTrip[1] + RoundTrip[2] + RoundTrip[3];

    if (Sum > bp ->MaxTAC)

            bp ->MaxTAC = Sum;

    return 1;

}

// Estimate the maximum error

static

int BlackPreservingEstimateErrorSampler(register WORD In[], register WORD Out[], register LPVOID Cargo)

{

    BPCARGO* bp = (LPBPCARGO) Cargo;

    WORD ColorimetricOut[4];

    cmsCIELab ColorimetricLab, BlackPreservingLab;

    double Error;

    if (In[0] == 0 && In[1] == 0 && In[2] == 0) return 1;

    cmsDoTransform(bp->cmyk2cmyk, In, ColorimetricOut, 1);

    cmsDoTransform(bp->hProofOutput, ColorimetricOut, &ColorimetricLab, 1);

    cmsDoTransform(bp->hProofOutput, Out, &BlackPreservingLab, 1);

    Error = cmsDeltaE(&ColorimetricLab, &BlackPreservingLab);

    if (Error > bp ->MaxError)

        bp ->MaxError = Error;

    return 1;

}

// Setup the K preservation strategy

int LCMSEXPORT cmsSetCMYKPreservationStrategy(int n)

{

    int OldVal = GlobalBlackPreservationStrategy;

    if (n >= 0)

            GlobalBlackPreservationStrategy = n;

    return OldVal;

}

// Get a pointer to callback on depending of strategy

static

_cmsSAMPLER _cmsGetBlackPreservationSampler(void)

{

    switch (GlobalBlackPreservationStrategy) {

        case 0: return BlackPreservingGrayOnlySampler;

        default: return BlackPreservingSampler;

   }

}

// This is the black-preserving devicelink generator

LPLUT _cmsPrecalculateBlackPreservingDeviceLink(cmsHTRANSFORM hCMYK2CMYK, DWORD dwFlags)

{

       _LPcmsTRANSFORM p = (_LPcmsTRANSFORM) hCMYK2CMYK;

       BPCARGO Cargo;

       LPLUT Grid;

       DWORD LocalFlags;

       cmsHPROFILE hLab = cmsCreateLabProfile(NULL);

       int nGridPoints;

       icTagSignature Device2PCS[] = {icSigAToB0Tag,       // Perceptual

                                      icSigAToB1Tag,       // Relative colorimetric

                                      icSigAToB2Tag,       // Saturation

                                      icSigAToB1Tag };     // Absolute colorimetric

                                                           // (Relative/WhitePoint)

       nGridPoints = _cmsReasonableGridpointsByColorspace(p -> EntryColorSpace, dwFlags);

       // Get a copy of inteserting flags for this kind of xform

       LocalFlags = cmsFLAGS_NOTPRECALC;

       if (p -> dwOriginalFlags & cmsFLAGS_BLACKPOINTCOMPENSATION)

           LocalFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;

       // Fill in cargo struct

       Cargo.cmyk2cmyk = hCMYK2CMYK;

       Cargo.KTone  =  _cmsBuildKToneCurve(hCMYK2CMYK, 256);

       if (Cargo.KTone == NULL) return NULL;