/* use PTRefNum1 and PTRefNum2 to propagate attributes to PTRefNumR */
PTErr_t ComposeAttrFut( PTRefNum_t PTRefNum1,
PTRefNum_t PTRefNum2,
PTRefNum_t PTRefNumR)
{
PTErr_t errnum = KCP_SUCCESS;
KpInt8_t strInSpace[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpInt8_t strOutSpace[KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpInt32_t inspace, outspace, attrSize;
/* get 1st PT */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = PTGetAttribute(PTRefNum1, KCM_SPACE_OUT, &attrSize, strOutSpace);
if (errnum == KCP_SUCCESS) {
outspace = KpAtoi(strOutSpace);
/* get 2nd PT */
attrSize = KCM_MAX_ATTRIB_VALUE_LENGTH;
errnum = PTGetAttribute(PTRefNum2, KCM_SPACE_IN, &attrSize, strInSpace);
if (errnum == KCP_SUCCESS) {
inspace = KpAtoi(strInSpace);
if ((outspace == KCM_UNKNOWN) && (inspace != KCM_UNKNOWN)) {
errnum = moveAttrList (PTRefNum2, 0, propIAttrF, 0, PTRefNumR);
if (errnum == KCP_SUCCESS) {
errnum = moveAttrList (PTRefNum2, 0, propOAttrF, 0, PTRefNumR);
}
return (errnum);
}
else {
if ((outspace != KCM_UNKNOWN) && (inspace == KCM_UNKNOWN)) {
errnum = moveAttrList (PTRefNum1, 0, propIAttrF, 0, PTRefNumR);
if (errnum == KCP_SUCCESS) {
errnum = moveAttrList (PTRefNum1, 0, propOAttrF, 0, PTRefNumR);
}
return (errnum);
}
}
}
}
errnum = moveAttrList (PTRefNum1, 0, propIAttrF, 0, PTRefNumR); /* propagate "input" attributes */
if (errnum == KCP_SUCCESS) {
errnum = moveAttrList (PTRefNum2, 0, propOAttrF, 0, PTRefNumR); /* propagate "output" attributes */
}
return (errnum);
}
/*--------------------------------------------------------------------
* DESCRIPTION
* This function obtains the number of input and output
* channels of a PT
*
* AUTHOR
* PGT
*
* DATE CREATED
* May 11, 1994
*--------------------------------------------------------------------*/
static PTErr_t
getNumChans ( PTRefNum_t RefNum,
KpInt32_p numOutChan,
KpInt32_p numInVar)
{
KpInt32_t attrib[FUT_NOCHAN] = {KCM_NUM_VAR_1_IN, KCM_NUM_VAR_2_IN, KCM_NUM_VAR_3_IN,
KCM_NUM_VAR_4_IN, KCM_NUM_VAR_5_IN, KCM_NUM_VAR_6_IN, KCM_NUM_VAR_7_IN, KCM_NUM_VAR_8_IN};
KpInt32_t i, nOutChan;
PTErr_t PTErr;
KpChar_t AttrValue [10];
KpInt32_t AttrSize;
/* get number of output variables and the number of input variables for each output variable */
AttrSize = sizeof (AttrValue);
PTErr = PTGetAttribute (RefNum, KCM_NUM_VAR_OUT, &AttrSize, AttrValue);
if (PTErr != KCP_SUCCESS) {
return PTErr;
}
nOutChan = KpAtoi (AttrValue);
*numOutChan = nOutChan;
if (nOutChan > FUT_NOCHAN) {
nOutChan = FUT_NOCHAN;
}
for (i = 0; i < nOutChan; i++) {
AttrSize = sizeof (AttrValue);
PTErr = PTGetAttribute(RefNum, attrib[i], &AttrSize, AttrValue);
if (KCP_SUCCESS != PTErr) {
numInVar [i] = 0;
}
else {
numInVar [i] = KpAtoi (AttrValue);
}
}
return KCP_SUCCESS;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Get the number of input and output channels for a Transform.
*
* AUTHOR
* mjb
*
* DATE CREATED
* October 17, 1995
*------------------------------------------------------------------*/
SpStatus_t KSPAPI SpXformGetChannels (
SpXform_t Xform,
KpInt32_t FAR *In,
KpInt32_t FAR *Out)
{
PTRefNum_t refNum;
KpChar_t attribute [KCM_MAX_ATTRIB_VALUE_LENGTH+1];
KpInt32_t inChans, outChans, temp, size, attribId, index;
SpStatus_t spStatus;
PTErr_t ptErr;
/* Get the PTRefNum for the transform */
spStatus = SpXformGetRefNum (Xform, &refNum);
if (SpStatSuccess != spStatus) {
return spStatus;
}
/* Start by determining the number of output channels */
size = sizeof (attribute);
ptErr = PTGetAttribute (refNum, KCM_NUM_VAR_OUT, &size, attribute);
if (KCP_SUCCESS != ptErr) {
return SpStatBadXform;
}
outChans = KpAtoi (attribute);
/* Check that we didn't exceed the maximum output channels */
if (outChans > SpMaxComponents) {
return SpStatBadXform;
}
/* For each output channel get the number of input channels.
The number of input channels must be the same for each
output channel. */
inChans = -1;
for (index = 0, attribId = KCM_NUM_VAR_1_IN; index < outChans;
index++, attribId++) {
size = sizeof (attribute);
ptErr = PTGetAttribute (refNum, attribId, &size, attribute);
if (KCP_SUCCESS != ptErr) {
return SpStatBadXform;
}
temp = KpAtoi (attribute);
if (-1 == inChans) {
inChans = temp;
}
else {
if (temp != inChans) {
return SpStatBadXform;
}
}
}
/* return the number of input and output channels */
*In = inChans;
*Out = outChans;
return SpStatSuccess;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* This function checks to determine if the PT can be inverted
*
* AUTHOR
* PGT
*
* DATE CREATED
* May 11, 1994
*--------------------------------------------------------------------*/
static KpBool_t
InvertOk ( PTRefNum_t RefNum,
KpInt32_t senseAttrib)
{
KpInt32_t sense;
KpInt32_t invertAttrib;
PTErr_t PTErr;
KpChar_t AttrValue [10];
KpInt32_t AttrSize;
/* See if the attribute is the right type */
switch (senseAttrib) {
case KCM_MEDIUM_SENSE_IN:
invertAttrib = KCM_SENSE_INVERTIBLE_IN;
break;
case KCM_MEDIUM_SENSE_OUT:
invertAttrib = KCM_SENSE_INVERTIBLE_OUT;
break;
default:
return KPFALSE;
}
/* If the sense attribute is not in this PT, then this PT cannot be
* inverted for that sense because it is a color space for which
* inverting is not appropriate (e.g., RCS) */
AttrSize = sizeof(AttrValue);
PTErr = PTGetAttribute (RefNum, senseAttrib, &AttrSize, AttrValue);
if (PTErr != KCP_SUCCESS) {
return KPFALSE;
}
sense = KpAtoi (AttrValue);
if (KCM_UNKNOWN == sense) {
return KPFALSE;
}
/* Make sure that the PT is allowed to be inverted:
* if the attribute KCM_SENSE_INVERTIBLE==KCM_IS_INVERTIBLE
* if KCM_SENSE_INVERTIBLE is missing and KCM_CLASS==KCM_OUTPUT_CLASS */
AttrSize = sizeof(AttrValue);
PTErr = PTGetAttribute (RefNum, invertAttrib, &AttrSize, AttrValue);
/* If attribute not set, OK to invert */
if (PTErr == KCP_SUCCESS) {
switch ( KpAtoi (AttrValue)) {
case KCM_IS_NOT_INVERTIBLE:
return KPFALSE;
case KCM_IS_INVERTIBLE:
return KPTRUE;
}
}
AttrSize = sizeof(AttrValue);
PTErr = PTGetAttribute (RefNum, KCM_CLASS, &AttrSize, AttrValue);
if (PTErr != KCP_SUCCESS) {
return KPFALSE;
}
if (KCM_OUTPUT_CLASS == KpAtoi(AttrValue)) {
return KPTRUE;
}
return KPFALSE;
}
