/* 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;
}
/* fut_new allocates and initializes a new fut_t data structure.
* iomask specifies which (common) input tables and which output channels
* are being defined. Additional channels may be added later using
* fut_defchan.
*
* NOTES:
* 1. All the tables must be packed into a single array.
*
* 2. If a needed input table is not supplied (as determined from the
* grid table) or if a supplied input table is NULL, then a ramp
* input table will be automatically generated and inserted into
* the common itbl list. The grid sizes are inferred from the
* supplied grid tables.
*/
fut_p
fut_new ( KpInt32_t iomask,
fut_itbl_p FAR* itbls,
fut_gtbl_p FAR* gtbls,
fut_otbl_p FAR* otbls)
{
fut_itbl_p itbl[FUT_NICHAN];
fut_otbl_p otbl[FUT_NOCHAN];
fut_gtbl_p gtbl[FUT_NOCHAN];
fut_p fut;
KpInt32_t tIndex, imask, omask, i;
/* get input and output masks */
imask = (KpInt32_t)FUT_IMASK(iomask);
omask = (KpInt32_t)FUT_OMASK(iomask);
if ( imask > FUT_ALLIN || omask > FUT_ALLOUT ) {
DIAG("fut_new: too many input or output channels.\n", 0);
return (NULL);
}
/* get args specified by iomask */
for ( i=0, tIndex = 0; i<FUT_NICHAN; i++ ) {
itbl[i] = (((imask & FUT_BIT(i)) != 0) && (itbls != NULL))
? itbls[tIndex++] : FUT_NULL_ITBL;
}
for ( i=0, tIndex = 0; i<FUT_NOCHAN; i++ ) {
gtbl[i] = FUT_NULL_GTBL;
otbl[i] = FUT_NULL_OTBL;
if ((omask & FUT_BIT(i)) != 0) {
if (gtbls != NULL) {
gtbl[i] = gtbls[tIndex];
}
if (otbls != NULL) {
otbl[i] = otbls[tIndex];
}
tIndex++;
}
}
/* allocate and clear the fut_t structure */
fut = fut_alloc_fut ();
if ( fut == NULL ) {
return (NULL);
}
/* set the interpolation order */
fut->iomask.order = (KpInt32_t)FUT_ORDMASK(iomask);
/* insert the specified input tables */
for ( i=0; i<FUT_NICHAN; i++ ) {
if ( itbl[i] == NULL) continue;
if ( ! IS_ITBL (itbl[i]) ) {
fut_free (fut);
return (NULL);
}
fut->iomask.in |= FUT_BIT(i);
fut->itbl[i] = fut_share_itbl(itbl[i]);
fut->itblHandle[i] = fut->itbl[i]->handle;
}
/* define the specified output channels */
for ( i=0; i<FUT_NOCHAN; i++ ) {
if ( gtbl[i] == NULL) continue;
if ( ! fut_defchan(fut,FUT_OUT(FUT_BIT(i)),NULL,gtbl[i],otbl[i]) ) {
fut_free (fut);
return (NULL);
}
}
fut->lutConfig = LUT_TYPE_UNKNOWN;
return (fut);
}
/* fut_copy copies an existing fut.
*/
fut_p
fut_copy (fut_p fut)
{
fut_p new_fut;
KpInt32_t i;
KpHandle_t h;
if ( ! IS_FUT(fut)) {
return (0);
}
/* allocate basic fut_structure */
new_fut = fut_alloc_fut ();
if ( new_fut == FUT_NULL ) {
return (FUT_NULL);
}
/* save handle before copying over old fut */
h = new_fut->handle;
/* copy over all data (including pointers */
*new_fut = *fut;
/* now copy back handle */
new_fut->handle = h;
/* copy id string */
new_fut->idstr = 0;
/* (void) fut_set_idstr (new_fut, fut->idstr); */
/* copy input tables */
for ( i=0; i<FUT_NICHAN; i++ ) {
new_fut->itbl[i] = (IS_SHARED (fut->itbl[i])) ?
fut_share_itbl (fut->itbl[i]) : fut_copy_itbl (fut->itbl[i]);
new_fut->itblHandle[i] = getHandleFromPtr((KpGenericPtr_t)new_fut->itbl[i]);
}
/* copy output channels */
for ( i=0; i<FUT_NOCHAN; i++ ) {
new_fut->chan[i] = fut_copy_chan (fut->chan[i]);
new_fut->chanHandle[i] = getHandleFromPtr((KpGenericPtr_t)new_fut->chan[i]);
}
/* now check that all copies were succesful */
if ( new_fut->idstr == 0 && fut->idstr != 0 ) {
goto ErrOut;
}
for ( i=0; i<FUT_NICHAN; i++ ) {
if ( new_fut->itbl[i] == 0 && fut->itbl[i] != 0) {
goto ErrOut;
}
}
for ( i=0; i<FUT_NOCHAN; i++ ) {
if ( new_fut->chan[i] == 0 && fut->chan[i] != 0) {
goto ErrOut;
}
}
for ( i=0; i<FUT_NMCHAN; i++ ) { /* free extra reference tables */
if (NULL != fut->mabInRefTblHandles[i])
{
new_fut->mabInTblEntries[i] = fut->mabInTblEntries[i];
new_fut->mabInRefTbl[i] = (mf2_tbldat_p)
allocBufferPtr (new_fut->mabInTblEntries[i] * sizeof (mf2_tbldat_t));
KpMemCpy (new_fut->mabInRefTbl[i], fut->mabInRefTbl[i],
new_fut->mabInTblEntries[i] * sizeof (mf2_tbldat_t));
new_fut->mabInRefTblHandles[i] = getHandleFromPtr ((KpGenericPtr_t)new_fut->mabInRefTbl[i]);
}
if (NULL != fut->mabOutRefTblHandles[i])
{
new_fut->mabOutTblEntries[i] = fut->mabOutTblEntries[i];
new_fut->mabOutRefTbl[i] = (mf2_tbldat_p)
allocBufferPtr (new_fut->mabOutTblEntries[i] * sizeof (mf2_tbldat_t));
KpMemCpy (new_fut->mabOutRefTbl[i], fut->mabOutRefTbl[i],
new_fut->mabOutTblEntries[i] * sizeof (mf2_tbldat_t));
new_fut->mabOutRefTblHandles[i] = getHandleFromPtr ((KpGenericPtr_t)new_fut->mabOutRefTbl[i]);
}
}
return (new_fut);
ErrOut:
fut_free (new_fut);
return (FUT_NULL);
}
