test: dec97/dll32/getcsa.c File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# getcsa.c File Reference

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

Go to the source code of this file.

## Defines

#define | ICMSEG

## Functions

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)
SINT | SendCSABWPoint (MEMPTR lpMem, CSIG Intent, LPSFLOAT IlluminantWP, LPSFLOAT MediaWP)
void | GetMediaWP (CHANDLE cp, CSIG InputIntent, LPSFLOAT IlluminantWP, LPSFLOAT MediaWP)
BOOL | GetDeviceRGB (MEMPTR lpMem, LPDWORD lpcbSize, DWORD InpDrvClrSp)
BOOL | GetDeviceCMYK (MEMPTR lpMem, LPDWORD lpcbSize, DWORD InpDrvClrSp)
BOOL | GetDeviceGray (MEMPTR lpMem, LPDWORD lpcbSize, DWORD InpDrvClrSp)
SINT | GetPublicArrayName (CHANDLE cp, CSIG IntentSig, MEMPTR PublicArrayName)
SINT | EnableGlobalDict (MEMPTR lpMem)
BOOL | GetPS2CSA_DEFG (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, CSIG InputIntent, SINT Index, int Type, BOOL AllowBinary)
BOOL | GetPS2CSA_ABC (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, CSIG InputIntent, DWORD InpDrvClrSp, BOOL AllowBinary)
BOOL | GetPS2CSA_ABC_LAB (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, CSIG InputIntent, DWORD InpDrvClrSp, BOOL AllowBinary)
BOOL | GetPS2CSA_MONO_ABC (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, CSIG InputIntent, BOOL AllowBinary)
BOOL | GetPS2CSA_MONO_A (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, CSIG InputIntent, BOOL AllowBinary)
BOOL | GetPS2CSA_MONO (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, DWORD InpDrvClrSp, CSIG InputIntent, BOOL AllowBinary)
BOOL | GetCSAFromProfile (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, DWORD InpDrvClrSp, CSIG DrvColorSpace, BOOL AllowBinary)
BOOL | GetPS2CSA_DEFG_Intent (CHANDLE cp, MEMPTR lpBuffer, LPDWORD lpcbSize, DWORD InpDrvClrSp, CSIG Intent, int Type, BOOL AllowBinary)
BOOL EXTERN | GetPS2ColorSpaceArray (CHANDLE cp, DWORD InputIntent, DWORD InpDrvClrSp, MEMPTR lpBuffer, LPDWORD lpcbSize, BOOL AllowBinary)

## Variables

char * | DecodeABCLab []

## Define Documentation

#define ICMSEG

## Function Documentation

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
| ) |

SINT EnableGlobalDict | ( | MEMPTR | lpMem | ) |

Definition at line 199 of file dec97/dll32/getcsa.c.

References BeginOp, CurrentGlobalOp, GlobalDictOp, MEMPTR, NewLine, SetGlobalOp, SINT, TrueOp, and WriteObject.

    00200 {
    00201     MEMPTR lpOldMem = lpMem;
    00202
    00203     lpMem += WriteObject (lpMem, NewLine);
    00204     lpMem += WriteObject (lpMem, GlobalDictOp);
    00205     lpMem += WriteObject (lpMem, BeginOp);
    00206
    00207     lpMem += WriteObject (lpMem, CurrentGlobalOp);
    00208     lpMem += WriteObject (lpMem, TrueOp);
    00209     lpMem += WriteObject (lpMem, SetGlobalOp);
    00210     return (lpMem - lpOldMem);
    00211 }

BOOL GetCSAFromProfile | ( | CHANDLE | cp,
|  | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | DWORD | InpDrvClrSp,
|  | CSIG | DrvColorSpace,
|  | BOOL | AllowBinary
| ) | `[static]`

Definition at line 1442 of file dec97/dll32/getcsa.c.

References AllowBinary, Convert2Ascii(), DoesCPTagExist(), FALSE, GetCPElementData(), GetCPElementDataSize(), GetCPTagIndex(), icSigGrayData, icSigPs2CSATag, Index, LPSINT, NULL, SINT, Size, and TRUE.

    01449 {
    01450     SINT Index;
    01451     SINT Size;
    01452     if ((DrvColorSpace == icSigGrayData) && (InpDrvClrSp != icSigGrayData))
    01453         return FALSE;
    01454
    01455     if (DoesCPTagExist (cp, icSigPs2CSATag) &&
    01456         GetCPTagIndex (cp, icSigPs2CSATag, (LPSINT) & Index) &&
    01457         GetCPElementDataSize (cp, Index, (LPSINT) & Size) &&
    01458         ((lpMem == NULL) || GetCPElementData (cp, Index, lpMem, Size)) &&
    01459         (*lpcbSize = Convert2Ascii (cp, Index, lpMem, *lpcbSize, Size, AllowBinary)))
    01460     {
    01461         return TRUE;
    01462     } else
    01463     {
    01464         return FALSE;
    01465     }
    01466 }

BOOL GetDeviceCMYK | ( | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | DWORD | InpDrvClrSp
| ) | `[static]`

Definition at line 79 of file dec97/dll32/getcsa.c.

References DeviceCMYKTag, DWORD, FALSE, icSigCmykData, MEMPTR, NewLine, NULL, TRUE, and WriteObject.

    00083 {
    00084     MEMPTR lpOldMem = lpMem;
    00085     if ((InpDrvClrSp != icSigCmykData) &&
    00086         (InpDrvClrSp != 0))
    00087         return FALSE;
    00088     if (lpMem == NULL)
    00089     {
    00090         *lpcbSize = lstrlen (DeviceCMYKTag) + 8;
    00091         return (TRUE);
    00092     }
    00093     lpMem += WriteObject (lpMem, NewLine);
    00094     lpMem += WriteObject (lpMem, DeviceCMYKTag);
    00095
    00096     *lpcbSize = (DWORD) (lpMem - lpOldMem);
    00097     return (TRUE);
    00098
    00099 }

BOOL GetDeviceGray | ( | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | DWORD | InpDrvClrSp
| ) | `[static]`

Definition at line 105 of file dec97/dll32/getcsa.c.

References DeviceGrayTag, DeviceRGBTag, DWORD, icSigDefData, icSigGrayData, icSigRgbData, MEMPTR, NewLine, NULL, TRUE, and WriteObject.

    00109 {
    00110     MEMPTR lpOldMem = lpMem;
    00111     if ((InpDrvClrSp == icSigRgbData) ||
    00112         (InpDrvClrSp == icSigDefData) ||
    00113         (InpDrvClrSp == 0))
    00114     {
    00115         if (lpMem == NULL)
    00116         {
    00117             *lpcbSize = lstrlen (DeviceRGBTag) + 8;
    00118             return (TRUE);
    00119         }
    00120         lpMem += WriteObject (lpMem, NewLine);
    00121         lpMem += WriteObject (lpMem, DeviceRGBTag);
    00122
    00123         *lpcbSize = (DWORD) (lpMem - lpOldMem);
    00124         return (TRUE);
    00125     } else if (InpDrvClrSp == icSigGrayData)
    00126     {
    00127         if (lpMem == NULL)
    00128         {
    00129             *lpcbSize = lstrlen (DeviceGrayTag) + 8;
    00130             return (TRUE);
    00131         }
    00132         lpMem += WriteObject (lpMem, NewLine);
    00133         lpMem += WriteObject (lpMem, DeviceGrayTag);
    00134
    00135         *lpcbSize = (DWORD) (lpMem - lpOldMem);
    00136         return (TRUE);
    00137     }
    00138 }

BOOL GetDeviceRGB | ( | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | DWORD | InpDrvClrSp
| ) | `[static]`

Definition at line 39 of file dec97/dll32/getcsa.c.

References DeviceRGBTag, DWORD, FALSE, icSigDefData, icSigRgbData, MEMPTR, NewLine, NULL, TRUE, and WriteObject.

    00043 {
    00044     MEMPTR lpOldMem = lpMem;
    00045     if ((InpDrvClrSp != icSigRgbData) &&
    00046         (InpDrvClrSp != icSigDefData) &&
    00047         (InpDrvClrSp != 0))
    00048         return FALSE;
    00049
    00050     if (lpMem == NULL)
    00051     {
    00052         *lpcbSize = lstrlen (DeviceRGBTag) + 8;
    00053         return (TRUE);
    00054     }
    00055     lpMem += WriteObject (lpMem, NewLine);
    00056     lpMem += WriteObject (lpMem, DeviceRGBTag);
    00057
    00058     *lpcbSize = (DWORD) (lpMem - lpOldMem);
    00059     return (TRUE);
    00060 }

void GetMediaWP | ( | CHANDLE | cp,
|  | CSIG | InputIntent,
|  | LPSFLOAT | IlluminantWP,
|  | LPSFLOAT | MediaWP
| ) | `[static]`

