/* propagate a list of attributes */
PTErr_t moveAttrList ( PTRefNum_t PTRefNum1, PTRefNum_t PTRefNum2,
KpInt32_p attrList, KpInt32_t hasSimAttr, PTRefNum_t PTRefNumR)
{
PTErr_t errnum = KCP_SUCCESS;
KpHandle_t startR1AttrList = NULL, startR2AttrList = NULL;
KpInt32_t i1;
KpInt32_t attrSize;
KpChar_t attribute[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
errnum = getPTStatus (PTRefNum1);
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) {
startR1AttrList = getPTAttr (PTRefNum1);
}
errnum = getPTStatus (PTRefNum2);
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) {
startR2AttrList = getPTAttr (PTRefNum2);
}
for (i1 = 0; attrList[i1] != ATTR_LIST_END; i1++) {
errnum = KCP_FAILURE;
if (startR1AttrList != NULL) {
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = GetAttribute (startR1AttrList, attrList[i1], &attrSize, attribute);
}
if ((errnum != KCP_SUCCESS) && (startR2AttrList != NULL)) { /* try for default attribute */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = GetAttribute (startR2AttrList, attrList[i1], &attrSize, attribute);
}
if (errnum == KCP_SUCCESS) {
errnum = PTSetAttribute(PTRefNumR, attrList[i1], attribute); /* write to destination PT */
}
if (hasSimAttr == 1) {
if (errnum == KCP_INVAL_PTA_TAG) { /* try for backup attribute */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; /* read attribute */
errnum = GetAttribute (startR2AttrList, attrList[i1+1], &attrSize, attribute);
if (errnum == KCP_SUCCESS) { /* write to destination PT */
errnum = PTSetAttribute (PTRefNumR, attrList[i1], attribute);
}
}
i1++; /* skip past backup attribute */
}
if ((errnum != KCP_INVAL_PTA_TAG) && (errnum != KCP_SUCCESS)) {
return (errnum);
}
}
return KCP_SUCCESS;
}
PTErr_t
initAttrib (PTRefNum_t PTRefNum)
{
PTErr_t errnum = KCP_SUCCESS;
KpInt32_t attrSize, year;
KpChar_t attrBuf[KCM_MAX_ATTRIB_VALUE_LENGTH+1], yearStr[10];
kpTm_t currentTime;
/* If the copyright string isn't there, then generate it */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = PTGetAttribute (PTRefNum, KCM_COPYRIGHT, &attrSize, attrBuf);
if (errnum == KCP_INVAL_PTA_TAG) {
KpGetLocalTime(¤tTime); /* get the current time, which has the current year */
year = currentTime.year + 1900; /* add 1900 to get the actual year */
KpItoa (year, yearStr);
strcpy (attrBuf, FUT_COPYRIGHT_PREFIX); /* make the copyright string. */
strcat (attrBuf, yearStr);
strcat (attrBuf, FUT_COPYRIGHT_SUFFIX);
errnum = PTSetAttribute (PTRefNum, KCM_COPYRIGHT, attrBuf);
}
return errnum;
}
/* if composition mode is input set input attribute to "is linearized" */
static PTErr_t setLinearized (PTRefNum_t PTRefNumR, KcmAttribute attrTag)
{
PTErr_t PTErr;
KpChar_t attrStr[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpItoa (KCM_IS_LINEARIZED, attrStr);
PTErr = PTSetAttribute (PTRefNumR, attrTag, attrStr);
return (PTErr);
}
/* Generate attributes which must be in each PT */
static PTErr_t generateAttr (PTRefNum_t PTRefNumR)
{
PTErr_t PTErr;
KpChar_t attrStr[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
kpTm_t Date;
KpGetLocalTime (&Date); /* get the current date and time */
KpItoa ((KpInt32_t) (1900 + Date.year), attrStr); /* start with year */
addIntStr ((KpInt32_t)Date.mon, attrStr); /* month */
addIntStr ((KpInt32_t)Date.mday, attrStr); /* day */
addIntStr ((KpInt32_t)Date.hour, attrStr); /* hour */
addIntStr ((KpInt32_t)Date.min, attrStr); /* minute */
addIntStr ((KpInt32_t)Date.sec, attrStr); /* second */
PTErr = PTSetAttribute (PTRefNumR, KCM_CREATE_TIME, attrStr); /* write time to destination PT */
if (PTErr == KCP_SUCCESS) {
KpItoa (KCM_COMPOSED_CLASS, attrStr);
PTErr = PTSetAttribute (PTRefNumR, KCM_CLASS, attrStr); /* set composition state to composed */
}
return (PTErr);
}
/* Set KCM_EFFECT_TYPE attribute, which use a default if the attribute is
* present in both PTs but with different values */
static PTErr_t setEFFECTstate (PTRefNum_t PTRefNum1, PTRefNum_t PTRefNum2,
PTRefNum_t PTRefNumR)
{
KpChar_t attrStr[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpChar_t attrStr1[KCM_MAX_ATTRIB_VALUE_LENGTH+1], attrStr2[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
PTErr_t PTErr, errnum1, errnum2;
KpInt32_t attrSize;
PTErr = KCP_FAILURE; /* attribute not yet written */
KpItoa (KCM_EFFECT_MULTIPLE, attrStr); /* initialize to default */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; /* get attribute from 1st PT */
errnum1 = PTGetAttribute (PTRefNum1, KCM_EFFECT_TYPE, &attrSize, attrStr1);
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH; /* get attribute from 2nd PT */
errnum2 = PTGetAttribute (PTRefNum2, KCM_EFFECT_TYPE, &attrSize, attrStr2);
if (errnum1 == KCP_SUCCESS) {
if ((errnum2 != KCP_SUCCESS) || /* if attribute is not in 2nd */
(strcmp (attrStr1, attrStr2) == 0)) { /* or attribute values are the same */
strcpy (attrStr, attrStr1); /* use attribute in 1st PT */
}
}
else {
if (errnum2 == KCP_SUCCESS) { /* if attribute is in 2nd */
strcpy (attrStr, attrStr2); /* use it */
}
else {
PTErr = KCP_SUCCESS; /* not in either PT, do not write attribute */
}
}
if (PTErr != KCP_SUCCESS) { /* write to destination PT */
PTErr = PTSetAttribute (PTRefNumR, KCM_EFFECT_TYPE, attrStr);
}
return (PTErr);
}
/* TpReadData reads a fut from a memory block and returns a handle to a newly allocated fut
*/
PTErr_t
TpReadData( KpFd_p fd,
PTType_t format,
PTRefNum_t PTRefNum,
KpHandle_t PTHdr,
KpHandle_t FAR* PTData)
{
PTErr_t errnum;
fut_p fut = NULL, theFutFromMatrix = NULL, newFut = NULL, lab2xyzFut = NULL, finalFut = NULL;
fut_hdr_p futHdr;
Fixed_t matrix[MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM];
KpInt32_t ret, iomask;
KpChar_t ENUM_String[20];
KpInt32_t inCS, i, i1;
ResponseRecord_t inRedTRC, inGreenTRC, inBlueTRC;
ResponseRecord_t outRedTRC, outGreenTRC, outBlueTRC;
PTRefNum_t matrixPTRefNum;
PTDataClass_t iClass, oClass;
futHdr = (fut_hdr_p) lockBuffer (PTHdr); /* get buffer pointer */
if (futHdr == NULL) {
errnum = KCP_MEM_LOCK_ERR;
goto GetOut;
}
futHdr->profileType = getIntAttrDef (PTRefNum, KCM_ICC_PROFILE_TYPE);
futHdr->spaceIn = getIntAttrDef (PTRefNum, KCM_SPACE_IN);
futHdr->spaceOut = getIntAttrDef (PTRefNum, KCM_SPACE_OUT);
futHdr->iDataClass = getDataClass (futHdr->spaceIn);
futHdr->oDataClass = getDataClass (futHdr->spaceOut);
switch (format) {
case FUT_CIGAM: /* fut with bytes reversed */
case FUT_MAGIC: /* fut with bytes in correct order */
if ((fut = fut_alloc_fut ()) == NULL) { /* allocate a new fut structure */
errnum = KCP_NO_ACTIVATE_MEM;
}
else {
if (fut_read_tbls (fd, fut, futHdr) != 1) { /* read fut tables */
errnum = KCP_PT_DATA_READ_ERR;
}
else {
if (fut_io_decode (fut, futHdr) == 0) {
errnum = KCP_PTERR_0;
}
else {
errnum = KCP_SUCCESS;
}
}
}
break;
case PTTYPE_MFT1:
case PTTYPE_MFT2:
fut = fut_readMFutTbls (fd, futHdr, matrix); /* read matrix fut tables */
if (fut == NULL) {
errnum = KCP_NO_ACTIVATE_MEM;
}
else {
inCS = getIntAttrDef (PTRefNum, KCM_SPACE_IN);
if ((inCS == KCM_CIE_XYZ) && (isIdentityMatrix (matrix, MF_MATRIX_DIM) != 1)) {
ret = makeOutputMatrixXform ((Fixed_p)&matrix, 8, &theFutFromMatrix);
if (ret != 1) {
errnum = KCP_INCON_PT;
goto GetOut;
}
else {
iomask = FUT_PASS(FUT_XYZ); /* get the Lab to XYZ fut */
lab2xyzFut = get_lab2xyz (KCP_GRID_DIM_SIXTEEN);
newFut = fut_comp (theFutFromMatrix, lab2xyzFut, iomask);
if (newFut != NULL) {
finalFut = fut_comp (fut, newFut, iomask);
}
fut_free (theFutFromMatrix); /* free intermediate futs */
fut_free (lab2xyzFut);
fut_free (fut);
fut_free (newFut);
fut = finalFut;
/* set the input color space attribute to Lab */
KpItoa (KCM_CIE_LAB, ENUM_String);
errnum = PTSetAttribute (PTRefNum, KCM_SPACE_IN, ENUM_String);
if (errnum != KCP_SUCCESS) {
goto GetOut;
}
/* set the input composition attribute to Lab */
errnum = PTSetAttribute (PTRefNum, KCM_IN_CHAIN_CLASS_2, "6");
if (errnum != KCP_SUCCESS) {
goto GetOut;
}
}
}
if ((fut == NULL) || !fut_io_encode (fut, futHdr)) { /* make the info header */
errnum = KCP_INCON_PT;
goto GetOut;
}
errnum = KCP_SUCCESS;
}
break;
case PTTYPE_MA2B:
case PTTYPE_MB2A:
matrix[0] = matrix[4] = matrix[8] = KpF15d16FromDouble(1.0);
matrix[1] = matrix[2] = matrix[3] =
matrix[5] = matrix[6] = matrix[7] =
matrix[9] = matrix[10] = matrix[11] = KpF15d16FromDouble(0.0);
fut = fut_readMabFutTbls (fd, futHdr, matrix); /* read matrix fut tables */
if (fut == NULL) {
errnum = KCP_NO_ACTIVATE_MEM;
}
else {
if (fut->lutConfig & HAS_MATRIX_DATA) {
i = MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM;
for (i1 = 0; i1 < i; i1++)
{
fut->matrix[i1] = matrix[i1];
}
switch (fut->lutConfig) {
case MAB_M_MATRIX_B_COMBO:
case MBA_B_MATRIX_M_COMBO:
inRedTRC.CurveCount = fut->mabInTblEntries[0];
inGreenTRC.CurveCount = fut->mabInTblEntries[1];
inBlueTRC.CurveCount = fut->mabInTblEntries[2];
inRedTRC.CurveData = fut->mabInRefTbl[0];
inGreenTRC.CurveData = fut->mabInRefTbl[1];
inBlueTRC.CurveData = fut->mabInRefTbl[2];
outRedTRC.CurveCount = fut->mabOutTblEntries[0];
outGreenTRC.CurveCount = fut->mabOutTblEntries[1];
outBlueTRC.CurveCount = fut->mabOutTblEntries[2];
outRedTRC.CurveData = fut->mabOutRefTbl[0];
outGreenTRC.CurveData = fut->mabOutRefTbl[1];
outBlueTRC.CurveData = fut->mabOutRefTbl[2];
iClass = getDataClass(futHdr->spaceIn);
oClass = getDataClass(futHdr->spaceOut);
ret = makeFutFromMatrix ((Fixed_p)&matrix, &inRedTRC, &inGreenTRC, &inBlueTRC,
&outRedTRC, &outGreenTRC, &outBlueTRC, MATRIX_GRID_SIZE, iClass, oClass,
(fut_p *)&theFutFromMatrix);
break;
case MBA_B_MATRIX_M_CLUT_A_COMBO:
inRedTRC.CurveCount = fut->mabInTblEntries[0];
inGreenTRC.CurveCount = fut->mabInTblEntries[1];
inBlueTRC.CurveCount = fut->mabInTblEntries[2];
inRedTRC.CurveData = fut->mabInRefTbl[0];
inGreenTRC.CurveData = fut->mabInRefTbl[1];
inBlueTRC.CurveData = fut->mabInRefTbl[2];
iClass = getDataClass(futHdr->spaceIn);
oClass = KCP_UNKNOWN;
ret = makeFutFromMatrix ((Fixed_p)&matrix, &inRedTRC, &inGreenTRC, &inBlueTRC,
NULL, NULL, NULL, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix);
break;
case MAB_A_CLUT_M_MATRIX_B_COMBO:
outRedTRC.CurveCount = fut->mabOutTblEntries[0];
outGreenTRC.CurveCount = fut->mabOutTblEntries[1];
outBlueTRC.CurveCount = fut->mabOutTblEntries[2];
outRedTRC.CurveData = fut->mabOutRefTbl[0];
outGreenTRC.CurveData = fut->mabOutRefTbl[1];
outBlueTRC.CurveData = fut->mabOutRefTbl[2];
iClass = KCP_UNKNOWN;
oClass = getDataClass(futHdr->spaceOut);
ret = makeFutFromMatrix ((Fixed_p)&matrix, NULL, NULL, NULL, &outRedTRC, &outGreenTRC,
&outBlueTRC, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix);
break;
default:
break;
}
if (NULL != theFutFromMatrix)
{
/* Create a PT from the fut */
errnum = fut2PT (&theFutFromMatrix, KCM_UNKNOWN, KCM_UNKNOWN, PTTYPE_CALCULATED, &matrixPTRefNum);
if (errnum != KCP_SUCCESS) {
goto GetOut;
}
errnum = setMatrixPTRefNum (PTRefNum, matrixPTRefNum, fut->lutConfig);
if (errnum != KCP_SUCCESS) {
goto GetOut;
}
}
if (ret != 1) {
errnum = KCP_INCON_PT;
goto GetOut;
}
}
if ((fut == NULL) || !fut_io_encode (fut, futHdr)) { /* make the info header */
errnum = KCP_INCON_PT;
goto GetOut;
}
errnum = KCP_SUCCESS;
}
break;
default:
break;
}
GetOut:
if ((errnum != KCP_SUCCESS) || (fut == NULL)) {
fut_free (fut);
}
else { /* return handle to fut to caller */
/* make sure the futs are in the reference state */
if (fut_to_mft (fut) == 1) {
*PTData = (KpHandle_t)fut_unlock_fut (fut);
}
}
if ( ! unlockBuffer (PTHdr)) {
errnum = KCP_MEM_UNLOCK_ERR;
}
return errnum;
}
PTErr_t
TpSetImplicitAttr ( PTRefNum_t PTRefNum)
{
KpChar_t attribute[256];
PTErr_t errnum;
fut_hdr_p futHdr;
chan_hdr_p chan;
KpInt32_t i1, i2, attributeTag, numOutVar, numInVar[FUT_NCHAN];
KpHandle_t PTHdr;
errnum = PTSetAttribute (PTRefNum, KCM_TECH_TYPE, KCM_FUT_S);
PTHdr = getPTHdr (PTRefNum); /* get the header info */
futHdr = (fut_hdr_p)lockBuffer (PTHdr);
if (futHdr != NULL) {
/* set the technology version attribute */
KpItoa (futHdr->version, attribute);
errnum = PTSetAttribute (PTRefNum, KCM_TECH_VERSION, attribute);
/* get the number of active output channels */
/* and the number of active inputs for each channel */
for (i1 = 0; i1 < FUT_NCHAN; i1++) {
numInVar[i1] = 0; /* zero out the number of inputs array */
}
numOutVar = 0; /* and # of outputs */
switch (futHdr->magic) {
case PTTYPE_MFT1:
case PTTYPE_MFT2:
case PTTYPE_MB2A:
case PTTYPE_MA2B:
numOutVar = futHdr->icode[1]; /* copy from header */
for (i1 = 0; i1 < numOutVar; i1++) {
numInVar[i1] = futHdr->icode[0];
}
break;
default: /* PTTYPE_FUTF */
for (i1 = 0, chan = futHdr->chan; i1 < FUT_NCHAN; i1++, chan++) {
if ((chan->gcode & FUTIO_CODE) != FUTIO_NULL) {
numOutVar++;
for (i2 = 0; i2 < FUT_NCHAN; i2++) {
if ((chan->icode[i2] & FUTIO_CODE) != FUTIO_NULL) {
(numInVar[i1])++;
}
}
}
}
break;
}
/* set the attribute for number of inputs for each channnel */
for (i1 = 0, attributeTag = KCM_NUM_IN_VAR_1; i1<FUT_NCHAN; i1++) {
if (numInVar[i1] != 0) {
KpItoa (numInVar[i1], attribute);
PTSetAttribute (PTRefNum, attributeTag, attribute);
attributeTag++;
}
}
/* set the number of output channnels attribute */
KpItoa (numOutVar, attribute);
errnum = PTSetAttribute (PTRefNum, KCM_NUM_OUT_VAR, attribute);
if ( ! unlockBuffer (PTHdr)) {
errnum = KCP_MEM_UNLOCK_ERR;
}
}
return errnum;
}
/* PTGetSizeF calculates the size of a PT in any format. */
PTErr_t
PTGetSizeF (PTRefNum_t PTRefNum,
PTType_t format,
KpInt32_p mBlkSize)
{
PTErr_t errnum, errnum1;
KpInt32_t extSize, intSize;
KpHandle_t PTHdr, PTData;
PTRefNum_t matrixPTRefNum;
KpUInt32_t lutConfig;
#if !defined KCP_ICC_ONLY
KpHandle_t PTAttr;
#endif
#if !defined KCMS_NO_CRC
KpChar_t strCRCmade[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpInt32_t crc32;
#endif
errnum = getPTStatus (PTRefNum);
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_PT_INACTIVE) || (errnum == KCP_SERIAL_PT)) {
if (mBlkSize == NULL)
return (KCP_BAD_PTR);
switch (format) {
#if !defined KCP_ICC_ONLY
case PTTYPE_FUTF:
extSize = KCP_PT_HEADER_SIZE; /* size of external header */
break;
#endif
case PTTYPE_MFT1:
case PTTYPE_MFT2:
case PTTYPE_MFT2_VER_0:
extSize = (2 * sizeof (KpInt32_t)) + (4 * sizeof (KpUInt8_t))
+ (MF_MATRIX_DIM * MF_MATRIX_DIM * sizeof (KpInt32_t));
break;
case PTTYPE_MAB1:
case PTTYPE_MAB2:
case PTTYPE_MBA1:
case PTTYPE_MBA2:
extSize = (7 * sizeof (KpInt32_t)) + (2 * sizeof (KpUInt8_t)) + sizeof (KpUInt16_t);
errnum1 = getMatrixPTRefNum (PTRefNum, &matrixPTRefNum, &lutConfig);
if (KCP_SUCCESS == errnum1)
{
extSize += ((MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM) * sizeof (KpInt32_t));
}
break;
default:
return (KCP_INVAL_PTTYPE);
}
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_SERIAL_PT)) {
/* when active, add size of external PT data block */
PTHdr = getPTHdr (PTRefNum);
PTData = getPTData (PTRefNum);
intSize = TpGetDataSize (PTHdr, PTData, format);
if (intSize == 0) {
PTRefNum_t resizePTRefNum;
/* TpGetDataSize will return 0 if the grid table
dimensions are not valid for the format specified.
PTGetPTF will attempt to resize the grid table of
the PT. Check if that resizing is possible */
errnum = gridDimValid (format, PTRefNum, &resizePTRefNum);
if (errnum != KCP_SUCCESS) {
return errnum;
}
/* Determine the size of the resized PT */
PTHdr = getPTHdr (resizePTRefNum);
PTData = getPTData (resizePTRefNum);
intSize = TpGetDataSize (PTHdr, PTData, format);
PTCheckOut (resizePTRefNum);
if (intSize == 0) {
return KCP_INCON_PT;
}
}
extSize += intSize; /* add size of data */
#if !defined KCMS_NO_CRC
switch (format) {
case PTTYPE_FUTF:
errnum = TpCalCrc (PTHdr, PTData, &crc32);
if (errnum == KCP_SUCCESS) {
KpItoa(crc32, strCRCmade);
PTSetAttribute(PTRefNum, KCM_CRC, strCRCmade);
}
break;
default:
break;
}
#endif
}
/* add size of attributes. Must be done after CRC calculation */
#if !defined KCP_ICC_ONLY
switch (format) {
case PTTYPE_FUTF:
PTAttr = getPTAttr (PTRefNum);
extSize += getAttrSize(PTAttr); /* plus size of attributes */
break;
default:
break;
}
#endif
*mBlkSize = extSize; /* return external size of PT */
errnum = KCP_SUCCESS;
}
return (errnum);
}
/* frees source fut on error */
PTErr_t
fut2PT (fut_p *futSrc,
KpInt32_t inSpace,
KpInt32_t outSpace,
KpInt32_t srcFormat,
PTRefNum_p PTRefNumNew)
{
PTErr_t PTErr;
fut_hdr_p PTHdr = NULL;
KpHandle_t PTHdrH = NULL, PTDataH = NULL;
KpChar_t colorSpaceAttr[20];
*PTRefNumNew = 0;
if ( ! IS_FUT(*futSrc)) goto ErrOut1;
PTHdr = allocBufferPtr (sizeof(fut_hdr_t)); /* get buffer for resultant info header */
if (PTHdr == NULL) {
goto ErrOut4;
}
if (!fut_io_encode (*futSrc, PTHdr)) { /* make the info header */
goto ErrOut3;
}
PTHdr->srcFormat = srcFormat;
PTDataH = fut_unlock_fut (*futSrc);
if (PTDataH == NULL) {
goto ErrOut2;
}
*futSrc = NULL;
PTHdrH = unlockBufferPtr (PTHdr); /* unlock the header buffer */
if (PTHdrH == NULL) {
goto ErrOut2;
}
PTHdr = NULL;
PTErr = registerPT (PTHdrH, NULL, PTRefNumNew); /* enter PT into list */
if (PTErr != KCP_SUCCESS) {
goto ErrOut0;
}
makeActive (*PTRefNumNew, PTDataH); /* activate the new PT */
if (inSpace != -1) { /* set the input color space attribute */
KpItoa (inSpace, colorSpaceAttr);
PTErr = PTSetAttribute (*PTRefNumNew, KCM_IN_SPACE, colorSpaceAttr);
}
if (outSpace != -1) { /* set the output color space attribute */
KpItoa (outSpace, colorSpaceAttr);
PTErr = PTSetAttribute (*PTRefNumNew, KCM_OUT_SPACE, colorSpaceAttr);
}
if (PTErr != KCP_SUCCESS) {
goto ErrOut0;
}
getOut:
return PTErr;
ErrOut4:
PTErr = KCP_NO_CHECKIN_MEM;
goto ErrOut0;
ErrOut3:
PTErr = KCP_ENCODE_PTHDR_ERR;
goto ErrOut0;
ErrOut2:
PTErr = KCP_MEM_UNLOCK_ERR;
goto ErrOut0;
ErrOut1:
PTErr = KCP_BAD_ARG;
ErrOut0:
if (PTDataH != NULL) {
*futSrc = fut_lock_fut (PTDataH);
}
if (*futSrc != FUT_NULL) fut_free (*futSrc);
if (PTHdr != NULL) freeBufferPtr (PTHdr);
if (PTHdrH != NULL) freeBuffer (PTHdrH);
if (*PTRefNumNew != 0) PTCheckOut (*PTRefNumNew);
goto getOut;
}
/* 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;
}
