//

// Little cms

// Chameleonic header file to instantiate different versions of the

// transform routines.

//

// As a bare minimum the following must be defined on entry:

//   FUNCTION_NAME             the name of the function

//

// In addition, a range of other symbols can be optionally defined on entry

// to make the generated code more efficient. All these symbols (and

// FUNCTION_NAME) will be automatically undefined at the end of the file so

// that repeated #includes of this file are made simple.

//

// If caching is wanted, define CACHED.

//

// If the representation/calculations are to be done using floating point

// define XFORM_FLOAT. In the absence of this it is assumed that the

// calculations will be done in 16 bit with appropriate unpacking/repacking.

//

// If you know the number of input/output channels, define NUMINCHANNELS and

// NUMOUTCHANNELS.

//

// If you know the number of bytes used for the packed version of input and/or

// output, define INPACKEDSAMPLESIZE and OUTPACKEDSAMPLESIZE.

//

// If you do not know the number of channels and/or the sample size, but you

// do know a maximum bound on the number of bytes used to represent the

// unpacked samples, then operation with CACHE can be accelerated by defining

// CMPBYTES to the number of bytes that should be compared to the cached result.

// Usually that is calculated from NUMINCHANNELS and INPACKEDSAMPLESIZE, so

// specifying it directly is only useful if either (or both) of those is not

// known in advance.

//

// For Premultiplied Alpha modes, you must define PREMULT. We only support

// premultiplied alpha where the alpha is the last 'extra' channel, and

// where both source and destination are packed in the same way.

//

// If you know the code to be used to unpack (or pack, or both) data to/from

// the simple 16 bit transform input/output format, then you can choose

// to this directly by defining UNPACK/PACK macros as follows:

//   UNPACK(T,TO,FROM,SIZE,AL) (Opt)   code to unpack input data (T = Transform

//                                     TO = buffer to unpack into, FROM = data,

//                                     SIZE = size of data, AL = Alpha)

//   PACK(T,FROM,TO,SIZE,AL)   (Opt)   code to pack transformed input data

//                                    (T = Transform, FROM = transformed data,

//                                    TO = output buffer to pack into,

//                                    SIZE = size of data, AL = Alpha)

//

// Ignore AL unless PREMULT is defined, in which case it will be in the packed

// format. AL is guaranteed to be non-zero.

//

// If UNPACKINCLUDESPREALPHA is defined, then UNPACK should undo the

// premultiplication by AL (i.e. divide by AL). Otherwise AL should be ignored

// and this routine will do it for you.

//

// If PACKINCLUDESPREALPHA is defined, then PACK should apply AL (i.e. multiply

// by AL). Otherwise AL should be ignored and this routine will do it for you.

//

// As an alternative to the above, if you know the function name that would

// be called, supply that in UNPACKFN and PACKFN and inlining compilers

// should hopefully do the hard work for you.

//   UNPACKFN          (Opt)   function to unpack input data

//   PACKFN            (Opt)   function to pack input data

//

// If the data happens to be in the correct input format anyway, we can skip

// unpacking it entirely and just use it direct.

//   NO_UNPACK         (Opt)   if defined, transform direct from the input

//                             data.

//

// UNPACK/PACK/UNPACKFN/PACKFN/NO_UNPACK are all expected to update their

// TO pointer to point to the next pixels data. This means for cases where

// we have extra bytes, they should skip the extra bytes too!

//

// If the data happens to be in the correct output format anyway, we can skip

// packing it entirely and just transform it direct into the buffer.

//   NO_PACK           (Opt)   if defined, transform direct to the output

//                             data.

//   COPY_MATCHED(FROM,TO)(Opt)if defined, copy output values from FROM to

//                             TO. Used in the case CACHED case where the

//                             cache matches and we have to copy forwards.

//

// GAMUTCHECK can be predefined if a gamut check needs to be done.

//

// If there are a known number of extra bytes to be dealt with, define EXTRABYTES

// to that number (such as 0 for none).

// If you want to provide your own code for copying from input to output, define

// COPY_EXTRAS(TRANS,FROM,TO) to do so.

// If none of these are defined, we call cmsHandleExtraChannels.

#ifndef CMPBYTES

#ifdef NUMINCHANNELS

#ifdef XFORM_FLOAT

#define CMPBYTES (NUMINCHANNELS*4)

#else

#define CMPBYTES (NUMINCHANNELS*2)