Definition at line 185 of file dec97/dll32/getcsa.c.

References GetCPMediaWhitePoint(), icAbsoluteColorimetric, and LPSFLOAT.

    00187 {
    00188     if (InputIntent == icAbsoluteColorimetric)
    00189     {
    00190         if (!GetCPMediaWhitePoint (cp, (LPSFLOAT) & MediaWP)) // .. Media WhitePoint
    00191         {
    00192             MediaWP[0] = IlluminantWP[0];
    00193             MediaWP[1] = IlluminantWP[1];
    00194             MediaWP[2] = IlluminantWP[2];
    00195         }
    00196     }
    00197 }

BOOL EXTERN GetPS2ColorSpaceArray | ( | CHANDLE | cp,
|  | DWORD | InputIntent,
|  | DWORD | InpDrvClrSp,
|  | MEMPTR | lpBuffer,
|  | LPDWORD | lpcbSize,
|  | BOOL | AllowBinary
| ) |

Definition at line 1571 of file dec97/dll32/getcsa.c.

References AllowBinary, BOOL, CSIG, DWORD, FALSE, GetCPDevSpace, GetCPRenderIntent, GetCSAFromProfile(), GetDeviceCMYK(), GetDeviceGray(), GetDeviceRGB(), GetPS2CSA_ABC(), GetPS2CSA_ABC_LAB(), GetPS2CSA_DEFG_Intent(), GetPS2CSA_MONO(), icSigCmykData, icSigGrayData, icSigLabData, icSigRgbData, icUseRenderingIntent, Intent, LPCSIG, MEMPTR, NewLine, NotSupportDEFG_S, NULL, SupportDEFG_E, TYPE_CIEBASEDDEF, TYPE_CIEBASEDDEFG, and WriteObject.

    01578 {
    01579     CSIG ColorSpace, Intent;
    01580     BOOL Success = FALSE;
    01581     DWORD dwSaveSize;
    01582     if (!cp)
    01583         return Success;
    01584
    01585     if (!GetCPDevSpace (cp, (LPCSIG) & ColorSpace) ||
    01586         !GetCPRenderIntent (cp, (LPCSIG) & Intent))
    01587     {
    01588         return Success;
    01589     }
    01590     dwSaveSize = *lpcbSize;
    01591     if (InputIntent == icUseRenderingIntent)
    01592         InputIntent = (DWORD)Intent;
    01593
    01594  // Get ColorSpace from Profile.
    01595     if ((CSIG) InputIntent == Intent)
    01596     {
    01597         Success = GetCSAFromProfile (cp, lpBuffer, lpcbSize,
    01598                                      InpDrvClrSp, ColorSpace, AllowBinary);
    01599     }
    01600     if (!Success)
    01601     {
    01602         switch (ColorSpace)
    01603         {
    01604             case icSigRgbData:
    01605                 Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
    01606                                                  InpDrvClrSp, (CSIG) InputIntent,
    01607                                                  TYPE_CIEBASEDDEF, AllowBinary);
    01608                 if (Success)
    01609                 {                       // Create CieBasedABC or DeviceRGB
    01610                                         // for the printer
    01611                                         // which does not support CieBasedDEF(G).
    01612                     DWORD cbNewSize = 0;
    01613                     MEMPTR lpNewBuffer;
    01614                     MEMPTR lpOldBuffer;
    01615                     if (lpBuffer)
    01616                     {
    01617                         lpNewBuffer = lpBuffer + *lpcbSize;
    01618                         lpOldBuffer = lpNewBuffer;
    01619                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01620                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01621                         lpNewBuffer += WriteObject (lpNewBuffer, NotSupportDEFG_S);
    01622                         cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
    01623                     } else
    01624                         lpNewBuffer = NULL;
    01625
    01626                     if (!GetPS2CSA_ABC (cp, lpNewBuffer, &cbNewSize,
    01627                                         (CSIG)InputIntent, InpDrvClrSp, AllowBinary))
    01628                         GetDeviceRGB (lpNewBuffer, &cbNewSize, InpDrvClrSp);
    01629
    01630                     if (lpBuffer)
    01631                     {
    01632                         lpNewBuffer += cbNewSize;
    01633                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01634                         lpNewBuffer += WriteObject (lpNewBuffer, SupportDEFG_E);
    01635                         *lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
    01636                     } else
    01637                         *lpcbSize += cbNewSize;
    01638
    01639                 }
    01640                 if (!Success)
    01641                 {                           // Create CieBasedABC
    01642                     Success = GetPS2CSA_ABC (cp, lpBuffer, lpcbSize,
    01643                                          (CSIG)InputIntent, InpDrvClrSp, AllowBinary);
    01644                 }
    01645                 if (!Success)
    01646                 {                           // Create DeviceRGB
    01647                     Success = GetDeviceRGB (lpBuffer, lpcbSize, InpDrvClrSp);
    01648                     Success = FALSE;
    01649                 }
    01650                 break;
    01651             case icSigCmykData:
    01652                 Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
    01653                                                  InpDrvClrSp, (CSIG) InputIntent,
    01654                                                  TYPE_CIEBASEDDEFG, AllowBinary);
    01655                 if (Success)
    01656                 {                       // Create DeviceCMYK for the printer
    01657                                         // which does not support CieBasedDEF(G).
    01658                     DWORD cbNewSize = 0;
    01659                     MEMPTR lpNewBuffer;
    01660                     MEMPTR lpOldBuffer;
    01661                     if (lpBuffer)
    01662                     {
    01663                         lpNewBuffer = lpBuffer + *lpcbSize;
    01664                         lpOldBuffer = lpNewBuffer;
    01665                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01666                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01667                         lpNewBuffer += WriteObject (lpNewBuffer, NotSupportDEFG_S);
    01668                         cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
    01669                     } else
    01670                         lpNewBuffer = NULL;
    01671
    01672                     GetDeviceCMYK (lpNewBuffer, &cbNewSize, InpDrvClrSp);
    01673
    01674                     if (lpBuffer)
    01675                     {
    01676                         lpNewBuffer += cbNewSize;
    01677                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01678                         lpNewBuffer += WriteObject (lpNewBuffer, SupportDEFG_E);
    01679                         *lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
    01680                     } else
    01681                         *lpcbSize += cbNewSize;
    01682                 }
    01683                 if (!Success)
    01684                 {                           // Create DeviceCMYK
    01685                     Success = GetDeviceCMYK (lpBuffer, lpcbSize, InpDrvClrSp);
    01686                     Success = FALSE;
    01687                 }
    01688                 break;
    01689             case icSigGrayData:
    01690                 Success = GetPS2CSA_MONO (cp, lpBuffer, lpcbSize, InpDrvClrSp,
    01691                                           (CSIG)InputIntent, AllowBinary);
    01692                 if (!Success)
    01693                 {                           // Create DeviceGray
    01694                     Success = GetDeviceGray (lpBuffer, lpcbSize, InpDrvClrSp);
    01695                     Success = FALSE;
    01696                 }
    01697                 break;
    01698             case icSigLabData:
    01699                 Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
    01700                                                  InpDrvClrSp, (CSIG) InputIntent,
    01701                                                  TYPE_CIEBASEDDEF, AllowBinary);
    01702                 if (Success)
    01703                 {                       // Create CieBasedABC or DeviceRGB
    01704                                         // for the printer
    01705                                         // which does not support CieBasedDEF(G).
    01706                     DWORD cbNewSize = 0;
    01707                     MEMPTR lpNewBuffer;
    01708                     MEMPTR lpOldBuffer;
    01709                     if (lpBuffer)
    01710                     {
    01711                         lpNewBuffer = lpBuffer + *lpcbSize;
    01712                         lpOldBuffer = lpNewBuffer;
    01713                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01714                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01715                         lpNewBuffer += WriteObject (lpNewBuffer, NotSupportDEFG_S);
    01716                         cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
    01717                     } else
    01718                         lpNewBuffer = NULL;
    01719
    01720                     GetPS2CSA_ABC_LAB (cp, lpNewBuffer, &cbNewSize,
    01721                                         (CSIG)InputIntent, InpDrvClrSp, AllowBinary);
    01722
    01723                     if (lpBuffer)
    01724                     {
    01725                         lpNewBuffer += cbNewSize;
    01726                         lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
    01727                         lpNewBuffer += WriteObject (lpNewBuffer, SupportDEFG_E);
    01728                         *lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
    01729                     } else
    01730                         *lpcbSize += cbNewSize;
    01731                 }
    01732                 if (!Success)
    01733                 {                           // Create CieBasedABC
    01734                     Success = GetPS2CSA_ABC_LAB (cp, lpBuffer, lpcbSize,
    01735                                          (CSIG)InputIntent, InpDrvClrSp, AllowBinary);
    01736                 }
    01737                 break;
    01738
    01739             default:
    01740                 break;
    01741         }
    01742     }
    01743     return Success;
    01744 }

