getcsa.c

Go to the documentation of this file.

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

#pragma code_seg(_ICMSEG)

static char  *DecodeABCLab[] = {"50 mul 16 add 116 div ", 
                               "128 mul 128 sub 500 div", 
                               "128 mul 128 sub 200 div"};

#pragma optimize("",off)

BOOL IsSRGB( CHANDLE cp );

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

SINT CreateColSpArray (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary);
SINT CreateColSpProc (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary);
SINT CreateFloatString (CHANDLE cp, MEMPTR lpMem, CSIG CPTag);
static SINT SendCSABWPoint(MEMPTR lpMem, CSIG Intent, 
    LPSFLOAT IlluminantWP, LPSFLOAT MediaWP);
static void GetMediaWP(CHANDLE cp, CSIG InputIntent, 
    LPSFLOAT IlluminantWP, LPSFLOAT MediaWP);

/***************************************************************************
*                           GetDevideRGB
*  function:
*    this is the function which creates the DeviceRGB ColorSpace (CS)
*  prototype:
*       BOOL EXTERN GetDeviceRGB(
*                          MEMPTR       lpMem,
*                          BOOL         AllowBinary)
*  parameters:
*       lpMem       --  Pointer to the memory block
*       AllowBinary --  1: binary CS allowed,  0: only ascii CS allowed.
*  returns:
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/
static BOOL
GetDeviceRGB (
              MEMPTR lpMem,
              LPDWORD lpcbSize,
              DWORD InpDrvClrSp,
              BOOL  BackupCSA)
{
    MEMPTR lpOldMem = lpMem;
    if ((InpDrvClrSp != icSigRgbData) &&
        (InpDrvClrSp != icSigDefData) &&
        (InpDrvClrSp != 0))
        return FALSE;

    if (lpMem == NULL)
    {
        *lpcbSize = lstrlen (DeviceRGBTag) + 8;
        return (TRUE);
    }

    if (BackupCSA)
    {
        lpMem += WriteNewLineObject (lpMem, NotSupportDEFG_S);
    }

    lpMem += WriteNewLineObject (lpMem, DeviceRGBTag);

    if (BackupCSA)
    {
        lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
    }

    *lpcbSize = (DWORD) (lpMem - lpOldMem);
    return (TRUE);
}
/***************************************************************************
*                           GetDevideCMYK
*  function:
*    this is the function which creates the DeviceCMYK ColorSpace (CS)
*  prototype:
*       BOOL EXTERN GetDeviceCMYK(
*                          MEMPTR       lpMem,
*                          BOOL         AllowBinary)
*  parameters:
*       lpMem       --  Pointer to the memory block
*       AllowBinary --  1: binary CS allowed,  0: only ascii CS allowed.
*  returns:
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/

static BOOL
GetDeviceCMYK (
               MEMPTR lpMem,
               LPDWORD lpcbSize,
               DWORD InpDrvClrSp)
{
    MEMPTR lpOldMem = lpMem;
    if ((InpDrvClrSp != icSigCmykData) &&
        (InpDrvClrSp != 0))
        return FALSE;
    if (lpMem == NULL)
    {
        *lpcbSize = lstrlen (DeviceCMYKTag) + 8;
        return (TRUE);
    }
    lpMem += WriteNewLineObject (lpMem, DeviceCMYKTag);

    *lpcbSize = (DWORD) (lpMem - lpOldMem);
    return (TRUE);

}
/***************************************************************************
*                           GetDeviceGray
***************************************************************************/

static BOOL
GetDeviceGray (
               MEMPTR lpMem,
               LPDWORD lpcbSize,
               DWORD InpDrvClrSp)
{
    MEMPTR lpOldMem = lpMem;
    if ((InpDrvClrSp == icSigRgbData) ||
        (InpDrvClrSp == icSigDefData) ||
        (InpDrvClrSp == 0))
    {
        if (lpMem == NULL)
        {
            *lpcbSize = lstrlen (DeviceRGBTag) + 8;
            return (TRUE);
        }
        lpMem += WriteNewLineObject (lpMem, DeviceRGBTag);

        *lpcbSize = (DWORD) (lpMem - lpOldMem);
        return (TRUE);
    } else if (InpDrvClrSp == icSigGrayData)
    {
        if (lpMem == NULL)
        {
            *lpcbSize = lstrlen (DeviceGrayTag) + 8;
            return (TRUE);
        }
        lpMem += WriteNewLineObject (lpMem, DeviceGrayTag);

        *lpcbSize = (DWORD) (lpMem - lpOldMem);
        return (TRUE);
    }
}
/***************************************************************************
*                           GetPublicArrayName
***************************************************************************/

SINT
GetPublicArrayName (CHANDLE cp, CSIG IntentSig, MEMPTR PublicArrayName)
{
    MEMPTR OldPtr;
    OldPtr = PublicArrayName;
    PublicArrayName[0] = 0;
    MemCopy (PublicArrayName, (MEMPTR) & IntentSig, sizeof (CSIG));
    PublicArrayName += sizeof (CSIG);
    PublicArrayName[0] = 0;
    return (PublicArrayName - OldPtr);
}

static SINT SendCSABWPoint(MEMPTR lpMem, CSIG Intent, 
                    LPSFLOAT IlluminantWP, LPSFLOAT MediaWP)
{
    SINT   i;
    MEMPTR lpOldMem = lpMem;

 //********** /BlackPoint
    lpMem += WriteNewLineObject (lpMem, BlackPointTag);
    lpMem += WriteObject (lpMem, BlackPoint);

 //********** /WhitePoint
    lpMem += WriteNewLineObject (lpMem, WhitePointTag);
    lpMem += WriteObject (lpMem, BeginArray);
    for (i = 0; i < 3; i++)
    {
        if (Intent == icAbsoluteColorimetric)
        {
            lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
        }
        else
        {
            lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
        }
    }
    lpMem += WriteObject (lpMem, EndArray);
    return (SINT)(lpMem - lpOldMem);
}

static void GetMediaWP(CHANDLE cp, CSIG InputIntent, 
                       LPSFLOAT IlluminantWP, LPSFLOAT MediaWP)
{
    if (InputIntent == icAbsoluteColorimetric)
    {
        if (!GetCPMediaWhitePoint (cp, (LPSFLOAT) & MediaWP)) // .. Media WhitePoint
        {
            MediaWP[0] = IlluminantWP[0];
            MediaWP[1] = IlluminantWP[1];
            MediaWP[2] = IlluminantWP[2];
        }
    }
}

SINT  BeginGlobalDict(MEMPTR lpMem)
{
    MEMPTR lpOldMem = lpMem;

    lpMem += WriteNewLineObject (lpMem, GlobalDictOp);
    lpMem += WriteObject (lpMem, BeginOp);

    return (lpMem - lpOldMem);
}

SINT  EndGlobalDict(MEMPTR lpMem)
{
    MEMPTR lpOldMem = lpMem;

    lpMem += WriteNewLineObject (lpMem, EndOp);
    lpMem += WriteObject (lpMem, SetGlobalOp);

    return (lpMem - lpOldMem);
}

SINT  EnableGlobalDict(MEMPTR lpMem)
{
    MEMPTR lpOldMem = lpMem;

    lpMem += WriteNewLineObject (lpMem, CurrentGlobalOp);
    lpMem += WriteObject (lpMem, TrueOp);
    lpMem += WriteObject (lpMem, SetGlobalOp);
    return (lpMem - lpOldMem);
}

