1747 lines
58 KiB
C
1747 lines
58 KiB
C
#include "generic.h"
|
|
#include "icmstr.h"
|
|
|
|
#pragma code_seg(_ICMSEG)
|
|
|
|
static char *DecodeABCLab[] = {"50 mul 16 add 116 div ",
|
|
"128 mul 128 sub 500 div",
|
|
"128 mul 128 sub 200 div"};
|
|
|
|
#pragma optimize("",off)
|
|
|
|
BOOL IsSRGB( CHANDLE cp );
|
|
|
|
|
|
|
|
SINT CreateColSpArray (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary);
|
|
SINT CreateColSpProc (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary);
|
|
SINT CreateFloatString (CHANDLE cp, MEMPTR lpMem, CSIG CPTag);
|
|
static SINT SendCSABWPoint(MEMPTR lpMem, CSIG Intent,
|
|
LPSFLOAT IlluminantWP, LPSFLOAT MediaWP);
|
|
static void GetMediaWP(CHANDLE cp, CSIG InputIntent,
|
|
LPSFLOAT IlluminantWP, LPSFLOAT MediaWP);
|
|
|
|
/*
|
|
* GetDevideRGB
|
|
* function:
|
|
* this is the function which creates the DeviceRGB ColorSpace (CS)
|
|
* prototype:
|
|
* BOOL EXTERN GetDeviceRGB(
|
|
* MEMPTR lpMem,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* lpMem -- Pointer to the memory block
|
|
* AllowBinary -- 1: binary CS allowed, 0: only ascii CS allowed.
|
|
* returns:
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
static BOOL
|
|
GetDeviceRGB (
|
|
MEMPTR lpMem,
|
|
LPDWORD lpcbSize,
|
|
DWORD InpDrvClrSp,
|
|
BOOL BackupCSA)
|
|
{
|
|
MEMPTR lpOldMem = lpMem;
|
|
if ((InpDrvClrSp != icSigRgbData) &&
|
|
(InpDrvClrSp != icSigDefData) &&
|
|
(InpDrvClrSp != 0))
|
|
return FALSE;
|
|
|
|
if (lpMem == NULL)
|
|
{
|
|
*lpcbSize = lstrlen (DeviceRGBTag) + 8;
|
|
return (TRUE);
|
|
}
|
|
|
|
if (BackupCSA)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, NotSupportDEFG_S);
|
|
}
|
|
|
|
lpMem += WriteNewLineObject (lpMem, DeviceRGBTag);
|
|
|
|
if (BackupCSA)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
|
|
}
|
|
|
|
*lpcbSize = (DWORD) (lpMem - lpOldMem);
|
|
return (TRUE);
|
|
}
|
|
/*
|
|
* GetDevideCMYK
|
|
* function:
|
|
* this is the function which creates the DeviceCMYK ColorSpace (CS)
|
|
* prototype:
|
|
* BOOL EXTERN GetDeviceCMYK(
|
|
* MEMPTR lpMem,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* lpMem -- Pointer to the memory block
|
|
* AllowBinary -- 1: binary CS allowed, 0: only ascii CS allowed.
|
|
* returns:
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
|
|
static BOOL
|
|
GetDeviceCMYK (
|
|
MEMPTR lpMem,
|
|
LPDWORD lpcbSize,
|
|
DWORD InpDrvClrSp)
|
|
{
|
|
MEMPTR lpOldMem = lpMem;
|
|
if ((InpDrvClrSp != icSigCmykData) &&
|
|
(InpDrvClrSp != 0))
|
|
return FALSE;
|
|
if (lpMem == NULL)
|
|
{
|
|
*lpcbSize = lstrlen (DeviceCMYKTag) + 8;
|
|
return (TRUE);
|
|
}
|
|
lpMem += WriteNewLineObject (lpMem, DeviceCMYKTag);
|
|
|
|
*lpcbSize = (DWORD) (lpMem - lpOldMem);
|
|
return (TRUE);
|
|
|
|
}
|
|
/*
|
|
* GetDeviceGray
|
|
*/
|
|
|
|
static BOOL
|
|
GetDeviceGray (
|
|
MEMPTR lpMem,
|
|
LPDWORD lpcbSize,
|
|
DWORD InpDrvClrSp)
|
|
{
|
|
MEMPTR lpOldMem = lpMem;
|
|
if ((InpDrvClrSp == icSigRgbData) ||
|
|
(InpDrvClrSp == icSigDefData) ||
|
|
(InpDrvClrSp == 0))
|
|
{
|
|
if (lpMem == NULL)
|
|
{
|
|
*lpcbSize = lstrlen (DeviceRGBTag) + 8;
|
|
return (TRUE);
|
|
}
|
|
lpMem += WriteNewLineObject (lpMem, DeviceRGBTag);
|
|
|
|
*lpcbSize = (DWORD) (lpMem - lpOldMem);
|
|
return (TRUE);
|
|
} else if (InpDrvClrSp == icSigGrayData)
|
|
{
|
|
if (lpMem == NULL)
|
|
{
|
|
*lpcbSize = lstrlen (DeviceGrayTag) + 8;
|
|
return (TRUE);
|
|
}
|
|
lpMem += WriteNewLineObject (lpMem, DeviceGrayTag);
|
|
|
|
*lpcbSize = (DWORD) (lpMem - lpOldMem);
|
|
return (TRUE);
|
|
}
|
|
}
|
|
/*
|
|
* GetPublicArrayName
|
|
*/
|
|
|
|
SINT
|
|
GetPublicArrayName (CHANDLE cp, CSIG IntentSig, MEMPTR PublicArrayName)
|
|
{
|
|
MEMPTR OldPtr;
|
|
OldPtr = PublicArrayName;
|
|
PublicArrayName[0] = 0;
|
|
MemCopy (PublicArrayName, (MEMPTR) & IntentSig, sizeof (CSIG));
|
|
PublicArrayName += sizeof (CSIG);
|
|
PublicArrayName[0] = 0;
|
|
return (PublicArrayName - OldPtr);
|
|
}
|
|
|
|
static SINT SendCSABWPoint(MEMPTR lpMem, CSIG Intent,
|
|
LPSFLOAT IlluminantWP, LPSFLOAT MediaWP)
|
|
{
|
|
SINT i;
|
|
MEMPTR 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++)
|
|
{
|
|
if (Intent == icAbsoluteColorimetric)
|
|
{
|
|
lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
|
|
}
|
|
else
|
|
{
|
|
lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
|
|
}
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
return (SINT)(lpMem - lpOldMem);
|
|
}
|
|
|
|
static void GetMediaWP(CHANDLE cp, CSIG InputIntent,
|
|
LPSFLOAT IlluminantWP, LPSFLOAT MediaWP)
|
|
{
|
|
if (InputIntent == icAbsoluteColorimetric)
|
|
{
|
|
if (!GetCPMediaWhitePoint (cp, (LPSFLOAT) & MediaWP)) // .. Media WhitePoint
|
|
{
|
|
MediaWP[0] = IlluminantWP[0];
|
|
MediaWP[1] = IlluminantWP[1];
|
|
MediaWP[2] = IlluminantWP[2];
|
|
}
|
|
}
|
|
}
|
|
|
|
SINT BeginGlobalDict(MEMPTR lpMem)
|
|
{
|
|
MEMPTR lpOldMem = lpMem;
|
|
|
|
lpMem += WriteNewLineObject (lpMem, GlobalDictOp);
|
|
lpMem += WriteObject (lpMem, BeginOp);
|
|
|
|
return (lpMem - lpOldMem);
|
|
}
|
|
|
|
SINT EndGlobalDict(MEMPTR lpMem)
|
|
{
|
|
MEMPTR lpOldMem = lpMem;
|
|
|
|
lpMem += WriteNewLineObject (lpMem, EndOp);
|
|
lpMem += WriteObject (lpMem, SetGlobalOp);
|
|
|
|
return (lpMem - lpOldMem);
|
|
}
|
|
|
|
SINT EnableGlobalDict(MEMPTR lpMem)
|
|
{
|
|
MEMPTR lpOldMem = lpMem;
|
|
|
|
lpMem += WriteNewLineObject (lpMem, CurrentGlobalOp);
|
|
lpMem += WriteObject (lpMem, TrueOp);
|
|
lpMem += WriteObject (lpMem, SetGlobalOp);
|
|
return (lpMem - lpOldMem);
|
|
}
|
|
|
|
/*
|
|
* GetPS2CSA_DEFG
|
|
* function:
|
|
* this is the function which creates the CIEBasedDEF(G) ColorSpace (CS)
|
|
* from the data supplied in the RGB or CMYK Input Profile.
|
|
* prototype:
|
|
* GetPS2CSA_DEFG(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpMem,
|
|
* LPDWORD lpcbSize,
|
|
* int Type
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpMem -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* Type -- CieBasedDEF or CieBasedDEFG.
|
|
* AllowBinary -- 1: binary CSA allowed, 0: only ascii CSA allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
static BOOL
|
|
GetPS2CSA_DEFG (
|
|
CHANDLE cp,
|
|
MEMPTR lpMem,
|
|
LPDWORD lpcbSize,
|
|
CSIG InputIntent,
|
|
SINT Index,
|
|
int Type,
|
|
BOOL AllowBinary)
|
|
{
|
|
CSIG PCS, LutTag;
|
|
CSIG IntentSig;
|
|
SFLOAT IlluminantWP[3];
|
|
SFLOAT MediaWP[3];
|
|
SINT nInputCh, nOutputCh, nGrids, SecondGrids;
|
|
SINT nInputTable, nOutputTable, nNumbers;
|
|
SINT i, j, k;
|
|
MEMPTR lpTable;
|
|
MEMPTR lpOldMem = lpMem;
|
|
MEMPTR lpLut = NULL;
|
|
MEMPTR lpLineStart;
|
|
HGLOBAL hLut = 0;
|
|
SINT LutSize;
|
|
char PublicArrayName[TempBfSize];
|
|
// Check if we can generate the CS.
|
|
// Required tags are: red, green and blue Colorants.
|
|
// As for TRC tags - we are quite flexible here - if we cannot find the
|
|
// required tag - we assume the linear responce
|
|
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);
|
|
|
|
// Level 2 printers support only tri-component CIEBasedABC input,
|
|
// but can have either 3 or 4 output channels.
|
|
if (!(nOutputCh == 3) ||
|
|
!((nInputCh == 3) && (Type == TYPE_CIEBASEDDEF)) &&
|
|
!((nInputCh == 4) && (Type == TYPE_CIEBASEDDEFG)))
|
|
{
|
|
SetCPLastError (CP_POSTSCRIPT_ERR);
|
|
MemFree (hLut);
|
|
return (FALSE);
|
|
}
|
|
if (lpMem == NULL) // This is a size request
|
|
{
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
*lpcbSize = nOutputCh * nGrids * nGrids * nGrids * nGrids * 2; // LUT HEX bytes
|
|
else
|
|
*lpcbSize = nOutputCh * nGrids * nGrids * nGrids * 2; // LUT HEX bytes
|
|
|
|
*lpcbSize = *lpcbSize +
|
|
nInputCh * nInputTable * 6 +
|
|
nOutputCh * nOutputTable * 6 + // Number of INT bytes
|
|
nInputCh * (lstrlen (IndexArray) +
|
|
lstrlen (StartClip) +
|
|
lstrlen (EndClip)) +
|
|
nOutputCh * (lstrlen (IndexArray) +
|
|
lstrlen (StartClip) +
|
|
lstrlen (EndClip)) +
|
|
4096; // + other PS stuff
|
|
|
|
|
|
return (TRUE);
|
|
}
|
|
// Get info about Illuminant White Point from the header
|
|
GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP); // .. Illuminant
|
|
|
|
// Support absolute whitePoint
|
|
GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//*********** Testing CieBasedDEFG support
|
|
lpMem += WriteNewLineObject (lpMem, TestingDEFG);
|
|
|
|
//*********** Creating global data
|
|
GetPublicArrayName (cp, IntentSig, PublicArrayName);
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedDEFGBegin);
|
|
else
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedDEFBegin);
|
|
|
|
lpMem += EnableGlobalDict(lpMem);
|
|
lpMem += WriteNewLineObject (lpMem, SupportDEFG_S);
|
|
lpMem += BeginGlobalDict(lpMem);
|
|
|
|
lpMem += CreateInputArray (lpMem, nInputCh, nInputTable,
|
|
(MEMPTR) PublicArrayName, LutTag, lpLut, AllowBinary, NULL);
|
|
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
{
|
|
i = nInputTable * nInputCh +
|
|
nGrids * nGrids * nGrids * nGrids * nOutputCh;
|
|
} else
|
|
{
|
|
i = nInputTable * nInputCh +
|
|
nGrids * nGrids * nGrids * nOutputCh;
|
|
}
|
|
lpMem += CreateOutputArray (lpMem, nOutputCh, nOutputTable, i,
|
|
(MEMPTR) PublicArrayName, LutTag, lpLut, AllowBinary, NULL);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, EndOp);
|
|
lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
|
|
lpMem += WriteNewLineObject (lpMem, SetGlobalOp);
|
|
lpMem += WriteNewLineObject (lpMem, SupportDEFG_S);
|
|
|
|
//*********** Start creating the ColorSpace
|
|
lpMem += WriteNewLineObject (lpMem, BeginArray); // Begin array
|
|
|
|
//********** /CIEBasedDEF(G)
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
lpMem += WriteObject (lpMem, CIEBasedDEFGTag);
|
|
else
|
|
lpMem += WriteObject (lpMem, CIEBasedDEFTag);
|
|
lpMem += WriteObject (lpMem, BeginDict); // Begin dictionary
|
|
|
|
//********** Black/White Point
|
|
lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//********** /DecodeDEF(G)
|
|
lpLineStart = lpMem;
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
lpMem += WriteNewLineObject (lpMem, DecodeDEFGTag);
|
|
else
|
|
lpMem += WriteNewLineObject (lpMem, DecodeDEFTag);
|
|
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < nInputCh; i++)
|
|
{
|
|
lpLineStart = lpMem;
|
|
|
|
lpMem += WriteNewLineObject (lpMem, BeginFunction);
|
|
#if 0
|
|
if (PCS == icSigLabData)
|
|
{
|
|
lpMem += WriteObject (lpMem,
|
|
(0 == i) ? EncodeABCLab1 : EncodeABCLab2);
|
|
}
|
|
#endif
|
|
lpMem += WriteObject (lpMem, StartClip);
|
|
lpMem += WriteObject (lpMem, InputArray);
|
|
lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName));
|
|
lpMem += WriteInt (lpMem, i);
|
|
|
|
if (!AllowBinary) // Output ASCII
|
|
{
|
|
lpMem += WriteObject (lpMem, IndexArray);
|
|
} else
|
|
{ // Output BINARY
|
|
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);
|
|
|
|
//********** /Table
|
|
lpMem += WriteNewLineObject (lpMem, TableTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
|
|
lpMem += WriteInt (lpMem, nGrids); // Send down Nh
|
|
lpMem += WriteInt (lpMem, nGrids); // Send down Ni
|
|
lpMem += WriteInt (lpMem, nGrids); // Send down Nj
|
|
nNumbers = nGrids * nGrids * nOutputCh;
|
|
SecondGrids = 1;
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
{
|
|
lpMem += WriteInt (lpMem, nGrids); // Send down Nk
|
|
// nNumbers = nGrids * nGrids * nGrids * nOutputCh ;
|
|
SecondGrids = nGrids;
|
|
}
|
|
lpMem += WriteNewLineObject (lpMem, BeginArray);
|
|
for (i = 0; i < nGrids; i++) // Nh strings should be sent
|
|
{
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, BeginArray);
|
|
}
|
|
for (k = 0; k < SecondGrids; k++)
|
|
{
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
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 (!AllowBinary) // Output ASCII
|
|
{
|
|
lpMem += WriteObject (lpMem, BeginString);
|
|
if (LutTag == icSigLut8Type)
|
|
lpMem += WriteHexBuffer (lpMem, lpTable, lpLineStart, nNumbers);
|
|
else
|
|
{
|
|
for (j = 0; j < nNumbers; j++)
|
|
{
|
|
lpMem += WriteHex (lpMem, ui16toSINT (lpTable) / 256);
|
|
lpTable += sizeof (icUInt16Number);
|
|
if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
|
|
{
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
}
|
|
}
|
|
}
|
|
lpMem += WriteObject (lpMem, EndString);
|
|
} else
|
|
{ // Output BINARY
|
|
lpMem += WriteStringToken (lpMem, 143, nNumbers);
|
|
if (LutTag == icSigLut8Type)
|
|
lpMem += WriteByteString (lpMem, lpTable, nNumbers);
|
|
else
|
|
lpMem += WriteInt2ByteString (lpMem, lpTable, nNumbers);
|
|
}
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
}
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
{
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
}
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
lpMem += WriteObject (lpMem, EndArray); // End array
|
|
|
|
//********** /DecodeABC
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteNewLineObject (lpMem, DecodeABCTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < nOutputCh; i++)
|
|
{
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteNewLineObject (lpMem, BeginFunction);
|
|
lpMem += WriteObject (lpMem, Clip01);
|
|
lpMem += WriteObject (lpMem, OutputArray);
|
|
lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName));
|
|
lpMem += WriteInt (lpMem, i);
|
|
|
|
if (!AllowBinary) // Output ASCII CRD
|
|
{
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
|
|
if (LutTag == icSigLut8Type)
|
|
{
|
|
lpMem += WriteObject (lpMem, TFunction8XYZ);
|
|
} else
|
|
{
|
|
lpMem += WriteObject (lpMem, IndexArray);
|
|
lpMem += WriteObject (lpMem, Scale16XYZ);
|
|
}
|
|
} else
|
|
{ // Output BINARY CRD
|
|
if (LutTag == icSigLut8Type)
|
|
{
|
|
lpMem += WriteObject (lpMem, TFunction8XYZ);
|
|
} else
|
|
{
|
|
lpMem += WriteObject (lpMem, IndexArray16b);
|
|
lpMem += WriteObject (lpMem, Scale16XYZ);
|
|
}
|
|
}
|
|
|
|
// Now, We get CieBasedXYZ output. Output range 0 --> 1.99997
|
|
// If the connection space is absolute XYZ, We need to convert
|
|
// from relative XYZ to absolute XYZ.
|
|
if ((PCS == icSigXYZData) &&
|
|
(InputIntent == icAbsoluteColorimetric))
|
|
{
|
|
lpMem += WriteFloat (lpMem, (double)MediaWP[i]/IlluminantWP[i]);
|
|
lpMem += WriteObject (lpMem, MulOp);
|
|
}
|
|
// If the connection space is Lab, We need to convert XYZ to Lab.
|
|
else if (PCS == icSigLabData)
|
|
lpMem += WriteObject (lpMem, DecodeABCLab[i]);
|
|
lpMem += WriteObject (lpMem, EndFunction);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
if (PCS == icSigLabData)
|
|
{
|
|
//********** /MatrixABC
|
|
lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
|
|
lpMem += WriteObject (lpMem, MatrixABCLab);
|
|
|
|
//********** /DecodeLMN
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteNewLineObject (lpMem, DecodeLMNTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteNewLineObject (lpMem, BeginFunction);
|
|
lpMem += WriteObject (lpMem, DecodeLMNLab);
|
|
if (InputIntent == icAbsoluteColorimetric)
|
|
lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
|
|
else
|
|
lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
|
|
lpMem += WriteObject (lpMem, MulOp);
|
|
lpMem += WriteObject (lpMem, EndFunction);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
} else
|
|
{
|
|
//********** /RangeLMN
|
|
lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
|
|
lpMem += WriteObject (lpMem, RangeLMN);
|
|
}
|
|
|
|
//********** End dictionary definition
|
|
lpMem += WriteNewLineObject (lpMem, EndDict);
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
if (Type == TYPE_CIEBASEDDEFG)
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedDEFGEnd);
|
|
else
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedDEFEnd);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
|
|
|
|
*lpcbSize = (DWORD) (lpMem - lpOldMem);
|
|
|
|
MemFree (hLut);
|
|
return (TRUE);
|
|
}
|
|
|
|
/*
|
|
* GetPS2CSA_ABC
|
|
* function:
|
|
* this is the function which creates the CIEBasedABC ColorSpace (CS)
|
|
* from the data supplied in the RGB Input Profile.
|
|
* prototype:
|
|
* GetPS2CSA_ABC(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpMem,
|
|
* LPDWORD lpcbSize,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpMem -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* InputIntent --
|
|
* InpDrvClrSp --
|
|
* AllowBinary -- 1: binary CSA allowed, 0: only ascii CSA allowed.
|
|
* BackupCSA -- 1: A CIEBasedDEF has been created, this CSA is a backup
|
|
* in case some old printer can not support CIEBasedDEF.
|
|
* 0: No CIEBasedDEF. This is the only CSA.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
|
|
BOOL
|
|
GetPS2CSA_ABC (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
|
|
CSIG InputIntent, DWORD InpDrvClrSp,
|
|
BOOL AllowBinary, BOOL BackupCSA)
|
|
{
|
|
CSIG PCS, Dev;
|
|
SFLOAT IlluminantWP[3];
|
|
SFLOAT MediaWP[3];
|
|
|
|
SINT i;
|
|
MEMPTR lpOldMem = lpMem;
|
|
SINT Ret = 0;
|
|
|
|
// Check if we can generate the CS.
|
|
// Required tags are: red, green and blue Colorants.
|
|
// As for TRC tags - we are quite flexible here - if we cannot find the
|
|
// required tag - we assume the linear responce
|
|
if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
|
|
!GetCPDevSpace (cp, (LPCSIG) & Dev) ||
|
|
(Dev != icSigRgbData) ||
|
|
!DoesTRCAndColorantTagExist(cp))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
if ((InpDrvClrSp != icSigRgbData) &&
|
|
(InpDrvClrSp != icSigDefData) &&
|
|
(InpDrvClrSp != 0))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
// Estimate the memory size required to hold CS
|
|
|
|
if (lpMem == NULL) // This is a size request
|
|
{
|
|
*lpcbSize = 65530;
|
|
return (TRUE);
|
|
}
|
|
|
|
// Get info about Illuminant White Point from the header
|
|
GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP); // .. Illuminant
|
|
|
|
// Support absolute whitePoint
|
|
GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//*********** Creating global data
|
|
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedABCBegin);
|
|
|
|
if (IsSRGB(cp))
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, AdobeCSA);
|
|
}
|
|
else
|
|
{
|
|
lpMem += EnableGlobalDict(lpMem);
|
|
|
|
if (BackupCSA)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, NotSupportDEFG_S);
|
|
}
|
|
|
|
lpMem += BeginGlobalDict(lpMem);
|
|
|
|
lpMem += CreateColSpArray (cp, lpMem, icSigRedTRCTag, AllowBinary);
|
|
lpMem += CreateColSpArray (cp, lpMem, icSigGreenTRCTag, AllowBinary);
|
|
lpMem += CreateColSpArray (cp, lpMem, icSigBlueTRCTag, AllowBinary);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, EndOp);
|
|
|
|
if (BackupCSA)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
|
|
}
|
|
lpMem += WriteNewLineObject (lpMem, SetGlobalOp);
|
|
|
|
if (BackupCSA)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, NotSupportDEFG_S);
|
|
}
|
|
|
|
//*********** Start creating the ColorSpace
|
|
lpMem += WriteNewLineObject (lpMem, BeginArray); // Begin array
|
|
//********** /CIEBasedABC
|
|
lpMem += WriteObject (lpMem, CIEBasedABCTag); // Create entry
|
|
lpMem += WriteObject (lpMem, BeginDict); // Begin dictionary
|
|
|
|
//********** Black/White Point
|
|
lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//********** /DecodeABC
|
|
lpMem += WriteNewLineObject (lpMem, DecodeABCTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
lpMem += CreateColSpProc (cp, lpMem, icSigRedTRCTag, AllowBinary);
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
lpMem += CreateColSpProc (cp, lpMem, icSigGreenTRCTag, AllowBinary);
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
lpMem += CreateColSpProc (cp, lpMem, icSigBlueTRCTag, AllowBinary);
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
//********** /MatrixABC
|
|
lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
|
|
lpMem += CreateFloatString (cp, lpMem, icSigRedColorantTag);
|
|
lpMem += CreateFloatString (cp, lpMem, icSigGreenColorantTag);
|
|
lpMem += CreateFloatString (cp, lpMem, icSigBlueColorantTag);
|
|
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
//********** /RangeLMN
|
|
lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
|
|
lpMem += WriteObject (lpMem, RangeLMN);
|
|
|
|
//********** /DecodeLMN
|
|
if (InputIntent == icAbsoluteColorimetric)
|
|
{
|
|
// Support absolute whitePoint
|
|
lpMem += WriteNewLineObject (lpMem, DecodeLMNTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < 3; i ++)
|
|
{
|
|
lpMem += WriteObject (lpMem, BeginFunction);
|
|
lpMem += WriteFloat (lpMem, (double)MediaWP[i]/IlluminantWP[i]);
|
|
lpMem += WriteObject (lpMem, MulOp);
|
|
lpMem += WriteObject (lpMem, EndFunction);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
}
|
|
|
|
//********** End dictionary definition
|
|
lpMem += WriteNewLineObject (lpMem, EndDict);
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
if (BackupCSA)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
|
|
}
|
|
|
|
}
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedABCEnd);
|
|
*lpcbSize = (DWORD) ((lpMem - lpOldMem));
|
|
return (TRUE);
|
|
}
|
|
|
|
/*
|
|
* GetPS2CSA_ABC_LAB
|
|
* function:
|
|
* this is the function which creates the CIEBasedABC ColorSpace (CS)
|
|
* from the data supplied in the LAB Input Profile.
|
|
* prototype:
|
|
* GetPS2CSA_ABC(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpMem,
|
|
* LPDWORD lpcbSize,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpMem -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* InputIntent --
|
|
* InpDrvClrSp --
|
|
* AllowBinary -- 1: binary CSA allowed, 0: only ascii CSA allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
|
|
BOOL
|
|
GetPS2CSA_ABC_LAB (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
|
|
CSIG InputIntent, DWORD InpDrvClrSp, BOOL AllowBinary)
|
|
{
|
|
CSIG PCS, Dev;
|
|
SFLOAT IlluminantWP[3];
|
|
SFLOAT MediaWP[3];
|
|
|
|
SINT i;
|
|
MEMPTR lpOldMem = lpMem;
|
|
SINT Ret = 0;
|
|
// Check if we can generate the CS.
|
|
// Required tags are: red, green and blue Colorants.
|
|
// As for TRC tags - we are quite flexible here - if we cannot find the
|
|
// required tag - we assume the linear responce
|
|
if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
|
|
!GetCPDevSpace (cp, (LPCSIG) & Dev) ||
|
|
(Dev != icSigLabData))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
if ((InpDrvClrSp != icSigLabData) &&
|
|
(InpDrvClrSp != icSigDefData) &&
|
|
(InpDrvClrSp != 0))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
// Estimate the memory size required to hold CS
|
|
|
|
if (lpMem == NULL) // This is a size request
|
|
{
|
|
*lpcbSize = 65530;
|
|
return (TRUE);
|
|
}
|
|
// Get info about Illuminant White Point from the header
|
|
GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP); // .. Illuminant
|
|
|
|
// Support absolute whitePoint
|
|
GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//*********** Start creating the ColorSpace
|
|
lpMem += WriteNewLineObject (lpMem, BeginArray); // Begin array
|
|
|
|
//********** /CIEBasedABC
|
|
lpMem += WriteObject (lpMem, CIEBasedABCTag); // Create entry
|
|
lpMem += WriteObject (lpMem, BeginDict); // Begin dictionary
|
|
|
|
//********** Black/White Point
|
|
lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//********** /RangeABC
|
|
lpMem += WriteNewLineObject (lpMem, RangeABCTag);
|
|
lpMem += WriteObject (lpMem, RangeABC_Lab);
|
|
|
|
//********** /DecodeABC
|
|
lpMem += WriteNewLineObject (lpMem, DecodeABCTag);
|
|
lpMem += WriteObject (lpMem, DecodeABCLab1);
|
|
|
|
//********** /MatrixABC
|
|
lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
|
|
lpMem += WriteObject (lpMem, MatrixABCLab);
|
|
|
|
//********** /DecodeLMN
|
|
lpMem += WriteNewLineObject (lpMem, DecodeLMNTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < 3; i ++)
|
|
{
|
|
lpMem += WriteObject (lpMem, BeginFunction);
|
|
lpMem += WriteObject (lpMem, DecodeLMNLab);
|
|
if (InputIntent == icAbsoluteColorimetric)
|
|
{
|
|
lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
|
|
}
|
|
else
|
|
{
|
|
lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
|
|
}
|
|
lpMem += WriteObject (lpMem, MulOp);
|
|
lpMem += WriteObject (lpMem, EndFunction);
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
|
|
//********** End dictionary definition
|
|
lpMem += WriteNewLineObject (lpMem, EndDict);
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedABCEnd);
|
|
*lpcbSize = (DWORD) ((lpMem - lpOldMem));
|
|
return (TRUE);
|
|
}
|
|
|
|
/*
|
|
* GetPS2CSA_MONO_ABC
|
|
* function:
|
|
* this is the function which creates the CIEBasedABC ColorSpace (CS)
|
|
* from the data supplied in the GRAY Input Profile.
|
|
* prototype:
|
|
* GetPS2CSA_MONO_ABC(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpMem,
|
|
* LPDWORD lpcbSize,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpMem -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* AllowBinary -- 1: binary CSA allowed, 0: only ascii CSA allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
|
|
static BOOL
|
|
GetPS2CSA_MONO_ABC (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
|
|
CSIG InputIntent, BOOL AllowBinary)
|
|
{
|
|
SINT nCount;
|
|
CSIG Tag, PCS;
|
|
SINT i, j, Index;
|
|
MEMPTR lpTable;
|
|
SFLOAT IlluminantWP[3];
|
|
SFLOAT MediaWP[3];
|
|
MEMPTR lpBuff = NULL;
|
|
SINT MemSize = 0;
|
|
MEMPTR lpOldMem = lpMem;
|
|
HGLOBAL hBuff;
|
|
MEMPTR lpLineStart;
|
|
// Check if we can generate the CS
|
|
if (!DoesCPTagExist (cp, icSigGrayTRCTag) ||
|
|
!GetCPTagIndex (cp, icSigGrayTRCTag, &Index) ||
|
|
!GetCPElementType (cp, Index, (LPCSIG) & Tag) ||
|
|
(Tag != icSigCurveType) ||
|
|
!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
|
|
!GetCPElementSize (cp, Index, (LPSINT) & MemSize) ||
|
|
!MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & lpBuff) ||
|
|
!GetCPElement (cp, Index, lpBuff, MemSize))
|
|
{
|
|
if (NULL != lpBuff)
|
|
{
|
|
MemFree (hBuff);
|
|
}
|
|
return (FALSE);
|
|
}
|
|
nCount = ui32toSINT (((lpcpCurveType) lpBuff)->curve.count);
|
|
|
|
// Estimate the memory size required to hold CS
|
|
*lpcbSize = nCount * 6 + // Number of INT elements
|
|
3 * (lstrlen (IndexArray) +
|
|
lstrlen (StartClip) +
|
|
lstrlen (EndClip)) +
|
|
2048; // + other PS stuff
|
|
if (lpMem == NULL) // This is a size request
|
|
{
|
|
MemFree (hBuff);
|
|
return (TRUE);
|
|
}
|
|
// Get info about Illuminant White Point from the header
|
|
GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP); // .. Illuminant
|
|
|
|
// Support absolute whitePoint
|
|
GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//*********** Start creating the ColorSpace
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedABCBegin);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, BeginArray); // Begin array
|
|
//********** /CIEBasedABC
|
|
lpMem += WriteObject (lpMem, CIEBasedABCTag); // Create entry
|
|
lpMem += WriteObject (lpMem, BeginDict); // Begin dictionary
|
|
|
|
//********** Black/White Point
|
|
lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//********** /DecodeABC
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
lpLineStart = lpMem;
|
|
|
|
if (nCount != 0)
|
|
{
|
|
lpMem += WriteObject (lpMem, DecodeABCTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
|
|
lpMem += WriteObject (lpMem, BeginFunction);
|
|
if (nCount == 1) // Gamma supplied in ui16 format
|
|
{
|
|
lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
|
|
lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
|
|
lpMem += WriteObject (lpMem, DecodeA3);
|
|
} else
|
|
{
|
|
lpMem += WriteObject (lpMem, StartClip);
|
|
lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
|
|
lpTable += sizeof (icUInt16Number);
|
|
if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
|
|
{
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
}
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
|
|
lpMem += WriteObject (lpMem, IndexArray);
|
|
lpMem += WriteObject (lpMem, Scale16);
|
|
lpMem += WriteObject (lpMem, EndClip);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndFunction);
|
|
lpMem += WriteObject (lpMem, DupOp);
|
|
lpMem += WriteObject (lpMem, DupOp);
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
}
|
|
//********** /MatrixABC
|
|
lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < 3; i ++)
|
|
{
|
|
for (j = 0; j < 3; j++)
|
|
{
|
|
if (i != j)
|
|
lpMem += WriteFloat (lpMem, (double)0);
|
|
else
|
|
{
|
|
if (InputIntent == icAbsoluteColorimetric)
|
|
lpMem += WriteFloat (lpMem, (double)MediaWP[i]);
|
|
else
|
|
lpMem += WriteFloat (lpMem, (double)IlluminantWP[i]);
|
|
}
|
|
}
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
//********** /RangeLMN
|
|
lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
|
|
lpMem += WriteObject (lpMem, RangeLMN);
|
|
|
|
|
|
lpMem += WriteObject (lpMem, EndDict); // End dictionary definition
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
MemFree (hBuff);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedABCEnd);
|
|
*lpcbSize = (DWORD) (lpMem - lpOldMem);
|
|
return (TRUE);
|
|
}
|
|
/*
|
|
* GetPS2CSA_MONO_A
|
|
* function:
|
|
* this is the function which creates the CIEBasedA ColorSpace (CS)
|
|
* from the data supplied in the GRAY Input Profile.
|
|
* prototype:
|
|
* GetPS2CSA_MONO_A(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpMem,
|
|
* LPDWORD lpcbSize,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpMem -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* AllowBinary -- 1: binary CSA allowed, 0: only ascii CSA allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
|
|
static BOOL
|
|
GetPS2CSA_MONO_A (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
|
|
CSIG InputIntent, BOOL AllowBinary)
|
|
{
|
|
SINT nCount;
|
|
CSIG Tag, PCS;
|
|
SINT i, Index;
|
|
MEMPTR lpTable;
|
|
SFLOAT IlluminantWP[3];
|
|
SFLOAT MediaWP[3];
|
|
MEMPTR lpBuff = NULL;
|
|
SINT MemSize = 0;
|
|
MEMPTR lpOldMem = lpMem;
|
|
HGLOBAL hBuff;
|
|
MEMPTR lpLineStart;
|
|
// Check if we can generate the CS
|
|
if (!DoesCPTagExist (cp, icSigGrayTRCTag) ||
|
|
!GetCPTagIndex (cp, icSigGrayTRCTag, &Index) ||
|
|
!GetCPElementType (cp, Index, (LPCSIG) & Tag) ||
|
|
(Tag != icSigCurveType) ||
|
|
!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
|
|
!GetCPElementSize (cp, Index, (LPSINT) & MemSize) ||
|
|
!MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & lpBuff) ||
|
|
!GetCPElement (cp, Index, lpBuff, MemSize))
|
|
{
|
|
if (NULL != lpBuff)
|
|
{
|
|
MemFree (hBuff);
|
|
}
|
|
return (FALSE);
|
|
}
|
|
nCount = ui32toSINT (((lpcpCurveType) lpBuff)->curve.count);
|
|
|
|
// Estimate the memory size required to hold CS
|
|
*lpcbSize = nCount * 6 + // Number of INT elements
|
|
3 * (lstrlen (IndexArray) +
|
|
lstrlen (StartClip) +
|
|
lstrlen (EndClip)) +
|
|
2048; // + other PS stuff
|
|
if (lpMem == NULL) // This is a size request
|
|
{
|
|
MemFree (hBuff);
|
|
return (TRUE);
|
|
}
|
|
// Get info about Illuminant White Point from the header
|
|
GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP); // .. Illuminant
|
|
|
|
// Support absolute whitePoint
|
|
GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//*********** Start creating the ColorSpace
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedABegin);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, BeginArray); // Begin array
|
|
//********** /CIEBasedA
|
|
lpMem += WriteObject (lpMem, CIEBasedATag); // Create entry
|
|
lpMem += WriteObject (lpMem, BeginDict); // Begin dictionary
|
|
|
|
//********** Black/White Point
|
|
lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
|
|
|
|
//********** /DecodeA
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
lpLineStart = lpMem;
|
|
|
|
if (nCount != 0)
|
|
{
|
|
lpMem += WriteObject (lpMem, DecodeATag);
|
|
|
|
lpMem += WriteObject (lpMem, BeginFunction);
|
|
if (nCount == 1) // Gamma supplied in ui16 format
|
|
{
|
|
lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
|
|
lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
|
|
lpMem += WriteObject (lpMem, DecodeA3);
|
|
// If the PCS is Lab, we need to convert Lab to XYZ
|
|
// Now, the range is from 0 --> 0.99997.
|
|
// Actually, the conversion from Lab to XYZ is not needed.
|
|
if (PCS == icSigLabData)
|
|
{
|
|
lpMem += WriteObject (lpMem, DecodeALab);
|
|
lpMem += WriteObject (lpMem, DecodeLMNLab);
|
|
}
|
|
} else
|
|
{
|
|
lpMem += WriteObject (lpMem, StartClip);
|
|
lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
|
|
lpTable += sizeof (icUInt16Number);
|
|
if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
|
|
{
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
}
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
lpLineStart = lpMem;
|
|
lpMem += WriteObject (lpMem, NewLine);
|
|
|
|
lpMem += WriteObject (lpMem, IndexArray);
|
|
lpMem += WriteObject (lpMem, Scale16);
|
|
// If the PCS is Lab, we need to convert Lab to XYZ
|
|
// Now, the range is from 0 --> .99997.
|
|
// Actually, the conversion from Lab to XYZ is not needed.
|
|
if (PCS == icSigLabData)
|
|
{
|
|
lpMem += WriteObject (lpMem, DecodeALab);
|
|
lpMem += WriteObject (lpMem, DecodeLMNLab);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndClip);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndFunction);
|
|
}
|
|
|
|
//********** /MatrixA
|
|
lpMem += WriteNewLineObject (lpMem, MatrixATag);
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
if (InputIntent == icAbsoluteColorimetric)
|
|
lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
|
|
else
|
|
lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
//********** /RangeLMN
|
|
lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
|
|
lpMem += WriteObject (lpMem, RangeLMN);
|
|
|
|
//********** /End dictionary
|
|
lpMem += WriteObject (lpMem, EndDict); // End dictionary definition
|
|
lpMem += WriteObject (lpMem, EndArray);
|
|
|
|
MemFree (hBuff);
|
|
|
|
lpMem += WriteNewLineObject (lpMem, CieBasedAEnd);
|
|
*lpcbSize = (DWORD) (lpMem - lpOldMem);
|
|
return (TRUE);
|
|
}
|
|
/*
|
|
* GetPS2CSA_MONO
|
|
* function:
|
|
* this is the function which creates the MONO ColorSpace (CS)
|
|
* from the data supplied in the GRAY Input Profile.
|
|
* prototype:
|
|
* GetPS2CSA_MONO(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpMem,
|
|
* LPDWORD lpcbSize,
|
|
* WORD InpDrvClrSp
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpMem -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* InpDrvClrSp -- Device color type (RGB or GRAY).
|
|
* AllowBinary -- 1: binary CSA allowed, 0: only ascii CSA allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
static BOOL
|
|
GetPS2CSA_MONO (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
|
|
DWORD InpDrvClrSp, CSIG InputIntent, BOOL AllowBinary)
|
|
{
|
|
BOOL Success = FALSE;
|
|
#if 0
|
|
if ((InpDrvClrSp == icSigRgbData) ||
|
|
(InpDrvClrSp == icSigDefData) ||
|
|
(InpDrvClrSp == 0))
|
|
{
|
|
Success = GetPS2CSA_MONO_ABC (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
|
|
} else if (InpDrvClrSp == icSigGrayData)
|
|
{
|
|
Success = GetPS2CSA_MONO_A (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
|
|
}
|
|
#else
|
|
if ((InpDrvClrSp == icSigGrayData) ||
|
|
(InpDrvClrSp == 0))
|
|
{
|
|
Success = GetPS2CSA_MONO_A (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
|
|
}
|
|
else
|
|
{
|
|
Success = FALSE;
|
|
}
|
|
#endif
|
|
return Success;
|
|
}
|
|
/*
|
|
|
|
* Function to create a procedure for Color space.
|
|
|
|
*/
|
|
|
|
SINT
|
|
CreateColSpProc (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary)
|
|
{
|
|
SINT nCount, Index;
|
|
MEMPTR lpTable;
|
|
MEMPTR Buff = NULL;
|
|
SINT MemSize = 0;
|
|
MEMPTR lpOldMem;
|
|
HGLOBAL hBuff;
|
|
lpOldMem = lpMem;
|
|
lpMem += WriteObject (lpMem, BeginFunction);
|
|
if (DoesCPTagExist (cp, CPTag) &&
|
|
GetCPTagIndex (cp, CPTag, (LPSINT) & Index) &&
|
|
GetCPElementSize (cp, Index, (LPSINT) & MemSize) &&
|
|
MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & Buff) &&
|
|
GetCPElement (cp, Index, Buff, MemSize))
|
|
{
|
|
nCount = ui32toSINT (((lpcpCurveType) Buff)->curve.count);
|
|
if (nCount != 0)
|
|
{
|
|
if (nCount == 1) // Gamma supplied in ui16 format
|
|
{
|
|
lpTable = (MEMPTR) (((lpcpCurveType) Buff)->curve.data);
|
|
lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
|
|
lpMem += WriteObject (lpMem, DecodeA3);
|
|
} else
|
|
{
|
|
lpMem += WriteObject (lpMem, StartClip);
|
|
lpTable = (MEMPTR) (((lpcpCurveType) Buff)->curve.data);
|
|
lpMem += WriteObject (lpMem, DecodeABCArray);
|
|
lpMem += WriteInt (lpMem, (SINT) CPTag);
|
|
|
|
if (!AllowBinary) // Output ASCII CS
|
|
{
|
|
lpMem += WriteObject (lpMem, IndexArray);
|
|
} else
|
|
{ // Output BINARY CS
|
|
lpMem += WriteObject (lpMem, IndexArray16b);
|
|
}
|
|
lpMem += WriteObject (lpMem, Scale16);
|
|
lpMem += WriteObject (lpMem, EndClip);
|
|
}
|
|
}
|
|
MemFree (hBuff);
|
|
}
|
|
lpMem += WriteObject (lpMem, EndFunction);
|
|
return ((SINT) (lpMem - lpOldMem));
|
|
}
|
|
/*
|
|
|
|
* Function to create a procedure for Color space.
|
|
|
|
*/
|
|
|
|
SINT
|
|
CreateFloatString (CHANDLE cp, MEMPTR lpMem, CSIG CPTag)
|
|
{
|
|
SINT i, Index;
|
|
MEMPTR lpTable;
|
|
MEMPTR Buff = NULL;
|
|
SINT MemSize = 0;
|
|
MEMPTR lpOldMem;
|
|
HGLOBAL hBuff;
|
|
lpOldMem = lpMem;
|
|
if (GetCPTagIndex (cp, CPTag, (LPSINT) & Index) &&
|
|
GetCPElementSize (cp, Index, (LPSINT) & MemSize) &&
|
|
MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & Buff) &&
|
|
GetCPElement (cp, Index, Buff, MemSize))
|
|
{
|
|
lpTable = (MEMPTR) & (((lpcpXYZType) Buff)->data);
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
lpMem += WriteFloat (lpMem, si16f16toSFLOAT (lpTable));
|
|
lpTable += sizeof (icS15Fixed16Number);
|
|
}
|
|
MemFree (hBuff);
|
|
}
|
|
return ((SINT) (lpMem - lpOldMem));
|
|
}
|
|
/*
|
|
|
|
* Function to create a array later to be used in ColorSpace's DecodeABC.
|
|
|
|
*/
|
|
|
|
SINT
|
|
CreateColSpArray (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary)
|
|
{
|
|
SINT i, nCount, Index;
|
|
MEMPTR lpTable;
|
|
MEMPTR Buff = NULL;
|
|
SINT MemSize = 0;
|
|
MEMPTR lpOldMem, lpLineStart;
|
|
HGLOBAL hBuff;
|
|
lpOldMem = lpMem;
|
|
|
|
lpLineStart = lpMem;
|
|
|
|
if (DoesCPTagExist (cp, CPTag) &&
|
|
GetCPTagIndex (cp, CPTag, (LPSINT) & Index) &&
|
|
GetCPElementSize (cp, Index, (LPSINT) & MemSize) &&
|
|
MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & Buff) &&
|
|
GetCPElement (cp, Index, Buff, MemSize))
|
|
{
|
|
nCount = ui32toSINT (((lpcpCurveType) Buff)->curve.count);
|
|
if (nCount > 1)
|
|
{
|
|
lpMem += WriteNewLineObject (lpMem, Slash);
|
|
lpMem += WriteObject (lpMem, DecodeABCArray);
|
|
lpMem += WriteInt (lpMem, (SINT) CPTag);
|
|
|
|
lpTable = (MEMPTR) (((lpcpCurveType) Buff)->curve.data);
|
|
if (!AllowBinary) // Output ASCII CS
|
|
{
|
|
lpMem += WriteObject (lpMem, BeginArray);
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
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 CS
|
|
lpMem += WriteHNAToken (lpMem, 149, nCount);
|
|
lpMem += WriteIntStringU2S (lpMem, lpTable, nCount);
|
|
}
|
|
lpMem += WriteObject (lpMem, DefOp);
|
|
}
|
|
MemFree (hBuff);
|
|
}
|
|
return ((SINT) (lpMem - lpOldMem));
|
|
}
|
|
/*
|
|
* GetCSAFromProfile
|
|
* function:
|
|
* this is the function which gets the ColorSpace dictionary array
|
|
* from the the Profile.
|
|
* prototype:
|
|
* static BOOL GetCSAFromProfile(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpMem,
|
|
* LPDWORD lpcbSize,
|
|
* WORD InpDrvClrSp,
|
|
* CSIG DrvColorSpace,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpBuffer -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* InpDrvClrSp -- Input device color space.
|
|
* DrvColorSpace -- Profile device color space.
|
|
* AllowBinary -- 1: binary CS allowed, 0: only ascii CS allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
|
|
static BOOL
|
|
GetCSAFromProfile (
|
|
CHANDLE cp,
|
|
MEMPTR lpMem,
|
|
LPDWORD lpcbSize,
|
|
DWORD InpDrvClrSp,
|
|
CSIG DrvColorSpace,
|
|
BOOL AllowBinary)
|
|
{
|
|
SINT Index;
|
|
SINT Size;
|
|
if ((DrvColorSpace == icSigGrayData) && (InpDrvClrSp != icSigGrayData))
|
|
return FALSE;
|
|
|
|
if (DoesCPTagExist (cp, icSigPs2CSATag) &&
|
|
GetCPTagIndex (cp, icSigPs2CSATag, (LPSINT) & Index) &&
|
|
GetCPElementDataSize (cp, Index, (LPSINT) & Size) &&
|
|
((lpMem == NULL) || GetCPElementData (cp, Index, lpMem, Size)) &&
|
|
(*lpcbSize = Convert2Ascii (cp, Index, lpMem, *lpcbSize, Size, AllowBinary)))
|
|
{
|
|
return TRUE;
|
|
} else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
/*
|
|
* GetPS2CSA_DEFG_Intent
|
|
* function:
|
|
* This is the function which creates the CieBasedDEF(G)ColorSpace array
|
|
* based on Intent.
|
|
* prototype:
|
|
* static BOOL GetPS2CSA_DEFG_Intent(
|
|
* CHANDLE cp,
|
|
* MEMPTR lpBuffer,
|
|
* LPDWORD lpcbSize,
|
|
* CSIG Intent,
|
|
* int Type,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpBuffer -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* Intent -- Intent.
|
|
* Type -- CieBasedDEF or CieBasedDEF.
|
|
* AllowBinary -- 1: binary CS allowed, 0: only ascii CS allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
|
|
BOOL
|
|
GetPS2CSA_DEFG_Intent (
|
|
CHANDLE cp,
|
|
MEMPTR lpBuffer,
|
|
LPDWORD lpcbSize,
|
|
DWORD InpDrvClrSp,
|
|
CSIG Intent,
|
|
int Type,
|
|
BOOL AllowBinary)
|
|
{
|
|
SINT Index;
|
|
BOOL Success = FALSE;
|
|
CSIG icSigAToBx;
|
|
|
|
// Try to create CieBasedDEFG CSA first.
|
|
if (((Type == TYPE_CIEBASEDDEFG) && (InpDrvClrSp != icSigCmykData) ||
|
|
(Type == TYPE_CIEBASEDDEF) && (InpDrvClrSp != icSigDefData)) &&
|
|
(InpDrvClrSp != 0))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
switch (Intent)
|
|
{
|
|
case icPerceptual:
|
|
icSigAToBx = icSigAToB0Tag;
|
|
break;
|
|
case icRelativeColorimetric:
|
|
icSigAToBx = icSigAToB1Tag;
|
|
break;
|
|
case icSaturation:
|
|
icSigAToBx = icSigAToB2Tag;
|
|
break;
|
|
case icAbsoluteColorimetric:
|
|
icSigAToBx = icSigAToB1Tag;
|
|
break;
|
|
default:
|
|
return Success;
|
|
}
|
|
|
|
if (DoesCPTagExist (cp, icSigAToBx) &&
|
|
GetCPTagIndex (cp, icSigAToBx, (LPSINT) & Index))
|
|
{
|
|
Success = GetPS2CSA_DEFG (cp, lpBuffer, lpcbSize, Intent, Index, Type, AllowBinary);
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
/*
|
|
* GetPS2ColorSpaceArray
|
|
* function:
|
|
* This is the main function which creates the ColorSpace array
|
|
* from the data supplied in the Profile.
|
|
* prototype:
|
|
* BOOL GetPS2ColorSpaceArray(
|
|
* CHANDLE cp,
|
|
* CSIG InputIntent,
|
|
* WORD InpDrvClrSp,
|
|
* MEMPTR lpBuffer,
|
|
* LPDWORD lpcbSize,
|
|
* BOOL AllowBinary)
|
|
* parameters:
|
|
* cp -- Color Profile handle
|
|
* lpBuffer -- Pointer to the memory block. If this point is NULL,
|
|
* require buffer size.
|
|
* lpcbSize -- Size of the memory block
|
|
* InpDrvClrSp -- Input device color space.
|
|
* icSigCmykData: input data is cmyk, create CiebasedDEFG CSA.
|
|
* icSigRgbData : input data is rgb, create CieBasedABC CSA.
|
|
* icSigDefData : input data is rgb or lab, create CiebasedDEF CSA.
|
|
* isSigGrayData: input data is gray, create CieBasedA CSA.
|
|
* 0 : Auto. Create CSA depends on profile color space.
|
|
* InputIntent -- Intent.
|
|
* AllowBinary -- 1: binary CS allowed, 0: only ascii CS allowed.
|
|
* returns:
|
|
* BOOL -- TRUE if the function was successful,
|
|
* FALSE otherwise.
|
|
*/
|
|
BOOL EXTERN
|
|
GetPS2ColorSpaceArray (
|
|
CHANDLE cp,
|
|
DWORD InputIntent,
|
|
DWORD InpDrvClrSp,
|
|
MEMPTR lpBuffer,
|
|
LPDWORD lpcbSize,
|
|
BOOL AllowBinary)
|
|
{
|
|
CSIG ColorSpace, Intent;
|
|
BOOL Success = FALSE;
|
|
DWORD dwSaveSize;
|
|
if (!cp)
|
|
return Success;
|
|
|
|
if (!GetCPDevSpace (cp, (LPCSIG) & ColorSpace) ||
|
|
!GetCPRenderIntent (cp, (LPCSIG) & Intent))
|
|
{
|
|
return Success;
|
|
}
|
|
dwSaveSize = *lpcbSize;
|
|
if (InputIntent == icUseRenderingIntent)
|
|
InputIntent = (DWORD)Intent;
|
|
|
|
// Get ColorSpace from Profile.
|
|
if ((CSIG) InputIntent == Intent)
|
|
{
|
|
Success = GetCSAFromProfile (cp, lpBuffer, lpcbSize,
|
|
InpDrvClrSp, ColorSpace, AllowBinary);
|
|
}
|
|
if (!Success)
|
|
{
|
|
switch (ColorSpace)
|
|
{
|
|
case icSigRgbData:
|
|
Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
|
|
InpDrvClrSp, (CSIG) InputIntent,
|
|
TYPE_CIEBASEDDEF, AllowBinary);
|
|
if (Success)
|
|
{ // Create CieBasedABC or DeviceRGB
|
|
// for the printer
|
|
// which does not support CieBasedDEF(G).
|
|
DWORD cbNewSize = 0;
|
|
MEMPTR lpNewBuffer;
|
|
MEMPTR lpOldBuffer;
|
|
if (lpBuffer)
|
|
{
|
|
lpNewBuffer = lpBuffer + *lpcbSize;
|
|
lpOldBuffer = lpNewBuffer;
|
|
lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
|
|
cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
|
|
} else
|
|
lpNewBuffer = NULL;
|
|
|
|
if (!GetPS2CSA_ABC (cp, lpNewBuffer, &cbNewSize,
|
|
(CSIG)InputIntent, InpDrvClrSp,
|
|
AllowBinary, 1)) // create a backup CSA
|
|
GetDeviceRGB (lpNewBuffer, &cbNewSize, InpDrvClrSp, 1);
|
|
|
|
if (lpBuffer)
|
|
{
|
|
lpNewBuffer += cbNewSize;
|
|
*lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
|
|
} else
|
|
*lpcbSize += cbNewSize;
|
|
|
|
}
|
|
if (!Success)
|
|
{ // Create CieBasedABC
|
|
Success = GetPS2CSA_ABC (cp, lpBuffer, lpcbSize,
|
|
(CSIG)InputIntent, InpDrvClrSp,
|
|
AllowBinary, 0);
|
|
}
|
|
if (!Success)
|
|
{ // Create DeviceRGB
|
|
Success = GetDeviceRGB (lpBuffer, lpcbSize, InpDrvClrSp, 0);
|
|
Success = FALSE;
|
|
}
|
|
break;
|
|
case icSigCmykData:
|
|
Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
|
|
InpDrvClrSp, (CSIG) InputIntent,
|
|
TYPE_CIEBASEDDEFG, AllowBinary);
|
|
if (Success)
|
|
{ // Create DeviceCMYK for the printer
|
|
// which does not support CieBasedDEF(G).
|
|
DWORD cbNewSize = 0;
|
|
MEMPTR lpNewBuffer;
|
|
MEMPTR lpOldBuffer;
|
|
if (lpBuffer)
|
|
{
|
|
lpNewBuffer = lpBuffer + *lpcbSize;
|
|
lpOldBuffer = lpNewBuffer;
|
|
lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
|
|
lpNewBuffer += WriteNewLineObject (lpNewBuffer, NotSupportDEFG_S);
|
|
cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
|
|
} else
|
|
lpNewBuffer = NULL;
|
|
|
|
GetDeviceCMYK (lpNewBuffer, &cbNewSize, InpDrvClrSp);
|
|
|
|
if (lpBuffer)
|
|
{
|
|
lpNewBuffer += cbNewSize;
|
|
lpNewBuffer += WriteNewLineObject (lpNewBuffer, SupportDEFG_E);
|
|
*lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
|
|
} else
|
|
*lpcbSize += cbNewSize;
|
|
}
|
|
if (!Success)
|
|
{ // Create DeviceCMYK
|
|
Success = GetDeviceCMYK (lpBuffer, lpcbSize, InpDrvClrSp);
|
|
Success = FALSE;
|
|
}
|
|
break;
|
|
case icSigGrayData:
|
|
Success = GetPS2CSA_MONO (cp, lpBuffer, lpcbSize, InpDrvClrSp,
|
|
(CSIG)InputIntent, AllowBinary);
|
|
if (!Success)
|
|
{ // Create DeviceGray
|
|
Success = GetDeviceGray (lpBuffer, lpcbSize, InpDrvClrSp);
|
|
Success = FALSE;
|
|
}
|
|
break;
|
|
case icSigLabData:
|
|
Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
|
|
InpDrvClrSp, (CSIG) InputIntent,
|
|
TYPE_CIEBASEDDEF, AllowBinary);
|
|
if (Success)
|
|
{ // Create CieBasedABC or DeviceRGB
|
|
// for the printer
|
|
// which does not support CieBasedDEF(G).
|
|
DWORD cbNewSize = 0;
|
|
MEMPTR lpNewBuffer;
|
|
MEMPTR lpOldBuffer;
|
|
if (lpBuffer)
|
|
{
|
|
lpNewBuffer = lpBuffer + *lpcbSize;
|
|
lpOldBuffer = lpNewBuffer;
|
|
lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
|
|
lpNewBuffer += WriteNewLineObject (lpNewBuffer, NotSupportDEFG_S);
|
|
cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
|
|
} else
|
|
lpNewBuffer = NULL;
|
|
|
|
GetPS2CSA_ABC_LAB (cp, lpNewBuffer, &cbNewSize,
|
|
(CSIG)InputIntent, InpDrvClrSp, AllowBinary);
|
|
|
|
if (lpBuffer)
|
|
{
|
|
lpNewBuffer += cbNewSize;
|
|
lpNewBuffer += WriteNewLineObject (lpNewBuffer, SupportDEFG_E);
|
|
*lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
|
|
} else
|
|
*lpcbSize += cbNewSize;
|
|
}
|
|
if (!Success)
|
|
{ // Create CieBasedABC
|
|
Success = GetPS2CSA_ABC_LAB (cp, lpBuffer, lpcbSize,
|
|
(CSIG)InputIntent, InpDrvClrSp, AllowBinary);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return Success;
|
|
}
|