BOOL GetPS2CSA_ABC | ( | CHANDLE | cp,
|  | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | CSIG | InputIntent,
|  | DWORD | InpDrvClrSp,
|  | BOOL | AllowBinary
| ) |

Definition at line 634 of file dec97/dll32/getcsa.c.

    00636 {
    00637     CSIG PCS, Dev;
    00638     SFLOAT IlluminantWP[3];
    00639     SFLOAT MediaWP[3];
    00640
    00641     SINT i;
    00642     MEMPTR lpOldMem = lpMem;
    00643     SINT Ret = 0;
    00644  // Check if we can generate the CS.
    00645  // Required  tags are: red, green and blue Colorants.
    00646  // As for TRC tags - we are quite flexible here - if we cannot find the
    00647  // required tag - we assume the linear responce
    00648     if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
    00649         !GetCPDevSpace (cp, (LPCSIG) & Dev) ||
    00650         (Dev != icSigRgbData) ||
    00651         !DoesCPTagExist (cp, icSigRedColorantTag) ||
    00652         !DoesCPTagExist (cp, icSigGreenColorantTag) ||
    00653         !DoesCPTagExist (cp, icSigBlueColorantTag) ||
    00654         !DoesCPTagExist (cp, icSigRedTRCTag) ||
    00655         !DoesCPTagExist (cp, icSigGreenTRCTag) ||
    00656         !DoesCPTagExist (cp, icSigBlueTRCTag))
    00657     {
    00658         return (FALSE);
    00659     }
    00660     if ((InpDrvClrSp != icSigRgbData) &&
    00661         (InpDrvClrSp != icSigDefData) &&
    00662         (InpDrvClrSp != 0))
    00663     {
    00664         return (FALSE);
    00665     }
    00666  // Estimate the memory size required to hold CS
    00667
    00668     if (lpMem == NULL)                  // This is a size request
    00669     {
    00670         *lpcbSize = 65530;
    00671         return (TRUE);
    00672     }
    00673  // Get info about Illuminant White Point from the header
    00674     GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);     // .. Illuminant
    00675
    00676  // Support absolute whitePoint
    00677     GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
    00678
    00679  //*********** Creating global data
    00680     lpMem += WriteObject (lpMem, NewLine);
    00681     lpMem += WriteObject (lpMem, CieBasedABCBegin);
    00682
    00683     lpMem += EnableGlobalDict(lpMem);
    00684
    00685     lpMem += CreateColSpArray (cp, lpMem, icSigRedTRCTag, AllowBinary);
    00686     lpMem += CreateColSpArray (cp, lpMem, icSigGreenTRCTag, AllowBinary);
    00687     lpMem += CreateColSpArray (cp, lpMem, icSigBlueTRCTag, AllowBinary);
    00688
    00689     lpMem += WriteObject (lpMem, NewLine);
    00690     lpMem += WriteObject (lpMem, SetGlobalOp);
    00691     lpMem += WriteObject (lpMem, EndOp);
    00692
    00693
    00694  //*********** Start creating the ColorSpace
    00695     lpMem += WriteObject (lpMem, NewLine);
    00696     lpMem += WriteObject (lpMem, BeginArray);   // Begin array
    00697  //********** /CIEBasedABC
    00698     lpMem += WriteObject (lpMem, CIEBasedABCTag);   // Create entry
    00699     lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary
    00700
    00701  //********** Black/White Point
    00702     lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
    00703
    00704  //********** /DecodeABC
    00705     lpMem += WriteObject (lpMem, NewLine);
    00706     lpMem += WriteObject (lpMem, DecodeABCTag);
    00707     lpMem += WriteObject (lpMem, BeginArray);
    00708
    00709     lpMem += WriteObject (lpMem, NewLine);
    00710     lpMem += CreateColSpProc (cp, lpMem, icSigRedTRCTag, AllowBinary);
    00711     lpMem += WriteObject (lpMem, NewLine);
    00712     lpMem += CreateColSpProc (cp, lpMem, icSigGreenTRCTag, AllowBinary);
    00713     lpMem += WriteObject (lpMem, NewLine);
    00714     lpMem += CreateColSpProc (cp, lpMem, icSigBlueTRCTag, AllowBinary);
    00715     lpMem += WriteObject (lpMem, EndArray);
    00716
    00717  //********** /MatrixABC
    00718     lpMem += WriteObject (lpMem, NewLine);
    00719     lpMem += WriteObject (lpMem, MatrixABCTag);
    00720     lpMem += WriteObject (lpMem, BeginArray);
    00721
    00722     lpMem += CreateFloatString (cp, lpMem, icSigRedColorantTag);
    00723     lpMem += CreateFloatString (cp, lpMem, icSigGreenColorantTag);
    00724     lpMem += CreateFloatString (cp, lpMem, icSigBlueColorantTag);
    00725
    00726     lpMem += WriteObject (lpMem, EndArray);
    00727
    00728  //********** /RangeLMN
    00729     lpMem += WriteObject (lpMem, NewLine);
    00730     lpMem += WriteObject (lpMem, RangeLMNTag);
    00731     lpMem += WriteObject (lpMem, RangeLMN);
    00732
    00733  //********** /DecodeLMN
    00734     if (InputIntent == icAbsoluteColorimetric)
    00735     {
    00736         // Support absolute whitePoint
    00737         lpMem += WriteObject (lpMem, NewLine);
    00738         lpMem += WriteObject (lpMem, DecodeLMNTag);
    00739         lpMem += WriteObject (lpMem, BeginArray);
    00740         for (i = 0; i < 3; i ++)
    00741         {
    00742             lpMem += WriteObject (lpMem, BeginFunction);
    00743             lpMem += WriteFloat (lpMem, (double)MediaWP[i]/IlluminantWP[i]);
    00744             lpMem += WriteObject (lpMem, MulOp);
    00745             lpMem += WriteObject (lpMem, EndFunction);
    00746         }
    00747         lpMem += WriteObject (lpMem, EndArray);
    00748     }
    00749
    00750  //********** End dictionary definition
    00751     lpMem += WriteObject (lpMem, NewLine);
    00752     lpMem += WriteObject (lpMem, EndDict);
    00753     lpMem += WriteObject (lpMem, EndArray);
    00754
    00755     lpMem += WriteObject (lpMem, NewLine);
    00756     lpMem += WriteObject (lpMem, CieBasedABCEnd);
    00757     *lpcbSize = (DWORD) ((lpMem - lpOldMem));
    00758     return (TRUE);
    00759 }

BOOL GetPS2CSA_ABC_LAB | ( | CHANDLE | cp,
|  | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | CSIG | InputIntent,
|  | DWORD | InpDrvClrSp,
|  | BOOL | AllowBinary
| ) |

Definition at line 786 of file dec97/dll32/getcsa.c.

