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	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)
BOOL	GetHostCSA_Intent (CHANDLE cp, MEMPTR lpBuffer, LPDWORD lpcbSize, CSIG Intent, int Type)
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)
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 dec97/dll32/profcrd.c.

---

Function Documentation

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

Definition at line 846 of file dec97/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 870 of file dec97/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 50 of file dec97/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 402 of file dec97/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 CreateInputArray (  MEMPTR  lpMem, SINT  nInputCh, SINT  nInputTable, MEMPTR  Intent, CSIG  Tag, MEMPTR  Buff, BOOL  bAllowBinary, MEMPTR  lpHostClut )

Definition at line 1322 of file dec97/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(), 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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 1210 of file dec97/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(), 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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 969 of file dec97/dll32/profcrd.c. References CheckColorLookupTable(), CheckInputOutputTable(), icSigLabData, icSigXYZData, LabToXYZ(), MAXCHANNELS, TRUE, and XYZToLab(). { float fTemp[MAXCHANNELS]; float fTemp1[MAXCHANNELS]; int i, j; // 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 { for (i = 0; i < 3; i++) fTemp1[i] = Input[i] * lpHostCRD->whitePoint[i] / lpHostCSA->whitePoint[i]; } // Matrix, used for XYZ data only. if (lpHostCRD->pcs == icSigXYZData) { for (i = 0; i < 3; i++) { j = i*3; fTemp[i] = lpHostCRD->e[j ] * fTemp1[0] + lpHostCRD->e[j + 1] * fTemp1[1] + lpHostCRD->e[j + 2] * fTemp1[2]; } } //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. for (i = 0; i < 3; i++) { fTemp[i] = Input[i]* (Grids - 1); if (fTemp[i] > (Grids - 1)) fTemp[i] = (float)(Grids - 1); } } // bCheckInputTable // 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 1075 of file dec97/dll32/profcrd.c. References CheckColorLookupTable(), CheckInputOutputTable(), MAXCHANNELS, and TRUE. { float fTemp[MAXCHANNELS]; int i; for (i = 0; (i <= MAXCHANNELS) && (i < lpHostClut->inputChan); i++) { fTemp[i] = Input[i]; } //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 620 of file dec97/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 96 of file dec97/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 1107 of file dec97/dll32/profcrd.c. References CSIG, DoesCPTagExist(), FALSE, FAR, GetCLUTinfo(), GetCPElement(), GetCPElementSize(), GetCPElementType(), GetCPTagIndex(), icAbsoluteColorimetric, icPerceptual, icRelativeColorimetric, icSaturation, icSigBToA0Tag, icSigBToA1Tag, icSigBToA2Tag, icSigLut16Type, icSigLut8Type, Index, Intent, LPCSIG, LPMEMPTR, LPSINT, MemAlloc(), MemFree(), MEMPTR, NULL, SINT, and TRUE. { 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)) { if (NULL != Buff) { MemFree (hMem); } return FALSE; } 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 559 of file dec97/dll32/profcrd.c. References CreateHostLutCRD(), CSIG, DoesCPTagExist(), DWORD, FALSE, GetCPTagIndex(), icAbsoluteColorimetric, icPerceptual, icRelativeColorimetric, icSaturation, icSigBToA0Tag, icSigBToA1Tag, icSigBToA2Tag, Index, Intent, LPSINT, NULL, and SINT. { SINT Index; SINT Ret; CSIG BToAxTag; if (!cp) return FALSE; if ((lpMem == NULL) || (*lpcbSize == 0)) { lpMem = NULL; *lpcbSize = 0; } Ret = 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) Ret; return FALSE; } if (DoesCPTagExist (cp, BToAxTag) && GetCPTagIndex (cp, BToAxTag, (LPSINT) & Index)) { Ret = CreateHostLutCRD (cp, Index, lpMem, Intent); } *lpcbSize = (DWORD) Ret; return (Ret > 0); }

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

Definition at line 347 of file dec97/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 135 of file dec97/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. References BOOL, CSIG, DoesCPTagExist(), FALSE, GetCPTagIndex(), GetHostCSA(), icAbsoluteColorimetric, icPerceptual, icRelativeColorimetric, icSaturation, icSigAToB0Tag, icSigAToB1Tag, icSigAToB2Tag, Index, Intent, LPSINT, and SINT. Referenced by GetCRDInputOutputArraySize(), and GetHostColorSpaceArray(). { 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 EXTERN GetPS2PreviewColorRenderingDictionary (  CHANDLE  cpDev, CHANDLE  cpTarget, DWORD  Intent, MEMPTR  lpMem, LPDWORD  lpcbSize, BOOL  bAllowBinary )

Definition at line 1715 of file dec97/dll32/profcrd.c. References BeginArray, BeginDict, BeginString, BOOL, BYTES, CRDBegin, CRDEnd, CreateInputArray(), CreateOutputArray(), CSIG, DictType, DoHostConversionCRD(), DoHostConversionCSA(), DWORD, EnableGlobalDict(), EndArray, EndDict, EndOp, EndString, FALSE, FAR, GetCPDevSpace, GetCRDInputOutputArraySize(), GetHostColorRenderingDictionary(), GetHostColorSpaceArray(), GetPublicArrayName(), icSigCmykData, Intent, LPCSIG, LPHOSTCLUT, LPMEMPTR, MAX_LINELENG, MAXCHANNELS, MemAlloc(), MemFree(), MEMPTR, NewLine, NULL, pcs, PREVIEWCRDGRID, RenderTableTag, SendCRDABC(), SendCRDBWPoint(), SendCRDLMN(), SendCRDOutputTable(), SendCRDPQR(), SetGlobalOp, SINT, TempBfSize, TRUE, USHORT, WriteHex, WriteInt, 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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, CRDBegin); lpMem += EnableGlobalDict(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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, SetGlobalOp); lpMem += WriteObject (lpMem, EndOp); //************* Start writing CRD **************************** lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, BeginDict); // Begin dictionary lpMem += WriteObject (lpMem, DictType); // Dictionary type //********** 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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, EndArray); lpMem += WriteObject (lpMem, EndDict); // End dictionary definition lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, CRDEnd); Success = TRUE; Done: *lpcbSize = (DWORD)(lpMem - lpOldMem); if (hTargetCRD) MemFree(hTargetCRD); if (hTargetCSA) MemFree(hTargetCSA); if (hDevCRD) MemFree(hDevCRD); return (Success); }

float inverse_g (  float  f  )  [static]

Definition at line 643 of file dec97/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 931 of file dec97/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 1511 of file dec97/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, NewLine, pcs, PreViewInArray, RangeABC, RangeABCTag, Scale16, Scale8, si16f16toSFLOAT, SINT, StartClip, WriteFloat(), WriteInt, WriteObject, and WriteObjectN(). { MEMPTR lpOldMem; SINT i, j; double TempMatrixABC[9]; MEMPTR lpTable; MEMPTR lpLineStart; lpOldMem = lpMem; //********** /RangeABC lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, RangeABCTag); lpMem += WriteObject (lpMem, RangeABC); //********** /MatrixABC lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 lpLineStart = lpMem; lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, EncodeABCTag); lpMem += WriteObject (lpMem, BeginArray); for (i = 0; i < nInputCh; i++) { lpLineStart = lpMem; lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 1616 of file dec97/dll32/profcrd.c. References BeginArray, BlackPoint, BlackPointTag, EndArray, MEMPTR, NewLine, SINT, WhitePointTag, WriteFloat(), and WriteObject. { MEMPTR lpOldMem; SINT i; lpOldMem = lpMem; //********** /BlackPoint lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, BlackPointTag); lpMem += WriteObject (lpMem, BlackPoint); //********** /WhitePoint lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 1410 of file dec97/dll32/profcrd.c. References BeginArray, BeginFunction, DivOp, EncodeLMNLab, EncodeLMNTag, EndArray, EndFunction, icAbsoluteColorimetric, icSigXYZData, Intent, MatrixLMNTag, MEMPTR, NewLine, pcs, RangeLMNLab, RangeLMNTag, SINT, WriteFloat(), and WriteObject. { MEMPTR lpOldMem; SINT i, j; lpOldMem = lpMem; //********** /MatrixLMN if (icAbsoluteColorimetric == Intent) { lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 1640 of file dec97/dll32/profcrd.c. References BeginFunction, Clip01, EndFunction, icSigLut8Type, IndexArray, IndexArray16b, MEMPTR, NewLine, OutputArray, PreViewOutArray, Scale16, SINT, TFunction8, WriteInt, WriteObject, and WriteObjectN(). { MEMPTR lpOldMem; SINT i; lpOldMem = lpMem; for (i = 0; i < nOutputCh; i++) { lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 1471 of file dec97/dll32/profcrd.c. References BeginArray, BeginFunction, EndArray, EndFunction, icAbsoluteColorimetric, Identity, Intent, MatrixPQRTag, MEMPTR, NewLine, NullOp, RangePQRTag, SINT, TransformPQR, TransformPQRTag, WriteFloat(), and WriteObject. { MEMPTR lpOldMem; SINT i; lpOldMem = lpMem; //********** /RangePQR lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 += WriteObject (lpMem, NewLine); lpMem += WriteObject (lpMem, MatrixPQRTag); lpMem += WriteObject (lpMem, Identity); //********** /TransformPQR lpMem += WriteObject (lpMem, NewLine); lpMem += WriteObject (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 660 of file dec97/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 730 of file dec97/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 944 of file dec97/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; }

---