#endif

#endif

#endif

#ifdef CMPBYTES

 // Previously, we've attempted to do 'int' based checks here, but this falls

 // foul of some compilers with their strict pointer aliasing. We have the

 // choice of calling memcmp (which tests using chars, so is safe), or of

 // testing using the actual type.

 #ifdef XFORM_FLOAT

  #if CMPBYTES == 4

   #define COMPARE(A,B) ((A)[0] != (B)[0])

  #elif CMPBYTES == 8

   #define COMPARE(A,B) (((A)[0] != (B)[0]) || ((A)[1] != (B)[1]))

  #elif CMPBYTES == 12

   #define COMPARE(A,B) (((A)[0] != (B)[0]) || ((A)[1] != (B)[1]) || ((A)[2] != (B)[2]))

  #elif CMPBYTES == 16

   #define COMPARE(A,B) (((A)[0] != (B)[0]) || ((A)[1] != (B)[1]) || ((A)[2] != (B)[2]) || ((A)[3] != (B)[3]))

  #endif

 #else

  #if CMPBYTES == 2

   #define COMPARE(A,B) ((A)[0] != (B)[0])

  #elif CMPBYTES == 4

   #define COMPARE(A,B) (((A)[0] != (B)[0]) || ((A)[1] != (B)[1]))

  #elif CMPBYTES == 6

   #define COMPARE(A,B) (((A)[0] != (B)[0]) || ((A)[1] != (B)[1]) || ((A)[2] != (B)[2]))

  #elif CMPBYTES == 8

   #define COMPARE(A,B) (((A)[0] != (B)[0]) || ((A)[1] != (B)[1]) || ((A)[2] != (B)[2]) || ((A)[3] != (B)[3]))

  #endif

 #endif

#else

 // Otherwise, set INBYTES to be the maximum size it could possibly be.

 #ifdef XFORM_FLOAT

  #define CMPBYTES (sizeof(cmsFloat32Number)*cmsMAXCHANNELS)

 #else

  #define CMPBYTES (sizeof(cmsUInt16Number)*cmsMAXCHANNELS)

 #endif

#endif

#ifndef COMPARE

 #define COMPARE(A,B) memcmp((A),(B), CMPBYTES)

#endif

#if   defined(UNPACK)

 // Nothing to do, UNPACK is already defined

#elif defined(NO_UNPACK)

 #define UNPACK(CTX,T,TO,FROM,STRIDE,AL) do { } while (0)

#elif defined(UNPACKFN)

 #define UNPACK(CTX,T,TO,FROM,STRIDE,AL) \

    do { (FROM) = UNPACKFN((CTX),(T),(TO),(FROM),(STRIDE),(AL)); } while (0)

#elif defined(XFORM_FLOAT)

 #define UNPACK(CTX,T,TO,FROM,STRIDE,AL) \

    do { (FROM) = (T)->FromInputFloat((CTX),(T),(TO),(FROM),(STRIDE)); } while (0)

#else

 #define UNPACK(CTX,T,TO,FROM,STRIDE,AL) \

    do { (FROM) = (T)->FromInput((CTX),(T),(TO),(FROM),(STRIDE)); } while (0)

#endif

#if defined(PACK)

 // Nothing to do, PACK is already defined

#elif defined(NO_PACK)

 #define PACK(CTX,T,FROM,TO,STRIDE,AL) \

     do { (FROM) += (totaloutbytes/sizeof(XFORM_TYPE)); } while (0)

#elif defined(PACKFN)

 #define PACK(CTX,T,FROM,TO,STRIDE,AL) \

     do { (TO) = PACKFN((CTX),(T),(FROM),(TO),(STRIDE)); } while (0)

#elif defined(XFORM_FLOAT)

 #define PACK(CTX,T,FROM,TO,STRIDE,AL) \

     do { (TO) = (T)->ToOutputFloat((CTX),(T),(FROM),(TO),(STRIDE)); } while (0)

#else

 #define PACK(CTX,T,FROM,TO,STRIDE,AL) \

     do { (TO) = (T)->ToOutput((CTX),(T),(FROM),(TO),(STRIDE)); } while (0)

#endif

#ifndef ZEROPACK

/* The 'default' definition of ZEROPACK only works when

 * inpackedsamplesize == outpackedsamplesize. */

