/*

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

// Transformations stuff

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

#define DEFAULT_OBSERVER_ADAPTATION_STATE 1.0

// The Context0 observer adaptation state.

_cmsAdaptationStateChunkType _cmsAdaptationStateChunk = { DEFAULT_OBSERVER_ADAPTATION_STATE };

// Init and duplicate observer adaptation state

void _cmsAllocAdaptationStateChunk(struct _cmsContext_struct* ctx,

                                   const struct _cmsContext_struct* src)

{

    static _cmsAdaptationStateChunkType AdaptationStateChunk = { DEFAULT_OBSERVER_ADAPTATION_STATE };

    void* from;

    if (src != NULL) {

        from = src ->chunks[AdaptationStateContext];

    }

    else {

       from = &AdaptationStateChunk;

    }

    ctx ->chunks[AdaptationStateContext] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsAdaptationStateChunkType));

}

// Sets adaptation state for absolute colorimetric intent in the given context.  Adaptation state applies on all

// but cmsCreateExtendedTransformTHR().  Little CMS can handle incomplete adaptation states.

cmsFloat64Number CMSEXPORT cmsSetAdaptationStateTHR(cmsContext ContextID, cmsFloat64Number d)

{

    cmsFloat64Number prev;

    _cmsAdaptationStateChunkType* ptr = (_cmsAdaptationStateChunkType*) _cmsContextGetClientChunk(ContextID, AdaptationStateContext);

    // Get previous value for return

    prev = ptr ->AdaptationState;

    // Set the value if d is positive or zero

    if (d >= 0.0) {

        ptr ->AdaptationState = d;

    }

    // Always return previous value

    return prev;

}

// The adaptation state may be defaulted by this function. If you don't like it, use the extended transform routine

cmsFloat64Number CMSEXPORT cmsSetAdaptationState(cmsFloat64Number d)

{

    return cmsSetAdaptationStateTHR(NULL, d);

}

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

// Alarm codes for 16-bit transformations, because the fixed range of containers there are

// no values left to mark out of gamut.

#define DEFAULT_ALARM_CODES_VALUE {0x7F00, 0x7F00, 0x7F00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

_cmsAlarmCodesChunkType _cmsAlarmCodesChunk = { DEFAULT_ALARM_CODES_VALUE };

// Sets the codes used to mark out-out-gamut on Proofing transforms for a given context. Values are meant to be

// encoded in 16 bits.

void CMSEXPORT cmsSetAlarmCodesTHR(cmsContext ContextID, const cmsUInt16Number AlarmCodesP[cmsMAXCHANNELS])

{

    _cmsAlarmCodesChunkType* ContextAlarmCodes = (_cmsAlarmCodesChunkType*) _cmsContextGetClientChunk(ContextID, AlarmCodesContext);

    _cmsAssert(ContextAlarmCodes != NULL); // Can't happen

    memcpy(ContextAlarmCodes->AlarmCodes, AlarmCodesP, sizeof(ContextAlarmCodes->AlarmCodes));

}

// Gets the current codes used to mark out-out-gamut on Proofing transforms for the given context.

// Values are meant to be encoded in 16 bits.

void CMSEXPORT cmsGetAlarmCodesTHR(cmsContext ContextID, cmsUInt16Number AlarmCodesP[cmsMAXCHANNELS])

{

    _cmsAlarmCodesChunkType* ContextAlarmCodes = (_cmsAlarmCodesChunkType*) _cmsContextGetClientChunk(ContextID, AlarmCodesContext);

    _cmsAssert(ContextAlarmCodes != NULL); // Can't happen

    memcpy(AlarmCodesP, ContextAlarmCodes->AlarmCodes, sizeof(ContextAlarmCodes->AlarmCodes));

}

void CMSEXPORT cmsSetAlarmCodes(const cmsUInt16Number NewAlarm[cmsMAXCHANNELS])

{

    _cmsAssert(NewAlarm != NULL);

    cmsSetAlarmCodesTHR(NULL, NewAlarm);

}

void CMSEXPORT cmsGetAlarmCodes(cmsUInt16Number OldAlarm[cmsMAXCHANNELS])

{

    _cmsAssert(OldAlarm != NULL);

    cmsGetAlarmCodesTHR(NULL, OldAlarm);

}

// Init and duplicate alarm codes

void _cmsAllocAlarmCodesChunk(struct _cmsContext_struct* ctx,

                              const struct _cmsContext_struct* src)

{

    static _cmsAlarmCodesChunkType AlarmCodesChunk = { DEFAULT_ALARM_CODES_VALUE };

    void* from;

    if (src != NULL) {

        from = src ->chunks[AlarmCodesContext];

    }

    else {

       from = &AlarmCodesChunk;

    }

    ctx ->chunks[AlarmCodesContext] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsAlarmCodesChunkType));

}

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

// Get rid of transform resources

void CMSEXPORT cmsDeleteTransform(cmsHTRANSFORM hTransform)

{

    _cmsTRANSFORM* p = (_cmsTRANSFORM*) hTransform;

    _cmsAssert(p != NULL);

    if (p -> GamutCheck)

        cmsPipelineFree(p -> GamutCheck);

    if (p -> Lut)

        cmsPipelineFree(p -> Lut);

    if (p ->InputColorant)

        cmsFreeNamedColorList(p ->InputColorant);

    if (p -> OutputColorant)

        cmsFreeNamedColorList(p ->OutputColorant);

    if (p ->Sequence)

        cmsFreeProfileSequenceDescription(p ->Sequence);

    if (p ->UserData)

        p ->FreeUserData(p ->ContextID, p ->UserData);

    _cmsFree(p ->ContextID, (void *) p);

}

// Apply transform.

void CMSEXPORT cmsDoTransform(cmsHTRANSFORM  Transform,

                              const void* InputBuffer,

                              void* OutputBuffer,

                              cmsUInt32Number Size)

{

    _cmsTRANSFORM* p = (_cmsTRANSFORM*) Transform;

    cmsStride stride;

    stride.BytesPerLineIn = 0;  // Not used

    stride.BytesPerLineOut = 0;

    stride.BytesPerPlaneIn = Size;

    stride.BytesPerPlaneOut = Size;

    p -> xform(p, InputBuffer, OutputBuffer, Size, 1, &stride);

}

// This is a legacy stride for planar

void CMSEXPORT cmsDoTransformStride(cmsHTRANSFORM  Transform,

                              const void* InputBuffer,

                              void* OutputBuffer,

                              cmsUInt32Number Size, cmsUInt32Number Stride)

{

    _cmsTRANSFORM* p = (_cmsTRANSFORM*) Transform;

    cmsStride stride;

    stride.BytesPerLineIn = 0;

    stride.BytesPerLineOut = 0;

    stride.BytesPerPlaneIn = Stride;

    stride.BytesPerPlaneOut = Stride;

    p -> xform(p, InputBuffer, OutputBuffer, Size, 1, &stride);

}

// This is the "fast" function for plugins

void CMSEXPORT cmsDoTransformLineStride(cmsHTRANSFORM  Transform,

                              const void* InputBuffer,

                              void* OutputBuffer,

                              cmsUInt32Number PixelsPerLine,

                              cmsUInt32Number LineCount,

                              cmsUInt32Number BytesPerLineIn,

                              cmsUInt32Number BytesPerLineOut,

                              cmsUInt32Number BytesPerPlaneIn,

                              cmsUInt32Number BytesPerPlaneOut)

{

    _cmsTRANSFORM* p = (_cmsTRANSFORM*) Transform;

    cmsStride stride;

    stride.BytesPerLineIn = BytesPerLineIn;

    stride.BytesPerLineOut = BytesPerLineOut;

    stride.BytesPerPlaneIn = BytesPerPlaneIn;

    stride.BytesPerPlaneOut = BytesPerPlaneOut;

    p->xform(p, InputBuffer, OutputBuffer, PixelsPerLine, LineCount, &stride);

}

// Transform routines ----------------------------------------------------------------------------------------------------------

// Float xform converts floats. Since there are no performance issues, one routine does all job, including gamut check.

// Note that because extended range, we can use a -1.0 value for out of gamut in this case.

static

void FloatXFORM(_cmsTRANSFORM* p,

                const void* in,

                void* out,

                cmsUInt32Number PixelsPerLine,

                cmsUInt32Number LineCount,

                const cmsStride* Stride)

{

    cmsUInt8Number* accum;

    cmsUInt8Number* output;

    cmsFloat32Number fIn[cmsMAXCHANNELS], fOut[cmsMAXCHANNELS];

    cmsFloat32Number OutOfGamut;

    cmsUInt32Number i, j, c, strideIn, strideOut;

    _cmsHandleExtraChannels(p, in, out, PixelsPerLine, LineCount, Stride);

    strideIn = 0;

    strideOut = 0;

    memset(fIn, 0, sizeof(fIn));

    memset(fOut, 0, sizeof(fIn));

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

        accum = (cmsUInt8Number*)in + strideIn;

        output = (cmsUInt8Number*)out + strideOut;

        for (j = 0; j < PixelsPerLine; j++) {

            accum = p->FromInputFloat(p, fIn, accum, Stride->BytesPerPlaneIn);

            // Any gamut chack to do?

            if (p->GamutCheck != NULL) {

                // Evaluate gamut marker.

                cmsPipelineEvalFloat(fIn, &OutOfGamut, p->GamutCheck);

                // Is current color out of gamut?

                if (OutOfGamut > 0.0) {

                    // Certainly, out of gamut

                    for (c = 0; c < cmsMAXCHANNELS; c++)

                        fOut[c] = -1.0;

                }

                else {

                    // No, proceed normally

                    cmsPipelineEvalFloat(fIn, fOut, p->Lut);

                }

            }

            else {

                // No gamut check at all

                cmsPipelineEvalFloat(fIn, fOut, p->Lut);

            }

            output = p->ToOutputFloat(p, fOut, output, Stride->BytesPerPlaneOut);

        }

        strideIn += Stride->BytesPerLineIn;

        strideOut += Stride->BytesPerLineOut;

    }

}

static

void NullFloatXFORM(_cmsTRANSFORM* p,

                    const void* in,

                    void* out,

                    cmsUInt32Number PixelsPerLine,

                    cmsUInt32Number LineCount,

                    const cmsStride* Stride)

{

    cmsUInt8Number* accum;

    cmsUInt8Number* output;

    cmsFloat32Number fIn[cmsMAXCHANNELS];

    cmsUInt32Number i, j, strideIn, strideOut;

    _cmsHandleExtraChannels(p, in, out, PixelsPerLine, LineCount, Stride);

    strideIn = 0;

    strideOut = 0;

    memset(fIn, 0, sizeof(fIn));

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

           accum = (cmsUInt8Number*) in + strideIn;

           output = (cmsUInt8Number*) out + strideOut;

           for (j = 0; j < PixelsPerLine; j++) {

                  accum = p->FromInputFloat(p, fIn, accum, Stride ->BytesPerPlaneIn);

                  output = p->ToOutputFloat(p, fIn, output, Stride->BytesPerPlaneOut);

           }

           strideIn += Stride->BytesPerLineIn;

           strideOut += Stride->BytesPerLineOut;

    }

}

// 16 bit precision -----------------------------------------------------------------------------------------------------------

// Null transformation, only applies formatters. No caché

static

void NullXFORM(_cmsTRANSFORM* p,

               const void* in,

               void* out,

               cmsUInt32Number PixelsPerLine,

               cmsUInt32Number LineCount,

               const cmsStride* Stride)

{

    cmsUInt8Number* accum;

    cmsUInt8Number* output;

    cmsUInt16Number wIn[cmsMAXCHANNELS];

    cmsUInt32Number i, j, strideIn, strideOut;

    _cmsHandleExtraChannels(p, in, out, PixelsPerLine, LineCount, Stride);

    strideIn = 0;

    strideOut = 0;

    memset(wIn, 0, sizeof(wIn));

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

           accum = (cmsUInt8Number*)in + strideIn;

           output = (cmsUInt8Number*)out + strideOut;

           for (j = 0; j < PixelsPerLine; j++) {

                  accum = p->FromInput(p, wIn, accum, Stride->BytesPerPlaneIn);

                  output = p->ToOutput(p, wIn, output, Stride->BytesPerPlaneOut);

    }

           strideIn += Stride->BytesPerLineIn;

           strideOut += Stride->BytesPerLineOut;

    }

}

// No gamut check, no cache, 16 bits

static

void PrecalculatedXFORM(_cmsTRANSFORM* p,

                        const void* in,

                        void* out,

                        cmsUInt32Number PixelsPerLine,

                        cmsUInt32Number LineCount,

                        const cmsStride* Stride)

{

    register cmsUInt8Number* accum;

    register cmsUInt8Number* output;

    cmsUInt16Number wIn[cmsMAXCHANNELS], wOut[cmsMAXCHANNELS];

    cmsUInt32Number i, j, strideIn, strideOut;

    _cmsHandleExtraChannels(p, in, out, PixelsPerLine, LineCount, Stride);

    strideIn = 0;

    strideOut = 0;

    memset(wIn, 0, sizeof(wIn));

    memset(wOut, 0, sizeof(wOut));

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

        accum = (cmsUInt8Number*)in + strideIn;

        output = (cmsUInt8Number*)out + strideOut;

        for (j = 0; j < PixelsPerLine; j++) {

            accum = p->FromInput(p, wIn, accum, Stride->BytesPerPlaneIn);

            p->Lut->Eval16Fn(wIn, wOut, p->Lut->Data);

            output = p->ToOutput(p, wOut, output, Stride->BytesPerPlaneOut);

        }

        strideIn += Stride->BytesPerLineIn;

        strideOut += Stride->BytesPerLineOut;

    }

}

// Auxiliary: Handle precalculated gamut check. The retrieval of context may be alittle bit slow, but this function is not critical.

static

void TransformOnePixelWithGamutCheck(_cmsTRANSFORM* p,

                                     const cmsUInt16Number wIn[],

                                     cmsUInt16Number wOut[])

{

    cmsUInt16Number wOutOfGamut;

    p ->GamutCheck ->Eval16Fn(wIn, &wOutOfGamut, p ->GamutCheck ->Data);

    if (wOutOfGamut >= 1) {

        cmsUInt16Number i;

        _cmsAlarmCodesChunkType* ContextAlarmCodes = (_cmsAlarmCodesChunkType*) _cmsContextGetClientChunk(p->ContextID, AlarmCodesContext);

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

            wOut[i] = ContextAlarmCodes ->AlarmCodes[i];

        }

    }

    else

        p ->Lut ->Eval16Fn(wIn, wOut, p -> Lut->Data);

}

// Gamut check, No caché, 16 bits.

static

void PrecalculatedXFORMGamutCheck(_cmsTRANSFORM* p,

                                  const void* in,

                                  void* out,

                                  cmsUInt32Number PixelsPerLine,

                                  cmsUInt32Number LineCount,

                                  const cmsStride* Stride)

{

    cmsUInt8Number* accum;

    cmsUInt8Number* output;

    cmsUInt16Number wIn[cmsMAXCHANNELS], wOut[cmsMAXCHANNELS];

    cmsUInt32Number i, j, strideIn, strideOut;

    _cmsHandleExtraChannels(p, in, out, PixelsPerLine, LineCount, Stride);

    strideIn = 0;

    strideOut = 0;