References BeginArray, BeginDict, BeginFunction, CieBasedABCEnd, CIEBasedABCTag, CSIG, DecodeABCLab1, DecodeABCTag, DecodeLMNLab, DecodeLMNTag, DWORD, EndArray, EndDict, EndFunction, FALSE, GetCPConnSpace, GetCPDevSpace, GetCPWhitePoint(), GetMediaWP(), icAbsoluteColorimetric, icSigDefData, icSigLabData, LPCSIG, LPSFLOAT, MatrixABCLab, MatrixABCTag, MEMPTR, MulOp, NewLine, NULL, RangeABC_Lab, RangeABCTag, SendCSABWPoint(), SFLOAT, SINT, TRUE, WriteFloat(), and WriteObject.

    00788 {
    00789     CSIG PCS, Dev;
    00790     SFLOAT IlluminantWP[3];
    00791     SFLOAT MediaWP[3];
    00792
    00793     SINT i;
    00794     MEMPTR lpOldMem = lpMem;
    00795     SINT Ret = 0;
    00796  // Check if we can generate the CS.
    00797  // Required  tags are: red, green and blue Colorants.
    00798  // As for TRC tags - we are quite flexible here - if we cannot find the
    00799  // required tag - we assume the linear responce
    00800     if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
    00801         !GetCPDevSpace (cp, (LPCSIG) & Dev) ||
    00802         (Dev != icSigLabData))
    00803     {
    00804         return (FALSE);
    00805     }
    00806     if ((InpDrvClrSp != icSigLabData) &&
    00807         (InpDrvClrSp != icSigDefData) &&
    00808         (InpDrvClrSp != 0))
    00809     {
    00810         return (FALSE);
    00811     }
    00812  // Estimate the memory size required to hold CS
    00813
    00814     if (lpMem == NULL)                  // This is a size request
    00815     {
    00816         *lpcbSize = 65530;
    00817         return (TRUE);
    00818     }
    00819  // Get info about Illuminant White Point from the header
    00820     GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);     // .. Illuminant
    00821
    00822  // Support absolute whitePoint
    00823     GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
    00824
    00825  //*********** Start creating the ColorSpace
    00826     lpMem += WriteObject (lpMem, NewLine);
    00827     lpMem += WriteObject (lpMem, BeginArray);   // Begin array
    00828
    00829  //********** /CIEBasedABC
    00830     lpMem += WriteObject (lpMem, CIEBasedABCTag);   // Create entry
    00831     lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary
    00832
    00833  //********** Black/White Point
    00834     lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
    00835
    00836  //********** /RangeABC
    00837     lpMem += WriteObject (lpMem, NewLine);
    00838     lpMem += WriteObject (lpMem, RangeABCTag);
    00839     lpMem += WriteObject (lpMem, RangeABC_Lab);
    00840
    00841  //********** /DecodeABC
    00842     lpMem += WriteObject (lpMem, NewLine);
    00843     lpMem += WriteObject (lpMem, DecodeABCTag);
    00844     lpMem += WriteObject (lpMem, DecodeABCLab1);
    00845
    00846  //********** /MatrixABC
    00847     lpMem += WriteObject (lpMem, NewLine);
    00848     lpMem += WriteObject (lpMem, MatrixABCTag);
    00849     lpMem += WriteObject (lpMem, MatrixABCLab);
    00850
    00851  //********** /DecodeLMN
    00852     lpMem += WriteObject (lpMem, NewLine);
    00853     lpMem += WriteObject (lpMem, DecodeLMNTag);
    00854     lpMem += WriteObject (lpMem, BeginArray);
    00855     for (i = 0; i < 3; i ++)
    00856     {
    00857         lpMem += WriteObject (lpMem, BeginFunction);
    00858         lpMem += WriteObject (lpMem, DecodeLMNLab);
    00859         if (InputIntent == icAbsoluteColorimetric)
    00860         {
    00861             lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
    00862         }
    00863         else
    00864         {
    00865             lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
    00866         }
    00867         lpMem += WriteObject (lpMem, MulOp);
    00868         lpMem += WriteObject (lpMem, EndFunction);
    00869         lpMem += WriteObject (lpMem, NewLine);
    00870     }
    00871     lpMem += WriteObject (lpMem, EndArray);
    00872
    00873
    00874  //********** End dictionary definition
    00875     lpMem += WriteObject (lpMem, NewLine);
    00876     lpMem += WriteObject (lpMem, EndDict);
    00877     lpMem += WriteObject (lpMem, EndArray);
    00878
    00879     lpMem += WriteObject (lpMem, NewLine);
    00880     lpMem += WriteObject (lpMem, CieBasedABCEnd);
    00881     *lpcbSize = (DWORD) ((lpMem - lpOldMem));
    00882     return (TRUE);
    00883 }

BOOL GetPS2CSA_DEFG | ( | CHANDLE | cp,
|  | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | CSIG | InputIntent,
|  | SINT | Index,
|  | int | Type,
|  | BOOL | AllowBinary
| ) | `[static]`

Definition at line 237 of file dec97/dll32/getcsa.c.

