windows-server-2003/windows/core/ntgdi/icm/mscms/ps2.c


								/****************************Module*Header******************************\

								* Module Name: PS2.C

								*

								* Module Descripton: Functions for retrieving or creating PostScript

								*    Level 2 operators from a profile. It is shared by mscms & pscript5

								*

								* Warnings:

								*

								* Issues:

								*

								* Public Routines:

								*

								* Created:  13 May 1996

								* Author:   Srinivasan Chandrasekar    [srinivac]

								*

								* Copyright (c) 1996, 1997  Microsoft Corporation

								\***********************************************************************/


								#include <math.h>


								#define MAX_LINELEN             240

								#define REVCURVE_RATIO          1

								#define CIEXYZRange             0x1FFEC       // 1.9997 in 16.16 notation

								#define ALIGN_DWORD(nBytes)     (((nBytes) + 3) & ~3)


								#define FIX_16_16_SHIFT         16

								#define FIX_16_16_SCALE         (1 << (FIX_16_16_SHIFT))


								#define TO_FIX(x)               ((x) << FIX_16_16_SHIFT)

								#define TO_INT(x)               ((x) >> FIX_16_16_SHIFT)

								#define FIX_MUL(x, y)           MulDiv((x), (y), FIX_16_16_SCALE)

								#define FIX_DIV(x, y)           MulDiv((x), FIX_16_16_SCALE, (y))


								#define FLOOR(x)                ((x) >> FIX_16_16_SHIFT << FIX_16_16_SHIFT)


								#define TYPE_CIEBASEDDEF        1

								#define TYPE_CIEBASEDDEFG       2


								#define TAG_PS2CSA              'ps2s'

								#define TAG_REDCOLORANT         'rXYZ'

								#define TAG_GREENCOLORANT       'gXYZ'

								#define TAG_BLUECOLORANT        'bXYZ'

								#define TAG_REDTRC              'rTRC'

								#define TAG_GREENTRC            'gTRC'

								#define TAG_BLUETRC             'bTRC'

								#define TAG_GRAYTRC             'kTRC'

								#define TAG_MEDIAWHITEPOINT     'wtpt'

								#define TAG_AToB0               'A2B0'

								#define TAG_AToB1               'A2B1'

								#define TAG_AToB2               'A2B2'

								#define TAG_PS2INTENT0          'psi0'

								#define TAG_PS2INTENT1          'psi1'

								#define TAG_PS2INTENT2          'psi2'

								#define TAG_PS2INTENT3          'psi3'

								#define TAG_CRDINTENT0          'psd0'

								#define TAG_CRDINTENT1          'psd1'

								#define TAG_CRDINTENT2          'psd2'

								#define TAG_CRDINTENT3          'psd3'

								#define TAG_BToA0               'B2A0'

								#define TAG_BToA1               'B2A1'

								#define TAG_BToA2               'B2A2'

								#define TAG_BToA3               'B2A3'


								#define LUT8_TYPE               'mft1'

								#define LUT16_TYPE              'mft2'


								#define SIG_CURVE_TYPE          'curv'


								#define GetCPConnSpace(pProfile)     (FIX_ENDIAN(((PPROFILEHEADER)pProfile)->phConnectionSpace))

								#define GetCPDevSpace(pProfile)      (FIX_ENDIAN(((PPROFILEHEADER)pProfile)->phDataColorSpace))

								#define GetCPRenderIntent(pProfile)  (FIX_ENDIAN(((PPROFILEHEADER)pProfile)->phRenderingIntent))

								#define WriteObject(pBuf, pStr)      (STRCPY(pBuf, pStr), STRLEN(pStr))


								#ifdef KERNEL_MODE

								#define WriteInt(pBuf, i)            OPSprintf(pBuf, "%l ", (i))

								#define WriteHex(pBuf, x)            OPSprintf(pBuf, "%x", ((x) & 0x00FF))

								#define STRLEN                       strlen

								#define STRCPY                       strcpy

								#else

								#define WriteInt(pBuf, i)            wsprintfA(pBuf, "%lu ", (i))

								#define WriteHex(pBuf, x)            wsprintfA(pBuf, "%2.2x", ((x) & 0x00FF))

								#define STRLEN                       lstrlenA

								#define STRCPY                       lstrcpyA

								#endif


								#define MAXCHANNELS             4

								#define PREVIEWCRDGRID          16

								#define MAXCOLOR8               255


								#define DATATYPE_LUT            0

								#define DATATYPE_MATRIX         1


								#define sRGB_CRC                0xa3d777b4L

								#define sRGB_TAGSIZE            6168


								#define BRADFORD_TRANSFORM


								//

								// Local typedefs

								//


								typedef DWORD FIX_16_16, *PFIX_16_16;


								typedef struct tagCURVETYPE {

								    DWORD dwSignature;

								    DWORD dwReserved;

								    DWORD nCount;

								    WORD  data[0];

								} CURVETYPE, *PCURVETYPE;


								typedef struct tagXYZTYPE {

								    DWORD     dwSignature;

								    DWORD     dwReserved;

								    FIX_16_16 afxData[0];

								} XYZTYPE, *PXYZTYPE;


								typedef struct tagLUT8TYPE {

								    DWORD     dwSignature;

								    DWORD     dwReserved;

								    BYTE      nInputChannels;

								    BYTE      nOutputChannels;

								    BYTE      nClutPoints;

								    BYTE      padding;

								    FIX_16_16 e00;

								    FIX_16_16 e01;

								    FIX_16_16 e02;

								    FIX_16_16 e10;

								    FIX_16_16 e11;

								    FIX_16_16 e12;

								    FIX_16_16 e20;

								    FIX_16_16 e21;

								    FIX_16_16 e22;

								    BYTE      data[0];

								} LUT8TYPE, *PLUT8TYPE;


								typedef struct tagLUT16TYPE {

								    DWORD     dwSignature;

								    DWORD     dwReserved;

								    BYTE      nInputChannels;

								    BYTE      nOutputChannels;

								    BYTE      nClutPoints;

								    BYTE      padding;

								    FIX_16_16 e00;

								    FIX_16_16 e01;

								    FIX_16_16 e02;

								    FIX_16_16 e10;

								    FIX_16_16 e11;

								    FIX_16_16 e12;

								    FIX_16_16 e20;

								    FIX_16_16 e21;

								    FIX_16_16 e22;

								    WORD      wInputEntries;

								    WORD      wOutputEntries;

								    WORD      data[0];

								} LUT16TYPE, *PLUT16TYPE;


								typedef struct tagHOSTCLUT {

								    WORD        wSize;

								    WORD        wDataType;

								    DWORD       dwDev;

								    DWORD       dwPCS;

								    DWORD       dwIntent;

								    FIX_16_16   afxIlluminantWP[3];

								    FIX_16_16   afxMediaWP[3];

								    BYTE        nInputCh;

								    BYTE        nOutputCh;

								    BYTE        nClutPoints;

								    BYTE        nLutBits;

								    FIX_16_16   e[9];

								    WORD        nInputEntries;

								    WORD        nOutputEntries;

								    PBYTE       inputArray[MAXCHANNELS];

								    PBYTE       outputArray[MAXCHANNELS];

								    PBYTE       clut;

								} HOSTCLUT, *PHOSTCLUT;


								//

								// Internal functions

								//


								BOOL  IsSRGBColorProfile(PBYTE);


								BOOL  GetCSAFromProfile (PBYTE, DWORD, DWORD, PBYTE, PDWORD, PBOOL);

								BOOL  GetPS2CSA_MONO_A(PBYTE, PBYTE, PDWORD, DWORD, PBOOL);

								BOOL  GetPS2CSA_ABC(PBYTE, PBYTE, PDWORD, DWORD, PBOOL, BOOL);

								BOOL  GetPS2CSA_ABC_Lab(PBYTE, PBYTE, PDWORD, DWORD, PBOOL);

								BOOL  GetPS2CSA_DEFG(PBYTE, PBYTE, PDWORD, DWORD, DWORD, PBOOL);


								BOOL  CreateMonoCRD(PBYTE, DWORD, PBYTE, PDWORD, DWORD);

								BOOL  CreateLutCRD(PBYTE, DWORD, PBYTE, PDWORD, DWORD, BOOL);


								BOOL  DoesCPTagExist(PBYTE, DWORD, PDWORD);

								BOOL  DoesTRCAndColorantTagExist(PBYTE);

								BOOL  GetCPWhitePoint(PBYTE, PFIX_16_16);

								BOOL  GetCPMediaWhitePoint(PBYTE, PFIX_16_16);

								BOOL  GetCPElementDataSize(PBYTE, DWORD, PDWORD);

								BOOL  GetCPElementSize(PBYTE, DWORD, PDWORD);

								BOOL  GetCPElementDataType(PBYTE, DWORD, PDWORD);

								BOOL  GetCPElementData(PBYTE, DWORD, PBYTE, PDWORD);

								BOOL  GetTRCElementSize(PBYTE, DWORD, PDWORD, PDWORD);


								DWORD Ascii85Encode(PBYTE, DWORD, DWORD);


								BOOL  GetCRDInputOutputArraySize(PBYTE, DWORD, PDWORD, PDWORD, PDWORD, PDWORD);

								BOOL  GetHostCSA(PBYTE, PBYTE, PDWORD, DWORD, DWORD);

								BOOL  GetHostColorRenderingDictionary(PBYTE, DWORD, PBYTE, PDWORD);

								BOOL  GetHostColorSpaceArray(PBYTE, DWORD, PBYTE, PDWORD);


								DWORD SendCRDBWPoint(PBYTE, PFIX_16_16);

								DWORD SendCRDPQR(PBYTE, DWORD, PFIX_16_16);

								DWORD SendCRDLMN(PBYTE, DWORD, PFIX_16_16, PFIX_16_16, DWORD);

								DWORD SendCRDABC(PBYTE, PBYTE, DWORD, DWORD, PBYTE, PFIX_16_16, DWORD, BOOL);

								DWORD SendCRDOutputTable(PBYTE, PBYTE, DWORD, DWORD, BOOL, BOOL);


								DWORD SendCSABWPoint(PBYTE, DWORD, PFIX_16_16, PFIX_16_16);

								VOID  GetMediaWP(PBYTE, DWORD, PFIX_16_16, PFIX_16_16);


								DWORD CreateCRDRevArray(PBYTE, PBYTE, PCURVETYPE, PWORD, DWORD, BOOL);

								DWORD SendCRDRevArray(PBYTE, PBYTE, PCURVETYPE, DWORD, BOOL);


								DWORD CreateColSpArray(PBYTE, PBYTE, DWORD, BOOL);

								DWORD CreateColSpProc(PBYTE, PBYTE, DWORD, BOOL);

								DWORD CreateFloatString(PBYTE, PBYTE, DWORD);

								DWORD CreateInputArray(PBYTE, DWORD, DWORD, PBYTE, DWORD, PBYTE, BOOL, PBYTE);

								DWORD CreateOutputArray(PBYTE, DWORD, DWORD, DWORD, PBYTE, DWORD, PBYTE, BOOL, PBYTE);


								DWORD GetPublicArrayName(DWORD, PBYTE);

								BOOL  GetRevCurve(PCURVETYPE, PWORD, PWORD);

								VOID  GetCLUTInfo(DWORD, PBYTE, PDWORD, PDWORD, PDWORD, PDWORD, PDWORD, PDWORD);

								DWORD EnableGlobalDict(PBYTE);

								DWORD BeginGlobalDict(PBYTE);

								DWORD EndGlobalDict(PBYTE);


								DWORD WriteNewLineObject(PBYTE, const char *);

								DWORD WriteHNAToken(PBYTE, BYTE, DWORD);

								DWORD WriteIntStringU2S(PBYTE, PBYTE, DWORD);

								DWORD WriteIntStringU2S_L(PBYTE, PBYTE, DWORD);

								DWORD WriteHexBuffer(PBYTE, PBYTE, PBYTE, DWORD);

								DWORD WriteStringToken(PBYTE, BYTE, DWORD);

								DWORD WriteByteString(PBYTE, PBYTE, DWORD);

								DWORD WriteInt2ByteString(PBYTE, PBYTE, DWORD);

								DWORD WriteFixed(PBYTE, FIX_16_16);

								DWORD WriteFixed2dot30(PBYTE, DWORD);

								#if !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)

								DWORD WriteDouble(PBYTE, double);


								BOOL  CreateMatrixCRD(PBYTE, PBYTE, PDWORD, DWORD, BOOL);

								DWORD CreateHostLutCRD(PBYTE, DWORD, PBYTE, DWORD);

								DWORD CreateHostMatrixCSAorCRD(PBYTE, PBYTE, PDWORD, DWORD, BOOL);

								DWORD CreateHostInputOutputArray(PBYTE, PBYTE*, DWORD, DWORD, DWORD, DWORD, PBYTE);

								DWORD CreateHostTRCInputTable(PBYTE, PHOSTCLUT, PCURVETYPE, PCURVETYPE, PCURVETYPE);

								DWORD CreateHostRevTRCInputTable(PBYTE, PHOSTCLUT, PCURVETYPE, PCURVETYPE, PCURVETYPE);


								BOOL  CheckInputOutputTable(PHOSTCLUT, float*, BOOL, BOOL);

								BOOL  CheckColorLookupTable(PHOSTCLUT, float*);


								BOOL  DoHostConversionCSA(PHOSTCLUT, float*, float*);

								BOOL  DoHostConversionCRD(PHOSTCLUT, PHOSTCLUT, float*, float*, BOOL);


								float g(float);

								float inverse_g(float);

								BOOL  TableInterp3(PHOSTCLUT, float*);

								BOOL  TableInterp4(PHOSTCLUT, float*);

								void  LabToXYZ(float*, float*, PFIX_16_16);

								void  XYZToLab(float*, float*, PFIX_16_16);

								VOID  ApplyMatrix(FIX_16_16 *e, float *Input, float *Output);


								BOOL  CreateColorantArray(PBYTE, double *, DWORD);

								BOOL  InvertColorantArray(double *, double *);

								#endif


								DWORD crc32(PBYTE buff, DWORD length);


								//

								// Global variables

								//


								const char  ASCII85DecodeBegin[] = "<~";

								const char  ASCII85DecodeEnd[]   = "~> cvx exec ";

								const char  TestingDEFG[]       = "/SupportDEFG? {/CIEBasedDEFG \

								 /ColorSpaceFamily resourcestatus { pop pop languagelevel 3 ge}{false} ifelse} def";

								const char  SupportDEFG_S[]     = "SupportDEFG? { ";

								const char  NotSupportDEFG_S[]  = "SupportDEFG? not { ";

								const char  SupportDEFG_E[]     = "}if ";

								const char  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 ";


								const char  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 ";

								const char  StartClip[]         = "dup 1.0 le{dup 0.0 ge{" ;

								const char  EndClip[]           = "}if}if " ;

								const char  BeginString[]       = "<";

								const char  EndString[]         = ">";

								const char  BeginArray[]        = "[";

								const char  EndArray[]          = "]";

								const char  BeginFunction[]     = "{";

								const char  EndFunction[]       = "}bind ";

								const char  BeginDict[]         = "<<" ;

								const char  EndDict[]           = ">>" ;

								const char  BlackPoint[]        = "[0 0 0]" ;

								const char  DictType[]          = "/ColorRenderingType 1 ";

								const char  IntentType[]        = "/RenderingIntent ";

								const char  IntentPer[]         = "/Perceptual";

								const char  IntentSat[]         = "/Saturation";

								const char  IntentACol[]        = "/AbsoluteColorimetric";

								const char  IntentRCol[]        = "/RelativeColorimetric";


								const char  WhitePointTag[]     = "/WhitePoint " ;

								const char  BlackPointTag[]     = "/BlackPoint " ;

								const char  RangePQRTag[]       = "/RangePQR " ;

								const char  TransformPQRTag[]   = "/TransformPQR " ;

								const char  MatrixPQRTag[]      = "/MatrixPQR " ;

								const char  RangePQR[]          = "[ -0.07 2.2 -0.02 1.4 -0.2 4.8 ]";

								const char  MatrixPQR[]         = "[0.8951 -0.7502 0.0389 0.2664 1.7135 -0.0685 -0.1614 0.0367 1.0296]";

								#ifdef BRADFORD_TRANSFORM

								const 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 " };

								#else

								const char  *TransformPQR[3]    = {"4 index 0 get div 2 index 0 get mul 4 {exch pop} repeat ",

								                                   "4 index 1 get div 2 index 1 get mul 4 {exch pop} repeat ",

								                                   "4 index 2 get div 2 index 2 get mul 4 {exch pop} repeat " };

								#endif

								const char  RangeABCTag[]       = "/RangeABC " ;

								const char  MatrixATag[]        = "/MatrixA ";

								const char  MatrixABCTag[]      = "/MatrixABC ";

								const char  EncodeABCTag[]      = "/EncodeABC " ;

								const char  RangeLMNTag[]       = "/RangeLMN " ;

								const char  MatrixLMNTag[]      = "/MatrixLMN " ;

								const char  EncodeLMNTag[]      = "/EncodeLMN " ;

								const char  RenderTableTag[]    = "/RenderTable " ;

								const char  CIEBasedATag[]      = "/CIEBasedA " ;

								const char  CIEBasedABCTag[]    = "/CIEBasedABC " ;

								const char  CIEBasedDEFGTag[]   = "/CIEBasedDEFG " ;

								const char  CIEBasedDEFTag[]    = "/CIEBasedDEF " ;

								const char  DecodeATag[]        = "/DecodeA " ;

								const char  DecodeABCTag[]      = "/DecodeABC " ;

								const char  DecodeLMNTag[]      = "/DecodeLMN " ;

								const char  DeviceRGBTag[]      = "/DeviceRGB " ;

								const char  DeviceCMYKTag[]     = "/DeviceCMYK " ;

								const char  DeviceGrayTag[]     = "/DeviceGray " ;

								const char  TableTag[]          = "/Table " ;

								const char  DecodeDEFGTag[]     = "/DecodeDEFG " ;

								const char  DecodeDEFTag[]      = "/DecodeDEF " ;


								const char  NullOp[]            = "";

								const char  DupOp[]             = "dup ";

								const char  UserDictOp[]        = "userdict ";

								const char  GlobalDictOp[]      = "globaldict ";

								const char  CurrentGlobalOp[]   = "currentglobal ";

								const char  SetGlobalOp[]       = "setglobal ";

								const char  DefOp[]             = "def ";

								const char  BeginOp[]           = "begin ";

								const char  EndOp[]             = "end ";

								const char  TrueOp[]            = "true ";

								const char  FalseOp[]           = "false ";

								const char  MulOp[]             = "mul ";

								const char  DivOp[]             = "div ";


								const char  NewLine[]           = "\r\n" ;

								const char  Slash[]             = "/" ;

								const char  Space[]             = " " ;

								const char  CRDBegin[]          = "%** CRD Begin ";

								const char  CRDEnd[]            = "%** CRD End ";

								const char  CieBasedDEFGBegin[] = "%** CieBasedDEFG CSA Begin ";

								const char  CieBasedDEFBegin[]  = "%** CieBasedDEF CSA Begin ";

								const char  CieBasedABCBegin[]  = "%** CieBasedABC CSA Begin ";

								const char  CieBasedABegin[]    = "%** CieBasedA CSA Begin ";

								const char  CieBasedDEFGEnd[]   = "%** CieBasedDEFG CSA End ";

								const char  CieBasedDEFEnd[]    = "%** CieBasedDEF CSA End ";

								const char  CieBasedABCEnd[]    = "%** CieBasedABC CSA End ";

								const char  CieBasedAEnd[]      = "%** CieBasedA CSA End ";

								const char  RangeABC[]          = "[ 0 1 0 1 0 1 ] ";

								const char  RangeLMN[]          = "[ 0 2 0 2 0 2 ] ";

								const char  Identity[]          = "[1 0 0 0 1 0 0 0 1]";

								const char  RangeABC_Lab[]      = "[0 100 -128 127 -128 127]";

								const char  Clip01[]            = "dup 1.0 ge{pop 1.0}{dup 0.0 lt{pop 0.0}if}ifelse " ;

								const char  DecodeA3[]          = "256 div exp ";

								const char  DecodeA3Rev[]       = "256 div 1.0 exch div exp ";

								const char  DecodeABCArray[]    = "DecodeABC_";

								const char  InputArray[]        = "Inp_";

								const char  OutputArray[]       = "Out_";

								const char  Scale8[]            = "255 div " ;

								const char  Scale16[]           = "65535 div " ;

								const char  Scale16XYZ[]        = "32768 div " ;

								const char  TFunction8[]        = "exch 255 mul round cvi get 255 div " ;

								const char  TFunction8XYZ[]     = "exch 255 mul round cvi get 128 div " ;

								const char  MatrixABCLab[]      = "[1 1 1 1 0 0 0 0 -1]" ;

								const char  DecodeABCLab1[]     = "[{16 add 116 div} bind {500 div} bind {200 div} bind]";

								const char  DecodeALab[]        = " 50 mul 16 add 116 div ";

								const char  DecodeLMNLab[]      = "dup 0.206897 ge{dup dup mul mul}{0.137931 sub 0.128419 mul} ifelse ";


								const char  RangeLMNLab[]       = "[0 1 0 1 0 1]" ;

								const char  EncodeLMNLab[]      = "dup 0.008856 le{7.787 mul 0.13793 add}{0.3333 exp}ifelse " ;


								const char  MatrixABCLabCRD[]   = "[0 500 0 116 -500 200 0 0 -200]" ;

								const char  MatrixABCXYZCRD[]   = "[0 1 0 1 0 0 0 0 1]" ;

								const char  EncodeABCLab1[]     = "16 sub 100 div " ;

								const char  EncodeABCLab2[]     = "128 add 255 div " ;

								const char  *DecodeABCLab[]     = {"50 mul 16 add 116 div ",

								                                   "128 mul 128 sub 500 div",

								                                   "128 mul 128 sub 200 div"};


								const char ColorSpace1[]        = "/CIEBasedABC << /DecodeLMN ";

								const char ColorSpace3[]        = " exp} bind ";

								const char ColorSpace5[]        = "/WhitePoint [0.9642 1 0.8249] ";


								const char PreViewInArray[]     = "IPV_";

								const char PreViewOutArray[]    = "OPV_";


								const char sRGBColorSpaceArray[] = "[/CIEBasedABC << \r\n\

								/DecodeLMN [{dup 0.03928 le {12.92321 div}{0.055 add 1.055 div 2.4 exp}ifelse} bind dup dup ] \r\n\

								/MatrixLMN [0.412457 0.212673 0.019334 0.357576 0.715152 0.119192 0.180437 0.072175 0.950301] \r\n\

								/WhitePoint [ 0.9505 1 1.0890 ] >> ]";


								#ifdef BRADFORD_TRANSFORM

								const char sRGBColorRenderingDictionary[] = "\

								/RangePQR [ -0.5 2 -0.5 2 -0.5 2 ] \r\n\

								/MatrixPQR [0.8951 -0.7502  0.0389 0.2664  1.7135 -0.0685 -0.1614  0.0367  1.0296] \r\n\

								/TransformPQR [\

								{exch pop exch 3 get mul exch pop exch 3 get div} bind \

								{exch pop exch 4 get mul exch pop exch 4 get div} bind \

								{exch pop exch 5 get mul exch pop exch 5 get div} bind] \r\n\

								/MatrixLMN [3.240449 -0.969265  0.055643 -1.537136  1.876011 -0.204026 -0.498531  0.041556  1.057229] \r\n\

								/EncodeABC [{dup 0.00304 le {12.92321 mul}{1 2.4 div exp 1.055 mul 0.055 sub}ifelse} bind dup dup] \r\n\

								/WhitePoint[0.9505 1 1.0890] >>";

								#else

								const char sRGBColorRenderingDictionary[] = "\

								/RangePQR [ -0.5 2 -0.5 2 -0.5 2 ] \r\n\

								/MatrixPQR [0.8951 -0.7502  0.0389 0.2664  1.7135 -0.0685 -0.1614  0.0367  1.0296] \r\n\

								/TransformPQR [\

								{4 index 0 get div 2 index 0 get mul 4 {exch pop} repeat} \

								{4 index 1 get div 2 index 1 get mul 4 {exch pop} repeat} \

								{4 index 2 get div 2 index 2 get mul 4 {exch pop} repeat}] \r\n\

								/MatrixLMN [3.240449 -0.969265  0.055643 -1.537136  1.876011 -0.204026 -0.498531  0.041556  1.057229] \r\n\

								/EncodeABC [{dup 0.00304 le {12.92321 mul}{1 2.4 div exp 1.055 mul 0.055 sub}ifelse} bind dup dup] \r\n\

								/WhitePoint[0.9505 1 1.0890] >>";

								#endif


								/******************************************************************************

								 *

								 *                       InternalGetPS2ColorSpaceArray

								 *

								 *  Function:

								 *       This functions retrieves the PostScript Level 2 CSA from the profile,

								 *       or creates it if the profile tag is not present

								 *

								 *  Arguments:

								 *       hProfile  - handle identifing the profile object

								 *       dwIntent  - rendering intent of CSA

								 *       dwCSAType - type of CSA

								 *       pbuffer   - pointer to receive the CSA

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								InternalGetPS2ColorSpaceArray (

								    PBYTE     pProfile,

								    DWORD     dwIntent,

								    DWORD     dwCSAType,

								    PBYTE     pBuffer,

								    PDWORD    pcbSize,

								    LPBOOL    pbBinary

								    )

								{

								    DWORD dwInpBufSize;

								    BOOL  bRc;


								    //

								    // If profile has a CSA tag, get it directly

								    //


								    bRc = GetCSAFromProfile(pProfile, dwIntent, dwCSAType, pBuffer,

								              pcbSize, pbBinary);


								    if (! bRc && (GetLastError() != ERROR_INSUFFICIENT_BUFFER))

								    {

								        //

								        // Create a CSA from the profile data

								        //


								        switch (dwCSAType)

								        {

								        case CSA_ABC:

								            bRc = GetPS2CSA_ABC(pProfile, pBuffer, pcbSize,

								                      dwIntent, pbBinary, FALSE);

								            break;


								        case CSA_DEF:

								            bRc = GetPS2CSA_DEFG(pProfile, pBuffer, pcbSize, dwIntent,

								                      TYPE_CIEBASEDDEF, pbBinary);

								            break;


								        case CSA_RGB:

								        case CSA_Lab:


								            dwInpBufSize = *pcbSize;


								            //

								            // We get a DEF CSA followed by an ABC CSA and set it up so that

								            // on PS interpreters that do not support the DEF CSA, the ABC one

								            // is active

								            //


								            bRc = GetPS2CSA_DEFG(pProfile, pBuffer, pcbSize, dwIntent,

								                      TYPE_CIEBASEDDEF, pbBinary);


								            if (bRc)

								            {

								                //

								                // Create CieBasedABC for printers that do not support CieBasedDEF

								                //


								                DWORD cbNewSize = 0;

								                PBYTE pNewBuffer;

								                PBYTE pOldBuffer;


								                if (pBuffer)

								                {

								                    pNewBuffer = pBuffer + *pcbSize;

								                    pOldBuffer = pNewBuffer;

								                    pNewBuffer += WriteObject(pNewBuffer, NewLine);

								                    if (dwCSAType == CSA_Lab)

								                    {

								                        pNewBuffer += WriteNewLineObject(pNewBuffer, NotSupportDEFG_S);

								                    }

								                    cbNewSize = dwInpBufSize - (DWORD)(pNewBuffer - pBuffer);

								                }

								                else

								                {

								                    pNewBuffer = NULL;

								                }


								                bRc = GetPS2CSA_ABC(pProfile, pNewBuffer, &cbNewSize,

								                          dwIntent, pbBinary, TRUE);


								                if (pBuffer)

								                {

								                    pNewBuffer += cbNewSize;

								                    if (dwCSAType == CSA_Lab)

								                    {

								                        pNewBuffer += WriteNewLineObject(pNewBuffer, SupportDEFG_E);

								                    }

								                    *pcbSize += (DWORD) (pNewBuffer - pOldBuffer);

								                }

								                else

								                {

								                    *pcbSize += cbNewSize;

								                }


								            }

								            else

								            {

								                *pcbSize = dwInpBufSize;


								                bRc = GetPS2CSA_ABC(pProfile, pBuffer, pcbSize, dwIntent, pbBinary, FALSE);

								            }


								            break;


								        case CSA_CMYK:

								        case CSA_DEFG:

								            bRc = GetPS2CSA_DEFG(pProfile, pBuffer, pcbSize, dwIntent,

								                      TYPE_CIEBASEDDEFG, pbBinary);

								            break;


								        case CSA_GRAY:

								        case CSA_A:

								            bRc = GetPS2CSA_MONO_A(pProfile, pBuffer, pcbSize, dwIntent, pbBinary);

								            break;


								        default:

								            WARNING((__TEXT("Invalid CSA type passed to GetPS2ColorSpaceArray: %d\n"), dwCSAType));

								            SetLastError(ERROR_INVALID_PARAMETER);

								            return FALSE;

								        }

								    }


								    return bRc;

								}


								/******************************************************************************

								 *

								 *                       InternalGetPS2ColorRenderingIntent

								 *

								 *  Function:

								 *       This functions retrieves the PostScript Level 2 color rendering intent

								 *       from the profile, or creates it if the profile tag is not present

								 *

								 *  Arguments:

								 *       hProfile  - handle identifing the profile object

								 *       pbuffer   - pointer to receive the color rendering intent

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								InternalGetPS2ColorRenderingIntent(

								    PBYTE     pProfile,

								    DWORD     dwIntent,

								    PBYTE     pBuffer,

								    PDWORD    pcbSize

								    )

								{

								    DWORD dwIndex, dwTag, dwSize;

								    BOOL  bRc = FALSE;


								    switch (dwIntent)

								    {

								    case INTENT_PERCEPTUAL:

								        dwTag = TAG_PS2INTENT0;

								        break;


								    case INTENT_RELATIVE_COLORIMETRIC:

								        dwTag = TAG_PS2INTENT1;

								        break;


								    case INTENT_SATURATION:

								        dwTag = TAG_PS2INTENT2;

								        break;


								    case INTENT_ABSOLUTE_COLORIMETRIC:

								        dwTag = TAG_PS2INTENT3;

								        break;


								    default:

								        WARNING((__TEXT("Invalid intent passed to GetPS2ColorRenderingIntent: %d\n"), dwIntent));

								        SetLastError(ERROR_INVALID_PARAMETER);

								        return FALSE;

								    }


								    if (DoesCPTagExist(pProfile, dwTag, &dwIndex))

								    {

								        (void)GetCPElementDataSize(pProfile, dwIndex, &dwSize);


								        if (pBuffer)

								        {

								            if (*pcbSize >= dwSize + 1) // for NULL terminating

								            {

								                bRc = GetCPElementData(pProfile, dwIndex, pBuffer, &dwSize);

								            }

								            else

								            {

								                WARNING((__TEXT("Buffer too small to get CRI\n")));

								                SetLastError(ERROR_INSUFFICIENT_BUFFER);

								            }

								        }

								        else

								            bRc = TRUE;


								        *pcbSize = dwSize;

								    }

								    else

								    {

								        WARNING((__TEXT("psi tag not present for intent %d in profile\n"), dwIntent));

								        SetLastError(ERROR_TAG_NOT_PRESENT);

								    }


								    //

								    // NULL terminate

								    //


								    if (bRc)

								    {

								        if (pBuffer)

								        {

								            pBuffer[*pcbSize] = '\0';

								        }

								        (*pcbSize)++;

								    }


								    return bRc;

								}


								/******************************************************************************

								 *

								 *                       InternalGetPS2ColorRenderingDictionary

								 *

								 *  Function:

								 *       This functions retrieves the PostScript Level 2 CRD from the profile,

								 *       or creates it if the profile tag is not preesnt

								 *

								 *  Arguments:

								 *       hProfile  - handle identifing the profile object

								 *       dwIntent  - intent whose CRD is required

								 *       pbuffer   - pointer to receive the CSA

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								InternalGetPS2ColorRenderingDictionary(

								    PBYTE     pProfile,

								    DWORD     dwIntent,

								    PBYTE     pBuffer,

								    PDWORD    pcbSize,

								    PBOOL     pbBinary

								    )

								{

								    DWORD dwIndex, dwSize, dwDataType;

								    DWORD dwCRDTag, dwBToATag;

								    BOOL  bRc = FALSE;


								    switch (dwIntent)

								    {

								    case INTENT_PERCEPTUAL:

								        dwCRDTag = TAG_CRDINTENT0;

								        dwBToATag = TAG_BToA0;

								        break;


								    case INTENT_RELATIVE_COLORIMETRIC:

								        dwCRDTag = TAG_CRDINTENT1;

								        dwBToATag = TAG_BToA1;

								        break;


								    case INTENT_SATURATION:

								        dwCRDTag = TAG_CRDINTENT2;

								        dwBToATag = TAG_BToA2;

								        break;


								    case INTENT_ABSOLUTE_COLORIMETRIC:

								        dwCRDTag = TAG_CRDINTENT3;

								        dwBToATag = TAG_BToA1;

								        break;


								    default:

								        WARNING((__TEXT("Invalid intent passed to GetPS2ColorRenderingDictionary: %d\n"), dwIntent));

								        SetLastError(ERROR_INVALID_PARAMETER);

								        return bRc;

								    }


								    if (DoesCPTagExist(pProfile, dwCRDTag, &dwIndex))

								    {

								        (void)GetCPElementDataSize(pProfile, dwIndex, &dwSize);


								        (void)GetCPElementDataType(pProfile, dwIndex, &dwDataType);


								        if (! *pbBinary && dwDataType == 1)

								        {

								            //

								            // Profile has binary data, user asked for ASCII, so we have to

								            // ASCII 85 encode it

								            //


								            dwSize = dwSize * 5 / 4 + sizeof(ASCII85DecodeBegin) + sizeof(ASCII85DecodeEnd) + 2048;

								        }


								        if (pBuffer)

								        {

								            if (*pcbSize >= dwSize)

								            {

								                (void)GetCPElementData(pProfile, dwIndex, pBuffer, &dwSize);


								                if (! *pbBinary && dwDataType == 1)

								                {

								                    dwSize = Ascii85Encode(pBuffer, dwSize, *pcbSize);

								                }

								                bRc = TRUE;

								            }

								            else

								            {

								                WARNING((__TEXT("Buffer too small to get CRD\n")));

								                SetLastError(ERROR_INSUFFICIENT_BUFFER);

								            }

								        }

								        else

								            bRc = TRUE;


								        *pcbSize = dwSize;

								    }

								    else if (DoesCPTagExist(pProfile, dwBToATag, &dwIndex))

								    {

								        bRc = CreateLutCRD(pProfile, dwIndex, pBuffer, pcbSize, dwIntent, *pbBinary);

								    }

								    else if (DoesCPTagExist(pProfile, TAG_GRAYTRC, &dwIndex))

								    {

								        bRc = CreateMonoCRD(pProfile, dwIndex, pBuffer, pcbSize, dwIntent);

								    }

								#if !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)

								    else if (DoesTRCAndColorantTagExist(pProfile))

								    {

								        bRc = CreateMatrixCRD(pProfile, pBuffer, pcbSize, dwIntent, *pbBinary);

								    }

								#endif // !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)

								    else

								    {

								        WARNING((__TEXT("Profile doesn't have tags to create CRD\n")));

								        SetLastError(ERROR_INVALID_PROFILE);

								    }


								    return bRc;

								}


								#if !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								/******************************************************************************

								 *

								 *                    InternalGetPS2PreviewCRD

								 *

								 *  Function:

								 *       This functions creates a preview PostScript Level 2 CRD from the

								 *       specified destination and target profiles

								 *       To do this, it does the following:

								 *           1) Creates host deviceCRD deviceCSA targetCRD.

								 *           2) Creates proofing CRD by sampling deviceCRD deviceCSA and targetCRD.

								 *           3) Uses deviceCRD's input table as proofingCRD's input table.

								 *           4) Uses targetCRD's output table as proofingCRD's output table.

								 *           5) Sample data is XYZ or Lab, depends on PCS of targetCRD.

								 *

								 *  Arguments:

								 *       pDestProf    - memory mapped pointer to destination profile

								 *       pTargetProf  - memory mapped pointer to target profile

								 *       dwIntent     - intent whose CRD is required

								 *       pbuffer      - pointer to receive the CSA

								 *       pcbSize      - pointer to size of buffer. If function fails because

								 *                      buffer is not big enough, it is filled with required size.

								 *       pcbBinary    - TRUE if binary data is requested. On return it is set to

								 *                      reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								InternalGetPS2PreviewCRD(

								    PBYTE   pDestProf,

								    PBYTE   pTargetProf,

								    DWORD   dwIntent,

								    PBYTE   pBuffer,

								    PDWORD  pcbSize,

								    PBOOL   pbBinary

								    )

								{

								    DWORD      i, j, k, l, dwDev, dwTag, dwPCS;

								    DWORD      dwInArraySize = 0, dwOutArraySize = 0;

								    DWORD      nDevGrids, nTargetGrids, nPreviewCRDGrids;

								    DWORD      cbDevCRD, cbTargetCSA, cbTargetCRD;

								    float      fInput[MAXCHANNELS];

								    float      fOutput[MAXCHANNELS];

								    float      fTemp[MAXCHANNELS];

								    PBYTE      pLineStart, pStart = pBuffer;

								    PBYTE      lpDevCRD = NULL, lpTargetCSA = NULL, lpTargetCRD = NULL;

								    char       pPublicArrayName[5];

								    BOOL       bRc = FALSE;


								    dwDev = GetCPDevSpace(pTargetProf);

								    i = (dwDev == SPACE_CMYK) ? 4 : 3;


								    //

								    // Get the input array size IntentTag and Grid of the destination profile

								    //


								    if (!GetCRDInputOutputArraySize(

								            pTargetProf,

								            dwIntent,

								            &dwInArraySize,

								            NULL,

								            &dwTag,

								            &nTargetGrids))

								        return FALSE;


								    //

								    // Get the output array size IntentTag and Grid of the target profile

								    //


								    if (!GetCRDInputOutputArraySize(

								            pDestProf,

								            dwIntent,

								            NULL,

								            &dwOutArraySize,

								            &dwTag,

								            &nDevGrids))

								        return FALSE;


								    nPreviewCRDGrids = (nTargetGrids > nDevGrids) ? nTargetGrids : nDevGrids;


								    //

								    // Min proofing CRD grid will be PREVIEWCRDGRID

								    //


								    if (nPreviewCRDGrids < PREVIEWCRDGRID)

								        nPreviewCRDGrids = PREVIEWCRDGRID;


								    if (pBuffer == NULL)

								    {

								        //

								        // Return size of buffer needed

								        //


								        *pcbSize = nPreviewCRDGrids * nPreviewCRDGrids * nPreviewCRDGrids *

								                   i * 2        +    // CLUT size (Hex output)

								                   dwOutArraySize +  // Output Array size

								                   dwInArraySize  +  // Input Array size

								                   4096;             // Extra PostScript stuff


								        //

								        // Add space for new line.

								        //


								        *pcbSize += (((*pcbSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								        return TRUE;

								    }


								    //

								    // Query the sizes of host target CRD, target CSA and device CRD

								    //


								    if (!GetHostColorRenderingDictionary(pTargetProf, dwIntent, NULL, &cbTargetCRD) ||

								        !GetHostColorSpaceArray(pTargetProf, dwIntent, NULL, &cbTargetCSA) ||

								        !GetHostColorRenderingDictionary(pDestProf, dwIntent, NULL, &cbDevCRD))

								    {

								        return FALSE;

								    }


								    //

								    // Allocate buffers for host target CRD, target CSA and device CRD

								    //


								    if (((lpTargetCRD = MemAlloc(cbTargetCRD)) == NULL) ||

								        ((lpTargetCSA = MemAlloc(cbTargetCSA)) == NULL) ||

								        ((lpDevCRD = MemAlloc(cbDevCRD)) == NULL))

								    {

								        goto Done;

								    }


								    //

								    // Build host target CRD, target CSA and device CRD

								    //


								    if (!GetHostColorRenderingDictionary(pTargetProf, dwIntent, lpTargetCRD, &cbTargetCRD) ||

								        !GetHostColorSpaceArray(pTargetProf, dwIntent, lpTargetCSA, &cbTargetCSA) ||

								        !GetHostColorRenderingDictionary(pDestProf, dwIntent, lpDevCRD, &cbDevCRD))

								    {

								        goto Done;

								    }


								    //

								    // Create global data

								    //


								    GetPublicArrayName(dwTag, pPublicArrayName);


								    //

								    // Build Proofing CRD based on Host target CRD, target CSA and dest CRD.

								    // We use target CRD input tables and matrix as the input tables and

								    // matrix of the ProofCRD. We use dest CRD output tables as the

								    // output tables of the ProofCRD.

								    //


								    pBuffer += WriteNewLineObject(pBuffer, CRDBegin);


								    pBuffer += EnableGlobalDict(pBuffer);

								    pBuffer += BeginGlobalDict(pBuffer);


								    pBuffer += CreateInputArray(pBuffer, 0, 0, pPublicArrayName,

								                    0, NULL, *pbBinary, lpTargetCRD);


								    pBuffer += CreateOutputArray(pBuffer, 0, 0, 0,

								                    pPublicArrayName, 0, NULL, *pbBinary, lpDevCRD);


								    pBuffer += EndGlobalDict(pBuffer);


								    //

								    // Start writing the CRD

								    //


								    pBuffer += WriteNewLineObject(pBuffer, BeginDict);     // Begin dictionary

								    pBuffer += WriteObject(pBuffer, DictType);      // Dictionary type


								    //

								    // Send /RenderingIntent

								    //


								    switch (dwIntent)

								    {

								        case INTENT_PERCEPTUAL:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentPer);

								            break;


								        case INTENT_SATURATION:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentSat);

								            break;


								        case INTENT_RELATIVE_COLORIMETRIC:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentRCol);

								            break;


								        case INTENT_ABSOLUTE_COLORIMETRIC:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentACol);

								            break;

								    }


								    //

								    // /BlackPoint & /WhitePoint

								    //


								    pBuffer += SendCRDBWPoint(pBuffer, ((PHOSTCLUT)lpTargetCRD)->afxIlluminantWP);


								    //

								    // Send PQR - used for Absolute Colorimetric

								    //


								    pBuffer += SendCRDPQR(pBuffer, dwIntent, ((PHOSTCLUT)lpTargetCRD)->afxIlluminantWP);


								    //

								    // Send LMN - For Absolute Colorimetric use WhitePoint's XYZs

								    //


								    pBuffer += SendCRDLMN(pBuffer, dwIntent,

								                   ((PHOSTCLUT)lpTargetCRD)->afxIlluminantWP,

								                   ((PHOSTCLUT)lpTargetCRD)->afxMediaWP,

								                   ((PHOSTCLUT)lpTargetCRD)->dwPCS);


								    //

								    // Send ABC

								    //


								    pBuffer += SendCRDABC(pBuffer, pPublicArrayName,

								                   ((PHOSTCLUT)lpTargetCRD)->dwPCS,

								                   ((PHOSTCLUT)lpTargetCRD)->nInputCh,

								                   NULL,

								                   ((PHOSTCLUT)lpTargetCRD)->e,

								                   (((PHOSTCLUT)lpTargetCRD)->nLutBits == 8)? LUT8_TYPE : LUT16_TYPE,

								                   *pbBinary);


								    //

								    // /RenderTable

								    //


								    pBuffer += WriteNewLineObject(pBuffer, RenderTableTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);


								    pBuffer += WriteInt(pBuffer, nPreviewCRDGrids);  // Send down Na

								    pBuffer += WriteInt(pBuffer, nPreviewCRDGrids);  // Send down Nb

								    pBuffer += WriteInt(pBuffer, nPreviewCRDGrids);  // Send down Nc


								    pLineStart = pBuffer;

								    pBuffer += WriteNewLineObject(pBuffer, BeginArray);

								    dwPCS = ((PHOSTCLUT)lpDevCRD)->dwPCS;


								    for (i=0; i<nPreviewCRDGrids; i++)        // Na strings should be sent

								    {

								        pBuffer += WriteObject(pBuffer, NewLine);

								        pLineStart = pBuffer;

								        if (*pbBinary)

								        {

								            pBuffer += WriteStringToken(pBuffer, 143,

								                nPreviewCRDGrids * nPreviewCRDGrids * ((PHOSTCLUT)lpDevCRD)->nOutputCh);

								        }

								        else

								        {

								            pBuffer += WriteObject(pBuffer, BeginString);

								        }

								        fInput[0] = ((float)i) / (nPreviewCRDGrids - 1);

								        for (j=0; j<nPreviewCRDGrids; j++)

								        {

								            fInput[1] = ((float)j) / (nPreviewCRDGrids - 1);

								            for (k=0; k<nPreviewCRDGrids; k++)

								            {

								                fInput[2] = ((float)k) / (nPreviewCRDGrids - 1);


								                DoHostConversionCRD((PHOSTCLUT)lpTargetCRD, NULL, fInput, fOutput, 1);

								                DoHostConversionCSA((PHOSTCLUT)lpTargetCSA, fOutput, fTemp);

								                DoHostConversionCRD((PHOSTCLUT)lpDevCRD, (PHOSTCLUT)lpTargetCSA,

								                                     fTemp, fOutput, 0);

								                for (l=0; l<((PHOSTCLUT)lpDevCRD)->nOutputCh; l++)

								                {

								                    if (*pbBinary)

								                    {

								                        *pBuffer++ = (BYTE)(fOutput[l] * 255);

								                    }

								                    else

								                    {

								                        pBuffer += WriteHex(pBuffer, (USHORT)(fOutput[l] * 255));

								                        if ((pBuffer - pLineStart) > MAX_LINELEN)

								                        {

								                            pLineStart = pBuffer;

								                            pBuffer += WriteObject(pBuffer, NewLine);

								                        }

								                    }

								                }

								            }

								        }

								        if (!*pbBinary)

								            pBuffer += WriteObject(pBuffer, EndString);

								    }

								    pBuffer += WriteNewLineObject(pBuffer, EndArray);

								    pBuffer += WriteInt(pBuffer, ((PHOSTCLUT)lpDevCRD)->nOutputCh);


								    //

								    // Send output table

								    //


								    pBuffer += SendCRDOutputTable(pBuffer, pPublicArrayName,

								                    ((PHOSTCLUT)lpDevCRD)->nOutputCh,

								                    (((PHOSTCLUT)lpDevCRD)->nLutBits == 8)? LUT8_TYPE : LUT16_TYPE,

								                    TRUE,

								                    *pbBinary);


								    pBuffer += WriteNewLineObject(pBuffer, EndArray);

								    pBuffer += WriteObject(pBuffer, EndDict); // End dictionary definition

								    pBuffer += WriteNewLineObject(pBuffer, CRDEnd);

								    bRc = TRUE;


								Done:

								    *pcbSize = (DWORD)(pBuffer - pStart);


								    if (lpTargetCRD)

								         MemFree(lpTargetCRD);

								    if (lpTargetCSA)

								         MemFree(lpTargetCSA);

								    if (lpDevCRD)

								         MemFree(lpDevCRD);


								    return bRc;

								}


								#endif //  !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								/******************************************************************************

								 *

								 *                               GetCSAFromProfile

								 *

								 *  Function:

								 *       This function gets the Color Space Array from the profile if the

								 *       tag is present

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped  profile

								 *       dwIntent  - rendering intent of CSA requested

								 *       dwCSAType - type of CSA requested

								 *       pBuffer   - pointer to receive the CSA

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								GetCSAFromProfile (

								    PBYTE  pProfile,

								    DWORD  dwIntent,

								    DWORD  dwCSAType,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    PBOOL  pbBinary

								    )

								{

								    DWORD dwDev, dwProfileIntent;

								    DWORD dwIndex, dwSize, dwDataType;

								    BOOL  bRc = FALSE;


								    //

								    // This function can fail without setting an error, so reset error

								    // here to prevent confusion later

								    //


								    SetLastError(0);


								    //

								    // Get the profile's color space and rendering intent

								    //


								    dwDev = GetCPDevSpace(pProfile);

								    dwProfileIntent = GetCPRenderIntent(pProfile);


								    //

								    // If the rendering intents don't match, or the profile's color space

								    // is incompatible with requested CSA type, fail

								    //


								    if  ((dwIntent != dwProfileIntent) ||

								         ((dwDev == SPACE_GRAY) &&

								         ((dwCSAType != CSA_GRAY) && (dwCSAType != CSA_A))))

								    {

								        WARNING((__TEXT("Can't use profile's CSA tag due to different rendering intents\n")));

								        return FALSE;

								    }


								    if (DoesCPTagExist(pProfile, TAG_PS2CSA, &dwIndex))

								    {

								        (void)GetCPElementDataSize(pProfile, dwIndex, &dwSize);


								        (void)GetCPElementDataType(pProfile, dwIndex, &dwDataType);


								        if (! *pbBinary && dwDataType == 1)

								        {

								            //

								            // Profile has binary data, user asked for ASCII, so we have to

								            // ASCII 85 encode it

								            //


								            dwSize = dwSize * 5 / 4 + sizeof(ASCII85DecodeBegin) + sizeof(ASCII85DecodeEnd) + 2048;

								        }


								        if (pBuffer)

								        {

								            if (*pcbSize >= dwSize)

								            {

								                (void)GetCPElementData(pProfile, dwIndex, pBuffer, &dwSize);


								                if (! *pbBinary && dwDataType == 1)

								                {

								                    dwSize = Ascii85Encode(pBuffer, dwSize, *pcbSize);

								                }

								                bRc = TRUE;

								            }

								            else

								            {

								                WARNING((__TEXT("Buffer too small to get CSA\n")));

								                SetLastError(ERROR_INSUFFICIENT_BUFFER);

								            }

								        }

								        else

								            bRc = TRUE;


								        *pcbSize = dwSize;

								    }


								    return bRc;

								}


								/******************************************************************************

								 *

								 *                              GetPS2CSA_MONO_A

								 *

								 *  Function:

								 *       This function creates a CIEBasedA colorspace array from an input

								 *       GRAY profile

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped profile

								 *       pBuffer   - pointer to receive the CSA

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       dwIntent  - rendering intent of CSA requested

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								GetPS2CSA_MONO_A(

								    PBYTE  pProfile,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    DWORD  dwIntent,

								    PBOOL  pbBinary

								    )

								{

								    PCURVETYPE pData;

								    PTAGDATA   pTagData;

								    PBYTE      pLineStart, pStart = pBuffer;

								    PBYTE      pTable;

								    DWORD      i, dwPCS, nCount;

								    DWORD      dwIndex, dwSize;

								    DWORD      afxIlluminantWP[3];

								    DWORD      afxMediaWP[3];


								    //

								    // Check if we can generate the CSA

								    // Required tag is gray TRC

								    //


								    if (! DoesCPTagExist(pProfile, TAG_GRAYTRC, &dwIndex))

								    {

								        WARNING((__TEXT("Gray TRC tag not present to create MONO_A CSA\n")));

								        SetLastError(ERROR_TAG_NOT_PRESENT);

								        return FALSE;

								    }


								    dwPCS = GetCPConnSpace(pProfile);


								    (void)GetCPElementSize(pProfile, dwIndex, &dwSize);


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    pData = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    nCount = FIX_ENDIAN(pData->nCount);


								    //

								    // Estimate size required to hold the CSA

								    //


								    dwSize = nCount * 6 +               // Number of INT elements

								        3 * (STRLEN(IndexArray) +

								             STRLEN(StartClip) +

								             STRLEN(EndClip)) +

								        2048;                           // + other PS stuff


								    //

								    // Add space for new line.

								    //


								    dwSize += (((dwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								    if (! pBuffer)

								    {

								        *pcbSize = dwSize;

								        return TRUE;

								    }

								    else if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get MONO_A CSA\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    //

								    // Get info about Illuminant White Point from the header

								    //


								    (void)GetCPWhitePoint(pProfile, afxIlluminantWP);


								    //

								    // Support absolute whitePoint

								    //


								    (void)GetMediaWP(pProfile, dwIntent, afxIlluminantWP, afxMediaWP);


								    //

								    // Start creating the ColorSpace

								    //


								    pBuffer += WriteNewLineObject(pBuffer, CieBasedABegin);


								    pBuffer += WriteNewLineObject(pBuffer, BeginArray);   // Begin array


								    //

								    // /CIEBasedA

								    //


								    pBuffer += WriteObject(pBuffer, CIEBasedATag); // Create entry

								    pBuffer += WriteObject(pBuffer, BeginDict);    // Begin dictionary


								    //

								    // Send /BlackPoint & /WhitePoint

								    //


								    pBuffer += SendCSABWPoint(pBuffer, dwIntent, afxIlluminantWP, afxMediaWP);


								    //

								    // /DecodeA

								    //


								    pBuffer += WriteObject(pBuffer, NewLine);

								    pLineStart = pBuffer;


								    if (nCount != 0)

								    {

								        pBuffer += WriteObject(pBuffer, DecodeATag);

								        pBuffer += WriteObject(pBuffer, BeginArray);


								        pBuffer += WriteObject(pBuffer, BeginFunction);


								        pTable = (PBYTE)(pData->data);


								        if (nCount == 1)                // Gamma supplied in ui16 format

								        {

								            pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)));

								            pBuffer += WriteObject(pBuffer, DecodeA3);


								            //

								            // If the PCS is Lab, we need to convert Lab to XYZ

								            // Now, the range is from 0 --> 0.99997.

								            // Actually, the conversion from Lab to XYZ is not needed

								            //


								            if (dwPCS == SPACE_Lab)

								            {

								                pBuffer += WriteObject(pBuffer, DecodeALab);

								                pBuffer += WriteObject(pBuffer, DecodeLMNLab);

								            }

								        }

								        else

								        {

								            pBuffer += WriteObject(pBuffer, StartClip);

								            pBuffer += WriteObject(pBuffer, BeginArray);

								            for (i=0; i<nCount; i++)

								            {

								                pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)));

								                pTable += sizeof(WORD);

								                if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                {

								                    pLineStart = pBuffer;

								                    pBuffer += WriteObject (pBuffer, NewLine);

								                }

								            }

								            pBuffer += WriteObject(pBuffer, EndArray);

								            pLineStart = pBuffer;

								            pBuffer += WriteObject(pBuffer, NewLine);


								            pBuffer += WriteObject(pBuffer, IndexArray);

								            pBuffer += WriteObject(pBuffer, Scale16);


								            //

								            // If the PCS is Lab, we need to convert Lab to XYZ

								            // Now, the range is from 0 --> .99997.

								            // Actually, the conversion from Lab to XYZ is not needed.

								            //


								            if (dwPCS == SPACE_Lab)

								            {

								                pBuffer += WriteObject(pBuffer, DecodeALab);

								                pBuffer += WriteObject(pBuffer, DecodeLMNLab);

								            }

								            pBuffer += WriteObject(pBuffer, EndClip);

								        }


								        pBuffer += WriteObject(pBuffer, EndFunction);

								        pBuffer += WriteObject(pBuffer, EndArray);

								    }


								    //

								    // /MatrixA

								    //


								    pBuffer += WriteNewLineObject(pBuffer, MatrixATag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<3; i++)

								    {

								        if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								        {

								            pBuffer += WriteFixed(pBuffer, afxMediaWP[i]);

								        }

								        else

								        {

								            pBuffer += WriteFixed(pBuffer, afxIlluminantWP[i]);

								        }

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    //

								    // /RangeLMN

								    //


								    pBuffer += WriteNewLineObject(pBuffer, RangeLMNTag);

								    pBuffer += WriteObject(pBuffer, RangeLMN);


								    //

								    // /End dictionary

								    //


								    pBuffer += WriteObject(pBuffer, EndDict);  // End dictionary definition

								    pBuffer += WriteObject(pBuffer, EndArray);


								    pBuffer += WriteNewLineObject(pBuffer, CieBasedAEnd);


								    *pcbSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								/******************************************************************************

								 *

								 *                              GetPS2CSA_ABC

								 *

								 *  Function:

								 *       This function creates a CIEBasedABC colorspace array from an input

								 *       RGB profile

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped profile

								 *       pBuffer   - pointer to receive the CSA

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       dwIntent  - rendering intent of CSA requested

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *       bBackup   - TRUE: A CIEBasedDEF has been created, this CSA is a backup

								 *                          in case some old printer can not support CIEBasedDEF.

								 *                   FALSE: No CIEBasedDEF. This is the only CSA.

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								GetPS2CSA_ABC(

								    PBYTE  pProfile,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    DWORD  dwIntent,

								    PBOOL  pbBinary,

								    BOOL   bBackup

								    )

								{

								    PBYTE     pStart = pBuffer;

								    DWORD     i, dwPCS, dwDev, dwSize;

								    FIX_16_16 afxIlluminantWP[3];

								    FIX_16_16 afxMediaWP[3];


								    //

								    // Check if we can generate the CSA:

								    // Required  tags are red, green and blue Colorants & TRCs

								    //


								    dwPCS = GetCPConnSpace(pProfile);

								    dwDev = GetCPDevSpace(pProfile);


								    //

								    // Call another function to handle Lab profiles

								    //


								    if (dwDev == SPACE_Lab)

								    {

								        return GetPS2CSA_ABC_Lab(pProfile, pBuffer, pcbSize, dwIntent, pbBinary);

								    }


								    //

								    // We only handle RGB profiles in this function

								    //


								    if ((dwDev != SPACE_RGB)                   ||

								        !DoesTRCAndColorantTagExist(pProfile))

								    {

								        WARNING((__TEXT("Colorant or TRC tag not present to create ABC CSA\n")));

								        SetLastError(ERROR_TAG_NOT_PRESENT);

								        return FALSE;

								    }


								    //

								    // Estimate size required to hold the CSA

								    //


								    dwSize = 65530;


								    if (! pBuffer)

								    {

								        *pcbSize = dwSize;

								        return TRUE;

								    }

								    else if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get ABC CSA\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    //

								    // Get info about Illuminant White Point from the header

								    //


								    (void)GetCPWhitePoint(pProfile, afxIlluminantWP);


								    //

								    // Support absolute whitePoint

								    //


								    (void)GetMediaWP(pProfile, dwIntent, afxIlluminantWP, afxMediaWP);


								    //

								    // Create global data

								    //


								    pBuffer += WriteNewLineObject(pBuffer, CieBasedABCBegin);


								    if (IsSRGBColorProfile(pProfile))

								    {

								        pBuffer += WriteNewLineObject(pBuffer, sRGBColorSpaceArray);

								    }

								    else

								    {

								        pBuffer += EnableGlobalDict(pBuffer);


								        if (bBackup)

								        {

								            pBuffer += WriteNewLineObject(pBuffer, NotSupportDEFG_S);

								        }


								        pBuffer += BeginGlobalDict(pBuffer);


								        pBuffer += CreateColSpArray(pProfile, pBuffer, TAG_REDTRC, *pbBinary);

								        pBuffer += CreateColSpArray(pProfile, pBuffer, TAG_GREENTRC, *pbBinary);

								        pBuffer += CreateColSpArray(pProfile, pBuffer, TAG_BLUETRC, *pbBinary);


								        pBuffer += WriteNewLineObject(pBuffer, EndOp);


								        if (bBackup)

								        {

								            pBuffer += WriteNewLineObject(pBuffer, SupportDEFG_E);

								        }


								        pBuffer += WriteNewLineObject(pBuffer, SetGlobalOp);


								        if (bBackup)

								        {

								            pBuffer += WriteNewLineObject(pBuffer, NotSupportDEFG_S);

								        }


								        //

								        // Start creating the ColorSpace

								        //


								        pBuffer += WriteNewLineObject(pBuffer, BeginArray);       // Begin array


								        //

								        // /CIEBasedABC

								        //


								        pBuffer += WriteObject(pBuffer, CIEBasedABCTag);   // Create entry

								        pBuffer += WriteObject(pBuffer, BeginDict);        // Begin dictionary


								        //

								        // /BlackPoint & /WhitePoint

								        //


								        pBuffer += SendCSABWPoint(pBuffer, dwIntent, afxIlluminantWP, afxMediaWP);


								        //

								        // /DecodeABC

								        //


								        pBuffer += WriteNewLineObject(pBuffer, DecodeABCTag);

								        pBuffer += WriteObject(pBuffer, BeginArray);


								        pBuffer += WriteObject(pBuffer, NewLine);

								        pBuffer += CreateColSpProc(pProfile, pBuffer, TAG_REDTRC, *pbBinary);

								        pBuffer += WriteObject(pBuffer, NewLine);

								        pBuffer += CreateColSpProc(pProfile, pBuffer, TAG_GREENTRC, *pbBinary);

								        pBuffer += WriteObject(pBuffer, NewLine);

								        pBuffer += CreateColSpProc(pProfile, pBuffer, TAG_BLUETRC, *pbBinary);

								        pBuffer += WriteObject(pBuffer, EndArray);


								        //

								        // /MatrixABC

								        //


								        pBuffer += WriteNewLineObject(pBuffer, MatrixABCTag);

								        pBuffer += WriteObject(pBuffer, BeginArray);


								        pBuffer += CreateFloatString(pProfile, pBuffer, TAG_REDCOLORANT);

								        pBuffer += CreateFloatString(pProfile, pBuffer, TAG_GREENCOLORANT);

								        pBuffer += CreateFloatString(pProfile, pBuffer, TAG_BLUECOLORANT);


								        pBuffer += WriteObject(pBuffer, EndArray);


								        //

								        // /RangeLMN

								        //


								        pBuffer += WriteObject(pBuffer, NewLine);

								        pBuffer += WriteObject(pBuffer, RangeLMNTag);

								        pBuffer += WriteObject(pBuffer, RangeLMN);


								        //

								        // /DecodeLMN

								        //


								        if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								        {

								            //

								            // Support absolute whitePoint

								            //


								            pBuffer += WriteNewLineObject(pBuffer, DecodeLMNTag);

								            pBuffer += WriteObject(pBuffer, BeginArray);

								            for (i=0; i<3; i++)

								            {

								                pBuffer += WriteObject(pBuffer, BeginFunction);

								                pBuffer += WriteFixed(pBuffer, FIX_DIV(afxMediaWP[i], afxIlluminantWP[i]));

								                pBuffer += WriteObject(pBuffer, MulOp);

								                pBuffer += WriteObject(pBuffer, EndFunction);

								            }

								            pBuffer += WriteObject (pBuffer, EndArray);

								        }


								        //

								        // End dictionary definition

								        //


								        pBuffer += WriteNewLineObject(pBuffer, EndDict);

								        pBuffer += WriteObject(pBuffer, EndArray);


								        pBuffer += WriteNewLineObject(pBuffer, CieBasedABCEnd);

								    }


								    *pcbSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								/******************************************************************************

								 *

								 *                              GetPS2CSA_ABC_Lab

								 *

								 *  Function:

								 *       This function creates a CIEBasedABC colorspace array from an input

								 *       Lab profile

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped profile

								 *       pBuffer   - pointer to receive the CSA

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       dwIntent  - rendering intent of CSA requested

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								GetPS2CSA_ABC_Lab(

								    PBYTE  pProfile,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    DWORD  dwIntent,

								    PBOOL  pbBinary

								    )

								{

								    PBYTE     pStart = pBuffer;

								    DWORD     i, dwSize;

								    FIX_16_16 afxIlluminantWP[3];

								    FIX_16_16 afxMediaWP[3];


								    //

								    // Estimate size required to hold the CSA

								    //


								    dwSize = 65530;


								    if (! pBuffer)

								    {

								        *pcbSize = dwSize;

								        return TRUE;

								    }

								    else if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get ABC_Lab CSA\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    //

								    // Get info about Illuminant White Point from the header

								    //


								    (void)GetCPWhitePoint(pProfile, afxIlluminantWP);


								    //

								    // Support absolute whitePoint

								    //


								    GetMediaWP(pProfile, dwIntent, afxIlluminantWP, afxMediaWP);


								    //

								    // Start creating the ColorSpace

								    //


								    pBuffer += WriteNewLineObject(pBuffer, BeginArray);       // Begin array


								    //

								    // /CIEBasedABC

								    //


								    pBuffer += WriteObject(pBuffer, CIEBasedABCTag);   // Create entry

								    pBuffer += WriteObject(pBuffer, BeginDict);        // Begin dictionary


								    //

								    // /BlackPoint & /WhitePoint

								    //


								    pBuffer += SendCSABWPoint(pBuffer, dwIntent, afxIlluminantWP, afxMediaWP);


								    //

								    // /RangeABC

								    //


								    pBuffer += WriteNewLineObject(pBuffer, RangeABCTag);

								    pBuffer += WriteObject(pBuffer, RangeABC_Lab);


								    //

								    // /DecodeABC

								    //


								    pBuffer += WriteNewLineObject(pBuffer, DecodeABCTag);

								    pBuffer += WriteObject(pBuffer, DecodeABCLab1);


								    //

								    // /MatrixABC

								    //


								    pBuffer += WriteNewLineObject(pBuffer, MatrixABCTag);

								    pBuffer += WriteObject(pBuffer, MatrixABCLab);


								    //

								    // /DecodeLMN

								    //


								    pBuffer += WriteNewLineObject(pBuffer, DecodeLMNTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<3; i++)

								    {

								        pBuffer += WriteObject(pBuffer, BeginFunction);

								        pBuffer += WriteObject(pBuffer, DecodeLMNLab);


								        if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								        {

								            pBuffer += WriteFixed(pBuffer, afxMediaWP[i]);

								        }

								        else

								        {

								            pBuffer += WriteFixed(pBuffer, afxIlluminantWP[i]);

								        }

								        pBuffer += WriteObject(pBuffer, MulOp);

								        pBuffer += WriteObject(pBuffer, EndFunction);

								        pBuffer += WriteObject(pBuffer, NewLine);

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    //

								    // End dictionary definition

								    //


								    pBuffer += WriteNewLineObject(pBuffer, EndDict);

								    pBuffer += WriteObject(pBuffer, EndArray);


								    pBuffer += WriteNewLineObject(pBuffer, CieBasedABCEnd);


								    *pcbSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								/******************************************************************************

								 *

								 *                           GetPS2CSA_DEFG

								 *

								 *  Function:

								 *       This function creates DEF and DEFG based CSAs from the data supplied

								 *       in the RGB or CMYK profiles respectively

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped profile

								 *       pBuffer   - pointer to receive the CSA

								 *       pcbSize   - pointer to size of buffer. If function fails because

								 *                   buffer is not big enough, it is filled with required size.

								 *       dwIntent  - rendering intent of CSA requested

								 *       dwType    - whether DEF CSA or DEFG CSA is required

								 *       pcbBinary - TRUE if binary data is requested. On return it is set to

								 *                   reflect the data returned

								 *

								 *  Returns:

								 *       TRUE if successful, FALSE otherwise

								 *

								 ******************************************************************************/


								BOOL

								GetPS2CSA_DEFG(

								    PBYTE  pProfile,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    DWORD  dwIntent,

								    DWORD  dwType,

								    PBOOL  pbBinary

								    )

								{

								    PLUT16TYPE pLut;

								    PTAGDATA   pTagData;

								    PBYTE      pLineStart, pStart = pBuffer;

								    PBYTE      pTable;

								    DWORD      i, j, k, dwPCS, dwDev, dwIndex, dwTag, dwLutSig, SecondGrids, dwSize;

								    DWORD      nInputCh, nOutputCh, nGrids, nInputTable, nOutputTable, nNumbers;

								    FIX_16_16  afxIlluminantWP[3];

								    FIX_16_16  afxMediaWP[3];

								    char       pPublicArrayName[5];


								    //

								    // Make sure required tags exist

								    //


								    switch (dwIntent)

								    {

								    case INTENT_PERCEPTUAL:

								        dwTag = TAG_AToB0;

								        break;


								    case INTENT_RELATIVE_COLORIMETRIC:

								        dwTag = TAG_AToB1;

								        break;


								    case INTENT_SATURATION:

								        dwTag = TAG_AToB2;

								        break;


								    case INTENT_ABSOLUTE_COLORIMETRIC:

								        dwTag = TAG_AToB1;

								        break;


								    default:

								        WARNING((__TEXT("Invalid intent passed to GetPS2CSA_DEFG: %d\n"), dwIntent));

								        SetLastError(ERROR_INVALID_PARAMETER);

								        return FALSE;

								    }


								    if (! DoesCPTagExist(pProfile, dwTag, &dwIndex))

								    {

								        WARNING((__TEXT("AToB%d tag not present to create DEF(G) CSA\n"), dwIntent));

								        SetLastError(ERROR_TAG_NOT_PRESENT);

								        return FALSE;

								    }


								    //

								    // Check if we can generate the CSA

								    // Required  tags is AToBi, where i is the rendering intent

								    //


								    dwPCS = GetCPConnSpace(pProfile);

								    dwDev = GetCPDevSpace(pProfile);


								    if ((dwType == TYPE_CIEBASEDDEF  && dwDev != SPACE_RGB) ||

								        (dwType == TYPE_CIEBASEDDEFG && dwDev != SPACE_CMYK))

								    {

								        WARNING((__TEXT("RGB profile & requesting CMYK CSA or vice versa\n")));

								        SetLastError(ERROR_TAG_NOT_PRESENT);

								        return FALSE;

								    }


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    pLut = (PLUT16TYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    dwLutSig = FIX_ENDIAN(pLut->dwSignature);


								    if (((dwPCS != SPACE_Lab) && (dwPCS != SPACE_XYZ)) ||

								        ((dwLutSig != LUT8_TYPE) && (dwLutSig != LUT16_TYPE)))

								    {

								        WARNING((__TEXT("Invalid color space - unable to create DEF(G) CSA\n")));

								        SetLastError(ERROR_INVALID_PROFILE);

								        return FALSE;

								    }


								    //

								    // Estimate size required to hold the CSA

								    //


								    (void)GetCLUTInfo(dwLutSig, (PBYTE)pLut, &nInputCh, &nOutputCh, &nGrids,

								                &nInputTable, &nOutputTable, NULL);


								    //

								    // Calculate size of buffer needed

								    //


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        dwSize = nOutputCh * nGrids * nGrids * nGrids * nGrids * 2;

								    }

								    else

								    {

								        dwSize = nOutputCh * nGrids * nGrids * nGrids * 2;

								    }


								    dwSize = dwSize +

								        nInputCh * nInputTable * 6 +

								        nOutputCh * nOutputTable * 6 +      // Number of INT bytes

								        nInputCh * (STRLEN(IndexArray) +

								                    STRLEN(StartClip) +

								                    STRLEN(EndClip)) +

								        nOutputCh * (STRLEN(IndexArray) +

								                     STRLEN(StartClip) +

								                     STRLEN(EndClip)) +

								        4096;                               // + other PS stuff


								    //

								    // Add space for new line.

								    //


								    dwSize += (((dwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								    if (! pBuffer)

								    {

								        *pcbSize = dwSize;

								        return TRUE;

								    }

								    else if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get DEFG CSA\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    //

								    // Get info about Illuminant White Point from the header

								    //


								    (void)GetCPWhitePoint(pProfile, afxIlluminantWP);


								    //

								    // Support absolute whitePoint

								    //


								    (void)GetMediaWP(pProfile, dwIntent, afxIlluminantWP, afxMediaWP);


								    //

								    // Testing CieBasedDEFG support

								    //


								    pBuffer += WriteNewLineObject(pBuffer, TestingDEFG);


								    //

								    // Create global data

								    //


								    GetPublicArrayName(dwTag, pPublicArrayName);


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        pBuffer += WriteNewLineObject(pBuffer, CieBasedDEFGBegin);

								    }

								    else

								    {

								        pBuffer += WriteNewLineObject(pBuffer, CieBasedDEFBegin);

								    }


								    pBuffer += EnableGlobalDict(pBuffer);

								    pBuffer += WriteNewLineObject(pBuffer, SupportDEFG_S);

								    pBuffer += BeginGlobalDict(pBuffer);


								    pBuffer += CreateInputArray(pBuffer, nInputCh, nInputTable,

								                 pPublicArrayName, dwLutSig, (PBYTE)pLut, *pbBinary, NULL);


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        i = nInputTable * nInputCh +

								            nGrids * nGrids * nGrids * nGrids * nOutputCh;

								    }

								    else

								    {

								        i = nInputTable * nInputCh +

								            nGrids * nGrids * nGrids * nOutputCh;

								    }

								    pBuffer += CreateOutputArray(pBuffer, nOutputCh, nOutputTable, i,

								                 pPublicArrayName, dwLutSig, (PBYTE)pLut, *pbBinary, NULL);


								    pBuffer += WriteNewLineObject(pBuffer, EndOp);

								    pBuffer += WriteNewLineObject(pBuffer, SupportDEFG_E);

								    pBuffer += WriteNewLineObject(pBuffer, SetGlobalOp);

								    pBuffer += WriteNewLineObject(pBuffer, SupportDEFG_S);


								    //

								    // Start creating the ColorSpace

								    //


								    pBuffer += WriteNewLineObject(pBuffer, BeginArray);   // Begin array


								    //

								    // /CIEBasedDEF(G)

								    //


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        pBuffer += WriteObject(pBuffer, CIEBasedDEFGTag);

								    }

								    else

								    {

								        pBuffer += WriteObject(pBuffer, CIEBasedDEFTag);

								    }


								    pBuffer += WriteObject(pBuffer, BeginDict);    // Begin dictionary


								    //

								    // /BlackPoint & /WhitePoint

								    //


								    pBuffer += SendCSABWPoint(pBuffer, dwIntent, afxIlluminantWP, afxMediaWP);


								    //

								    // /DecodeDEF(G)

								    //


								    pLineStart = pBuffer;


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        pBuffer += WriteNewLineObject(pBuffer, DecodeDEFGTag);

								    }

								    else

								    {

								        pBuffer += WriteNewLineObject(pBuffer, DecodeDEFTag);

								    }


								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<nInputCh; i++)

								    {

								        pLineStart = pBuffer;


								        pBuffer += WriteNewLineObject(pBuffer, BeginFunction);

								        pBuffer += WriteObject(pBuffer, StartClip);

								        pBuffer += WriteObject(pBuffer, InputArray);

								        pBuffer += WriteObject(pBuffer, pPublicArrayName);

								        pBuffer += WriteInt(pBuffer, i);


								        if (! *pbBinary)               // Output ASCII

								        {

								            pBuffer += WriteObject(pBuffer, IndexArray);

								        }

								        else

								        {                               // Output BINARY

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray16b);

								            }

								        }

								        pBuffer += WriteObject(pBuffer, (dwLutSig == LUT8_TYPE) ? Scale8 : Scale16);

								        pBuffer += WriteObject(pBuffer, EndClip);

								        pBuffer += WriteObject(pBuffer, EndFunction);

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    //

								    // /Table

								    //


								    pBuffer += WriteNewLineObject(pBuffer, TableTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);


								    pBuffer += WriteInt(pBuffer, nGrids);  // Send down Nh

								    pBuffer += WriteInt(pBuffer, nGrids);  // Send down Ni

								    pBuffer += WriteInt(pBuffer, nGrids);  // Send down Nj

								    nNumbers = nGrids * nGrids * nOutputCh;

								    SecondGrids = 1;


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        pBuffer += WriteInt (pBuffer, nGrids);  // Send down Nk

								        SecondGrids = nGrids;

								    }

								    pBuffer += WriteNewLineObject(pBuffer, BeginArray);


								    for (i=0; i<nGrids; i++)        // Nh strings should be sent

								    {

								        if (dwType == TYPE_CIEBASEDDEFG)

								        {

								            pBuffer += WriteNewLineObject(pBuffer, BeginArray);

								        }

								        for (k=0; k<SecondGrids; k++)

								        {

								            pLineStart = pBuffer;

								            pBuffer += WriteObject(pBuffer, NewLine);

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pTable = (PBYTE)(((PLUT8TYPE)pLut)->data) +

								                    nInputTable * nInputCh +

								                    nNumbers * (i * SecondGrids + k);

								            }

								            else

								            {

								                pTable = (PBYTE)(((PLUT16TYPE)pLut)->data) +

								                    2 * nInputTable * nInputCh +

								                    2 * nNumbers * (i * SecondGrids + k);

								            }


								            if (! *pbBinary)           // Output ASCII

								            {

								                pBuffer += WriteObject(pBuffer, BeginString);

								                if (dwLutSig == LUT8_TYPE)

								                {

								                    pBuffer += WriteHexBuffer(pBuffer, pTable, pLineStart, nNumbers);

								                }

								                else

								                {

								                    for (j=0; j<nNumbers; j++)

								                    {

								                        pBuffer += WriteHex(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)) / 256);

								                        pTable += sizeof(WORD);


								                        if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                        {

								                            pLineStart = pBuffer;

								                            pBuffer += WriteObject(pBuffer, NewLine);

								                        }

								                    }

								                }

								                pBuffer += WriteObject(pBuffer, EndString);

								            }

								            else

								            {                           // Output BINARY

								                pBuffer += WriteStringToken(pBuffer, 143, nNumbers);

								                if (dwLutSig == LUT8_TYPE)

								                    pBuffer += WriteByteString(pBuffer, pTable, nNumbers);

								                else

								                    pBuffer += WriteInt2ByteString(pBuffer, pTable, nNumbers);

								            }

								            pBuffer += WriteObject (pBuffer, NewLine);

								        }

								        if (dwType == TYPE_CIEBASEDDEFG)

								        {

								            pBuffer += WriteObject(pBuffer, EndArray);

								        }

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);

								    pBuffer += WriteObject(pBuffer, EndArray); // End array


								    //

								    // /DecodeABC

								    //


								    pLineStart = pBuffer;

								    pBuffer += WriteNewLineObject(pBuffer, DecodeABCTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<nOutputCh; i++)

								    {

								        pLineStart = pBuffer;


								        pBuffer += WriteNewLineObject(pBuffer, BeginFunction);

								        pBuffer += WriteObject(pBuffer, Clip01);

								        pBuffer += WriteObject(pBuffer, OutputArray);

								        pBuffer += WriteObject(pBuffer, pPublicArrayName);

								        pBuffer += WriteInt(pBuffer, i);


								        if (! *pbBinary)

								        {

								            pBuffer += WriteObject(pBuffer, NewLine);


								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, TFunction8XYZ);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray);

								                pBuffer += WriteObject(pBuffer, Scale16XYZ);

								            }

								        }

								        else

								        {

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, TFunction8XYZ);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray16b);

								                pBuffer += WriteObject(pBuffer, Scale16XYZ);

								            }

								        }


								        //

								        // Now, We get CieBasedXYZ output. Output range 0 --> 1.99997

								        // If the connection space is absolute XYZ, We need to convert

								        // from relative XYZ to absolute XYZ.

								        //


								        if ((dwPCS == SPACE_XYZ) && (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC))

								        {

								            pBuffer += WriteFixed(pBuffer, FIX_DIV(afxMediaWP[i], afxIlluminantWP[i]));

								            pBuffer += WriteObject(pBuffer, MulOp);

								        }

								        else if (dwPCS == SPACE_Lab)

								        {

								            //

								            // If the connection space is Lab, We need to convert XYZ to Lab

								            //


								            pBuffer += WriteObject(pBuffer, DecodeABCLab[i]);

								        }

								        pBuffer += WriteObject(pBuffer, EndFunction);

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    if (dwPCS == SPACE_Lab)

								    {

								        //

								        // /MatrixABC

								        //


								        pBuffer += WriteNewLineObject(pBuffer, MatrixABCTag);

								        pBuffer += WriteObject(pBuffer, MatrixABCLab);


								        //

								        // /DecodeLMN

								        //


								        pLineStart = pBuffer;

								        pBuffer += WriteNewLineObject(pBuffer, DecodeLMNTag);

								        pBuffer += WriteObject(pBuffer, BeginArray);

								        for (i=0; i<3; i++)

								        {

								            pLineStart = pBuffer;


								            pBuffer += WriteNewLineObject(pBuffer, BeginFunction);

								            pBuffer += WriteObject(pBuffer, DecodeLMNLab);

								            if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								            {

								                pBuffer += WriteFixed(pBuffer, afxMediaWP[i]);

								            }

								            else

								            {

								                pBuffer += WriteFixed(pBuffer, afxIlluminantWP[i]);

								            }

								            pBuffer += WriteObject(pBuffer, MulOp);

								            pBuffer += WriteObject(pBuffer, EndFunction);

								        }

								        pBuffer += WriteObject(pBuffer, EndArray);

								    }

								    else

								    {

								        //

								        // /RangeLMN

								        //


								        pBuffer += WriteNewLineObject(pBuffer, RangeLMNTag);

								        pBuffer += WriteObject(pBuffer, RangeLMN);

								    }


								    //

								    // End dictionary definition

								    //


								    pBuffer += WriteNewLineObject(pBuffer, EndDict);

								    pBuffer += WriteObject(pBuffer, EndArray);


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        pBuffer += WriteNewLineObject(pBuffer, CieBasedDEFGEnd);

								    }

								    else

								    {

								        pBuffer += WriteNewLineObject(pBuffer, CieBasedDEFEnd);

								    }


								    pBuffer += WriteNewLineObject(pBuffer, SupportDEFG_E);


								    *pcbSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								BOOL

								InternalGetPS2CSAFromLCS(

								    LPLOGCOLORSPACE pLogColorSpace,

								    PBYTE           pBuffer,

								    PDWORD          pcbSize,

								    PBOOL           pbBinary

								    )

								{

								    PBYTE  pStart = pBuffer;

								    DWORD  dwSize = 1024*2; // same value as in pscript/icm.c


								    if (! pBuffer)

								    {

								        *pcbSize = dwSize;


								        return TRUE;

								    }


								    if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get CSA from LCS\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    pBuffer += WriteObject(pBuffer, NewLine);

								    pBuffer += WriteObject(pBuffer, BeginArray);    // Begin array


								    pBuffer += WriteObject(pBuffer, ColorSpace1);

								    pBuffer += WriteObject(pBuffer, BeginArray);    // [


								    //

								    // Red gamma

								    //


								    pBuffer += WriteObject(pBuffer, BeginFunction);

								    pBuffer += WriteFixed(pBuffer, pLogColorSpace->lcsGammaRed);

								    pBuffer += WriteObject(pBuffer, ColorSpace3);


								    //

								    // Green gamma

								    //


								    pBuffer += WriteObject(pBuffer, BeginFunction);

								    pBuffer += WriteFixed(pBuffer, pLogColorSpace->lcsGammaGreen);

								    pBuffer += WriteObject(pBuffer, ColorSpace3);


								    //

								    // Blue Gamma

								    //


								    pBuffer += WriteObject(pBuffer, BeginFunction);

								    pBuffer += WriteFixed(pBuffer, pLogColorSpace->lcsGammaBlue);

								    pBuffer += WriteObject(pBuffer, ColorSpace3);


								    pBuffer += WriteObject(pBuffer, EndArray);      // ]


								    pBuffer += WriteObject(pBuffer, ColorSpace5);   // /WhitePoint


								    //

								    // Matrix LMN

								    //


								    pBuffer += WriteObject(pBuffer, MatrixLMNTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);


								    //

								    // Red Value

								    //


								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzRed.ciexyzX);

								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzRed.ciexyzY);

								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzRed.ciexyzZ);


								    //

								    // Green Value

								    //


								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzGreen.ciexyzX);

								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzGreen.ciexyzY);

								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzGreen.ciexyzZ);


								    //

								    // Blue Value

								    //


								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzBlue.ciexyzX);

								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzBlue.ciexyzY);

								    pBuffer += WriteFixed2dot30(pBuffer, pLogColorSpace->lcsEndpoints.ciexyzBlue.ciexyzZ);


								    pBuffer += WriteObject(pBuffer, EndArray);      // ]

								    pBuffer += WriteObject(pBuffer, EndDict);       // End dictionary


								    pBuffer += WriteObject(pBuffer, EndArray);      // ]


								    *pcbSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								/******************************************************************************

								 *

								 *                           CreateColorSpArray

								 *

								 *  Function:

								 *       This function creates an array that is used in /DecodeABC

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped profile

								 *       pBuffer   - pointer to receive the array

								 *       dwCPTag   - Channel TRC tag

								 *       bBinary   - TRUE if binary data is requested

								 *

								 *  Returns:

								 *       Length of the data created in bytes

								 *

								 ******************************************************************************/


								DWORD

								CreateColSpArray(

								    PBYTE pProfile,

								    PBYTE pBuffer,

								    DWORD dwCPTag,

								    BOOL  bBinary

								    )

								{

								    PCURVETYPE pData;

								    PTAGDATA   pTagData;

								    PBYTE      pLineStart, pStart = pBuffer;

								    PBYTE      pTable;

								    DWORD      i, nCount, dwIndex;


								    pLineStart = pBuffer;


								    if (DoesCPTagExist(pProfile, dwCPTag, &dwIndex))

								    {

								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwIndex * sizeof(TAGDATA));


								        pData = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								        nCount = FIX_ENDIAN(pData->nCount);


								        if (nCount > 1)

								        {

								            pBuffer += WriteNewLineObject(pBuffer, Slash);

								            pBuffer += WriteObject(pBuffer, DecodeABCArray);

								            pBuffer += WriteInt(pBuffer, dwCPTag);


								            pTable = (PBYTE)(pData->data);


								            if (! bBinary)           // Output ASCII CS

								            {

								                pBuffer += WriteObject(pBuffer, BeginArray);

								                for (i=0; i<nCount; i++)

								                {

								                    pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)));

								                    pTable += sizeof(WORD);


								                    if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                    {

								                        pLineStart = pBuffer;

								                        pBuffer += WriteObject(pBuffer, NewLine);

								                    }

								                }

								                pBuffer += WriteObject(pBuffer, EndArray);

								            }

								            else

								            {                           // Output BINARY CS

								                pBuffer += WriteHNAToken(pBuffer, 149, nCount);

								                pBuffer += WriteIntStringU2S(pBuffer, pTable, nCount);

								            }


								            pBuffer += WriteObject(pBuffer, DefOp);

								        }

								    }

								    return (DWORD) (pBuffer - pStart);

								}


								/******************************************************************************

								 *

								 *                           CreateColorSpProc

								 *

								 *  Function:

								 *       This function creates a PostScript procedure for the color space

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped profile

								 *       pBuffer   - pointer to receive the procedure

								 *       dwCPTag   - Channel TRC tag

								 *       bBinary   - TRUE if binary data is requested

								 *

								 *  Returns:

								 *       Length of the data created in bytes

								 *

								 ******************************************************************************/


								DWORD

								CreateColSpProc(

								    PBYTE pProfile,

								    PBYTE pBuffer,

								    DWORD dwCPTag,

								    BOOL  bBinary

								    )

								{

								    PCURVETYPE pData;

								    PTAGDATA   pTagData;

								    PBYTE      pStart = pBuffer;

								    PBYTE      pTable;

								    DWORD      nCount, dwIndex;


								    pBuffer += WriteObject(pBuffer, BeginFunction);


								    if (DoesCPTagExist(pProfile, dwCPTag, &dwIndex))

								    {

								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwIndex * sizeof(TAGDATA));


								        pData = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								        nCount = FIX_ENDIAN(pData->nCount);


								        if (nCount != 0)

								        {

								            if (nCount == 1)            // Gamma supplied in ui16 format

								            {

								                pTable = (PBYTE)(pData->data);

								                pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)));

								                pBuffer += WriteObject(pBuffer, DecodeA3);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, StartClip);

								                pBuffer += WriteObject(pBuffer, DecodeABCArray);

								                pBuffer += WriteInt(pBuffer, dwCPTag);


								                if (! bBinary)       // Output ASCII CS

								                {

								                    pBuffer += WriteObject(pBuffer, IndexArray);

								                }

								                else

								                {                    // Output BINARY CS

								                    pBuffer += WriteObject(pBuffer, IndexArray16b);

								                }

								                pBuffer += WriteObject(pBuffer, Scale16);

								                pBuffer += WriteObject(pBuffer, EndClip);

								            }

								        }

								    }

								    pBuffer += WriteObject(pBuffer, EndFunction);


								    return (DWORD) (pBuffer - pStart);

								}


								/******************************************************************************

								 *

								 *                           CreateFloatString

								 *

								 *  Function:

								 *       This function creates a string of floating point numbers for

								 *       the X, Y and Z values of the specified colorant.

								 *

								 *  Arguments:

								 *       pProfile  - pointer to the memory mapped profile

								 *       pBuffer   - pointer to receive the string

								 *       dwCPTag   - Colorant tag

								 *

								 *  Returns:

								 *       Length of the data created in bytes

								 *

								 ******************************************************************************/


								DWORD

								CreateFloatString(

								    PBYTE pProfile,

								    PBYTE pBuffer,

								    DWORD dwCPTag

								    )

								{

								    PTAGDATA   pTagData;

								    PBYTE      pStart = pBuffer;

								    PDWORD     pTable;

								    DWORD      i, dwIndex;


								    if (DoesCPTagExist(pProfile, dwCPTag, &dwIndex))

								    {

								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwIndex * sizeof(TAGDATA));


								        pTable = (PDWORD)(pProfile + FIX_ENDIAN(pTagData->dwOffset)) + 2;


								        for (i=0; i<3; i++)

								        {

								            pBuffer += WriteFixed(pBuffer, FIX_ENDIAN(*pTable));

								            pTable ++;

								        }

								    }


								    return (DWORD) (pBuffer - pStart);

								}


								/******************************************************************************

								 *

								 *                           CreateInputArray

								 *

								 *  Function:

								 *       This function creates the Color Rendering Dictionary (CRD)

								 *       from the data supplied in the ColorProfile's LUT8 or LUT16 tag.

								 *

								 *  Arguments:

								 *       pBuffer        - pointer to receive the data

								 *       nInputChannels - number of input channels

								 *       nInputTable    - size of input table

								 *       pIntent        - rendering intent signature (eg. A2B0)

								 *       dwTag          - signature of the look up table (8 or 16 bits)

								 *       pLut           - pointer to the look up table

								 *       bBinary        - TRUE if binary data is requested

								 *

								 *  Returns:

								 *       Length of the data created in bytes

								 *

								 ******************************************************************************/


								DWORD

								CreateInputArray(

								    PBYTE pBuffer,

								    DWORD nInputChannels,

								    DWORD nInputTable,

								    PBYTE pIntent,

								    DWORD dwTag,

								    PBYTE pLut,

								    BOOL  bBinary,

								    PBYTE pHostClut

								    )

								{

								    DWORD i, j;

								    PBYTE pLineStart, pStart = pBuffer;

								    PBYTE pTable;


								    if (pHostClut)

								    {

								        nInputChannels = ((PHOSTCLUT)pHostClut)->nInputCh;

								        nInputTable = ((PHOSTCLUT)pHostClut)->nInputEntries;

								        dwTag = ((PHOSTCLUT)pHostClut)->nLutBits == 8 ? LUT8_TYPE : LUT16_TYPE;

								    }


								    for (i=0; i<nInputChannels; i++)

								    {

								        pLineStart = pBuffer;

								        pBuffer += WriteNewLineObject(pBuffer, Slash);

								        if (pHostClut)

								            pBuffer += WriteObject(pBuffer, PreViewInArray);

								        else

								            pBuffer += WriteObject(pBuffer, InputArray);


								        pBuffer += WriteObject(pBuffer, pIntent);

								        pBuffer += WriteInt(pBuffer, i);


								        if (pHostClut)

								        {

								            pTable = ((PHOSTCLUT)pHostClut)->inputArray[i];

								        }

								        else

								        {

								            if (dwTag == LUT8_TYPE)

								            {

								                pTable = (PBYTE)(((PLUT8TYPE)pLut)->data) + nInputTable * i;

								            }

								            else

								            {

								                pTable = (PBYTE)(((PLUT16TYPE)pLut)->data) + 2 * nInputTable * i;

								            }

								        }


								        if (! bBinary)

								        {

								            if (dwTag == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, BeginString);

								                pBuffer += WriteHexBuffer(pBuffer, pTable, pLineStart, nInputTable);

								                pBuffer += WriteObject(pBuffer, EndString);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, BeginArray);

								                for (j=0; j<nInputTable; j++)

								                {

								                    if (pHostClut)

								                        pBuffer += WriteInt(pBuffer, *((PWORD)pTable));

								                    else

								                        pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)));

								                    pTable += sizeof(WORD);

								                    if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                    {

								                        pLineStart = pBuffer;

								                        pBuffer += WriteObject(pBuffer, NewLine);

								                    }

								                }

								                pBuffer += WriteObject(pBuffer, EndArray);

								            }

								        }

								        else

								        {

								            if (dwTag == LUT8_TYPE)

								            {

								                pBuffer += WriteStringToken(pBuffer, 143, nInputTable);

								                pBuffer += WriteByteString(pBuffer, pTable, nInputTable);

								            }

								            else

								            {

								                pBuffer += WriteHNAToken(pBuffer, 149, nInputTable);

								                if (pHostClut)

								                    pBuffer += WriteIntStringU2S_L(pBuffer, pTable, nInputTable);

								                else

								                    pBuffer += WriteIntStringU2S(pBuffer, pTable, nInputTable);

								            }

								        }

								        pBuffer += WriteObject(pBuffer, DefOp);

								    }


								    return (DWORD) (pBuffer - pStart);

								}


								/******************************************************************************

								 *

								 *                           CreateOutputArray

								 *

								 *  Function:

								 *       This function creates the Color Rendering Dictionary (CRD)

								 *       from the data supplied in the ColorProfile's LUT8 or LUT16 tag.

								 *

								 *  Arguments:

								 *       pBuffer        - pointer to receive the data

								 *       nOutputChannels- number of output channels

								 *       nOutputTable   - size of output table

								 *       dwOffset       - offset into the output table

								 *       pIntent        - rendering intent signature (eg. A2B0)

								 *       dwTag          - signature of the look up table (8 or 16 bits)

								 *       pLut           - pointer to the look up table

								 *       bBinary        - TRUE if binary data is requested

								 *

								 *  Returns:

								 *       Length of the data created in bytes

								 *

								 ******************************************************************************/


								DWORD

								CreateOutputArray(

								    PBYTE pBuffer,

								    DWORD nOutputChannels,

								    DWORD nOutputTable,

								    DWORD dwOffset,

								    PBYTE pIntent,

								    DWORD dwTag,

								    PBYTE pLut,

								    BOOL  bBinary,

								    PBYTE pHostClut

								    )

								{

								    DWORD i, j;

								    PBYTE pLineStart, pStart = pBuffer;

								    PBYTE pTable;


								    if (pHostClut)

								    {

								        nOutputChannels = ((PHOSTCLUT)pHostClut)->nOutputCh;

								        nOutputTable = ((PHOSTCLUT)pHostClut)->nOutputEntries;

								        dwTag = ((PHOSTCLUT)pHostClut)->nLutBits == 8 ? LUT8_TYPE : LUT16_TYPE;

								    }


								    for (i=0; i<nOutputChannels; i++)

								    {

								        pLineStart = pBuffer;

								        pBuffer += WriteNewLineObject(pBuffer, Slash);

								        if (pHostClut)

								            pBuffer += WriteObject(pBuffer, PreViewOutArray);

								        else

								            pBuffer += WriteObject(pBuffer, OutputArray);

								        pBuffer += WriteObject(pBuffer, pIntent);

								        pBuffer += WriteInt(pBuffer, i);


								        if (pHostClut)

								        {

								            pTable = ((PHOSTCLUT)pHostClut)->outputArray[i];

								        }

								        else

								        {

								            if (dwTag == LUT8_TYPE)

								            {

								                pTable = (PBYTE)(((PLUT8TYPE)pLut)->data) +

								                    dwOffset + nOutputTable * i;

								            }

								            else

								            {

								                pTable = (PBYTE)(((PLUT16TYPE)pLut)->data) +

								                    2 * dwOffset + 2 * nOutputTable * i;

								            }

								        }


								        if (! bBinary)

								        {

								            if (dwTag == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, BeginString);

								                pBuffer += WriteHexBuffer(pBuffer, pTable, pLineStart, nOutputTable);

								                pBuffer += WriteObject(pBuffer, EndString);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, BeginArray);

								                for (j=0; j<nOutputTable; j++)

								                {

								                    if (pHostClut)

								                        pBuffer += WriteInt(pBuffer, *((PWORD)pTable));

								                    else

								                        pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)));

								                    pTable += sizeof(WORD);

								                    if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                    {

								                        pLineStart = pBuffer;

								                        pBuffer += WriteObject(pBuffer, NewLine);

								                    }

								                }

								                pBuffer += WriteObject(pBuffer, EndArray);

								            }

								        }

								        else

								        {

								            if (dwTag == LUT8_TYPE)

								            {

								                pBuffer += WriteStringToken(pBuffer, 143, 256);

								                pBuffer += WriteByteString(pBuffer, pTable, 256L);

								            }

								            else

								            {

								                pBuffer += WriteHNAToken(pBuffer, 149, nOutputTable);

								                if (pHostClut)

								                    pBuffer += WriteIntStringU2S_L(pBuffer, pTable, nOutputTable);

								                else

								                    pBuffer += WriteIntStringU2S(pBuffer, pTable, nOutputTable);

								            }

								        }

								        pBuffer += WriteObject(pBuffer, DefOp);

								    }


								    return (DWORD)(pBuffer - pStart);

								}


								/******************************************************************************

								 *

								 *                           GetPublicArrayName

								 *

								 *  Function:

								 *       This function creates a string with the lookup table's signature

								 *

								 *  Arguments:

								 *       dwIntentSig      - the look up table signature

								 *       pPublicArrayName - pointer to buffer

								 *

								 *  Returns:

								 *       Length of the data created in bytes

								 *

								 ******************************************************************************/


								DWORD

								GetPublicArrayName(

								    DWORD   dwIntentSig,

								    PBYTE   pPublicArrayName

								    )

								{

								    *((DWORD *)pPublicArrayName) = dwIntentSig;

								    pPublicArrayName[sizeof(DWORD)] = '\0';


								    return sizeof(DWORD) + 1;

								}


								/***************************************************************************

								*                               CreateMonoCRD

								*  function:

								*    this is the function which creates the Color Rendering Dictionary (CRD)

								*    from the data supplied in the GrayTRC tag.

								*

								*  returns:

								*       BOOL        --  !=0 if the function was successful,

								*                         0 otherwise.

								*                       Returns number of bytes required/transferred

								***************************************************************************/


								BOOL

								CreateMonoCRD(

								    PBYTE  pProfile,

								    DWORD  dwIndex,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    DWORD  dwIntent

								    )

								{

								    PTAGDATA   pTagData;

								    PCURVETYPE pData;

								    PBYTE      pLineStart, pStart = pBuffer;

								    PWORD      pCurve, pRevCurve, pRevCurveStart;

								    DWORD      dwPCS, dwSize, nCount, i;

								    FIX_16_16  afxIlluminantWP[3];

								    FIX_16_16  afxMediaWP[3];


								    dwPCS = GetCPConnSpace(pProfile);


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    pData = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    nCount = FIX_ENDIAN(pData->nCount);


								    //

								    // Estimate size required to hold the CRD

								    //


								    dwSize = nCount * 6 * REVCURVE_RATIO + // Number of INT elements

								        2048;                              // + other PS stuff


								    //

								    // Add space for new line.

								    //


								    dwSize += (((dwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								    if (! pBuffer)

								    {

								        *pcbSize = dwSize;

								        return TRUE;

								    }

								    else if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get Mono CRD\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    //

								    // Allocate memory, each entry occupy 2 bytes (1 word),

								    //

								    // input buffer  = (nCount * sizeof(WORD)

								    // output buffer = (nCount * sizeof(WORD) * REVCURVE_RATIO)

								    //


								    if ((pRevCurveStart = MemAlloc(nCount * sizeof(WORD) * (REVCURVE_RATIO + 1))) == NULL)

								    {

								        WARNING((__TEXT("Unable to allocate memory for reverse curve\n")));

								        SetLastError(ERROR_NOT_ENOUGH_MEMORY);

								        return FALSE;

								    }


								    //

								    // pCurve will points input buffer (which used in GetRevCurve)

								    //


								    pCurve    = pRevCurveStart + nCount * REVCURVE_RATIO;

								    pRevCurve = pRevCurveStart;


								    (void)GetRevCurve(pData, pCurve, pRevCurve);


								    //

								    // Get info about Illuminant White Point from the header

								    //


								    (void)GetCPWhitePoint(pProfile, afxIlluminantWP);


								    //

								    // Support absolute whitePoint

								    //


								    if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								    {

								        if (! GetCPMediaWhitePoint(pProfile, afxMediaWP))

								        {

								            afxMediaWP[0] = afxIlluminantWP[0];

								            afxMediaWP[1] = afxIlluminantWP[1];

								            afxMediaWP[2] = afxIlluminantWP[2];

								        }

								    }


								    //

								    // Start writing the CRD

								    //


								    pBuffer += WriteNewLineObject(pBuffer, BeginDict); // Begin dictionary

								    pBuffer += WriteObject(pBuffer, DictType); // Dictionary type


								    //

								    // Send /RenderingIntent

								    //


								    switch (dwIntent)

								    {

								        case INTENT_PERCEPTUAL:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentPer);

								            break;


								        case INTENT_SATURATION:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentSat);

								            break;


								        case INTENT_RELATIVE_COLORIMETRIC:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentRCol);

								            break;


								        case INTENT_ABSOLUTE_COLORIMETRIC:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentACol);

								            break;

								    }


								    //

								    // Send /BlackPoint & /WhitePoint

								    //


								    pBuffer += SendCRDBWPoint(pBuffer, afxIlluminantWP);


								    //

								    // Send PQR

								    //


								    pBuffer += SendCRDPQR(pBuffer, dwIntent, afxIlluminantWP);


								    //

								    // Send LMN

								    //


								    pBuffer += SendCRDLMN(pBuffer, dwIntent, afxIlluminantWP, afxMediaWP, dwPCS);


								    //

								    // /MatrixABC

								    //


								    if (dwPCS == SPACE_XYZ)

								    {

								        //

								        // Switch ABC to BAC, since we want to output B

								        // which is converted from Y

								        //


								        pBuffer += WriteNewLineObject(pBuffer, MatrixABCTag);

								        pBuffer += WriteObject(pBuffer, MatrixABCXYZCRD);

								    }

								    else if (dwPCS == SPACE_Lab)

								    {

								        pBuffer += WriteNewLineObject(pBuffer, MatrixABCTag);

								        pBuffer += WriteObject(pBuffer, MatrixABCLabCRD);

								    }


								    //

								    // /EncodeABC

								    //


								    if (nCount != 0)

								    {

								        pBuffer += WriteObject(pBuffer, NewLine);

								        pLineStart = pBuffer;

								        pBuffer += WriteObject(pBuffer, EncodeABCTag);

								        pBuffer += WriteObject(pBuffer, BeginArray);

								        pBuffer += WriteObject(pBuffer, BeginFunction);

								        if (nCount == 1)                // Gamma supplied in ui16 format

								        {

								            PBYTE pTable;


								            pTable = (PBYTE) (pData->data);

								            pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)));

								            pBuffer += WriteObject(pBuffer, DecodeA3Rev);

								        }

								        else

								        {

								            if (dwPCS == SPACE_Lab)

								            {

								                pBuffer += WriteObject(pBuffer, EncodeABCLab1);

								            }

								            pBuffer += WriteObject(pBuffer, StartClip);

								            pBuffer += WriteObject(pBuffer, BeginArray);

								            for (i=0; i<nCount * REVCURVE_RATIO; i++)

								            {

								                pBuffer += WriteInt(pBuffer, *((WORD *)pRevCurve));

								                pRevCurve++;

								                if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                {

								                    pLineStart = pBuffer;

								                    pBuffer += WriteObject(pBuffer, NewLine);

								                }

								            }

								            pBuffer += WriteObject(pBuffer, EndArray);

								            pLineStart = pBuffer;


								            pBuffer += WriteNewLineObject(pBuffer, IndexArray);

								            pBuffer += WriteObject(pBuffer, Scale16);

								            pBuffer += WriteObject(pBuffer, EndClip);

								        }

								        pBuffer += WriteObject (pBuffer, EndFunction);

								        pBuffer += WriteObject (pBuffer, DupOp);

								        pBuffer += WriteObject (pBuffer, DupOp);

								        pBuffer += WriteObject (pBuffer, EndArray);

								    }

								    pBuffer += WriteObject(pBuffer, EndDict);  // End dictionary definition


								    MemFree(pRevCurveStart);


								    *pcbSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								/***************************************************************************

								*                               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.

								*

								*  returns:

								*       BOOL        --  !=0 if the function was successful,

								*                         0 otherwise.

								*                       Returns number of bytes required/transferred

								***************************************************************************/


								BOOL

								CreateLutCRD(

								    PBYTE  pProfile,

								    DWORD  dwIndex,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    DWORD  dwIntent,

								    BOOL   bBinary

								    )

								{

								    PTAGDATA   pTagData;

								    PLUT16TYPE pLut;

								    PBYTE      pTable;

								    PBYTE      pLineStart, pStart = pBuffer;

								    DWORD      dwPCS, dwSize, dwLutSig, dwTag, i, j;

								    DWORD      nInputCh, nOutputCh, nGrids, nInputTable, nOutputTable, nNumbers;

								    FIX_16_16  afxIlluminantWP[3];

								    FIX_16_16  afxMediaWP[3];

								    char       pPublicArrayName[5];


								    //

								    // Check if we can generate the CSA

								    // Required  tags is AToBi, where i is the rendering intent

								    //


								    dwPCS = GetCPConnSpace(pProfile);


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    dwTag = FIX_ENDIAN(pTagData->tagType);


								    pLut = (PLUT16TYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    dwLutSig = FIX_ENDIAN(pLut->dwSignature);


								    if ((dwLutSig != LUT8_TYPE) && (dwLutSig != LUT16_TYPE))

								    {

								        WARNING((__TEXT("Invalid profile - unable to create Lut CRD\n")));

								        SetLastError(ERROR_INVALID_PROFILE);

								        return FALSE;

								    }


								    //

								    // Estimate size required to hold the CSA

								    //


								    (void)GetCLUTInfo(dwLutSig, (PBYTE)pLut, &nInputCh, &nOutputCh, &nGrids,

								                &nInputTable, &nOutputTable, NULL);


								    //

								    // Calculate size of buffer needed

								    //


								    dwSize = nInputCh * nInputTable * 6 +

								        nOutputCh * nOutputTable * 6 +               // Number of INT bytes

								        nOutputCh * nGrids * nGrids * nGrids * 2 +   // LUT HEX bytes

								        nInputCh * (STRLEN(IndexArray) +

								                    STRLEN(StartClip) +

								                    STRLEN(EndClip)) +

								        nOutputCh * (STRLEN(IndexArray) +

								                     STRLEN(StartClip) +

								                     STRLEN(EndClip)) +

								        2048;                                        // + other PS stuff


								    //

								    // Add space for new line.

								    //


								    dwSize += (((dwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								    if (! pBuffer)

								    {

								        *pcbSize = dwSize;

								        return TRUE;

								    }

								    else if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get DEFG CSA\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    //

								    // Get info about Illuminant White Point from the header

								    //


								    (void)GetCPWhitePoint(pProfile, afxIlluminantWP);


								    //

								    // Support absolute whitePoint

								    //


								    if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								    {

								        if (! GetCPMediaWhitePoint(pProfile, afxMediaWP))

								        {

								            afxMediaWP[0] = afxIlluminantWP[0];

								            afxMediaWP[1] = afxIlluminantWP[1];

								            afxMediaWP[2] = afxIlluminantWP[2];

								        }

								    }


								    //

								    // Define global array used in EncodeABC and RenderTable

								    //


								    GetPublicArrayName(dwTag, pPublicArrayName);

								    pBuffer += WriteNewLineObject(pBuffer, CRDBegin);


								    pBuffer += EnableGlobalDict(pBuffer);

								    pBuffer += BeginGlobalDict(pBuffer);


								    pBuffer += CreateInputArray(pBuffer, nInputCh, nInputTable,

								                 pPublicArrayName, dwLutSig, (PBYTE)pLut, bBinary, NULL);


								    i = nInputTable * nInputCh +

								        nGrids * nGrids * nGrids * nOutputCh;

								    pBuffer += CreateOutputArray(pBuffer, nOutputCh, nOutputTable, i,

								                 pPublicArrayName, dwLutSig, (PBYTE)pLut, bBinary, NULL);


								    pBuffer += EndGlobalDict(pBuffer);


								    //

								    // Start writing the CRD

								    //


								    pBuffer += WriteNewLineObject(pBuffer, BeginDict); // Begin dictionary

								    pBuffer += WriteObject(pBuffer, DictType); // Dictionary type


								    //

								    // Send /RenderingIntent

								    //


								    switch (dwIntent)

								    {

								        case INTENT_PERCEPTUAL:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentPer);

								            break;


								        case INTENT_SATURATION:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentSat);

								            break;


								        case INTENT_RELATIVE_COLORIMETRIC:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentRCol);

								            break;


								        case INTENT_ABSOLUTE_COLORIMETRIC:

								            pBuffer += WriteNewLineObject(pBuffer, IntentType);

								            pBuffer += WriteObject(pBuffer, IntentACol);

								            break;

								    }


								    //

								    // Send /BlackPoint & /WhitePoint

								    //


								    pBuffer += SendCRDBWPoint(pBuffer, afxIlluminantWP);


								    //

								    // Send PQR

								    //


								    pBuffer += SendCRDPQR(pBuffer, dwIntent, afxIlluminantWP);


								    //

								    // Send LMN

								    //


								    pBuffer += SendCRDLMN(pBuffer, dwIntent, afxIlluminantWP, afxMediaWP, dwPCS);


								    //

								    // Send ABC

								    //


								    pBuffer += SendCRDABC(pBuffer, pPublicArrayName, dwPCS, nInputCh,

								                    (PBYTE)pLut, NULL, dwLutSig, bBinary);


								    //

								    // /RenderTable

								    //


								    pBuffer += WriteNewLineObject(pBuffer, RenderTableTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);


								    pBuffer += WriteInt(pBuffer, nGrids);  // Send down Na

								    pBuffer += WriteInt(pBuffer, nGrids);  // Send down Nb

								    pBuffer += WriteInt(pBuffer, nGrids);  // Send down Nc


								    pLineStart = pBuffer;

								    pBuffer += WriteNewLineObject(pBuffer, BeginArray);

								    nNumbers = nGrids * nGrids * nOutputCh;


								    for (i=0; i<nGrids; i++)        // Na strings should be sent

								    {

								        pBuffer += WriteObject(pBuffer, NewLine);

								        pLineStart = pBuffer;

								        if (dwLutSig == LUT8_TYPE)

								        {

								            pTable = (PBYTE)(((PLUT8TYPE)pLut)->data) + nInputTable * nInputCh + nNumbers * i;

								        }

								        else

								        {

								            pTable = (PBYTE)(((PLUT16TYPE)pLut)->data) + 2 * nInputTable * nInputCh + 2 * nNumbers * i;

								        }


								        if (! bBinary)

								        {

								            pBuffer += WriteObject(pBuffer, BeginString);

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteHexBuffer(pBuffer, pTable, pLineStart, nNumbers);

								            }

								            else

								            {

								                for (j=0; j<nNumbers; j++)

								                {

								                    pBuffer += WriteHex(pBuffer, FIX_ENDIAN16(*((PWORD)pTable)) / 256);

								                    pTable += sizeof(WORD);

								                    if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                    {

								                        pLineStart = pBuffer;

								                        pBuffer += WriteObject(pBuffer, NewLine);

								                    }

								                }

								            }

								            pBuffer += WriteObject(pBuffer, EndString);

								        }

								        else

								        {

								            pBuffer += WriteStringToken(pBuffer, 143, nNumbers);

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteByteString(pBuffer, pTable, nNumbers);

								            }

								            else

								            {

								                pBuffer += WriteInt2ByteString(pBuffer, pTable, nNumbers);

								            }

								        }

								    }


								    pBuffer += WriteObject(pBuffer, EndArray); // End array

								    pBuffer += WriteInt(pBuffer, nOutputCh);   // Send down m


								    pBuffer += SendCRDOutputTable(pBuffer, pPublicArrayName,

								                    nOutputCh, dwLutSig, FALSE, bBinary);


								    pBuffer += WriteObject(pBuffer, EndArray); // End array

								    pBuffer += WriteObject(pBuffer, EndDict);  // End dictionary definition


								    pBuffer += WriteNewLineObject(pBuffer, CRDEnd);


								    *pcbSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								#if !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								/***************************************************************************

								*                           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

								*

								*  returns:

								*       BOOL        --  !=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.


								BOOL

								CreateMatrixCRD(

								    PBYTE  pProfile,

								    PBYTE  pBuffer,

								    PDWORD pcbSize,

								    DWORD  dwIntent,

								    BOOL   bBinary

								    )

								{

								    PTAGDATA   pTagData;

								    DWORD      dwRedTRCIndex, dwGreenTRCIndex, dwBlueTRCIndex;

								    DWORD      dwRedCount, dwGreenCount, dwBlueCount;

								    PBYTE      pMem = NULL;

								    PCURVETYPE pRed, pGreen, pBlue;

								    DWORD      i, dwSize;

								    PBYTE      pStart = pBuffer;

								    PWORD      pRevCurve;

								    FIX_16_16  afxIlluminantWP[3];

								    double     adColorant[9];

								    double     adRevColorant[9];


								    //

								    // Check this is sRGB color profile or not.

								    //


								    if (IsSRGBColorProfile(pProfile))

								    {

								        dwSize = 4096; // hack - approx.


								        //

								        // Return buffer size, if this is a size request

								        //


								        if (! pBuffer)

								        {

								            *pcbSize = dwSize;

								            return TRUE;

								        }


								        //

								        // Check buffer size.

								        //


								        if (*pcbSize < dwSize)

								        {

								            WARNING((__TEXT("Buffer too small to get sRGB CRD\n")));

								            SetLastError(ERROR_INSUFFICIENT_BUFFER);

								            return FALSE;

								        }


								        //

								        // Start writing the CRD

								        //


								        pBuffer += WriteNewLineObject(pBuffer, CRDBegin);

								        pBuffer += WriteNewLineObject(pBuffer, BeginDict);  // Begin dictionary

								        pBuffer += WriteObject(pBuffer, DictType);          // Dictionary type


								        //

								        // Send /RenderingIntent

								        //


								        switch (dwIntent)

								        {

								            case INTENT_PERCEPTUAL:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentPer);

								                break;


								            case INTENT_SATURATION:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentSat);

								                break;


								            case INTENT_RELATIVE_COLORIMETRIC:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentRCol);

								                break;


								            case INTENT_ABSOLUTE_COLORIMETRIC:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentACol);

								                break;

								        }


								        //

								        // Write prepaired sRGB CRD.

								        //


								        pBuffer += WriteNewLineObject(pBuffer, sRGBColorRenderingDictionary);


								        //

								        // End CRD.

								        //


								        pBuffer += WriteNewLineObject(pBuffer, CRDEnd);

								    }

								    else

								    {

								        //

								        // Get each TRC index for Red, Green and Blue.

								        //


								        if (!DoesCPTagExist(pProfile, TAG_REDTRC, &dwRedTRCIndex) ||

								            !DoesCPTagExist(pProfile, TAG_GREENTRC, &dwGreenTRCIndex) ||

								            !DoesCPTagExist(pProfile, TAG_BLUETRC, &dwBlueTRCIndex))

								        {

								            return FALSE;

								        }


								        //

								        // Get CURVETYPE data for each Red, Green and Blue

								        //


								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwRedTRCIndex * sizeof(TAGDATA));


								        pRed = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwGreenTRCIndex * sizeof(TAGDATA));


								        pGreen = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwBlueTRCIndex * sizeof(TAGDATA));


								        pBlue = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								        //

								        // Get curve count for each Red, Green and Blue.

								        //


								        dwRedCount   = FIX_ENDIAN(pRed->nCount);

								        dwGreenCount = FIX_ENDIAN(pGreen->nCount);

								        dwBlueCount  = FIX_ENDIAN(pBlue->nCount);


								        //

								        // Estimate the memory size required to hold CRD

								        //


								        dwSize = (dwRedCount + dwGreenCount + dwBlueCount) * 6 * REVCURVE_RATIO +

								                 4096;  // Number of INT elements + other PS stuff


								        //

								        // Add space for new line.

								        //


								        dwSize += (((dwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								        if (pBuffer == NULL)     // This is a size request

								        {

								            *pcbSize = dwSize;

								            return TRUE;

								        }


								        //

								        // Check buffer size.

								        //


								        if (*pcbSize < dwSize)

								        {

								            WARNING((__TEXT("Buffer too small to get sRGB CRD\n")));

								            SetLastError(ERROR_INSUFFICIENT_BUFFER);

								            return FALSE;

								        }


								        //

								        // Allocate buffer for curves

								        //


								        if ((pRevCurve = MemAlloc(dwRedCount * sizeof(WORD) * (REVCURVE_RATIO + 1))) == NULL)

								        {

								            WARNING((__TEXT("Unable to allocate memory for reserved curve\n")));

								            SetLastError(ERROR_NOT_ENOUGH_MEMORY);

								            MemFree(pMem);

								            return FALSE;

								        }


								        //

								        // Get info about Illuminant White Point from the header

								        //


								        (void)GetCPWhitePoint(pProfile, afxIlluminantWP);


								        //

								        // Start writing the CRD

								        //


								        pBuffer += EnableGlobalDict(pBuffer);

								        pBuffer += BeginGlobalDict(pBuffer);


								        pBuffer += CreateCRDRevArray(pProfile, pBuffer, pRed, pRevCurve, TAG_REDTRC, bBinary);

								        pBuffer += CreateCRDRevArray(pProfile, pBuffer, pGreen, pRevCurve, TAG_GREENTRC, bBinary);

								        pBuffer += CreateCRDRevArray(pProfile, pBuffer, pBlue, pRevCurve, TAG_BLUETRC, bBinary);


								        pBuffer += EndGlobalDict(pBuffer);


								        //

								        // Start writing the CRD

								        //


								        pBuffer += WriteNewLineObject(pBuffer, CRDBegin);

								        pBuffer += WriteNewLineObject(pBuffer, BeginDict);  // Begin dictionary

								        pBuffer += WriteObject(pBuffer, DictType);          // Dictionary type


								        //

								        // Send /RenderingIntent

								        //


								        switch (dwIntent)

								        {

								            case INTENT_PERCEPTUAL:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentPer);

								                break;


								            case INTENT_SATURATION:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentSat);

								                break;


								            case INTENT_RELATIVE_COLORIMETRIC:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentRCol);

								                break;


								            case INTENT_ABSOLUTE_COLORIMETRIC:

								                pBuffer += WriteNewLineObject(pBuffer, IntentType);

								                pBuffer += WriteObject(pBuffer, IntentACol);

								                break;

								        }


								        //

								        // Send /BlackPoint & /WhitePoint

								        //


								        pBuffer += SendCRDBWPoint(pBuffer, afxIlluminantWP);


								        //

								        // Send PQR

								        //


								        pBuffer += SendCRDPQR(pBuffer, dwIntent, afxIlluminantWP);


								        //

								        // Send LMN

								        //


								        CreateColorantArray(pProfile, &adColorant[0], TAG_REDCOLORANT);

								        CreateColorantArray(pProfile, &adColorant[3], TAG_GREENCOLORANT);

								        CreateColorantArray(pProfile, &adColorant[6], TAG_BLUECOLORANT);

								        InvertColorantArray(adColorant, adRevColorant);


								        pBuffer += WriteNewLineObject(pBuffer, MatrixLMNTag);


								        pBuffer += WriteObject(pBuffer, BeginArray);

								        for (i = 0; i < 9; i++)

								        {

								            pBuffer += WriteDouble(pBuffer, adRevColorant[i]);

								        }

								        pBuffer += WriteObject(pBuffer, EndArray);


								        //

								        // /EncodeABC

								        //


								        pBuffer += WriteNewLineObject(pBuffer, EncodeABCTag);

								        pBuffer += WriteObject(pBuffer, BeginArray);


								        pBuffer += WriteObject(pBuffer, NewLine);

								        pBuffer += SendCRDRevArray(pProfile, pBuffer, pRed, TAG_REDTRC, bBinary);


								        pBuffer += WriteObject(pBuffer, NewLine);

								        pBuffer += SendCRDRevArray(pProfile, pBuffer, pGreen, TAG_GREENTRC, bBinary);


								        pBuffer += WriteObject(pBuffer, NewLine);

								        pBuffer += SendCRDRevArray(pProfile, pBuffer, pBlue, TAG_BLUETRC, bBinary);


								        pBuffer += WriteNewLineObject(pBuffer, EndArray);

								        pBuffer += WriteObject(pBuffer, EndDict);  // End dictionary definition


								        pBuffer += WriteNewLineObject(pBuffer, CRDEnd);


								        MemFree (pRevCurve);

								    }


								    *pcbSize = (DWORD)(pBuffer - pStart);


								    return TRUE;

								}


								DWORD

								CreateCRDRevArray(

								    PBYTE      pProfile,

								    PBYTE      pBuffer,

								    PCURVETYPE pData,

								    PWORD      pRevCurve,

								    DWORD      dwTag,

								    BOOL       bBinary

								    )

								{

								    DWORD i, nCount;

								    PBYTE pStart, pLineStart;

								    PWORD pCurve;


								    pStart = pBuffer;

								    pLineStart = pBuffer;


								    nCount = FIX_ENDIAN(pData->nCount);

								    if (nCount > 1)

								    {

								        pBuffer += WriteNewLineObject(pBuffer, Slash);

								        pBuffer += WriteObject(pBuffer, InputArray);

								        pBuffer += WriteInt(pBuffer, (INT) dwTag);


								        pCurve = pRevCurve + (REVCURVE_RATIO * nCount);


								        GetRevCurve (pData, pCurve, pRevCurve);


								        if (!bBinary)  // Output ASCII DATA

								        {

								            pBuffer += WriteObject(pBuffer, BeginArray);

								            for (i = 0; i < nCount * REVCURVE_RATIO; i++)

								            {

								                pBuffer += WriteInt(pBuffer, *pRevCurve);

								                pRevCurve++;

								                if (((DWORD) (pBuffer - pLineStart)) > MAX_LINELEN)

								                {

								                    pLineStart = pBuffer;

								                    pBuffer += WriteObject(pBuffer, NewLine);

								                }

								            }

								            pBuffer += WriteObject(pBuffer, EndArray);

								        }

								        else // Output BINARY DATA

								        {

								            pBuffer += WriteHNAToken(pBuffer, 149, nCount);

								            pBuffer += WriteIntStringU2S_L(pBuffer, (PBYTE) pRevCurve, nCount);

								        }

								        pBuffer += WriteObject(pBuffer, DefOp);

								    }


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								SendCRDRevArray(

								    PBYTE pProfile,

								    PBYTE pBuffer,

								    PCURVETYPE pData,

								    DWORD dwTag,

								    BOOL  bBinary

								    )

								{

								    DWORD nCount;

								    PBYTE pStart;

								    PWORD pTable;


								    pStart = pBuffer;


								    pBuffer += WriteObject(pBuffer, BeginFunction);

								    nCount = FIX_ENDIAN(pData->nCount);

								    if (nCount != 0)

								    {

								        if (nCount == 1)            // Gamma supplied in ui16 format

								        {

								            pTable = pData->data;

								            pBuffer += WriteInt(pBuffer, FIX_ENDIAN16(*pTable));

								            pBuffer += WriteObject(pBuffer, DecodeA3Rev);

								        }

								        else

								        {

								            pBuffer += WriteObject(pBuffer, StartClip);

								            pBuffer += WriteObject(pBuffer, InputArray);

								            pBuffer += WriteInt(pBuffer, dwTag);


								            if (!bBinary)       // Output ASCII CS

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray);

								            }

								            else                // Output BINARY CS

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray16b);

								            }


								            pBuffer += WriteObject(pBuffer, Scale16);

								            pBuffer += WriteObject(pBuffer, EndClip);

								        }

								    }

								    pBuffer += WriteObject(pBuffer, EndFunction);


								    return (DWORD)(pBuffer - pStart);

								}


								BOOL

								CreateColorantArray(

								    PBYTE pProfile,

								    double *lpArray,

								    DWORD dwTag

								    )

								{

								    PTAGDATA pTagData;

								    PXYZTYPE pData;

								    PFIX_16_16 pTable;

								    DWORD i, dwIndex;

								    BYTE buffer[1000];


								    if (DoesCPTagExist(pProfile, dwTag, &dwIndex))

								    {

								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwIndex * sizeof(TAGDATA));


								        pData = (PXYZTYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								        pTable = pData->afxData;


								        for (i = 0; i < 3; i++)

								        {

								            FIX_16_16 afxData = FIX_ENDIAN(*pTable);


								            //

								            // Convert Fix 16.16 to double.

								            //


								            *lpArray = ((double) afxData) / ((double) FIX_16_16_SCALE);


								            pTable++; lpArray++;

								        }


								        return (TRUE);

								    }


								    return (FALSE);

								}


								#endif // !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								/***************************************************************************

								*                               GetRevCurve

								*  function:

								*  returns:

								*       BOOL        --  TRUE:  successful,

								*                       FALSE: otherwise.

								***************************************************************************/


								BOOL

								GetRevCurve(

								    PCURVETYPE pData,

								    PWORD      pInput,

								    PWORD      pOutput

								    )

								{

								    PBYTE       pTable;

								    DWORD       nCount, dwStore, i, j;

								    DWORD       dwBegin, dwEnd, dwTemp;


								    nCount = FIX_ENDIAN(pData->nCount);

								    pTable = (PBYTE)pData->data;


								    if(nCount < 2)

								    {

								        WARNING((__TEXT("nCount < 2 in GetRevCurve\n")));

								        return FALSE;

								    }

								    for (i=0; i<nCount; i++)

								    {

								        pInput[i] = FIX_ENDIAN16(*((PWORD)pTable));

								        pTable += sizeof(WORD);

								    }


								    j = nCount * REVCURVE_RATIO;

								    for (i=0; i<j; i++)

								    {

								        dwStore = i * 65535 / (j - 1);

								        pOutput[i] = (dwStore < 65535) ? (WORD) dwStore : 65535;

								    }


								    for (i=0; i<j; i++)

								    {

								        dwBegin = 0;

								        dwEnd = nCount - 1;

								        for (;;)

								        {

								            if ((dwEnd - dwBegin) <= 1)

								                break;

								            dwTemp = (dwEnd + dwBegin) / 2;

								            if (pOutput[i] < pInput[dwTemp])

								                dwEnd = dwTemp;

								            else

								                dwBegin = dwTemp;

								        }

								        if (pOutput[i] <= pInput[dwBegin])

								        {

								            dwStore = dwBegin;

								        }

								        else if (pOutput[i] >= pInput[dwEnd])

								        {

								            dwStore = dwEnd;

								        }

								        else

								        {

								            dwStore = (pInput[dwEnd] - pOutput[i]) / (pOutput[i] - pInput[dwBegin]);

								            dwStore = (dwBegin * dwStore + dwEnd) / (dwStore + 1);

								        }


								        dwStore = dwStore * 65535 / (nCount - 1);

								        pOutput[i] = (dwStore < 65535) ? (WORD) dwStore : 65535;

								    }


								    return TRUE;

								}


								BOOL

								DoesCPTagExist(

								    PBYTE     pProfile,

								    DWORD     dwTag,

								    PDWORD    pdwIndex

								    )

								{

								    DWORD    i, dwCount;

								    PTAGDATA pTagData;

								    BOOL     bRc;


								    //

								    // Get count of tag items - it is right after the profile header

								    //


								    dwCount = FIX_ENDIAN(*((DWORD *)(pProfile + sizeof(PROFILEHEADER))));


								    //

								    // Tag data records follow the count.

								    //


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD));


								    //

								    // Check if any of these records match the tag passed in.

								    //


								    bRc = FALSE;

								    dwTag = FIX_ENDIAN(dwTag);      // to match tags in profile

								    for (i=0; i<dwCount; i++)

								    {

								        if (pTagData->tagType == dwTag)

								        {

								            if (pdwIndex)

								            {

								                *pdwIndex = i;

								            }


								            bRc = TRUE;

								            break;

								        }

								        pTagData++;                     // Next record

								    }


								    return bRc;

								}


								BOOL

								DoesTRCAndColorantTagExist(

								    PBYTE pProfile

								    )

								{

								    if (DoesCPTagExist(pProfile,TAG_REDCOLORANT,NULL) &&

								        DoesCPTagExist(pProfile,TAG_REDTRC,NULL) &&

								        DoesCPTagExist(pProfile,TAG_GREENCOLORANT,NULL) &&

								        DoesCPTagExist(pProfile,TAG_GREENTRC,NULL) &&

								        DoesCPTagExist(pProfile,TAG_BLUECOLORANT,NULL) &&

								        DoesCPTagExist(pProfile,TAG_BLUETRC,NULL))

								    {

								        return TRUE;

								    }


								    return FALSE;

								}


								BOOL

								GetCPWhitePoint(

								    PBYTE      pProfile,

								    PFIX_16_16 pafxWP

								    )

								{

								    pafxWP[0]  = FIX_ENDIAN(((PPROFILEHEADER)pProfile)->phIlluminant.ciexyzX);

								    pafxWP[1]  = FIX_ENDIAN(((PPROFILEHEADER)pProfile)->phIlluminant.ciexyzY);

								    pafxWP[2]  = FIX_ENDIAN(((PPROFILEHEADER)pProfile)->phIlluminant.ciexyzZ);


								    return TRUE;

								}


								BOOL

								GetCPMediaWhitePoint(

								    PBYTE      pProfile,

								    PFIX_16_16 pafxMediaWP

								    )

								{

								    PTAGDATA pTagData;

								    PDWORD   pTable;

								    DWORD    dwIndex, i;


								    if (DoesCPTagExist (pProfile, TAG_MEDIAWHITEPOINT, &dwIndex))

								    {

								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								        //

								        // Skip the first 2 DWORDs to get to the real data

								        //


								        pTable = (PDWORD)(pProfile + FIX_ENDIAN(pTagData->dwOffset)) + 2;


								        for (i=0; i<3; i++)

								        {

								            pafxMediaWP[i] = FIX_ENDIAN(*pTable);

								            pTable++;

								        }


								        return TRUE;

								    }


								    return FALSE;

								}


								BOOL

								GetCPElementDataSize(

								    PBYTE  pProfile,

								    DWORD  dwIndex,

								    PDWORD pcbSize)

								{

								    PTAGDATA pTagData;


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    //

								    // Actual data Size of elements of type 'dataType' is 3 DWORDs less than the

								    // total tag data size

								    //


								    *pcbSize = FIX_ENDIAN(pTagData->cbSize) - 3 * sizeof(DWORD);


								    return TRUE;

								}


								BOOL

								GetCPElementSize(

								    PBYTE  pProfile,

								    DWORD  dwIndex,

								    PDWORD pcbSize)

								{

								    PTAGDATA pTagData;


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    *pcbSize = FIX_ENDIAN(pTagData->cbSize);


								    return TRUE;

								}


								BOOL

								GetCPElementDataType(

								    PBYTE  pProfile,

								    DWORD  dwIndex,

								    PDWORD pdwDataType)

								{

								    PTAGDATA pTagData;

								    PBYTE    pData;


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    pData = pProfile + FIX_ENDIAN(pTagData->dwOffset);


								    *pdwDataType = FIX_ENDIAN(*((DWORD *)(pData + 2 * sizeof(DWORD))));


								    return TRUE;

								}


								BOOL

								GetCPElementData(

								    PBYTE  pProfile,

								    DWORD  dwIndex,

								    PBYTE  pBuffer,

								    PDWORD pdwSize

								    )

								{

								    PTAGDATA pTagData;

								    PBYTE    pData;


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    pData = pProfile + FIX_ENDIAN(pTagData->dwOffset);


								    //

								    // Actual data Size of elements of type 'dataType' is 3 DWORDs less than the

								    // total tag data size

								    //


								    *pdwSize = FIX_ENDIAN(pTagData->cbSize) - 3 * sizeof(DWORD);


								    if (pBuffer)

								    {

								        CopyMemory(pBuffer, (pData + 3*sizeof(DWORD)), *pdwSize);

								    }


								    return TRUE;

								}


								BOOL

								GetTRCElementSize(

								    PBYTE  pProfile,

								    DWORD  dwTag,

								    PDWORD pdwIndex,

								    PDWORD pdwSize

								    )

								{

								    DWORD dwDataType;


								    if (!DoesCPTagExist(pProfile, dwTag, pdwIndex) ||

								        !GetCPElementDataType(pProfile, *pdwIndex, &dwDataType) ||

								        !(dwDataType != SIG_CURVE_TYPE) ||

								        !GetCPElementSize(pProfile, *pdwIndex, pdwSize))

								    {

								        return FALSE;

								    }


								    return TRUE;

								}


								DWORD

								Ascii85Encode(

								    PBYTE pBuffer,

								    DWORD dwDataSize,

								    DWORD dwBufSize

								    )

								{

								    // WINBUG #83136 2-7-2000 bhouse Investigate empty function Ascii85Encode

								    // Old Comment:

								    //     - To be done


								#if 0

								    PBYTE     pTempBuf, pPtr;

								    DWORD     dwASCII85Size = 0;

								    DWORD     dwBufSize = DataSize * 5 / 4 + sizeof(ASCII85DecodeBegin)+sizeof(ASCII85DecodeEnd) + 2048;


								    if ((pTempBuf = (PBYTE)MemAlloc(dwBufSize)))

								    {

								        pPtr = pTempBuf;

								        pPtr += WriteObject(pPtr,  NewLine);

								        pPtr += WriteObject(pPtr,  ASCII85DecodeBegin);

								        pPtr += WriteObject(pPtr,  NewLine);

								        pPtr += WriteASCII85Cont(pPtr, dwBufSize, pBuffer, dwDataSize);

								        pPtr += WriteObject(pPtr,  ASCII85DecodeEnd);

								        dwAscii85Size = (DWORD)(pPtr - pTempBuf);

								        lstrcpyn(pBuffer, pTempBuf, dwAscii85Size);


								        MemFree(pTempBuf);

								    }


								    return dwAscii85Size;

								#else

								    return 0;

								#endif

								}


								/***************************************************************************

								*

								*   Function to write the Homogeneous Number Array token into the buffer

								*

								***************************************************************************/


								DWORD

								WriteHNAToken(

								    PBYTE pBuffer,

								    BYTE  token,

								    DWORD dwNum

								    )

								{

								    *pBuffer++ = token;

								    *pBuffer++ = 32;       // 16-bit fixed integer, high-order byte first

								    *pBuffer++ = (BYTE)((dwNum & 0xFF00) >> 8);

								    *pBuffer++ = (BYTE)(dwNum & 0x00FF);


								    return 4;

								}


								/***************************************************************************

								*

								*   Function to convert 2-bytes unsigned integer to 2-bytes signed

								*   integer(-32768) and write them to the buffer. High byte first.

								*

								***************************************************************************/


								DWORD

								WriteIntStringU2S(

								    PBYTE pBuffer,

								    PBYTE pData,

								    DWORD dwNum

								    )

								{

								    DWORD i, dwTemp;


								    for (i=0; i<dwNum; i++)

								    {

								        dwTemp = FIX_ENDIAN16(*((PWORD)pData)) - 32768;

								        *pBuffer++ = (BYTE)((dwTemp & 0xFF00) >> 8);

								        *pBuffer++ = (BYTE)(dwTemp & 0x00FF);

								        pData += sizeof(WORD);

								    }


								    return dwNum * 2;

								}


								/***************************************************************************

								*

								*   Function to convert 2-bytes unsigned integer to 2-bytes signed

								*   integer(-32768) and write them to the buffer. Low-order byte first.

								*

								***************************************************************************/


								DWORD

								WriteIntStringU2S_L(

								    PBYTE pBuffer,

								    PBYTE pData,

								    DWORD dwNum

								    )

								{

								    DWORD i, dwTemp;


								    for (i=0; i<dwNum; i++)

								    {

								        dwTemp = *((PWORD)pData) - 32768;

								        *pBuffer++ = (BYTE)((dwTemp & 0xFF00) >> 8);

								        *pBuffer++ = (BYTE)(dwTemp & 0x00FF);

								        pData += sizeof(WORD);

								    }


								    return dwNum * 2;

								}


								/***************************************************************************

								*

								*   Function to put the chunk of memory as string of Hex

								*

								***************************************************************************/


								DWORD

								WriteHexBuffer(

								    PBYTE pBuffer,

								    PBYTE pData,

								    PBYTE pLineStart,

								    DWORD dwBytes

								    )

								{

								    PBYTE  pStart = pBuffer;


								    for ( ; dwBytes ; dwBytes-- )

								    {

								        WriteHex(pBuffer, *pData);

								        pBuffer += 2;

								        pData++;

								        if (((DWORD)(pBuffer - pLineStart)) > MAX_LINELEN)

								        {

								            pLineStart = pBuffer;

								            pBuffer += WriteObject(pBuffer,  NewLine);

								        }

								    }

								    return( (DWORD)(pBuffer - pStart));

								}


								/***************************************************************************

								*

								*   Function to write the string token into the buffer

								*

								***************************************************************************/


								DWORD

								WriteStringToken(

								    PBYTE pBuffer,

								    BYTE  token,

								    DWORD dwNum

								    )

								{

								    *pBuffer++ = token;

								    *pBuffer++ = (BYTE)((dwNum & 0xFF00) >> 8);

								    *pBuffer++ = (BYTE)(dwNum & 0x00FF);


								    return 3;

								}


								/***************************************************************************

								*

								*   Function to put the chunk of memory into buffer

								*

								***************************************************************************/


								DWORD

								WriteByteString(

								    PBYTE pBuffer,

								    PBYTE pData,

								    DWORD dwBytes

								    )

								{

								    DWORD  i;


								    for (i=0; i<dwBytes; i++)

								        *pBuffer++ = *pData++;


								    return dwBytes;

								}


								/***************************************************************************

								*

								*   Function to put the chunk of memory into buffer

								*

								***************************************************************************/


								DWORD

								WriteInt2ByteString(

								    PBYTE pBuffer,

								    PBYTE pData,

								    DWORD dwBytes

								    )

								{

								    DWORD  i;


								    for (i=0; i<dwBytes ; i++)

								    {

								        *pBuffer++ = (BYTE)(FIX_ENDIAN16(*((PWORD)pData))/256);

								        pData += sizeof(WORD);

								    }


								    return dwBytes;

								}


								#ifndef KERNEL_MODE

								DWORD

								WriteFixed(

								    PBYTE     pBuffer,

								    FIX_16_16 fxNum

								    )

								{

								    double dFloat = (double) ((long) fxNum) / (double) FIX_16_16_SCALE;


								    return (WriteDouble(pBuffer,dFloat));

								}

								#else

								DWORD

								WriteFixed(

								    PBYTE     pBuffer,

								    FIX_16_16 fxNum

								    )

								{

								    PBYTE pStart = pBuffer;

								    DWORD i;


								    //

								    // Integer portion

								    //


								    #ifndef KERNEL_MODE

								    pBuffer += wsprintfA(pBuffer, "%lu", fxNum >> FIX_16_16_SHIFT);

								    #else

								    pBuffer += OPSprintf(pBuffer, "%l", fxNum >> FIX_16_16_SHIFT);

								    #endif


								    //

								    // Fractional part

								    //


								    fxNum &= 0xffff;

								    if (fxNum != 0)

								    {

								        //

								        // We output a maximum of 6 digits after the

								        // decimal point

								        //


								        *pBuffer++ = '.';


								        i = 0;

								        while (fxNum && i++ < 6)

								        {

								            fxNum *= 10;

								            *pBuffer++ = (BYTE)(fxNum >> FIX_16_16_SHIFT) + '0';  // quotient + '0'

								            fxNum -= FLOOR(fxNum);          // remainder

								        }

								    }


								    *pBuffer++ = ' ';


								    return (DWORD) (pBuffer - pStart);

								}

								#endif


								DWORD

								WriteFixed2dot30(

								    PBYTE pBuffer,

								    DWORD fxNum

								    )

								{

								    PBYTE pStart = pBuffer;

								    DWORD i;


								    //

								    // Integer portion

								    //


								    #ifndef KERNEL_MODE

								    pBuffer += wsprintfA(pBuffer, "%lu", fxNum >> 30);

								    #else

								    pBuffer += OPSprintf(pBuffer, "%l", fxNum >> 30);

								    #endif


								    //

								    // Fractional part

								    //


								    fxNum &= 0x3fffffffL;

								    if (fxNum != 0)

								    {

								        //

								        // We output a maximum of 10 digits after the

								        // decimal point

								        //


								        *pBuffer++ = '.';


								        i = 0;

								        while (fxNum && i++ < 10)

								        {

								            fxNum *= 10;

								            *pBuffer++ = (BYTE)(fxNum >> 30) + '0';  // quotient + '0'

								            fxNum -= ((fxNum >> 30) << 30);          // remainder

								        }

								    }


								    *pBuffer++ = ' ';


								    return (DWORD) (pBuffer - pStart);

								}


								#if !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								/***************************************************************************

								*

								*   Function to write the float into the buffer

								*

								***************************************************************************/


								DWORD WriteDouble(PBYTE pBuffer, double dFloat)

								{

								    LONG   lFloat  = (LONG) floor(dFloat * 10000.0 + 0.5);

								    double dFloat1 = lFloat  / 10000.0 ;

								    double dInt    = floor(fabs(dFloat1));

								    double dFract =  fabs(dFloat1) - dInt ;

								    char   cSign  = ' ' ;


								    if (dFloat1 < 0)

								    {

								        cSign = '-' ;

								    }


								    return (wsprintfA(pBuffer, (LPSTR) "%c%d.%0.4lu ",

								                        cSign, (WORD) dInt , (DWORD) (dFract * 10000.0)));

								}


								#endif // !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								DWORD WriteNewLineObject(

								    PBYTE       pBuffer,

								    const char *pData)

								{

								    PBYTE pStart = pBuffer;


								    pBuffer += WriteObject(pBuffer, NewLine);

								    pBuffer += WriteObject(pBuffer, pData);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								SendCRDBWPoint(

								    PBYTE      pBuffer,

								    PFIX_16_16 pafxWP

								    )

								{

								    PBYTE pStart = pBuffer;

								    int   i;


								    //

								    // /BlackPoint

								    //


								    pBuffer += WriteObject(pBuffer, NewLine);

								    pBuffer += WriteObject(pBuffer, BlackPointTag);

								    pBuffer += WriteObject(pBuffer, BlackPoint);


								    //

								    // /WhitePoint

								    //


								    pBuffer += WriteObject(pBuffer, NewLine);

								    pBuffer += WriteObject(pBuffer, WhitePointTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<3; i++)

								    {

								        pBuffer += WriteFixed(pBuffer, pafxWP[i]);

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								SendCRDPQR(

								    PBYTE      pBuffer,

								    DWORD      dwIntent,

								    PFIX_16_16 pafxWP

								    )

								{

								    PBYTE pStart = pBuffer;

								    int   i;


								    if (dwIntent != INTENT_ABSOLUTE_COLORIMETRIC)

								    {

								        //

								        // /RangePQR

								        //


								        pBuffer += WriteNewLineObject(pBuffer, RangePQRTag);

								        pBuffer += WriteObject(pBuffer, RangePQR);


								        //

								        // /MatrixPQR

								        //


								        pBuffer += WriteNewLineObject(pBuffer, MatrixPQRTag);

								        pBuffer += WriteObject(pBuffer, MatrixPQR);

								    }

								    else

								    {

								        //

								        // /RangePQR

								        //


								        pBuffer += WriteNewLineObject(pBuffer, RangePQRTag);

								        pBuffer += WriteObject(pBuffer, BeginArray);

								        for (i=0; i<3; i++)

								        {

								            pBuffer += WriteFixed(pBuffer, 0);

								            pBuffer += WriteFixed(pBuffer, pafxWP[i]);

								        }

								        pBuffer += WriteObject(pBuffer, EndArray);


								        //

								        // /MatrixPQR

								        //


								        pBuffer += WriteNewLineObject(pBuffer, MatrixPQRTag);

								        pBuffer += WriteObject(pBuffer, Identity);

								    }


								    //

								    // /TransformPQR

								    //


								    pBuffer += WriteNewLineObject(pBuffer, TransformPQRTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<3; i++)

								    {

								        pBuffer += WriteObject(pBuffer, BeginFunction);

								        pBuffer += WriteObject(pBuffer,

								            (dwIntent != INTENT_ABSOLUTE_COLORIMETRIC) ? TransformPQR[i] : NullOp);

								        pBuffer += WriteObject(pBuffer, EndFunction);

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								SendCRDLMN(

								    PBYTE      pBuffer,

								    DWORD      dwIntent,

								    PFIX_16_16 pafxIlluminantWP,

								    PFIX_16_16 pafxMediaWP,

								    DWORD      dwPCS

								    )

								{

								    PBYTE pStart = pBuffer;

								    DWORD i, j;


								    //

								    // /MatrixLMN

								    //


								    if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								    {

								        pBuffer += WriteNewLineObject(pBuffer, MatrixLMNTag);


								        pBuffer += WriteObject(pBuffer, BeginArray);

								        for (i=0; i<3; i++)

								        {

								            for (j=0; j<3; j++)

								                pBuffer += WriteFixed(pBuffer,

								                    (i == j) ? FIX_DIV(pafxIlluminantWP[i], pafxMediaWP[i]) : 0);

								        }

								        pBuffer += WriteObject(pBuffer, EndArray);

								    }


								    //

								    // /RangeLMN

								    //


								    pBuffer += WriteNewLineObject(pBuffer, RangeLMNTag);

								    if (dwPCS == SPACE_XYZ)

								    {

								        pBuffer += WriteObject(pBuffer, BeginArray);

								        for (i=0; i<3; i++)

								        {

								            pBuffer += WriteFixed(pBuffer, 0);

								            pBuffer += WriteFixed(pBuffer, pafxIlluminantWP[i]);

								        }

								        pBuffer += WriteObject(pBuffer, EndArray);

								    }

								    else

								    {

								        pBuffer += WriteObject(pBuffer, RangeLMNLab);

								    }


								    //

								    // /EncodeLMN

								    //


								    pBuffer += WriteNewLineObject(pBuffer, EncodeLMNTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<3; i++)

								    {

								        pBuffer += WriteObject(pBuffer, BeginFunction);

								        if (dwPCS != SPACE_XYZ)

								        {

								            pBuffer += WriteFixed(pBuffer, pafxIlluminantWP[i]);

								            pBuffer += WriteObject(pBuffer, DivOp);

								            pBuffer += WriteObject(pBuffer, EncodeLMNLab);

								        }

								        pBuffer += WriteObject(pBuffer, EndFunction);

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								SendCRDABC(

								    PBYTE       pBuffer,

								    PBYTE       pPublicArrayName,

								    DWORD       dwPCS,

								    DWORD       nInputCh,

								    PBYTE       pLut,

								    PFIX_16_16  e,

								    DWORD       dwLutSig,

								    BOOL        bBinary

								    )

								{

								    PBYTE      pLineStart, pStart = pBuffer;

								    PBYTE      pTable;

								    DWORD      i, j;

								    FIX_16_16  fxTempMatrixABC[9];


								    //

								    // /RangeABC

								    //


								    pBuffer += WriteNewLineObject(pBuffer, RangeABCTag);

								    pBuffer += WriteObject(pBuffer, RangeABC);


								    //

								    // /MatrixABC

								    //


								    pBuffer += WriteNewLineObject(pBuffer, MatrixABCTag);

								    if (dwPCS == SPACE_XYZ)

								    {

								        pBuffer += WriteObject(pBuffer, BeginArray);

								        if (e)

								        {

								            for (i=0; i<3; i++)

								            {

								                for (j=0; j<3; j++)

								                {

								                    pBuffer += WriteFixed(pBuffer, e[i + j * 3]);

								                }

								            }

								        }

								        else

								        {

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pTable = (PBYTE) &((PLUT8TYPE)pLut)->e00;

								            }

								            else

								            {

								                pTable = (PBYTE) &((PLUT16TYPE)pLut)->e00;

								            }


								            for (i=0; i<9; i++)

								            {

								                fxTempMatrixABC[i] = FIX_DIV(FIX_ENDIAN(*((PDWORD)pTable)), CIEXYZRange);

								                pTable += sizeof(DWORD);

								            }

								            for (i=0; i<3; i++)

								            {

								                for (j=0; j<3; j++)

								                {

								                    pBuffer += WriteFixed(pBuffer, fxTempMatrixABC[i + j * 3]);

								                }

								            }

								        }

								        pBuffer += WriteObject(pBuffer, EndArray);

								    }

								    else

								    {

								        pBuffer += WriteObject(pBuffer, MatrixABCLabCRD);

								    }


								    //

								    // /EncodeABC

								    //


								    if (nInputCh == 0)

								    {

								        return (DWORD)(pBuffer - pStart);

								    }


								    pLineStart = pBuffer;

								    pBuffer += WriteNewLineObject(pBuffer, EncodeABCTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<nInputCh; i++)

								    {

								        pLineStart = pBuffer;


								        pBuffer += WriteNewLineObject(pBuffer, BeginFunction);

								        if (dwPCS == SPACE_Lab)

								        {

								            pBuffer += WriteObject(pBuffer, (i == 0) ? EncodeABCLab1 : EncodeABCLab2);

								        }


								        pBuffer += WriteObject(pBuffer, StartClip);

								        if (e)

								            pBuffer += WriteObject(pBuffer, PreViewInArray);

								        else

								            pBuffer += WriteObject(pBuffer, InputArray);


								        pBuffer += WriteObject(pBuffer, pPublicArrayName);

								        pBuffer += WriteInt(pBuffer, i);


								        if (!bBinary)              // Output ASCII CRD

								        {

								            pBuffer += WriteNewLineObject(pBuffer, IndexArray);

								        }

								        else

								        {                               // Output BINARY CRD

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray16b);

								            }

								        }


								        pBuffer += WriteObject(pBuffer, (dwLutSig == LUT8_TYPE) ?

								                         Scale8 : Scale16);

								        pBuffer += WriteObject(pBuffer, EndClip);

								        pBuffer += WriteObject(pBuffer, EndFunction);

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								SendCRDOutputTable(

								    PBYTE pBuffer,

								    PBYTE pPublicArrayName,

								    DWORD nOutputCh,

								    DWORD dwLutSig,

								    BOOL  bHost,

								    BOOL  bBinary

								    )

								{

								    PBYTE pStart = pBuffer;

								    DWORD i;


								    for (i=0; i<nOutputCh; i++)

								    {

								        pBuffer += WriteNewLineObject(pBuffer, BeginFunction);

								        pBuffer += WriteObject(pBuffer, Clip01);

								        if (bHost)

								            pBuffer += WriteObject(pBuffer, PreViewOutArray);

								        else

								            pBuffer += WriteObject(pBuffer, OutputArray);


								        pBuffer += WriteObject(pBuffer, pPublicArrayName);

								        pBuffer += WriteInt(pBuffer, i);


								        if (! bBinary)

								        {

								            pBuffer += WriteObject(pBuffer, NewLine);

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, TFunction8);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray);

								                pBuffer += WriteObject(pBuffer, Scale16);

								            }

								        }

								        else

								        {

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pBuffer += WriteObject(pBuffer, TFunction8);

								            }

								            else

								            {

								                pBuffer += WriteObject(pBuffer, IndexArray16b);

								                pBuffer += WriteObject(pBuffer, Scale16);

								            }

								        }


								        pBuffer += WriteObject(pBuffer, EndFunction);

								    }


								    return (DWORD)(pBuffer - pStart);

								}


								VOID

								GetCLUTInfo(

								    DWORD  dwLutSig,

								    PBYTE  pLut,

								    PDWORD pnInputCh,

								    PDWORD pnOutputCh,

								    PDWORD pnGrids,

								    PDWORD pnInputTable,

								    PDWORD pnOutputTable,

								    PDWORD pdwSize

								    )

								{

								    if (dwLutSig == LUT8_TYPE)

								    {

								        *pnInputCh = ((PLUT8TYPE)pLut)->nInputChannels;

								        *pnOutputCh = ((PLUT8TYPE)pLut)->nOutputChannels;

								        *pnGrids = ((PLUT8TYPE)pLut)->nClutPoints;

								        *pnInputTable = 256L;

								        *pnOutputTable = 256L;

								        if (pdwSize)

								            *pdwSize = 1;

								    }

								    else

								    {

								        *pnInputCh = ((PLUT16TYPE)pLut)->nInputChannels;

								        *pnOutputCh = ((PLUT16TYPE)pLut)->nOutputChannels;

								        *pnGrids =  ((PLUT16TYPE)pLut)->nClutPoints;

								        *pnInputTable = FIX_ENDIAN16(((PLUT16TYPE)pLut)->wInputEntries);

								        *pnOutputTable = FIX_ENDIAN16(((PLUT16TYPE)pLut)->wOutputEntries);

								        if (pdwSize)

								            *pdwSize = 2;

								    }


								    return;

								}


								DWORD

								EnableGlobalDict(

								    PBYTE pBuffer

								    )

								{

								    PBYTE pStart = pBuffer;


								    pBuffer += WriteNewLineObject(pBuffer, CurrentGlobalOp);

								    pBuffer += WriteObject(pBuffer, TrueOp);

								    pBuffer += WriteObject(pBuffer, SetGlobalOp);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								BeginGlobalDict(

								    PBYTE pBuffer

								    )

								{

								    PBYTE pStart = pBuffer;


								    pBuffer += WriteNewLineObject(pBuffer, GlobalDictOp);

								    pBuffer += WriteObject(pBuffer, BeginOp);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								EndGlobalDict(

								    PBYTE pBuffer

								    )

								{

								    PBYTE pStart = pBuffer;


								    pBuffer += WriteNewLineObject(pBuffer, EndOp);

								    pBuffer += WriteObject(pBuffer, SetGlobalOp);


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								SendCSABWPoint(

								    PBYTE      pBuffer,

								    DWORD      dwIntent,

								    PFIX_16_16 pafxIlluminantWP,

								    PFIX_16_16 pafxMediaWP

								    )

								{

								    PBYTE pStart = pBuffer;

								    int   i;


								    //

								    // /BlackPoint

								    //


								    pBuffer += WriteNewLineObject(pBuffer, BlackPointTag);

								    pBuffer += WriteObject(pBuffer, BlackPoint);


								    //

								    // /WhitePoint

								    //


								    pBuffer += WriteNewLineObject(pBuffer, WhitePointTag);

								    pBuffer += WriteObject(pBuffer, BeginArray);

								    for (i=0; i<3; i++)

								    {

								        if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								        {

								            pBuffer += WriteFixed(pBuffer, pafxMediaWP[i]);

								        }

								        else

								        {

								            pBuffer += WriteFixed(pBuffer, pafxIlluminantWP[i]);

								        }

								    }

								    pBuffer += WriteObject(pBuffer, EndArray);


								    return (DWORD)(pBuffer - pStart);

								}


								VOID

								GetMediaWP(

								    PBYTE      pProfile,

								    DWORD      dwIntent,

								    PFIX_16_16 pafxIlluminantWP,

								    PFIX_16_16 pafxMediaWP

								    )

								{

								    if (dwIntent == INTENT_ABSOLUTE_COLORIMETRIC)

								    {

								        if (! GetCPMediaWhitePoint(pProfile, pafxMediaWP))

								        {

								            pafxMediaWP[0] = pafxIlluminantWP[0];

								            pafxMediaWP[1] = pafxIlluminantWP[1];

								            pafxMediaWP[2] = pafxIlluminantWP[2];

								        }

								    }


								    return;

								}


								BOOL

								GetCRDInputOutputArraySize(

								    PBYTE  pProfile,

								    DWORD  dwIntent,

								    PDWORD pdwInTblSize,

								    PDWORD pdwOutTblSize,

								    PDWORD pdwTag,

								    PDWORD pnGrids

								    )

								{

								    PTAGDATA   pTagData;

								    PLUT16TYPE pLut;

								    DWORD      dwIndex, dwLutSig;

								    DWORD      nInputEntries, nOutputEntries;

								    DWORD      nInputCh, nOutputCh, nGrids;

								    BOOL       bRet = TRUE;


								    //

								    // Make sure required tags exist

								    //


								    switch (dwIntent)

								    {

								    case INTENT_PERCEPTUAL:

								        *pdwTag = TAG_BToA0;

								        break;


								    case INTENT_RELATIVE_COLORIMETRIC:

								    case INTENT_ABSOLUTE_COLORIMETRIC:

								        *pdwTag = TAG_BToA1;

								        break;


								    case INTENT_SATURATION:

								        *pdwTag = TAG_BToA2;

								        break;


								    default:

								        WARNING((__TEXT("Invalid intent passed to GetCRDInputOutputArraySize: %d\n"), dwIntent));

								        SetLastError(ERROR_INVALID_PARAMETER);

								        return FALSE;

								    }


								    if (DoesCPTagExist(pProfile, *pdwTag, &dwIndex))

								    {

								        pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								                   dwIndex * sizeof(TAGDATA));


								        pLut = (PLUT16TYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								        dwLutSig = FIX_ENDIAN(pLut->dwSignature);


								        if ((dwLutSig != LUT8_TYPE) && (dwLutSig != LUT16_TYPE))

								        {

								            WARNING((__TEXT("Invalid Lut type - unable to create proofing CRD\n")));

								            SetLastError(ERROR_INVALID_PROFILE);

								            return FALSE;

								        }


								        (void)GetCLUTInfo(dwLutSig, (PBYTE)pLut, &nInputCh, &nOutputCh,

								                &nGrids, &nInputEntries, &nOutputEntries, NULL);


								        if (pdwInTblSize)

								        {

								            if (nInputCh != 3)

								            {

								                return FALSE;

								            }


								            *pdwInTblSize = nInputCh * nInputEntries * 6;  // Number of INT bytes

								            *pnGrids = nGrids;

								        }


								        if (pdwOutTblSize)

								        {

								            if ((nOutputCh != 3) && (nOutputCh != 4))

								            {

								                return FALSE;

								            }


								            *pdwOutTblSize = nOutputCh * nOutputEntries * 6; // Number of INT bytes

								            *pnGrids = nGrids;

								        }


								        return TRUE;

								    }

								    else

								    {

								        //

								        // Matrix icc profile.

								        //


								        *pnGrids = 2;


								        if (pdwInTblSize)

								        {

								            bRet = GetHostCSA(pProfile, NULL, pdwInTblSize,

								                              dwIntent, TYPE_CIEBASEDDEF);

								            *pdwInTblSize = *pdwInTblSize * 3;

								        }


								        if (bRet && pdwOutTblSize)

								        {

								            bRet = GetHostCSA(pProfile, NULL, pdwInTblSize,

								                              dwIntent, TYPE_CIEBASEDDEF);

								            *pdwOutTblSize = *pdwOutTblSize * 3;

								        }


								        return bRet;

								    }

								}


								#if !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								DWORD

								CreateHostLutCRD(

								    PBYTE  pProfile,

								    DWORD  dwIndex,

								    PBYTE  pBuffer,

								    DWORD  dwIntent

								    )

								{

								    PLUT16TYPE pLut;

								    PHOSTCLUT  pHostClut;

								    PTAGDATA   pTagData;

								    PBYTE      pTable;

								    DWORD      nInputCh, nOutputCh, nGrids;

								    DWORD      nInputEntries, nOutputEntries, nNumbers;

								    DWORD      dwPCS, dwLutSig;

								    DWORD      dwSize, i, j;

								    PBYTE      pStart = pBuffer;


								    //

								    // Check if we can generate the CSA

								    // Required  tags is AToBi, where i is the rendering intent

								    //


								    dwPCS = GetCPConnSpace(pProfile);


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    pLut = (PLUT16TYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    dwLutSig = FIX_ENDIAN(pLut->dwSignature);


								    if ((dwLutSig != LUT8_TYPE) && (dwLutSig != LUT16_TYPE))

								    {

								        WARNING((__TEXT("Invalid profile - unable to create Lut CRD\n")));

								        SetLastError(ERROR_INVALID_PROFILE);

								        return 0;

								    }


								    (void)GetCLUTInfo(dwLutSig, (PBYTE)pLut, &nInputCh, &nOutputCh,

								            &nGrids, &nInputEntries, &nOutputEntries, &i);


								    if (((nOutputCh != 3) && (nOutputCh != 4)) ||  (nInputCh != 3))

								    {

								        return 0;

								    }


								    if (pBuffer == NULL)

								    {

								        //

								        // Return size

								        //


								        dwSize = nInputCh * nInputEntries * i    +  // Input table 8/16-bits

								            nOutputCh * nOutputEntries * i       +  // Output table 8/16-bits

								            nOutputCh * nGrids * nGrids * nGrids +  // CLUT 8-bits only

								            sizeof(HOSTCLUT)                     +  // Data structure

								            2048;                                   // Other PS stuff


								        //

								        // Add space for new line.

								        //


								        dwSize += (((dwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								        return dwSize;

								    }


								    pHostClut = (PHOSTCLUT)pBuffer;

								    pBuffer += sizeof(HOSTCLUT);

								    pHostClut->wSize = sizeof(HOSTCLUT);

								    pHostClut->wDataType = DATATYPE_LUT;

								    pHostClut->dwPCS = dwPCS;

								    pHostClut->dwIntent = dwIntent;

								    pHostClut->nLutBits = (dwLutSig == LUT8_TYPE) ? 8 : 16;


								    (void)GetCPWhitePoint(pProfile, pHostClut->afxIlluminantWP);


								    //

								    // Support absolute whitePoint

								    //


								    if (!GetCPMediaWhitePoint(pProfile, pHostClut->afxMediaWP))

								    {

								        pHostClut->afxMediaWP[0] = pHostClut->afxIlluminantWP[0];

								        pHostClut->afxMediaWP[1] = pHostClut->afxIlluminantWP[1];

								        pHostClut->afxMediaWP[2] = pHostClut->afxIlluminantWP[2];

								    }


								    pHostClut->nInputCh = (BYTE)nInputCh;

								    pHostClut->nOutputCh = (BYTE)nOutputCh;

								    pHostClut->nClutPoints = (BYTE)nGrids;

								    pHostClut->nInputEntries = (WORD)nInputEntries;

								    pHostClut->nOutputEntries = (WORD)nOutputEntries;


								    //

								    // Input array

								    //


								    pBuffer += CreateHostInputOutputArray(

								                        pBuffer,

								                        pHostClut->inputArray,

								                        nInputCh,

								                        nInputEntries,

								                        0,

								                        dwLutSig,

								                        (PBYTE)pLut);


								    //

								    // The offset to the position of output array.

								    //


								    i = nInputEntries * nInputCh +

								        nGrids * nGrids * nGrids * nOutputCh;


								    //

								    // Output array

								    //


								    pBuffer += CreateHostInputOutputArray(

								                        pBuffer,

								                        pHostClut->outputArray,

								                        nOutputCh,

								                        nOutputEntries,

								                        i,

								                        dwLutSig,

								                        (PBYTE)pLut);


								    //

								    // Matrix

								    //


								    if (dwPCS == SPACE_XYZ)

								    {

								        if (dwLutSig == LUT8_TYPE)

								        {

								            pTable = (PBYTE) &((PLUT8TYPE)pLut)->e00;

								        } else

								        {

								            pTable = (PBYTE) &((PLUT16TYPE)pLut)->e00;

								        }


								        for (i=0; i<9; i++)

								        {

								            pHostClut->e[i] = FIX_DIV(FIX_ENDIAN(*((PDWORD)pTable)), CIEXYZRange);

								            pTable += sizeof(DWORD);

								        }

								    }


								    //

								    // RenderTable

								    //


								    nNumbers = nGrids * nGrids * nOutputCh;

								    pHostClut->clut = pBuffer;


								    for (i=0; i<nGrids; i++)        // Na strings should be sent

								    {

								        if (dwLutSig == LUT8_TYPE)

								        {

								            pTable = (PBYTE)(((PLUT8TYPE)pLut)->data) +

								                nInputEntries * nInputCh +

								                nNumbers * i;

								        }

								        else

								        {

								            pTable = (PBYTE)(((PLUT16TYPE)pLut)->data) +

								                2 * nInputEntries * nInputCh +

								                2 * nNumbers * i;

								        }


								        if (dwLutSig == LUT8_TYPE)

								        {

								            CopyMemory(pBuffer, pTable, nNumbers);

								            pBuffer += nNumbers;

								        }

								        else

								        {

								            for (j=0; j<nNumbers; j++)

								            {

								                *pBuffer++ = (BYTE)(FIX_ENDIAN16(*((PWORD)pTable)) / 256);

								                pTable += sizeof(WORD);

								            }

								        }

								    }


								    return (DWORD)(pBuffer - pStart);

								}


								DWORD

								CreateHostMatrixCSAorCRD(

								    PBYTE pProfile,

								    PBYTE pBuffer,

								    PDWORD pcbSize,

								    DWORD dwIntent,

								    BOOL bCSA

								    )

								{

								    PTAGDATA   pTagData;

								    DWORD      dwRedTRCIndex, dwGreenTRCIndex, dwBlueTRCIndex;

								    DWORD      dwRedCount, dwGreenCount, dwBlueCount;

								    PCURVETYPE pRed, pGreen, pBlue;

								    PHOSTCLUT  pHostClut;

								    PBYTE      pStart = pBuffer;

								    DWORD      i, dwSize;

								    double     adArray[9], adRevArray[9], adTemp[9];


								    //

								    // Get each TRC index for Red, Green and Blue.

								    //


								    if (!DoesCPTagExist(pProfile, TAG_REDTRC, &dwRedTRCIndex) ||

								        !DoesCPTagExist(pProfile, TAG_GREENTRC, &dwGreenTRCIndex) ||

								        !DoesCPTagExist(pProfile, TAG_BLUETRC, &dwBlueTRCIndex))

								    {

								        return FALSE;

								    }


								    //

								    // Get CURVETYPE data for each Red, Green and Blue

								    //


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwRedTRCIndex * sizeof(TAGDATA));


								    pRed = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwGreenTRCIndex * sizeof(TAGDATA));


								    pGreen = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwBlueTRCIndex * sizeof(TAGDATA));


								    pBlue = (PCURVETYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    //

								    // Get curve count for each Red, Green and Blue.

								    //


								    dwRedCount   = FIX_ENDIAN(pRed->nCount);

								    dwGreenCount = FIX_ENDIAN(pGreen->nCount);

								    dwBlueCount  = FIX_ENDIAN(pBlue->nCount);


								    //

								    // Estimate the memory size required to hold CRD

								    //


								    dwSize = (dwRedCount + dwGreenCount + dwBlueCount) * 2 +

								             sizeof(HOSTCLUT) + 2048;   // data structure + extra safe space


								    //

								    // Add space for new line.

								    //


								    dwSize += (((dwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								    if (pBuffer == NULL)     // This is a size request

								    {

								        *pcbSize = dwSize;

								        return TRUE;

								    }


								    //

								    // Check buffer size.

								    //


								    if (*pcbSize < dwSize)

								    {

								        WARNING((__TEXT("Buffer too small to get Host Matrix CSA/CRD\n")));

								        SetLastError(ERROR_INSUFFICIENT_BUFFER);

								        return FALSE;

								    }


								    pHostClut = (PHOSTCLUT)pBuffer;

								    pBuffer += sizeof(HOSTCLUT);

								    pHostClut->wSize = sizeof(HOSTCLUT);

								    pHostClut->wDataType = DATATYPE_MATRIX;

								    pHostClut->dwPCS = SPACE_XYZ;

								    pHostClut->dwIntent = dwIntent;

								    pHostClut->nClutPoints = 2;


								    (void)GetCPWhitePoint(pProfile, pHostClut->afxIlluminantWP);


								    if (bCSA)

								    {

								        pHostClut->nInputEntries = (USHORT) dwRedCount;

								        pHostClut->nInputCh      = 3;


								        pBuffer += CreateHostTRCInputTable(pBuffer, pHostClut,

								                                           pRed, pGreen, pBlue);

								    }

								    else

								    {

								        pHostClut->nOutputEntries = (USHORT) dwRedCount;

								        pHostClut->nOutputCh = 3;


								        pBuffer += CreateHostRevTRCInputTable(pBuffer, pHostClut,

								                                              pRed, pGreen, pBlue);

								    }


								    if (!CreateColorantArray(pProfile, &adTemp[0], TAG_REDCOLORANT) ||

								        !CreateColorantArray(pProfile, &adTemp[3], TAG_GREENCOLORANT) ||

								        !CreateColorantArray(pProfile, &adTemp[6], TAG_BLUECOLORANT))

								    {

								        WARNING((__TEXT("Fail to create colorant array for Host Matrix CSA/CRD\n")));

								        return FALSE;

								    }


								    for (i = 0; i < 9; i++)

								    {

								        adArray[i] = adTemp[i/8*8 + i*3%8];

								    }


								    if (bCSA)

								    {

								        for (i = 0; i < 9; i++)

								        {

								            //

								            // Convert double to Fix 16.16

								            //


								            pHostClut->e[i] = (FIX_16_16)(adArray[i] * (double)FIX_16_16_SCALE);

								        }

								    }

								    else

								    {

								        InvertColorantArray(adArray, adRevArray);

								        for (i = 0; i < 9; i++)

								        {

								            //

								            // Convert double to Fix 16.16

								            //


								            pHostClut->e[i] = (FIX_16_16)(adRevArray[i] * (double)FIX_16_16_SCALE);

								        }

								    }


								    *pcbSize = (DWORD)(pBuffer - pStart);


								    return TRUE;

								}


								DWORD

								CreateHostTRCInputTable(

								    PBYTE pBuffer,

								    PHOSTCLUT pHostClut,

								    PCURVETYPE pRed,

								    PCURVETYPE pGreen,

								    PCURVETYPE pBlue

								    )

								{

								    DWORD i;

								    PWORD pBuffer16 = (PWORD) pBuffer;

								    PWORD pTable;


								    //

								    // Red

								    //


								    pHostClut->inputArray[0] = (PBYTE) pBuffer16;

								    pTable = pRed->data;

								    for (i = 0; i < pHostClut->nInputEntries; i++)

								    {

								        *pBuffer16++ = FIX_ENDIAN16(*pTable);

								        pTable++;

								    }


								    //

								    // Green

								    //


								    pHostClut->inputArray[1] = (PBYTE) pBuffer16;

								    pTable = pGreen->data;

								    for (i = 0; i < pHostClut->nInputEntries; i++)

								    {

								        *pBuffer16++ = FIX_ENDIAN16(*pTable);

								        pTable++;

								    }


								    //

								    // Blue

								    //


								    pHostClut->inputArray[2] = (PBYTE) pBuffer16;

								    pTable = pBlue->data;

								    for (i = 0; i < pHostClut->nInputEntries; i++)

								    {

								        *pBuffer16++ = FIX_ENDIAN16(*pTable);

								        pTable++;

								    }


								    return (DWORD)((PBYTE)pBuffer16 - pBuffer);

								}


								DWORD

								CreateHostRevTRCInputTable(

								    PBYTE pBuffer,

								    PHOSTCLUT pHostClut,

								    PCURVETYPE pRed,

								    PCURVETYPE pGreen,

								    PCURVETYPE pBlue

								    )

								{

								    PWORD pTemp = MemAlloc(pHostClut->nOutputEntries * (REVCURVE_RATIO + 1) * 2);


								    if (! pTemp)

								    {

								        return 0;

								    }


								    //

								    // Red

								    //


								    pHostClut->outputArray[0] = pBuffer;

								    GetRevCurve(pRed, pTemp, (PWORD) pHostClut->outputArray[0]);


								    //

								    // Green

								    //


								    pHostClut->outputArray[1] = pHostClut->outputArray[0] +

								                                2 * REVCURVE_RATIO * pHostClut->nOutputEntries;

								    GetRevCurve(pGreen, pTemp, (PWORD) pHostClut->outputArray[1]);


								    //

								    // Blue

								    //


								    pHostClut->outputArray[2] = pHostClut->outputArray[1] +

								                                2 * REVCURVE_RATIO * pHostClut->nOutputEntries;

								    GetRevCurve(pBlue, pTemp, (PWORD) pHostClut->outputArray[2]);


								    MemFree(pTemp);


								    return (DWORD)(2 * REVCURVE_RATIO * pHostClut->nOutputEntries * 3);

								}


								/***************************************************************************

								*                      GetHostColorRenderingDictionary

								*  function:

								*    this is the main function which creates the Host CRD

								*  parameters:

								*       cp          --  Color Profile handle

								*       Intent      --  Intent.

								*       lpMem       --  Pointer to the memory block.If this point is NULL,

								*                       require buffer size.

								*       lpcbSize    --  size of memory block.

								*

								*  returns:

								*       SINT        --  !=0 if the function was successful,

								*                         0 otherwise.

								*                       Returns number of bytes required/transferred

								***************************************************************************/


								BOOL

								GetHostColorRenderingDictionary(

								    PBYTE  pProfile,

								    DWORD  dwIntent,

								    PBYTE  pBuffer,

								    PDWORD pdwSize

								    )

								{

								    DWORD dwBToATag, dwIndex;


								    switch (dwIntent)

								    {

								    case INTENT_PERCEPTUAL:

								        dwBToATag = TAG_BToA0;

								        break;


								    case INTENT_RELATIVE_COLORIMETRIC:

								    case INTENT_ABSOLUTE_COLORIMETRIC:

								        dwBToATag = TAG_BToA1;

								        break;


								    case INTENT_SATURATION:

								        dwBToATag = TAG_BToA2;

								        break;


								    default:

								        *pdwSize = 0;

								        return FALSE;

								    }


								    if (DoesCPTagExist(pProfile, dwBToATag, &dwIndex))

								    {

								        *pdwSize = CreateHostLutCRD(pProfile, dwIndex, pBuffer, dwIntent);


								        return *pdwSize > 0;

								    }

								    else if (DoesTRCAndColorantTagExist(pProfile))

								    {

								        return CreateHostMatrixCSAorCRD(pProfile, pBuffer, pdwSize, dwIntent, FALSE);

								    }

								    else

								    {

								        return FALSE;

								    }

								}


								/***************************************************************************

								*                           CreateHostInputOutputArray

								*  function:

								*    this is the function which creates the output array from the data

								*    supplied in the ColorProfile's LUT8 or LUT16 tag.

								*  parameters:

								*    MEMPTR     lpMem        : The buffer to save output array.

								*    LPHOSTCLUT lpHostClut   :

								*    SINT       nOutputCh    : Number of input channel.

								*    SINT       nOutputTable : The size of each input table.

								*    SINT       Offset       : The position of source output data(in icc profile).

								*    CSIG       Tag          : To determin the Output table is 8 or 16 bits.

								*    MEMPTR     Buff         : The buffer that contains source data(copyed from icc profile)

								*

								*  returns:

								*       SINT    Returns number of bytes of Output Array

								*

								***************************************************************************/


								DWORD

								CreateHostInputOutputArray(

								    PBYTE  pBuffer,

								    PBYTE  *ppArray,

								    DWORD  nNumChan,

								    DWORD  nTableSize,

								    DWORD  dwOffset,

								    DWORD  dwLutSig,

								    PBYTE  pLut

								    )

								{

								    PBYTE   pStart = pBuffer;

								    PBYTE   pTable;

								    DWORD   i, j;


								    for (i=0; i<nNumChan; i++)

								    {

								        ppArray[i] = pBuffer;


								        if (dwLutSig == LUT8_TYPE)

								        {

								            pTable = (PBYTE) (((PLUT8TYPE)pLut)->data) +

								                dwOffset + nTableSize * i;


								            CopyMemory(pBuffer, pTable, nTableSize);


								            pBuffer += nTableSize;

								        }

								        else

								        {

								            pTable = (PBYTE) (((PLUT16TYPE)pLut)->data) +

								                2 * dwOffset +

								                2 * nTableSize * i;


								            for (j=0; j<nTableSize; j++)

								            {

								                *((PWORD)pBuffer) = FIX_ENDIAN16(*((PWORD)pTable));

								                pBuffer += sizeof(WORD);

								                pTable += sizeof(WORD);

								            }

								        }

								    }


								    return (DWORD) (pBuffer - pStart);

								}


								/***************************************************************************

								*                           GetHostCSA

								*  function:

								*    this is the function which creates a Host CSA

								*  parameters:

								*       CHANDLE cp       --  Color Profile handle

								*       MEMPTR lpMem     --  Pointer to the memory block. If this point is NULL,

								*                            require buffer size.

								*       LPDWORD lpcbSize --  Size of the memory block

								*       CSIG InputIntent --

								*       SINT Index       --  to the icc profile tag that contains the data of Intent

								*       int  Type        --  DEF or DEFG

								*  returns:

								*       BOOL        --  TRUE if the function was successful,

								*                       FALSE otherwise.

								***************************************************************************/


								BOOL

								GetHostCSA(

								    PBYTE  pProfile,

								    PBYTE  pBuffer,

								    PDWORD pdwSize,

								    DWORD  dwIntent,

								    DWORD  dwType

								    )

								{

								    PHOSTCLUT  pHostClut;

								    PTAGDATA   pTagData;

								    PLUT16TYPE pLut;

								    DWORD      dwAToBTag;

								    DWORD      dwPCS, dwLutSig;

								    DWORD      nInputCh, nOutputCh, nGrids, SecondGrids;

								    DWORD      nInputTable, nOutputTable, nNumbers;

								    DWORD      dwIndex, i, j, k;

								    PBYTE      pTable;

								    PBYTE      pStart = pBuffer;


								    switch (dwIntent)

								    {

								    case INTENT_PERCEPTUAL:

								        dwAToBTag = TAG_AToB0;

								        break;


								    case INTENT_RELATIVE_COLORIMETRIC:

								    case INTENT_ABSOLUTE_COLORIMETRIC:

								        dwAToBTag = TAG_AToB1;

								        break;


								    case INTENT_SATURATION:

								        dwAToBTag = TAG_AToB2;

								        break;


								    default:

								        WARNING((__TEXT("Invalid intent passed to GetHostCSA: %d\n"), dwIntent));

								        SetLastError(ERROR_INVALID_PARAMETER);

								        return FALSE;

								        break;

								    }


								    if (!DoesCPTagExist(pProfile, dwAToBTag, &dwIndex))

								    {

								        if (DoesTRCAndColorantTagExist(pProfile) && (dwType == TYPE_CIEBASEDDEF))

								        {

								            //

								            // Create Host CSA from Matrix.

								            //


								            return CreateHostMatrixCSAorCRD(pProfile,pBuffer,pdwSize,dwIntent,TRUE);

								        }

								        else

								        {

								            WARNING((__TEXT("AToB tag not present for intent %d\n"), dwIntent));

								            SetLastError(ERROR_TAG_NOT_PRESENT);

								            return FALSE;

								        }

								    }


								    //

								    // Check if we can generate the CSA

								    //


								    dwPCS = GetCPConnSpace(pProfile);


								    pTagData = (PTAGDATA)(pProfile + sizeof(PROFILEHEADER) + sizeof(DWORD) +

								               dwIndex * sizeof(TAGDATA));


								    pLut = (PLUT16TYPE)(pProfile + FIX_ENDIAN(pTagData->dwOffset));


								    dwLutSig = FIX_ENDIAN(pLut->dwSignature);


								    if (((dwPCS != SPACE_Lab) && (dwPCS != SPACE_XYZ)) ||

								        ((dwLutSig != LUT8_TYPE) && (dwLutSig != LUT16_TYPE)))

								    {

								        WARNING((__TEXT("Invalid color space - unable to create DEF(G) host CSA\n")));

								        SetLastError(ERROR_INVALID_PROFILE);

								        return FALSE;

								    }


								    //

								    // Estimate the memory size required to hold CSA

								    //


								    (void)GetCLUTInfo(dwLutSig, (PBYTE)pLut, &nInputCh, &nOutputCh, &nGrids,

								                &nInputTable, &nOutputTable, &i);


								    if (!(nOutputCh == 3) ||

								        !((nInputCh == 3) && (dwType == TYPE_CIEBASEDDEF)) &&

								        !((nInputCh == 4) && (dwType == TYPE_CIEBASEDDEFG)))

								    {

								        return FALSE;

								    }


								    if (pBuffer == NULL)

								    {

								        //

								        // Return size

								        //


								        if (dwType == TYPE_CIEBASEDDEFG)

								            *pdwSize = nOutputCh * nGrids * nGrids * nGrids * nGrids;

								        else

								            *pdwSize = nOutputCh * nGrids * nGrids * nGrids;


								        *pdwSize +=                           // size of RenderTable 8-bits only

								            nInputCh * nInputTable * i    +   // size of input table 8/16-bits

								            nOutputCh * nOutputTable * i  +   // size of output table 8/16-bits

								            sizeof(HOSTCLUT) + 2048;          // data structure + other PS stuff


								        //

								        // Add space for new line.

								        //


								        *pdwSize += (((*pdwSize) / MAX_LINELEN) + 1) * STRLEN(NewLine);


								        return TRUE;

								    }


								    pHostClut = (PHOSTCLUT)pBuffer;

								    pBuffer += sizeof(HOSTCLUT);

								    pHostClut->wSize = sizeof(HOSTCLUT);

								    pHostClut->wDataType = DATATYPE_LUT;

								    pHostClut->dwPCS = dwPCS;

								    pHostClut->dwIntent = dwIntent;

								    pHostClut->nLutBits = (dwLutSig == LUT8_TYPE) ? 8 : 16;


								    //

								    // Get info about Illuminant White Point from the header

								    //


								    (void)GetCPWhitePoint(pProfile, pHostClut->afxIlluminantWP);


								    pHostClut->nInputCh = (BYTE)nInputCh;

								    pHostClut->nOutputCh = (BYTE)nOutputCh;

								    pHostClut->nClutPoints = (BYTE)nGrids;

								    pHostClut->nInputEntries = (WORD)nInputTable;

								    pHostClut->nOutputEntries = (WORD)nOutputTable;


								    //

								    // Input Array

								    //


								    pBuffer += CreateHostInputOutputArray(pBuffer, pHostClut->inputArray,

								             nInputCh, nInputTable, 0, dwLutSig, (PBYTE)pLut);


								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        i = nInputTable * nInputCh +

								            nGrids * nGrids * nGrids * nGrids * nOutputCh;

								    }

								    else

								    {

								        i = nInputTable * nInputCh +

								            nGrids * nGrids * nGrids * nOutputCh;

								    }


								    //

								    // Output Array

								    //


								    pBuffer += CreateHostInputOutputArray(pBuffer, pHostClut->outputArray,

								             nOutputCh, nOutputTable, i, dwLutSig, (PBYTE)pLut);


								    //

								    // /Table

								    //


								    pHostClut->clut = pBuffer;

								    nNumbers = nGrids * nGrids * nOutputCh;

								    SecondGrids = 1;

								    if (dwType == TYPE_CIEBASEDDEFG)

								    {

								        SecondGrids = nGrids;

								    }


								    for (i=0; i<nGrids; i++)        // Nh strings should be sent

								    {

								        for (k=0; k<SecondGrids; k++)

								        {

								            if (dwLutSig == LUT8_TYPE)

								            {

								                pTable = (PBYTE) (((PLUT8TYPE)pLut)->data) +

								                    nInputTable * nInputCh +

								                    nNumbers * (i * SecondGrids + k);

								            }

								            else

								            {

								                pTable = (PBYTE) (((PLUT16TYPE)pLut)->data) +

								                    2 * nInputTable * nInputCh +

								                    2 * nNumbers * (i * SecondGrids + k);

								            }


								            if (dwLutSig == LUT8_TYPE)

								            {

								                CopyMemory(pBuffer, pTable, nNumbers);

								                pBuffer += nNumbers;

								            }

								            else

								            {

								                for (j=0; j<nNumbers; j++)

								                {

								                    *pBuffer++ = (BYTE)(FIX_ENDIAN16(*((PWORD)pTable)) / 256);

								                    pTable += sizeof(WORD);

								                }

								            }

								        }

								    }


								    *pdwSize = (DWORD) (pBuffer - pStart);


								    return TRUE;

								}


								/***************************************************************************

								*                            GetHostColorSpaceArray

								*  function:

								*    This is the main function which creates the Host CSA

								*    from the data supplied in the Profile.

								*  parameters:

								*       cp          --  Color Profile handle

								*       InputIntent --  Intent.

								*       lpBuffer    --  Pointer to the memory block. If this point is NULL,

								*                       require buffer size.

								*       lpcbSize    --  Size of the memory block

								*  returns:

								*       BOOL        --  TRUE if the function was successful,

								*                       FALSE otherwise.

								***************************************************************************/


								BOOL

								GetHostColorSpaceArray(

								    PBYTE  pProfile,

								    DWORD  dwIntent,

								    PBYTE  pBuffer,

								    PDWORD pdwSize

								    )

								{

								    DWORD dwDev;

								    BOOL bRc = FALSE;


								    dwDev = GetCPDevSpace(pProfile);


								    switch (dwDev)

								    {

								    case SPACE_RGB:

								        bRc = GetHostCSA(pProfile, pBuffer, pdwSize,

								                  dwIntent, TYPE_CIEBASEDDEF);

								        break;

								    case SPACE_CMYK:

								        bRc = GetHostCSA(pProfile, pBuffer, pdwSize,

								                  dwIntent, TYPE_CIEBASEDDEFG);

								        break;

								    default:

								        break;

								    }


								    return bRc;

								}


								/***************************************************************************

								*                         DoHostConversionCRD

								*  function:

								*    This function converts XYZ/Lab to RGB/CMYK by using HostCRD

								*  parameters:

								*       LPHOSTCLUT lpHostCRD  -- pointer to a HostCRD

								*       LPHOSTCLUT lpHostCSA  -- pointer to a HostCSA

								*       float far *Input      -- Input XYZ/Lab

								*       float far *Output     -- Output RGB/CMYK

								*  returns:

								*       BOOL                  -- TRUE

								***************************************************************************/


								BOOL

								DoHostConversionCRD(

								    PHOSTCLUT   pHostCRD,

								    PHOSTCLUT   pHostCSA,

								    float       *pfInput,

								    float       *pfOutput,

								    BOOL        bCheckOutputTable

								    )

								{

								    float      fTemp[MAXCHANNELS];

								    float      fTemp1[MAXCHANNELS];

								    DWORD      i, j;


								    //

								    // Input XYZ or Lab in range [0 2]

								    //

								    // When sampling the deviceCRD, skip the input table.

								    // If pHostCSA is not NULL, the current CRD is targetCRD, we

								    // need to do input table conversion

								    //


								    if (pHostCSA)

								    {

								        //

								        // Convert Lab to XYZ  in range [ 0 whitePoint ]

								        //


								        if ((pHostCRD->dwPCS == SPACE_XYZ) &&

								            (pHostCSA->dwPCS == SPACE_Lab))

								        {

								            LabToXYZ(pfInput, fTemp1, pHostCRD->afxIlluminantWP);

								        }

								        else if ((pHostCRD->dwPCS == SPACE_Lab) &&

								                 (pHostCSA->dwPCS == SPACE_XYZ))

								        {

								            //

								            // Convert XYZ to Lab in range [ 0 1]

								            //


								            XYZToLab(pfInput, fTemp, pHostCSA->afxIlluminantWP);

								        }

								        else if ((pHostCRD->dwPCS == SPACE_Lab) &&

								                 (pHostCSA->dwPCS == SPACE_Lab))

								        {

								            //

								            // Convert Lab to range [ 0 1]

								            //


								            for (i=0; i<3; i++)

								                fTemp[i] = pfInput[i] / 2;

								        }

								        else

								        {

								            //

								            // Convert XYZ to XYZ (based on white point) to range [0 1]

								            //

								            //       different intents using different conversion.

								            //       icRelativeColorimetric: using Bradford transform.

								            //       icAbsoluteColorimetric: using scaling.

								            //


								            for (i=0; i<3; i++)

								                fTemp1[i] = (pfInput[i] * pHostCRD->afxIlluminantWP[i]) / pHostCSA->afxIlluminantWP[i];

								        }


								        //

								        // Matrix, used for XYZ data only.

								        //


								        if (pHostCRD->dwPCS == SPACE_XYZ)

								        {

								            ApplyMatrix(pHostCRD->e, fTemp1, fTemp);

								        }


								        if (pHostCRD->wDataType != DATATYPE_MATRIX)

								        {

								            //

								            // Search input Table

								            //


								            (void)CheckInputOutputTable(pHostCRD, fTemp, FALSE, TRUE);

								        }

								    }


								    //

								    // If the current CRD is device CRD, we do not need to do input

								    // table conversion

								    //


								    else

								    {

								        WORD nGrids;


								        nGrids = pHostCRD->nClutPoints;


								        //

								        // Sample data may be XYZ or Lab. It depends on Target icc profile.

								        // If the PCS of the target icc profile is XYZ, input data will be XYZ.

								        // If the PCS of the target icc profile is Lab, input data will be Lab.

								        //


								        if (pHostCRD->wDataType == DATATYPE_MATRIX)

								        {

								            for (i = 0; i < 3; i++)

								            {

								                fTemp[i] = pfInput[i];

								            }

								        }

								        else

								        {

								            for (i=0; i<3; i++)

								            {

								                fTemp[i] = pfInput[i] * (nGrids - 1);

								                if (fTemp[i] > (nGrids - 1))

								                    fTemp[i] = (float)(nGrids - 1);

								            }

								        }

								    }


								    if (pHostCRD->wDataType != DATATYPE_MATRIX)

								    {

								        //

								        // Rendering table

								        //


								        (void)CheckColorLookupTable(pHostCRD, fTemp);

								    }


								    //

								    // Output RGB or CMYK in range [0 1]

								    //


								    if (bCheckOutputTable)

								    {

								        (void)CheckInputOutputTable(pHostCRD, fTemp, FALSE, FALSE);

								    }


								    for (i=0; (i<=MAXCHANNELS) && (i<pHostCRD->nOutputCh); i++)

								    {

								        pfOutput[i] = fTemp[i];

								    }


								    return TRUE;

								}


								/***************************************************************************

								*                         DoHostConversionCSA

								*  function:

								*    This function converts RGB/CMYK to XYZ/Lab by using HostCSA

								*  parameters:

								*       LPHOSTCLUT lpHostCLUT -- pointer to a HostCSA

								*       float far *Input      -- Input XYZ/Lab

								*       float far *Output     -- Output RGB/CMYK

								*  returns:

								*       BOOL                  -- TRUE

								***************************************************************************/


								BOOL

								DoHostConversionCSA(

								    PHOSTCLUT     pHostClut,

								    float         *pfInput,

								    float         *pfOutput

								    )

								{

								    float      fTemp[MAXCHANNELS];

								    DWORD      i;


								    //

								    // Input RGB or CMYK in range [0 1]

								    //


								    for (i=0; (i<=MAXCHANNELS) && (i<pHostClut->nInputCh); i++)

								    {

								        fTemp[i] = pfInput[i];

								    }


								    //

								    // Search input Table

								    //


								    (void)CheckInputOutputTable(pHostClut, fTemp, TRUE, TRUE);


								    if (pHostClut->wDataType == DATATYPE_MATRIX)

								    {

								        ApplyMatrix(pHostClut->e, fTemp, pfOutput);

								    }

								    else

								    {

								        //

								        // Rendering table

								        //


								        (void)CheckColorLookupTable(pHostClut, fTemp);


								        //

								        // Output Table

								        //


								        (void)CheckInputOutputTable(pHostClut, fTemp, TRUE, FALSE);


								        //

								        // Output XYZ or Lab in range [0 2]

								        //


								        for (i=0; (i<=MAXCHANNELS) && (i<pHostClut->nOutputCh); i++)

								        {

								            pfOutput[i] = fTemp[i];

								        }

								    }


								    return TRUE;

								}


								/***************************************************************************

								*                         CheckInputOutputTable

								*  function:

								*    This function check inputTable.

								*  parameters:

								*       LPHOSTCLUT lpHostClut --

								*       float far  *fTemp     --  Input / output data

								*  returns:

								*       BOOL                  -- TRUE

								***************************************************************************/


								BOOL

								CheckInputOutputTable(

								    PHOSTCLUT    pHostClut,

								    float        *pfTemp,

								    BOOL         bCSA,

								    BOOL         bInputTable

								    )

								{

								    PBYTE      *ppArray;

								    float      fIndex;

								    DWORD      nNumCh;

								    DWORD      nNumEntries, i;

								    WORD       nGrids;

								    WORD       floor1, ceiling1;


								    if (bInputTable)

								    {

								        nNumCh = pHostClut->nInputCh;

								        nNumEntries = pHostClut->nInputEntries - 1;

								        ppArray = pHostClut->inputArray;

								    }

								    else

								    {

								        nNumCh = pHostClut->nOutputCh;

								        nNumEntries = pHostClut->nOutputEntries - 1;

								        ppArray = pHostClut->outputArray;

								    }


								    nGrids = pHostClut->nClutPoints;

								    for (i=0; (i<=MAXCHANNELS) && (i<nNumCh); i++)

								    {

								        pfTemp[i] = (pfTemp[i] < 0) ? 0 : ((pfTemp[i] > 1) ? 1 : pfTemp[i]);


								        fIndex = pfTemp[i] * nNumEntries;


								        if (pHostClut->nLutBits == 8)

								        {

								            floor1 = ppArray[i][(DWORD)fIndex];

								            ceiling1 = ppArray[i][((DWORD)fIndex) + 1];


								            pfTemp[i] = (float)(floor1 + (ceiling1 - floor1) * (fIndex - floor(fIndex)));


								            if (bCSA && !bInputTable)

								                pfTemp[i] = pfTemp[i] / 127.0f;

								            else

								                pfTemp[i] = pfTemp[i] / 255.0f;

								        }

								        else

								        {

								            floor1 = ((PWORD)(ppArray[i]))[(DWORD)fIndex];

								            ceiling1 = ((PWORD)(ppArray[i]))[((DWORD)fIndex) + 1];


								            pfTemp[i] = (float)(floor1 + (ceiling1 - floor1) * (fIndex - floor(fIndex)));


								            if (bCSA && !bInputTable)

								                pfTemp[i] = pfTemp[i] / 32767.0f;

								            else

								                pfTemp[i] = pfTemp[i] / 65535.0f;


								        }


								        if (bInputTable)

								        {

								            pfTemp[i] *= (nGrids - 1);

								            if (pfTemp[i] > (nGrids - 1))

								                pfTemp[i] =  (float)(nGrids - 1);

								        }

								    }


								    return TRUE;

								}


								/***************************************************************************

								*                               g

								*  function:

								*    Calculate function y = g(x). used in Lab->XYZ conversion

								*    y = g(x):      g(x) = x*x*x             if x >= 6/29

								*                   g(x) = 108/841*(x-4/29)  otherwise

								*  parameters:

								*       f           --  x

								*  returns:

								*       SINT        --  y

								***************************************************************************/


								float g(

								    float f

								    )

								{

								    float fRc;


								    if (f >= (6.0f/29.0f))

								    {

								        fRc = f * f * f;

								    }

								    else

								    {

								        fRc = f - (4.0f / 29.0f) * (108.0f / 841.0f);

								    }


								    return fRc;

								}


								/***************************************************************************

								*                          inverse_g

								*  function:

								*    Calculate inverse function y = g(x). used in XYZ->Lab conversion

								*  parameters:

								*       f           --  y

								*  returns:

								*       SINT        --  x

								***************************************************************************/


								float

								inverse_g(

								    float f

								    )

								{

								    double fRc;


								    if (f >= (6.0f*6.0f*6.0f)/(29.0f*29.0f*29.0f))

								    {

								        fRc = pow(f, 1.0 / 3.0);

								    }

								    else

								    {

								        fRc = f * (841.0f / 108.0f) + (4.0f / 29.0f);

								    }


								    return (float)fRc;

								}


								void

								LabToXYZ(

								    float      *pfInput,

								    float      *pfOutput,

								    PFIX_16_16 pafxWP

								    )

								{

								    float   fL, fa, fb;


								    fL = (pfInput[0] * 50 + 16) / 116;

								    fa = (pfInput[1] * 128 - 128) / 500;

								    fb = (pfInput[2] * 128 - 128) / 200;


								    pfOutput[0] = pafxWP[0] * g(fL + fa) / FIX_16_16_SCALE;

								    pfOutput[1] = pafxWP[1] * g(fL) / FIX_16_16_SCALE;

								    pfOutput[2] = pafxWP[2] * g(fL - fb) / FIX_16_16_SCALE;


								    return;

								}


								void

								XYZToLab(

								    float      *pfInput,

								    float      *pfOutput,

								    PFIX_16_16 pafxWP

								    )

								{

								    float  fL, fa, fb;


								    fL = inverse_g(pfInput[0] * FIX_16_16_SCALE / pafxWP[0]);

								    fa = inverse_g(pfInput[1] * FIX_16_16_SCALE / pafxWP[1]);

								    fb = inverse_g(pfInput[2] * FIX_16_16_SCALE / pafxWP[2]);


								    pfOutput[0] = (fa * 116 - 16) / 100;

								    pfOutput[1] = (fL * 500 - fa * 500 + 128) / 255;

								    pfOutput[2] = (fa * 200 - fb * 200 + 128) / 255;


								    return;

								}


								BOOL

								TableInterp3(

								    PHOSTCLUT  pHostClut,

								    float      *pfTemp

								    )

								{


								    PBYTE        v000, v001, v010, v011;

								    PBYTE        v100, v101, v110, v111;

								    float        fA, fB, fC;

								    float        fVx0x, fVx1x;

								    float        fV0xx, fV1xx;

								    DWORD        tmpA, tmpBC;

								    DWORD        cellA, cellB, cellC;

								    DWORD        idx;

								    WORD         nGrids;

								    WORD         nOutputCh;


								    cellA = (DWORD)pfTemp[0];

								    fA = pfTemp[0] - cellA;


								    cellB = (DWORD)pfTemp[1];

								    fB = pfTemp[1] - cellB;


								    cellC = (DWORD)pfTemp[2];

								    fC = pfTemp[2] - cellC;


								    nGrids = pHostClut->nClutPoints;

								    nOutputCh = pHostClut->nOutputCh;

								    tmpA  = nOutputCh * nGrids * nGrids;

								    tmpBC = nOutputCh * (nGrids * cellB + cellC);


								    //

								    // Calculate 8 surrounding cells.

								    //


								    v000 = pHostClut->clut + tmpA * cellA + tmpBC;

								    v001 = (cellC < (DWORD)(nGrids - 1)) ? v000 + nOutputCh : v000;

								    v010 = (cellB < (DWORD)(nGrids - 1)) ? v000 + nOutputCh * nGrids : v000;

								    v011 = (cellC < (DWORD)(nGrids - 1)) ? v010 + nOutputCh : v010 ;


								    v100 = (cellA < (DWORD)(nGrids - 1)) ? v000 + tmpA : v000;

								    v101 = (cellC < (DWORD)(nGrids - 1)) ? v100 + nOutputCh : v100;

								    v110 = (cellB < (DWORD)(nGrids - 1)) ? v100 + nOutputCh * nGrids : v100;

								    v111 = (cellC < (DWORD)(nGrids - 1)) ? v110 + nOutputCh : v110;


								    for (idx=0; idx<nOutputCh; idx++)

								    {

								        //

								        // Calculate the average of 4 bottom cells.

								        //


								        fVx0x = *v000 + fC * (int)((int)*v001 - (int)*v000);

								        fVx1x = *v010 + fC * (int)((int)*v011 - (int)*v010);

								        fV0xx = fVx0x + fB * (fVx1x - fVx0x);


								        //

								        // Calculate the average of 4 upper cells.

								        //


								        fVx0x = *v100 + fC * (int)((int)*v101 - (int)*v100);

								        fVx1x = *v110 + fC * (int)((int)*v111 - (int)*v110);

								        fV1xx = fVx0x + fB * (fVx1x - fVx0x);


								        //

								        // Calculate the bottom and upper average.

								        //


								        pfTemp[idx] = (fV0xx + fA * (fV1xx - fV0xx)) / MAXCOLOR8;


								        if ( idx < (DWORD)(nOutputCh - 1))

								        {

								            v000++;

								            v001++;

								            v010++;

								            v011++;

								            v100++;

								            v101++;

								            v110++;

								            v111++;

								        }

								    }


								    return TRUE;

								}


								BOOL

								TableInterp4(

								    PHOSTCLUT  pHostClut,

								    float      *pfTemp

								    )

								{

								    PBYTE     v0000, v0001, v0010, v0011;

								    PBYTE     v0100, v0101, v0110, v0111;

								    PBYTE     v1000, v1001, v1010, v1011;

								    PBYTE     v1100, v1101, v1110, v1111;

								    float     fH, fI, fJ, fK;

								    float     fVxx0x, fVxx1x;

								    float     fVx0xx, fVx1xx;

								    float     fV0xxx, fV1xxx;

								    DWORD     tmpH, tmpI, tmpJK;

								    DWORD     cellH, cellI, cellJ, cellK;

								    DWORD     idx;

								    WORD      nGrids;

								    WORD      nOutputCh;


								    cellH = (DWORD)pfTemp[0];

								    fH = pfTemp[0] - cellH;


								    cellI = (DWORD)pfTemp[1];

								    fI = pfTemp[1] - cellI;


								    cellJ = (DWORD)pfTemp[2];

								    fJ = pfTemp[2] - cellJ;


								    cellK = (DWORD)pfTemp[3];

								    fK = pfTemp[3] - cellK;


								    nGrids = pHostClut->nClutPoints;

								    nOutputCh = pHostClut->nOutputCh;

								    tmpI  = nOutputCh * nGrids * nGrids;

								    tmpH  = tmpI * nGrids;

								    tmpJK = nOutputCh * (nGrids * cellJ + cellK);


								    //

								    // Calculate 16 surrounding cells.

								    //


								    v0000 = pHostClut->clut + tmpH * cellH + tmpI * cellI + tmpJK;

								    v0001 = (cellK < (DWORD)(nGrids - 1))? v0000 + nOutputCh : v0000;

								    v0010 = (cellJ < (DWORD)(nGrids - 1))? v0000 + nOutputCh * nGrids : v0000;

								    v0011 = (cellK < (DWORD)(nGrids - 1))? v0010 + nOutputCh : v0010;


								    v0100 = (cellI < (DWORD)(nGrids - 1))? v0000 + tmpI : v0000;

								    v0101 = (cellK < (DWORD)(nGrids - 1))? v0100 + nOutputCh : v0100;

								    v0110 = (cellJ < (DWORD)(nGrids - 1))? v0100 + nOutputCh * nGrids : v0100;

								    v0111 = (cellK < (DWORD)(nGrids - 1))? v0110 + nOutputCh : v0110;


								    v1000 = (cellH < (DWORD)(nGrids - 1))? v0000 + tmpH : v0000;

								    v1001 = (cellK < (DWORD)(nGrids - 1))? v1000 + nOutputCh : v1000;

								    v1010 = (cellJ < (DWORD)(nGrids - 1))? v1000 + nOutputCh * nGrids : v1000;

								    v1011 = (cellK < (DWORD)(nGrids - 1))? v1010 + nOutputCh : v1010;


								    v1100 = (cellI < (DWORD)(nGrids - 1))? v1000 + tmpI : v1000;

								    v1101 = (cellK < (DWORD)(nGrids - 1))? v1100 + nOutputCh : v1100;

								    v1110 = (cellJ < (DWORD)(nGrids - 1))? v1100 + nOutputCh * nGrids : v1100;

								    v1111 = (cellK < (DWORD)(nGrids - 1))? v1110 + nOutputCh : v1110;


								    for (idx=0; idx<nOutputCh; idx++)

								    {

								        //

								        // Calculate the average of 8 bottom cells.

								        //


								        fVxx0x = *v0000 + fK * (int)((int)*v0001 - (int)*v0000);

								        fVxx1x = *v0010 + fK * (int)((int)*v0011 - (int)*v0010);

								        fVx0xx = fVxx0x + fJ * (fVxx1x - fVxx0x);

								        fVxx0x = *v0100 + fK * (int)((int)*v0101 - (int)*v0100);

								        fVxx1x = *v0110 + fK * (int)((int)*v0111 - (int)*v0110);

								        fVx1xx = fVxx0x + fJ * (fVxx1x - fVxx0x);

								        fV0xxx = fVx0xx + fI * (fVx1xx - fVx0xx);


								        //

								        // Calculate the average of 8 upper cells.

								        //


								        fVxx0x = *v1000 + fK * (int)((int)*v1001 - (int)*v1000);

								        fVxx1x = *v1010 + fK * (int)((int)*v1011 - (int)*v1010);

								        fVx0xx = fVxx0x + fJ * (fVxx1x - fVxx0x);

								        fVxx0x = *v1100 + fK * (int)((int)*v1101 - (int)*v1100);

								        fVxx1x = *v1110 + fK * (int)((int)*v1111 - (int)*v1110);

								        fVx1xx = fVxx0x + fJ * (fVxx1x - fVxx0x);

								        fV1xxx = fVx0xx + fI * (fVx1xx - fVx0xx);


								        //

								        // Calculate the bottom and upper average.

								        //


								        pfTemp[idx] = (fV0xxx + fH * (fV1xxx - fV0xxx)) / MAXCOLOR8;


								        if (idx < (DWORD)(nOutputCh - 1))

								        {

								            v0000++;

								            v0001++;

								            v0010++;

								            v0011++;

								            v0100++;

								            v0101++;

								            v0110++;

								            v0111++;

								            v1000++;

								            v1001++;

								            v1010++;

								            v1011++;

								            v1100++;

								            v1101++;

								            v1110++;

								            v1111++;

								        }

								    }


								    return TRUE;

								}


								BOOL

								InvertColorantArray(

								    double *lpInMatrix,

								    double *lpOutMatrix)

								{

								    double det;


								    double *a;

								    double *b;

								    double *c;


								    a = &(lpInMatrix[0]);

								    b = &(lpInMatrix[3]);

								    c = &(lpInMatrix[6]);


								    det = a[0] * b[1] * c[2] + a[1] * b[2] * c[0] + a[2] * b[0] * c[1] -

								         (a[2] * b[1] * c[0] + a[1] * b[0] * c[2] + a[0] * b[2] * c[1]);


								    if (det == 0.0)    // What to do?

								    {

								        lpOutMatrix[0] = 1.0;

								        lpOutMatrix[1] = 0.0;

								        lpOutMatrix[2] = 0.0;


								        lpOutMatrix[3] = 0.0;

								        lpOutMatrix[4] = 1.0;

								        lpOutMatrix[5] = 0.0;


								        lpOutMatrix[6] = 0.0;

								        lpOutMatrix[7] = 0.0;

								        lpOutMatrix[8] = 1.0;

								    }

								    else

								    {

								        lpOutMatrix[0] = (b[1] * c[2] - b[2] * c[1]) / det;

								        lpOutMatrix[3] = -(b[0] * c[2] - b[2] * c[0]) / det;

								        lpOutMatrix[6] = (b[0] * c[1] - b[1] * c[0]) / det;


								        lpOutMatrix[1] = -(a[1] * c[2] - a[2] * c[1]) / det;

								        lpOutMatrix[4] = (a[0] * c[2] - a[2] * c[0]) / det;

								        lpOutMatrix[7] = -(a[0] * c[1] - a[1] * c[0]) / det;


								        lpOutMatrix[2] = (a[1] * b[2] - a[2] * b[1]) / det;

								        lpOutMatrix[5] = -(a[0] * b[2] - a[2] * b[0]) / det;

								        lpOutMatrix[8] = (a[0] * b[1] - a[1] * b[0]) / det;

								    }


								    return (TRUE);

								}


								VOID

								ApplyMatrix(

								    FIX_16_16 *e,

								    float *Input,

								    float *Output)

								{

								    DWORD i, j;


								    for (i=0; i<3; i++)

								    {

								        j = i * 3;


								        Output[i] = ((e[j]     * Input[0]) / FIX_16_16_SCALE) +

								                    ((e[j + 1] * Input[1]) / FIX_16_16_SCALE) +

								                    ((e[j + 2] * Input[2]) / FIX_16_16_SCALE);

								    }

								}


								/***************************************************************************

								*                         CheckColorLookupTable

								*  function:

								*    This function check RenderTable.

								*  parameters:

								*       LPHOSTCLUT lpHostClut --

								*       float far  *fTemp     --  Input (in range [0 gred-1]) /

								*                                 output(in range [0 1)

								*  returns:

								*       BOOL                  -- TRUE

								***************************************************************************/


								BOOL

								CheckColorLookupTable(

								    PHOSTCLUT   pHostClut,

								    float       *pfTemp

								    )

								{

								    if (pHostClut->nInputCh == 3)

								    {

								        return TableInterp3(pHostClut, pfTemp);

								    }

								    else if (pHostClut->nInputCh == 4)

								    {

								        return TableInterp4(pHostClut, pfTemp);

								    }

								    else

								        return FALSE;

								}


								//

								// For testing purposes

								//


								BOOL WINAPI

								GetPS2PreviewCRD (

								    HPROFILE  hDestProfile,

								    HPROFILE  hTargetProfile,

								    DWORD     dwIntent,

								    PBYTE     pBuffer,

								    PDWORD    pcbSize,

								    LPBOOL    pbBinary

								    )

								{

								    PPROFOBJ pDestProfObj;

								    PPROFOBJ pTargetProfObj;


								    pDestProfObj = (PPROFOBJ)HDLTOPTR(hDestProfile);

								    pTargetProfObj = (PPROFOBJ)HDLTOPTR(hTargetProfile);


								    return InternalGetPS2PreviewCRD(pDestProfObj->pView, pTargetProfObj->pView, dwIntent, pBuffer, pcbSize, pbBinary);

								}


								#endif // !defined(KERNEL_MODE) || defined(USERMODE_DRIVER)


								/*

								 *  Crc - 32 BIT ANSI X3.66 CRC checksum files

								 *

								 *

								 * Copyright (C) 1986 Gary S. Brown.  You may use this program, or

								 * code or tables extracted from it, as desired without restriction.

								 */


								static DWORD  crc_32_tab[] = { /* CRC polynomial 0xedb88320 */

								0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,

								0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,

								0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,

								0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,

								0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,

								0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,

								0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,

								0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,

								0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,

								0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,

								0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,

								0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,

								0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,

								0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,

								0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,

								0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,

								0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,

								0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,

								0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,

								0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,

								0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,

								0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,

								0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,

								0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,

								0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,

								0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,

								0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,

								0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,

								0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,

								0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,

								0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,

								0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d

								};


								DWORD crc32(PBYTE buff, DWORD length)

								{

								    DWORD crc, charcnt;

								    BYTE  c;


								    crc = 0xFFFFFFFF;

								    charcnt = 0;


								    for (charcnt = 0 ; charcnt < length ; charcnt++)

								    {

								        c = buff[charcnt];

								        crc = crc_32_tab[(crc ^ c) & 0xff] ^ (crc >> 8);

								    }


								    return crc;

								}


								/***************************************************************************

								*                           IsSRGBColorProfile

								*

								*  function: check if the profile is sRGB

								*

								*  parameters:

								*       cp          --  Color Profile handle

								*

								*  returns:

								*       BOOL        --  TRUE if the profile is sRGB

								*                       FALSE otherwise.

								***************************************************************************/


								BOOL IsSRGBColorProfile(

								    PBYTE pProfile

								    )

								{

								    BOOL  bMatch = FALSE;

								    DWORD dwRedTRCIndex, dwGreenTRCIndex, dwBlueTRCIndex;

								    DWORD dwRedCIndex, dwGreenCIndex, dwBlueCIndex;

								    DWORD dwSize;

								    DWORD dwRedTRCSize=0, dwGreenTRCSize=0, dwBlueTRCSize=0;

								    DWORD dwRedCSize=0, dwGreenCSize=0, dwBlueCSize=0;

								    PBYTE pRed, pGreen, pBlue, pRedC, pGreenC, pBlueC;

								    BYTE  DataBuffer[ALIGN_DWORD(sRGB_TAGSIZE)];


								    if (DoesCPTagExist(pProfile, TAG_REDTRC, &dwRedTRCIndex)             &&

								        GetCPElementDataSize(pProfile, dwRedTRCIndex, &dwRedTRCSize)     &&


								        DoesCPTagExist(pProfile, TAG_GREENTRC, &dwGreenTRCIndex)         &&

								        GetCPElementDataSize(pProfile, dwGreenTRCIndex, &dwGreenTRCSize) &&


								        DoesCPTagExist(pProfile, TAG_BLUETRC, &dwBlueTRCIndex)           &&

								        GetCPElementDataSize(pProfile, dwBlueTRCIndex, &dwBlueTRCSize)   &&


								        DoesCPTagExist(pProfile, TAG_REDCOLORANT, &dwRedCIndex)          &&

								        GetCPElementDataSize(pProfile, dwRedCIndex, &dwRedCSize)         &&


								        DoesCPTagExist(pProfile, TAG_GREENCOLORANT, &dwGreenCIndex)      &&

								        GetCPElementDataSize(pProfile, dwGreenCIndex, &dwGreenCSize)     &&


								        DoesCPTagExist(pProfile, TAG_BLUECOLORANT, &dwBlueCIndex)        &&

								        GetCPElementDataSize(pProfile, dwBlueCIndex, &dwBlueCSize))

								    {

								        dwSize = dwRedTRCSize + dwGreenTRCSize + dwBlueTRCSize +

								                 dwRedCSize   + dwGreenCSize   + dwBlueCSize;


								        if (dwSize == sRGB_TAGSIZE)

								        {

								            ZeroMemory(DataBuffer,sizeof(DataBuffer));


								            pRed    = DataBuffer;

								            pGreen  = pRed    + dwRedTRCSize;

								            pBlue   = pGreen  + dwGreenTRCSize;

								            pRedC   = pBlue   + dwBlueTRCSize;

								            pGreenC = pRedC   + dwRedCSize;

								            pBlueC  = pGreenC + dwGreenCSize;


								            if (GetCPElementData(pProfile, dwRedTRCIndex, pRed, &dwRedTRCSize)       &&

								                GetCPElementData(pProfile, dwGreenTRCIndex, pGreen, &dwGreenTRCSize) &&

								                GetCPElementData(pProfile, dwBlueTRCIndex, pBlue, &dwBlueTRCSize)    &&

								                GetCPElementData(pProfile, dwRedCIndex, pRedC, &dwRedCSize)          &&

								                GetCPElementData(pProfile, dwGreenCIndex, pGreenC, &dwGreenCSize)    &&

								                GetCPElementData(pProfile, dwBlueCIndex, pBlueC, &dwBlueCSize))

								            {

								                bMatch = (crc32(DataBuffer, sRGB_TAGSIZE) == sRGB_CRC);

								            }

								        }

								    }


								    return (bMatch);

								}