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

//

//  Little Color Management System

//  Copyright (c) 1998-2026 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 cmsCreateExtendedTransform().  Little CMS can handle incomplete adaptation states.

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

cmsFloat64Number CMSEXPORT cmsSetAdaptationState(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;

}

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

// 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 cmsSetAlarmCodes(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 cmsGetAlarmCodes(cmsContext ContextID, cmsUInt16Number AlarmCodesP[cmsMAXCHANNELS])

{

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

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

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

}

// 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(cmsContext ContextID, cmsHTRANSFORM hTransform)

{

    _cmsTRANSFORM* p = (_cmsTRANSFORM*) hTransform;

    _cmsTRANSFORMCORE *core;

    cmsUInt32Number refs;

    if (p == NULL)

        return;

    core = p->core;

    _cmsAssert(core != NULL);

    refs = _cmsAdjustReferenceCount(&core->refs, -1);

    _cmsFree(ContextID, (void *) p);

    if (refs != 0)

        return;

    if (core->GamutCheck)

        cmsPipelineFree(ContextID, core->GamutCheck);

    if (core->Lut)

        cmsPipelineFree(ContextID, core->Lut);

    if (core->InputColorant)

        cmsFreeNamedColorList(ContextID, core->InputColorant);

    if (core->OutputColorant)

        cmsFreeNamedColorList(ContextID, core->OutputColorant);

    if (core->Sequence)

        cmsFreeProfileSequenceDescription(ContextID, core->Sequence);

    if (core->UserData)

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

    _cmsFree(ContextID, (void *)core);

}

static

cmsUInt32Number PixelSize(cmsUInt32Number Format)

{

    cmsUInt32Number fmt_bytes = T_BYTES(Format);

    // For double, the T_BYTES field is zero

    if (fmt_bytes == 0)

        return sizeof(cmsUInt64Number);

    // Otherwise, it is already correct for all formats

    return fmt_bytes;

}

// Apply transform.

void CMSEXPORT cmsDoTransform(cmsContext ContextID, 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 * PixelSize(p->InputFormat);

    stride.BytesPerPlaneOut = Size * PixelSize(p->OutputFormat);

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

}

// This is a legacy stride for planar

void CMSEXPORT cmsDoTransformStride(cmsContext ContextID, 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(ContextID, p, InputBuffer, OutputBuffer, Size, 1, &stride);

}

// This is the "fast" function for plugins

void CMSEXPORT cmsDoTransformLineStride(cmsContext ContextID, 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(ContextID, 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(cmsContext ContextID, _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;

    size_t i, j, c, strideIn, strideOut;

    _cmsTRANSFORMCORE *core = p->core;

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

    strideIn = 0;

    strideOut = 0;

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

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

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

        accum = (cmsUInt8Number*)in + strideIn;

        output = (cmsUInt8Number*)out + strideOut;

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

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

            // Any gamut chack to do?

            if (core->GamutCheck != NULL) {

                // Evaluate gamut marker.

                cmsPipelineEvalFloat(ContextID, fIn, &OutOfGamut, core->GamutCheck);

                // Is current color out of gamut?

                if (OutOfGamut > 0.0) {

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

                    // Certainly, out of gamut

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

                        fOut[c] = ContextAlarmCodes->AlarmCodes[c] / 65535.0F;

                }

                else {

                    // No, proceed normally

                    cmsPipelineEvalFloat(ContextID, fIn, fOut, core->Lut);

                }

            }

            else {

                // No gamut check at all

                cmsPipelineEvalFloat(ContextID, fIn, fOut, core->Lut);

            }

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

        }

        strideIn += Stride->BytesPerLineIn;

        strideOut += Stride->BytesPerLineOut;

    }

}

static

void NullFloatXFORM(cmsContext ContextID, _cmsTRANSFORM* p,

                    const void* in,

                    void* out,

                    cmsUInt32Number PixelsPerLine,

                    cmsUInt32Number LineCount,

                    const cmsStride* Stride)

{

    cmsUInt8Number* accum;

    cmsUInt8Number* output;

    cmsFloat32Number fIn[cmsMAXCHANNELS];

    size_t i, j, strideIn, strideOut;

    _cmsHandleExtraChannels(ContextID, 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(ContextID, p, fIn, accum, Stride ->BytesPerPlaneIn);

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

           }

           strideIn += Stride->BytesPerLineIn;

           strideOut += Stride->BytesPerLineOut;

    }

}

cmsINLINE int mul255(cmsUInt32Number a, cmsUInt32Number b)

{

  /* see Jim Blinn's book "Dirty Pixels" for how this works */

  cmsUInt32Number x = a * b + 128;

  x += x >> 8;

  return x >> 8;

}

cmsINLINE cmsUInt32Number mul65535(cmsUInt32Number a, cmsUInt32Number b)

{

  /* see Jim Blinn's book "Dirty Pixels" for how this works */

  cmsUInt32Number x = a * b + 0x8000;

  x += x >> 16;

  return x >> 16;

}

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

// Null transformation, only applies formatters. No cache

static

