/*--------------------------------------------------------------------
* DESCRIPTION
* Create an SpXform_t from a data block containing a PT using the
* default grid size. There is no RCS->LAB color space conversion.
* Used for importing the raw PT.
*
* AUTHOR
* mjb
*
* DATE CREATED
* September 27, 1995
*------------------------------------------------------------------*/
SpStatus_t KSPAPI SpXformCreateFromDataNC (
KpInt32_t Size,
KpLargeBuffer_t Data,
SpXform_t FAR *Xform)
{
SpStatus_t Status;
PTRefNum_t RefNum;
*Xform = NULL;
Status = SpXformLoadImp (Data, Size, NO_DT_ICC_TYPE, SpSigNone,
SpSigNone, &RefNum);
if (SpStatSuccess != Status)
return Status;
Status = SpXformFromPTRefNumNC (&RefNum, Xform);
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nSpXformCreateFromDataEx\n *Xform %x\n",*Xform);
kcpDiagLog (string); }
#endif
return Status;
}
fut_p
get_linlab_fut (KpInt32_t size,
double neutralInput,
PTDataClass_t iClass,
PTDataClass_t oClass)
{
fut_p futp;
KpInt32_t iomask, sizeArray[KCP_THIS_FUT_CHANS];
fut_ifunc_t ifunArray[KCP_THIS_FUT_CHANS] = {NULL, yzfun, yzfun};
fut_ofunc_t ofunArray[KCP_THIS_FUT_CHANS] = {ofun, ofun, ofun};
fData_t fData;
if (iClass) {} if (oClass) {}
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "get_linlab_fut\n size %d, neutralInput %f\n", size, neutralInput);
kcpDiagLog (string); }
#endif
iomask = FUT_IN(FUT_XYZ) | FUT_OUT(FUT_XYZ);
/* define neutral input position and grid point */
fData.neutralInput = neutralInput;
fData.neutralgrid = (double)(size / 2) / (double)(size - 1);
/* assume all dimensions are the same */
sizeArray[0] = size;
sizeArray[1] = size;
sizeArray[2] = size;
futp = constructfut (iomask, sizeArray, &fData.std, ifunArray, NULL, ofunArray,
iClass, oClass);
#if defined KCP_DIAG_LOG
saveFut (futp, "CP24.fut");
#endif
return (futp);
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Generate Colorant and Response Curve tags for the specified
* Xform data. This data is assumed to be a PT.
*
* AUTHOR
* lsh
*
* DATE CREATED
* April 15, 1994
*------------------------------------------------------------------*/
SpStatus_t KSPAPI SpXformCreateMatTags (
SpProfile_t Profile,
KpInt32_t DataSize,
KpLargeBuffer_t Data)
{
SpStatus_t Status;
PTRefNum_t RefNum;
SpHeader_t Hdr;
KpInt32_t SpDataType;
Status = SpProfileGetHeader (Profile, &Hdr);
if (SpStatSuccess != Status)
return Status;
if ((Hdr.Originator == SpSigOrgKodak1_Ver_0) ||
(Hdr.Originator == SpSigOrgKodak2_Ver_0)) {
SpDataType = KCM_ICC_TYPE_0;
}
else {
SpDataType = KCM_ICC_TYPE_1;
}
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nSpXformCreateMatTags\n Profile %x, DataSize %d, Data %x\n", Profile, DataSize, Data);
kcpDiagLog (string); }
#endif
Status = SpXformLoadImp (Data, DataSize,
SpDataType, Hdr.DataColorSpace, Hdr.InterchangeColorSpace, &RefNum);
if (SpStatSuccess != Status)
return Status;
Status = SpXformCreateMatTagsFromPT (Profile, RefNum);
PTCheckOut (RefNum);
return Status;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Create a duplicate of an existing transform.
*
* AUTHOR
* gbp
*
* DATE Modified
* 25 Jan 99
*------------------------------------------------------------------*/
SpStatus_t KSPAPI SpXformDuplicate (
SpXform_t srcXform,
SpXform_t FAR *dupXform)
{
SpStatus_t Status;
PTRefNum_t srcRefNum, dupRefNum;
PTErr_t PTStat;
*dupXform = NULL;
/* Get the PTRefNum for the transform */
Status = SpXformGetRefNum (srcXform, &srcRefNum);
if (SpStatSuccess != Status) {
return Status;
}
/* duplicate it by using PTCombine */
PTStat = PTCombine (0, srcRefNum, NULL, &dupRefNum);
if (KCP_SUCCESS != PTStat) {
return (SpStatusFromPTErr(PTStat));
}
/* build an SpXform_t from the RefNum */
if (SpStatSuccess == Status)
Status = SpXformFromPTRefNumImp (dupRefNum, dupXform);
/* free PT if SpXform_t not created */
if (SpStatSuccess != Status)
PTCheckOut (dupRefNum);
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nSpXformFromBufferDT\n *dupXform %x\n",*dupXform);
kcpDiagLog (string); }
#endif
return Status;
}
fut_p
constructfut ( KpInt32_t iomask,
KpInt32_p sizeArray,
fut_calcData_p fData,
fut_ifunc_p ifunArray,
fut_gfunc_p gfunArray,
fut_ofunc_p ofunArray,
PTDataClass_t iClass,
PTDataClass_t oClass)
{
fut_p futp;
KpInt32_t i1, imask, omask;
fut_itbl_p itbls[FUT_NICHAN] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
fut_gtbl_p gtbls[FUT_NOCHAN] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
fut_otbl_p otbls[FUT_NOCHAN] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
fut_ifunc_t ifun;
fut_gfunc_t gfun;
fut_ofunc_t ofun;
fData_t fDataL;
fut_calcData_p fDataP;
if (sizeArray == NULL) return NULL;
if (fData == NULL) {
fDataP = &fDataL.std;
}
else {
fDataP = fData;
}
imask = FUT_IMASK(iomask);
omask = FUT_OMASK(iomask);
#if defined KCP_DIAG_LOG
{KpChar_t string[256], str2[256];
KpInt32_t i1;
sprintf (string, "constructfut\n iomask %x, sizeArray[]", iomask);
for (i1 = 0; i1 < FUT_NICHAN; i1++) {
if ((FUT_BIT(i1) & imask) != 0) {
sprintf (str2, " %d", sizeArray[i1]);
strcat (string, str2);
}
}
sprintf (str2, ", fData %x, ifunArray %x, gfunArray %x, ofunArray %x, iClass %d, oClass %d\n",
fData, ifunArray, gfunArray, ofunArray, iClass, oClass);
strcat (string, str2);
kcpDiagLog (string);}
#endif
/* Compute shared input tables: */
for (i1 = 0; i1 < FUT_NICHAN; i1++) {
if ((imask & FUT_BIT(i1)) != 0) {
if ((ifunArray == NULL) || (ifunArray[i1] == NULL)) {
ifun = fut_irampEx;
fDataP = &fDataL.std;
if (iClass == KCP_VARIABLE_RANGE) {
fDataL.scale = KCP_16_TO_8_ENCODING;
}
else {
fDataL.scale = 1.0;
}
}
else {
ifun = ifunArray[i1];
}
fDataP->chan = i1; /* define the channel # */
itbls[i1] = fut_new_itblEx (KCP_REF_TABLES, iClass, sizeArray[i1], ifun, fDataP);
itbls[i1]->id = fut_unique_id ();
itbls[i1]->dataClass = iClass;
}
}
/* Compute grid tables and output tables: */
for (i1 = 0; i1 < FUT_NOCHAN; i1++) {
if ((omask & FUT_BIT(i1)) != 0) {
if ((gfunArray == NULL) || (gfunArray[i1] == NULL)) {
gfun = fut_grampEx;
}
else {
gfun = gfunArray[i1];
}
fDataP->chan = i1; /* define the channel # */
gtbls[i1] = fut_new_gtblEx (KCP_REF_TABLES, iomask, gfun, fDataP, sizeArray);
gtbls[i1]->id = fut_unique_id();
if ((ofunArray == NULL) || (ofunArray[i1] == NULL)) {
ofun = fut_orampEx;
fDataP = &fDataL.std;
if (oClass == KCP_VARIABLE_RANGE) {
fDataL.scale = KCP_8_TO_16_ENCODING;
}
else {
fDataL.scale = 1.0;
}
}
else {
ofun = ofunArray[i1];
}
otbls[i1] = fut_new_otblEx (KCP_REF_TABLES, oClass, ofun, fDataP);
otbls[i1]->id = fut_unique_id();
otbls[i1]->dataClass = oClass;
}
}
/* Assemble FuT: */
futp = fut_new (iomask, itbls, gtbls, otbls);
fut_free_tbls (FUT_NICHAN, (KpGenericPtr_t *)itbls);
fut_free_tbls (FUT_NOCHAN, (KpGenericPtr_t *)gtbls);
fut_free_tbls (FUT_NOCHAN, (KpGenericPtr_t *)otbls);
if (fut_to_mft (futp) != 1) { /* convert to reference tables */
fut_free (futp);
futp = NULL;
}
return (futp);
}
fut_p
fut_resize ( fut_p fut,
KpInt32_p sizeArray)
{
fut_p reSizedGtblFut = NULL, gtblFut = NULL, reSizedFut = NULL, identityFut = NULL;
KpInt32_t i1, i2, iomask, iiomask, imask, omask, sameDims;
fut_chan_p chan;
fut_itbl_p itbl, itbls[FUT_NICHAN];
fut_gtbl_p gtbls[FUT_NOCHAN];
fut_otbl_p otbls[FUT_NOCHAN];
#if defined KCP_DIAG_LOG
kcpDiagLog ("fut_resize\n");
#endif
if ( ! IS_FUT(fut)) {
return NULL;
}
for (i1 = 0; i1 < FUT_NICHAN; i1++) {
itbls[i1] = FUT_NULL_ITBL; /* init to null for freeing on error */
}
/* collect the gtbls from the source fut */
/* make sure that all the gtbls use the same itbls */
omask = 0;
for (i1 = 0, sameDims = 1; i1 < FUT_NOCHAN; i1++) {
chan = fut->chan[i1];
if (IS_CHAN(chan)) {
for (i2 = 0; i2 < FUT_NICHAN; i2++) {
itbl = fut->itbl[i2];
if (chan->itbl[i2] != itbl) { /* must be shared */
goto GetOut;
}
if (IS_ITBL(itbl)) {
if (itbl->size != sizeArray [i2]) {
sameDims = 0; /* not the same */
}
}
}
omask |= FUT_BIT(i1); /* resize this chan */
gtbls[i1] = chan->gtbl; /* collect gtbls */
}
else {
gtbls[i1] = NULL;
}
}
if (sameDims == 1) {
return fut; /* already the right size! */
}
imask = fut->iomask.in;
iomask = FUT_OUT(omask) | FUT_IN(imask);
/* make a new fut with these gtbls and identity itbls and otbls */
gtblFut = fut_new (iomask, NULL, gtbls, NULL);
if (gtblFut != NULL) {
/* make an identity fut with itbls that have the specified sizes */
iiomask = FUT_OUT(imask) | FUT_IN(imask);
identityFut = constructfut (iiomask, sizeArray, NULL, NULL, NULL, NULL, KCP_FIXED_RANGE, KCP_FIXED_RANGE);
if (identityFut != NULL) {
/* compose the new size fut with the gtbl fut */
reSizedGtblFut = fut_comp (gtblFut, identityFut, 0);
if (reSizedGtblFut != NULL) {
/* make a new fut with original itbls, ... */
for (i1 = 0; i1 < FUT_NICHAN; i1++) {
if ((imask & FUT_BIT(i1)) != 0) {
itbls[i1] = fut_copy_itbl (fut->itbl[i1]); /* copy (do not share!) original itbls */
if (itbls[i1] == NULL) {
goto GetOut;
}
makeMftiTblDat (itbls[i1]); /* convert to mft to remove grid size dependancy */
itbls[i1]->size = reSizedGtblFut->itbl[i1]->size; /* set new grid size */
fut_free_itbldat (itbls[i1], freeData); /* free fixed table, it has incorrect grid indices */
}
}
/* ... resized gtbls, and original otbls */
for (i1 = 0; i1 < FUT_NOCHAN; i1++) {
if ((omask & FUT_BIT(i1)) != 0) {
gtbls[i1] = reSizedGtblFut->chan[i1]->gtbl; /* collect resized gtbls */
otbls[i1] = fut->chan[i1]->otbl; /* and original otbls */
}
else {
gtbls[i1] = NULL;
otbls[i1] = NULL;
}
}
reSizedFut = fut_new (iomask, itbls, gtbls, otbls);
}
}
}
GetOut:
fut_free (reSizedGtblFut); /* free the intermediate futs */
fut_free (gtblFut);
fut_free (identityFut);
fut_free_tbls (FUT_NICHAN, (void **)itbls);
return (reSizedFut);
}
/***************************************************************************
* FUNCTION NAME
* SpXformBufferDT
*
* DESCRIPTION
* This function copies the PT associated with the PTRefNum in
* the Xform to the Address given. It will be in the format
* requested by the caller. The SpXform is NOT freed by this
* function.
*
*
***************************************************************************/
SpStatus_t KSPAPI SpXformToBufferDT(SpXform_t spXform,
KpUInt32_t LutType,
KpInt32_t SpDataType,
KpUInt32_t Datasize,
SpHugeBuffer_t pXformData)
{
PTRefNum_t refNum;
SpStatus_t spStatus;
KpUInt32_t PTDatasize;
PTErr_t PTStat;
KpUInt32_t MFType;
KpInt32_t KcmDataType;
spStatus = SpDTtoKcmDT (SpDataType, &KcmDataType);
if (spStatus != SpStatSuccess) {
return (spStatus);
}
/* Get the Color Processor PTRefNum of the SpXform */
spStatus = SpXformGetRefNum (spXform, &refNum);
if (SpStatSuccess != spStatus)
return spStatus;
/* determine type of transform to get */
switch (LutType) {
case SP_ICC_FUT:
MFType = PTTYPE_FUTF;
break;
case SP_ICC_MFT1:
MFType = PTTYPE_MFT1;
break;
case SP_ICC_MFT2:
if (KcmDataType == KCM_ICC_TYPE_0)
MFType = PTTYPE_MFT2_VER_0;
else
MFType = PTTYPE_MFT2;
break;
case SP_ICC_MAB1:
MFType = PTTYPE_MAB1;
break;
case SP_ICC_MAB2:
MFType = PTTYPE_MAB2;
break;
case SP_ICC_MBA1:
MFType = PTTYPE_MBA1;
break;
case SP_ICC_MBA2:
MFType = PTTYPE_MBA2;
break;
default:
return SpStatOutOfRange;
}
/* ask color processor for the size of the Transform */
PTStat = PTGetSizeF (refNum, MFType, (KpInt32_t FAR *)&PTDatasize);
if (KCP_SUCCESS != PTStat)
return SpStatusFromPTErr(PTStat);
if (PTDatasize > Datasize)
return SpStatBufferTooSmall;
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nSpXformToBufferDT\n spXform %x, PTRefNum %x",
spXform, pXformData);
kcpDiagLog (string); }
#endif
/* ask color processor for the Transform data */
PTStat = PTGetPTF(refNum, MFType,
Datasize, (PTAddr_t) pXformData);
return SpStatusFromPTErr(PTStat);
}
SpStatus_t KSPAPI SpXformToLutDT(SpXform_t Xform,
KpInt32_t SpDataType,
SpLut_t *Lut,
SpTransRender_t *WhichRender,
SpTransType_t *WhichTransform,
SpSig_t *SpaceIn,
SpSig_t *SpaceOut,
KpF15d16XYZ_t *HdrWhite,
KpF15d16XYZ_t *MedWhite,
KpUInt32_t *ChainIn,
KpUInt32_t *ChainOut)
{
SpHugeBuffer_t Buf;
char *LutBuf;
KpUInt32_t BufSize;
SpStatus_t Status;
SpXformData_t FAR *XformData;
KpInt32_t KcmDataType;
Status = SpDTtoKcmDT (SpDataType, &KcmDataType);
if (Status != SpStatSuccess) {
return (Status);
}
/* Set Up Private Structure to Populate */
XformData = lockBuffer ((KcmHandle)Xform);
if (NULL == XformData)
return SpStatBadXform;
/* Set Up Lut Size based on Lut Type and size */
switch ( XformData->LutType )
{
case SpTypeLut8:
XformData->LutSize = SP_ICC_MFT1;
break;
case SpTypeLut16:
XformData->LutSize = SP_ICC_MFT2;
break;
case SpTypeLutAB:
if ((XformData->LutSize == 0) ||
(XformData->LutSize == 16))
XformData->LutSize = SP_ICC_MAB2;
else
XformData->LutSize = SP_ICC_MAB1;
break;
case SpTypeLutBA:
if ((XformData->LutSize == 0) ||
(XformData->LutSize == 16))
XformData->LutSize = SP_ICC_MBA2;
else
XformData->LutSize = SP_ICC_MBA1;
break;
} /* end switch */
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nSpXformToLutDT\n Xform %x, PTRefNum %x, Lut %x",
Xform, XformData->PTRefNum, Lut);
kcpDiagLog (string); }
#endif
Status = SpXformGetDataFromCP (XformData->PTRefNum,
XformData->LutSize,
KcmDataType,
&BufSize,
&Buf);
if (Status != SpStatSuccess)
{
unlockBuffer ((KcmHandle)Xform);
return Status;
}
Lut->LutType = XformData->LutType;
/* Move past the tag and Reserved */
LutBuf = (char *)Buf;
LutBuf += 8;
Status = SpLutToPublic(LutBuf, Lut);
/* Clear White Points */
HdrWhite->X = MedWhite->X =
HdrWhite->Y = MedWhite->Y =
HdrWhite->Z = MedWhite->Z = 0;
if (Status == SpStatSuccess)
{
*WhichRender = XformData->WhichRender;
*WhichTransform = XformData->WhichTransform;
*SpaceIn = XformData->SpaceIn;
*SpaceOut = XformData->SpaceOut;
if (XformData->HdrWPValid) {
HdrWhite->X = XformData->HdrWtPoint.X;
HdrWhite->Y = XformData->HdrWtPoint.Y;
HdrWhite->Z = XformData->HdrWtPoint.Z;
}
if (XformData->MedWPValid) {
MedWhite->X = XformData->MedWtPoint.X;
MedWhite->Y = XformData->MedWtPoint.Y;
MedWhite->Z = XformData->MedWtPoint.Z;
}
*ChainIn = XformData->ChainIn;
*ChainOut = XformData->ChainOut;
}
SpFree(Buf);
unlockBuffer ((KcmHandle)Xform);
return Status;
}
/* PTGetPTF writes a PT to external memory in a variety of formats. */
PTErr_t
PTGetPTF ( PTRefNum_t PTRefNum,
PTType_t format,
KpInt32_t mBlkSize,
PTAddr_t PTAddr)
{
PTErr_t errnum, PTstatus;
KpHandle_t PTHdr, PTAttr, PTData;
KpFd_t fd;
KpInt32_t attrSize, resultSize, nBytes;
PTRefNum_t resizePTRefNum = 0, thePTRefNum;
KpChar_p memData;
errnum = getPTStatus (PTRefNum);
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) {
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nPTGetPTF\n PTRefNum %x, format %x, mBlkSize %d, PTAddr %x\n",
PTRefNum, format, mBlkSize, PTAddr);
kcpDiagLog (string);}
#endif
PTstatus = errnum;
/* verify the dimensions of the grid table are valid for the specified format. */
errnum = gridDimValid (format, PTRefNum, &resizePTRefNum);
if (errnum != KCP_SUCCESS) {
goto ErrOut1;
}
if (resizePTRefNum != 0) {
thePTRefNum = resizePTRefNum; /* resized PT made */
}
else {
thePTRefNum = PTRefNum; /* use original PT */
}
/* determine the size the resized PT */
errnum = PTGetSizeF (thePTRefNum, format, &resultSize);
if (errnum != KCP_SUCCESS) {
goto ErrOut1;
}
if (resultSize > mBlkSize) { /* PT may not be larger than the buffer size */
errnum = KCP_PT_BLOCK_TOO_SMALL;
goto ErrOut1;
}
PTAttr = getPTAttr (thePTRefNum);
PTHdr = getPTHdr (thePTRefNum);
PTData = getPTData (thePTRefNum);
/* initialize memory file manager to write the PT */
if (KpOpen (NULL, "m", &fd, NULL, (KpGenericPtr_t)PTAddr, mBlkSize) != KCMS_IO_SUCCESS) {
errnum = KCP_SYSERR_1;
goto ErrOut1;
}
attrSize = getAttrSize (PTAttr); /* get size of attributes */
errnum = TpWriteHdr (&fd, format, PTHdr, attrSize); /* write the header info */
if (errnum != KCP_SUCCESS) {
Kp_close (&fd);
goto ErrOut1;
}
#if !defined KCP_ICC_ONLY
switch (format) {
case PTTYPE_FUTF:
errnum = writeAttributes (&fd, PTAttr); /* write the attributes */
if (errnum != KCP_SUCCESS) {
break;
}
default:
break;
}
#endif
/* if PT active, write data to external format */
if (((PTstatus == KCP_PT_ACTIVE) || (PTstatus == KCP_SERIAL_PT)) && (errnum == KCP_SUCCESS)) {
errnum = TpWriteData (&fd, format, PTHdr, PTData);
}
(void) Kp_close (&fd);
/* if the result PT size is smaller than the memory block size
fill the end of the memory block with zeros */
nBytes = mBlkSize - resultSize;
if (nBytes > 0) {
memData = (KpChar_p)PTAddr + resultSize;
while (nBytes--) {
*memData++ = 0;
}
}
}
ErrOut1:
if (resizePTRefNum != 0) {
PTCheckOut (resizePTRefNum);
}
return (errnum);
}
/* PTActivate reads the PT data from an external memory block and
* sets up the technology specific PT memory structures. Before loading
* the PT, check to make sure that it matches the "checked in" info.
*/
PTErr_t
PTActivate( PTRefNum_t PTRefNum,
KpInt32_t mBlkSize,
PTAddr_t PTAddr)
{
PTErr_t errnum;
KpFd_t fd;
KpHandle_t PTHdr, PTData, PTHdr2;
fut_hdr_p futp;
#if !defined KCMS_NO_CRC
KpChar_t strCRCmade[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpChar_t strCRCfound[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpInt32_t crcAttrSize, crc32;
#endif
KpInt32_t attrSize;
PTType_t format;
errnum = getPTStatus (PTRefNum);
if (errnum != KCP_PT_INACTIVE) {
goto ErrOut1;
}
/* initialize memory file manager */
if (KpOpen (NULL, "m", &fd, NULL, (KpGenericPtr_t)PTAddr, mBlkSize) != KCMS_IO_SUCCESS) {
errnum = KCP_SYSERR_1;
goto ErrOut1;
}
/* read in the encoded header, verify that its the same as the original, then discard */
errnum = TpReadHdr (&fd, &PTHdr2, &format);
if (errnum != KCP_SUCCESS ) {
goto ErrOut2;
}
#if defined KCP_DIAG_LOG
{KpChar_t string[256];
sprintf (string, "\nPTActivate\n PTRefNum %x, mBlkSize %d, PTAddr %x, format %x\n",
PTRefNum, mBlkSize, PTAddr, format);
kcpDiagLog (string);}
#endif
/* get and save size of attributes */
futp = lockBuffer (PTHdr2);
attrSize = futp->idstr_len;
unlockBuffer (PTHdr2);
PTHdr = getPTHdr (PTRefNum); /* get the original PT header */
/* make sure the PT header and checkin info match */
errnum = TpCompareHdr (PTHdr, PTHdr2);
(void) TpFreeHdr (PTHdr2); /* free the header */
if (errnum != KCP_SUCCESS) { /* then check for an error in hdrVerify */
goto ErrOut2;
}
#if !defined KCP_ICC_ONLY
switch (format) {
case PTTYPE_FUTF: /* discard the attribute info */
if (Kp_skip (&fd, attrSize) != KCMS_IO_SUCCESS){ /* may have been setAttribute after checkin */
errnum = KCP_PTERR_3;
goto ErrOut2;
}
break;
default:
break;
}
#endif
errnum = TpReadData (&fd, format, PTRefNum, PTHdr, &PTData); /* get the PT data */
if (errnum == KCP_SUCCESS) {
if (PTMemTest () == 0) { /* enough memory to continue operations? */
errnum = KCP_NO_ACTIVATE_MEM;
goto ErrOut3;
}
#if !defined KCMS_NO_CRC
errnum = TpCalCrc (PTHdr, PTData, &crc32); /* calculate the CRC */
if (errnum == KCP_SUCCESS) {
KpItoa(crc32, strCRCmade);
crcAttrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = PTGetAttribute(PTRefNum, KCM_CRC, &crcAttrSize, strCRCfound);
if (errnum == KCP_INVAL_PTA_TAG) { /* if not present, just set it */
PTSetAttribute(PTRefNum, KCM_CRC, strCRCmade);
errnum = KCP_SUCCESS;
}
else {
/* if ((errnum == KCP_SUCCESS)*/ /* if present, must match */
/* && (strcmp (strCRCmade, strCRCfound) != 0)) { */
/* errnum = KCP_INCON_PT; */
/* goto ErrOut3; */
/* } */
}
}
#endif
}
if (errnum == KCP_SUCCESS) { /* Everything's OK, now activate */
makeActive (PTRefNum, PTData);
}
ErrOut2:
(void) Kp_close (&fd);
ErrOut1:
return (errnum);
ErrOut3:
(void) TpFreeData (PTData); /* Release the PT memory */
goto ErrOut2;
}
