/* calculate channel usage mask */ KpUInt32_t calcChanMask ( KpInt32_t dataType, KpInt32_t nAddr, PTCompDef_p addrList) { KpUInt32_t chanMask; KpInt32_t i1; chanMask = 0; if ( (dataType == KCM_USHORT_555) || (dataType == KCM_USHORT_565) || (dataType == KCM_R10G10B10) ) { /* single address, multiple channels */ if (addrList[0].addr != NULL) { chanMask = FUT_BIT(0) | FUT_BIT(1) | FUT_BIT(2); } } else { /* discrete channels */ for (i1 = 0; i1 < nAddr; i1++) { if (addrList[i1].addr != NULL) { chanMask |= FUT_BIT(i1); } } } return chanMask; }
/* create a new fut which has shared input tables and calculates the identity function */ fut_p fut_new_empty ( KpInt32_t ndim, KpInt32_p dim, KpInt32_t nchan, PTDataClass_t iClass, PTDataClass_t oClass) { fut_p fut; KpInt32_t iomask = 0, i1; if ((ndim > FUT_NICHAN) || (nchan > FUT_NOCHAN)) { return FUT_NULL; } for (i1 = 0; i1 < ndim; i1++) { iomask |= FUT_IN(FUT_BIT(i1)); } for (i1 = 0; i1 < nchan; i1++) { iomask |= FUT_OUT(FUT_BIT(i1)); } /* Compute shared input tables, grid tables, and output tables: */ fut = constructfut (iomask, dim, NULL, NULL, NULL, NULL, iClass, oClass); return (fut); }
/* fut_add_chan inserts a new output channel into a fut. * Unlike itbls, otbls, and gtbls, the channel structure is not sharable * and so the caller must not free the chan after this call. (If the * passed channel structure needs to be saved, use fut_copy_chan). * The iomask in this case simply tells which output channel is being * added, and if this channel already exists, an error (0) is returned. * * fut_add_chan is intended to be used in conjunction with fut_new_chan * to construct futs with independent input tables. It does not update * the list of common input tables as does fut_new and fut_defchan and * should not be mixed with calls to fut_defchan. */ KpInt32_t fut_add_chan (fut_p fut, KpInt32_t iomask, fut_chan_p chan) { KpInt32_t ochan; if ( ! IS_FUT(fut) || (chan != FUT_NULL_CHAN && ! IS_CHAN(chan)) ) { return (0); } /* get output channel no. */ ochan = FUT_CHAN ((KpInt32_t)FUT_OMASK(iomask)); /* prohibit redefinition of channel */ if ( ochan >= FUT_NOCHAN || fut->chan[ochan] != NULL) return (0); /* insert channel into fut */ fut->chan[ochan] = chan; fut->chanHandle[ochan] = (IS_CHAN(fut->chan[ochan])) ? fut->chan[ochan]->handle : FUT_NULL_HANDLE; /* update iomasks */ if ( IS_CHAN(chan) ) { fut->iomask.out |= FUT_BIT(ochan); fut->iomask.in |= chan->imask; } return (1); }
/* fut_new_gtbl creates a new grid table and optionally intializes it. * The input channels defined for the grid are specified in the input * channel mask portion of iomask. Each input defined must have a size * specified in a KpInt32_t array. * Gfun must be a pointer to a function accepting from zero to three * doubles (depending on values of sx, sy, and sz) in the range (0.0,1.0) * and returning a fut_gtbldat_t in the range (0,FUT_GRD_MAXVAL). * A pointer to the newly allocated table is returned if there were no * errors. (If gfun is NULL, the table is not initialized). */ fut_gtbl_p fut_new_gtblEx ( PTTableType_t tableType, KpInt32_t iomask, fut_gfunc_t gfun, fut_calcData_p data, KpInt32_p dimList) { fut_gtbl_p gtbl; KpInt32_t imask, i, dim_size, grid_size; /* get input mask */ imask = (KpInt32_t)FUT_IMASK(iomask); /* allocate grid table structure */ gtbl = fut_alloc_gtbl (); if ( gtbl == FUT_NULL_GTBL ) { DIAG("fut_new_gtblA: can't alloc grid table struct.\n", 0); return (FUT_NULL_GTBL); } /* get sizes from dimList */ grid_size = 1; for ( i=0; i<FUT_NCHAN; i++ ) { dim_size = (imask & FUT_BIT(i)) ? dimList[i] : 1; if ( dim_size <= 0 ) { dim_size = 1; /* make sure > 0 */ } gtbl->size[i] = (KpInt16_t)dim_size; grid_size *= (KpInt32_t)dim_size; } /* check for valid grid size */ if ( grid_size <= 0 || grid_size > FUT_GRD_MAX_ENT ) { DIAG("fut_new_gtblA: bad grid table size (%d).\n", grid_size); fut_free_gtbl(gtbl); return (FUT_NULL_GTBL); } gtbl->tbl_size = (KpInt32_t)grid_size * (KpInt32_t)sizeof(fut_gtbldat_t); /* allocate grid table */ if (tableType == KCP_PT_TABLES) { gtbl->refTbl = fut_alloc_gtbldat (gtbl); } else { gtbl->refTbl = fut_alloc_gmftdat (gtbl); } if ( gtbl->refTbl == NULL ) { DIAG("fut_new_gtblA: can't alloc grid table array.\n", 0); fut_free_gtbl(gtbl); return (FUT_NULL_GTBL); } /* compute the grid table entries */ if ( ! fut_calc_gtblEx (gtbl, gfun, data) ) { fut_free_gtbl(gtbl); return (FUT_NULL_GTBL); } return (gtbl); }
/* fut_defchan defines an output channel for a fut. Returns FALSE(0) if * the output channel is already defined (or fut is NULL), TRUE(1) * otherwise. The size of the grid table (if non-zero) must match those * of the corresponding input table. If they do not, the channel remains * undefined and FALSE is returned. * * If a required input table is missing, the table will be shared * with the corresponding one from the list of common itbls. If there * is no such table in the common list, a ramp table is created and * inserted into the common itbl list. * * Since fut_defchan is intended to be used for constructing futs with * shared input tables, if an input table is supplied that conflicts with * a table in the common list, an error occurs. */ KpInt32_t fut_defchan ( fut_p fut, KpInt32_t iomask, fut_itbl_p FAR* itbls, fut_gtbl_p gtbl, fut_otbl_p otbl) { fut_itbl_p itbl[FUT_NICHAN]; fut_chan_p chan; KpInt32_t imask, i, tIndex; /* check for valid fut */ if ( ! IS_FUT(fut)) { return (0); } /* get input mask */ imask = (KpInt32_t) FUT_IMASK(iomask); /* get args specified by imask */ for ( i=0, tIndex = 0; i < FUT_NICHAN; i++ ) { if ((itbls != NULL) && ((imask & FUT_BIT(i)) != 0)) { /* if itbl is in arglist, use it */ itbl[i] = (fut_itbl_p)itbls[tIndex++]; } else { /* use itbl from shared itbl list */ itbl[i] = fut->itbl[i]; } } chan = fut_new_chan ((KpInt32_t)(FUT_IN (FUT_ALLIN)), (fut_itbl_p FAR*)itbl, gtbl, otbl); if ( ! IS_CHAN(chan)) { return (0); } /* If fut_new_chan created a new itbl (ramp), add it to the * common list. However, if an itbl in the chan differs from * one in the common list, return an error. */ for ( i=0; i < FUT_NICHAN; i++ ) { if ( chan->itbl[i] == NULL ) { continue; } if ( ! IS_ITBL(fut->itbl[i])) { fut->itbl[i] = fut_share_itbl(chan->itbl[i]); fut->itblHandle[i] = chan->itblHandle[i]; } else { if ( fut->itbl[i] != chan->itbl[i] ) { DIAG("fut_defchan: conflicting itbls.\n", 0); fut_free_chan (chan); return (0); } } } /* insert channel into fut */ if ( ! fut_add_chan (fut, iomask, chan) ) { fut_free_chan (chan); return (0); } return (1); }
/* fut_new_chan allocates and initializes a fut_chan_t data structure. * If a required input table is missing, a ramp of the proper grid size * will be created. If a supplied itbl is not required, it will not be * inserted into the channel's private itbl list. All tables which are * actually used are copied and so the caller is responsible for * freeing the passed tables if necessary. * * If VARARGS is used, the list of input tables may be relaced by a * single array of fut_itbl_t pointers. This array must then be followed * by a fut_gtbl_p and a fut_otbl_p. */ fut_chan_p fut_new_chan ( KpInt32_t iomask, fut_itbl_p FAR* itbls, fut_gtbl_p gtbl, fut_otbl_p otbl) { fut_itbl_p itbl[FUT_NCHAN]; fut_chan_p chan; KpInt32_t imask, i, tIndex; /* get input mask */ imask = (KpInt32_t)FUT_IMASK(iomask); /* get args specified by imask */ for ( i=0, tIndex = 0; i<FUT_NCHAN; i++ ) { itbl[i] = ((imask & FUT_BIT(i)) && (itbls != NULL)) ? itbls[tIndex++] : NULL; } /* allocate and clear the fut_chan_t structure */ chan = fut_alloc_chan (); if ( ! IS_CHAN(chan)) { return (NULL); } /* check for valid grid and output tables */ if (( ! IS_GTBL(gtbl)) || ((otbl != NULL) && ( ! IS_OTBL(otbl))) ) { DIAG("fut_new_chan: invalid grid or output table.\n", 0); fut_free_chan (chan); return (NULL); } /* get required input channels from gtbl */ chan->imask = fut_gtbl_imask(gtbl); /* insert the required input tables */ for ( i=0; i<FUT_NICHAN; i++ ) { if ( (chan->imask & FUT_BIT(i)) == 0 ) continue; if ( itbl[i] == FUT_NULL_ITBL ) { chan->itbl[i] = fut_new_itblEx (KCP_REF_TABLES, KCP_FIXED_RANGE, gtbl->size[i], fut_irampEx, NULL); if ( chan->itbl[i] == NULL) { DIAG("fut_new_chan: can't create itbl.\n",0); fut_free_chan (chan); return (NULL); } chan->itblHandle[i] = chan->itbl[i]->handle; } else { if ( ! IS_ITBL (itbl[i])) { DIAG("fut_new_chan: invalid input table.\n", 0); fut_free_chan (chan); return (NULL); } else { if ( itbl[i]->size != gtbl->size[i] ) { DIAG("fut_new_chan: gtbl-itbl size mismatch.\n", 0); fut_free_chan (chan); return (NULL); } else { chan->itbl[i] = fut_share_itbl(itbl[i]); /* share the input table */ chan->itblHandle[i] = chan->itbl[i]->handle; } } } } /* insert grid and output tables */ chan->gtbl = fut_share_gtbl (gtbl); chan->gtblHandle = (IS_GTBL(chan->gtbl)) ? chan->gtbl->handle : FUT_NULL_HANDLE; if (IS_OTBL(otbl)) { chan->otbl = fut_share_otbl (otbl); } else { chan->otbl = fut_alloc_otbl(); } chan->otblHandle = (IS_OTBL(chan->otbl)) ? chan->otbl->handle : FUT_NULL_HANDLE; return (chan); }
/* 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_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); }
/* fut_comp_ilut composes a set of 8 or 12-bit, 256 element look-up tables * with the input tables of a fut. These may have been derived from * another separable fut. A new fut is returned which shares grid and * output tables with the original but has new input tables. * * Iomask usage: * imask => luts defined in vararglist to be composed with itbls. * A NULL imask indicates one lut which is composed with * the first defined input table. * omask => unused * pmask => unused * INPLACE may be set to perform the composition in place, * replacing the existing itbls and returning a pointer * to the original fut. * VARARGS may be used to specify an array of luts. * 12BITS if set, supplied luts are 12-bit data (KpInt16_t). * Otherwise, they are 8-bit (KpUInt8_t). */ fut_p fut_comp_ilut ( fut_p fut, KpInt32_t iomask, KpGenericPtr_t FAR* srcluts) { KpChar_p luts[FUT_NICHAN]; KpInt32_t i, i2; KpInt32_t imask; KpInt32_t is_12bits; KpInt32_t in_place; fut_p new_fut; fut_itbl_p new_itbl; fut_itbl_p orig_itbls[FUT_NICHAN]; if ( ! IS_FUT(fut) ) return (FUT_NULL); /* unpack input mask. If zero, use first defined channel */ imask = (KpInt32_t)FUT_IMASK(iomask); if (imask == 0 ) { imask = (KpInt32_t)FUT_BIT(fut_first_chan((KpInt32_t)fut->iomask.in)); iomask |= FUT_IN(imask); } /* get args specified by iomask */ for ( i=0, i2 = 0; i<FUT_NICHAN; i++ ) { if (imask & FUT_BIT(i)) { luts[i] = srcluts[i2]; /* save lut address in array */ i2++; } } /* if INPLACE is not set, create a new fut which shares all of its tables */ in_place = (KpInt32_t)FUT_IPMASK(iomask); if ( in_place ) { new_fut = fut; } else { new_fut = fut_copy (fut); } /* unpack 12bit data flag */ is_12bits = (KpInt32_t)FUT_12BMASK(iomask); /* for each lut passed, compose it with the specified input table(s) */ /* start by composing the common itbls */ for ( i=0; i<FUT_NICHAN; i++) { /* save original itbls for future comparison */ orig_itbls[i] = fut->itbl[i]; /* if no lut or no itbl, there's nothing to do. */ if ( luts[i] == 0 || fut->itbl[i] == FUT_NULL_ITBL ) continue; /* compose itbl with fut and replace the existing one. */ new_itbl = fut_comp_itbl_ilut (fut->itbl[i], luts[i], is_12bits); if ( new_itbl == FUT_NULL_ITBL ) { if ( ! in_place ) fut_free (new_fut); return (FUT_NULL); } fut_free_itbl (new_fut->itbl[i]); new_fut->itbl[i] = new_itbl; } /* now compose the itbls in each chan, re-sharing if possible */ for ( i=0; i<FUT_NOCHAN; i++) { if ( new_fut->chan[i] == FUT_NULL_CHAN ) continue; if ( ! fut_comp_chan_ilut (new_fut->chan[i], (KpChar_p FAR*)luts, orig_itbls, new_fut->itbl, is_12bits) ) { if ( ! in_place ) { fut_free (new_fut); } return (FUT_NULL); } } return (new_fut); }
fut_p fut_comp (fut_p fut1, fut_p fut0, KpInt32_t iomask) { KpInt32_t ok = 1, nGridPoints, omask, evalomask, imask, pmask, order, i, j, nEntries, nOutChans; fut_p fut2 = NULL, evalFut = NULL; fut_itbl_p oitbls[FUT_NICHAN]; mf2_tbldat_p indat[FUT_NICHAN], outdat[FUT_NOCHAN]; fut_gtbl_p fut1_gtbls[FUT_NOCHAN]; if (( ! IS_FUT(fut0)) || ( ! IS_FUT(fut1))) { return (NULL); } /* extract component masks from iomask */ omask = FUT_OMASK(iomask); /* which output chans? */ pmask = FUT_PMASK(iomask); /* which ones allowed to pass through? */ order = FUT_ORDMASK(iomask); /* which interpolation to use? */ if ( order == FUT_DEFAULT ) { order = fut1->iomask.order; } /* adjust masks for iomask_check below */ pmask &= fut0->iomask.out; /* available for "pass through" */ if ( omask == 0 ) { /* required outputs (0 means all) */ omask = fut1->iomask.out; } /* see if fut0 can provide required inputs to fut1 */ imask = fut0->iomask.out; /* available inputs for fut1 */ iomask = FUT_OUT(omask) | FUT_IN(imask) | FUT_PASS(pmask); if ( ! fut_iomask_check (fut1, iomask) ) { return (NULL); } /* make sure the futs are in the reference state */ if ((fut_to_mft (fut0) != 1) || (fut_to_mft (fut1) != 1)) { return (NULL); } /* fut1 will be used to process the grid tables of fut0, placing the * results in the grid tables of fut2. Fut0's grid table data must first * be passed through its output tables before sending it through fut1's * input tables. This is accomplished more efficiently by composing * fut1's input tables with fut0's output tables and using these directly * on fut0 grid data rather than the normal input tables. * * Create the result fut (fut2) which will be the composition of fut1 * and fut0. Fut2 will inherit the input tables of fut0 and the output * tables of fut1. Its grid data will be in the same color coordinates * as fut1's. */ fut2 = fut_new (FUT_IN(FUT_ALLIN), fut0->itbl, NULL, NULL); if ( fut2 == NULL ) { return (NULL); } /* for each desired channel i in fut2, create a new grid table. The * dimensions of each new grid table are derived from fut0 and fut1 * like so: for every input required for channel i of fut1, form the * union of the input sets of all corresponding fut0 outputs. */ /* null all io tables and table pointers */ KpMemSet (oitbls, 0, sizeof(oitbls)); imask = 0; /* will be the input mask for all inputs needed to fut1 */ evalomask = 0; /* omask for evaluation */ for (i = 0; (i < FUT_NOCHAN) && ok; i++) { KpInt32_t size[FUT_NICHAN]; fut_gtbl_p gtbl; KpInt32_t imask1, imask2; fut1_gtbls[i] = NULL; /* assume not needed */ if ((omask & FUT_BIT(i)) == 0) { /* is this output channel needed? */ continue; /* no */ } /* if a specified output is to be passed through from fut0, do that here */ if ( ! IS_CHAN(fut1->chan[i]) && IS_CHAN(fut0->chan[i])) { ok = fut_defchan (fut2, FUT_OUT(FUT_BIT(i)), NULL, fut0->chan[i]->gtbl, fut0->chan[i]->otbl); continue; /* no need to evaluate this ochan */ } if (! IS_CHAN(fut1->chan[i])) { ok = 0; /* something wrong */ goto GetOut; } /* At this point we know that (fut1->chan[i] != 0). We also * have determined (from iomask_check above) that fut0->chan[j] != 0. */ imask2 = 0; /* determine inputs from fut0 needed for this channel */ imask1 = fut1->chan[i]->imask; /* inputs used by this chan */ for (j = 0; (j < FUT_NICHAN) && ok; j++) { if ((imask1 & FUT_BIT(j)) != 0) { /* this input chan is needed */ if ( ! IS_CHAN(fut0->chan[j])) { /* available? */ ok = 0; /* composition fails */ goto GetOut; } if (fut1->itbl[j] != fut1->chan[i]->itbl[j]) { /* shared itbl? */ goto nextOChan; /* nope, ignore this ochan */ } imask2 |= fut0->chan[j]->imask; } } evalomask |= FUT_BIT(i); /* will be evalutating this channel */ imask |= imask1; /* build mask of all needed inputs */ /* determine required dimensions from mask */ for (j = 0; j < FUT_NICHAN; j++) { size[j] = (imask2 & (KpInt32_t)FUT_BIT(j)) ? fut0->itbl[j]->size : 1; } /* create the new grid table * insert it along with fut1's output table into fut2 */ gtbl = fut_new_gtblEx (FUT_IN(FUT_ALLIN), NULL, NULL, size); ok = fut_defchan (fut2, FUT_OUT(FUT_BIT(i)), NULL, gtbl, fut1->chan[i]->otbl); fut_free_gtbl (gtbl); if (!ok) { goto GetOut; } fut1_gtbls[i] = fut1->chan[i]->gtbl; /* collect gtbls for evaluation fut */ /* verify the input data for the evaluation of the output channel in fut1 */ for (j = 0; j < FUT_NICHAN; j++) { if ((imask1 & FUT_BIT(j)) != 0) { /* this channel needed as input */ if ((fut0->chan[j]->imask & (~fut2->chan[i]->imask)) != 0) { /* it's inputs must be used by output */ ok = 0; /* composition fails */ goto GetOut; } } } nextOChan:; } /* collect the gtbls which are the input data for the chan evaluation. * also pre-compose fut0's otbls with fut1's itbls. */ for (i = 0; i < FUT_NICHAN; i++) { oitbls[i] = NULL; if (ok) { fut_chan_p theChan = fut0->chan[i]; if ((imask & FUT_BIT(i)) == 0) { continue; /* this output from fut0 not required */ } indat[i] = theChan->gtbl->refTbl; /* collect gtbls: the input data for the evaluation */ ok = (indat[i] != NULL); /* allocate memory for composed i/o tables * these have the same size as the output tables of the channel supplying the input */ if (ok) { fut_itbl_p theITbl = fut1->itbl[i]; fut_otbl_p theOTbl = theChan->otbl; oitbls[i] = fut_alloc_itbl (); /* get an itbl */ oitbls[i]->size = theITbl->size; oitbls[i]->dataClass = KCP_FIXED_RANGE; nEntries = MAX(theITbl->refTblEntries, theOTbl->refTblEntries); ok = (fut_alloc_imftdat (oitbls[i], nEntries) != NULL); if (ok) { /* make input table for evaluation */ ok = fut_comp_iotblMF (theITbl, theOTbl, oitbls[i]); } } } } /* make an evaluation fut with the composed I/O tables, fut1's gtbls, and no otbls */ evalFut = fut_new (iomask, oitbls, fut1_gtbls, NULL); if (( ! ok) || (evalFut == NULL) || /* if evaluation fut ok */ (fut_to_mft (fut2) != 1)) { /* make sure the futs are in the reference state */ ok = 0; goto GetOut; } else { /* Finally, we are ready to pass fut0's grid tables through fut1 */ for (i = 0, nOutChans = 0; (i < FUT_NOCHAN) && ok; i++) { if ((evalomask & FUT_BIT(i)) != 0) { fut_gtbl_p gtbl; gtbl = fut2->chan[i]->gtbl; nGridPoints = gtbl->tbl_size / sizeof (fut_gtbldat_t); /* grid points for eval */ if (evalFut->iomask.in != evalFut->chan[i]->imask) { /* must evaluate this channel singly */ evalomask &= ~FUT_BIT(i); /* remove channel from multiple eval list */ ok = evaluateFut (evalFut, FUT_BIT(i), KCM_USHORT, nGridPoints, (KpGenericPtr_t FAR*) indat, (KpGenericPtr_t FAR*) &(gtbl->refTbl)); } else { outdat[nOutChans] = gtbl->refTbl; nOutChans++; } } } /* eval result is composed fut's gtbls */ ok = evaluateFut (evalFut, evalomask, KCM_USHORT, nGridPoints, (KpGenericPtr_t FAR*) indat, (KpGenericPtr_t FAR*) outdat); } GetOut: /* must always free up the evaluation fut and io tables, even if an error occurred! */ fut_free (evalFut); fut_free_tbls (FUT_NICHAN, (void *)oitbls); /* check for errors */ if ( !ok ) { fut_free (fut2); fut2 = NULL; } return (fut2); }
/* Determine whether or not temporary memory is needed */ static PTErr_t setupEvalList ( KpUInt32_t numPTs, PTTable_p* evalList, KpUInt32_p ioMaskList, PTEvalDTPB_p evalDef, KpUInt32_p tempMemNeeded) { PTErr_t PTErr = KCP_SUCCESS; KpInt32_t i1, i2; KpInt32_t finalOutputs, nOutputs, maxOutputs; KpUInt32_t thisOmask, thisImask; KpInt32_t sizeInData, sizeOutData; fut_chan_p futChan; thisOmask = calcChanMask (evalDef->dataTypeO, evalDef->nOutputs, evalDef->output); /* calculate final output mask */ finalOutputs = calcChans (thisOmask); /* and number of output channels */ /* does the fut have those outputs? */ if ((FFUTP(evalList[numPTs -1]->data)->iomask.out & thisOmask) != thisOmask) { PTErr = KCP_INVAL_EVAL; goto ErrOut; } nOutputs = finalOutputs; /* # outputs of fut at the end of the list */ maxOutputs = 0; /* none yet */ for (i1 = (numPTs -1); i1 >= 0; i1--) { if (nOutputs > maxOutputs) { /* remember max # outputs needed */ maxOutputs = nOutputs; } /* get inputs required for this fut as determined by outputs required from this fut */ thisImask = 0; for (i2 = 0; i2 < FUT_NOCHAN; i2++) { if (thisOmask & FUT_BIT(i2)) { /* is this output channel needed? */ futChan = FCHANP(FFUTP(evalList[i1]->data)->chanHandle[i2]); /* get pointer to chan */ thisImask |= (KpUInt32_t)FUT_CHAN_IMASK(futChan); /* include inputs required for this chan */ } } ioMaskList [i1] = FUT_OUT(thisOmask) | FUT_IN(thisImask); /* store the evaluation I/O mask */ /* set up outputs for preceeding fut in the list */ thisOmask = thisImask; /* which are inputs to this fut */ nOutputs = calcChans (thisOmask); /* get number of output channels */ } thisImask = calcChanMask (evalDef->dataTypeI, evalDef->nInputs, evalDef->input); /* calculate input mask for the first fut */ /* does the first fut have the required inputs? */ if ((thisImask & FFUTP(evalList[0]->data)->iomask.in) != FFUTP(evalList[0]->data)->iomask.in) { PTErr = KCP_INVAL_EVAL; goto ErrOut; } /* Is temporary memory required? */ /* If just one PT, then temporary data memory is not needed */ /* if more than one PT (serial evaluation), then the number and size of the outputs */ /* determines whether or not temporary memory is needed */ PTErr = getDataBytes (evalDef->dataTypeI, &sizeInData); /* get input data size */ if (PTErr != KCP_SUCCESS) { goto ErrOut; } PTErr = getDataBytes (evalDef->dataTypeO, &sizeOutData); /* get output data size */ if (PTErr != KCP_SUCCESS) { goto ErrOut; } if (numPTs == 1) { (*tempMemNeeded) = 0; /* not serial evaluation, no temporary data memory needed */ } else { /* serial evaluation */ /* does this require temporary memory? */ if ((maxOutputs > finalOutputs) || (sizeInData < 2) || (sizeOutData < 2)) { (*tempMemNeeded) = 1; /* yes */ } else { (*tempMemNeeded) = 0; /* no */ } } ErrOut: return PTErr; }