profcrd.c File Reference

#include "generic.h"
#include "icmstr.h"

Go to the source code of this file.

Defines
#define	ICMSEG
#define	MAXCOLOR8   255
Functions
SINT	CreateHostInputOutputArray (MEMPTR lpMem, PMEMPTR ppArray, SINT numChan, SINT tableSize, SINT Offset, CSIG Tag, MEMPTR Buff)
BOOL	CheckInputOutputTable (LPHOSTCLUT lpHostClut, float far *fTemp, BOOL, BOOL)
BOOL	GetHostCSA_Intent (CHANDLE cp, MEMPTR lpBuffer, LPDWORD lpcbSize, CSIG Intent, int Type)
BOOL	CheckColorLookupTable (LPHOSTCLUT lpHostClut, float far *fTemp)
BOOL	DoHostConversionCRD (LPHOSTCLUT lpHostCRD, LPHOSTCLUT lpHostCSA, float far *Input, float far *Output, CSIG ColorSpace, BOOL bCheckOutputTable)
BOOL	DoHostConversionCSA (LPHOSTCLUT lpHostClut, float far *Input, float far *Output)
BOOL	GetCRDInputOutputArraySize (CHANDLE cp, DWORD Intent, LPSINT lpInTbSize, LPSINT lpOutTbSize, LPCSIG lpIntentTag, LPSINT lpGrids)
void	LabToXYZ (float far *Input, float far *Output, float far *whitePoint)
VOID	GetCLUTinfo (CSIG LutTag, MEMPTR lpLut, LPSINT nInputCh, LPSINT nOutputCh, LPSINT nGrids, LPSINT nInputTable, LPSINT nOutputTable, LPSINT size)
BOOL	GetHostCSA (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, CSIG InputIntent, SINT Index, int Type)
HGLOBAL	GetTRCData (CHANDLE cp, LPMEMPTR lpRed, LPMEMPTR lpGreen, LPMEMPTR lpBlue, LPSINT lpnRed, LPSINT lpnGreen, LPSINT lpnBlue)
SINT	CreateHostTRCInputTable (MEMPTR lpMem, LPHOSTCLUT lpHostClut, MEMPTR lpRed, MEMPTR lpGreen, MEMPTR lpBlue)
SINT	CreateHostRevTRCInputTable (MEMPTR lpMem, LPHOSTCLUT lpHostClut, MEMPTR lpRed, MEMPTR lpGreen, MEMPTR lpBlue)
BOOL	GetHostMatrixCSAorCRD (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, BOOL bCSA)
BOOL	GetHostColorSpaceArray (CHANDLE cp, DWORD InputIntent, MEMPTR lpBuffer, LPDWORD lpcbSize)
SINT	CreateHostLutCRD (CHANDLE cp, SINT Index, MEMPTR lpMem, DWORD InputIntent)
BOOL	GetHostColorRenderingDictionary (CHANDLE cp, DWORD Intent, MEMPTR lpMem, LPDWORD lpcbSize)
float	g (float f)
float	inverse_g (float f)
BOOL	TableInterp3 (LPHOSTCLUT lpHostClut, float far *fTemp)
BOOL	TableInterp4 (LPHOSTCLUT lpHostClut, float far *fTemp)
void	XYZToLab (float far *Input, float far *Output, float far *whitePoint)
void	ApplyMatrix (PFLOAT e, float far *Input, float far *Output)
SINT	CreateOutputArray (MEMPTR lpMem, SINT nOutputCh, SINT nOutputTable, SINT Offset, MEMPTR Intent, CSIG Tag, MEMPTR Buff, BOOL AllowBinary, MEMPTR lpHostClut)
SINT	CreateInputArray (MEMPTR lpMem, SINT nInputCh, SINT nInputTable, MEMPTR Intent, CSIG Tag, MEMPTR Buff, BOOL bAllowBinary, MEMPTR lpHostClut)
SINT	SendCRDLMN (MEMPTR lpMem, CSIG Intent, LPSFLOAT whitePoint, LPSFLOAT mediaWP, CSIG pcs)
SINT	SendCRDPQR (MEMPTR lpMem, CSIG Intent, LPSFLOAT whitePoint)
SINT	SendCRDABC (MEMPTR lpMem, MEMPTR PublicArrayName, CSIG pcs, SINT nInputCh, MEMPTR Buff, LPSFLOAT e, CSIG LutTag, BOOL bAllowBinary)
SINT	SendCRDBWPoint (MEMPTR lpMem, LPSFLOAT whitePoint)
SINT	SendCRDOutputTable (MEMPTR lpMem, MEMPTR PublicArrayName, SINT nOutputCh, CSIG LutTag, BOOL bHost, BOOL bAllowBinary)
BOOL EXTERN	GetPS2PreviewColorRenderingDictionary (CHANDLE cpDev, CHANDLE cpTarget, DWORD Intent, MEMPTR lpMem, LPDWORD lpcbSize, BOOL bAllowBinary)

---

Define Documentation

#define ICMSEG

#define MAXCOLOR8   255

Definition at line 6 of file jan99/dll32/profcrd.c.

---

Function Documentation

void ApplyMatrix (  PFLOAT  e, float far *  Input, float far *  Output )  [static]

Definition at line 1143 of file jan99/dll32/profcrd.c. References SINT. { SINT i, j; for (i = 0; i < 3; i++) { j = i*3; Output[i] = e[j ] * Input[0] + e[j + 1] * Input[1] + e[j + 2] * Input[2]; } }

BOOL CheckColorLookupTable (  LPHOSTCLUT  lpHostClut, float far *  fTemp )  [static]

Definition at line 1032 of file jan99/dll32/profcrd.c. References TableInterp3(), TableInterp4(), and TRUE. { if (lpHostClut->inputChan == 3) { TableInterp3(lpHostClut, fTemp); } else if(lpHostClut->inputChan == 4) { TableInterp4(lpHostClut, fTemp); } return TRUE; }

BOOL CheckInputOutputTable (  LPHOSTCLUT  lpHostClut, float far *  fTemp, BOOL  , BOOL  )  [static]

Definition at line 1056 of file jan99/dll32/profcrd.c. References MAXCHANNELS, PMEMPTR, PUSHORT, TRUE, and USHORT. { int i; short Grids; USHORT floor1, ceiling1; float fIndex; int numChan; int numEnt; PMEMPTR ppArray; if (bInputTable) { numChan = lpHostClut->inputChan; numEnt = lpHostClut->inputEnt - 1; ppArray = lpHostClut->inputArray; } else { numChan = lpHostClut->outputChan; numEnt = lpHostClut->outputEnt - 1; ppArray = lpHostClut->outputArray; } Grids = lpHostClut->clutPoints; for (i = 0; (i <= MAXCHANNELS) && (i < numChan); i++) { fTemp[i] = (fTemp[i] < 0)? 0: ((fTemp[i] > 1)? 1: fTemp[i]); fIndex = fTemp[i] * numEnt; if (lpHostClut->lutBits == 8) { floor1 = ppArray[i][(int)fIndex]; ceiling1 = ppArray[i][((int)fIndex) + 1]; fTemp[i] = (float)(floor1 + (ceiling1 - floor1) * (fIndex - floor(fIndex))); if (bCSA && !bInputTable) fTemp[i] = (float)(fTemp[i] / 127.0); else fTemp[i] = (float)(fTemp[i] / 255.0); } else { floor1 = ((PUSHORT)(ppArray[i]))[(int)fIndex]; ceiling1 = ((PUSHORT)(ppArray[i]))[((int)fIndex) + 1]; fTemp[i] = (float)(floor1 + (ceiling1 - floor1) * (fIndex - floor(fIndex))); if (bCSA && !bInputTable) fTemp[i] = (float)(fTemp[i] / 32767.0); else fTemp[i] = (float)(fTemp[i] / 65535.0); } if (bInputTable) { fTemp[i] *= (Grids - 1); if (fTemp[i] > (Grids - 1)) fTemp[i] = (float)(Grids - 1); } } return TRUE; }

SINT CreateHostInputOutputArray (  MEMPTR  lpMem, PMEMPTR  ppArray, SINT  numChan, SINT  tableSize, SINT  Offset, CSIG  Tag, MEMPTR  Buff )  [static]

Definition at line 53 of file jan99/dll32/profcrd.c. References icSigLut8Type, icUInt16Number, lpcpLut16Type, lpcpLut8Type, MEMPTR, Offset, PUSHORT, SINT, ui16toSINT, and USHORT. { SINT i, j; PUSHORT lpMemPtr16; MEMPTR lpMemPtr8; MEMPTR lpTable; if (Tag == icSigLut8Type) lpMemPtr8 = lpMem; else lpMemPtr16 = (PUSHORT)lpMem; for (i = 0; i < numChan; i++) { if (Tag == icSigLut8Type) { ppArray[i] = lpMemPtr8; lpTable = (MEMPTR) (((lpcpLut8Type) Buff)->lut.data) + Offset + tableSize * i; MemCopy(lpMemPtr8, lpTable, tableSize); lpMemPtr8 += tableSize; } else { ppArray[i] = (MEMPTR)lpMemPtr16; lpTable = (MEMPTR) (((lpcpLut16Type) Buff)->lut.data) + 2 * Offset + 2 * tableSize * i; for (j = 0; j < tableSize; j++) { *lpMemPtr16++ = (USHORT) ui16toSINT (lpTable); lpTable += sizeof (icUInt16Number); } } } if (Tag == icSigLut8Type) return ((SINT) ((MEMPTR)lpMemPtr8 - lpMem)); else return ((SINT) ((MEMPTR)lpMemPtr16 - lpMem)); }

SINT CreateHostLutCRD (  CHANDLE  cp, SINT  Index, MEMPTR  lpMem, DWORD  InputIntent )  [static]