void NullXFORM(cmsContext ContextID,

               _cmsTRANSFORM* p,

               const void* in,

               void* out,

               cmsUInt32Number PixelsPerLine,

               cmsUInt32Number LineCount,

               const cmsStride* Stride)

{

    cmsUInt8Number* accum;

    cmsUInt8Number* output;

    cmsUInt16Number wIn[cmsMAXCHANNELS];

    size_t i, j, strideIn, strideOut;

    _cmsHandleExtraChannels(ContextID, 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(ContextID, p, wIn, accum, Stride->BytesPerPlaneIn);

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

        }

        strideIn += Stride->BytesPerLineIn;

        strideOut += Stride->BytesPerLineOut;

    }

}

// No gamut check, no cache, 16 bits

#define FUNCTION_NAME PrecalculatedXFORM

#include "extra_xform.h"

// No gamut check, no cache, 16 bits

#define PREALPHA

#define FUNCTION_NAME PrecalculatedXFORM_P

#include "extra_xform.h"

// No gamut check, no cache, Identity transform, including pack/unpack

static

void PrecalculatedXFORMIdentity(cmsContext ContextID,

                                _cmsTRANSFORM* p,

                                const void* in,

                                void* out,

                                cmsUInt32Number PixelsPerLine,

                                cmsUInt32Number LineCount,

                                const cmsStride* Stride)

{

    cmsUInt32Number bpli = Stride->BytesPerLineIn;

    cmsUInt32Number bplo = Stride->BytesPerLineOut;

    int bpp;

    cmsUNUSED_PARAMETER(ContextID);

    /* Silence some warnings */

    (void)bpli;

    (void)bplo;

    if ((in == out && bpli == bplo) || PixelsPerLine == 0)

        return;

    bpp = T_BYTES(p->InputFormat);

    if (bpp == 0)

        bpp = sizeof(double);

    bpp *= T_CHANNELS(p->InputFormat) + T_EXTRA(p->InputFormat);

    PixelsPerLine *= bpp; /* Convert to BytesPerLine */

    while (LineCount-- > 0)

    {

        memmove(out, in, PixelsPerLine);

        in = (void *)((cmsUInt8Number *)in + bpli);

        out = (void *)((cmsUInt8Number *)out + bplo);

    }

}

static

void PrecalculatedXFORMIdentityPlanar(cmsContext ContextID,

                                      _cmsTRANSFORM* p,

                                      const void* in,

                                      void* out,

                                      cmsUInt32Number PixelsPerLine,

                                      cmsUInt32Number LineCount,

                                      const cmsStride* Stride)

{

    cmsUInt32Number bpli = Stride->BytesPerLineIn;

    cmsUInt32Number bplo = Stride->BytesPerLineOut;

    cmsUInt32Number bppi = Stride->BytesPerPlaneIn;

    cmsUInt32Number bppo = Stride->BytesPerPlaneOut;

    int bpp;

    int planes;

    const void *plane_in;

    void *plane_out;

    cmsUNUSED_PARAMETER(ContextID);

    /* Silence some warnings */

    (void)bpli;

    (void)bplo;

    (void)bppi;

    (void)bppo;

    if ((in == out && bpli == bplo && bppi == bppo) || PixelsPerLine == 0)

        return;

    bpp = T_BYTES(p->InputFormat);

    if (bpp == 0)

        bpp = sizeof(double);

    PixelsPerLine *= bpp; /* Convert to BytesPerLine */

    planes = T_CHANNELS(p->InputFormat) + T_EXTRA(p->InputFormat);

    while (planes-- > 0)

    {

        plane_in = in;

        plane_out = out;

        while (LineCount-- > 0)

        {

            memmove(plane_out, plane_in, PixelsPerLine);

            plane_in = (void *)((cmsUInt8Number *)plane_in + bpli);

            plane_out = (void *)((cmsUInt8Number *)plane_out + bplo);

        }

        in = (void *)((cmsUInt8Number *)in + bppi);

        out = (void *)((cmsUInt8Number *)out + bppo);

    }

}

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

static

void TransformOnePixelWithGamutCheck(cmsContext ContextID, _cmsTRANSFORM* p,

                                     const cmsUInt16Number wIn[],

                                     cmsUInt16Number wOut[])

{

    cmsUInt16Number wOutOfGamut;

    _cmsTRANSFORMCORE *core = p->core;

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

    if (wOutOfGamut >= 1) {

        cmsUInt32Number i;

        cmsUInt32Number n = core->Lut->OutputChannels;

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

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

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

        }

    }

    else

        core->Lut->Eval16Fn(ContextID, wIn, wOut, core->Lut->Data);

}

// Gamut check, No cache, 16 bits.

#define FUNCTION_NAME PrecalculatedXFORMGamutCheck

#define GAMUTCHECK

#include "extra_xform.h"

// Gamut check, No cache, 16 bits.

#define FUNCTION_NAME PrecalculatedXFORMGamutCheck_P

#define PREALPHA

#define GAMUTCHECK

#include "extra_xform.h"

// No gamut check, Cache, 16 bits,

#define FUNCTION_NAME CachedXFORM

#define CACHED

#include "extra_xform.h"

