/* 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;
}
/* deactivate a checked in PT */
PTErr_t PTDeActivate (PTRefNum_t PTRefNum)
{
PTErr_t errnum;
errnum = getPTStatus (PTRefNum); /* must currently be active */
if ((errnum == KCP_PT_ACTIVE) || (errnum == KCP_SERIAL_PT)) {
errnum = makeInActive (PTRefNum, KPTRUE); /* deactivate the PT */
if (KCP_PT_TABLE_DELETED == errnum)
{
errnum = KCP_SUCCESS;
}
}
return errnum;
}
/* 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);
}
/* 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);
}
/* 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;
}
PTErr_t
PTEvaluate ( PTRefNum_t PTRefNum,
PTEvalDTPB_p evalDef,
PTEvalTypes_t evalID,
KpInt32_t devNum,
KpInt32_t aSync,
opRefNum_p opRefNum,
callBack_p callBack)
{
PTErr_t PTErr;
PTEvalDTPB_t lEvalDef;
PTCompDef_t thisInput [FUT_NICHAN], thisOutput [FUT_NOCHAN];
PTRefNum_t PTList [MAX_PT_CHAIN_SIZE];
PTTable_p evalList [MAX_PT_CHAIN_SIZE], PTTableP;
PTTable_p* listStart;
KpInt32_t theSerialCount, i1, i2, i3, i4, nOutputs, nFuts, PTcount;
KpUInt32_t tempMemNeeded, oMask, ioMaskList [MAX_PT_CHAIN_SIZE];
PTImgAddr_t addr;
#if defined (KCP_ACCEL)
PTEvalTypes_t evaluator;
KpInt32_t numEvals;
#endif
if (devNum) {}
if (aSync) {}
if (opRefNum) {}
#if defined (KCP_MACPPC_MP)
KCPInitializeMP ();
#endif
PTErr = getPTStatus (PTRefNum); /* must be an active or serial PT */
if ((PTErr != KCP_PT_ACTIVE) && (PTErr != KCP_SERIAL_PT)) {
goto ErrOut0;
}
#if defined (KCP_ACCEL)
PTErr = GetEval (evalID, &evaluator); /* get an evaluator */
if (PTErr != KCP_SUCCESS) {
goto ErrOut0;
}
#endif
/* valid PTEvalDTPB_p? */
if (evalDef == NULL) goto ErrOut1;
if (evalDef->input == NULL) goto ErrOut1;
if (evalDef->output == NULL) goto ErrOut1;
if (evalDef->nInputs > FUT_NICHAN) goto ErrOut3;
if (evalDef->nOutputs > FUT_NOCHAN) goto ErrOut3;
/* set up the local evaluation structures */
/* set input and output to NULL */
/* this preserves the channel position while allowing */
/* the number of channels to indicate the number of valid addresses */
/* this is needed to keep both the CTE and SW evaluations happy */
for (i1 = 0; i1 < FUT_NICHAN; i1++) {
thisInput[i1].pelStride = 0;
thisInput[i1].lineStride = 0;
thisInput[i1].addr = NULL;
}
lEvalDef.nPels = evalDef->nPels;
lEvalDef.nLines = evalDef->nLines;
lEvalDef.nInputs = FUT_NICHAN;
lEvalDef.dataTypeI = evalDef->dataTypeI;
lEvalDef.input = thisInput;
for (i1 = 0; i1 < evalDef->nInputs; i1++) {
lEvalDef.input[i1].pelStride = evalDef->input[i1].pelStride;
lEvalDef.input[i1].lineStride = evalDef->input[i1].lineStride;
lEvalDef.input[i1].addr = evalDef->input[i1].addr;
}
/* output addresses are loaded in the evaluation loop, no need to do anything here */
/* clear the PT and evaluation lists, just for clarity */
for (i1 = 0; i1 < MAX_PT_CHAIN_SIZE; i1++) {
PTList[i1] = NULL;
evalList[i1] = NULL;
}
/* get the list of PTs which we must actually evaluate */
PTErr = resolvePTData (PTRefNum, &theSerialCount, PTList);
/* set up list of futs through which the image is evaluated */
for (i1 = 0; i1 < theSerialCount; i1++) {
PTTableP = lockPTTable (PTList[i1]); /* lock tables while evaluating */
evalList[i1] = PTTableP;
}
/* initialize the evaluation list */
PTErr = setupEvalList (theSerialCount, evalList, ioMaskList, evalDef, &tempMemNeeded);
if (PTErr != KCP_SUCCESS) {
goto ErrOut2;
}
/* if temporary memory is not needed, */
/* then evaluate a full image at a time until */
/* the image has been processed through all futs */
/* if temporary memory is needed, */
/* then this level processes the image just once */
/* and a lower level processes the image through all futs */
if (tempMemNeeded == 0) {
PTcount = theSerialCount;
}
else {
PTcount = 1;
}
initProgressPasses (PTcount, callBack);
/* process the image through each fut in the list */
for (i1 = 0; i1 < PTcount; i1++) {
/* set up the output data addresses */
/* use io mask to order output channels properly */
if (tempMemNeeded == 1) {
nFuts = theSerialCount; /* this many futs to evaluate */
listStart = &evalList[0];
oMask = FUT_OMASK(ioMaskList[nFuts-1]); /* use mask of last fut */
}
else {
nFuts = 1; /* evaluate one fut */
listStart = &evalList[i1];
oMask = FUT_OMASK(ioMaskList[i1]); /* use mask of this fut */
}
/* initialize the output data structures */
lEvalDef.nOutputs = FUT_NOCHAN;
lEvalDef.dataTypeO = evalDef->dataTypeO;
lEvalDef.output = thisOutput;
for (i2 = 0; i2 < FUT_NOCHAN; i2++) {
thisOutput[i2].pelStride = 0;
thisOutput[i2].lineStride = 0;
thisOutput[i2].addr = NULL;
}
/* set the output channel addresses */
if (i1 == (PTcount -1)) { /* last, just use supplied stuff */
for (i2 = 0, nOutputs = 0; i2 < evalDef->nOutputs; i2++) {
lEvalDef.output[i2].pelStride = evalDef->output[i2].pelStride;
lEvalDef.output[i2].lineStride = evalDef->output[i2].lineStride;
lEvalDef.output[i2].addr = evalDef->output[i2].addr;
nOutputs++; /* count actual outputs */
}
getDataBytes (evalDef->dataTypeO, &i3); /* get output data size */
if (i3 == 0) {
nOutputs = 3;
}
}
else {
for (i2 = oMask, i3 = 0, i4 = 0, nOutputs = 0; i2 != 0; i2 >>= 1, i3++) {
if ((i2 & 1) == 1) { /* this output channel is needed */
while ((addr = evalDef->output[i4].addr) == NULL) {
i4++; /* get next available output channel */
}
if (i4 > evalDef->nOutputs) {
PTErr = KCP_PTERR_4; /* programming error */
goto ErrOut2;
}
lEvalDef.output[i3].pelStride = evalDef->output[i4].pelStride;
lEvalDef.output[i3].lineStride = evalDef->output[i4].lineStride;
lEvalDef.output[i3].addr = addr;
i4++; /* next output address */
nOutputs++; /* count actual outputs */
}
}
}
#if defined (KCP_ACCEL)
/* if there are less than FASTER_IN_SW evaluations, it's faster to do it in software. */
numEvals = lEvalDef.nPels * lEvalDef.nLines * nOutputs;
if ((numEvals < FASTER_IN_SW) || (tempMemNeeded == 1)) {
evaluator = KCP_EVAL_SW;
}
switch (evaluator) {
case KCP_EVAL_SW: /* evaluate in software */
software_evaluation:
#endif
PTErr = PTEvalSeq (nFuts, listStart, ioMaskList, &lEvalDef, callBack);
if (PTErr != KCP_SUCCESS) {
goto ErrOut2;
}
#if defined (KCP_ACCEL)
break;
case KCP_EVAL_CTE: /* evaluate using the NFE */
{
PTRefNum_t thePTRefNum;
KpHandle_t PTData;
thePTRefNum = listStart[0]->refNum; /* get the PT reference number */
PTData = getPTData (thePTRefNum); /* get the transform data */
PTErr = PT_eval_cteDT (PTData, &lEvalDef, 0, 0, callBack);
if ((PTErr == KCP_CTE_GRID_TOO_BIG) || (PTErr == KCP_CTE_NOT_ATTEMPTED)) {
goto software_evaluation;
}
break;
}
default:
PTErr = KCP_INVAL_EVAL;
break;
}
#else
if (evalID) {} /* unreferenced formal parameter */
#endif
/* output for this PT is input for next PT */
lEvalDef.nInputs = lEvalDef.nOutputs;
lEvalDef.dataTypeI = lEvalDef.dataTypeO;
for (i2 = 0; i2 < lEvalDef.nInputs; i2++) {
lEvalDef.input[i2].pelStride = lEvalDef.output[i2].pelStride;
lEvalDef.input[i2].lineStride = lEvalDef.output[i2].lineStride;
lEvalDef.input[i2].addr = lEvalDef.output[i2].addr;
}
}
ErrOut2:
/* unlock the PTs used for evaluation */
for (i1 = 0; i1 < theSerialCount; i1++) {
unlockPTTable (PTList[i1]);
}
ErrOut0:
return (PTErr);
ErrOut1:
PTErr = KCP_BAD_PTR;
goto ErrOut0;
ErrOut3:
PTErr = KCP_INVAL_EVAL;
goto ErrOut0;
}