#define ZEROPACK(CTX,T,TO,FROM) do { \

    memset((TO),0,numoutchannels*outpackedsamplesize);\

    if (numextras != 0) memcpy((TO)+numoutchannels*outpackedsamplesize,\

                               (FROM)+numinchannels*inpackedsamplesize,\

                               numextras*outpackedsamplesize);\

    (TO)+=(1+prealphaindexout)*outpackedsamplesize; } while (0)

#endif

#ifndef UNPRE

#ifdef PREALPHA

#else

#define UNPRE(CTX,T,S,A) do {} while (0)

#endif

#endif

#ifndef REPRE

#ifdef PREALPHA

#define REPRE(CTX,T,S,A) do { int i; for (i = 0; i < numoutchannels; i++) \

                                          (S)[i] = mul65535((S)[i],A); } while (0)

#else

#define REPRE(CTX,T,S,A) do {} while (0)

#endif

#endif

#ifndef XFORMVARS

#define XFORMVARS(p) do { } while (0)

#endif

#if defined(NUMOUTCHANNELS)

 #ifdef XFORM_FLOAT

  #define OUTBYTES (sizeof(cmsFloat32Number)*NUMOUTCHANNELS)

 #else

  #define OUTBYTES (sizeof(cmsUInt16Number)*NUMOUTCHANNELS)

 #endif

#endif

#if defined(NO_PACK) && !defined(COPY_MATCHED) && defined(OUTBYTES)

 #if (defined(XFORM_FLOAT) && OUTBYTES == 4) || OUTBYTES == 2

  #define COPY_MATCHED(FROM,TO) ((TO)[0] = (FROM)[0])

 #elif (defined(XFORM_FLOAT) && OUTBYTES == 8) || OUTBYTES == 4

  #define COPY_MATCHED(FROM,TO) ((TO)[0] = (FROM)[0],(TO)[1] = (FROM)[1])

 #elif (defined(XFORM_FLOAT) && OUTBYTES == 12) || OUTBYTES == 6

  #define COPY_MATCHED(FROM,TO) ((TO)[0] = (FROM)[0],(TO)[1] = (FROM)[1],(TO)[2] = (FROM)[2])

 #elif (defined(XFORM_FLOAT) && OUTBYTES == 16) || OUTBYTES == 8

  #define COPY_MATCHED(FROM,TO) ((TO)[0] = (FROM)[0],(TO)[1] = (FROM)[1],(TO)[2] = (FROM)[2],(TO)[3] = (FROM)[3])

 #else

  #define COPY_MATCHED(FROM,TO) memcpy((TO),(FROM),(OUTBYTES))

 #endif

#endif

#ifdef XFORM_FLOAT

 #define XFORM_TYPE cmsFloat32Number

#else

 #define XFORM_TYPE cmsUInt16Number

#endif

#ifndef COPY_EXTRAS

 #ifdef NUMEXTRAS

  #if NUMEXTRAS == 0

   #define COPY_EXTRAS(TRANS,FROM,TO) do { } while (0)

  #else

   #define COPY_EXTRAS(TRANS,FROM,TO) \

       do { memcpy((TO),(FROM),(NUMEXTRAS)*inpackedsamplesize); \

            (TO) += (NUMEXTRAS)*inpackedsamplesize; \

            (FROM) += (NUMEXTRAS)*inpackedsamplesize; \

       } while (0)

  #endif

 #else

  #define BULK_COPY_EXTRAS

  #define COPY_EXTRAS(TRANS,FROM,TO) do { } while (0)

 #endif

#endif

static

void FUNCTION_NAME(cmsContext ContextID,

       _cmsTRANSFORM* p,

                   const void* in,

                   void* out,

                   cmsUInt32Number PixelsPerLine,

                   cmsUInt32Number LineCount,

                   const cmsStride* Stride)