// All those nice features together

#define FUNCTION_NAME CachedXFORMGamutCheck

#define CACHED

#define GAMUTCHECK

#include "extra_xform.h"

// All those nice features together

#define FUNCTION_NAME CachedXFORMGamutCheck_P

#define CACHED

#define PREALPHA

#define GAMUTCHECK

#include "extra_xform.h"

// No gamut check, Cache, 16 bits, <= 4 bytes

#define FUNCTION_NAME CachedXFORM4

#define CACHED

#define CMPBYTES 4

#define NUMEXTRAS 0

#include "extra_xform.h"

// No gamut check, Cache, 16 bits, <= 8 bytes total

#define FUNCTION_NAME CachedXFORM8

#define CACHED

#define CMPBYTES 8

#define NUMEXTRAS 0

#include "extra_xform.h"

// Special ones for common cases.

#define FUNCTION_NAME CachedXFORM1to1

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM1x2to1x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM1to3

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 3

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

    *(D)++ = FROM_16_TO_8((S)[1]); \

    *(D)++ = FROM_16_TO_8((S)[2]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM1x2to3x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 3

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[1]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[2]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM1to4

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 4

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

    *(D)++ = FROM_16_TO_8((S)[1]); \

    *(D)++ = FROM_16_TO_8((S)[2]); \

    *(D)++ = FROM_16_TO_8((S)[3]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM1x2to4x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 4

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[1]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[2]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[3]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM3to1

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 3

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)               \

do {                                        \

        (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

        (D)[1] = FROM_8_TO_16(*(S)); (S)++; \

        (D)[2] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM3x2to1x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 3

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                       \

do {                                                \

        (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

        (D)[1] = *(cmsUInt16Number *)(S); (S) += 2; \

        (D)[2] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM3to3

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 3

#define NUMOUTCHANNELS 3

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[1] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[2] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

    *(D)++ = FROM_16_TO_8((S)[1]); \

    *(D)++ = FROM_16_TO_8((S)[2]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM3x2to3x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 3

#define NUMOUTCHANNELS 3

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[1] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[2] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[1]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[2]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM3to4

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 3

#define NUMOUTCHANNELS 4

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[1] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[2] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

    *(D)++ = FROM_16_TO_8((S)[1]); \

    *(D)++ = FROM_16_TO_8((S)[2]); \

    *(D)++ = FROM_16_TO_8((S)[3]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM3x2to4x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 3

#define NUMOUTCHANNELS 4

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[1] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[2] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[1]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[2]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[3]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM4to1

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 4

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[1] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[2] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[3] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM4x2to1x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 4

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[1] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[2] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[3] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM4to3

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 4

#define NUMOUTCHANNELS 3

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[1] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[2] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[3] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

    *(D)++ = FROM_16_TO_8((S)[1]); \

    *(D)++ = FROM_16_TO_8((S)[2]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM4x2to3x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 4

#define NUMOUTCHANNELS 3

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[1] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[2] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[3] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[1]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[2]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM4to4

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 4

#define NUMOUTCHANNELS 4

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[1] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[2] = FROM_8_TO_16(*(S)); (S)++; \

       (D)[3] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

    *(D)++ = FROM_16_TO_8((S)[1]); \

    *(D)++ = FROM_16_TO_8((S)[2]); \

    *(D)++ = FROM_16_TO_8((S)[3]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM4x2to4x2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 4

#define NUMOUTCHANNELS 4

#define NUMEXTRAS 0

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[1] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[2] = *(cmsUInt16Number *)(S); (S) += 2; \

       (D)[3] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[1]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[2]; (D) += 2; \

    *(cmsUInt16Number *)(D) = (S)[3]; (D) += 2; \

} while (0)

#include "extra_xform.h"

// Same again, but with alpha

// Special ones for common cases.

#define FUNCTION_NAME CachedXFORM1to1_1

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 1

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 1

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM1x2to1x2_2

#define CACHED

#define INPACKEDSAMPLESIZE 2

#define OUTPACKEDSAMPLESIZE 2

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 1

#define UNPACK(CTX,T,D,S,Z,A)                      \

do {                                               \

       (D)[0] = *(cmsUInt16Number *)(S); (S) += 2; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)                     \

do {                                            \

    *(cmsUInt16Number *)(D) = (S)[0]; (D) += 2; \

} while (0)

#include "extra_xform.h"

#define FUNCTION_NAME CachedXFORM1to3_1

#define CACHED

#define INPACKEDSAMPLESIZE 1

#define OUTPACKEDSAMPLESIZE 3

#define NUMINCHANNELS 1

#define NUMOUTCHANNELS 1

#define NUMEXTRAS 1

#define UNPACK(CTX,T,D,S,Z,A)              \

do {                                       \

       (D)[0] = FROM_8_TO_16(*(S)); (S)++; \

} while (0)

#define PACK(CTX,T,S,D,Z,A)        \

do {                               \

    *(D)++ = FROM_16_TO_8((S)[0]); \

    *(D)++ = FROM_16_TO_8((S)[1]); \

    *(D)++ = FROM_16_TO_8((S)[2]); \

} while (0)