References AllowBinary, BeginArray, BeginDict, BeginFunction, BeginString, CieBasedDEFBegin, CieBasedDEFEnd, CieBasedDEFGBegin, CieBasedDEFGEnd, CIEBasedDEFGTag, CIEBasedDEFTag, Clip01, CP_POSTSCRIPT_ERR, CreateInputArray(), CreateOutputArray(), CSIG, DecodeABCLab, DecodeABCTag, DecodeDEFGTag, DecodeDEFTag, DecodeLMNLab, DecodeLMNTag, DWORD, EnableGlobalDict(), EncodeABCLab1, EncodeABCLab2, EndArray, EndClip, EndDict, EndFunction, EndOp, EndString, FALSE, FAR, GetCLUTinfo(), GetCPConnSpace, GetCPElement(), GetCPElementSize(), GetCPElementType(), GetCPTagSig(), GetCPWhitePoint(), GetMediaWP(), GetPublicArrayName(), icAbsoluteColorimetric, icSigLabData, icSigLut16Type, icSigLut8Type, icSigXYZData, icUInt16Number, Index, IndexArray, IndexArray16b, InputArray, lpcpLut16Type, lpcpLut8Type, LPCSIG, LPMEMPTR, LPSFLOAT, LPSINT, MatrixABCLab, MatrixABCTag, MAX_LINELENG, MemAlloc(), MemFree(), MEMPTR, MulOp, NewLine, NULL, OutputArray, RangeLMN, RangeLMNTag, Scale16, Scale16XYZ, Scale8, SendCSABWPoint(), SetCPLastError(), SetGlobalOp, SFLOAT, SINT, StartClip, SupportDEFG_E, SupportDEFG_S, TableTag, TempBfSize, TestingDEFG, TFunction8XYZ, TRUE, TYPE_CIEBASEDDEF, TYPE_CIEBASEDDEFG, ui16toSINT, WriteByteString(), WriteFloat(), WriteHex, WriteHexBuffer(), WriteInt, WriteInt2ByteString(), WriteObject, WriteObjectN(), and WriteStringToken().

    00245 {
    00246     CSIG PCS, LutTag;
    00247     CSIG IntentSig;
    00248     SFLOAT IlluminantWP[3];
    00249     SFLOAT MediaWP[3];
    00250     SINT nInputCh, nOutputCh, nGrids, SecondGrids;
    00251     SINT nInputTable, nOutputTable, nNumbers;
    00252     SINT i, j, k;
    00253     MEMPTR lpTable;
    00254     MEMPTR lpOldMem = lpMem;
    00255     MEMPTR lpLut = NULL;
    00256     MEMPTR lpLineStart;
    00257     HGLOBAL hLut = 0;
    00258     SINT LutSize;
    00259     char PublicArrayName[TempBfSize];
    00260  // Check if we can generate the CS.
    00261  // Required  tags are: red, green and blue Colorants.
    00262  // As for TRC tags - we are quite flexible here - if we cannot find the
    00263  // required tag - we assume the linear responce
    00264     if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
    00265         (PCS != icSigLabData) && (PCS != icSigXYZData) ||
    00266         !GetCPTagSig (cp, Index, (LPCSIG) & IntentSig))
    00267     {
    00268         return (FALSE);
    00269     }
    00270     if (!GetCPElementType (cp, Index, (LPCSIG) & LutTag) ||
    00271         ((LutTag != icSigLut8Type) && (LutTag != icSigLut16Type)) ||
    00272         !GetCPElementSize (cp, Index, (LPSINT) & LutSize) ||
    00273         !MemAlloc (LutSize, (HGLOBAL FAR *) &hLut, (LPMEMPTR) & lpLut) ||
    00274         !GetCPElement (cp, Index, lpLut, LutSize))
    00275     {
    00276         if (0 != hLut)
    00277         {
    00278             MemFree (hLut);
    00279         }
    00280         return (FALSE);
    00281     }
    00282  // Estimate the memory size required to hold CS
    00283
    00284     GetCLUTinfo(LutTag, lpLut, &nInputCh, &nOutputCh,
    00285         &nGrids, &nInputTable, &nOutputTable, &i);
    00286
    00287  // Level 2 printers support only tri-component CIEBasedABC input,
    00288  // but can have either 3 or 4 output channels.
    00289     if (!(nOutputCh == 3) ||
    00290         !((nInputCh == 3) && (Type == TYPE_CIEBASEDDEF)) &&
    00291         !((nInputCh == 4) && (Type == TYPE_CIEBASEDDEFG)))
    00292     {
    00293         SetCPLastError (CP_POSTSCRIPT_ERR);
    00294         MemFree (hLut);
    00295         return (FALSE);
    00296     }
    00297     if (lpMem == NULL)                  // This is a size request
    00298     {
    00299         if (Type == TYPE_CIEBASEDDEFG)
    00300             *lpcbSize = nOutputCh * nGrids * nGrids * nGrids * nGrids * 2;  // LUT HEX bytes
    00301         else
    00302             *lpcbSize = nOutputCh * nGrids * nGrids * nGrids * 2;   // LUT HEX bytes
    00303
    00304         *lpcbSize = *lpcbSize +
    00305             nInputCh * nInputTable * 6 +
    00306             nOutputCh * nOutputTable * 6 +  // Number of INT bytes
    00307             nInputCh * (lstrlen (IndexArray) +
    00308                         lstrlen (StartClip) +
    00309                         lstrlen (EndClip)) +
    00310             nOutputCh * (lstrlen (IndexArray) +
    00311                          lstrlen (StartClip) +
    00312                          lstrlen (EndClip)) +
    00313             4096;                       // + other PS stuff
    00314
    00315
    00316         return (TRUE);
    00317     }
    00318  // Get info about Illuminant White Point from the header
    00319     GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);          // .. Illuminant
    00320
    00321  // Support absolute whitePoint
    00322     GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
    00323
    00324  //*********** Testing CieBasedDEFG support
    00325     lpMem += WriteObject (lpMem, NewLine);
    00326     lpMem += WriteObject (lpMem, TestingDEFG);
    00327     lpMem += WriteObject (lpMem, NewLine);
    00328     lpMem += WriteObject (lpMem, SupportDEFG_S);
    00329
    00330  //*********** Creating global data
    00331     GetPublicArrayName (cp, IntentSig, PublicArrayName);
    00332     lpMem += WriteObject (lpMem, NewLine);
    00333     if (Type == TYPE_CIEBASEDDEFG)
    00334         lpMem += WriteObject (lpMem, CieBasedDEFGBegin);
    00335     else
    00336         lpMem += WriteObject (lpMem, CieBasedDEFBegin);
    00337
    00338     lpMem += EnableGlobalDict(lpMem);
    00339
    00340     lpMem += CreateInputArray (lpMem, nInputCh, nInputTable,
    00341              (MEMPTR) PublicArrayName, LutTag, lpLut, AllowBinary, NULL);
    00342
    00343     if (Type == TYPE_CIEBASEDDEFG)
    00344     {
    00345         i = nInputTable * nInputCh +
    00346             nGrids * nGrids * nGrids * nGrids * nOutputCh;
    00347     } else
    00348     {
    00349         i = nInputTable * nInputCh +
    00350             nGrids * nGrids * nGrids * nOutputCh;
    00351     }
    00352     lpMem += CreateOutputArray (lpMem, nOutputCh, nOutputTable, i,
    00353              (MEMPTR) PublicArrayName, LutTag, lpLut, AllowBinary, NULL);
    00354
    00355     lpMem += WriteObject (lpMem, NewLine);
    00356     lpMem += WriteObject (lpMem, SetGlobalOp);
    00357     lpMem += WriteObject (lpMem, EndOp);
    00358
    00359  //*********** Start creating the ColorSpace
    00360     lpMem += WriteObject (lpMem, NewLine);
    00361     lpMem += WriteObject (lpMem, BeginArray);   // Begin array
    00362
    00363  //********** /CIEBasedDEF(G)
    00364     if (Type == TYPE_CIEBASEDDEFG)
    00365         lpMem += WriteObject (lpMem, CIEBasedDEFGTag);
    00366     else
    00367         lpMem += WriteObject (lpMem, CIEBasedDEFTag);
    00368     lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary
    00369
    00370  //********** Black/White Point
    00371     lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
    00372
    00373  //********** /DecodeDEF(G)
    00374     lpLineStart = lpMem;
    00375     lpMem += WriteObject (lpMem, NewLine);
    00376     if (Type == TYPE_CIEBASEDDEFG)
    00377         lpMem += WriteObject (lpMem, DecodeDEFGTag);
    00378     else
    00379         lpMem += WriteObject (lpMem, DecodeDEFTag);
    00380
    00381     lpMem += WriteObject (lpMem, BeginArray);
    00382     for (i = 0; i < nInputCh; i++)
    00383     {
    00384         lpLineStart = lpMem;
    00385         lpMem += WriteObject (lpMem, NewLine);
    00386
    00387         lpMem += WriteObject (lpMem, BeginFunction);
    00388 #if 0
    00389         if (PCS == icSigLabData)
    00390         {
    00391             lpMem += WriteObject (lpMem,
    00392                                   (0 == i) ? EncodeABCLab1 : EncodeABCLab2);
    00393         }
    00394 #endif
    00395         lpMem += WriteObject (lpMem, StartClip);
    00396         lpMem += WriteObject (lpMem, InputArray);
    00397         lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName));
    00398         lpMem += WriteInt (lpMem, i);
    00399
    00400         if (!AllowBinary)               // Output ASCII
    00401         {
    00402             lpMem += WriteObject (lpMem, IndexArray);
    00403         } else
    00404         {                               // Output BINARY
    00405             if (LutTag == icSigLut8Type)
    00406             {
    00407                 lpMem += WriteObject (lpMem, IndexArray);
    00408             } else
    00409             {
    00410                 lpMem += WriteObject (lpMem, IndexArray16b);
    00411             }
    00412         }
    00413         lpMem += WriteObject (lpMem, (LutTag == icSigLut8Type) ? Scale8 : Scale16);
    00414         lpMem += WriteObject (lpMem, EndClip);
    00415         lpMem += WriteObject (lpMem, EndFunction);
    00416     }
    00417     lpMem += WriteObject (lpMem, EndArray);
    00418
    00419  //********** /Table
    00420     lpMem += WriteObject (lpMem, NewLine);
    00421     lpMem += WriteObject (lpMem, TableTag);
    00422     lpMem += WriteObject (lpMem, BeginArray);
    00423
    00424     lpMem += WriteInt (lpMem, nGrids);  // Send down Nh
    00425     lpMem += WriteInt (lpMem, nGrids);  // Send down Ni
    00426     lpMem += WriteInt (lpMem, nGrids);  // Send down Nj
    00427     nNumbers = nGrids * nGrids * nOutputCh;
    00428     SecondGrids = 1;
    00429     if (Type == TYPE_CIEBASEDDEFG)
    00430     {
    00431         lpMem += WriteInt (lpMem, nGrids);  // Send down Nk
    00432 //      nNumbers = nGrids * nGrids * nGrids * nOutputCh ;
    00433         SecondGrids = nGrids;
    00434     }
    00435     lpMem += WriteObject (lpMem, NewLine);
    00436     lpMem += WriteObject (lpMem, BeginArray);
    00437     for (i = 0; i < nGrids; i++)        // Nh strings should be sent
    00438     {
    00439         if (Type == TYPE_CIEBASEDDEFG)
    00440         {
    00441             lpMem += WriteObject (lpMem, NewLine);
    00442             lpMem += WriteObject (lpMem, BeginArray);
    00443         }
    00444         for (k = 0; k < SecondGrids; k++)
    00445         {
    00446             lpLineStart = lpMem;
    00447             lpMem += WriteObject (lpMem, NewLine);
    00448             if (LutTag == icSigLut8Type)
    00449             {
    00450                 lpTable = (MEMPTR) (((lpcpLut8Type) lpLut)->lut.data) +
    00451                     nInputTable * nInputCh +
    00452                     nNumbers * (i * SecondGrids + k);
    00453             } else
    00454             {
    00455                 lpTable = (MEMPTR) (((lpcpLut16Type) lpLut)->lut.data) +
    00456                     2 * nInputTable * nInputCh +
    00457                     2 * nNumbers * (i * SecondGrids + k);
    00458             }
    00459
    00460             if (!AllowBinary)           // Output ASCII
    00461             {
    00462                 lpMem += WriteObject (lpMem, BeginString);
    00463                 if (LutTag == icSigLut8Type)
    00464                     lpMem += WriteHexBuffer (lpMem, lpTable, lpLineStart, nNumbers);
    00465                 else
    00466                 {
    00467                     for (j = 0; j < nNumbers; j++)
    00468                     {
    00469                         lpMem += WriteHex (lpMem, ui16toSINT (lpTable) / 256);
    00470                         lpTable += sizeof (icUInt16Number);
    00471                         if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
    00472                         {
    00473                             lpLineStart = lpMem;
    00474                             lpMem += WriteObject (lpMem, NewLine);
    00475                         }
    00476                     }
    00477                 }
    00478                 lpMem += WriteObject (lpMem, EndString);
    00479             } else
    00480             {                           // Output BINARY
    00481                 lpMem += WriteStringToken (lpMem, 143, nNumbers);
    00482                 if (LutTag == icSigLut8Type)
    00483                     lpMem += WriteByteString (lpMem, lpTable, nNumbers);
    00484                 else
    00485                     lpMem += WriteInt2ByteString (lpMem, lpTable, nNumbers);
    00486             }
    00487             lpMem += WriteObject (lpMem, NewLine);
    00488         }
    00489         if (Type == TYPE_CIEBASEDDEFG)
    00490         {
    00491             lpMem += WriteObject (lpMem, EndArray);
    00492         }
    00493     }
    00494     lpMem += WriteObject (lpMem, EndArray);
    00495     lpMem += WriteObject (lpMem, EndArray); // End array
    00496
    00497  //********** /DecodeABC
    00498     lpLineStart = lpMem;
    00499     lpMem += WriteObject (lpMem, NewLine);
    00500     lpMem += WriteObject (lpMem, DecodeABCTag);
    00501     lpMem += WriteObject (lpMem, BeginArray);
    00502     for (i = 0; i < nOutputCh; i++)
    00503     {
    00504         lpLineStart = lpMem;
    00505         lpMem += WriteObject (lpMem, NewLine);
    00506
    00507         lpMem += WriteObject (lpMem, BeginFunction);
    00508         lpMem += WriteObject (lpMem, Clip01);
    00509         lpMem += WriteObject (lpMem, OutputArray);
    00510         lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName));
    00511         lpMem += WriteInt (lpMem, i);
    00512
    00513         if (!AllowBinary)               // Output ASCII CRD
    00514         {
    00515             lpMem += WriteObject (lpMem, NewLine);
    00516
    00517             if (LutTag == icSigLut8Type)
    00518             {
    00519                 lpMem += WriteObject (lpMem, TFunction8XYZ);
    00520             } else
    00521             {
    00522                 lpMem += WriteObject (lpMem, IndexArray);
    00523                 lpMem += WriteObject (lpMem, Scale16XYZ);
    00524             }
    00525         } else
    00526         {                               // Output BINARY CRD
    00527             if (LutTag == icSigLut8Type)
    00528             {
    00529                 lpMem += WriteObject (lpMem, TFunction8XYZ);
    00530             } else
    00531             {
    00532                 lpMem += WriteObject (lpMem, IndexArray16b);
    00533                 lpMem += WriteObject (lpMem, Scale16XYZ);
    00534             }
    00535         }
    00536
    00537  // Now, We get CieBasedXYZ output. Output range 0 --> 1.99997
    00538  // If the connection space is absolute XYZ, We need to convert
    00539  // from relative XYZ to absolute XYZ.
    00540         if ((PCS == icSigXYZData) &&
    00541             (InputIntent == icAbsoluteColorimetric))
    00542         {
    00543             lpMem += WriteFloat (lpMem, (double)MediaWP[i]/IlluminantWP[i]);
    00544             lpMem += WriteObject (lpMem, MulOp);
    00545         }
    00546  // If the connection space is Lab, We need to convert XYZ to Lab.
    00547         else if (PCS == icSigLabData)
    00548             lpMem += WriteObject (lpMem, DecodeABCLab[i]);
    00549         lpMem += WriteObject (lpMem, EndFunction);
    00550     }
    00551     lpMem += WriteObject (lpMem, EndArray);
    00552
    00553     if (PCS == icSigLabData)
    00554     {
    00555  //********** /MatrixABC
    00556         lpMem += WriteObject (lpMem, NewLine);
    00557         lpMem += WriteObject (lpMem, MatrixABCTag);
    00558         lpMem += WriteObject (lpMem, MatrixABCLab);
    00559
    00560  //********** /DecodeLMN
    00561         lpLineStart = lpMem;
    00562         lpMem += WriteObject (lpMem, NewLine);
    00563         lpMem += WriteObject (lpMem, DecodeLMNTag);
    00564         lpMem += WriteObject (lpMem, BeginArray);
    00565         for (i = 0; i < 3; i++)
    00566         {
    00567             lpLineStart = lpMem;
    00568             lpMem += WriteObject (lpMem, NewLine);
    00569
    00570             lpMem += WriteObject (lpMem, BeginFunction);
    00571             lpMem += WriteObject (lpMem, DecodeLMNLab);
    00572             if (InputIntent == icAbsoluteColorimetric)
    00573                 lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
    00574             else
    00575                 lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
    00576             lpMem += WriteObject (lpMem, MulOp);
    00577             lpMem += WriteObject (lpMem, EndFunction);
    00578         }
    00579         lpMem += WriteObject (lpMem, EndArray);
    00580     } else
    00581     {
    00582  //********** /RangeLMN
    00583         lpMem += WriteObject (lpMem, NewLine);
    00584         lpMem += WriteObject (lpMem, RangeLMNTag);
    00585         lpMem += WriteObject (lpMem, RangeLMN);
    00586     }
    00587
    00588  //********** End dictionary definition
    00589     lpMem += WriteObject (lpMem, NewLine);
    00590     lpMem += WriteObject (lpMem, EndDict);
    00591     lpMem += WriteObject (lpMem, EndArray);
    00592
    00593     lpMem += WriteObject (lpMem, NewLine);
    00594     if (Type == TYPE_CIEBASEDDEFG)
    00595         lpMem += WriteObject (lpMem, CieBasedDEFGEnd);
    00596     else
    00597         lpMem += WriteObject (lpMem, CieBasedDEFEnd);
    00598
    00599     lpMem += WriteObject (lpMem, NewLine);
    00600     lpMem += WriteObject (lpMem, SupportDEFG_E);
    00601
    00602     *lpcbSize = (DWORD) (lpMem - lpOldMem);
    00603
    00604     MemFree (hLut);
    00605     return (TRUE);
    00606 }

