/* initialize a PT for export * lock and return pointers to the header and fut * make the tables for the specified export format */ PTErr_t initExport ( KpHandle_t PTHdr, KpHandle_t PTData, PTType_t format, fut_hdr_p FAR* futHdrP, fut_p FAR* futP) { PTErr_t errnum = KCP_SUCCESS; fut_p fut; fut_hdr_p futHdr; KpInt32_t status; /* get fut pointer */ fut = fut_lock_fut ((KpHandle_t)PTData); if ( ! IS_FUT(fut)) { errnum = KCP_PTERR_2; goto GetOut; } /* get header pointer of checked in PT */ futHdr = (fut_hdr_p) lockBuffer (PTHdr); if (futHdr == NULL) { errnum = KCP_MEM_LOCK_ERR; goto GetOut; } if (format == PTTYPE_FUTF) { /* make fixed tables */ status = makeFutTblDat (fut); if (status != 1) { fut_free_tbldat (fut); errnum = KCP_INCON_PT; } } else { status = makeMftTblDat (fut); if (status != 1) { fut_free_mftdat (fut); errnum = KCP_INCON_PT; } } GetOut: if (errnum == KCP_SUCCESS) { *futP = fut; /* return pointers to caller */ *futHdrP = futHdr; } else { (void) unlockPT (PTHdr, fut); *futP = NULL; *futHdrP = NULL; } return errnum; }
/* TpFreeData frees all of the memory allocated for a fut. */ PTErr_t TpFreeData ( KpHandle_t PTData) { PTErr_t errnum = KCP_PTERR_2; fut_p fut; fut = fut_lock_fut ((KpHandle_t)PTData); if (IS_FUT(fut)) { fut_free (fut); errnum = KCP_SUCCESS; } return errnum; }
/* check the input and output data class of a PT * if a color space is known and the data class is not known, * set the data class to correspond to the color space */ void checkDataClass (PTRefNum_t PTRefNum) { KpInt32_t i1; KpHandle_t PTData; fut_p fut; fut_chan_p chan; fut_otbl_p otbl; PTDataClass_t iDataClass, oDataClass; iDataClass = getPTDataClass (PTRefNum, KCM_IN_SPACE); oDataClass = getPTDataClass (PTRefNum, KCM_OUT_SPACE); PTData = getPTData (PTRefNum); fut = fut_lock_fut (PTData); if ( ! IS_FUT(fut)) return; /* bummer */ checkInDataClass (iDataClass, fut->itbl); /* check the data class of each shared input table */ for (i1 = 0; i1 < FUT_NOCHAN; i1++) { chan = fut->chan[i1]; if (IS_CHAN(chan)) { checkInDataClass (iDataClass, chan->itbl); /* check the data class of each input table */ if (oDataClass != KCP_UNKNOWN) { /* check the data class of each output table */ otbl = chan->otbl; if ((IS_OTBL(otbl)) && (otbl->dataClass == KCP_UNKNOWN)) { otbl->dataClass = oDataClass; } } } } fut_unlock_fut (fut); }
/* gridDimValid determines whether the grid table dimensions are valid * for the format specified. If the dimensions are not valid then the * function attempts to create a * PT with the correct size grid tables. If it is successful the * PTRefNum of the resized PT is returned in the location pointed to by * resizePTRefNumP. If resizing is not required the value returned in * the location pointed to by resizePTRefNumP is 0. * * NOTE: If this function creates a resized PT, that PT is checked in. * it is the responsibility of the calling function to check out * that PT. */ static PTErr_t gridDimValid ( PTType_t format, PTRefNum_t PTRefNum, PTRefNum_p resizePTRefNumP) { KpHandle_t PTData; KpInt32_t inputChans, outputChans, LUTDimensions, dummy = 0; fut_p fut; PTErr_t retVal, error = KCP_SUCCESS; /* Assume no resizing */ if (NULL != resizePTRefNumP) { *resizePTRefNumP = 0; } /* Convert the PTRefNum to a fut */ PTData = getPTData (PTRefNum); fut = fut_lock_fut (PTData); if (fut == FUT_NULL) { return KCP_PTERR_2; } if ( ! IS_FUT (fut) ) { /* check for valid fut */ retVal = KCP_NOT_FUT; goto GetOut; } switch (format ) { #if !defined KCP_ICC_ONLY case PTTYPE_FUTF: /* may want to check if any of the grid dimensions exceed the max grid dimension, but for now accept any size */ break; #endif case PTTYPE_MAB1: case PTTYPE_MAB2: case PTTYPE_MBA1: case PTTYPE_MBA2: /* may want to check if any of the grid dimensions exceed the max grid dimension, but for now accept any size */ break; case PTTYPE_MFT1: case PTTYPE_MFT2: case PTTYPE_MFT2_VER_0: /* The grid dimensions must all be the same. If they are not then attempt to build a grid table where all the dimensions are the same. */ retVal = (PTErr_t) fut_mfutInfo (fut, &LUTDimensions, &inputChans, &outputChans, format, &dummy, &dummy, &dummy); if (1 != retVal) { if (-2 != retVal) { retVal = KCP_INVAL_GRID_DIM; goto GetOut; } else { KpInt32_t i1, newGridDims[FUT_NICHAN]; fut_p futresized; for (i1 = 0; i1 < FUT_NICHAN; i1++) { /* define new grid sizes */ newGridDims[i1] = LUTDimensions; } futresized = fut_resize (fut, newGridDims); /* resize the fut */ if (futresized == NULL) { retVal = KCP_NO_MEMORY; goto GetOut; } if (futresized == fut) { /* should not happen, probably fut_mfutInfo() error */ retVal = KCP_SYSERR_3; goto GetOut; } if (fut_to_mft (futresized) != 1) { /* convert to reference tables */ retVal = KCP_INCON_PT; goto GetOut; } retVal = fut2PT (&futresized, -1, -1, PTTYPE_CALCULATED, resizePTRefNumP); /* make into PT */ if (retVal == KCP_SUCCESS) { retVal = copyAllAttr (PTRefNum, *resizePTRefNumP); /* Copy all attributes to new PT */ if (retVal != KCP_SUCCESS) { PTCheckOut (*resizePTRefNumP); goto GetOut; } } } } break; default: retVal = KCP_INVAL_PTTYPE; } retVal = KCP_SUCCESS; GetOut: fut_unlock_fut (fut); return retVal; }
/* 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; }