/***************************************************************************
*                           GetPS2CSA_DEFG
*  function:
*    this is the function which creates the CIEBasedDEF(G) ColorSpace (CS)
*    from the data supplied in the RGB or CMYK Input Profile.
*  prototype:
*       GetPS2CSA_DEFG(
*                       CHANDLE     cp,
*                       MEMPTR      lpMem,
*                       LPDWORD     lpcbSize,
*                       int         Type
*                       BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpMem       --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       Type        --  CieBasedDEF or CieBasedDEFG.
*       AllowBinary --  1: binary CSA allowed,  0: only ascii CSA allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/
static BOOL
GetPS2CSA_DEFG (
                CHANDLE cp,
                MEMPTR lpMem,
                LPDWORD lpcbSize,
                CSIG InputIntent,
                SINT Index,
                int Type,
                BOOL AllowBinary)
{
    CSIG PCS, LutTag;
    CSIG IntentSig;
    SFLOAT IlluminantWP[3];
    SFLOAT MediaWP[3];
    SINT nInputCh, nOutputCh, nGrids, SecondGrids;
    SINT nInputTable, nOutputTable, nNumbers;
    SINT i, j, k;
    MEMPTR lpTable;
    MEMPTR lpOldMem = lpMem;
    MEMPTR lpLut = NULL;
    MEMPTR lpLineStart;
    HGLOBAL hLut = 0;
    SINT LutSize;
    char PublicArrayName[TempBfSize];
 // Check if we can generate the CS.
 // Required  tags are: red, green and blue Colorants.
 // As for TRC tags - we are quite flexible here - if we cannot find the
 // required tag - we assume the linear responce
    if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
        (PCS != icSigLabData) && (PCS != icSigXYZData) ||
        !GetCPTagSig (cp, Index, (LPCSIG) & IntentSig))
    {
        return (FALSE);
    }
    if (!GetCPElementType (cp, Index, (LPCSIG) & LutTag) ||
        ((LutTag != icSigLut8Type) && (LutTag != icSigLut16Type)) ||
        !GetCPElementSize (cp, Index, (LPSINT) & LutSize) ||
        !MemAlloc (LutSize, (HGLOBAL FAR *) &hLut, (LPMEMPTR) & lpLut) ||
        !GetCPElement (cp, Index, lpLut, LutSize))
    {
        if (0 != hLut)
        {
            MemFree (hLut);
        }
        return (FALSE);
    }
 // Estimate the memory size required to hold CS

    GetCLUTinfo(LutTag, lpLut, &nInputCh, &nOutputCh, 
        &nGrids, &nInputTable, &nOutputTable, &i);

 // Level 2 printers support only tri-component CIEBasedABC input,
 // but can have either 3 or 4 output channels.
    if (!(nOutputCh == 3) ||
        !((nInputCh == 3) && (Type == TYPE_CIEBASEDDEF)) &&
        !((nInputCh == 4) && (Type == TYPE_CIEBASEDDEFG)))
    {
        SetCPLastError (CP_POSTSCRIPT_ERR);
        MemFree (hLut);
        return (FALSE);
    }
    if (lpMem == NULL)                  // This is a size request
    {
        if (Type == TYPE_CIEBASEDDEFG)
            *lpcbSize = nOutputCh * nGrids * nGrids * nGrids * nGrids * 2;  // LUT HEX bytes
        else
            *lpcbSize = nOutputCh * nGrids * nGrids * nGrids * 2;   // LUT HEX bytes

        *lpcbSize = *lpcbSize +
            nInputCh * nInputTable * 6 +
            nOutputCh * nOutputTable * 6 +  // Number of INT bytes
            nInputCh * (lstrlen (IndexArray) +
                        lstrlen (StartClip) +
                        lstrlen (EndClip)) +
            nOutputCh * (lstrlen (IndexArray) +
                         lstrlen (StartClip) +
                         lstrlen (EndClip)) +
            4096;                       // + other PS stuff


        return (TRUE);
    }
 // Get info about Illuminant White Point from the header
    GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);          // .. Illuminant

 // Support absolute whitePoint
    GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);

 //*********** Testing CieBasedDEFG support
    lpMem += WriteNewLineObject (lpMem, TestingDEFG);

 //*********** Creating global data
    GetPublicArrayName (cp, IntentSig, PublicArrayName);
    if (Type == TYPE_CIEBASEDDEFG)
        lpMem += WriteNewLineObject (lpMem, CieBasedDEFGBegin);
    else
        lpMem += WriteNewLineObject (lpMem, CieBasedDEFBegin);

    lpMem += EnableGlobalDict(lpMem);
    lpMem += WriteNewLineObject (lpMem, SupportDEFG_S);
    lpMem += BeginGlobalDict(lpMem);

    lpMem += CreateInputArray (lpMem, nInputCh, nInputTable,
             (MEMPTR) PublicArrayName, LutTag, lpLut, AllowBinary, NULL);

    if (Type == TYPE_CIEBASEDDEFG)
    {
        i = nInputTable * nInputCh +
            nGrids * nGrids * nGrids * nGrids * nOutputCh;
    } else
    {
        i = nInputTable * nInputCh +
            nGrids * nGrids * nGrids * nOutputCh;
    }
    lpMem += CreateOutputArray (lpMem, nOutputCh, nOutputTable, i,
             (MEMPTR) PublicArrayName, LutTag, lpLut, AllowBinary, NULL);

    lpMem += WriteNewLineObject (lpMem, EndOp);
    lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
    lpMem += WriteNewLineObject (lpMem, SetGlobalOp);
    lpMem += WriteNewLineObject (lpMem, SupportDEFG_S);

 //*********** Start creating the ColorSpace
    lpMem += WriteNewLineObject (lpMem, BeginArray);   // Begin array

 //********** /CIEBasedDEF(G)
    if (Type == TYPE_CIEBASEDDEFG)
        lpMem += WriteObject (lpMem, CIEBasedDEFGTag);
    else
        lpMem += WriteObject (lpMem, CIEBasedDEFTag);
    lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary

 //********** Black/White Point
    lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);

 //********** /DecodeDEF(G)
    lpLineStart = lpMem;
    if (Type == TYPE_CIEBASEDDEFG)
        lpMem += WriteNewLineObject (lpMem, DecodeDEFGTag);
    else
        lpMem += WriteNewLineObject (lpMem, DecodeDEFTag);

    lpMem += WriteObject (lpMem, BeginArray);
    for (i = 0; i < nInputCh; i++)
    {
        lpLineStart = lpMem;

        lpMem += WriteNewLineObject (lpMem, BeginFunction);
#if 0
        if (PCS == icSigLabData)
        {
            lpMem += WriteObject (lpMem,
                                  (0 == i) ? EncodeABCLab1 : EncodeABCLab2);
        }
#endif
        lpMem += WriteObject (lpMem, StartClip);
        lpMem += WriteObject (lpMem, InputArray);
        lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName));
        lpMem += WriteInt (lpMem, i);

        if (!AllowBinary)               // Output ASCII
        {
            lpMem += WriteObject (lpMem, IndexArray);
        } else
        {                               // Output BINARY
            if (LutTag == icSigLut8Type)
            {
                lpMem += WriteObject (lpMem, IndexArray);
            } else
            {
                lpMem += WriteObject (lpMem, IndexArray16b);
            }
        }
        lpMem += WriteObject (lpMem, (LutTag == icSigLut8Type) ? Scale8 : Scale16);
        lpMem += WriteObject (lpMem, EndClip);
        lpMem += WriteObject (lpMem, EndFunction);
    }
    lpMem += WriteObject (lpMem, EndArray);

 //********** /Table
    lpMem += WriteNewLineObject (lpMem, TableTag);
    lpMem += WriteObject (lpMem, BeginArray);

    lpMem += WriteInt (lpMem, nGrids);  // Send down Nh
    lpMem += WriteInt (lpMem, nGrids);  // Send down Ni
    lpMem += WriteInt (lpMem, nGrids);  // Send down Nj
    nNumbers = nGrids * nGrids * nOutputCh;
    SecondGrids = 1;
    if (Type == TYPE_CIEBASEDDEFG)
    {
        lpMem += WriteInt (lpMem, nGrids);  // Send down Nk
//       nNumbers = nGrids * nGrids * nGrids * nOutputCh ;
        SecondGrids = nGrids;
    }
    lpMem += WriteNewLineObject (lpMem, BeginArray);
    for (i = 0; i < nGrids; i++)        // Nh strings should be sent
    {
        if (Type == TYPE_CIEBASEDDEFG)
        {
            lpMem += WriteNewLineObject (lpMem, BeginArray);
        }
        for (k = 0; k < SecondGrids; k++)
        {
            lpLineStart = lpMem;
            lpMem += WriteObject (lpMem, NewLine);
            if (LutTag == icSigLut8Type)
            {
                lpTable = (MEMPTR) (((lpcpLut8Type) lpLut)->lut.data) +
                    nInputTable * nInputCh +
                    nNumbers * (i * SecondGrids + k);
            } else
            {
                lpTable = (MEMPTR) (((lpcpLut16Type) lpLut)->lut.data) +
                    2 * nInputTable * nInputCh +
                    2 * nNumbers * (i * SecondGrids + k);
            }

            if (!AllowBinary)           // Output ASCII
            {
                lpMem += WriteObject (lpMem, BeginString);
                if (LutTag == icSigLut8Type)
                    lpMem += WriteHexBuffer (lpMem, lpTable, lpLineStart, nNumbers);
                else
                {
                    for (j = 0; j < nNumbers; j++)
                    {
                        lpMem += WriteHex (lpMem, ui16toSINT (lpTable) / 256);
                        lpTable += sizeof (icUInt16Number);
                        if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
                        {
                            lpLineStart = lpMem;
                            lpMem += WriteObject (lpMem, NewLine);
                        }
                    }
                }
                lpMem += WriteObject (lpMem, EndString);
            } else
            {                           // Output BINARY
                lpMem += WriteStringToken (lpMem, 143, nNumbers);
                if (LutTag == icSigLut8Type)
                    lpMem += WriteByteString (lpMem, lpTable, nNumbers);
                else
                    lpMem += WriteInt2ByteString (lpMem, lpTable, nNumbers);
            }
            lpMem += WriteObject (lpMem, NewLine);
        }
        if (Type == TYPE_CIEBASEDDEFG)
        {
            lpMem += WriteObject (lpMem, EndArray);
        }
    }
    lpMem += WriteObject (lpMem, EndArray);
    lpMem += WriteObject (lpMem, EndArray); // End array

 //********** /DecodeABC
    lpLineStart = lpMem;
    lpMem += WriteNewLineObject (lpMem, DecodeABCTag);
    lpMem += WriteObject (lpMem, BeginArray);
    for (i = 0; i < nOutputCh; i++)
    {
        lpLineStart = lpMem;
        lpMem += WriteNewLineObject (lpMem, BeginFunction);
        lpMem += WriteObject (lpMem, Clip01);
        lpMem += WriteObject (lpMem, OutputArray);
        lpMem += WriteObjectN (lpMem, (MEMPTR) PublicArrayName, lstrlen (PublicArrayName));
        lpMem += WriteInt (lpMem, i);

        if (!AllowBinary)               // Output ASCII CRD
        {
            lpMem += WriteObject (lpMem, NewLine);

            if (LutTag == icSigLut8Type)
            {
                lpMem += WriteObject (lpMem, TFunction8XYZ);
            } else
            {
                lpMem += WriteObject (lpMem, IndexArray);
                lpMem += WriteObject (lpMem, Scale16XYZ);
            }
        } else
        {                               // Output BINARY CRD
            if (LutTag == icSigLut8Type)
            {
                lpMem += WriteObject (lpMem, TFunction8XYZ);
            } else
            {
                lpMem += WriteObject (lpMem, IndexArray16b);
                lpMem += WriteObject (lpMem, Scale16XYZ);
            }
        }

 // Now, We get CieBasedXYZ output. Output range 0 --> 1.99997
 // If the connection space is absolute XYZ, We need to convert 
 // from relative XYZ to absolute XYZ.
        if ((PCS == icSigXYZData) &&
            (InputIntent == icAbsoluteColorimetric))
        {
            lpMem += WriteFloat (lpMem, (double)MediaWP[i]/IlluminantWP[i]);
            lpMem += WriteObject (lpMem, MulOp); 
        }
 // If the connection space is Lab, We need to convert XYZ to Lab.
        else if (PCS == icSigLabData)
            lpMem += WriteObject (lpMem, DecodeABCLab[i]);
        lpMem += WriteObject (lpMem, EndFunction);
    }
    lpMem += WriteObject (lpMem, EndArray);

    if (PCS == icSigLabData)
    {
 //********** /MatrixABC
        lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
        lpMem += WriteObject (lpMem, MatrixABCLab);

 //********** /DecodeLMN
        lpLineStart = lpMem;
        lpMem += WriteNewLineObject (lpMem, DecodeLMNTag);
        lpMem += WriteObject (lpMem, BeginArray);
        for (i = 0; i < 3; i++)
        {
            lpLineStart = lpMem;
            lpMem += WriteNewLineObject (lpMem, BeginFunction);
            lpMem += WriteObject (lpMem, DecodeLMNLab);
            if (InputIntent == icAbsoluteColorimetric)
                lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
            else 
                lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
            lpMem += WriteObject (lpMem, MulOp);
            lpMem += WriteObject (lpMem, EndFunction);
        }
        lpMem += WriteObject (lpMem, EndArray);
    } else
    {
 //********** /RangeLMN
        lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
        lpMem += WriteObject (lpMem, RangeLMN);
    }

 //********** End dictionary definition
    lpMem += WriteNewLineObject (lpMem, EndDict);
    lpMem += WriteObject (lpMem, EndArray);

    if (Type == TYPE_CIEBASEDDEFG)
        lpMem += WriteNewLineObject (lpMem, CieBasedDEFGEnd);
    else
        lpMem += WriteNewLineObject (lpMem, CieBasedDEFEnd);

    lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);

    *lpcbSize = (DWORD) (lpMem - lpOldMem);

    MemFree (hLut);
    return (TRUE);
}

/***************************************************************************
*                           GetPS2CSA_ABC
*  function:
*    this is the function which creates the CIEBasedABC ColorSpace (CS)
*    from the data supplied in the RGB Input Profile.
*  prototype:
*       GetPS2CSA_ABC(
*                       CHANDLE     cp,
*                       MEMPTR      lpMem,
*                       LPDWORD     lpcbSize,
*                       BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpMem       --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       InputIntent --
*       InpDrvClrSp --
*       AllowBinary --  1: binary CSA allowed,  0: only ascii CSA allowed.
*       BackupCSA   --  1: A CIEBasedDEF has been created, this CSA is a backup 
*                          in case some old printer can not support CIEBasedDEF.
*                       0: No CIEBasedDEF. This is the only CSA.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/

BOOL
GetPS2CSA_ABC (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
               CSIG InputIntent, DWORD InpDrvClrSp, 
               BOOL AllowBinary, BOOL BackupCSA)
{
    CSIG PCS, Dev;
    SFLOAT IlluminantWP[3];
    SFLOAT MediaWP[3];

    SINT i;
    MEMPTR lpOldMem = lpMem;
    SINT Ret = 0; 
    
 // Check if we can generate the CS.
 // Required  tags are: red, green and blue Colorants.
 // As for TRC tags - we are quite flexible here - if we cannot find the
 // required tag - we assume the linear responce
    if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
        !GetCPDevSpace (cp, (LPCSIG) & Dev) ||
        (Dev != icSigRgbData) ||
        !DoesTRCAndColorantTagExist(cp))
    {
        return (FALSE);
    }
    if ((InpDrvClrSp != icSigRgbData) &&
        (InpDrvClrSp != icSigDefData) &&
        (InpDrvClrSp != 0))
    {
        return (FALSE);
    }
 // Estimate the memory size required to hold CS

    if (lpMem == NULL)                  // This is a size request
    {
        *lpcbSize = 65530;
        return (TRUE);
    }

 // Get info about Illuminant White Point from the header
    GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);     // .. Illuminant
                                                            
 // Support absolute whitePoint
    GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);

 //*********** Creating global data

    lpMem += WriteNewLineObject (lpMem, CieBasedABCBegin);

    if (IsSRGB(cp))
    {
       lpMem += WriteNewLineObject (lpMem, AdobeCSA);
    }
    else
    {
       lpMem += EnableGlobalDict(lpMem);
       
       if (BackupCSA)
       {
           lpMem += WriteNewLineObject (lpMem, NotSupportDEFG_S);
       }
   
       lpMem += BeginGlobalDict(lpMem);
   
       lpMem += CreateColSpArray (cp, lpMem, icSigRedTRCTag, AllowBinary);
       lpMem += CreateColSpArray (cp, lpMem, icSigGreenTRCTag, AllowBinary);
       lpMem += CreateColSpArray (cp, lpMem, icSigBlueTRCTag, AllowBinary);
   
       lpMem += WriteNewLineObject (lpMem, EndOp);
   
       if (BackupCSA)
       {
           lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
       }
       lpMem += WriteNewLineObject (lpMem, SetGlobalOp);
   
       if (BackupCSA)
       {
           lpMem += WriteNewLineObject (lpMem, NotSupportDEFG_S);
       }
   
    //*********** Start creating the ColorSpace
       lpMem += WriteNewLineObject (lpMem, BeginArray);   // Begin array
    //********** /CIEBasedABC
       lpMem += WriteObject (lpMem, CIEBasedABCTag);   // Create entry
       lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary
   
    //********** Black/White Point
       lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);
   
    //********** /DecodeABC
       lpMem += WriteNewLineObject (lpMem, DecodeABCTag);
       lpMem += WriteObject (lpMem, BeginArray);
   
       lpMem += WriteObject (lpMem, NewLine);
       lpMem += CreateColSpProc (cp, lpMem, icSigRedTRCTag, AllowBinary);
       lpMem += WriteObject (lpMem, NewLine);
       lpMem += CreateColSpProc (cp, lpMem, icSigGreenTRCTag, AllowBinary);
       lpMem += WriteObject (lpMem, NewLine);
       lpMem += CreateColSpProc (cp, lpMem, icSigBlueTRCTag, AllowBinary);
       lpMem += WriteObject (lpMem, EndArray);
   
    //********** /MatrixABC
       lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
       lpMem += WriteObject (lpMem, BeginArray);
   
       lpMem += CreateFloatString (cp, lpMem, icSigRedColorantTag);
       lpMem += CreateFloatString (cp, lpMem, icSigGreenColorantTag);
       lpMem += CreateFloatString (cp, lpMem, icSigBlueColorantTag);
   
       lpMem += WriteObject (lpMem, EndArray);
   
    //********** /RangeLMN
       lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
       lpMem += WriteObject (lpMem, RangeLMN);
   
    //********** /DecodeLMN
       if (InputIntent == icAbsoluteColorimetric)
       {
           // Support absolute whitePoint
           lpMem += WriteNewLineObject (lpMem, DecodeLMNTag);
           lpMem += WriteObject (lpMem, BeginArray);
           for (i = 0; i < 3; i ++)
           {
               lpMem += WriteObject (lpMem, BeginFunction);
               lpMem += WriteFloat (lpMem, (double)MediaWP[i]/IlluminantWP[i]);
               lpMem += WriteObject (lpMem, MulOp); 
               lpMem += WriteObject (lpMem, EndFunction);
           }
           lpMem += WriteObject (lpMem, EndArray);
       }
   
    //********** End dictionary definition
       lpMem += WriteNewLineObject (lpMem, EndDict);
       lpMem += WriteObject (lpMem, EndArray);
   
       if (BackupCSA)
       {
           lpMem += WriteNewLineObject (lpMem, SupportDEFG_E);
       }
   
    }
    lpMem += WriteNewLineObject (lpMem, CieBasedABCEnd);
    *lpcbSize = (DWORD) ((lpMem - lpOldMem));
    return (TRUE);
}

/***************************************************************************
*                           GetPS2CSA_ABC_LAB
*  function:
*    this is the function which creates the CIEBasedABC ColorSpace (CS)
*    from the data supplied in the LAB Input Profile.
*  prototype:
*       GetPS2CSA_ABC(
*                       CHANDLE     cp,
*                       MEMPTR      lpMem,
*                       LPDWORD     lpcbSize,
*                       BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpMem       --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       InputIntent --
*       InpDrvClrSp --
*       AllowBinary --  1: binary CSA allowed,  0: only ascii CSA allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/

BOOL
GetPS2CSA_ABC_LAB (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
               CSIG InputIntent, DWORD InpDrvClrSp, BOOL AllowBinary)
{
    CSIG PCS, Dev;
    SFLOAT IlluminantWP[3];
    SFLOAT MediaWP[3];

    SINT i;
    MEMPTR lpOldMem = lpMem;
    SINT Ret = 0;
 // Check if we can generate the CS.
 // Required  tags are: red, green and blue Colorants.
 // As for TRC tags - we are quite flexible here - if we cannot find the
 // required tag - we assume the linear responce
    if (!GetCPConnSpace (cp, (LPCSIG) & PCS) ||
        !GetCPDevSpace (cp, (LPCSIG) & Dev) ||
        (Dev != icSigLabData))
    {
        return (FALSE);
    }
    if ((InpDrvClrSp != icSigLabData) &&
        (InpDrvClrSp != icSigDefData) &&
        (InpDrvClrSp != 0))
    {
        return (FALSE);
    }
 // Estimate the memory size required to hold CS

    if (lpMem == NULL)                  // This is a size request
    {
        *lpcbSize = 65530;
        return (TRUE);
    }
 // Get info about Illuminant White Point from the header
    GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);     // .. Illuminant
                                                         
 // Support absolute whitePoint
    GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);

 //*********** Start creating the ColorSpace
    lpMem += WriteNewLineObject (lpMem, BeginArray);   // Begin array

 //********** /CIEBasedABC
    lpMem += WriteObject (lpMem, CIEBasedABCTag);   // Create entry
    lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary

 //********** Black/White Point
    lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);

 //********** /RangeABC
    lpMem += WriteNewLineObject (lpMem, RangeABCTag);
    lpMem += WriteObject (lpMem, RangeABC_Lab);

 //********** /DecodeABC
    lpMem += WriteNewLineObject (lpMem, DecodeABCTag);
    lpMem += WriteObject (lpMem, DecodeABCLab1);

 //********** /MatrixABC
    lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
    lpMem += WriteObject (lpMem, MatrixABCLab);

 //********** /DecodeLMN
    lpMem += WriteNewLineObject (lpMem, DecodeLMNTag);
    lpMem += WriteObject (lpMem, BeginArray);
    for (i = 0; i < 3; i ++)
    {
        lpMem += WriteObject (lpMem, BeginFunction);
        lpMem += WriteObject (lpMem, DecodeLMNLab);
        if (InputIntent == icAbsoluteColorimetric)
        {
            lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
        }
        else
        {
            lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
        }
        lpMem += WriteObject (lpMem, MulOp); 
        lpMem += WriteObject (lpMem, EndFunction);
        lpMem += WriteObject (lpMem, NewLine);
    }
    lpMem += WriteObject (lpMem, EndArray);


 //********** End dictionary definition
    lpMem += WriteNewLineObject (lpMem, EndDict);
    lpMem += WriteObject (lpMem, EndArray);

    lpMem += WriteNewLineObject (lpMem, CieBasedABCEnd);
    *lpcbSize = (DWORD) ((lpMem - lpOldMem));
    return (TRUE);
}

/***************************************************************************
*                           GetPS2CSA_MONO_ABC
*  function:
*    this is the function which creates the CIEBasedABC ColorSpace (CS)
*    from the data supplied in the GRAY Input Profile.
*  prototype:
*       GetPS2CSA_MONO_ABC(
*                       CHANDLE     cp,
*                       MEMPTR      lpMem,
*                       LPDWORD     lpcbSize,
*                       BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpMem       --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       AllowBinary --  1: binary CSA allowed,  0: only ascii CSA allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/

static BOOL
GetPS2CSA_MONO_ABC (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, 
                    CSIG InputIntent, BOOL AllowBinary)
{
    SINT nCount;
    CSIG Tag, PCS;
    SINT i, j, Index;
    MEMPTR lpTable;
    SFLOAT IlluminantWP[3];
    SFLOAT MediaWP[3];
    MEMPTR lpBuff = NULL;
    SINT MemSize = 0;
    MEMPTR lpOldMem = lpMem;
    HGLOBAL hBuff;
    MEMPTR lpLineStart;
 // Check if we can generate the CS
    if (!DoesCPTagExist (cp, icSigGrayTRCTag) ||
        !GetCPTagIndex (cp, icSigGrayTRCTag, &Index) ||
        !GetCPElementType (cp, Index, (LPCSIG) & Tag) ||
        (Tag != icSigCurveType) ||
        !GetCPConnSpace (cp, (LPCSIG) & PCS) ||
        !GetCPElementSize (cp, Index, (LPSINT) & MemSize) ||
        !MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & lpBuff) ||
        !GetCPElement (cp, Index, lpBuff, MemSize))
    {
        if (NULL != lpBuff)
        {
            MemFree (hBuff);
        }
        return (FALSE);
    }
    nCount = ui32toSINT (((lpcpCurveType) lpBuff)->curve.count);

 // Estimate the memory size required to hold CS
    *lpcbSize = nCount * 6 +            // Number of INT elements
        3 * (lstrlen (IndexArray) +
             lstrlen (StartClip) +
             lstrlen (EndClip)) +
        2048;                           // + other PS stuff
    if (lpMem == NULL)                  // This is a size request
    {
        MemFree (hBuff);
        return (TRUE);
    }
 // Get info about Illuminant White Point from the header
    GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);          // .. Illuminant

 // Support absolute whitePoint
    GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);

 //*********** Start creating the ColorSpace
    lpMem += WriteNewLineObject (lpMem, CieBasedABCBegin);

    lpMem += WriteNewLineObject (lpMem, BeginArray);   // Begin array
 //********** /CIEBasedABC
    lpMem += WriteObject (lpMem, CIEBasedABCTag);   // Create entry
    lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary

 //********** Black/White Point
    lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);

 //********** /DecodeABC
    lpMem += WriteObject (lpMem, NewLine);
    lpLineStart = lpMem;

    if (nCount != 0)
    {
        lpMem += WriteObject (lpMem, DecodeABCTag);
        lpMem += WriteObject (lpMem, BeginArray);

        lpMem += WriteObject (lpMem, BeginFunction);
        if (nCount == 1)                // Gamma supplied in ui16 format
        {
            lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
            lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
            lpMem += WriteObject (lpMem, DecodeA3);
        } else
        {
            lpMem += WriteObject (lpMem, StartClip);
            lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
            lpMem += WriteObject (lpMem, BeginArray);
            for (i = 0; i < nCount; i++)
            {
                lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
                lpTable += sizeof (icUInt16Number);
                if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
                {
                    lpLineStart = lpMem;
                    lpMem += WriteObject (lpMem, NewLine);
                }
            }
            lpMem += WriteObject (lpMem, EndArray);
            lpLineStart = lpMem;
            lpMem += WriteObject (lpMem, NewLine);

            lpMem += WriteObject (lpMem, IndexArray);
            lpMem += WriteObject (lpMem, Scale16);
            lpMem += WriteObject (lpMem, EndClip);
        }
        lpMem += WriteObject (lpMem, EndFunction);
        lpMem += WriteObject (lpMem, DupOp);
        lpMem += WriteObject (lpMem, DupOp);
        lpMem += WriteObject (lpMem, EndArray);
    }
 //********** /MatrixABC
    lpMem += WriteNewLineObject (lpMem, MatrixABCTag);
    lpMem += WriteObject (lpMem, BeginArray);
    for (i = 0; i < 3; i ++)
    {
        for (j = 0; j < 3; j++)
        {
            if (i != j)
                lpMem += WriteFloat (lpMem, (double)0);
            else
            {
                if (InputIntent == icAbsoluteColorimetric)
                    lpMem += WriteFloat (lpMem, (double)MediaWP[i]);
                else
                    lpMem += WriteFloat (lpMem, (double)IlluminantWP[i]);
            }
        }
    }
    lpMem += WriteObject (lpMem, EndArray);

 //********** /RangeLMN
    lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
    lpMem += WriteObject (lpMem, RangeLMN);


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

    MemFree (hBuff);

    lpMem += WriteNewLineObject (lpMem, CieBasedABCEnd);
    *lpcbSize = (DWORD) (lpMem - lpOldMem);
    return (TRUE);
}
/***************************************************************************
*                           GetPS2CSA_MONO_A
*  function:
*    this is the function which creates the CIEBasedA ColorSpace (CS)
*    from the data supplied in the GRAY Input Profile.
*  prototype:
*       GetPS2CSA_MONO_A(
*                       CHANDLE     cp,
*                       MEMPTR      lpMem,
*                       LPDWORD     lpcbSize,
*                       BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpMem       --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       AllowBinary --  1: binary CSA allowed,  0: only ascii CSA allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/

static BOOL
GetPS2CSA_MONO_A (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize, 
                  CSIG InputIntent, BOOL AllowBinary)
{
    SINT nCount;
    CSIG Tag, PCS;
    SINT i, Index;
    MEMPTR lpTable;
    SFLOAT IlluminantWP[3];
    SFLOAT MediaWP[3];
    MEMPTR lpBuff = NULL;
    SINT MemSize = 0;
    MEMPTR lpOldMem = lpMem;
    HGLOBAL hBuff;
    MEMPTR lpLineStart;
 // Check if we can generate the CS
    if (!DoesCPTagExist (cp, icSigGrayTRCTag) ||
        !GetCPTagIndex (cp, icSigGrayTRCTag, &Index) ||
        !GetCPElementType (cp, Index, (LPCSIG) & Tag) ||
        (Tag != icSigCurveType) ||
        !GetCPConnSpace (cp, (LPCSIG) & PCS) ||
        !GetCPElementSize (cp, Index, (LPSINT) & MemSize) ||
        !MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & lpBuff) ||
        !GetCPElement (cp, Index, lpBuff, MemSize))
    {
        if (NULL != lpBuff)
        {
            MemFree (hBuff);
        }
        return (FALSE);
    }
    nCount = ui32toSINT (((lpcpCurveType) lpBuff)->curve.count);

 // Estimate the memory size required to hold CS
    *lpcbSize = nCount * 6 +            // Number of INT elements
        3 * (lstrlen (IndexArray) +
             lstrlen (StartClip) +
             lstrlen (EndClip)) +
        2048;                           // + other PS stuff
    if (lpMem == NULL)                  // This is a size request
    {
        MemFree (hBuff);
        return (TRUE);
    }
 // Get info about Illuminant White Point from the header
    GetCPWhitePoint (cp, (LPSFLOAT) & IlluminantWP);          // .. Illuminant

 // Support absolute whitePoint
    GetMediaWP(cp, InputIntent, IlluminantWP, MediaWP);

 //*********** Start creating the ColorSpace
    lpMem += WriteNewLineObject (lpMem, CieBasedABegin);

    lpMem += WriteNewLineObject (lpMem, BeginArray);   // Begin array
 //********** /CIEBasedA
    lpMem += WriteObject (lpMem, CIEBasedATag); // Create entry
    lpMem += WriteObject (lpMem, BeginDict);    // Begin dictionary

 //********** Black/White Point
    lpMem += SendCSABWPoint(lpMem, InputIntent, IlluminantWP, MediaWP);

 //********** /DecodeA
    lpMem += WriteObject (lpMem, NewLine);
    lpLineStart = lpMem;

    if (nCount != 0)
    {
        lpMem += WriteObject (lpMem, DecodeATag);

        lpMem += WriteObject (lpMem, BeginFunction);
        if (nCount == 1)                // Gamma supplied in ui16 format
        {
            lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
            lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
            lpMem += WriteObject (lpMem, DecodeA3);
    // If the PCS is Lab, we need to convert Lab to XYZ
    // Now, the range is from 0 --> 0.99997.
    // Actually, the conversion from Lab to XYZ is not needed.
            if (PCS == icSigLabData)
            {
                lpMem += WriteObject (lpMem, DecodeALab);
                lpMem += WriteObject (lpMem, DecodeLMNLab);
            }
        } else
        {
            lpMem += WriteObject (lpMem, StartClip);
            lpTable = (MEMPTR) (((lpcpCurveType) lpBuff)->curve.data);
            lpMem += WriteObject (lpMem, BeginArray);
            for (i = 0; i < nCount; i++)
            {
                lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
                lpTable += sizeof (icUInt16Number);
                if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
                {
                    lpLineStart = lpMem;
                    lpMem += WriteObject (lpMem, NewLine);
                }
            }
            lpMem += WriteObject (lpMem, EndArray);
            lpLineStart = lpMem;
            lpMem += WriteObject (lpMem, NewLine);

            lpMem += WriteObject (lpMem, IndexArray);
            lpMem += WriteObject (lpMem, Scale16);
    // If the PCS is Lab, we need to convert Lab to XYZ
    // Now, the range is from 0 --> .99997.
    // Actually, the conversion from Lab to XYZ is not needed.
            if (PCS == icSigLabData)
            {
                lpMem += WriteObject (lpMem, DecodeALab);
                lpMem += WriteObject (lpMem, DecodeLMNLab);
            }
            lpMem += WriteObject (lpMem, EndClip);
        }
        lpMem += WriteObject (lpMem, EndFunction);
    }

 //********** /MatrixA
    lpMem += WriteNewLineObject (lpMem, MatrixATag);
    lpMem += WriteObject (lpMem, BeginArray);
    for (i = 0; i < 3; i++)
    {
        if (InputIntent == icAbsoluteColorimetric)
            lpMem += WriteFloat (lpMem, (double) MediaWP[i]);
        else
            lpMem += WriteFloat (lpMem, (double) IlluminantWP[i]);
    }
    lpMem += WriteObject (lpMem, EndArray);

 //********** /RangeLMN
    lpMem += WriteNewLineObject (lpMem, RangeLMNTag);
    lpMem += WriteObject (lpMem, RangeLMN);

 //********** /End dictionary
    lpMem += WriteObject (lpMem, EndDict);  // End dictionary definition
    lpMem += WriteObject (lpMem, EndArray);

    MemFree (hBuff);

    lpMem += WriteNewLineObject (lpMem, CieBasedAEnd);
    *lpcbSize = (DWORD) (lpMem - lpOldMem);
    return (TRUE);
}
/***************************************************************************
*                           GetPS2CSA_MONO
*  function:
*    this is the function which creates the MONO ColorSpace (CS)
*    from the data supplied in the GRAY Input Profile.
*  prototype:
*       GetPS2CSA_MONO(
*                       CHANDLE     cp,
*                       MEMPTR      lpMem,
*                       LPDWORD     lpcbSize,
*                       WORD        InpDrvClrSp
*                       BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpMem       --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       InpDrvClrSp --  Device color type (RGB or GRAY).
*       AllowBinary --  1: binary CSA allowed,  0: only ascii CSA allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/
static BOOL
GetPS2CSA_MONO (CHANDLE cp, MEMPTR lpMem, LPDWORD lpcbSize,
                DWORD InpDrvClrSp, CSIG InputIntent, BOOL AllowBinary)
{
    BOOL Success = FALSE;
#if 0
    if ((InpDrvClrSp == icSigRgbData) ||
        (InpDrvClrSp == icSigDefData) ||
        (InpDrvClrSp == 0))
    {
        Success = GetPS2CSA_MONO_ABC (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
    } else if (InpDrvClrSp == icSigGrayData)
    {
        Success = GetPS2CSA_MONO_A (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
    }
#else
    if ((InpDrvClrSp == icSigGrayData) ||
        (InpDrvClrSp == 0))
    {
        Success = GetPS2CSA_MONO_A (cp, lpMem, lpcbSize, InputIntent, AllowBinary);
    }
    else
    {
        Success = FALSE;
    }
#endif
    return Success;
}
/***************************************************************************
*
*   Function to create a procedure for Color space.
*
***************************************************************************/