BOOL GetPS2CSA_DEFG_Intent | ( | CHANDLE | cp,
|  | MEMPTR | lpBuffer,
|  | LPDWORD | lpcbSize,
|  | DWORD | InpDrvClrSp,
|  | CSIG | Intent,
|  | int | Type,
|  | BOOL | AllowBinary
| ) |

Definition at line 1494 of file dec97/dll32/getcsa.c.

References AllowBinary, BOOL, CSIG, DoesCPTagExist(), FALSE, GetCPTagIndex(), GetPS2CSA_DEFG(), icAbsoluteColorimetric, icPerceptual, icRelativeColorimetric, icSaturation, icSigAToB0Tag, icSigAToB1Tag, icSigAToB2Tag, icSigCmykData, icSigDefData, Index, Intent, LPSINT, SINT, TYPE_CIEBASEDDEF, and TYPE_CIEBASEDDEFG.

    01502 {
    01503     SINT Index;
    01504     BOOL Success = FALSE;
    01505     CSIG icSigAToBx;
    01506
    01507  // Try to create CieBasedDEFG CSA first.
    01508     if (((Type == TYPE_CIEBASEDDEFG) && (InpDrvClrSp != icSigCmykData) ||
    01509          (Type == TYPE_CIEBASEDDEF) && (InpDrvClrSp != icSigDefData)) &&
    01510         (InpDrvClrSp != 0))
    01511     {
    01512         return (FALSE);
    01513     }
    01514     switch (Intent)
    01515     {
    01516         case icPerceptual:
    01517             icSigAToBx = icSigAToB0Tag;
    01518             break;
    01519         case icRelativeColorimetric:
    01520             icSigAToBx = icSigAToB1Tag;
    01521             break;
    01522         case icSaturation:
    01523             icSigAToBx = icSigAToB2Tag;
    01524             break;
    01525         case icAbsoluteColorimetric:
    01526             icSigAToBx = icSigAToB1Tag;
    01527             break;
    01528         default:
    01529             return Success;
    01530     }
    01531
    01532     if (DoesCPTagExist (cp, icSigAToBx) &&
    01533         GetCPTagIndex (cp, icSigAToBx, (LPSINT) & Index))
    01534     {
    01535         Success = GetPS2CSA_DEFG (cp, lpBuffer, lpcbSize, Intent, Index, Type, AllowBinary);
    01536     }
    01537
    01538     return Success;
    01539 }

BOOL GetPS2CSA_MONO | ( | CHANDLE | cp,
|  | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | DWORD | InpDrvClrSp,
|  | CSIG | InputIntent,
|  | BOOL | AllowBinary
| ) | `[static]`

Definition at line 1246 of file dec97/dll32/getcsa.c.