Definition at line 587 of file jan99/dll32/profcrd.c. References BYTE, CIEXYZRange, CP_POSTSCRIPT_ERR, CreateHostInputOutputArray(), CSIG, FAR, GetCLUTinfo(), GetCPConnSpace, GetCPElement(), GetCPElementSize(), GetCPElementType(), GetCPMediaWhitePoint(), GetCPTagSig(), GetCPWhitePoint(), icS15Fixed16Number, icSigLut16Type, icSigLut8Type, icSigXYZData, icUInt16Number, Index, lpcpLut16Type, lpcpLut8Type, LPCSIG, LPHOSTCLUT, LPMEMPTR, LPSFLOAT, LPSINT, MemAlloc(), MemFree(), MEMPTR, NULL, SetCPLastError(), si16f16toSFLOAT, SINT, ui16toSINT, and USHORT. { SINT nInputCh, nOutputCh, nGrids; SINT nInputTable, nOutputTable, nNumbers; CSIG Tag, PCS; CSIG IntentSig; SINT Ret; SINT i, j; MEMPTR lpTable; MEMPTR Buff = NULL; SINT MemSize = 0; MEMPTR lpOldMem = lpMem; HGLOBAL hMem; LPHOSTCLUT lpHostClut; // Check if we can generate the CRD if (!GetCPTagSig (cp, Index, (LPCSIG) & IntentSig) || !GetCPElementType (cp, Index, (LPCSIG) & Tag) || ((Tag != icSigLut8Type) && (Tag != icSigLut16Type)) || !GetCPConnSpace (cp, (LPCSIG) & PCS) || !GetCPElementSize (cp, Index, (LPSINT) & MemSize) || !MemAlloc (MemSize, (HGLOBAL FAR *)&hMem, (LPMEMPTR) & Buff) || !GetCPElement (cp, Index, Buff, MemSize)) { if (NULL != Buff) { MemFree (hMem); } return (0); } GetCLUTinfo(Tag, Buff, &nInputCh, &nOutputCh, &nGrids, &nInputTable, &nOutputTable, &i); if (((nOutputCh != 3) && (nOutputCh != 4)) || (nInputCh != 3)) { SetCPLastError (CP_POSTSCRIPT_ERR); MemFree (hMem); return (0); } // First Pass. This is a size request if (lpMem == NULL) { Ret = nInputCh * nInputTable * i + // Input table 8/16-bits nOutputCh * nOutputTable * i + // Output table 8/16-bits nOutputCh * nGrids * nGrids * nGrids + // CLUT 8-bits only sizeof(HOSTCLUT) + // Data structure 1024; // safe MemFree (hMem); return (Ret); } // Second Pass. Get a HostCRD lpHostClut = (LPHOSTCLUT)lpMem; lpMem += sizeof(HOSTCLUT); lpHostClut->size = sizeof(HOSTCLUT); lpHostClut->pcs = PCS; lpHostClut->intent = InputIntent; lpHostClut->lutBits = (Tag == icSigLut8Type)? 8:16; GetCPWhitePoint (cp, (LPSFLOAT)lpHostClut->whitePoint); // .. Illuminant // Support absolute whitePoint if (!GetCPMediaWhitePoint (cp, (LPSFLOAT)lpHostClut->mediaWP)) // .. Media WhitePoint { lpHostClut->mediaWP[0] = lpHostClut->whitePoint[0]; lpHostClut->mediaWP[1] = lpHostClut->whitePoint[1]; lpHostClut->mediaWP[2] = lpHostClut->whitePoint[2]; } lpHostClut->inputChan = (unsigned char)nInputCh; lpHostClut->outputChan = (unsigned char)nOutputCh; lpHostClut->clutPoints = (unsigned char)nGrids; lpHostClut->inputEnt = (USHORT)nInputTable; lpHostClut->outputEnt = (USHORT)nOutputTable; //******** Input array lpMem += CreateHostInputOutputArray (lpMem, lpHostClut->inputArray, nInputCh, nInputTable, 0, Tag, Buff); //******** the offset to the position of output array. i = nInputTable * nInputCh + nGrids * nGrids * nGrids * nOutputCh; //******** Output array lpMem += CreateHostInputOutputArray (lpMem, lpHostClut->outputArray, nOutputCh, nOutputTable, i, Tag, Buff); //******** Matrix. if (PCS == icSigXYZData) { if (Tag == icSigLut8Type) { lpTable = (MEMPTR) & ((lpcpLut8Type) Buff)->lut.e00; } else { lpTable = (MEMPTR) & ((lpcpLut16Type) Buff)->lut.e00; } for (i = 0; i < 9; i++) { lpHostClut->e[i] = (float)((si16f16toSFLOAT (lpTable)) / CIEXYZRange); lpTable += sizeof (icS15Fixed16Number); } } //********** RenderTable nNumbers = nGrids * nGrids * nOutputCh; lpHostClut->clut = lpMem; for (i = 0; i < nGrids; i++) // Na strings should be sent { if (Tag == icSigLut8Type) { lpTable = (MEMPTR) (((lpcpLut8Type) Buff)->lut.data) + nInputTable * nInputCh + nNumbers * i; } else { lpTable = (MEMPTR) (((lpcpLut16Type) Buff)->lut.data) + 2 * nInputTable * nInputCh + 2 * nNumbers * i; } if (Tag == icSigLut8Type) { MemCopy(lpMem, lpTable, nNumbers); lpMem += nNumbers; } else { for (j = 0; j < nNumbers; j++) { *lpMem++ = (BYTE)(ui16toSINT (lpTable) / 256); lpTable += sizeof (icUInt16Number); } } } MemFree (hMem); return ((SINT) ((unsigned long) (lpMem - lpOldMem))); }

SINT CreateHostRevTRCInputTable (  MEMPTR  lpMem, LPHOSTCLUT  lpHostClut, MEMPTR  lpRed, MEMPTR  lpGreen, MEMPTR  lpBlue )  [static]

Definition at line 358 of file jan99/dll32/profcrd.c. References FAR, GetRevCurve(), LPMEMPTR, MemAlloc(), MemFree(), MEMPTR, and REVCURVE_RATIO. { HGLOBAL hTemp; MEMPTR lpTemp; if (!MemAlloc (lpHostClut->outputEnt * (REVCURVE_RATIO + 1) * 2 , (HGLOBAL FAR *) &hTemp, (LPMEMPTR) &lpTemp)) { return (0); } lpHostClut->outputArray[0] = lpMem; GetRevCurve (lpRed, lpTemp, lpHostClut->outputArray[0]); lpHostClut->outputArray[1] = lpHostClut->outputArray[0] + 2 * REVCURVE_RATIO * lpHostClut->outputEnt; GetRevCurve (lpGreen, lpTemp, lpHostClut->outputArray[1]); lpHostClut->outputArray[2] = lpHostClut->outputArray[1] + 2 * REVCURVE_RATIO * lpHostClut->outputEnt; GetRevCurve (lpBlue, lpTemp, lpHostClut->outputArray[2]); MemFree (hTemp); return ( 2 * REVCURVE_RATIO * lpHostClut->outputEnt * 3); }

SINT CreateHostTRCInputTable (  MEMPTR  lpMem, LPHOSTCLUT  lpHostClut, MEMPTR  lpRed, MEMPTR  lpGreen, MEMPTR  lpBlue )  [static]

Definition at line 322 of file jan99/dll32/profcrd.c. References icUInt16Number, lpcpCurveType, MEMPTR, PUSHORT, SINT, ui16toSINT, and USHORT. { SINT i; PUSHORT lpPtr16; MEMPTR lpTable; lpPtr16 = (PUSHORT)lpMem; lpHostClut->inputArray[0] = (MEMPTR)lpPtr16; lpTable = (MEMPTR)(((lpcpCurveType) lpRed)->curve.data); for (i = 0; i < (SINT)(lpHostClut->inputEnt); i++) { *lpPtr16++ = (USHORT) ui16toSINT(lpTable); lpTable += sizeof(icUInt16Number); } lpHostClut->inputArray[1] = (MEMPTR)lpPtr16; lpTable = (MEMPTR)(((lpcpCurveType) lpGreen)->curve.data); for (i = 0; i < (SINT)(lpHostClut->inputEnt); i++) { *lpPtr16++ = (USHORT) ui16toSINT(lpTable); lpTable += sizeof(icUInt16Number); } lpHostClut->inputArray[2] = (MEMPTR)lpPtr16; lpTable = (MEMPTR)(((lpcpCurveType) lpBlue)->curve.data); for (i = 0; i < (SINT)(lpHostClut->inputEnt); i++) { *lpPtr16++ = (USHORT) ui16toSINT(lpTable); lpTable += sizeof(icUInt16Number); } return ((MEMPTR)lpPtr16 - lpMem); }

SINT CreateInputArray (  MEMPTR  lpMem, SINT  nInputCh, SINT  nInputTable, MEMPTR  Intent, CSIG  Tag, MEMPTR  Buff, BOOL  bAllowBinary, MEMPTR  lpHostClut )

Definition at line 1563 of file jan99/dll32/profcrd.c. References BeginArray, BeginString, DefOp, EndArray, EndString, icSigLut16Type, icSigLut8Type, icUInt16Number, InputArray, Intent, L, lpcpLut16Type, lpcpLut8Type, LPHOSTCLUT, MAX_LINELENG, MEMPTR, NewLine, PreViewInArray, PUSHORT, SINT, Slash, ui16toSINT, WriteByteString(), WriteHexBuffer(), WriteHNAToken(), WriteInt, WriteIntStringU2S(), WriteIntStringU2S_L(), WriteNewLineObject(), WriteObject, WriteObjectN(), and WriteStringToken(). { SINT i, j; MEMPTR lpOldMem; MEMPTR lpTable; MEMPTR lpLineStart; lpOldMem = lpMem; if (lpHostClut) { nInputCh = (SINT)(((LPHOSTCLUT)lpHostClut)->inputChan); nInputTable = (SINT)(((LPHOSTCLUT)lpHostClut)->inputEnt); Tag = (((LPHOSTCLUT)lpHostClut)->lutBits == 8)? icSigLut8Type : icSigLut16Type; } for (i = 0; i < nInputCh; i++) { lpLineStart = lpMem; lpMem += WriteNewLineObject (lpMem, Slash); if (lpHostClut) lpMem += WriteObject (lpMem, PreViewInArray); else lpMem += WriteObject (lpMem, InputArray); lpMem += WriteObjectN (lpMem, Intent, lstrlen (Intent)); lpMem += WriteInt (lpMem, i); if (lpHostClut) { lpTable = ((LPHOSTCLUT)lpHostClut)->inputArray[i]; } else { if (Tag == icSigLut8Type) lpTable = (MEMPTR) (((lpcpLut8Type) Buff)->lut.data) + nInputTable * i; else lpTable = (MEMPTR) (((lpcpLut16Type) Buff)->lut.data) + 2 * nInputTable * i; } if (!bAllowBinary) // Output ASCII CRD { if (Tag == icSigLut8Type) { lpMem += WriteObject (lpMem, BeginString); lpMem += WriteHexBuffer (lpMem, lpTable,lpLineStart, nInputTable); lpMem += WriteObject (lpMem, EndString); } else { lpMem += WriteObject (lpMem, BeginArray); for (j = 0; j < nInputTable; j++) { if(lpHostClut) lpMem += WriteInt (lpMem, *((PUSHORT)lpTable)); else lpMem += WriteInt (lpMem, ui16toSINT (lpTable)); lpTable += sizeof (icUInt16Number); if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG) { lpLineStart = lpMem; lpMem += WriteObject (lpMem, NewLine); } } lpMem += WriteObject (lpMem, EndArray); } } else { // Output BINARY CRD if (Tag == icSigLut8Type) { lpMem += WriteStringToken (lpMem, 143, 256); lpMem += WriteByteString (lpMem, lpTable, 256L); } else { lpMem += WriteHNAToken (lpMem, 149, nInputTable); if (lpHostClut) lpMem += WriteIntStringU2S_L (lpMem, lpTable, nInputTable); else lpMem += WriteIntStringU2S (lpMem, lpTable, nInputTable); } } lpMem += WriteObject (lpMem, DefOp); } return ((SINT) (lpMem - lpOldMem)); }

SINT CreateOutputArray (  MEMPTR  lpMem, SINT  nOutputCh, SINT  nOutputTable, SINT  Offset, MEMPTR  Intent, CSIG  Tag, MEMPTR  Buff, BOOL  AllowBinary, MEMPTR  lpHostClut )

Definition at line 1452 of file jan99/dll32/profcrd.c. References AllowBinary, BeginArray, BeginString, DefOp, EndArray, EndString, icSigLut16Type, icSigLut8Type, icUInt16Number, Intent, L, lpcpLut16Type, lpcpLut8Type, LPHOSTCLUT, MAX_LINELENG, MEMPTR, NewLine, Offset, OutputArray, PreViewOutArray, PUSHORT, SINT, Slash, ui16toSINT, WriteByteString(), WriteHexBuffer(), WriteHNAToken(), WriteInt, WriteIntStringU2S(), WriteIntStringU2S_L(), WriteNewLineObject(), WriteObject, WriteObjectN(), and WriteStringToken(). { SINT i, j; MEMPTR lpOldMem; MEMPTR lpTable; MEMPTR lpLineStart; lpOldMem = lpMem; if (lpHostClut) { nOutputCh = (SINT)(((LPHOSTCLUT)lpHostClut)->outputChan); nOutputTable = (SINT)(((LPHOSTCLUT)lpHostClut)->outputEnt); Tag = (((LPHOSTCLUT)lpHostClut)->lutBits == 8)? icSigLut8Type : icSigLut16Type; } for (i = 0; i < nOutputCh; i++) { lpLineStart = lpMem; lpMem += WriteNewLineObject (lpMem, Slash); if (lpHostClut) lpMem += WriteObject (lpMem, PreViewOutArray); else lpMem += WriteObject (lpMem, OutputArray); lpMem += WriteObjectN (lpMem, Intent, lstrlen (Intent)); lpMem += WriteInt (lpMem, i); if (lpHostClut) lpTable = ((LPHOSTCLUT)lpHostClut)->outputArray[i]; else { if (Tag == icSigLut8Type) lpTable = (MEMPTR) (((lpcpLut8Type) Buff)->lut.data) + Offset + nOutputTable * i; else lpTable = (MEMPTR) (((lpcpLut16Type) Buff)->lut.data) + 2 * Offset + 2 * nOutputTable * i; } if (!AllowBinary) // Output ASCII CRD { if (Tag == icSigLut8Type) { lpMem += WriteObject (lpMem, BeginString); lpMem += WriteHexBuffer (lpMem, lpTable, lpLineStart, nOutputTable); lpMem += WriteObject (lpMem, EndString); } else { lpMem += WriteObject (lpMem, BeginArray); for (j = 0; j < nOutputTable; j++) { if (lpHostClut) lpMem += WriteInt (lpMem, *((PUSHORT)lpTable)); else lpMem += WriteInt (lpMem, ui16toSINT (lpTable)); lpTable += sizeof (icUInt16Number); if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG) { lpLineStart = lpMem; lpMem += WriteObject (lpMem, NewLine); } } lpMem += WriteObject (lpMem, EndArray); } } else { // Output BINARY CRD if (Tag == icSigLut8Type) { lpMem += WriteStringToken (lpMem, 143, 256); lpMem += WriteByteString (lpMem, lpTable, 256L); } else { lpMem += WriteHNAToken (lpMem, 149, nOutputTable); if (lpHostClut) lpMem += WriteIntStringU2S_L (lpMem, lpTable, nOutputTable); else lpMem += WriteIntStringU2S (lpMem, lpTable, nOutputTable); } } lpMem += WriteObject (lpMem, DefOp); } return ((SINT) (lpMem - lpOldMem)); }

BOOL DoHostConversionCRD (  LPHOSTCLUT  lpHostCRD, LPHOSTCLUT  lpHostCSA, float far *  Input, float far *  Output, CSIG  ColorSpace, BOOL  bCheckOutputTable )  [static]

Definition at line 1169 of file jan99/dll32/profcrd.c. References ApplyMatrix(), CheckColorLookupTable(), CheckInputOutputTable(), DATA_matrix, icSigLabData, icSigXYZData, LabToXYZ(), MAXCHANNELS, TRUE, and XYZToLab(). { float fTemp[MAXCHANNELS]; float fTemp1[MAXCHANNELS]; int i; // When sampling the deviceCRD, skip the input table. // If lpHostCSA is not NULL, the current CRD is targetCRD, we // need to do input table conversion if (lpHostCSA) { // Convert Lab to XYZ in range [ 0 whitePoint ] if ((lpHostCRD->pcs == icSigXYZData) && (lpHostCSA->pcs == icSigLabData)) { LabToXYZ(Input, fTemp1, lpHostCRD->whitePoint); } // Convert XYZ to Lab in range [ 0 1] else if ((lpHostCRD->pcs == icSigLabData) && (lpHostCSA->pcs == icSigXYZData)) { XYZToLab(Input, fTemp, lpHostCSA->whitePoint); } // Convert Lab to range [ 0 1] else if ((lpHostCRD->pcs == icSigLabData) && (lpHostCSA->pcs == icSigLabData)) { for (i = 0; i < 3; i++) fTemp[i] = Input[i] / 2; } // Convert XYZ to XYZ (based on white point) to range [0 1] else { // TODO: different intents using different conversion. // icRelativeColorimetric: using Bradford transform. // icAbsoluteColorimetric: using scaling. for (i = 0; i < 3; i++) fTemp1[i] = Input[i] * lpHostCRD->whitePoint[i] / lpHostCSA->whitePoint[i]; } // Matrix, used for XYZ data only or Matrix icc profile only if (lpHostCRD->pcs == icSigXYZData) { ApplyMatrix(lpHostCRD->e, fTemp1, fTemp); } if (lpHostCRD->dataType != DATA_matrix) { //Search input Table CheckInputOutputTable(lpHostCRD, fTemp, 0, 1); } } // If the current CRD is device CRD, we do not need to do input // table conversion. else { short Grids; Grids = lpHostCRD->clutPoints; // Sample data may be XYZ or Lab. It depends on Target icc profile. // If the PCS of the target icc profile is XYZ, input data will be XYZ. // If the PCS of the target icc profile is Lab, input data will be Lab. if (lpHostCRD->dataType == DATA_matrix) { for (i = 0; i < 3; i++) { fTemp[i] = Input[i]; } } else { for (i = 0; i < 3; i++) { fTemp[i] = Input[i]* (Grids - 1); if (fTemp[i] > (Grids - 1)) fTemp[i] = (float)(Grids - 1); } } } // bCheckInputTable if (lpHostCRD->dataType != DATA_matrix) { // Rendering table CheckColorLookupTable(lpHostCRD, fTemp); } if (bCheckOutputTable) { //Output Table CheckInputOutputTable(lpHostCRD, fTemp, 0, 0); } for (i = 0; (i <= MAXCHANNELS) && (i < lpHostCRD->outputChan); i++) { Output[i] = fTemp[i]; } return TRUE; }

BOOL DoHostConversionCSA (  LPHOSTCLUT  lpHostClut, float far *  Input, float far *  Output )  [static]

Definition at line 1288 of file jan99/dll32/profcrd.c. References ApplyMatrix(), CheckColorLookupTable(), CheckInputOutputTable(), DATA_matrix, MAXCHANNELS, and TRUE. { float fTemp[MAXCHANNELS]; int i; for (i = 0; (i <= MAXCHANNELS) && (i < lpHostClut->inputChan); i++) { fTemp[i] = Input[i]; } if (lpHostClut->dataType == DATA_matrix) { //Search input Table CheckInputOutputTable(lpHostClut, fTemp, 1, 1); ApplyMatrix(lpHostClut->e, fTemp, Output); } else { //Search input Table CheckInputOutputTable(lpHostClut, fTemp, 1, 1); // Rendering table CheckColorLookupTable(lpHostClut, fTemp); //Output Table CheckInputOutputTable(lpHostClut, fTemp, 1, 0 ); for (i = 0; (i <= MAXCHANNELS) && (i < lpHostClut->outputChan); i++) { Output[i] = fTemp[i]; } } return TRUE; }

float g (  float  f  )  [static]

Definition at line 806 of file jan99/dll32/profcrd.c. { float frc; if (f >= (6/29)) { frc = f * f * f; } else { frc = f - (4.0f / 29.0f) * (108.0f / 841.0f); } return frc; }

VOID GetCLUTinfo (  CSIG  LutTag, MEMPTR  lpLut, LPSINT  nInputCh, LPSINT  nOutputCh, LPSINT  nGrids, LPSINT  nInputTable, LPSINT  nOutputTable, LPSINT  size )

Definition at line 99 of file jan99/dll32/profcrd.c. References icSigLut8Type, L, lpcpLut16Type, lpcpLut8Type, ui16toSINT, and ui8toSINT. { if (LutTag == icSigLut8Type) { *nInputCh = ui8toSINT (((lpcpLut8Type) lpLut)->lut.inputChan); *nOutputCh = ui8toSINT (((lpcpLut8Type) lpLut)->lut.outputChan); *nGrids = ui8toSINT (((lpcpLut8Type) lpLut)->lut.clutPoints); *nInputTable = 256L; *nOutputTable = 256L; *size = 1; // one byte for each input\output table entry } else { *nInputCh = ui8toSINT (((lpcpLut16Type) lpLut)->lut.inputChan); *nOutputCh = ui8toSINT (((lpcpLut16Type) lpLut)->lut.outputChan); *nGrids = ui8toSINT (((lpcpLut16Type) lpLut)->lut.clutPoints); *nInputTable = ui16toSINT (((lpcpLut16Type) lpLut)->lut.inputEnt); *nOutputTable = ui16toSINT (((lpcpLut16Type) lpLut)->lut.outputEnt); *size = 2; // two bytes for each input\output table entry } }

BOOL GetCRDInputOutputArraySize (  CHANDLE  cp, DWORD  Intent, LPSINT  lpInTbSize, LPSINT  lpOutTbSize, LPCSIG  lpIntentTag, LPSINT  lpGrids )  [static]

Definition at line 1331 of file jan99/dll32/profcrd.c. References BOOL, CSIG, DoesCPTagExist(), FALSE, FAR, GetCLUTinfo(), GetCPElement(), GetCPElementSize(), GetCPElementType(), GetCPTagIndex(), GetHostCSA_Intent(), icAbsoluteColorimetric, icPerceptual, icRelativeColorimetric, icSaturation, icSigBToA0Tag, icSigBToA1Tag, icSigBToA2Tag, icSigLut16Type, icSigLut8Type, Index, Intent, LPCSIG, LPMEMPTR, LPSINT, MemAlloc(), MemFree(), MEMPTR, NULL, SINT, TRUE, and TYPE_CIEBASEDDEF. { CSIG Tag; SINT Index; SINT Ret = 0; MEMPTR Buff = NULL; SINT MemSize = 0; HGLOBAL hMem; SINT outputChan, outputEnt; SINT inputChan, inputEnt; SINT Grids; SINT i; switch (Intent) { case icPerceptual: *lpIntentTag = icSigBToA0Tag; break; case icRelativeColorimetric: case icAbsoluteColorimetric: *lpIntentTag = icSigBToA1Tag; break; case icSaturation: *lpIntentTag = icSigBToA2Tag; break; default: return FALSE; } if (!DoesCPTagExist (cp, *lpIntentTag) || !GetCPTagIndex (cp, *lpIntentTag, (LPSINT) & Index) || !GetCPElementType (cp, Index, (LPCSIG) & Tag) || ((Tag != icSigLut8Type) && (Tag != icSigLut16Type)) || !GetCPElementSize (cp, Index, (LPSINT) & MemSize) || !MemAlloc (MemSize, (HGLOBAL FAR *)&hMem, (LPMEMPTR) & Buff) || !GetCPElement (cp, Index, Buff, MemSize)) { BOOL retVal = FALSE; if (NULL != Buff) { MemFree (hMem); } // Matrix icc profile. *lpGrids = 2; if (lpInTbSize) { retVal = GetHostCSA_Intent (cp, NULL, lpInTbSize, (CSIG) Intent, TYPE_CIEBASEDDEF); *lpInTbSize = *lpInTbSize * 3; } if (lpOutTbSize) { retVal = GetHostCSA_Intent (cp, NULL, lpOutTbSize, (CSIG) Intent, TYPE_CIEBASEDDEF); *lpOutTbSize = *lpOutTbSize * 3; } return retVal; } if (lpInTbSize) { GetCLUTinfo(Tag, Buff, &inputChan, &outputChan, &Grids, &inputEnt, &outputEnt, &i); if (inputChan != 3) { MemFree (hMem); return FALSE; } *lpInTbSize = inputChan * inputEnt * 6; // Number of INT bytes *lpGrids = Grids; } if (lpOutTbSize) { GetCLUTinfo(Tag, Buff, &inputChan, &outputChan, &Grids, &inputEnt, &outputEnt, &i); if ((outputChan != 3) && (outputChan != 4)) { MemFree (hMem); return FALSE; } *lpOutTbSize = outputChan * outputEnt * 6; // Number of INT bytes *lpGrids = Grids; } MemFree (hMem); return TRUE; }

BOOL GetHostColorRenderingDictionary (  CHANDLE  cp, DWORD  Intent, MEMPTR  lpMem, LPDWORD  lpcbSize )  [static]

Definition at line 745 of file jan99/dll32/profcrd.c. References CreateHostLutCRD(), CSIG, DoesCPTagExist(), DoesTRCAndColorantTagExist(), DWORD, FALSE, GetCPTagIndex(), GetHostMatrixCSAorCRD(), icAbsoluteColorimetric, icPerceptual, icRelativeColorimetric, icSaturation, icSigBToA0Tag, icSigBToA1Tag, icSigBToA2Tag, Index, Intent, LPSINT, NULL, and SINT. { SINT Index; CSIG BToAxTag; if (!cp) return FALSE; if ((lpMem == NULL) || (*lpcbSize == 0)) { lpMem = NULL; *lpcbSize = 0; } switch (Intent) { case icPerceptual: BToAxTag = icSigBToA0Tag; break; case icRelativeColorimetric: case icAbsoluteColorimetric: // Use RelativeColorimetric to calculate this CRD. BToAxTag = icSigBToA1Tag; break; case icSaturation: BToAxTag = icSigBToA2Tag; break; default: *lpcbSize = (DWORD) 0; return FALSE; } if (DoesCPTagExist (cp, BToAxTag) && GetCPTagIndex (cp, BToAxTag, (LPSINT) & Index)) { *lpcbSize = CreateHostLutCRD (cp, Index, lpMem, Intent); } else if(DoesTRCAndColorantTagExist(cp)) { GetHostMatrixCSAorCRD(cp, lpMem, lpcbSize, FALSE); } return (*lpcbSize > 0); }

BOOL GetHostColorSpaceArray (  CHANDLE  cp, DWORD  InputIntent, MEMPTR  lpBuffer, LPDWORD  lpcbSize )  [static]

Definition at line 532 of file jan99/dll32/profcrd.c. References BOOL, CSIG, DWORD, FALSE, GetCPDevSpace, GetCPRenderIntent, GetHostCSA_Intent(), icSigCmykData, icSigRgbData, icUseRenderingIntent, Intent, LPCSIG, TYPE_CIEBASEDDEF, and TYPE_CIEBASEDDEFG. { CSIG ColorSpace, Intent; BOOL Success = FALSE; if (!cp) return Success; if (!GetCPDevSpace (cp, (LPCSIG) & ColorSpace) || !GetCPRenderIntent (cp, (LPCSIG) & Intent)) { return Success; } if (InputIntent == icUseRenderingIntent) InputIntent = (DWORD)Intent; if (!Success) { switch (ColorSpace) { case icSigRgbData: Success = GetHostCSA_Intent (cp, lpBuffer, lpcbSize, (CSIG) InputIntent, TYPE_CIEBASEDDEF); break; case icSigCmykData: Success = GetHostCSA_Intent (cp, lpBuffer, lpcbSize, (CSIG) InputIntent, TYPE_CIEBASEDDEFG); break; default: break; } } return Success; }

BOOL GetHostCSA (  CHANDLE  cp, MEMPTR  lpMem, LPDWORD  lpcbSize, CSIG  InputIntent, SINT  Index, int  Type )  [static]

Definition at line 138 of file jan99/dll32/profcrd.c. References BYTE, CP_POSTSCRIPT_ERR, CreateHostInputOutputArray(), CSIG, DWORD, FALSE, FAR, GetCLUTinfo(), GetCPConnSpace, GetCPElement(), GetCPElementSize(), GetCPElementType(), GetCPTagSig(), GetCPWhitePoint(), icSigLabData, icSigLut16Type, icSigLut8Type, icSigXYZData, icUInt16Number, Index, lpcpLut16Type, lpcpLut8Type, LPCSIG, LPHOSTCLUT, LPMEMPTR, LPSFLOAT, LPSINT, MemAlloc(), MemFree(), MEMPTR, NULL, SetCPLastError(), SINT, TRUE, TYPE_CIEBASEDDEF, TYPE_CIEBASEDDEFG, ui16toSINT, and USHORT. { CSIG PCS, LutTag; CSIG IntentSig; SINT nInputCh, nOutputCh, nGrids, SecondGrids; SINT nInputTable, nOutputTable, nNumbers; SINT i, j, k; MEMPTR lpTable; MEMPTR lpOldMem = lpMem; MEMPTR lpLut = NULL; HGLOBAL hLut = 0; SINT LutSize; LPHOSTCLUT lpHostClut; // Check if we can generate the CS. // If we cannot find the required tag - we will return false if (!GetCPConnSpace (cp, (LPCSIG) & PCS) || (PCS != icSigLabData) && (PCS != icSigXYZData) || !GetCPTagSig (cp, Index, (LPCSIG) & IntentSig)) { return (FALSE); } if (!GetCPElementType (cp, Index, (LPCSIG) & LutTag) || ((LutTag != icSigLut8Type) && (LutTag != icSigLut16Type)) || !GetCPElementSize (cp, Index, (LPSINT) & LutSize) || !MemAlloc (LutSize, (HGLOBAL FAR *) &hLut, (LPMEMPTR) & lpLut) || !GetCPElement (cp, Index, lpLut, LutSize)) { if (0 != hLut) { MemFree (hLut); } return (FALSE); } // Estimate the memory size required to hold CS GetCLUTinfo(LutTag, lpLut, &nInputCh, &nOutputCh, &nGrids, &nInputTable, &nOutputTable, &i); if (!(nOutputCh == 3) || !((nInputCh == 3) && (Type == TYPE_CIEBASEDDEF)) && !((nInputCh == 4) && (Type == TYPE_CIEBASEDDEFG))) { SetCPLastError (CP_POSTSCRIPT_ERR); MemFree (hLut); return (FALSE); } // First Pass. This is a size request if (lpMem == NULL) { if (Type == TYPE_CIEBASEDDEFG) *lpcbSize = nOutputCh * nGrids * nGrids * nGrids * nGrids; else *lpcbSize = nOutputCh * nGrids * nGrids * nGrids; *lpcbSize = *lpcbSize + // size of RenderTable 8-bits only nInputCh * nInputTable * i + // size of input table 8/16-bits nOutputCh * nOutputTable * i + // size of output table 8/16-bits sizeof(HOSTCLUT) + 1024; // data structure + extra safe space MemFree (hLut); return (TRUE); } // Second pass. constructure real HostCSA lpHostClut = (LPHOSTCLUT)lpMem; lpMem += sizeof(HOSTCLUT); lpHostClut->size = sizeof(HOSTCLUT); lpHostClut->pcs = PCS; lpHostClut->intent = InputIntent; lpHostClut->lutBits = (LutTag == icSigLut8Type)? 8:16; // Get info about Illuminant White Point from the header GetCPWhitePoint (cp, (LPSFLOAT)lpHostClut->whitePoint); // .. Illuminant lpHostClut->inputChan = (unsigned char)nInputCh; lpHostClut->outputChan = (unsigned char)nOutputCh; lpHostClut->clutPoints = (unsigned char)nGrids; lpHostClut->inputEnt = (USHORT)nInputTable; lpHostClut->outputEnt = (USHORT)nOutputTable; // Input Array lpMem += CreateHostInputOutputArray (lpMem, lpHostClut->inputArray, nInputCh, nInputTable, 0, LutTag, lpLut); if (Type == TYPE_CIEBASEDDEFG) { i = nInputTable * nInputCh + nGrids * nGrids * nGrids * nGrids * nOutputCh; } else { i = nInputTable * nInputCh + nGrids * nGrids * nGrids * nOutputCh; } // ourput array lpMem += CreateHostInputOutputArray (lpMem, lpHostClut->outputArray, nOutputCh, nOutputTable, i, LutTag, lpLut); //********** /Table lpHostClut->clut = lpMem; nNumbers = nGrids * nGrids * nOutputCh; SecondGrids = 1; if (Type == TYPE_CIEBASEDDEFG) { SecondGrids = nGrids; } for (i = 0; i < nGrids; i++) // Nh strings should be sent { for (k = 0; k < SecondGrids; k++) { if (LutTag == icSigLut8Type) { lpTable = (MEMPTR) (((lpcpLut8Type) lpLut)->lut.data) + nInputTable * nInputCh + nNumbers * (i * SecondGrids + k); } else { lpTable = (MEMPTR) (((lpcpLut16Type) lpLut)->lut.data) + 2 * nInputTable * nInputCh + 2 * nNumbers * (i * SecondGrids + k); } if (LutTag == icSigLut8Type) { // Copy 8-bit data. MemCopy(lpMem, lpTable, nNumbers); lpMem += nNumbers; } else { // convert 16 bit integer to right format. then copy only 8 bits. for (j = 0; j < nNumbers; j++) { *lpMem++ = (BYTE)(ui16toSINT (lpTable) / 256); lpTable += sizeof (icUInt16Number); } } } } *lpcbSize = (DWORD) (lpMem - lpOldMem); MemFree (hLut); return (TRUE); }

BOOL GetHostCSA_Intent (  CHANDLE  cp, MEMPTR  lpBuffer, LPDWORD  lpcbSize, CSIG  Intent, int  Type )

Definition at line 299 of file dec97/dll32/profcrd.c. { SINT Index; BOOL Success = FALSE; CSIG AToBxTag; switch (Intent) { case icPerceptual: AToBxTag = icSigAToB0Tag; break; case icRelativeColorimetric: case icAbsoluteColorimetric: // use RelativeColorimetric data to build it. AToBxTag = icSigAToB1Tag; break; case icSaturation: AToBxTag = icSigAToB2Tag; break; default: return FALSE; break; } if (DoesCPTagExist (cp, AToBxTag) && GetCPTagIndex (cp, AToBxTag, (LPSINT) & Index)) { Success = GetHostCSA(cp, lpBuffer, lpcbSize, Intent, Index, Type); } return Success; }

BOOL GetHostMatrixCSAorCRD (  CHANDLE  cp, MEMPTR  lpMem, LPDWORD  lpcbSize, BOOL  bCSA )  [static]

Definition at line 384 of file jan99/dll32/profcrd.c. References CreateColorantArray(), CreateHostRevTRCInputTable(), CreateHostTRCInputTable(), DATA_matrix, DWORD, FALSE, GetCPWhitePoint(), GetTRCData(), icSigBlueColorantTag, icSigGreenColorantTag, icSigRedColorantTag, icSigXYZData, InvertMatrix(), LPHOSTCLUT, LPMEMPTR, LPSFLOAT, LPSINT, MemFree(), MEMPTR, NULL, SINT, TRUE, and USHORT. { SINT nRedCount, nGreenCount, nBlueCount; MEMPTR lpRed = NULL,lpGreen, lpBlue; HGLOBAL hMem; LPHOSTCLUT lpHostClut; MEMPTR lpOldMem = lpMem; double pArray[9], pRevArray[9], pTemp[9]; SINT i; hMem = GetTRCData(cp, (LPMEMPTR)&lpRed, (LPMEMPTR)&lpGreen, (LPMEMPTR)&lpBlue, (LPSINT)&nRedCount,(LPSINT)&nGreenCount, (LPSINT)&nBlueCount); // Estimate the memory size required to hold CRD *lpcbSize = (nRedCount + nGreenCount + nBlueCount) * 2 + sizeof(HOSTCLUT) + 1024; // data structure + extra safe space if (lpMem == NULL) // This is a size request { MemFree (hMem); return TRUE; } lpHostClut = (LPHOSTCLUT)lpMem; lpMem += sizeof(HOSTCLUT); lpHostClut->size = sizeof(HOSTCLUT); lpHostClut->dataType = DATA_matrix; lpHostClut->clutPoints = 2; lpHostClut->pcs = icSigXYZData; GetCPWhitePoint(cp, (LPSFLOAT)lpHostClut->whitePoint); if (bCSA) { lpHostClut->inputEnt = (USHORT)nRedCount; lpHostClut->inputChan = 3; lpMem += CreateHostTRCInputTable(lpMem, lpHostClut, lpRed, lpGreen, lpBlue); } else { lpHostClut->outputEnt = (USHORT)nRedCount; lpHostClut->outputChan = 3; lpMem += CreateHostRevTRCInputTable(lpMem, lpHostClut, lpRed, lpGreen, lpBlue); } MemFree (hMem); *lpcbSize = (DWORD) (lpMem - lpOldMem); if (!CreateColorantArray(cp, &pTemp[0], icSigRedColorantTag) || !CreateColorantArray(cp, &pTemp[3], icSigGreenColorantTag) || !CreateColorantArray(cp, &pTemp[6], icSigBlueColorantTag)) { return (FALSE); } for (i = 0; i < 9; i++) { pArray[i] = pTemp[i/8*8 + i*3%8]; } if (bCSA) { for (i = 0; i < 9; i++) lpHostClut->e[i] = (float)pArray[i]; } else { InvertMatrix(pArray, pRevArray); for (i = 0; i < 9; i++) lpHostClut->e[i] = (float)pRevArray[i]; } return TRUE; }

BOOL EXTERN GetPS2PreviewColorRenderingDictionary (  CHANDLE  cpDev, CHANDLE  cpTarget, DWORD  Intent, MEMPTR  lpMem, LPDWORD  lpcbSize, BOOL  bAllowBinary )

Definition at line 1954 of file jan99/dll32/profcrd.c. References BeginArray, BeginDict, BeginGlobalDict(), BeginString, BOOL, BYTES, CRDBegin, CRDEnd, CreateInputArray(), CreateOutputArray(), CSIG, DictType, DoHostConversionCRD(), DoHostConversionCSA(), DWORD, EnableGlobalDict(), EndArray, EndDict, EndGlobalDict(), EndString, FALSE, FAR, GetCPDevSpace, GetCRDInputOutputArraySize(), GetHostColorRenderingDictionary(), GetHostColorSpaceArray(), GetPublicArrayName(), icAbsoluteColorimetric, icPerceptual, icRelativeColorimetric, icSaturation, icSigCmykData, Intent, IntentACol, IntentPer, IntentRCol, IntentSat, IntentType, LPCSIG, LPHOSTCLUT, LPMEMPTR, MAX_LINELENG, MAXCHANNELS, MemAlloc(), MemFree(), MEMPTR, NewLine, NULL, pcs, PREVIEWCRDGRID, RenderTableTag, SendCRDABC(), SendCRDBWPoint(), SendCRDLMN(), SendCRDOutputTable(), SendCRDPQR(), SINT, TempBfSize, TRUE, USHORT, WriteHex, WriteInt, WriteNewLineObject(), WriteObject, and WriteStringToken(). { MEMPTR lpTargetCRD, lpTargetCSA, lpDevCRD; DWORD cbTargetCRD, cbTargetCSA, cbDevCRD; HGLOBAL hTargetCRD, hTargetCSA, hDevCRD; BOOL Success = FALSE; float Input[MAXCHANNELS]; float Output[MAXCHANNELS]; float Temp[MAXCHANNELS]; int i, j, k, l; MEMPTR lpLineStart; MEMPTR lpOldMem; CSIG ColorSpace; CSIG DevColorSpace; static CSIG IntentTag; static SINT PreviewCRDGrid; SINT OutArraySize, InArraySize; char PublicArrayName[TempBfSize]; SINT TargetGrids, DevGrids; // First pass, return the size of Previewind CRD. if (lpMem == NULL) { SINT dwOutArraySizr = 0; i = 3; // Default output channal; if ((GetCPDevSpace (cpDev, (LPCSIG) & DevColorSpace)) && (DevColorSpace == icSigCmykData)) { i = 4; } // Get the input array size IntentTag and Grid of the Target icc profile. if (!GetCRDInputOutputArraySize(cpTarget, Intent, &InArraySize, NULL, &IntentTag, &TargetGrids )) return FALSE; // Get the output array size IntentTag and Grid of the Dev icc profile. if (!GetCRDInputOutputArraySize(cpDev, Intent, NULL, &OutArraySize, &IntentTag, &DevGrids )) return FALSE; PreviewCRDGrid = (TargetGrids > DevGrids)? TargetGrids: DevGrids; // Min proofing CRD grid will be PREVIEWCRDGRID if (PreviewCRDGrid < PREVIEWCRDGRID) PreviewCRDGrid = PREVIEWCRDGRID; *lpcbSize = PreviewCRDGrid * PreviewCRDGrid * PreviewCRDGrid * i * 2 + // CLUT size (Hex output) OutArraySize + // Output Array size InArraySize + // Input Array size 4096; // Extra PostScript staff. return (TRUE); } // Second pass, return the Previewind CRD. lpOldMem = lpMem; //Query the sizes of Host TargetCRD, TargetCSA and DevCRD. if (!(GetHostColorRenderingDictionary (cpTarget, Intent, NULL, &cbTargetCRD)) || !(GetHostColorSpaceArray (cpTarget, Intent, NULL, &cbTargetCSA)) || !(GetHostColorRenderingDictionary (cpDev, Intent, NULL, &cbDevCRD))) { return (Success); } //Alloc the buffers for Host TargetCRD, TargetCSA and DevCRD. hTargetCRD = hTargetCSA = hDevCRD = 0; if (!MemAlloc (cbTargetCRD, (HGLOBAL FAR *)&hTargetCRD, (LPMEMPTR)&lpTargetCRD) || !MemAlloc (cbTargetCSA, (HGLOBAL FAR *)&hTargetCSA, (LPMEMPTR)&lpTargetCSA) || !MemAlloc (cbDevCRD, (HGLOBAL FAR *)&hDevCRD, (LPMEMPTR)&lpDevCRD)) { goto Done; } //Build Host TargetCRD, TargetCSA and DevCRD. if (!(GetHostColorRenderingDictionary (cpTarget, Intent, lpTargetCRD, &cbTargetCRD)) || !(GetHostColorSpaceArray (cpTarget, Intent, lpTargetCSA, &cbTargetCSA)) || !(GetHostColorRenderingDictionary (cpDev, Intent, lpDevCRD, &cbDevCRD))) { goto Done; } // Build Proofing CRD based on Host TargetCRD TargetCSA and DevCRD. // We use TargetCRD input tables and matrix as the // input tables and matrix of the ProofCRD. // We use DevCRD output tables as the output tables of the ProofCRD. //******** Define golbal array used in EncodeABC and RenderTaber GetPublicArrayName (cpDev, IntentTag, PublicArrayName); lpMem += WriteNewLineObject (lpMem, CRDBegin); lpMem += EnableGlobalDict(lpMem); lpMem += BeginGlobalDict(lpMem); lpMem += CreateInputArray (lpMem, (SINT)0, (SINT)0, (MEMPTR)PublicArrayName, (CSIG)0, NULL, bAllowBinary, lpTargetCRD); lpMem += CreateOutputArray (lpMem, (SINT)0, (SINT)0, (SINT)0, (MEMPTR)PublicArrayName, (CSIG)0, NULL, bAllowBinary, lpDevCRD); lpMem += EndGlobalDict(lpMem); //************* Start writing CRD **************************** lpMem += WriteNewLineObject (lpMem, BeginDict); // Begin dictionary lpMem += WriteObject (lpMem, DictType); // Dictionary type lpMem += WriteNewLineObject (lpMem, IntentType); // RenderingIntent switch (Intent) { case icPerceptual: lpMem += WriteObject (lpMem, IntentPer); break; case icSaturation: lpMem += WriteObject (lpMem, IntentSat); break; case icRelativeColorimetric: lpMem += WriteObject (lpMem, IntentRCol); break; case icAbsoluteColorimetric: lpMem += WriteObject (lpMem, IntentACol); break; } //********** Send Black/White Point. lpMem += SendCRDBWPoint(lpMem, ((LPHOSTCLUT)lpTargetCRD)->whitePoint); //********** Send PQR - For White Point correction lpMem += SendCRDPQR(lpMem, Intent, ((LPHOSTCLUT)lpTargetCRD)->whitePoint); //********** Send LMN - For Absolute Colorimetric use WhitePoint's XYZs lpMem += SendCRDLMN(lpMem, Intent, ((LPHOSTCLUT)lpTargetCRD)->whitePoint, ((LPHOSTCLUT)lpTargetCRD)->mediaWP, ((LPHOSTCLUT)lpTargetCRD)->pcs); //********** Create MatrixABC and EncodeABC stuff lpMem += SendCRDABC(lpMem, PublicArrayName, ((LPHOSTCLUT)lpTargetCRD)->pcs, ((LPHOSTCLUT)lpTargetCRD)->inputChan, NULL, ((LPHOSTCLUT)lpTargetCRD)->e, (((LPHOSTCLUT)lpTargetCRD)->lutBits == 8)? icSigLut8Type:icSigLut16Type, bAllowBinary); //********** /RenderTable lpMem += WriteNewLineObject (lpMem, RenderTableTag); lpMem += WriteObject (lpMem, BeginArray); lpMem += WriteInt (lpMem, PreviewCRDGrid); // Send down Na lpMem += WriteInt (lpMem, PreviewCRDGrid); // Send down Nb lpMem += WriteInt (lpMem, PreviewCRDGrid); // Send down Nc lpLineStart = lpMem; lpMem += WriteNewLineObject (lpMem, BeginArray); ColorSpace = ((LPHOSTCLUT)lpDevCRD)->pcs; for (i = 0; i < PreviewCRDGrid; i++) // Na strings should be sent { lpMem += WriteObject (lpMem, NewLine); lpLineStart = lpMem; if (bAllowBinary) { lpMem += WriteStringToken (lpMem, 143, PreviewCRDGrid * PreviewCRDGrid * ((LPHOSTCLUT)lpDevCRD)->outputChan); } else { lpMem += WriteObject (lpMem, BeginString); } Input[0] = ((float)i) / (PreviewCRDGrid - 1); for (j = 0; j < PreviewCRDGrid; j++) { Input[1] = ((float)j) / (PreviewCRDGrid - 1); for (k = 0; k < PreviewCRDGrid; k++) { Input[2] = ((float)k) / (PreviewCRDGrid - 1); DoHostConversionCRD ((LPHOSTCLUT)lpTargetCRD, NULL, Input, Output, ColorSpace, 1); DoHostConversionCSA ((LPHOSTCLUT)lpTargetCSA, Output, Temp); DoHostConversionCRD ((LPHOSTCLUT)lpDevCRD, (LPHOSTCLUT)lpTargetCSA, Temp, Output, 0, 0); for (l = 0; l < ((LPHOSTCLUT)lpDevCRD)->outputChan; l++) { if (bAllowBinary) { *lpMem++ = (BYTES)(Output[l]*255); } else { lpMem += WriteHex (lpMem, (USHORT)(Output[l]*255)); if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG) { lpLineStart = lpMem; lpMem += WriteObject (lpMem, NewLine); } } } } } if (!bAllowBinary) lpMem += WriteObject (lpMem, EndString); } lpMem += WriteNewLineObject (lpMem, EndArray); lpMem += WriteInt (lpMem, ((LPHOSTCLUT)lpDevCRD)->outputChan); //********** Send Output Table. lpMem += SendCRDOutputTable(lpMem, PublicArrayName, ((LPHOSTCLUT)lpDevCRD)->outputChan, (((LPHOSTCLUT)lpDevCRD)->lutBits == 8)? icSigLut8Type:icSigLut16Type, TRUE, bAllowBinary); lpMem += WriteNewLineObject (lpMem, EndArray); lpMem += WriteObject (lpMem, EndDict); // End dictionary definition lpMem += WriteNewLineObject (lpMem, CRDEnd); Success = TRUE; Done: *lpcbSize = (DWORD)(lpMem - lpOldMem); if (hTargetCRD) MemFree(hTargetCRD); if (hTargetCSA) MemFree(hTargetCSA); if (hDevCRD) MemFree(hDevCRD); return (Success); }

HGLOBAL GetTRCData (  CHANDLE  cp, LPMEMPTR  lpRed, LPMEMPTR  lpGreen, LPMEMPTR  lpBlue, LPSINT  lpnRed, LPSINT  lpnGreen, LPSINT  lpnBlue )

Definition at line 284 of file jan99/dll32/profcrd.c. References FAR, GetCPElement(), GetTRCElementSize(), icSigBlueTRCTag, icSigGreenTRCTag, icSigRedTRCTag, lpcpCurveType, LPMEMPTR, MemAlloc(), MemFree(), NULL, SINT, and ui32toSINT. { SINT RedTRCIndex, GreenTRCIndex, BlueTRCIndex; SINT RedTRCSize = 0, GreenTRCSize = 0, BlueTRCSize = 0; SINT MemSize; HGLOBAL hMem; // Check if we can generate the CRD if (!GetTRCElementSize(cp, icSigRedTRCTag, &RedTRCIndex, &RedTRCSize) || !GetTRCElementSize(cp, icSigGreenTRCTag, &GreenTRCIndex, &GreenTRCSize) || !GetTRCElementSize(cp, icSigBlueTRCTag, &BlueTRCIndex, &BlueTRCSize)) { return 0; } MemSize = RedTRCSize + GreenTRCSize + BlueTRCSize; if (!MemAlloc (MemSize, (HGLOBAL FAR *)&hMem, (LPMEMPTR) lpRed)) return 0; *lpGreen = *lpRed + RedTRCSize; *lpBlue = *lpGreen + GreenTRCSize; if (!GetCPElement (cp, RedTRCIndex, *lpRed, RedTRCSize) || !GetCPElement (cp, GreenTRCIndex, *lpGreen, GreenTRCSize ) || !GetCPElement (cp, BlueTRCIndex, *lpBlue, BlueTRCSize )) { MemFree (hMem); return (NULL); } *lpnRed = ui32toSINT (((lpcpCurveType) *lpRed)->curve.count); *lpnGreen = ui32toSINT (((lpcpCurveType) *lpGreen)->curve.count); *lpnBlue = ui32toSINT (((lpcpCurveType) *lpBlue)->curve.count); return (hMem); }

float inverse_g (  float  f  )  [static]

Definition at line 829 of file jan99/dll32/profcrd.c. { double frc; if (f >= (6.0*6.0*6.0)/(29.0*29.0*29.0)) { frc = pow(f, 1.0 / 3.0); } else { frc = f * (841.0 / 108.0) + (4.0 / 29.0); } return (float)frc; }

void LabToXYZ (  float far *  Input, float far *  Output, float far *  whitePoint )  [static]

Definition at line 1117 of file jan99/dll32/profcrd.c. References g(). { float fL, fa, fb; fL = (Input[0] * 50 + 16) / 116; fa = (Input[1] * 128 - 128) / 500; fb = (Input[2] * 128 - 128) / 200; Output[0] = whitePoint[0] * g(fL + fa); Output[1] = whitePoint[1] * g(fL); Output[2] = whitePoint[2] * g(fL - fb); }

SINT SendCRDABC (  MEMPTR  lpMem, MEMPTR  PublicArrayName, CSIG  pcs, SINT  nInputCh, MEMPTR  Buff, LPSFLOAT  e, CSIG  LutTag, BOOL  bAllowBinary )

Definition at line 1756 of file jan99/dll32/profcrd.c. References BeginArray, BeginFunction, CIEXYZRange, EncodeABCLab1, EncodeABCLab2, EncodeABCTag, EndArray, EndClip, EndFunction, icS15Fixed16Number, icSigLabData, icSigLut8Type, icSigXYZData, IndexArray, IndexArray16b, InputArray, lpcpLut16Type, lpcpLut8Type, MatrixABCLabCRD, MatrixABCTag, MEMPTR, pcs, PreViewInArray, RangeABC, RangeABCTag, Scale16, Scale8, si16f16toSFLOAT, SINT, StartClip, WriteFloat(), WriteInt, WriteNewLineObject(), WriteObject, and WriteObjectN(). { MEMPTR lpOldMem; SINT i, j; double TempMatrixABC[9]; MEMPTR lpTable; MEMPTR lpLineStart; lpOldMem = lpMem; //********** /RangeABC lpMem += WriteNewLineObject (lpMem, RangeABCTag); lpMem += WriteObject (lpMem, RangeABC); //********** /MatrixABC lpMem += WriteNewLineObject (lpMem, MatrixABCTag); if (pcs == icSigXYZData) { lpMem += WriteObject (lpMem, BeginArray); if (e) { for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { lpMem += WriteFloat (lpMem, e[i + j * 3]); } } } else { if (LutTag == icSigLut8Type) { lpTable = (MEMPTR) & ((lpcpLut8Type) Buff)->lut.e00; } else { lpTable = (MEMPTR) & ((lpcpLut16Type) Buff)->lut.e00; } for (i = 0; i < 9; i++) { TempMatrixABC[i] = ((double) si16f16toSFLOAT (lpTable)) / CIEXYZRange; lpTable += sizeof (icS15Fixed16Number); } for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { lpMem += WriteFloat (lpMem, TempMatrixABC[i + j * 3]); } } } lpMem += WriteObject (lpMem, EndArray); } else { lpMem += WriteObject (lpMem, MatrixABCLabCRD); } //********** /EncodeABC if (nInputCh == 0) return (SINT)(lpMem - lpOldMem); lpLineStart = lpMem; lpMem += WriteNewLineObject (lpMem, EncodeABCTag); lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < nInputCh; i++) { lpLineStart = lpMem; lpMem += WriteNewLineObject (lpMem, BeginFunction); if (pcs == icSigLabData) { lpMem += WriteObject (lpMem, (0 == i) ? EncodeABCLab1 : EncodeABCLab2); } lpMem += WriteObject (lpMem, StartClip); if (e) lpMem += WriteObject (lpMem, PreViewInArray); else lpMem += WriteObject (lpMem, InputArray); lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName)); lpMem += WriteInt (lpMem, i); if (!bAllowBinary) // Output ASCII CRD { lpMem += WriteNewLineObject (lpMem, IndexArray); } else { // Output BINARY CRD if (LutTag == icSigLut8Type) { lpMem += WriteObject (lpMem, IndexArray); } else { lpMem += WriteObject (lpMem, IndexArray16b); } } lpMem += WriteObject (lpMem, (LutTag == icSigLut8Type) ? Scale8 : Scale16); lpMem += WriteObject (lpMem, EndClip); lpMem += WriteObject (lpMem, EndFunction); } lpMem += WriteObject (lpMem, EndArray); return (SINT)(lpMem - lpOldMem); }

SINT SendCRDBWPoint (  MEMPTR  lpMem, LPSFLOAT  whitePoint )

Definition at line 1858 of file jan99/dll32/profcrd.c. References BeginArray, BlackPoint, BlackPointTag, EndArray, MEMPTR, SINT, WhitePointTag, WriteFloat(), WriteNewLineObject(), and WriteObject. { MEMPTR lpOldMem; SINT i; lpOldMem = lpMem; //********** /BlackPoint lpMem += WriteNewLineObject (lpMem, BlackPointTag); lpMem += WriteObject (lpMem, BlackPoint); //********** /WhitePoint lpMem += WriteNewLineObject (lpMem, WhitePointTag); lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < 3; i++) { lpMem += WriteFloat (lpMem, (double)(whitePoint[i])); } lpMem += WriteObject (lpMem, EndArray); return (SINT)(lpMem - lpOldMem); }

SINT SendCRDLMN (  MEMPTR  lpMem, CSIG  Intent, LPSFLOAT  whitePoint, LPSFLOAT  mediaWP, CSIG  pcs )

Definition at line 1650 of file jan99/dll32/profcrd.c. References BeginArray, BeginFunction, DivOp, EncodeLMNLab, EncodeLMNTag, EndArray, EndFunction, icAbsoluteColorimetric, icSigXYZData, Intent, MatrixLMNTag, MEMPTR, pcs, RangeLMNLab, RangeLMNTag, SINT, WriteFloat(), WriteNewLineObject(), and WriteObject. { MEMPTR lpOldMem; SINT i, j; lpOldMem = lpMem; //********** /MatrixLMN if (icAbsoluteColorimetric == Intent) { lpMem += WriteNewLineObject (lpMem, MatrixLMNTag); lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) lpMem += WriteFloat (lpMem, (double) (i == j) ? whitePoint[i] / mediaWP[i] : 0.0); } lpMem += WriteObject (lpMem, EndArray); } //********** /RangeLMN lpMem += WriteNewLineObject (lpMem, RangeLMNTag); if (pcs == icSigXYZData) { lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < 3; i++) { lpMem += WriteFloat (lpMem, (double) 0); lpMem += WriteFloat (lpMem, (double) whitePoint[i]); } lpMem += WriteObject (lpMem, EndArray); } else { lpMem += WriteObject (lpMem, RangeLMNLab); } //********** /EncodeLMN lpMem += WriteNewLineObject (lpMem, EncodeLMNTag); lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < 3; i++) { lpMem += WriteObject (lpMem, BeginFunction); if (pcs != icSigXYZData) { lpMem += WriteFloat (lpMem, (double)whitePoint[i]); lpMem += WriteObject (lpMem, DivOp); lpMem += WriteObject (lpMem, EncodeLMNLab); } lpMem += WriteObject (lpMem, EndFunction); } lpMem += WriteObject (lpMem, EndArray); return (SINT)(lpMem - lpOldMem); }

SINT SendCRDOutputTable (  MEMPTR  lpMem, MEMPTR  PublicArrayName, SINT  nOutputCh, CSIG  LutTag, BOOL  bHost, BOOL  bAllowBinary )

Definition at line 1880 of file jan99/dll32/profcrd.c. References BeginFunction, Clip01, EndFunction, icSigLut8Type, IndexArray, IndexArray16b, MEMPTR, NewLine, OutputArray, PreViewOutArray, Scale16, SINT, TFunction8, WriteInt, WriteNewLineObject(), WriteObject, and WriteObjectN(). { MEMPTR lpOldMem; SINT i; lpOldMem = lpMem; for (i = 0; i < nOutputCh; i++) { lpMem += WriteNewLineObject (lpMem, BeginFunction); lpMem += WriteObject (lpMem, Clip01); if (bHost) lpMem += WriteObject (lpMem, PreViewOutArray); else lpMem += WriteObject (lpMem, OutputArray); lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName)); lpMem += WriteInt (lpMem, i); if (!bAllowBinary) // Output ASCII CRD { lpMem += WriteObject (lpMem, NewLine); if (LutTag == icSigLut8Type) { lpMem += WriteObject (lpMem, TFunction8); } else { lpMem += WriteObject (lpMem, IndexArray); lpMem += WriteObject (lpMem, Scale16); } } else { // Output BINARY CRD if (LutTag == icSigLut8Type) { lpMem += WriteObject (lpMem, TFunction8); } else { lpMem += WriteObject (lpMem, IndexArray16b); lpMem += WriteObject (lpMem, Scale16); } } lpMem += WriteObject (lpMem, EndFunction); } return (SINT)(lpMem - lpOldMem); }

SINT SendCRDPQR (  MEMPTR  lpMem, CSIG  Intent, LPSFLOAT  whitePoint )

Definition at line 1708 of file jan99/dll32/profcrd.c. References BeginArray, BeginFunction, EndArray, EndFunction, icAbsoluteColorimetric, Identity, Intent, MatrixPQR, MatrixPQRTag, MEMPTR, NullOp, RangePQR, RangePQRTag, SINT, TransformPQR, TransformPQRTag, WriteFloat(), WriteNewLineObject(), and WriteObject. { MEMPTR lpOldMem; SINT i; lpOldMem = lpMem; if (icAbsoluteColorimetric != Intent) { //********** /RangePQR lpMem += WriteNewLineObject (lpMem, RangePQRTag); lpMem += WriteObject (lpMem, RangePQR); //********** /MatrixPQR lpMem += WriteNewLineObject (lpMem, MatrixPQRTag); lpMem += WriteObject (lpMem, MatrixPQR); } else { //********** /RangePQR lpMem += WriteNewLineObject (lpMem, RangePQRTag); lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < 3; i++) { lpMem += WriteFloat (lpMem, (double) 0); lpMem += WriteFloat (lpMem, (double)(whitePoint[i])); } lpMem += WriteObject (lpMem, EndArray); //********** /MatrixPQR lpMem += WriteNewLineObject (lpMem, MatrixPQRTag); lpMem += WriteObject (lpMem, Identity); } //********** /TransformPQR lpMem += WriteNewLineObject (lpMem, TransformPQRTag); lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < 3; i++) { lpMem += WriteObject (lpMem, BeginFunction); lpMem += WriteObject (lpMem, (icAbsoluteColorimetric != Intent) ? TransformPQR[i] : NullOp); lpMem += WriteObject (lpMem, EndFunction); } lpMem += WriteObject (lpMem, EndArray); return (SINT)(lpMem - lpOldMem); }

BOOL TableInterp3 (  LPHOSTCLUT  lpHostClut, float far *  fTemp )  [static]

Definition at line 846 of file jan99/dll32/profcrd.c. References c, MAXCOLOR8, MEMPTR, and TRUE. { int tmpA, tmpBC; int cellA, cellB, cellC; float a, b, c; short Grids; short outputChan; MEMPTR v000, v001, v010, v011; MEMPTR v100, v101, v110, v111; float vx0x, vx1x; float v0xx, v1xx; int idx; cellA = (int)(fTemp[0]); a = fTemp[0] - cellA; cellB = (int)(fTemp[1]); b = fTemp[1] - cellB; cellC = (int)(fTemp[2]); c = fTemp[2] - cellC; Grids = lpHostClut->clutPoints; outputChan = lpHostClut->outputChan; tmpA = outputChan * Grids * Grids; tmpBC = outputChan * (Grids * cellB + cellC); // Calculate 8 surrounding cells. v000 = lpHostClut->clut + tmpA * cellA + tmpBC; v001 = (cellC < (Grids - 1))? v000 + outputChan : v000; v010 = (cellB < (Grids - 1))? v000 + outputChan * Grids : v000; v011 = (cellC < (Grids - 1))? v010 + outputChan : v010 ; v100 = (cellA < (Grids - 1))? v000 + tmpA : v000; v101 = (cellC < (Grids - 1))? v100 + outputChan : v100; v110 = (cellB < (Grids - 1))? v100 + outputChan * Grids : v100; v111 = (cellC < (Grids - 1))? v110 + outputChan : v110; for (idx = 0; idx < outputChan; idx++) { // Calculate the average of 4 bottom cells. vx0x = *v000 + c * (int)((int)*v001 - (int)*v000); vx1x = *v010 + c * (int)((int)*v011 - (int)*v010); v0xx = vx0x + b * (vx1x - vx0x); // Calculate the average of 4 upper cells. vx0x = *v100 + c * (int)((int)*v101 - (int)*v100); vx1x = *v110 + c * (int)((int)*v111 - (int)*v110); v1xx = vx0x + b * (vx1x - vx0x); // Calculate the bottom and upper average. fTemp[idx] = (v0xx + a * (v1xx - v0xx)) / MAXCOLOR8; if ( idx < (outputChan - 1)) { v000++; v001++; v010++; v011++; v100++; v101++; v110++; v111++; } } return TRUE; }

BOOL TableInterp4 (  LPHOSTCLUT  lpHostClut, float far *  fTemp )  [static]

Definition at line 916 of file jan99/dll32/profcrd.c. References MAXCOLOR8, MEMPTR, and TRUE. { int tmpH, tmpI, tmpJK; int cellH, cellI, cellJ, cellK; float h, i, j, k; short Grids; short outputChan; MEMPTR v0000, v0001, v0010, v0011; MEMPTR v0100, v0101, v0110, v0111; MEMPTR v1000, v1001, v1010, v1011; MEMPTR v1100, v1101, v1110, v1111; float vxx0x, vxx1x; float vx0xx, vx1xx; float v0xxx, v1xxx; int idx; cellH = (int)(fTemp[0]); h = fTemp[0] - cellH; cellI = (int)(fTemp[1]); i = fTemp[1] - cellI; cellJ = (int)(fTemp[2]); j = fTemp[2] - cellJ; cellK = (int)(fTemp[3]); k = fTemp[3] - cellK; Grids = lpHostClut->clutPoints; outputChan = lpHostClut->outputChan; tmpI = outputChan * Grids * Grids; tmpH = tmpI * Grids; tmpJK = outputChan * (Grids * cellJ + cellK); // Calculate 16 surrounding cells. v0000 = lpHostClut->clut + tmpH * cellH + tmpI * cellI + tmpJK; v0001 = (cellK < (Grids - 1))? v0000 + outputChan : v0000; v0010 = (cellJ < (Grids - 1))? v0000 + outputChan * Grids : v0000; v0011 = (cellK < (Grids - 1))? v0010 + outputChan : v0010; v0100 = (cellI < (Grids - 1))? v0000 + tmpI : v0000; v0101 = (cellK < (Grids - 1))? v0100 + outputChan : v0100; v0110 = (cellJ < (Grids - 1))? v0100 + outputChan * Grids : v0100; v0111 = (cellK < (Grids - 1))? v0110 + outputChan : v0110; v1000 = (cellH < (Grids - 1))? v0000 + tmpH : v0000; v1001 = (cellK < (Grids - 1))? v1000 + outputChan : v1000; v1010 = (cellJ < (Grids - 1))? v1000 + outputChan * Grids : v1000; v1011 = (cellK < (Grids - 1))? v1010 + outputChan : v1010; v1100 = (cellI < (Grids - 1))? v1000 + tmpI : v1000; v1101 = (cellK < (Grids - 1))? v1100 + outputChan : v1100; v1110 = (cellJ < (Grids - 1))? v1100 + outputChan * Grids : v1100; v1111 = (cellK < (Grids - 1))? v1110 + outputChan : v1110; for (idx = 0; idx < outputChan; idx++) { // Calculate the average of 8 bottom cells. vxx0x = *v0000 + k * (int)((int)*v0001 - (int)*v0000); vxx1x = *v0010 + k * (int)((int)*v0011 - (int)*v0010); vx0xx = vxx0x + j * (vxx1x - vxx0x); vxx0x = *v0100 + k * (int)((int)*v0101 - (int)*v0100); vxx1x = *v0110 + k * (int)((int)*v0111 - (int)*v0110); vx1xx = vxx0x + j * (vxx1x - vxx0x); v0xxx = vx0xx + i * (vx1xx - vx0xx); // Calculate the average of 8 upper cells. vxx0x = *v1000 + k * (int)((int)*v1001 - (int)*v1000); vxx1x = *v1010 + k * (int)((int)*v1011 - (int)*v1010); vx0xx = vxx0x + j * (vxx1x - vxx0x); vxx0x = *v1100 + k * (int)((int)*v1101 - (int)*v1100); vxx1x = *v1110 + k * (int)((int)*v1111 - (int)*v1110); vx1xx = vxx0x + j * (vxx1x - vxx0x); v1xxx = vx0xx + i * (vx1xx - vx0xx); // Calculate the bottom and upper average. fTemp[idx] = (v0xxx + h * (v1xxx - v0xxx)) / MAXCOLOR8; if ( idx < (outputChan - 1)) { v0000++; v0001++; v0010++; v0011++; v0100++; v0101++; v0110++; v0111++; v1000++; v1001++; v1010++; v1011++; v1100++; v1101++; v1110++; v1111++; } } return TRUE; }

void XYZToLab (  float far *  Input, float far *  Output, float far *  whitePoint )  [static]

Definition at line 1130 of file jan99/dll32/profcrd.c. References inverse_g(). { float fL, fa, fb; fL = inverse_g(Input[0] / whitePoint[0]); fa = inverse_g(Input[1] / whitePoint[1]); fb = inverse_g(Input[2] / whitePoint[2]); Output[0] = (fa * 116 - 16) / 100; Output[1] = (fL * 500 - fa * 500 + 128) / 255; Output[2] = (fa * 200 - fb * 200 + 128) / 255; }

---