{

    _cmsTRANSFORMCORE *core = p->core;

#ifndef NO_UNPACK

 #ifdef XFORM_FLOAT

    cmsFloat32Number wIn[cmsMAXCHANNELS*2];

 #else

    cmsUInt16Number wIn[cmsMAXCHANNELS*2];

 #endif

 #define wIn0 (&wIn[0])

 #define wIn1 (&wIn[cmsMAXCHANNELS])

#endif

    XFORM_TYPE *currIn;

#ifdef CACHED

    XFORM_TYPE *prevIn;

#endif /* CACHED */

#ifdef NO_PACK

    XFORM_TYPE *wOut = (XFORM_TYPE *)out;

    XFORM_TYPE *prevOut = (XFORM_TYPE *)p->Cache.CacheOut;

#else

    XFORM_TYPE wOut[cmsMAXCHANNELS];

#endif

#if defined(PREALPHA) && !defined(PACKINCLUDESPREALPHA)

    XFORM_TYPE wScaled[cmsMAXCHANNELS];

#endif

#ifdef GAMUTCHECK

    _cmsPipelineEval16Fn evalGamut = core->GamutCheck->Eval16Fn;

#endif /* GAMUTCHECK */

#ifdef XFORM_FLOAT

    _cmsPipelineEvalFloatFn eval = core->Lut->EvalFloatFn;

    const cmsPipeline *data = core->Lut;

#else

    _cmsPipelineEval16Fn eval = core->Lut->Eval16Fn;

    void *data = core->Lut->Data;

#endif

    cmsUInt32Number bppi = Stride->BytesPerPlaneIn;

    cmsUInt32Number bppo = Stride->BytesPerPlaneOut;

#ifdef NUMINCHANNELS

    int numinchannels = NUMINCHANNELS;

#else

    int numinchannels = T_CHANNELS(p->InputFormat);

#endif

#ifdef NUMOUTCHANNELS

    int numoutchannels = NUMOUTCHANNELS;

#else

    int numoutchannels = T_CHANNELS(p->OutputFormat);

#endif

#ifdef NUMEXTRAS

    int numextras = NUMEXTRAS;

#else

    int numextras = T_EXTRA(p->InputFormat);

#endif

#ifdef INPACKEDSAMPLESIZE

    int inpackedsamplesize = INPACKEDSAMPLESIZE;

#else

    int inpackedsamplesize = T_BYTES(p->InputFormat);

#endif

#ifdef OUTPACKEDSAMPLESIZE

    int outpackedsamplesize = OUTPACKEDSAMPLESIZE;

#else

    int outpackedsamplesize = T_BYTES(p->OutputFormat);

#endif

    int prealphaindexin = numinchannels + numextras - 1;

    int prealphaindexout = numoutchannels + numextras - 1;

    int totalinbytes = (numinchannels + numextras)*inpackedsamplesize;

    int totaloutbytes = (numoutchannels + numextras)*outpackedsamplesize;

    /* Silence some warnings */

    (void)bppi;

    (void)bppo;

    (void)prealphaindexin;

    (void)numextras;

    (void)prealphaindexout;

    (void)inpackedsamplesize;

    (void)outpackedsamplesize;

    (void)totalinbytes;

    (void)totaloutbytes;

#ifdef BULK_COPY_EXTRAS

    if (core->dwOriginalFlags & cmsFLAGS_COPY_ALPHA)

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

#endif

    if (PixelsPerLine == 0)

        return;

#ifdef NO_UNPACK

    prevIn = (XFORM_TYPE *)p->Cache.CacheIn;

#else

 #ifdef CACHED

    // Empty buffers for quick memcmp

    memset(wIn1, 0, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

    // Get copy of zero cache

    memcpy(wIn0, p->Cache.CacheIn,  sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

    memcpy(wOut, p->Cache.CacheOut, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

    // The caller guarantees us that the cache is always valid on entry; if

    // the representation is changed, the cache is reset.

    prevIn = wIn0;

 #endif /* CACHED */

    currIn = wIn1;

#endif

    while (LineCount-- > 0)

    {

        cmsUInt32Number n = PixelsPerLine;

        cmsUInt8Number* accum  = (cmsUInt8Number*) in;

        cmsUInt8Number* output = (cmsUInt8Number*) out;

#ifdef NO_UNPACK

        currIn = (XFORM_TYPE *)accum;

#endif

        while (n-- > 0) { // prevIn == CacheIn, wOut = CacheOut

#ifdef PREALPHA

 #ifdef XFORM_FLOAT

            cmsFloat32Number alpha = ((cmsFloat32Number *)accum)[prealphaindexin];

 #else

            cmsUInt32Number alpha = inpackedsamplesize == 2 ?

                                     ((cmsUInt16Number *)accum)[prealphaindexin] :

                                     (accum[prealphaindexin]);

 #endif

            if (alpha == 0) {

                ZEROPACK(ContextID,p,output,accum);

                accum += inpackedsamplesize*(prealphaindexin+1);

            } else {

#endif

                UNPACK(ContextID,p,currIn,accum,bppi,alpha);

#ifdef PREALPHA

 #ifndef UNPACKINCLUDESPREALPHA

  #ifdef XFORM_FLOAT

                {

                    int i;

                    cmsFloat32Number inva = 1.0f / alpha;

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

                        currIn[i] *= inva;

                }

  #else

                {

                    int i;

                    cmsUInt32Number al = inpackedsamplesize == 1 ? alpha*0x101 : alpha;

                    cmsUInt32Number inva = 0xffff0000U / al;

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

                        currIn[i] = ((currIn[i] * inva)>>16);

                }

  #endif

 #endif

#endif

#ifdef CACHED

                if (COMPARE(currIn, prevIn))

#endif /* CACHED */

                {

#ifdef GAMUTCHECK

 #ifdef XFORM_FLOAT

                    cmsFloat32Number OutOfGamut;

                    // Evaluate gamut marker.

                    cmsPipelineEvalFloat(currIn, &OutOfGamut, core->GamutCheck);

                    // Is current color out of gamut?

                    if (OutOfGamut > 0.0)

                        // Certainly, out of gamut

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

                            fOut[j] = -1.0;

                    else

 #else

                    cmsUInt16Number wOutOfGamut;

                    evalGamut(ContextID, currIn, &wOutOfGamut, core->GamutCheck->Data);

                    if (wOutOfGamut >= 1)

                        /* RJW: Could be faster? copy once to a local buffer? */

                        cmsGetAlarmCodes(ContextID, wOut);

                    else

 #endif /* FLOAT_XFORM */

#endif /* GAMUTCHECK */

                        eval(ContextID, currIn, wOut, data);

#ifdef NO_UNPACK

 #ifdef CACHED

                    prevIn = currIn;

 #endif

                    currIn = (XFORM_TYPE *)(((char *)currIn) + totalinbytes);

#else

 #ifdef CACHED

                    {XFORM_TYPE *tmp = currIn; currIn = prevIn; prevIn = tmp;} // SWAP

 #endif /* CACHED */

#endif /* NO_UNPACK */

                }

#ifdef NO_PACK

                else

                    COPY_MATCHED(prevOut,wOut);

                prevOut = wOut;

#endif

#ifdef PREALPHA

 #ifndef PACKINCLUDESPREALPHA

  #ifdef XFORM_FLOAT

                {

                    int i;

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

                        wScaled = wOut[i] * alpha;

                }

  #else

                {

                    int i;

                    cmsUInt32Number al = inpackedsamplesize == 1 ? alpha*0x101 : alpha;

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

                        wScaled[i] = mul65535(wOut[i],al);

                }

  #endif

                PACK(ContextID,p,wScaled,output,bppo,alpha);

 #else

                PACK(ContextID,p,wOut,output,bppo,alpha);

 #endif

#else

                PACK(ContextID,p,wOut,output,bppo,alpha);

#endif

                COPY_EXTRAS(p,accum,output);

#ifdef PREALPHA

            }

#endif

        } /* End x loop */

        in = (void *)((cmsUInt8Number *)in + Stride->BytesPerLineIn);

        out = (void *)((cmsUInt8Number *)out + Stride->BytesPerLineOut);

    } /* End y loop */

    /* The following code is only safe if we know that a given transform is

     * called on one thread a time. */

#if 0

#ifdef CACHED

#ifdef NO_UNPACK

    memcpy(p->Cache.CacheIn,prevIn, CMPBYTES);

#else

    memcpy(p->Cache.CacheIn, prevIn, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

#endif

#ifdef NO_PACK

    COPY_MATCHED(prevOut,p->Cache.CacheOut);

#else

    memcpy(p->Cache.CacheOut, wOut, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

#endif /* NO_PACK */

#endif /* CACHED */

#endif

}

Unexecuted instantiation: cmsxform.c:PrecalculatedXFORMGamutCheck_P

Unexecuted instantiation: cmsxform.c:PrecalculatedXFORM_P

Unexecuted instantiation: cmsxform.c:CachedXFORMGamutCheck_P

Unexecuted instantiation: cmsxform.c:PrecalculatedXFORMGamutCheck

Unexecuted instantiation: cmsxform.c:PrecalculatedXFORM

Unexecuted instantiation: cmsxform.c:CachedXFORMGamutCheck

Unexecuted instantiation: cmsxform.c:CachedXFORM1to1_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to1x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM1to3_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to3x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM1to4_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to4x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to1_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to1x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to3_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to3x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to4_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to4x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to1_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to1x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to3_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to3x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to4_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to4x2_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM1to1_1

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to1x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM1to3_1

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to3x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM1to4_1

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to4x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to1_1

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to1x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to3_1

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to3x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to4_1

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to4x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to1_1

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to1x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to3_1

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to3x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to4_1

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to4x2_2

Unexecuted instantiation: cmsxform.c:CachedXFORM_P1

Unexecuted instantiation: cmsxform.c:CachedXFORM_P2

Unexecuted instantiation: cmsxform.c:CachedXFORM

Unexecuted instantiation: cmsxform.c:CachedXFORM1to1

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to1x2

Unexecuted instantiation: cmsxform.c:CachedXFORM1to3

cmsxform.c:CachedXFORM1x2to3x2

Line

Count

Source

255

27

{

256

27

    _cmsTRANSFORMCORE *core = p->core;

257

27

#ifndef NO_UNPACK

258

 #ifdef XFORM_FLOAT

259

    cmsFloat32Number wIn[cmsMAXCHANNELS*2];

260

 #else

261

27

    cmsUInt16Number wIn[cmsMAXCHANNELS*2];

262

27

 #endif

263

27

 #define wIn0 (&wIn[0])

264

27

 #define wIn1 (&wIn[cmsMAXCHANNELS])

265

27

#endif

266

27

    XFORM_TYPE *currIn;

267

27

#ifdef CACHED

268

27

    XFORM_TYPE *prevIn;

269

27

#endif /* CACHED */

270

#ifdef NO_PACK

271

    XFORM_TYPE *wOut = (XFORM_TYPE *)out;

272

    XFORM_TYPE *prevOut = (XFORM_TYPE *)p->Cache.CacheOut;

273

#else

274

27

    XFORM_TYPE wOut[cmsMAXCHANNELS];

275

27

#endif

276

#if defined(PREALPHA) && !defined(PACKINCLUDESPREALPHA)

277

    XFORM_TYPE wScaled[cmsMAXCHANNELS];

278

#endif

279

#ifdef GAMUTCHECK

280

    _cmsPipelineEval16Fn evalGamut = core->GamutCheck->Eval16Fn;

281

#endif /* GAMUTCHECK */

282

#ifdef XFORM_FLOAT

283

    _cmsPipelineEvalFloatFn eval = core->Lut->EvalFloatFn;

284

    const cmsPipeline *data = core->Lut;

285

#else

286

27

    _cmsPipelineEval16Fn eval = core->Lut->Eval16Fn;

287

27

    void *data = core->Lut->Data;

288

27

#endif

289

27

    cmsUInt32Number bppi = Stride->BytesPerPlaneIn;

290

27

    cmsUInt32Number bppo = Stride->BytesPerPlaneOut;

291

27

#ifdef NUMINCHANNELS

292

27

    int numinchannels = NUMINCHANNELS;

293

#else

294

    int numinchannels = T_CHANNELS(p->InputFormat);

295

#endif

296

27

#ifdef NUMOUTCHANNELS

297

27

    int numoutchannels = NUMOUTCHANNELS;

298

#else

299

    int numoutchannels = T_CHANNELS(p->OutputFormat);

300

#endif

301

27

#ifdef NUMEXTRAS

302

27

    int numextras = NUMEXTRAS;

303

#else

304

    int numextras = T_EXTRA(p->InputFormat);

305

#endif

306

27

#ifdef INPACKEDSAMPLESIZE

307

27

    int inpackedsamplesize = INPACKEDSAMPLESIZE;

308

#else

309

    int inpackedsamplesize = T_BYTES(p->InputFormat);

310

#endif

311

27

#ifdef OUTPACKEDSAMPLESIZE

312

27

    int outpackedsamplesize = OUTPACKEDSAMPLESIZE;

313

#else

314

    int outpackedsamplesize = T_BYTES(p->OutputFormat);

315

#endif

316

27

    int prealphaindexin = numinchannels + numextras - 1;

317

27

    int prealphaindexout = numoutchannels + numextras - 1;

318

27

    int totalinbytes = (numinchannels + numextras)*inpackedsamplesize;

319

27

    int totaloutbytes = (numoutchannels + numextras)*outpackedsamplesize;

320

321

    /* Silence some warnings */

322

27

    (void)bppi;

323

27

    (void)bppo;

324

27

    (void)prealphaindexin;

325

27

    (void)numextras;

326

27

    (void)prealphaindexout;

327

27

    (void)inpackedsamplesize;

328

27

    (void)outpackedsamplesize;

329

27

    (void)totalinbytes;

330

27

    (void)totaloutbytes;

331

332

#ifdef BULK_COPY_EXTRAS

333

    if (core->dwOriginalFlags & cmsFLAGS_COPY_ALPHA)

334

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

335

#endif

336

337

27

    if (PixelsPerLine == 0)

338

0

        return;

339

340

#ifdef NO_UNPACK

341

    prevIn = (XFORM_TYPE *)p->Cache.CacheIn;

342

#else

343

27

 #ifdef CACHED

344

    // Empty buffers for quick memcmp

345

27

    memset(wIn1, 0, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

346

347

    // Get copy of zero cache

348

27

    memcpy(wIn0, p->Cache.CacheIn,  sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

349

27

    memcpy(wOut, p->Cache.CacheOut, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

350

351

    // The caller guarantees us that the cache is always valid on entry; if

352

    // the representation is changed, the cache is reset.

353

27

    prevIn = wIn0;

354

27

 #endif /* CACHED */

355

27

    currIn = wIn1;

356

27

#endif

357

358

54

    while (LineCount-- > 0)

359

27

    {

360

27

        cmsUInt32Number n = PixelsPerLine;

361

27

        cmsUInt8Number* accum  = (cmsUInt8Number*) in;

362

27

        cmsUInt8Number* output = (cmsUInt8Number*) out;

363

#ifdef NO_UNPACK

364

        currIn = (XFORM_TYPE *)accum;

365

#endif

366

54

        while (n-- > 0) { // prevIn == CacheIn, wOut = CacheOut

367

#ifdef PREALPHA

368

 #ifdef XFORM_FLOAT

369

            cmsFloat32Number alpha = ((cmsFloat32Number *)accum)[prealphaindexin];

370

 #else

371

            cmsUInt32Number alpha = inpackedsamplesize == 2 ?

372

                                     ((cmsUInt16Number *)accum)[prealphaindexin] :

373

                                     (accum[prealphaindexin]);

374

 #endif

375

            if (alpha == 0) {

376

                ZEROPACK(ContextID,p,output,accum);

377

                accum += inpackedsamplesize*(prealphaindexin+1);

378

            } else {

379

#endif

380

27

                UNPACK(ContextID,p,currIn,accum,bppi,alpha);

381

#ifdef PREALPHA

382

 #ifndef UNPACKINCLUDESPREALPHA

383

  #ifdef XFORM_FLOAT

384

                {

385

                    int i;

386

                    cmsFloat32Number inva = 1.0f / alpha;

387

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

388

                        currIn[i] *= inva;

389

                }

390

  #else

391

                {

392

                    int i;

393

                    cmsUInt32Number al = inpackedsamplesize == 1 ? alpha*0x101 : alpha;

394

                    cmsUInt32Number inva = 0xffff0000U / al;

395

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

396

                        currIn[i] = ((currIn[i] * inva)>>16);

397

                }

398

  #endif

399

 #endif

400

#endif

401

27

#ifdef CACHED

402

27

                if (COMPARE(currIn, prevIn))

403

0

#endif /* CACHED */

404

0

                {

405

#ifdef GAMUTCHECK

406

 #ifdef XFORM_FLOAT

407

                    cmsFloat32Number OutOfGamut;

408

409

                    // Evaluate gamut marker.

410

                    cmsPipelineEvalFloat(currIn, &OutOfGamut, core->GamutCheck);

411

412

                    // Is current color out of gamut?

413

                    if (OutOfGamut > 0.0)

414

                        // Certainly, out of gamut

415

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

416

                            fOut[j] = -1.0;

417

                    else

418

 #else

419

                    cmsUInt16Number wOutOfGamut;

420

421

                    evalGamut(ContextID, currIn, &wOutOfGamut, core->GamutCheck->Data);

422

                    if (wOutOfGamut >= 1)

423

                        /* RJW: Could be faster? copy once to a local buffer? */

424

                        cmsGetAlarmCodes(ContextID, wOut);

425

                    else

426

 #endif /* FLOAT_XFORM */

427

#endif /* GAMUTCHECK */

428

0

                        eval(ContextID, currIn, wOut, data);

429

#ifdef NO_UNPACK

430

 #ifdef CACHED

431

                    prevIn = currIn;

432

 #endif

433

                    currIn = (XFORM_TYPE *)(((char *)currIn) + totalinbytes);

434

#else

435

0

 #ifdef CACHED

436

0

                    {XFORM_TYPE *tmp = currIn; currIn = prevIn; prevIn = tmp;} // SWAP

437

0

 #endif /* CACHED */

438

0

#endif /* NO_UNPACK */

439

0

                }

440

#ifdef NO_PACK

441

                else

442

                    COPY_MATCHED(prevOut,wOut);

443

                prevOut = wOut;

444

#endif

445

#ifdef PREALPHA

446

 #ifndef PACKINCLUDESPREALPHA

447

  #ifdef XFORM_FLOAT

448

                {

449

                    int i;

450

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

451

                        wScaled = wOut[i] * alpha;

452

                }

453

  #else

454

                {

455

                    int i;

456

                    cmsUInt32Number al = inpackedsamplesize == 1 ? alpha*0x101 : alpha;

457

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

458

                        wScaled[i] = mul65535(wOut[i],al);

459

                }

460

  #endif

461

                PACK(ContextID,p,wScaled,output,bppo,alpha);

462

 #else

463

                PACK(ContextID,p,wOut,output,bppo,alpha);

464

 #endif

465

#else

466

27

                PACK(ContextID,p,wOut,output,bppo,alpha);

467

27

#endif

468

27

                COPY_EXTRAS(p,accum,output);

469

#ifdef PREALPHA

470

            }

471

#endif

472

27

        } /* End x loop */

473

27

        in = (void *)((cmsUInt8Number *)in + Stride->BytesPerLineIn);

474

27

        out = (void *)((cmsUInt8Number *)out + Stride->BytesPerLineOut);

475

27

    } /* End y loop */

476

    /* The following code is only safe if we know that a given transform is

477

     * called on one thread a time. */

478

#if 0

479

#ifdef CACHED

480

#ifdef NO_UNPACK

481

    memcpy(p->Cache.CacheIn,prevIn, CMPBYTES);

482

#else

483

    memcpy(p->Cache.CacheIn, prevIn, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

484

#endif

485

#ifdef NO_PACK

486

    COPY_MATCHED(prevOut,p->Cache.CacheOut);

487

#else

488

    memcpy(p->Cache.CacheOut, wOut, sizeof(XFORM_TYPE) * cmsMAXCHANNELS);

489

#endif /* NO_PACK */

490

#endif /* CACHED */

491

#endif

492

27

}

Unexecuted instantiation: cmsxform.c:CachedXFORM1to4

Unexecuted instantiation: cmsxform.c:CachedXFORM1x2to4x2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to1

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to1x2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to3

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to3x2

Unexecuted instantiation: cmsxform.c:CachedXFORM3to4

Unexecuted instantiation: cmsxform.c:CachedXFORM3x2to4x2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to1

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to1x2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to3

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to3x2

Unexecuted instantiation: cmsxform.c:CachedXFORM4to4

Unexecuted instantiation: cmsxform.c:CachedXFORM4x2to4x2

Unexecuted instantiation: cmsxform.c:CachedXFORM4

Unexecuted instantiation: cmsxform.c:CachedXFORM8

#undef wIn0

#undef wIn1

#undef XFORM_TYPE

#undef XFORM_FLOAT

#undef FUNCTION_NAME

#undef COMPARE

#undef CMPBYTES

#undef OUTBYTES

#undef UNPACK

#undef NO_UNPACK

#undef PACK

#undef NO_PACK

#undef UNPACKFN

#undef PACKFN

#undef GAMUTCHECK

#undef CACHED

#undef COPY_MATCHED

#undef EXTRABYTES

#undef COPY_EXTRAS

#undef BULK_COPY_EXTRAS

#undef PREALPHA

#undef ZEROPACK

#undef XFORMVARS

#undef UNPRE

#undef REPRE

#undef INPACKEDSAMPLESIZE

#undef OUTPACKEDSAMPLESIZE

#undef NUMINCHANNELS

#undef NUMOUTCHANNELS

#undef NUMEXTRAS