References AllowBinary, BOOL, FALSE, GetPS2CSA_MONO_A(), GetPS2CSA_MONO_ABC(), icSigDefData, icSigGrayData, and icSigRgbData.

    01248 {
    01249     BOOL Success = FALSE;
    01250 #if 0
    01251     if ((InpDrvClrSp == icSigRgbData) ||
    01252         (InpDrvClrSp == icSigDefData) ||
    01253         (InpDrvClrSp == 0))
    01254     {
    01255         Success = GetPS2CSA_MONO_ABC (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
    01256     } else if (InpDrvClrSp == icSigGrayData)
    01257     {
    01258         Success = GetPS2CSA_MONO_A (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
    01259     }
    01260 #else
    01261     if ((InpDrvClrSp == icSigGrayData) ||
    01262         (InpDrvClrSp == 0))
    01263     {
    01264         Success = GetPS2CSA_MONO_A (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
    01265     }
    01266     else
    01267     {
    01268         Success = FALSE;
    01269     }
    01270 #endif
    01271     return Success;
    01272 }

BOOL GetPS2CSA_MONO_A | ( | CHANDLE | cp,
|  | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | CSIG | InputIntent,
|  | BOOL | AllowBinary
| ) | `[static]`

Definition at line 1073 of file dec97/dll32/getcsa.c.

References BeginArray, BeginDict, BeginFunction, CieBasedABegin, CieBasedAEnd, CIEBasedATag, CSIG, DecodeA3, DecodeALab, DecodeATag, DecodeLMNLab, DoesCPTagExist(), DWORD, EndArray, EndClip, EndDict, EndFunction, FALSE, FAR, GetCPConnSpace, GetCPElement(), GetCPElementSize(), GetCPElementType(), GetCPTagIndex(), GetCPWhitePoint(), GetMediaWP(), icAbsoluteColorimetric, icSigCurveType, icSigGrayTRCTag, icSigLabData, icUInt16Number, Index, IndexArray, lpcpCurveType, LPCSIG, LPMEMPTR, LPSFLOAT, LPSINT, MatrixATag, MAX_LINELENG, MemAlloc(), MemFree(), MEMPTR, NewLine, NULL, RangeLMN, RangeLMNTag, Scale16, SendCSABWPoint(), SFLOAT, SINT, StartClip, TRUE, ui16toSINT, ui32toSINT, WriteFloat(), WriteInt, and WriteObject.

    01075 {
    01076     SINT nCount;
    01077     CSIG Tag, PCS;
    01078     SINT i, Index;
    01079     MEMPTR lpTable;
    01080     SFLOAT IlluminantWP[3];
    01081     SFLOAT MediaWP[3];
    01082     MEMPTR lpBuff = NULL;
    01083     SINT MemSize = 0;
    01084     MEMPTR lpOldMem = lpMem;
    01085     HGLOBAL hBuff;
    01086     MEMPTR lpLineStart;
    01087  // Check if we can generate the CS
    01088     if (!DoesCPTagExist (cp, icSigGrayTRCTag) ||
    01089         !GetCPTagIndex (cp, icSigGrayTRCTag, &Index) ||
    01090         !GetCPElementType (cp, Index, (LPCSIG) & Tag) ||
    01091         (Tag != icSigCurveType) ||
    01092         !GetCPConnSpace (cp, (LPCSIG) & PCS) ||
    01093         !GetCPElementSize (cp, Index, (LPSINT) & MemSize) ||
    01094         !MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & lpBuff) ||
    01095         !GetCPElement (cp, Index, lpBuff, MemSize))
    01096     {
    01097         if (NULL != lpBuff)
    01098         {
    01099             MemFree (hBuff);
    01100         }
    01101         return (FALSE);
    01102     }
    01103     nCount = ui32toSINT (((lpcpCurveType) lpBuff)->curve.count);
    01104
    01105  // Estimate the memory size required to hold CS
    01106     *lpcbSize = nCount * 6 +            // Number of INT elements
    01107         3 * (lstrlen (IndexArray) +
    01108              lstrlen (StartClip) +
    01109              lstrlen (EndClip)) +
    01110         2048;                           // + other PS stuff
    01111     if (lpMem == NULL)                  // This is a size request
    01112     {
    01113         MemFree (hBuff);
    01114         return (TRUE);
    01115     }
    01116  // Get info about Illuminant White Point from the header
    01117     GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);          // .. Illuminant
    01118
    01119  // Support absolute whitePoint
    01120     GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
    01121
    01122  //*********** Start creating the ColorSpace
    01123     lpMem += WriteObject (lpMem, NewLine);
    01124     lpMem += WriteObject (lpMem, CieBasedABegin);
    01125
    01126     lpMem += WriteObject (lpMem, NewLine);
    01127     lpMem += WriteObject (lpMem, BeginArray);   // Begin array
    01128  //********** /CIEBasedA
    01129     lpMem += WriteObject (lpMem, CIEBasedATag); // Create entry
    01130     lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary
    01131
    01132  //********** Black/White Point
    01133     lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
    01134
    01135  //********** /DecodeA
    01136     lpMem += WriteObject (lpMem, NewLine);
    01137     lpLineStart = lpMem;
    01138
    01139     if (nCount != 0)
    01140     {
    01141         lpMem += WriteObject (lpMem, DecodeATag);
    01142         lpMem += WriteObject (lpMem, BeginArray);
    01143
    01144         lpMem += WriteObject (lpMem, BeginFunction);
    01145         if (nCount == 1)                // Gamma supplied in ui16 format
    01146         {
    01147             lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
    01148             lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
    01149             lpMem += WriteObject (lpMem, DecodeA3);
    01150     // If the PCS is Lab, we need to convert Lab to XYZ
    01151     // Now, the range is from 0 --> 0.99997.
    01152     // Actually, the conversion from Lab to XYZ is not needed.
    01153             if (PCS == icSigLabData)
    01154             {
    01155                 lpMem += WriteObject (lpMem, DecodeALab);
    01156                 lpMem += WriteObject (lpMem, DecodeLMNLab);
    01157             }
    01158         } else
    01159         {
    01160             lpMem += WriteObject (lpMem, StartClip);
    01161             lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
    01162             lpMem += WriteObject (lpMem, BeginArray);
    01163             for (i = 0; i < nCount; i++)
    01164             {
    01165                 lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
    01166                 lpTable += sizeof (icUInt16Number);
    01167                 if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
    01168                 {
    01169                     lpLineStart = lpMem;
    01170                     lpMem += WriteObject (lpMem, NewLine);
    01171                 }
    01172             }
    01173             lpMem += WriteObject (lpMem, EndArray);
    01174             lpLineStart = lpMem;
    01175             lpMem += WriteObject (lpMem, NewLine);
    01176
    01177             lpMem += WriteObject (lpMem, IndexArray);
    01178             lpMem += WriteObject (lpMem, Scale16);
    01179     // If the PCS is Lab, we need to convert Lab to XYZ
    01180     // Now, the range is from 0 --> .99997.
    01181     // Actually, the conversion from Lab to XYZ is not needed.
    01182             if (PCS == icSigLabData)
    01183             {
    01184                 lpMem += WriteObject (lpMem, DecodeALab);
    01185                 lpMem += WriteObject (lpMem, DecodeLMNLab);
    01186             }
    01187             lpMem += WriteObject (lpMem, EndClip);
    01188         }
    01189         lpMem += WriteObject (lpMem, EndFunction);
    01190         lpMem += WriteObject (lpMem, EndArray);
    01191     }
    01192
    01193  //********** /MatrixA
    01194     lpMem += WriteObject (lpMem, NewLine);
    01195     lpMem += WriteObject (lpMem, MatrixATag);
    01196     lpMem += WriteObject (lpMem, BeginArray);
    01197     for (i = 0; i < 3; i++)
    01198     {
    01199         if (InputIntent == icAbsoluteColorimetric)
    01200             lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
    01201         else
    01202             lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
    01203     }
    01204     lpMem += WriteObject (lpMem, EndArray);
    01205
    01206  //********** /RangeLMN
    01207     lpMem += WriteObject (lpMem, NewLine);
    01208     lpMem += WriteObject (lpMem, RangeLMNTag);
    01209     lpMem += WriteObject (lpMem, RangeLMN);
    01210
    01211  //********** /End dictionary
    01212     lpMem += WriteObject (lpMem, EndDict);  // End dictionary definition
    01213     lpMem += WriteObject (lpMem, EndArray);
    01214
    01215     MemFree (hBuff);
    01216
    01217     lpMem += WriteObject (lpMem, NewLine);
    01218     lpMem += WriteObject (lpMem, CieBasedAEnd);
    01219     *lpcbSize = (DWORD) (lpMem - lpOldMem);
    01220     return (TRUE);
    01221 }

BOOL GetPS2CSA_MONO_ABC | ( | CHANDLE | cp,
|  | MEMPTR | lpMem,
|  | LPDWORD | lpcbSize,
|  | CSIG | InputIntent,
|  | BOOL | AllowBinary
| ) | `[static]`

Definition at line 908 of file dec97/dll32/getcsa.c.

References BeginArray, BeginDict, BeginFunction, CieBasedABCBegin, CieBasedABCEnd, CIEBasedABCTag, CSIG, DecodeA3, DecodeABCTag, DoesCPTagExist(), DupOp, DWORD, EndArray, EndClip, EndDict, EndFunction, FALSE, FAR, GetCPConnSpace, GetCPElement(), GetCPElementSize(), GetCPElementType(), GetCPTagIndex(), GetCPWhitePoint(), GetMediaWP(), icAbsoluteColorimetric, icSigCurveType, icSigGrayTRCTag, icUInt16Number, Index, IndexArray, lpcpCurveType, LPCSIG, LPMEMPTR, LPSFLOAT, LPSINT, MatrixABCTag, MAX_LINELENG, MemAlloc(), MemFree(), MEMPTR, NewLine, NULL, RangeLMN, RangeLMNTag, Scale16, SendCSABWPoint(), SFLOAT, SINT, StartClip, TRUE, ui16toSINT, ui32toSINT, WriteFloat(), WriteInt, and WriteObject.

    00910 {
    00911     SINT nCount;
    00912     CSIG Tag, PCS;
    00913     SINT i, j, Index;
    00914     MEMPTR lpTable;
    00915     SFLOAT IlluminantWP[3];
    00916     SFLOAT MediaWP[3];
    00917     MEMPTR lpBuff = NULL;
    00918     SINT MemSize = 0;
    00919     MEMPTR lpOldMem = lpMem;
    00920     HGLOBAL hBuff;
    00921     MEMPTR lpLineStart;
    00922  // Check if we can generate the CS
    00923     if (!DoesCPTagExist (cp, icSigGrayTRCTag) ||
    00924         !GetCPTagIndex (cp, icSigGrayTRCTag, &Index) ||
    00925         !GetCPElementType (cp, Index, (LPCSIG) & Tag) ||
    00926         (Tag != icSigCurveType) ||
    00927         !GetCPConnSpace (cp, (LPCSIG) & PCS) ||
    00928         !GetCPElementSize (cp, Index, (LPSINT) & MemSize) ||
    00929         !MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & lpBuff) ||
    00930         !GetCPElement (cp, Index, lpBuff, MemSize))
    00931     {
    00932         if (NULL != lpBuff)
    00933         {
    00934             MemFree (hBuff);
    00935         }
    00936         return (FALSE);
    00937     }
    00938     nCount = ui32toSINT (((lpcpCurveType) lpBuff)->curve.count);
    00939
    00940  // Estimate the memory size required to hold CS
    00941     *lpcbSize = nCount * 6 +            // Number of INT elements
    00942         3 * (lstrlen (IndexArray) +
    00943              lstrlen (StartClip) +
    00944              lstrlen (EndClip)) +
    00945         2048;                           // + other PS stuff
    00946     if (lpMem == NULL)                  // This is a size request
    00947     {
    00948         MemFree (hBuff);
    00949         return (TRUE);
    00950     }
    00951  // Get info about Illuminant White Point from the header
    00952     GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);          // .. Illuminant
    00953
    00954  // Support absolute whitePoint
    00955     GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);
    00956
    00957  //*********** Start creating the ColorSpace
    00958     lpMem += WriteObject (lpMem, NewLine);
    00959     lpMem += WriteObject (lpMem, CieBasedABCBegin);
    00960
    00961     lpMem += WriteObject (lpMem, NewLine);
    00962     lpMem += WriteObject (lpMem, BeginArray);   // Begin array
    00963  //********** /CIEBasedABC
    00964     lpMem += WriteObject (lpMem, CIEBasedABCTag);   // Create entry
    00965     lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary
    00966
    00967  //********** Black/White Point
    00968     lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
    00969
    00970  //********** /DecodeABC
    00971     lpMem += WriteObject (lpMem, NewLine);
    00972     lpLineStart = lpMem;
    00973
    00974     if (nCount != 0)
    00975     {
    00976         lpMem += WriteObject (lpMem, DecodeABCTag);
    00977         lpMem += WriteObject (lpMem, BeginArray);
    00978
    00979         lpMem += WriteObject (lpMem, BeginFunction);
    00980         if (nCount == 1)                // Gamma supplied in ui16 format
    00981         {
    00982             lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
    00983             lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
    00984             lpMem += WriteObject (lpMem, DecodeA3);
    00985         } else
    00986         {
    00987             lpMem += WriteObject (lpMem, StartClip);
    00988             lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
    00989             lpMem += WriteObject (lpMem, BeginArray);
    00990             for (i = 0; i < nCount; i++)
    00991             {
    00992                 lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
    00993                 lpTable += sizeof (icUInt16Number);
    00994                 if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
    00995                 {
    00996                     lpLineStart = lpMem;
    00997                     lpMem += WriteObject (lpMem, NewLine);
    00998                 }
    00999             }
    01000             lpMem += WriteObject (lpMem, EndArray);
    01001             lpLineStart = lpMem;
    01002             lpMem += WriteObject (lpMem, NewLine);
    01003
    01004             lpMem += WriteObject (lpMem, IndexArray);
    01005             lpMem += WriteObject (lpMem, Scale16);
    01006             lpMem += WriteObject (lpMem, EndClip);
    01007         }
    01008         lpMem += WriteObject (lpMem, EndFunction);
    01009         lpMem += WriteObject (lpMem, DupOp);
    01010         lpMem += WriteObject (lpMem, DupOp);
    01011         lpMem += WriteObject (lpMem, EndArray);
    01012     }
    01013  //********** /MatrixABC
    01014     lpMem += WriteObject (lpMem, NewLine);
    01015     lpMem += WriteObject (lpMem, MatrixABCTag);
    01016     lpMem += WriteObject (lpMem, BeginArray);
    01017     for (i = 0; i < 3; i ++)
    01018     {
    01019         for (j = 0; j < 3; j++)
    01020         {
    01021             if (i != j)
    01022                 lpMem += WriteFloat (lpMem, (double)0);
    01023             else
    01024             {
    01025                 if (InputIntent == icAbsoluteColorimetric)
    01026                     lpMem += WriteFloat (lpMem, (double)MediaWP[i]);
    01027                 else
    01028                     lpMem += WriteFloat (lpMem, (double)IlluminantWP[i]);
    01029             }
    01030         }
    01031     }
    01032     lpMem += WriteObject (lpMem, EndArray);
    01033
    01034  //********** /RangeLMN
    01035     lpMem += WriteObject (lpMem, NewLine);
    01036     lpMem += WriteObject (lpMem, RangeLMNTag);
    01037     lpMem += WriteObject (lpMem, RangeLMN);
    01038
    01039
    01040     lpMem += WriteObject (lpMem, EndDict);  // End dictionary definition
    01041     lpMem += WriteObject (lpMem, EndArray);
    01042
    01043     MemFree (hBuff);
    01044
    01045     lpMem += WriteObject (lpMem, NewLine);
    01046     lpMem += WriteObject (lpMem, CieBasedABCEnd);
    01047     *lpcbSize = (DWORD) (lpMem - lpOldMem);
    01048     return (TRUE);
    01049 }

