1066 lines
37 KiB
C
1066 lines
37 KiB
C
|
#include "generic.h"
|
||
|
|
#include "stdio.h"
|
||
|
|
#pragma code_seg(_ICMSEG)
|
||
|
|
|
||
|
|
char ICMSEG BeginString[] = "<";
|
||
|
|
char ICMSEG EndString[] = ">";
|
||
|
|
char ICMSEG BeginArray[] = "[";
|
||
|
|
char ICMSEG EndArray[] = "]";
|
||
|
|
char ICMSEG BeginFunction[] = "{";
|
||
|
|
char ICMSEG EndFunction[] = "}bind ";
|
||
|
|
char ICMSEG BeginDict[] = "<<";
|
||
|
|
char ICMSEG EndDict[] = ">>";
|
||
|
|
char ICMSEG BlackPoint[] = "[0 0 0]";
|
||
|
|
char ICMSEG DictType[] = "/ColorRenderingType 1 ";
|
||
|
|
char ICMSEG IntentType[] = "/RenderingIntent ";
|
||
|
|
char ICMSEG IntentPer[] = "/Perceptual";
|
||
|
|
char ICMSEG IntentSat[] = "/Saturation";
|
||
|
|
char ICMSEG IntentACol[] = "/AbsoluteColorimetric";
|
||
|
|
char ICMSEG IntentRCol[] = "/RelativeColorimetric";
|
||
|
|
|
||
|
|
char ICMSEG WhitePointTag[] = "/WhitePoint ";
|
||
|
|
char ICMSEG BlackPointTag[] = "/BlackPoint ";
|
||
|
|
char ICMSEG RangePQRTag[] = "/RangePQR ";
|
||
|
|
char ICMSEG TransformPQRTag[] = "/TransformPQR ";
|
||
|
|
char ICMSEG MatrixPQRTag[] = "/MatrixPQR ";
|
||
|
|
|
||
|
|
char ICMSEG RangeABCTag[] = "/RangeABC ";
|
||
|
|
char ICMSEG MatrixATag[] = "/MatrixA ";
|
||
|
|
char ICMSEG MatrixABCTag[] = "/MatrixABC ";
|
||
|
|
char ICMSEG EncodeABCTag[] = "/EncodeABC ";
|
||
|
|
char ICMSEG RangeLMNTag[] = "/RangeLMN ";
|
||
|
|
char ICMSEG MatrixLMNTag[] = "/MatrixLMN ";
|
||
|
|
char ICMSEG EncodeLMNTag[] = "/EncodeLMN ";
|
||
|
|
char ICMSEG RenderTableTag[] = "/RenderTable ";
|
||
|
|
char ICMSEG CIEBasedATag[] = "/CIEBasedA ";
|
||
|
|
char ICMSEG CIEBasedABCTag[] = "/CIEBasedABC ";
|
||
|
|
char ICMSEG CIEBasedDEFGTag[] = "/CIEBasedDEFG ";
|
||
|
|
char ICMSEG CIEBasedDEFTag[] = "/CIEBasedDEF ";
|
||
|
|
char ICMSEG DecodeATag[] = "/DecodeA ";
|
||
|
|
char ICMSEG DecodeABCTag[] = "/DecodeABC ";
|
||
|
|
char ICMSEG DecodeLMNTag[] = "/DecodeLMN ";
|
||
|
|
char ICMSEG DeviceRGBTag[] = "/DeviceRGB ";
|
||
|
|
char ICMSEG DeviceCMYKTag[] = "/DeviceCMYK ";
|
||
|
|
char ICMSEG DeviceGrayTag[] = "/DeviceGray ";
|
||
|
|
char ICMSEG TableTag[] = "/Table ";
|
||
|
|
char ICMSEG DecodeDEFGTag[] = "/DecodeDEFG ";
|
||
|
|
char ICMSEG DecodeDEFTag[] = "/DecodeDEF ";
|
||
|
|
|
||
|
|
char ICMSEG NullOp[] = "";
|
||
|
|
char ICMSEG DupOp[] = "dup ";
|
||
|
|
char ICMSEG UserDictOp[] = "userdict ";
|
||
|
|
char ICMSEG GlobalDictOp[] = "globaldict ";
|
||
|
|
char ICMSEG CurrentGlobalOp[] = "currentglobal ";
|
||
|
|
char ICMSEG SetGlobalOp[] = "setglobal ";
|
||
|
|
char ICMSEG DefOp[] = "def ";
|
||
|
|
char ICMSEG BeginOp[] = "begin ";
|
||
|
|
char ICMSEG EndOp[] = "end ";
|
||
|
|
char ICMSEG TrueOp[] = "true ";
|
||
|
|
char ICMSEG FalseOp[] = "false ";
|
||
|
|
char ICMSEG MulOp[] = "mul ";
|
||
|
|
char ICMSEG DivOp[] = "div ";
|
||
|
|
|
||
|
|
char ICMSEG NewLine[] = "\n";
|
||
|
|
char ICMSEG Slash[] = "/";
|
||
|
|
char ICMSEG Space[] = " ";
|
||
|
|
char ICMSEG CRDBegin[] = "%** CRD Begin ";
|
||
|
|
char ICMSEG CRDEnd[] = "%** CRD End ";
|
||
|
|
char ICMSEG CieBasedDEFGBegin[] = "%** CieBasedDEFG CSA Begin ";
|
||
|
|
char ICMSEG CieBasedDEFBegin[] = "%** CieBasedDEF CSA Begin ";
|
||
|
|
char ICMSEG CieBasedABCBegin[] = "%** CieBasedABC CSA Begin ";
|
||
|
|
char ICMSEG CieBasedABegin[] = "%** CieBasedA CSA Begin ";
|
||
|
|
char ICMSEG CieBasedDEFGEnd[] = "%** CieBasedDEFG CSA End ";
|
||
|
|
char ICMSEG CieBasedDEFEnd[] = "%** CieBasedDEF CSA End ";
|
||
|
|
char ICMSEG CieBasedABCEnd[] = "%** CieBasedABC CSA End ";
|
||
|
|
char ICMSEG CieBasedAEnd[] = "%** CieBasedA CSA End ";
|
||
|
|
char ICMSEG RangeABC[] = "[ 0 1 0 1 0 1 ] ";
|
||
|
|
char ICMSEG RangeLMN[] = "[ 0 2 0 2 0 2 ] ";
|
||
|
|
char ICMSEG Identity[] = "[1 0 0 0 1 0 0 0 1]";
|
||
|
|
char ICMSEG RangeABC_Lab[] = "[0 100 -128 127 -128 127]";
|
||
|
|
|
||
|
|
/********** This PostScript code clips incoming value between 0.0 and 1.0
|
||
|
|
Use: x <clip> -- <clipped x> */
|
||
|
|
char ICMSEG Clip01[] = "dup 1.0 ge{pop 1.0}{dup 0.0 lt{pop 0.0}if}ifelse ";
|
||
|
|
char ICMSEG DecodeA3[] = "256 div exp ";
|
||
|
|
char ICMSEG DecodeA3Rev[] = "256 div 1.0 exch div exp ";
|
||
|
|
char ICMSEG DecodeABCArray[] = "DecodeABC_";
|
||
|
|
char ICMSEG InputArray[] = "Inp_";
|
||
|
|
char ICMSEG OutputArray[] = "Out_";
|
||
|
|
char ICMSEG PreViewInArray[] = "IPV_";
|
||
|
|
char ICMSEG PreViewOutArray[] = "OPV_";
|
||
|
|
|
||
|
|
char ICMSEG AdobeCSA[] = "[ /CIEBasedABC << /DecodeLMN [\n\
|
||
|
|
{dup 0.03928 le {12.92321 div}{0.055 add 1.055 div 2.4 exp}ifelse} bind dup dup ]\n\
|
||
|
|
/MatrixLMN [0.412457 0.212673 0.019334 0.357576 0.715152 0.119192 0.180437 0.072175 0.950301]\n\
|
||
|
|
/WhitePoint [ 0.9505 1 1.0890 ] >> ]";
|
||
|
|
|
||
|
|
char ICMSEG AdobeCRD[] = " /RangePQR [ -0.5 2 -0.5 2 -0.5 2 ]\n\
|
||
|
|
/MatrixPQR [0.8951 -0.7502 0.0389 0.2664 1.7135 -0.0685 -0.1614 0.0367 1.0296]\n\
|
||
|
|
/TransformPQR [{exch pop exch 3 get mul exch pop exch 3 get div} bind\n\
|
||
|
|
{exch pop exch 4 get mul exch pop exch 4 get div} bind\n\
|
||
|
|
{exch pop exch 5 get mul exch pop exch 5 get div} bind]\n\
|
||
|
|
/MatrixLMN [3.240449 -0.969265 0.055643 -1.537136 1.876011 -0.204026 -0.498531 0.041556 1.057229]\n\
|
||
|
|
/EncodeABC [{dup 0.00304 le {12.92321 mul}{1 2.4 div exp 1.055 mul 0.055 sub}ifelse} bind dup dup]\n\
|
||
|
|
/WhitePoint[0.9505 1 1.0890] >>";
|
||
|
|
|
||
|
|
// This PostScript segment takes value in range from 0.0 to 1.0 and
|
||
|
|
// interpolates the result using array supplied.
|
||
|
|
// x [array] -- <interpolated value>
|
||
|
|
|
||
|
|
char ICMSEG IndexArray16b[] = \
|
||
|
|
" dup length 1 sub 3 -1 roll mul dup dup floor cvi \
|
||
|
|
exch ceiling cvi 3 index exch get 32768 add 4 -1 roll 3 -1 roll get 32768 add \
|
||
|
|
dup 3 1 roll sub 3 -1 roll dup floor cvi sub mul add ";
|
||
|
|
|
||
|
|
char ICMSEG IndexArray[] = \
|
||
|
|
" dup length 1 sub 3 -1 roll mul dup dup floor cvi \
|
||
|
|
exch ceiling cvi 3 index exch get 4 -1 roll 3 -1 roll get \
|
||
|
|
dup 3 1 roll sub 3 -1 roll dup floor cvi sub mul add ";
|
||
|
|
|
||
|
|
char ICMSEG TestingDEFG[] = \
|
||
|
|
"/SupportDEFG? {/CIEBasedDEFG /ColorSpaceFamily resourcestatus { pop pop languagelevel 3 ge}{false} ifelse} def";
|
||
|
|
|
||
|
|
char ICMSEG SupportDEFG_S[] = "SupportDEFG? { ";
|
||
|
|
char ICMSEG NotSupportDEFG_S[] = "SupportDEFG? not { ";
|
||
|
|
char ICMSEG SupportDEFG_E[] = "}if ";
|
||
|
|
|
||
|
|
char ICMSEG StartClip[] = "dup 1.0 le{dup 0.0 ge{";
|
||
|
|
char ICMSEG EndClip[] = "}if}if ";
|
||
|
|
|
||
|
|
char ICMSEG Scale8[] = "255 div ";
|
||
|
|
char ICMSEG Scale16[] = "65535 div ";
|
||
|
|
char ICMSEG Scale16XYZ[] = "32768 div ";
|
||
|
|
char ICMSEG TFunction8[] = "exch 255 mul round cvi get 255 div ";
|
||
|
|
char ICMSEG TFunction8XYZ[] = "exch 255 mul round cvi get 128 div ";
|
||
|
|
char ICMSEG MatrixABCLab[] = "[1 1 1 1 0 0 0 0 -1]";
|
||
|
|
char ICMSEG DecodeABCLab1[] = "[{16 add 116 div} bind {500 div} bind {200 div} bind]";
|
||
|
|
char ICMSEG DecodeALab[] = " 50 mul 16 add 116 div ";
|
||
|
|
char ICMSEG DecodeLMNLab[] = \
|
||
|
|
"dup 0.206897 ge{dup dup mul mul}{0.137931 sub 0.128419 mul} ifelse ";
|
||
|
|
|
||
|
|
char ICMSEG RangeLMNLab[] = "[0 1 0 1 0 1]";
|
||
|
|
char ICMSEG EncodeLMNLab[] = "\
|
||
|
|
dup 0.008856 le{7.787 mul 0.13793 add}{0.3333 exp}ifelse ";
|
||
|
|
|
||
|
|
char ICMSEG MatrixABCLabCRD[] = "[0 500 0 116 -500 200 0 0 -200]";
|
||
|
|
char ICMSEG MatrixABCXYZCRD[] = "[0 1 0 1 0 0 0 0 1]";
|
||
|
|
char ICMSEG EncodeABCLab1[] = "16 sub 100 div ";
|
||
|
|
char ICMSEG EncodeABCLab2[] = "128 add 255 div ";
|
||
|
|
|
||
|
|
char ICMSEG RangePQR[] = "[ -0.07 2.2 -0.02 1.4 -0.2 4.8 ]";
|
||
|
|
char ICMSEG MatrixPQR[] = "[0.8951 -0.7502 0.0389 0.2664 1.7135 -0.0685 -0.1614 0.0367 1.0296]";
|
||
|
|
|
||
|
|
char *TransformPQR[3] = {
|
||
|
|
"exch pop exch 3 get mul exch pop exch 3 get div ",
|
||
|
|
"exch pop exch 4 get mul exch pop exch 4 get div ",
|
||
|
|
"exch pop exch 5 get mul exch pop exch 5 get div "};
|
||
|
|
|
||
|
|
#define SRGBCRC 0x678175D2L
|
||
|
|
|
||
|
|
#pragma optimize("",off)
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CreateLutCRD
|
||
|
|
* function:
|
||
|
|
* this is the function which creates the Color Rendering Dictionary (CRD)
|
||
|
|
* from the data supplied in the ColorProfile's LUT8 or LUT16 tag.
|
||
|
|
* prototype:
|
||
|
|
* SINT EXTERN CreateLutCRD(
|
||
|
|
* CHANDLE cp,
|
||
|
|
* SINT Index,
|
||
|
|
* MEMPTR lpMem,
|
||
|
|
* BOOL AllowBinary)
|
||
|
|
* parameters:
|
||
|
|
* cp -- Color Profile handle
|
||
|
|
* Index -- Index of the tag
|
||
|
|
* lpMem -- Pointer to the memory block
|
||
|
|
* AllowBinary -- 1: binary CRD allowed, 0: only ascii CRD allowed.
|
||
|
|
|
||
|
|
* returns:
|
||
|
|
* SINT -- !=0 if the function was successful,
|
||
|
|
* 0 otherwise.
|
||
|
|
* Returns number of bytes required/transferred
|
||
|
|
*/
|
||
|
|
|
||
|
|
SINT EXTERN
|
||
|
|
CreateLutCRD(CHANDLE cp, SINT Index, MEMPTR lpMem, DWORD InputIntent, BOOL AllowBinary)
|
||
|
|
{
|
||
|
|
SINT nInputCh, nOutputCh, nGrids;
|
||
|
|
SINT nInputTable, nOutputTable, nNumbers;
|
||
|
|
CSIG Tag, PCS;
|
||
|
|
CSIG IntentSig;
|
||
|
|
|
||
|
|
SINT Ret;
|
||
|
|
SINT i, j;
|
||
|
|
MEMPTR lpTable;
|
||
|
|
|
||
|
|
SFLOAT IlluminantWP[3];
|
||
|
|
SFLOAT MediaWP[3];
|
||
|
|
MEMPTR Buff = NULL;
|
||
|
|
SINT MemSize = 0;
|
||
|
|
MEMPTR lpOldMem = lpMem;
|
||
|
|
char PublicArrayName[TempBfSize];
|
||
|
|
HGLOBAL hMem;
|
||
|
|
MEMPTR lpLineStart;
|
||
|
|
// 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);
|
||
|
|
// Level 2 printers support only tri-component CIEBasedABC input,
|
||
|
|
// but can have either 3 or 4 output channels.
|
||
|
|
if (((nOutputCh != 3) &&
|
||
|
|
(nOutputCh != 4)) ||
|
||
|
|
(nInputCh != 3)) {
|
||
|
|
SetCPLastError(CP_POSTSCRIPT_ERR);
|
||
|
|
MemFree(hMem);
|
||
|
|
return (0);
|
||
|
|
}
|
||
|
|
Ret = nInputCh * nInputTable * 6 +
|
||
|
|
nOutputCh * nOutputTable * 6 + // Number of INT bytes
|
||
|
|
nOutputCh * nGrids * nGrids * nGrids * 2 + // LUT HEX bytes
|
||
|
|
nInputCh * (lstrlen(IndexArray) +
|
||
|
|
lstrlen(StartClip) +
|
||
|
|
lstrlen(EndClip)) +
|
||
|
|
nOutputCh * (lstrlen(IndexArray) +
|
||
|
|
lstrlen(StartClip) +
|
||
|
|
lstrlen(EndClip)) +
|
||
|
|
2048; // + other PS stuff
|
||
|
|
|
||
|
|
if (lpMem == NULL) // This is a size request
|
||
|
|
{
|
||
|
|
MemFree(hMem);
|
||
|
|
return (Ret);
|
||
|
|
}
|
||
|
|
// Get all necessary params from the header
|
||
|
|
// GetCPRenderIntent (cp, (LPCSIG) & Intent); // Get Intent
|
||
|
|
GetCPWhitePoint(cp, (LPSFLOAT)& IlluminantWP); // .. Illuminant
|
||
|
|
|
||
|
|
// Support absolute whitePoint
|
||
|
|
if (InputIntent == icAbsoluteColorimetric) {
|
||
|
|
if (!GetCPMediaWhitePoint(cp, (LPSFLOAT)& MediaWP)) // .. Media WhitePoint
|
||
|
|
{
|
||
|
|
MediaWP[0] = IlluminantWP[0];
|
||
|
|
MediaWP[1] = IlluminantWP[1];
|
||
|
|
MediaWP[2] = IlluminantWP[2];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//******** Define golbal array used in EncodeABC and RenderTaber
|
||
|
|
GetPublicArrayName(cp, IntentSig, PublicArrayName);
|
||
|
|
lpMem += WriteNewLineObject(lpMem, CRDBegin);
|
||
|
|
|
||
|
|
lpMem += EnableGlobalDict(lpMem);
|
||
|
|
lpMem += BeginGlobalDict(lpMem);
|
||
|
|
|
||
|
|
lpMem += CreateInputArray(lpMem, nInputCh, nInputTable,
|
||
|
|
(MEMPTR)PublicArrayName, Tag, Buff, AllowBinary, NULL);
|
||
|
|
|
||
|
|
i = nInputTable * nInputCh +
|
||
|
|
nGrids * nGrids * nGrids * nOutputCh;
|
||
|
|
lpMem += CreateOutputArray(lpMem, nOutputCh, nOutputTable, i,
|
||
|
|
(MEMPTR)PublicArrayName, Tag, Buff, AllowBinary, NULL);
|
||
|
|
|
||
|
|
lpMem += EndGlobalDict(lpMem);
|
||
|
|
|
||
|
|
//************* Start writing CRD ****************************
|
||
|
|
lpMem += WriteNewLineObject(lpMem, BeginDict); // Begin dictionary
|
||
|
|
lpMem += WriteObject(lpMem, DictType); // Dictionary type
|
||
|
|
|
||
|
|
lpMem += WriteNewLineObject(lpMem, IntentType); // RenderingIntent
|
||
|
|
switch (InputIntent) {
|
||
|
|
case icPerceptual:
|
||
|
|
lpMem += WriteObject(lpMem, IntentPer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icSaturation:
|
||
|
|
lpMem += WriteObject(lpMem, IntentSat);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icRelativeColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentRCol);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icAbsoluteColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentACol);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//********** Send Black/White Point.
|
||
|
|
lpMem += SendCRDBWPoint(lpMem, IlluminantWP);
|
||
|
|
|
||
|
|
//********** Send PQR - used for Absolute Colorimetric *****
|
||
|
|
lpMem += SendCRDPQR(lpMem, InputIntent, IlluminantWP);
|
||
|
|
|
||
|
|
//********** Send LMN - For Absolute Colorimetric use WhitePoint's XYZs
|
||
|
|
lpMem += SendCRDLMN(lpMem, InputIntent, IlluminantWP, MediaWP, PCS);
|
||
|
|
|
||
|
|
// ******** Create MatrixABC and EncodeABC stuff
|
||
|
|
lpMem += SendCRDABC(lpMem, PublicArrayName,
|
||
|
|
PCS, nInputCh, Buff, NULL, Tag, AllowBinary);
|
||
|
|
|
||
|
|
//********** /RenderTable
|
||
|
|
lpMem += WriteNewLineObject(lpMem, RenderTableTag);
|
||
|
|
lpMem += WriteObject(lpMem, BeginArray);
|
||
|
|
|
||
|
|
lpMem += WriteInt(lpMem, nGrids); // Send down Na
|
||
|
|
lpMem += WriteInt(lpMem, nGrids); // Send down Nb
|
||
|
|
lpMem += WriteInt(lpMem, nGrids); // Send down Nc
|
||
|
|
|
||
|
|
lpLineStart = lpMem;
|
||
|
|
lpMem += WriteNewLineObject(lpMem, BeginArray);
|
||
|
|
nNumbers = nGrids * nGrids * nOutputCh;
|
||
|
|
for (i = 0; i < nGrids; i++) // Na strings should be sent
|
||
|
|
{
|
||
|
|
lpMem += WriteObject(lpMem, NewLine);
|
||
|
|
lpLineStart = lpMem;
|
||
|
|
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 (!AllowBinary) // Output ASCII CRD
|
||
|
|
{
|
||
|
|
lpMem += WriteObject(lpMem, BeginString);
|
||
|
|
if (Tag == 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 CRD
|
||
|
|
lpMem += WriteStringToken(lpMem, 143, nNumbers);
|
||
|
|
if (Tag == icSigLut8Type)
|
||
|
|
lpMem += WriteByteString(lpMem, lpTable, nNumbers);
|
||
|
|
else
|
||
|
|
lpMem += WriteInt2ByteString(lpMem, lpTable, nNumbers);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
lpMem += WriteObject(lpMem, EndArray); // End array
|
||
|
|
lpMem += WriteInt(lpMem, nOutputCh); // Send down m
|
||
|
|
|
||
|
|
//********** Send Output Table.
|
||
|
|
lpMem += SendCRDOutputTable(lpMem, PublicArrayName,
|
||
|
|
nOutputCh, Tag, FALSE, AllowBinary);
|
||
|
|
|
||
|
|
lpMem += WriteObject(lpMem, EndArray); // End array
|
||
|
|
lpMem += WriteObject(lpMem, EndDict); // End dictionary definition
|
||
|
|
|
||
|
|
lpMem += WriteNewLineObject(lpMem, CRDEnd);
|
||
|
|
|
||
|
|
// Testing Convert binary to ascii
|
||
|
|
// i = ConvertBinaryData2Ascii(lpOldMem, (SINT)(lpMem - lpOldMem), Ret);
|
||
|
|
// lpMem = lpOldMem + i;
|
||
|
|
// Testing Convert binary to ascii
|
||
|
|
|
||
|
|
MemFree(hMem);
|
||
|
|
return ((SINT)((unsigned long)(lpMem - lpOldMem)));
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
* GetRevCurve
|
||
|
|
* function:
|
||
|
|
* prototype:
|
||
|
|
* BOOL GetRevCurve(
|
||
|
|
* MEMPTR Buff,
|
||
|
|
* MEMPTR lpRevCurve)
|
||
|
|
* parameters:
|
||
|
|
* Buff --
|
||
|
|
* lpRevCurve --
|
||
|
|
* returns:
|
||
|
|
* BOOL -- TRUE: successful,
|
||
|
|
* FALSE: otherwise.
|
||
|
|
*/
|
||
|
|
|
||
|
|
BOOL
|
||
|
|
GetRevCurve(MEMPTR lpBuff, MEMPTR lpCurve, MEMPTR lpRevCurve)
|
||
|
|
{
|
||
|
|
SINT i, j, nCount;
|
||
|
|
MEMPTR lpTable;
|
||
|
|
PUSHORT lpInput, lpOutput;
|
||
|
|
SFLOAT fTemp;
|
||
|
|
SINT iBegin, iEnd, iTemp;
|
||
|
|
nCount = ui32toSINT(((lpcpCurveType)lpBuff)->curve.count);
|
||
|
|
lpTable = (MEMPTR)(((lpcpCurveType)lpBuff)->curve.data);
|
||
|
|
lpOutput = (PUSHORT)lpRevCurve;
|
||
|
|
lpInput = (PUSHORT)lpCurve;
|
||
|
|
|
||
|
|
for (i = 0; i < nCount; i++) {
|
||
|
|
lpInput[i] = (USHORT)(ui16toSINT(lpTable));
|
||
|
|
lpTable += sizeof(icUInt16Number);
|
||
|
|
}
|
||
|
|
|
||
|
|
j = nCount * REVCURVE_RATIO;
|
||
|
|
for (i = 0; i < j; i++) {
|
||
|
|
fTemp = (SFLOAT)i * 65535 / (j - 1);
|
||
|
|
lpOutput[i] = (fTemp < 65535) ? (USHORT)fTemp : (USHORT)65535;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < j; i++) {
|
||
|
|
iBegin = 0;
|
||
|
|
iEnd = nCount - 1;
|
||
|
|
for (;;) {
|
||
|
|
if ((iEnd - iBegin) <= 1)
|
||
|
|
break;
|
||
|
|
iTemp = (iEnd + iBegin) / 2;
|
||
|
|
if (lpOutput[i] < lpInput[iTemp])
|
||
|
|
iEnd = iTemp;
|
||
|
|
else
|
||
|
|
iBegin = iTemp;
|
||
|
|
}
|
||
|
|
if (lpOutput[i] <= lpInput[iBegin])
|
||
|
|
fTemp = (SFLOAT)iBegin;
|
||
|
|
else if (lpOutput[i] >= lpInput[iEnd])
|
||
|
|
fTemp = (SFLOAT)iEnd;
|
||
|
|
else {
|
||
|
|
fTemp = ((SFLOAT)(lpInput[iEnd] - lpOutput[i])) /
|
||
|
|
(lpOutput[i] - lpInput[iBegin]);
|
||
|
|
fTemp = (iBegin * fTemp + iEnd) / (fTemp + 1);
|
||
|
|
}
|
||
|
|
fTemp = (fTemp / (nCount - 1)) * 65535;
|
||
|
|
lpOutput[i] = (fTemp < 65535) ? (USHORT)fTemp : (USHORT)65535;
|
||
|
|
}
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
* CreateMonoCRD
|
||
|
|
* function:
|
||
|
|
* this is the function which creates the Color Rendering Dictionary (CRD)
|
||
|
|
* from the data supplied in the GrayTRC tag.
|
||
|
|
* prototype:
|
||
|
|
* BOOL EXTERN CreateMonoCRD(
|
||
|
|
* CHANDLE cp,
|
||
|
|
* SINT Index,
|
||
|
|
* MEMPTR lpMem)
|
||
|
|
* parameters:
|
||
|
|
* cp -- Color Profile handle
|
||
|
|
* Index -- Index of the tag
|
||
|
|
* lpMem -- Pointer to the memory block
|
||
|
|
* returns:
|
||
|
|
* SINT -- !=0 if the function was successful,
|
||
|
|
* 0 otherwise.
|
||
|
|
* Returns number of bytes required/transferred
|
||
|
|
*/
|
||
|
|
// According to the spec this tag-based function only converts from
|
||
|
|
// Device to PCS, so we need to create an inverse function to perform
|
||
|
|
// PCS->device conversion. By definition the CRD is only
|
||
|
|
// for XYZ->DeviceRGB/CMYK conversion.
|
||
|
|
SINT EXTERN
|
||
|
|
CreateMonoCRD(CHANDLE cp, SINT Index, MEMPTR lpMem, DWORD InputIntent)
|
||
|
|
{
|
||
|
|
SINT nCount;
|
||
|
|
CSIG Tag, PCS;
|
||
|
|
|
||
|
|
MEMPTR Buff = NULL;
|
||
|
|
SINT MemSize = 0;
|
||
|
|
MEMPTR lpOldMem = lpMem;
|
||
|
|
MEMPTR lpCurve, lpRevCurve;
|
||
|
|
HGLOBAL hRevCurve;
|
||
|
|
SINT Ret = 0;
|
||
|
|
HGLOBAL hMem;
|
||
|
|
SINT i;
|
||
|
|
MEMPTR lpTable;
|
||
|
|
SFLOAT IlluminantWP[3];
|
||
|
|
SFLOAT MediaWP[3];
|
||
|
|
MEMPTR lpLineStart;
|
||
|
|
// Check if we can generate the CRD
|
||
|
|
if (!GetCPElementType(cp, Index, (LPCSIG)& Tag) ||
|
||
|
|
(Tag != icSigCurveType) ||
|
||
|
|
!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);
|
||
|
|
}
|
||
|
|
nCount = ui32toSINT(((lpcpCurveType)Buff)->curve.count);
|
||
|
|
|
||
|
|
// Estimate the memory size required to hold CRD
|
||
|
|
// SRGB98
|
||
|
|
Ret = nCount * 6 * REVCURVE_RATIO + // Number of INT elements
|
||
|
|
2048; // + other PS stuff
|
||
|
|
if (lpMem == NULL) // This is a size request
|
||
|
|
{
|
||
|
|
MemFree(hMem);
|
||
|
|
return (Ret);
|
||
|
|
}
|
||
|
|
if (!MemAlloc(nCount * 2 * (REVCURVE_RATIO + 1),
|
||
|
|
(HGLOBAL FAR *) &hRevCurve, (LPMEMPTR)& lpRevCurve)) {
|
||
|
|
MemFree(hMem);
|
||
|
|
return (FALSE);
|
||
|
|
}
|
||
|
|
lpCurve = lpRevCurve + 2 * REVCURVE_RATIO * nCount;
|
||
|
|
GetRevCurve(Buff, lpCurve, lpRevCurve);
|
||
|
|
|
||
|
|
// GetCPCMMType (cp, (LPCSIG) & Intent); // Get Intent
|
||
|
|
GetCPWhitePoint(cp, (LPSFLOAT)& IlluminantWP); // .. Illuminant
|
||
|
|
|
||
|
|
// Support absolute whitePoint
|
||
|
|
if (InputIntent == icAbsoluteColorimetric) {
|
||
|
|
if (!GetCPMediaWhitePoint(cp, (LPSFLOAT)& MediaWP)) // .. Media WhitePoint
|
||
|
|
{
|
||
|
|
MediaWP[0] = IlluminantWP[0];
|
||
|
|
MediaWP[1] = IlluminantWP[1];
|
||
|
|
MediaWP[2] = IlluminantWP[2];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//************* Start writing CRD ****************************
|
||
|
|
lpMem += WriteNewLineObject(lpMem, BeginDict); // Begin dictionary
|
||
|
|
lpMem += WriteObject(lpMem, DictType); // Dictionary type
|
||
|
|
|
||
|
|
lpMem += WriteNewLineObject(lpMem, IntentType); // RenderingIntent
|
||
|
|
switch (InputIntent) {
|
||
|
|
case icPerceptual:
|
||
|
|
lpMem += WriteObject(lpMem, IntentPer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icSaturation:
|
||
|
|
lpMem += WriteObject(lpMem, IntentSat);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icRelativeColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentRCol);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icAbsoluteColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentACol);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//********** Send Black/White Point.
|
||
|
|
lpMem += SendCRDBWPoint(lpMem, IlluminantWP);
|
||
|
|
|
||
|
|
//********** /TransformPQR
|
||
|
|
lpMem += SendCRDPQR(lpMem, InputIntent, IlluminantWP);
|
||
|
|
|
||
|
|
//********** /MatrixLMN
|
||
|
|
lpMem += SendCRDLMN(lpMem, InputIntent, IlluminantWP, MediaWP, PCS);
|
||
|
|
|
||
|
|
//********** /MatrixABC
|
||
|
|
if (PCS == icSigXYZData) { // Switch ABC to BAC, since we want to output B which is converted from Y.
|
||
|
|
lpMem += WriteNewLineObject(lpMem, MatrixABCTag);
|
||
|
|
lpMem += WriteObject(lpMem, MatrixABCXYZCRD);
|
||
|
|
} else if (PCS == icSigLabData) {
|
||
|
|
lpMem += WriteNewLineObject(lpMem, MatrixABCTag);
|
||
|
|
lpMem += WriteObject(lpMem, MatrixABCLabCRD);
|
||
|
|
}
|
||
|
|
//********** /EncodeABC
|
||
|
|
if (nCount != 0) {
|
||
|
|
lpMem += WriteObject(lpMem, NewLine);
|
||
|
|
lpLineStart = lpMem;
|
||
|
|
lpMem += WriteObject(lpMem, EncodeABCTag);
|
||
|
|
lpMem += WriteObject(lpMem, BeginArray);
|
||
|
|
lpMem += WriteObject(lpMem, BeginFunction);
|
||
|
|
if (nCount == 1) // Gamma supplied in ui16 format
|
||
|
|
{
|
||
|
|
lpTable = (MEMPTR)(((lpcpCurveType)Buff)->curve.data);
|
||
|
|
lpMem += WriteInt(lpMem, ui16toSINT(lpTable));
|
||
|
|
lpMem += WriteObject(lpMem, DecodeA3Rev);
|
||
|
|
} else {
|
||
|
|
if (PCS == icSigLabData) {
|
||
|
|
lpMem += WriteObject(lpMem, EncodeABCLab1);
|
||
|
|
}
|
||
|
|
lpMem += WriteObject(lpMem, StartClip);
|
||
|
|
lpMem += WriteObject(lpMem, BeginArray);
|
||
|
|
for (i = 0; i < nCount * REVCURVE_RATIO; i++) {
|
||
|
|
lpMem += WriteInt(lpMem, (SINT)(*((PUSHORT)lpRevCurve)));
|
||
|
|
lpRevCurve += sizeof(icUInt16Number);
|
||
|
|
if (((SINT)(lpMem - lpLineStart)) > MAX_LINELENG) {
|
||
|
|
lpLineStart = lpMem;
|
||
|
|
lpMem += WriteObject(lpMem, NewLine);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
lpMem += WriteObject(lpMem, EndArray);
|
||
|
|
lpLineStart = lpMem;
|
||
|
|
lpMem += WriteNewLineObject(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);
|
||
|
|
}
|
||
|
|
lpMem += WriteObject(lpMem, EndDict); // End dictionary definition
|
||
|
|
|
||
|
|
MemFree(hRevCurve);
|
||
|
|
MemFree(hMem);
|
||
|
|
return ((SINT)((unsigned long)(lpMem - lpOldMem)));
|
||
|
|
}
|
||
|
|
|
||
|
|
// SRGB98 start
|
||
|
|
BOOL
|
||
|
|
GetTRCElementSize(CHANDLE cp, CSIG icSigXTRCTag, LPSINT pIndex, LPSINT pTRCSize)
|
||
|
|
{
|
||
|
|
CSIG Tag;
|
||
|
|
|
||
|
|
if (!GetCPTagIndex(cp, icSigXTRCTag, (LPSINT)pIndex) ||
|
||
|
|
!GetCPElementType(cp, *pIndex, (LPCSIG)& Tag) ||
|
||
|
|
!(Tag == icSigCurveType) ||
|
||
|
|
!GetCPElementSize(cp, *pIndex, (LPSINT)pTRCSize)) {
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL
|
||
|
|
DoesTRCAndColorantTagExist(CHANDLE cp)
|
||
|
|
{
|
||
|
|
if (DoesCPTagExist(cp, icSigRedColorantTag) &&
|
||
|
|
DoesCPTagExist(cp, icSigRedTRCTag) &&
|
||
|
|
DoesCPTagExist(cp, icSigGreenColorantTag) &&
|
||
|
|
DoesCPTagExist(cp, icSigGreenTRCTag) &&
|
||
|
|
DoesCPTagExist(cp, icSigBlueColorantTag) &&
|
||
|
|
DoesCPTagExist(cp, icSigBlueTRCTag)) {
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
static SINT
|
||
|
|
CreateRevArray(CHANDLE cp, MEMPTR lpMem, MEMPTR lpBuff,
|
||
|
|
MEMPTR lpRevCurve, CSIG CPTag, BOOL AllowBinary)
|
||
|
|
{
|
||
|
|
SINT i, nCount;
|
||
|
|
SINT MemSize = 0;
|
||
|
|
MEMPTR lpOldMem, lpLineStart;
|
||
|
|
MEMPTR lpCurve;
|
||
|
|
|
||
|
|
lpOldMem = lpMem;
|
||
|
|
|
||
|
|
lpLineStart = lpMem;
|
||
|
|
nCount = ui32toSINT(((lpcpCurveType)lpBuff)->curve.count);
|
||
|
|
if (nCount > 1) {
|
||
|
|
lpMem += WriteNewLineObject(lpMem, Slash);
|
||
|
|
lpMem += WriteObject(lpMem, InputArray);
|
||
|
|
lpMem += WriteInt(lpMem, (SINT)CPTag);
|
||
|
|
|
||
|
|
lpCurve = lpRevCurve + 2 * REVCURVE_RATIO * nCount;
|
||
|
|
GetRevCurve(lpBuff, lpCurve, lpRevCurve);
|
||
|
|
|
||
|
|
if (!AllowBinary) // Output ASCII DATA
|
||
|
|
{
|
||
|
|
lpMem += WriteObject(lpMem, BeginArray);
|
||
|
|
for (i = 0; i < nCount * REVCURVE_RATIO; i++) {
|
||
|
|
lpMem += WriteInt(lpMem, (SINT)(*((PUSHORT)lpRevCurve)));
|
||
|
|
lpRevCurve += sizeof(icUInt16Number);
|
||
|
|
if (((SINT)(lpMem - lpLineStart)) > MAX_LINELENG) {
|
||
|
|
lpLineStart = lpMem;
|
||
|
|
lpMem += WriteObject(lpMem, NewLine);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
lpMem += WriteObject(lpMem, EndArray);
|
||
|
|
} else { // Output BINARY DATA
|
||
|
|
lpMem += WriteHNAToken(lpMem, 149, nCount);
|
||
|
|
lpMem += WriteIntStringU2S_L(lpMem, lpRevCurve, nCount);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
lpMem += WriteObject(lpMem, DefOp);
|
||
|
|
return ((SINT)(lpMem - lpOldMem));
|
||
|
|
}
|
||
|
|
|
||
|
|
static SINT
|
||
|
|
SendRevArray(CHANDLE cp, MEMPTR lpMem, MEMPTR lpBuff,
|
||
|
|
CSIG CPTag, BOOL AllowBinary)
|
||
|
|
{
|
||
|
|
SINT nCount;
|
||
|
|
MEMPTR lpOldMem;
|
||
|
|
MEMPTR lpTable;
|
||
|
|
|
||
|
|
lpOldMem = lpMem;
|
||
|
|
lpMem += WriteObject(lpMem, BeginFunction);
|
||
|
|
nCount = ui32toSINT(((lpcpCurveType)lpBuff)->curve.count);
|
||
|
|
if (nCount != 0) {
|
||
|
|
if (nCount == 1) // Gamma supplied in ui16 format
|
||
|
|
{
|
||
|
|
lpTable = (MEMPTR)(((lpcpCurveType)lpBuff)->curve.data);
|
||
|
|
lpMem += WriteInt(lpMem, ui16toSINT(lpTable));
|
||
|
|
lpMem += WriteObject(lpMem, DecodeA3Rev);
|
||
|
|
} else {
|
||
|
|
lpMem += WriteObject(lpMem, StartClip);
|
||
|
|
lpMem += WriteObject(lpMem, InputArray);
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
lpMem += WriteObject(lpMem, EndFunction);
|
||
|
|
return ((SINT)(lpMem - lpOldMem));
|
||
|
|
}
|
||
|
|
|
||
|
|
SINT
|
||
|
|
CreateColorantArray(CHANDLE cp, double FAR *lpArray, CSIG CPTag)
|
||
|
|
{
|
||
|
|
SINT i, Index;
|
||
|
|
MEMPTR lpTable;
|
||
|
|
MEMPTR Buff = NULL;
|
||
|
|
SINT MemSize = 0;
|
||
|
|
HGLOBAL hBuff;
|
||
|
|
|
||
|
|
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++) {
|
||
|
|
*lpArray++ = (SFLOAT)si16f16toSFLOAT(lpTable);
|
||
|
|
lpTable += sizeof(icS15Fixed16Number);
|
||
|
|
}
|
||
|
|
MemFree(hBuff);
|
||
|
|
}
|
||
|
|
return (TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* IsSRGB
|
||
|
|
* function: check if the profile is sRGB
|
||
|
|
|
||
|
|
* parameters:
|
||
|
|
* cp -- Color Profile handle
|
||
|
|
|
||
|
|
* returns:
|
||
|
|
* BOOL -- TRUE if the profile is sRGB
|
||
|
|
* FALSE otherwise.
|
||
|
|
*/
|
||
|
|
BOOL FAR IsSRGB(CHANDLE cp)
|
||
|
|
{
|
||
|
|
BOOL match = FALSE;
|
||
|
|
SINT RedTRCIndex, GreenTRCIndex, BlueTRCIndex, RedCIndex, GreenCIndex, BlueCIndex;
|
||
|
|
SINT MemSize;
|
||
|
|
SINT RedTRCSize = 0, GreenTRCSize = 0, BlueTRCSize = 0, RedCSize = 0, GreenCSize = 0, BlueCSize = 0;
|
||
|
|
HGLOBAL hMem;
|
||
|
|
MEMPTR lpRed = NULL, lpGreen, lpBlue, lpRedC, lpGreenC, lpBlueC;
|
||
|
|
DWORD crc;
|
||
|
|
|
||
|
|
if (GetCPTagIndex(cp, icSigRedTRCTag, &RedTRCIndex) &&
|
||
|
|
GetCPElementSize(cp, RedTRCIndex, &RedTRCSize) &&
|
||
|
|
|
||
|
|
GetCPTagIndex(cp, icSigGreenTRCTag, &GreenTRCIndex) &&
|
||
|
|
GetCPElementSize(cp, GreenTRCIndex, &GreenTRCSize) &&
|
||
|
|
|
||
|
|
GetCPTagIndex(cp, icSigBlueTRCTag, &BlueTRCIndex) &&
|
||
|
|
GetCPElementSize(cp, BlueTRCIndex, &BlueTRCSize) &&
|
||
|
|
|
||
|
|
GetCPTagIndex(cp, icSigRedColorantTag, &RedCIndex) &&
|
||
|
|
GetCPElementSize(cp, RedCIndex, &RedCSize) &&
|
||
|
|
|
||
|
|
GetCPTagIndex(cp, icSigGreenColorantTag, &GreenCIndex) &&
|
||
|
|
GetCPElementSize(cp, GreenCIndex, &GreenCSize) &&
|
||
|
|
|
||
|
|
GetCPTagIndex(cp, icSigBlueColorantTag, &BlueCIndex) &&
|
||
|
|
GetCPElementSize(cp, BlueCIndex, &BlueCSize)) {
|
||
|
|
MemSize = RedTRCSize + GreenTRCSize + BlueTRCSize + RedCSize + GreenCSize + BlueCSize;
|
||
|
|
|
||
|
|
if ((MemSize == 6240) && // #bytes in sRGBColorTags
|
||
|
|
MemAlloc(MemSize, (HGLOBAL FAR *)&hMem, (LPMEMPTR)&lpRed)) {
|
||
|
|
lpGreen = lpRed + RedTRCSize;
|
||
|
|
lpBlue = lpGreen + GreenTRCSize;
|
||
|
|
lpRedC = lpBlue + BlueTRCSize;
|
||
|
|
lpGreenC = lpRedC + RedCSize;
|
||
|
|
lpBlueC = lpGreenC + GreenCSize;
|
||
|
|
|
||
|
|
if (GetCPElement(cp, RedTRCIndex, lpRed, RedTRCSize) &&
|
||
|
|
GetCPElement(cp, GreenTRCIndex, lpGreen, GreenTRCSize) &&
|
||
|
|
GetCPElement(cp, BlueTRCIndex, lpBlue, BlueTRCSize) &&
|
||
|
|
GetCPElement(cp, RedCIndex, lpRedC, RedCSize) &&
|
||
|
|
GetCPElement(cp, GreenCIndex, lpGreenC, GreenCSize) &&
|
||
|
|
GetCPElement(cp, BlueCIndex, lpBlueC, BlueCSize)) {
|
||
|
|
crc = crc32(lpRed, 6240);
|
||
|
|
match = (crc == SRGBCRC);
|
||
|
|
}
|
||
|
|
MemFree(hMem);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return (match);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CreateMatrixCRD
|
||
|
|
* function:
|
||
|
|
* this is the function which creates the Color Rendering Dictionary (CRD)
|
||
|
|
* from the data supplied in the redTRC, greenTRC, blueTRA, redColorant,
|
||
|
|
* greenColorant and BlueColorant tags
|
||
|
|
* prototype:
|
||
|
|
* BOOL EXTERN CreateMatrixCRD(
|
||
|
|
* CHANDLE cp,
|
||
|
|
* MEMPTR lpMem,
|
||
|
|
* BOOL AllowBinary)
|
||
|
|
* parameters:
|
||
|
|
* cp -- Color Profile handle
|
||
|
|
* lpMem -- Pointer to the memory block
|
||
|
|
* AllowBinary --
|
||
|
|
* returns:
|
||
|
|
* SINT -- !=0 if the function was successful,
|
||
|
|
* 0 otherwise.
|
||
|
|
* Returns number of bytes required/transferred
|
||
|
|
*/
|
||
|
|
// With matrix/TRC model, only the CIEXYZ encoding of the PCS can be used.
|
||
|
|
// So, we don't need to worry about CIELAB.
|
||
|
|
SINT EXTERN
|
||
|
|
CreateMatrixCRD(CHANDLE cp, MEMPTR lpMem, DWORD InputIntent, BOOL AllowBinary)
|
||
|
|
{
|
||
|
|
SINT RedTRCIndex, GreenTRCIndex, BlueTRCIndex;
|
||
|
|
SINT i, MemSize;
|
||
|
|
SINT nRedCount, nGreenCount, nBlueCount;
|
||
|
|
MEMPTR lpRed = NULL, lpGreen, lpBlue;
|
||
|
|
SINT RedTRCSize = 0, GreenTRCSize = 0, BlueTRCSize = 0;
|
||
|
|
MEMPTR lpOldMem = lpMem;
|
||
|
|
MEMPTR lpRevCurve;
|
||
|
|
HGLOBAL hRevCurve;
|
||
|
|
SINT Ret = 0;
|
||
|
|
HGLOBAL hMem;
|
||
|
|
SFLOAT IlluminantWP[3];
|
||
|
|
double Colorant[9];
|
||
|
|
double RevColorant[9];
|
||
|
|
|
||
|
|
// Check if we can generate the CRD
|
||
|
|
if (!GetTRCElementSize(cp, icSigRedTRCTag, &RedTRCIndex, &RedTRCSize) ||
|
||
|
|
!GetTRCElementSize(cp, icSigGreenTRCTag, &GreenTRCIndex, &GreenTRCSize) ||
|
||
|
|
!GetTRCElementSize(cp, icSigBlueTRCTag, &BlueTRCIndex, &BlueTRCSize)) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
MemSize = RedTRCSize + GreenTRCSize + BlueTRCSize;
|
||
|
|
if (!MemAlloc(MemSize, (HGLOBAL FAR *)&hMem, (LPMEMPTR)& lpRed))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
lpGreen = lpRed + RedTRCSize;
|
||
|
|
lpBlue = lpGreen + GreenTRCSize;
|
||
|
|
if (!GetCPElement(cp, RedTRCIndex, lpRed, RedTRCSize) ||
|
||
|
|
!GetCPElement(cp, GreenTRCIndex, lpGreen, GreenTRCSize) ||
|
||
|
|
!GetCPElement(cp, BlueTRCIndex, lpBlue, BlueTRCSize)) {
|
||
|
|
MemFree(hMem);
|
||
|
|
return (0);
|
||
|
|
}
|
||
|
|
nRedCount = ui32toSINT(((lpcpCurveType)lpRed)->curve.count);
|
||
|
|
nGreenCount = ui32toSINT(((lpcpCurveType)lpGreen)->curve.count);
|
||
|
|
nBlueCount = ui32toSINT(((lpcpCurveType)lpBlue)->curve.count);
|
||
|
|
|
||
|
|
// Estimate the memory size required to hold CRD
|
||
|
|
Ret = (nRedCount + nGreenCount + nBlueCount) * 6 * REVCURVE_RATIO +
|
||
|
|
2048; // Number of INT elements + other PS stuff
|
||
|
|
if (lpMem == NULL) // This is a size request
|
||
|
|
{
|
||
|
|
MemFree(hMem);
|
||
|
|
return (Ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!MemAlloc(nRedCount * 2 * (REVCURVE_RATIO + 1),
|
||
|
|
(HGLOBAL FAR *) &hRevCurve, (LPMEMPTR)& lpRevCurve)) {
|
||
|
|
MemFree(hMem);
|
||
|
|
return (0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (IsSRGB(cp)) {
|
||
|
|
lpMem += WriteNewLineObject(lpMem, CRDBegin);
|
||
|
|
lpMem += WriteNewLineObject(lpMem, BeginDict); // Begin dictionary
|
||
|
|
lpMem += WriteObject(lpMem, DictType); // Dictionary type
|
||
|
|
lpMem += WriteNewLineObject(lpMem, IntentType); // RenderingIntent
|
||
|
|
switch (InputIntent) {
|
||
|
|
case icPerceptual:
|
||
|
|
lpMem += WriteObject(lpMem, IntentPer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icSaturation:
|
||
|
|
lpMem += WriteObject(lpMem, IntentSat);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icRelativeColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentRCol);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icAbsoluteColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentACol);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
lpMem += WriteNewLineObject(lpMem, AdobeCRD);
|
||
|
|
lpMem += WriteNewLineObject(lpMem, CRDEnd);
|
||
|
|
} else {
|
||
|
|
lpMem += EnableGlobalDict(lpMem);
|
||
|
|
lpMem += BeginGlobalDict(lpMem);
|
||
|
|
|
||
|
|
lpMem += CreateRevArray(cp, lpMem, lpRed, lpRevCurve, icSigRedTRCTag, AllowBinary);
|
||
|
|
lpMem += CreateRevArray(cp, lpMem, lpGreen, lpRevCurve, icSigGreenTRCTag, AllowBinary);
|
||
|
|
lpMem += CreateRevArray(cp, lpMem, lpBlue, lpRevCurve, icSigBlueTRCTag, AllowBinary);
|
||
|
|
|
||
|
|
lpMem += EndGlobalDict(lpMem);
|
||
|
|
|
||
|
|
// GetCPCMMType (cp, (LPCSIG) & Intent); // Get Intent
|
||
|
|
GetCPWhitePoint(cp, (LPSFLOAT)& IlluminantWP); // .. Illuminant
|
||
|
|
|
||
|
|
//************* Start writing CRD ****************************
|
||
|
|
lpMem += WriteNewLineObject(lpMem, CRDBegin);
|
||
|
|
|
||
|
|
lpMem += WriteNewLineObject(lpMem, BeginDict); // Begin dictionary
|
||
|
|
lpMem += WriteObject(lpMem, DictType); // Dictionary type
|
||
|
|
|
||
|
|
lpMem += WriteNewLineObject(lpMem, IntentType); // RenderingIntent
|
||
|
|
switch (InputIntent) {
|
||
|
|
case icPerceptual:
|
||
|
|
lpMem += WriteObject(lpMem, IntentPer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icSaturation:
|
||
|
|
lpMem += WriteObject(lpMem, IntentSat);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icRelativeColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentRCol);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icAbsoluteColorimetric:
|
||
|
|
lpMem += WriteObject(lpMem, IntentACol);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//********** Send Black/White Point.
|
||
|
|
lpMem += SendCRDBWPoint(lpMem, IlluminantWP);
|
||
|
|
|
||
|
|
//********** /TransformPQR
|
||
|
|
lpMem += SendCRDPQR(lpMem, InputIntent, IlluminantWP);
|
||
|
|
|
||
|
|
//********** /MatrixLMN
|
||
|
|
CreateColorantArray(cp, &Colorant[0], icSigRedColorantTag);
|
||
|
|
CreateColorantArray(cp, &Colorant[3], icSigGreenColorantTag);
|
||
|
|
CreateColorantArray(cp, &Colorant[6], icSigBlueColorantTag);
|
||
|
|
InvertMatrix(Colorant, RevColorant);
|
||
|
|
|
||
|
|
lpMem += WriteNewLineObject(lpMem, MatrixLMNTag);
|
||
|
|
|
||
|
|
lpMem += WriteObject(lpMem, BeginArray);
|
||
|
|
for (i = 0; i < 9; i++) {
|
||
|
|
lpMem += WriteFloat(lpMem, (SFLOAT)RevColorant[i]);
|
||
|
|
}
|
||
|
|
lpMem += WriteObject(lpMem, EndArray);
|
||
|
|
|
||
|
|
//********** /EncodeABC
|
||
|
|
lpMem += WriteNewLineObject(lpMem, EncodeABCTag);
|
||
|
|
lpMem += WriteObject(lpMem, BeginArray);
|
||
|
|
|
||
|
|
lpMem += WriteObject(lpMem, NewLine);
|
||
|
|
lpMem += SendRevArray(cp, lpMem, lpRed, icSigRedTRCTag, AllowBinary);
|
||
|
|
lpMem += WriteObject(lpMem, NewLine);
|
||
|
|
lpMem += SendRevArray(cp, lpMem, lpGreen, icSigGreenTRCTag, AllowBinary);
|
||
|
|
lpMem += WriteObject(lpMem, NewLine);
|
||
|
|
lpMem += SendRevArray(cp, lpMem, lpBlue, icSigBlueTRCTag, AllowBinary);
|
||
|
|
lpMem += WriteNewLineObject(lpMem, EndArray);
|
||
|
|
|
||
|
|
lpMem += WriteObject(lpMem, EndDict); // End dictionary definition
|
||
|
|
|
||
|
|
lpMem += WriteNewLineObject(lpMem, CRDEnd);
|
||
|
|
}
|
||
|
|
MemFree(hRevCurve);
|
||
|
|
MemFree(hMem);
|
||
|
|
return ((SINT)((unsigned long)(lpMem - lpOldMem)));
|
||
|
|
}
|
||
|
|
// SRGB98 End
|
||
|
|
|
||
|
|
BOOL EXTERN
|
||
|
|
GetPS2ColorRenderingDictionary(
|
||
|
|
CHANDLE cp,
|
||
|
|
DWORD Intent,
|
||
|
|
MEMPTR lpMem,
|
||
|
|
LPDWORD lpcbSize,
|
||
|
|
BOOL AllowBinary)
|
||
|
|
{
|
||
|
|
SINT Index;
|
||
|
|
SINT Ret, Size;
|
||
|
|
CSIG icSigPs2CRDx, icSigBToAx;
|
||
|
|
|
||
|
|
if (!cp)
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
if ((lpMem == NULL) || (*lpcbSize == 0)) {
|
||
|
|
lpMem = NULL;
|
||
|
|
*lpcbSize = 0;
|
||
|
|
}
|
||
|
|
Ret = 0;
|
||
|
|
Size = (SINT)* lpcbSize;
|
||
|
|
|
||
|
|
switch (Intent) {
|
||
|
|
case icPerceptual:
|
||
|
|
icSigPs2CRDx = icSigPs2CRD0Tag;
|
||
|
|
icSigBToAx = icSigBToA0Tag;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icRelativeColorimetric:
|
||
|
|
icSigPs2CRDx = icSigPs2CRD1Tag;
|
||
|
|
icSigBToAx = icSigBToA1Tag;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icSaturation:
|
||
|
|
icSigPs2CRDx = icSigPs2CRD2Tag;
|
||
|
|
icSigBToAx = icSigBToA2Tag;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case icAbsoluteColorimetric:
|
||
|
|
icSigPs2CRDx = icSigPs2CRD3Tag;
|
||
|
|
icSigBToAx = icSigBToA1Tag;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
*lpcbSize = (DWORD)Ret;
|
||
|
|
return (Ret > 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (
|
||
|
|
(DoesCPTagExist(cp, icSigPs2CRDx) &&
|
||
|
|
GetCPTagIndex(cp, icSigPs2CRDx, (LPSINT)& Index) &&
|
||
|
|
GetCPElementDataSize(cp, Index, (LPSINT)& Ret) &&
|
||
|
|
((Size == 0) ||
|
||
|
|
GetCPElementData(cp, Index, lpMem, Size)) &&
|
||
|
|
(Ret = Convert2Ascii(cp, Index, lpMem, Size, Ret, AllowBinary))
|
||
|
|
) ||
|
||
|
|
(DoesCPTagExist(cp, icSigBToAx) &&
|
||
|
|
GetCPTagIndex(cp, icSigBToAx, (LPSINT)& Index) &&
|
||
|
|
(Ret = CreateLutCRD(cp, Index, lpMem, Intent, AllowBinary))
|
||
|
|
) ||
|
||
|
|
// SRGB98 Support Windows 98 sRGB icc profile.
|
||
|
|
// Create CRD from TRC and Colorant Tags.
|
||
|
|
(DoesTRCAndColorantTagExist(cp) &&
|
||
|
|
(Ret = CreateMatrixCRD(cp, lpMem, Intent, AllowBinary))
|
||
|
|
) ||
|
||
|
|
(DoesCPTagExist(cp, icSigGrayTRCTag) &&
|
||
|
|
GetCPTagIndex(cp, icSigGrayTRCTag, (LPSINT)& Index) &&
|
||
|
|
(Ret = CreateMonoCRD(cp, Index, lpMem, Intent))
|
||
|
|
)
|
||
|
|
) {
|
||
|
|
}
|
||
|
|
|
||
|
|
*lpcbSize = (DWORD)Ret;
|
||
|
|
return (Ret > 0);
|
||
|
|
}
|