SINT 
CreateColSpProc (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary)
{
    SINT nCount, Index;
    MEMPTR lpTable;
    MEMPTR Buff = NULL;
    SINT MemSize = 0;
    MEMPTR lpOldMem;
    HGLOBAL hBuff;
    lpOldMem = lpMem;
    lpMem += WriteObject (lpMem, BeginFunction);
    if (DoesCPTagExist (cp, CPTag) &&
        GetCPTagIndex (cp, CPTag, (LPSINT) & Index) &&
        GetCPElementSize (cp, Index, (LPSINT) & MemSize) &&
        MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & Buff) &&
        GetCPElement (cp, Index, Buff, MemSize))
    {
        nCount = ui32toSINT (((lpcpCurveType) Buff)->curve.count);
        if (nCount != 0)
        {
            if (nCount == 1)            // Gamma supplied in ui16 format
            {
                lpTable = (MEMPTR) (((lpcpCurveType) Buff)->curve.data);
                lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
                lpMem += WriteObject (lpMem, DecodeA3);
            } else
            {
                lpMem += WriteObject (lpMem, StartClip);
                lpTable = (MEMPTR) (((lpcpCurveType) Buff)->curve.data);
                lpMem += WriteObject (lpMem, DecodeABCArray);
                lpMem += WriteInt (lpMem, (SINT) CPTag);

                if (!AllowBinary)       // Output ASCII CS
                {
                    lpMem += WriteObject (lpMem, IndexArray);
                } else
                {                       // Output BINARY CS
                    lpMem += WriteObject (lpMem, IndexArray16b);
                }
                lpMem += WriteObject (lpMem, Scale16);
                lpMem += WriteObject (lpMem, EndClip);
            }
        }
        MemFree (hBuff);
    }
    lpMem += WriteObject (lpMem, EndFunction);
    return ((SINT) (lpMem - lpOldMem));
}
/***************************************************************************
*
*   Function to create a procedure for Color space.
*
***************************************************************************/