SINT GetPublicArrayName | ( | CHANDLE | cp,
|  | CSIG | IntentSig,
|  | MEMPTR | PublicArrayName
| ) |

Definition at line 144 of file dec97/dll32/getcsa.c.

References CSIG, and MEMPTR.

    00145 {
    00146     MEMPTR OldPtr;
    00147     OldPtr = PublicArrayName;
    00148     PublicArrayName[0] = 0;
    00149     MemCopy (PublicArrayName, (MEMPTR) & IntentSig, sizeof (CSIG));
    00150     PublicArrayName += sizeof (CSIG);
    00151     PublicArrayName[0] = 0;
    00152     return (PublicArrayName - OldPtr);
    00153 }

SINT SendCSABWPoint | ( | MEMPTR | lpMem,
|  | CSIG | Intent,
|  | LPSFLOAT | IlluminantWP,
|  | LPSFLOAT | MediaWP
| ) | `[static]`

Definition at line 155 of file dec97/dll32/getcsa.c.

References BeginArray, BlackPoint, BlackPointTag, EndArray, icAbsoluteColorimetric, Intent, MEMPTR, NewLine, SINT, WhitePointTag, WriteFloat(), and WriteObject.

    00157 {
    00158     SINT   i;
    00159     MEMPTR lpOldMem = lpMem;
    00160
    00161  //********** /BlackPoint
    00162     lpMem += WriteObject (lpMem, NewLine);
    00163     lpMem += WriteObject (lpMem, BlackPointTag);
    00164     lpMem += WriteObject (lpMem, BlackPoint);
    00165
    00166  //********** /WhitePoint
    00167     lpMem += WriteObject (lpMem, NewLine);
    00168     lpMem += WriteObject (lpMem, WhitePointTag);
    00169     lpMem += WriteObject (lpMem, BeginArray);
    00170     for (i = 0; i < 3; i++)
    00171     {
    00172         if (Intent == icAbsoluteColorimetric)
    00173         {
    00174             lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
    00175         }
    00176         else
    00177         {
    00178             lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
    00179         }
    00180     }
    00181     lpMem += WriteObject (lpMem, EndArray);
    00182     return (SINT)(lpMem - lpOldMem);
    00183 }

## Variable Documentation

char* DecodeABCLab[]`[static]`

Initial value:

     {"50 mul 16 add 116 div ",
                                   "128 mul 128 sub 500 div",
                                   "128 mul 128 sub 200 div"}

Definition at line 6 of file dec97/dll32/getcsa.c.

Referenced by GetPS2CSA_DEFG().