SINT 
CreateFloatString (CHANDLE cp, MEMPTR lpMem, CSIG CPTag)
{
    SINT i, Index;
    MEMPTR lpTable;
    MEMPTR Buff = NULL;
    SINT MemSize = 0;
    MEMPTR lpOldMem;
    HGLOBAL hBuff;
    lpOldMem = lpMem;
    if (GetCPTagIndex (cp, CPTag, (LPSINT) & Index) &&
        GetCPElementSize (cp, Index, (LPSINT) & MemSize) &&
        MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & Buff) &&
        GetCPElement (cp, Index, Buff, MemSize))
    {
        lpTable = (MEMPTR) & (((lpcpXYZType) Buff)->data);
        for (i = 0; i < 3; i++)
        {
            lpMem += WriteFloat (lpMem, si16f16toSFLOAT (lpTable));
            lpTable += sizeof (icS15Fixed16Number);
        }
        MemFree (hBuff);
    }
    return ((SINT) (lpMem - lpOldMem));
}
/***************************************************************************
*
*   Function to create a array later to be used in ColorSpace's DecodeABC.
*
***************************************************************************/

SINT 
CreateColSpArray (CHANDLE cp, MEMPTR lpMem, CSIG CPTag, BOOL AllowBinary)
{
    SINT i, nCount, Index;
    MEMPTR lpTable;
    MEMPTR Buff = NULL;
    SINT MemSize = 0;
    MEMPTR lpOldMem, lpLineStart;
    HGLOBAL hBuff;
    lpOldMem = lpMem;

    lpLineStart = lpMem;

    if (DoesCPTagExist (cp, CPTag) &&
        GetCPTagIndex (cp, CPTag, (LPSINT) & Index) &&
        GetCPElementSize (cp, Index, (LPSINT) & MemSize) &&
        MemAlloc (MemSize, (HGLOBAL FAR *)&hBuff, (LPMEMPTR) & Buff) &&
        GetCPElement (cp, Index, Buff, MemSize))
    {
        nCount = ui32toSINT (((lpcpCurveType) Buff)->curve.count);
        if (nCount > 1)
        {
            lpMem += WriteNewLineObject (lpMem, Slash);
            lpMem += WriteObject (lpMem, DecodeABCArray);
            lpMem += WriteInt (lpMem, (SINT) CPTag);

            lpTable = (MEMPTR) (((lpcpCurveType) Buff)->curve.data);
            if (!AllowBinary)           // Output ASCII CS
            {
                lpMem += WriteObject (lpMem, BeginArray);
                for (i = 0; i < nCount; i++)
                {
                    lpMem += WriteInt (lpMem, ui16toSINT (lpTable));
                    lpTable += sizeof (icUInt16Number);
                    if (((SINT) (lpMem - lpLineStart)) > MAX_LINELENG)
                    {
                        lpLineStart = lpMem;
                        lpMem += WriteObject (lpMem, NewLine);
                    }
                }
                lpMem += WriteObject (lpMem, EndArray);
            } else
            {                           // Output BINARY CS
                lpMem += WriteHNAToken (lpMem, 149, nCount);
                lpMem += WriteIntStringU2S (lpMem, lpTable, nCount);
            }
            lpMem += WriteObject (lpMem, DefOp);
        }
        MemFree (hBuff);
    }
    return ((SINT) (lpMem - lpOldMem));
}
/***************************************************************************
*                               GetCSAFromProfile
*  function:
*    this is the function which gets the ColorSpace dictionary array
*    from the the Profile.
*  prototype:
*       static BOOL GetCSAFromProfile(
*                       CHANDLE     cp,
*                       MEMPTR      lpMem,
*                       LPDWORD     lpcbSize,
*                       WORD        InpDrvClrSp,
*                       CSIG        DrvColorSpace,
*                       BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpBuffer    --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       InpDrvClrSp --  Input device color space.
*       DrvColorSpace --  Profile device color space.
*       AllowBinary --  1: binary CS allowed,  0: only ascii CS allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/

static BOOL
GetCSAFromProfile (
                   CHANDLE cp,
                   MEMPTR lpMem,
                   LPDWORD lpcbSize,
                   DWORD InpDrvClrSp,
                   CSIG DrvColorSpace,
                   BOOL AllowBinary)
{
    SINT Index;
    SINT Size;
    if ((DrvColorSpace == icSigGrayData) && (InpDrvClrSp != icSigGrayData))
        return FALSE;

    if (DoesCPTagExist (cp, icSigPs2CSATag) &&
        GetCPTagIndex (cp, icSigPs2CSATag, (LPSINT) & Index) &&
        GetCPElementDataSize (cp, Index, (LPSINT) & Size) &&
        ((lpMem == NULL) || GetCPElementData (cp, Index, lpMem, Size)) &&
        (*lpcbSize = Convert2Ascii (cp, Index, lpMem, *lpcbSize, Size, AllowBinary)))
    {
        return TRUE;
    } else
    {
        return FALSE;
    }
}
/***************************************************************************
*                           GetPS2CSA_DEFG_Intent
*  function:
*    This is the function which creates the CieBasedDEF(G)ColorSpace array
*    based on Intent.
*  prototype:
*       static BOOL GetPS2CSA_DEFG_Intent(
*                   CHANDLE     cp,
*                   MEMPTR      lpBuffer,
*                   LPDWORD     lpcbSize,
*                   CSIG        Intent,
*                   int         Type,
*                   BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpBuffer    --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       Intent      --  Intent.
*       Type        --  CieBasedDEF or CieBasedDEF.
*       AllowBinary --  1: binary CS allowed,  0: only ascii CS allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/

BOOL
GetPS2CSA_DEFG_Intent (
                       CHANDLE cp,
                       MEMPTR lpBuffer,
                       LPDWORD lpcbSize,
                       DWORD InpDrvClrSp,
                       CSIG Intent,
                       int Type,
                       BOOL AllowBinary)
{
    SINT Index;
    BOOL Success = FALSE;
    CSIG icSigAToBx;

 // Try to create CieBasedDEFG CSA first.
    if (((Type == TYPE_CIEBASEDDEFG) && (InpDrvClrSp != icSigCmykData) ||
         (Type == TYPE_CIEBASEDDEF) && (InpDrvClrSp != icSigDefData)) &&
        (InpDrvClrSp != 0))
    {
        return (FALSE);
    }
    switch (Intent)
    {
        case icPerceptual:
            icSigAToBx = icSigAToB0Tag;
            break;
        case icRelativeColorimetric:
            icSigAToBx = icSigAToB1Tag;
            break;
        case icSaturation:
            icSigAToBx = icSigAToB2Tag;
            break;
        case icAbsoluteColorimetric:
            icSigAToBx = icSigAToB1Tag;
            break;
        default:
            return Success;
    }

    if (DoesCPTagExist (cp, icSigAToBx) &&
        GetCPTagIndex (cp, icSigAToBx, (LPSINT) & Index))
    {
        Success = GetPS2CSA_DEFG (cp, lpBuffer, lpcbSize, Intent, Index, Type, AllowBinary);
    }

    return Success;
}
/***************************************************************************
*                               GetPS2ColorSpaceArray
*  function:
*    This is the main function which creates the ColorSpace array
*    from the data supplied in the Profile.
*  prototype:
*       BOOL GetPS2ColorSpaceArray(
*               CHANDLE     cp,
*               CSIG        InputIntent,
*               WORD        InpDrvClrSp,
*               MEMPTR      lpBuffer,
*               LPDWORD     lpcbSize,
*               BOOL        AllowBinary)
*  parameters:
*       cp          --  Color Profile handle
*       lpBuffer    --  Pointer to the memory block. If this point is NULL,
*                       require buffer size.
*       lpcbSize    --  Size of the memory block
*       InpDrvClrSp --  Input device color space.
*                       icSigCmykData: input data is cmyk, create CiebasedDEFG CSA.
*                       icSigRgbData : input data is rgb, create CieBasedABC CSA.
*                       icSigDefData : input data is rgb or lab, create CiebasedDEF CSA.
*                       isSigGrayData: input data is gray, create CieBasedA CSA.
*                       0            : Auto. Create CSA depends on profile color space.
*       InputIntent --  Intent.
*       AllowBinary --  1: binary CS allowed,  0: only ascii CS allowed.
*  returns:
*       BOOL        --  TRUE if the function was successful,
*                       FALSE otherwise.
***************************************************************************/
BOOL EXTERN
GetPS2ColorSpaceArray (
                       CHANDLE cp,
                       DWORD InputIntent,
                       DWORD InpDrvClrSp,
                       MEMPTR lpBuffer,
                       LPDWORD lpcbSize,
                       BOOL AllowBinary)
{
    CSIG ColorSpace, Intent;
    BOOL Success = FALSE;
    DWORD dwSaveSize;
    if (!cp)
        return Success;

    if (!GetCPDevSpace (cp, (LPCSIG) & ColorSpace) ||
        !GetCPRenderIntent (cp, (LPCSIG) & Intent))
    {
        return Success;
    }
    dwSaveSize = *lpcbSize;
    if (InputIntent == icUseRenderingIntent)
        InputIntent = (DWORD)Intent;

 // Get ColorSpace from Profile.
    if ((CSIG) InputIntent == Intent)
    {
        Success = GetCSAFromProfile (cp, lpBuffer, lpcbSize,
                                     InpDrvClrSp, ColorSpace, AllowBinary);
    }
    if (!Success)
    {
        switch (ColorSpace)
        {
            case icSigRgbData:
                Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
                                                 InpDrvClrSp, (CSIG) InputIntent, 
                                                 TYPE_CIEBASEDDEF, AllowBinary);
                if (Success)
                {                       // Create CieBasedABC or DeviceRGB
                                        // for the printer
                                        // which does not support CieBasedDEF(G).
                    DWORD cbNewSize = 0;
                    MEMPTR lpNewBuffer;
                    MEMPTR lpOldBuffer;
                    if (lpBuffer)
                    {
                        lpNewBuffer = lpBuffer + *lpcbSize;
                        lpOldBuffer = lpNewBuffer;
                        lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
                        cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
                    } else
                        lpNewBuffer = NULL;

                    if (!GetPS2CSA_ABC (cp, lpNewBuffer, &cbNewSize,
                                        (CSIG)InputIntent, InpDrvClrSp, 
                                        AllowBinary, 1))   // create a backup CSA
                        GetDeviceRGB (lpNewBuffer, &cbNewSize, InpDrvClrSp, 1);

                    if (lpBuffer)
                    {
                        lpNewBuffer += cbNewSize;
                        *lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
                    } else
                        *lpcbSize += cbNewSize;

                }
                if (!Success)
                {                           // Create CieBasedABC
                    Success = GetPS2CSA_ABC (cp, lpBuffer, lpcbSize,
                                         (CSIG)InputIntent, InpDrvClrSp, 
                                         AllowBinary, 0);
                }
                if (!Success)
                {                           // Create DeviceRGB
                    Success = GetDeviceRGB (lpBuffer, lpcbSize, InpDrvClrSp, 0);
                    Success = FALSE;
                }
                break;
            case icSigCmykData:
                Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
                                                 InpDrvClrSp, (CSIG) InputIntent, 
                                                 TYPE_CIEBASEDDEFG, AllowBinary);
                if (Success)
                {                       // Create DeviceCMYK for the printer
                                        // which does not support CieBasedDEF(G).
                    DWORD cbNewSize = 0;
                    MEMPTR lpNewBuffer;
                    MEMPTR lpOldBuffer;
                    if (lpBuffer)
                    {
                        lpNewBuffer = lpBuffer + *lpcbSize;
                        lpOldBuffer = lpNewBuffer;
                        lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
                        lpNewBuffer += WriteNewLineObject (lpNewBuffer, NotSupportDEFG_S);
                        cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
                    } else
                        lpNewBuffer = NULL;

                    GetDeviceCMYK (lpNewBuffer, &cbNewSize, InpDrvClrSp);

                    if (lpBuffer)
                    {
                        lpNewBuffer += cbNewSize;
                        lpNewBuffer += WriteNewLineObject (lpNewBuffer, SupportDEFG_E);
                        *lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
                    } else
                        *lpcbSize += cbNewSize;
                }
                if (!Success)
                {                           // Create DeviceCMYK
                    Success = GetDeviceCMYK (lpBuffer, lpcbSize, InpDrvClrSp);
                    Success = FALSE;
                }
                break;
            case icSigGrayData:
                Success = GetPS2CSA_MONO (cp, lpBuffer, lpcbSize, InpDrvClrSp, 
                                          (CSIG)InputIntent, AllowBinary);
                if (!Success)
                {                           // Create DeviceGray
                    Success = GetDeviceGray (lpBuffer, lpcbSize, InpDrvClrSp);
                    Success = FALSE;
                }
                break;
            case icSigLabData:
                Success = GetPS2CSA_DEFG_Intent (cp, lpBuffer, lpcbSize,
                                                 InpDrvClrSp, (CSIG) InputIntent, 
                                                 TYPE_CIEBASEDDEF, AllowBinary);
                if (Success)
                {                       // Create CieBasedABC or DeviceRGB
                                        // for the printer
                                        // which does not support CieBasedDEF(G).
                    DWORD cbNewSize = 0;
                    MEMPTR lpNewBuffer;
                    MEMPTR lpOldBuffer;
                    if (lpBuffer)
                    {
                        lpNewBuffer = lpBuffer + *lpcbSize;
                        lpOldBuffer = lpNewBuffer;
                        lpNewBuffer += WriteObject (lpNewBuffer, NewLine);
                        lpNewBuffer += WriteNewLineObject (lpNewBuffer, NotSupportDEFG_S);
                        cbNewSize = dwSaveSize - (DWORD) (lpNewBuffer - lpBuffer);
                    } else
                        lpNewBuffer = NULL;

                    GetPS2CSA_ABC_LAB (cp, lpNewBuffer, &cbNewSize,
                                        (CSIG)InputIntent, InpDrvClrSp, AllowBinary);

                    if (lpBuffer)
                    {
                        lpNewBuffer += cbNewSize;
                        lpNewBuffer += WriteNewLineObject (lpNewBuffer, SupportDEFG_E);
                        *lpcbSize += (DWORD) (lpNewBuffer - lpOldBuffer);
                    } else
                        *lpcbSize += cbNewSize;
                }
                if (!Success)
                {                           // Create CieBasedABC
                    Success = GetPS2CSA_ABC_LAB (cp, lpBuffer, lpcbSize,
                                         (CSIG)InputIntent, InpDrvClrSp, AllowBinary);
                }
                break;

            default:
                break;
        }
    }
    return Success;
}

---