CIccCalculatorFunc Class Reference

#include <IccMpeCalc.h>

Collaboration diagram for CIccCalculatorFunc:

Public Member Functions
	CIccCalculatorFunc (CIccMpeCalculator *pCalc)
	CIccCalculatorFunc (const CIccCalculatorFunc &ICF)
virtual	~CIccCalculatorFunc ()
virtual bool	Apply (CIccApplyMpeCalculator *pApply) const
virtual bool	Begin (const CIccMpeCalculator *pChannelMux, CIccTagMultiProcessElement *pMPE)
int	CheckUnderflowOverflow (SIccCalcOp *op, icUInt32Number nOps, int nArgs, bool bCheckUnderflow, std::string &sReport) const
virtual void	Describe (std::string &sDescription, int nVerboseness=0, int nBlanks=0)
bool	DoesOverflowInput (icUInt16Number nInputChannels) const
bool	DoesOverflowOutput (icUInt16Number nOutputChannels) const
icFuncParseStatus	DoesStackUnderflowOverflow (std::string &sReport) const
virtual const icChar *	GetClassName () const
icUInt32Number	GetMaxTemp () const
virtual icChannelFuncSignature	GetType () const
bool	HasUnsupportedOperations (std::string &sReport, const CIccProfile *pProfile) const
bool	HasValidOperations (std::string &sReport) const
bool	NeedTempReset (icUInt8Number *tempUsage, icUInt32Number nMaxTemp)
virtual CIccCalculatorFunc *	NewCopy () const
CIccCalculatorFunc &	operator= (const CIccCalculatorFunc &ICF)
virtual bool	Read (icUInt32Number size, CIccIO *pIO)
icFuncParseStatus	SetFunction (CIccCalcOpList &opList, std::string &sReport)
icFuncParseStatus	SetFunction (const char *szFuncDef, std::string &sReport)
bool	SetOpDefs ()
virtual icValidateStatus	Validate (std::string sigPath, std::string &sReport, const CIccMpeCalculator *pChannelCalc=NULL, const CIccProfile *pProfile=NULL) const
virtual bool	Write (CIccIO *pIO)

Protected Member Functions
bool	ApplySequence (CIccApplyMpeCalculator *pApply, icUInt32Number nOps, SIccCalcOp *op) const
void	DescribeSequence (std::string &sDescription, icUInt32Number nOps, SIccCalcOp *op, int nBlanks)
bool	InitSelectOp (SIccCalcOp *ops, icUInt32Number nOps)
bool	InitSelectOps ()
void	InsertBlanks (std::string &sDescription, int nBlanks)
const char *	ParseFuncDef (const char *szFuncDef, CIccCalcOpList &m_list, std::string &sReport)
bool	SequenceNeedTempReset (SIccCalcOp *op, icUInt32Number nOps, icUInt8Number *tempUsage, icUInt32Number nMaxTemp)

Protected Attributes
icUInt32Number	m_nOps
icUInt32Number	m_nReserved
SIccCalcOp *	m_Op
CIccMpeCalculator *	m_pCalc

Detailed Description

Class: CIccCalculatorFunc

Purpose: The Calculator function sequence

Constructor & Destructor Documentation

CIccCalculatorFunc() [1/2]

CIccCalculatorFunc::CIccCalculatorFunc

(

CIccMpeCalculator *

pCalc

)

Name: CIccCalculatorFunc::CIccCalculatorFunc

Purpose:

Args:

Return:

{
  m_pCalc = pCalc;
  m_nReserved = 0;
 
  m_nOps = 0;
  m_Op = NULL;
}

References m_nOps, m_nReserved, m_Op, and m_pCalc.

Referenced by CIccMpeCalculator::Read(), and CIccMpeCalculator::SetCalcFunc().

Here is the caller graph for this function:

CIccCalculatorFunc() [2/2]

CIccCalculatorFunc::CIccCalculatorFunc

(

const CIccCalculatorFunc &

func

)

Name: CIccCalculatorFunc::CIccCalculatorFunc

Purpose:

Args:

Return:

{
  m_pCalc = func.m_pCalc;
 
  m_nReserved= func.m_nReserved;
 
  m_nOps = func.m_nOps;
 
  if (m_nOps) {
    m_Op = (SIccCalcOp*)malloc(m_nOps * sizeof(SIccCalcOp));
    memcpy(m_Op, func.m_Op, m_nOps*sizeof(SIccCalcOp));
  }
  else
    m_Op = NULL;
}

References m_nOps, m_nReserved, m_Op, and m_pCalc.

Referenced by NewCopy().

Here is the caller graph for this function:

~CIccCalculatorFunc()

CIccCalculatorFunc::~CIccCalculatorFunc ( )

virtual

Name: CIccCalculatorFunc::~CIccChannelFunc

Purpose:

Args:

Return:

{
  if (m_Op) {
    free(m_Op);
  }
}

References m_Op.

Member Function Documentation

Apply()

bool CIccCalculatorFunc::Apply ( CIccApplyMpeCalculator *  pApply ) const

virtual

Name: CIccCalculatorFunc::Apply

Purpose:

Args:

Return:

{
  CIccFloatVector *pStack = pApply->GetStack();
 
  pStack->clear();
 
  if (!ApplySequence(pApply, m_nOps, m_Op)) {
    icFloatNumber *pOut = pApply->GetOutput();
    icUInt32Number i;
    for (i=0; i<m_pCalc->NumOutputChannels(); i++)
      pOut[i] = -1;
    return false;
  }
 
  return true;
}

References ApplySequence(), CIccApplyMpeCalculator::GetOutput(), CIccApplyMpeCalculator::GetStack(), m_nOps, m_Op, m_pCalc, and CIccMultiProcessElement::NumOutputChannels().

Referenced by CIccMpeCalculator::Apply().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplySequence()

bool CIccCalculatorFunc::ApplySequence ( CIccApplyMpeCalculator *  pApply, icUInt32Number  nOps, SIccCalcOp *  ops  ) const

protected

Name: CIccCalculatorFunc::ApplySequence

Purpose:

Args:

Return:

{
  SIccCalcOp *op;
  SIccOpState os;
 
  os.pApply = pApply;
  os.pStack = pApply->GetStack();
  os.pScratch = pApply->GetScratch();
  os.temp = pApply->GetTemp();
  os.pixel = pApply->GetInput();
  os.output = pApply->GetOutput();
  os.nOps = nOps;
 
  for (os.idx=0; os.idx<os.nOps; os.idx++) {
    op = &ops[os.idx];
 
    if (g_pDebugger)
      g_pDebugger->BeforeOp(op, os, ops);
 
    if (op->sig==icSigIfOp) {
      icFloatNumber a1;
      OsPopArg(a1);
 
      if (os.idx+1<nOps && ops[os.idx+1].sig==icSigElseOp) {
        os.idx++;
        if (a1>=0.5) {
          if (os.idx+1 + op->data.size >= nOps)
            return false;
 
          if (!ApplySequence(pApply, op->data.size, &ops[os.idx+1]))
            return false;
        }
        else {
          if (os.idx+1 + op->data.size + ops[os.idx].data.size > nOps)
            return false;
 
          if (!ApplySequence(pApply, ops[os.idx].data.size, &ops[os.idx+1 + op->data.size]))
            return false;
        }
        os.idx += op->data.size + ops[os.idx].data.size;
      }
      else {
        if (a1>=0.5) {
          if (os.idx+op->data.size >= nOps)
            return false;
 
          if (!ApplySequence(pApply, op->data.size, &ops[os.idx+1]))
            return false;
        }
        os.idx+= op->data.size;
      }
    }
    else if (op->sig==icSigSelectOp) {
      icFloatNumber a1;
      OsPopArg(a1);
      icInt32Number nSel = (a1 >= 0.0) ? (icInt32Number)(a1+0.5f) : (icInt32Number)(a1-0.5f);
 
      if (!op->extra) {
        return false;
      }
      
      icUInt32Number nDefOff = (icUInt32Number)(os.idx+1 + op->extra);
      if (nDefOff >= nOps)
        return false;
 
      if (nSel<0 || (icUInt32Number)nSel>=op->extra) {
 
        if (ops[nDefOff].sig==icSigDefaultOp) {
          if (os.idx+1 + ops[nDefOff].extra >= nOps)
            return false;
 
          if (!ApplySequence(pApply, ops[nDefOff].data.size, &ops[os.idx+1 + ops[nDefOff].extra]))
            break;
        }
      }
      else {
        icUInt32Number nOff = os.idx+1 + nSel;
 
        if (nOff >= nOps) 
          return false;
 
        if (!ApplySequence(pApply, ops[nOff].data.size, &ops[os.idx+1 + ops[nOff].extra]))
          break;
      }
 
      if (ops[nDefOff].sig==icSigDefaultOp) {
        if (os.idx+1 + ops[nDefOff].extra + ops[nDefOff].data.size >nOps)
          return false;
 
        os.idx = (icUInt32Number)(os.idx + ops[nDefOff].extra + ops[nDefOff].data.size);
      }
      else if (op->extra) {
        unsigned long nOff = os.idx + op->extra;
 
        if (os.idx+1 + ops[nOff].extra + ops[nOff].data.size > nOps)
          return false;
 
        os.idx = (icUInt32Number)(os.idx + ops[nOff].extra + ops[nOff].data.size);
      }
      else 
        return false;
    }
    else {
      if (!op->def->Exec(op, os))
        return false;
    }
 
    if (g_pDebugger) {
      g_pDebugger->AfterOp(op, os, ops);
    }
  }
  return true;
}

References IIccCalcDebugger::AfterOp(), ApplySequence(), IIccCalcDebugger::BeforeOp(), SIccCalcOp::def, IIccOpDef::Exec(), SIccCalcOp::extra, g_pDebugger, CIccApplyMpeCalculator::GetInput(), CIccApplyMpeCalculator::GetOutput(), CIccApplyMpeCalculator::GetScratch(), CIccApplyMpeCalculator::GetStack(), CIccApplyMpeCalculator::GetTemp(), icSigDefaultOp, icSigElseOp, icSigIfOp, icSigSelectOp, SIccOpState::idx, SIccOpState::nOps, SIccOpState::output, SIccOpState::pApply, SIccOpState::pixel, SIccOpState::pScratch, SIccOpState::pStack, SIccCalcOp::sig, and SIccOpState::temp.

Referenced by Apply(), and ApplySequence().

Here is the call graph for this function:

Here is the caller graph for this function:

Begin()

bool CIccCalculatorFunc::Begin ( const CIccMpeCalculator *  pChannelCalc, CIccTagMultiProcessElement *  pMPE  )

virtual

Name: CIccCalculatorFunc::Begin

Purpose:

Args:

Return:

{
  if (!pChannelCalc)
    return false;
  std::string sReport;
 
  if (!InitSelectOps())
    return false;
 
  if (!HasValidOperations(sReport))
    return false;
 
  if (!SetOpDefs())
    return false;
 
  if (DoesOverflowInput(pChannelCalc->NumInputChannels()))
    return false;
 
  if (DoesOverflowOutput(pChannelCalc->NumOutputChannels()))
    return false;
 
  if (DoesStackUnderflowOverflow(sReport)!=icFuncParseNoError)
    return false;
 
  return true;
}

References DoesOverflowInput(), DoesOverflowOutput(), DoesStackUnderflowOverflow(), HasValidOperations(), icFuncParseNoError, InitSelectOps(), CIccMultiProcessElement::NumInputChannels(), CIccMultiProcessElement::NumOutputChannels(), and SetOpDefs().

Referenced by CIccMpeCalculator::Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckUnderflowOverflow()

int CIccCalculatorFunc::CheckUnderflowOverflow	(	SIccCalcOp *	op,
		icUInt32Number	nOps,
		int	nArgs,
		bool	bCheckUnderflow,
		std::string &	sReport
	)		const

Name: CIccCalculatorFunc::CheckUnderflow

Purpose:

Args:

Return:

{
  icUInt32Number i, p;
  int n, nIfArgs, nElseArgs, nSelArgs, nCaseArgs;
 
  for (i=0; i<nOps; i++) {
    n = op[i].ArgsUsed(m_pCalc);
 
#if 0
    std::string opstr;
    op[i].Describe(opstr);
    printf("%s : %d %d\n", opstr.c_str(), n, nArgs);
#endif
 
    if (n > nArgs) {
      std::string opDesc;
      icUInt32Number j, l;
      icInt32Number f;
 
      op[i].Describe(opDesc, 100); // TODO - propogate nVerboseness
      sReport += "Stack underflow at operation \"" + opDesc + "\" in \"";
      f=i-2;
      if (f<0) f=0;
      l=i+2;
      if (l>nOps-1)
        l=nOps-1;
      for (j=(icUInt32Number)f; j<=l; j++) {
        op[j].Describe(opDesc, 100); // TODO - propogate nVerboseness
        if (j!=f)
          sReport += " ";
        sReport += opDesc;
      }
      sReport += "\"\n";
      return -1;
    }
 
    nArgs -= n;
    nArgs += op[i].ArgsPushed(m_pCalc);
 
    if (nArgs>icMaxDataStackSize)
      return -2;
 
    if (op[i].sig == icSigIfOp) {
      int incI = 0;
      if (i+1<nOps && op[i+1].sig==icSigElseOp) {
        p = i+2; 
        nIfArgs = CheckUnderflowOverflow(&op[p], icIntMin(nOps-p, op[i].data.size), nArgs, bCheckUnderflow, sReport);
        if (nIfArgs<0)
          return -1;
        incI =op[i].data.size;
 
        p = i+2+op[i].data.size;
        nElseArgs = CheckUnderflowOverflow(&op[p], icIntMin(nOps-p, op[i+1].data.size), nArgs, bCheckUnderflow, sReport);
        if (nElseArgs<0)
          return -1;
        incI += op[i+1].data.size;
 
        nArgs = bCheckUnderflow ? icIntMin(nIfArgs, nElseArgs) : icIntMax(nIfArgs, nElseArgs) ;
        i++;
        i+=incI;
      }
      else {
        p = i+1; 
        nIfArgs = CheckUnderflowOverflow(&op[p], icIntMin(nOps-p, op[i].data.size), nArgs, bCheckUnderflow, sReport);
        if (nIfArgs<0)
          return -1;
        nArgs = bCheckUnderflow ? icIntMin(nArgs, nIfArgs) : icIntMax(nArgs, nIfArgs);
 
        i+= op[i].data.size;
      }
    }
    else if (op[i].sig == icSigSelectOp) {
      icUInt32Number n;
      nSelArgs = nArgs;
 
      for (n=1; i+n<nOps; ) {
        if (op[i+n].sig==icSigCaseOp)
          n++;
        else if (n>1 && op[i+n].sig==icSigDefaultOp) {
          n++;
          break;
        }
        else
          break;
      }
      n--;
 
      if (!n)
        return -1;
 
      icUInt32Number pos = i+1 + n;
      for (p=0; p<n; p++) {
        SIccCalcOp *sop = &op[i+1+p];
        int len = sop->data.size;
        if (pos>=nOps)
          return -1;
 
        nCaseArgs = CheckUnderflowOverflow(&op[pos], icIntMin(nOps-pos, len), nArgs, bCheckUnderflow, sReport);
        if (nCaseArgs<0)
          return -1;
 
        if (!p)
          nSelArgs = nCaseArgs;
        else
          nSelArgs = bCheckUnderflow ? icIntMin(nSelArgs, nCaseArgs) : icIntMax(nSelArgs, nCaseArgs);
 
        pos += sop->data.size;
      }
      nArgs = nSelArgs;
 
      i = pos - 1;
    }
  }
 
  return nArgs;
}

References SIccCalcOp::ArgsPushed(), SIccCalcOp::ArgsUsed(), CheckUnderflowOverflow(), SIccCalcOp::Describe(), icIntMax(), icIntMin(), icSigCaseOp, icSigDefaultOp, icSigElseOp, icSigIfOp, icSigSelectOp, m_pCalc, and SIccCalcOp::sig.

Referenced by CheckUnderflowOverflow(), and DoesStackUnderflowOverflow().

Here is the call graph for this function:

Here is the caller graph for this function:

Describe()

void CIccCalculatorFunc::Describe ( std::string &  sDescription, int  nVerboseness = 0, int  nBlanks = 0  )

virtual

Name: CIccCalculatorFunc::Describe

Purpose:

Args:

Return:

{
  if (m_nOps) {
    DescribeSequence(sDescription, m_nOps, m_Op, nBlanks);
  }
  else {
    sDescription += "Undefined Function!\n";
  }
}

References DescribeSequence(), m_nOps, and m_Op.

Referenced by CIccMpeCalculator::Describe(), and CIccMpeXmlCalculator::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

DescribeSequence()

void CIccCalculatorFunc::DescribeSequence ( std::string &  sDescription, icUInt32Number  nOps, SIccCalcOp *  op, int  nBlanks  )

protected

{
  icUInt32Number i;
  int pos;
  std::string opName;
  std::string funcDesc;
 
  InsertBlanks(funcDesc, nBlanks);
  funcDesc += "{ ";
 
  pos = nBlanks + 2;
 
  for (i=0; i<nOps;) {
    if (pos >nBlanks + 65) {
      funcDesc += "\n";
      InsertBlanks(funcDesc, nBlanks + 2);
      pos = nBlanks + 2;
    }
 
    op->Describe(opName, 100); // TODO - propogate nVerboseness
    funcDesc += opName;
    funcDesc += " ";
    pos += (int)opName.size() + 1;
 
    if (op->sig == icSigIfOp) {
      SIccCalcOp *ifop = op;
 
      if  (i+1<nOps && op[1].sig == icSigElseOp) {
        SIccCalcOp *elseop = &op[1];
        icUInt32Number nSubOps = (icUInt32Number)icIntMin(nOps-i, ifop->data.size);
        op++;
        i++;
        funcDesc += "\n";
        DescribeSequence(funcDesc, nSubOps, &op[1], nBlanks+2);
        op += nSubOps;
        i += nSubOps;
 
        InsertBlanks(funcDesc, nBlanks+2);
        funcDesc += "else\n";
        pos = 0;
 
        nSubOps = (icUInt32Number)icIntMin(nOps-i, elseop->data.size);
        DescribeSequence(funcDesc, nSubOps, &op[1], nBlanks+2);
        op += nSubOps;
        i += nSubOps;
      }
      else {
        icUInt32Number nSubOps = (icUInt32Number)icIntMin(nOps-i, ifop->data.size);
        funcDesc += "\n";
        DescribeSequence(funcDesc, nSubOps, &op[1], nBlanks+2);
        op += nSubOps;
        i += nSubOps;
      }
 
      InsertBlanks(funcDesc, nBlanks + 2);
      pos = nBlanks + 2;
    }
    else if (op->sig == icSigSelectOp) {
      op++;
      i++;
      funcDesc += "\n";
 
      int j, n;
 
      for (n=0; i+n<nOps; ) {
        if (op[n].sig==icSigCaseOp)
          n++;
        else if (n>1 && op[n].sig==icSigDefaultOp) {
          n++;
          break;
        }
        else
          break;
      }
 
      int p = n;
      for (j=0; j<n; j++) {
        icUInt32Number nSubOps = (icUInt32Number)icIntMin(nOps-(i+p), op[j].data.size);
        InsertBlanks(funcDesc, nBlanks+2);
        if (op[j].sig==icSigCaseOp)
          funcDesc += "case\n";
        else
          funcDesc += "dflt\n";
 
        DescribeSequence(funcDesc, nSubOps, &op[p], nBlanks+2);
        p += nSubOps;
      }
 
      op += p-1;
      i += p-1;
 
      InsertBlanks(funcDesc, nBlanks + 2);
      pos = nBlanks + 2;
    }
    op++;
    i++;
  }
  funcDesc += "}\n";
 
  sDescription += funcDesc;
}

References SIccCalcOp::Describe(), DescribeSequence(), icIntMin(), icSigCaseOp, icSigDefaultOp, icSigElseOp, icSigIfOp, icSigSelectOp, InsertBlanks(), and SIccCalcOp::sig.

Referenced by Describe(), and DescribeSequence().

Here is the call graph for this function:

Here is the caller graph for this function:

DoesOverflowInput()

bool CIccCalculatorFunc::DoesOverflowInput

(

icUInt16Number

nInputChannels

)

const

Name: CIccChannelFunc::DoesOverflowInput

Purpose:

Args:

Return:

{
  icUInt32Number i;
  for (i=0; i<m_nOps; i++) {
    if (m_Op[i].sig == icSigInputChanOp) {
      if (m_Op[i].data.select.v1+m_Op[i].data.select.v2 >= nInputChannels)
        return true;
    }
  }
  return false;
}

References icSigInputChanOp, m_nOps, m_Op, and SIccCalcOp::sig.

Referenced by Begin(), and Validate().

Here is the caller graph for this function:

DoesOverflowOutput()

bool CIccCalculatorFunc::DoesOverflowOutput

(

icUInt16Number

nOutputChannels

)

const

Name: CIccChannelFunc::DoesOverflowOutput

Purpose:

Args:

Return:

{
  icUInt32Number i;
  for (i=0; i<m_nOps; i++) {
    if (m_Op[i].sig == icSigOutputChanOp) {
      if (m_Op[i].data.select.v1 + m_Op[i].data.select.v2 >= nOutputChannels)
        return true;
    }
  }
  return false;
}

References icSigOutputChanOp, m_nOps, m_Op, and SIccCalcOp::sig.

Referenced by Begin(), and Validate().

Here is the caller graph for this function:

DoesStackUnderflowOverflow()

icFuncParseStatus CIccCalculatorFunc::DoesStackUnderflowOverflow

(

std::string &

sReport

)

const

Name: CIccCalculatorFunc::DoesStackUnderflowOverflow

Purpose:

Args:

Return:

{
  int rv = CheckUnderflowOverflow(m_Op, m_nOps, 0, true, sReport); 
 
  if (rv==-1)
    return icFuncParseStackUnderflow;
  else if (rv<0)
    return icFuncParseStackOverflow;
 
  rv = CheckUnderflowOverflow(m_Op, m_nOps, 0, false, sReport); 
 
  if (rv==-1)
    return icFuncParseStackUnderflow;
  else if (rv<0)
    return icFuncParseStackOverflow;
 
  return icFuncParseNoError;
}

References CheckUnderflowOverflow(), icFuncParseNoError, icFuncParseStackOverflow, icFuncParseStackUnderflow, m_nOps, and m_Op.

Referenced by Begin(), SetFunction(), and Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

GetClassName()

virtual const icChar * CIccCalculatorFunc::GetClassName ( ) const

inlinevirtual

{ return "CIccChannelFunction"; }

GetMaxTemp()

icUInt32Number CIccCalculatorFunc::GetMaxTemp

(

)

const

Name: CIccCalculatorFunc::GetMaxTemp

Purpose:

Args:

Return:

{
  icUInt32Number i, nMaxTemp = 0;
 
  for (i=0; i<m_nOps; i++) {
    if (m_Op[i].sig == icSigTempGetChanOp || m_Op[i].sig == icSigTempPutChanOp || m_Op[i].sig == icSigTempSaveChanOp ) {
      icUInt32Number last = (icUInt32Number)(m_Op[i].data.select.v1) + (icUInt32Number)(m_Op[i].data.select.v2);
      if (last>nMaxTemp)
        nMaxTemp = last;
    }
  }
  return nMaxTemp;
}

References icSigTempGetChanOp, icSigTempPutChanOp, icSigTempSaveChanOp, m_nOps, m_Op, and SIccCalcOp::sig.

Referenced by CIccMpeCalculator::Begin(), and Validate().

Here is the caller graph for this function:

GetType()

virtual icChannelFuncSignature CIccCalculatorFunc::GetType ( ) const

inlinevirtual

{ return icSigChannelFunction; }

References icSigChannelFunction.

Referenced by Read(), and Write().

Here is the caller graph for this function:

HasUnsupportedOperations()

bool CIccCalculatorFunc::HasUnsupportedOperations	(	std::string &	sReport,
		const CIccProfile *	pProfile
	)		const

Name: CIccCalculatorFunc::HasUnsupportedOperations

Purpose:

Args:

Return:

{
  icUInt32Number i;
  if (pProfile) {
    icUInt32Number version = pProfile->m_Header.version;
 
    icCalcOpMap map;
    for (i = 0; i < m_nOps; i++) {
      if (version < icVersionNumberV5_1 && 
          (m_Op[i].sig == icSigNotOp ||
           m_Op[i].sig == icSigNotEqualOp)) {
        map[m_Op[i].sig] = NULL;
      }
    }
    if (map.size()) {
      icCalcOpMap::iterator sig;
      sReport += "Calculator operator(s) not supported by profile version:";
      for (sig = map.begin(); sig != map.end(); sig++) {
        SIccCalcOp op;
        op.sig = sig->first;
        std::string opname;
        op.Describe(opname, 100);
        sReport += std::string(" (") + opname + ")";
      }
      sReport += "\n";
 
      return true;
    }
  }
  return false;
}

References SIccCalcOp::Describe(), icSigNotEqualOp, icSigNotOp, m_nOps, m_Op, SIccCalcOp::sig, and icHeader::version.

Referenced by Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

HasValidOperations()

bool CIccCalculatorFunc::HasValidOperations

(

std::string &

sReport

)

const

Name: CIccCalculatorFunc::HasValidOperations

Purpose:

Args:

Return:

{
  icUInt32Number i;
  for (i=0; i<m_nOps; i++) {
    if (!m_Op[i].IsValidOp(m_pCalc)) {
      std::string opDesc;
      m_Op[i].Describe(opDesc, 100); // TODO - propogate nVerboseness 
      sReport += "Invalid Operation (" + opDesc + ")\n";
      return false;
    }
    if (m_Op[i].sig==icSigSelectOp && i+1<m_nOps && m_Op[i+1].sig!=icSigCaseOp) {
      sReport += "A case operator does not follow a sel operator\n";
      return false;
    }
    if (i) {
      if (m_Op[i].sig==icSigElseOp) {
        if (m_Op[i-1].sig!=icSigIfOp) {
          sReport += "An else operator has no proceeding if operator\n";
          return false;
        }
      }
      else if (m_Op[i].sig==icSigCaseOp) {
        if (m_Op[i-1].sig!=icSigSelectOp && m_Op[i-1].sig!=icSigCaseOp) {
          sReport += "A case operator has no proceeding sel or case operator\n";
          return false;
        }
      }
      else if (m_Op[i].sig==icSigDefaultOp) {
        if (m_Op[i-1].sig!=icSigCaseOp) {
          sReport += "An dflt operator has no proceeding case operator\n";
          return false;
        }
      }
    }
  }
  return true;
}

References SIccCalcOp::Describe(), icSigCaseOp, icSigDefaultOp, icSigElseOp, icSigIfOp, icSigSelectOp, SIccCalcOp::IsValidOp(), m_nOps, m_Op, m_pCalc, and SIccCalcOp::sig.

Referenced by Begin(), SetFunction(), and Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

InitSelectOp()

bool CIccCalculatorFunc::InitSelectOp ( SIccCalcOp *  ops, icUInt32Number  nOps  )

protected

Name: CIccCalculatorFunc::InitSelectOp

Purpose:

Args:

Return:

{
 
  if (ops->sig != icSigSelectOp)
    return false;
 
  if (ops->extra)
    return true;
 
 
  icUInt32Number i, n, pos;
  for (n=0; n<nOps && ops[n+1].sig==icSigCaseOp; n++);
  ops->extra=n;
  if (ops[n+1].sig==icSigDefaultOp) {
    n++;
  }
  pos = n;
  for (i=1; i<=n && pos<nOps; i++) {
    ops[i].extra = pos;
    pos += ops[i].data.size;
  }
 
  if (i<=n)
    return false;
 
  return true;
}

References SIccCalcOp::extra, icSigCaseOp, icSigDefaultOp, icSigSelectOp, and SIccCalcOp::sig.

Referenced by InitSelectOps().

Here is the caller graph for this function:

InitSelectOps()

bool CIccCalculatorFunc::InitSelectOps ( )

protected

Name: CIccCalculatorFunc::InitSelectOps

Purpose:

Args:

Return:

{
  icUInt32Number i;
 
  for (i=0; i<m_nOps; i++) {
    if (m_Op[i].sig==icSigSelectOp) {
      if (!InitSelectOp(&m_Op[i], m_nOps-i))
        return false;
    }
  }
 
  return true;
}

References icSigSelectOp, InitSelectOp(), m_nOps, m_Op, and SIccCalcOp::sig.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

InsertBlanks()

void CIccCalculatorFunc::InsertBlanks ( std::string &  sDescription, int  nBlanks  )

protected

{
  char blanks[21]="                    ";
  int i;
 
  while (nBlanks>0) {
    i =  nBlanks < 20 ? nBlanks : 20;
    blanks[i] = 0;
    sDescription += blanks;
    nBlanks -= i;
  }
}

Referenced by DescribeSequence().

Here is the caller graph for this function:

NeedTempReset()

bool CIccCalculatorFunc::NeedTempReset	(	icUInt8Number *	tempUsage,
		icUInt32Number	nMaxTemp
	)

Name: CIccCalculatorFunc::NeedTempReset

Purpose:

Args:

Return:

{
  return SequenceNeedTempReset(m_Op, m_nOps, tempUsage, nMaxTemp);
}

References m_nOps, m_Op, and SequenceNeedTempReset().

Referenced by CIccMpeCalculator::Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

NewCopy()

virtual CIccCalculatorFunc * CIccCalculatorFunc::NewCopy ( ) const

inlinevirtual

{ return new CIccCalculatorFunc(*this);}

References CIccCalculatorFunc().

Referenced by CIccMpeCalculator::CIccMpeCalculator(), and CIccMpeCalculator::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

CIccCalculatorFunc & CIccCalculatorFunc::operator=

(

const CIccCalculatorFunc &

func

)

Name: &CIccCalculatorFunc::operator=

Purpose:

Args:

Return:

{
  m_pCalc = func.m_pCalc;
 
  m_nReserved= func.m_nReserved;
 
  if (m_Op)
    free(m_Op);
 
  m_nOps = func.m_nOps;
 
  if (m_nOps) {
    m_Op = (SIccCalcOp*)malloc(m_nOps * sizeof(SIccCalcOp));
    memcpy(m_Op, func.m_Op, m_nOps*sizeof(SIccCalcOp));
  }
  else
    m_Op = NULL;
 
  return (*this);
}

References m_nOps, m_nReserved, m_Op, and m_pCalc.

ParseFuncDef()

const char * CIccCalculatorFunc::ParseFuncDef ( const char *  szFuncDef, CIccCalcOpList &  scanList, std::string &  sReport  )

protected

Name: CIccCalculatorFunc::ParseFuncDef

Purpose:

Args:

Return:

{
  SIccCalcOp op;
  op.extra = 0;
  op.def=NULL;
 
  scanList.clear();
 
  if (!szFuncDef)
    return szFuncDef;
 
  CIccFuncTokenizer scan(szFuncDef);
  if (!scan.GetNext())
    return NULL;
 
  if (scan.GetSig() != icSigBeginBlockOp)
    return NULL;
 
  while(scan.GetNext()) {
    op.sig = scan.GetSig();
 
    if (op.sig == icSigEndBlockOp)
      return scan.GetPos();
 
    switch(op.sig) {
      case icSigDataOp:
        op.data.num = scan.GetValue();
        scanList.push_back(op);
        break;
 
      case icSigIfOp:
        {
          CIccCalcOpList trueList, falseList;
          bool bHasElse;
 
          szFuncDef = ParseFuncDef(scan.GetPos(), trueList, sReport);
          if (!szFuncDef)
            return NULL;
 
          scan.SetPos(szFuncDef);
          bHasElse = false;
          if (scan.GetNext() && scan.GetSig()==icSigElseOp) {
            bHasElse = true;
            szFuncDef = ParseFuncDef(scan.GetPos(), falseList, sReport);
 
            if (!szFuncDef)
              return NULL;
          }
 
          scan.SetPos(szFuncDef);
          op.data.size = (icUInt32Number)trueList.size();
          scanList.push_back(op);
 
          if (bHasElse) {
            op.sig = icSigElseOp;
            op.data.size = (icUInt32Number)falseList.size();
            scanList.push_back(op);
 
            AppendOpList(scanList, trueList);
            AppendOpList(scanList, falseList);
          }
          else {
            AppendOpList(scanList, trueList);
          }
        }
        break;
 
      case icSigSelectOp:
        {
          op.sig = icSigSelectOp;
          op.data.size = 0;
          scanList.push_back(op);
 
          int c;
          CIccCalcOpListPtrList selList;
          for (c=0; ; c++) {
            szFuncDef = scan.GetPos();
            scan.GetNext();
            if (scan.GetSig()==icSigCaseOp) {
              CIccCalcOpListPtr pCaseList = new CIccCalcOpList();
 
              szFuncDef = ParseFuncDef(scan.GetPos(), *pCaseList, sReport);
 
              if (!szFuncDef) {
                delete pCaseList;
                return NULL;
              }
 
              scan.SetPos(szFuncDef);
              op.sig = icSigCaseOp;
              op.data.size = (icUInt32Number)pCaseList->size();
              scanList.push_back(op);
 
              selList.push_back(pCaseList);
            }
            else if (c && scan.GetSig()==icSigDefaultOp) {
              CIccCalcOpListPtr pDefaultList = new CIccCalcOpList();
 
              szFuncDef = ParseFuncDef(scan.GetPos(), *pDefaultList, sReport);
 
              if (!szFuncDef) {
                delete pDefaultList;
                return NULL;
              }
 
              scan.SetPos(szFuncDef);
              op.sig = icSigDefaultOp;
              op.data.size = (icUInt32Number)pDefaultList->size();
              scanList.push_back(op);
 
              selList.push_back(pDefaultList);
              break;
            }
            else {
              scan.SetPos(szFuncDef);
              break;
            }
          }
          CIccCalcOpListPtrList::iterator l;
          for (l=selList.begin(); l!=selList.end(); l++) {
            CIccCalcOpListPtr pCaseList = *l;
 
            AppendOpList(scanList, *pCaseList);
            delete pCaseList;
          }
        }
        break;
 
      case icSigInputChanOp:
      case icSigOutputChanOp:
      case icSigTempGetChanOp:
      case icSigTempPutChanOp:
      case icSigTempSaveChanOp:
        if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 0, 1))
          return NULL;
        scanList.push_back(op);
        break;
 
      case icSigEnvVarOp:
        {
          icSigCmmEnvVar envSig;
          if (!scan.GetEnvSig(envSig))
            return NULL;
          op.data.size = (icUInt32Number)envSig;
          scanList.push_back(op);
        }
        break;
 
      case icSigCopyOp:
      case icSigRotateLeftOp:
      case icSigRotateRightOp:
      case icSigPositionDupOp:
      case icSigSolveOp:
      case icSigTransposeOp:
        if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 1, 1))
          return NULL;
        scanList.push_back(op);
        break;
 
      case icSigPopOp:
        if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 1))
          return NULL;
        op.data.select.v2 = 0;
        scanList.push_back(op);
        break;
 
      case icSigFlipOp:
      case icSigSumOp:
      case icSigProductOp:
      case icSigMinimumOp:
      case icSigMaximumOp:
      case icSigAndOp:
      case icSigOrOp:
        if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 2))
          return NULL;
        op.data.select.v2 = 0;
        scanList.push_back(op);
        break;
 
      case icSigApplyCurvesOp:
      case icSigApplyMatrixOp:
      case icSigApplyCLutOp:
      case icSigApplyTintOp:
      case icSigApplyToJabOp:
      case icSigApplyFromJabOp:
      case icSigApplyCalcOp:
      case icSigApplyElemOp:
        if (!scan.GetIndex(op.data.select.v1, op.data.select.v2))
          return NULL;
        op.data.select.v2 = 0;
        scanList.push_back(op);
        break;
 
      case icSigGammaOp:
      case icSigScalarAddOp:
      case icSigScalarSubtractOp:
      case icSigScalarMultiplyOp:
      case icSigScalarDivideOp:
      case icSigAddOp:
      case icSigSubtractOp:
      case icSigMultiplyOp:
      case icSigDivideOp:
      case icSigModulusOp:
      case icSigPowOp:
      case icSigArcTan2Op:          
      case icSigLessThanOp:         
      case icSigLessThanEqualOp:    
      case icSigEqualOp:
      case icSigNotEqualOp:
      case icSigNearOp:
      case icSigGreaterThanEqualOp: 
      case icSigGreaterThanOp:
      case icSigSquareOp:       
      case icSigSquareRootOp:       
      case icSigCubeOp:       
      case icSigCubeRootOp:
      case icSigSignOp:
      case icSigAbsoluteValOp:
      case icSigTruncateOp:
      case icSigFloorOp:
      case icSigCeilingOp:
      case icSigRoundOp:
      case icSigRealNumberOp:
      case icSigNegOp:      
      case icSigExpOp:              
      case icSigLogrithmOp:         
      case icSigNaturalLogOp:       
      case icSigSineOp:             
      case icSigCosineOp:             
      case icSigTangentOp:          
      case icSigArcSineOp:          
      case icSigArcCosineOp:        
      case icSigArcTangentOp:
      case icSigCartesianToPolarOp:
      case icSigPolarToCartesianOp:
      case icSigNotOp:
      case icSigToLabOp:
      case icSigToXYZOp:
      case icSigVectorMinimumOp:
      case icSigVectorMaximumOp:
      case icSigVectorAndOp:
      case icSigVectorOrOp:
        if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 1))
          return NULL;
        op.data.select.v2 = 0;
        scanList.push_back(op);
        break;
 
      default:
        if (!SIccCalcOp::IsValidOp(op.sig)) {
          std::string opDesc;
 
          op.Describe(opDesc, 100); // TODO - propogate nVerboseness
          sReport += "Invalid Operator \"";
          sReport += opDesc;
          sReport += "\"\n";
 
          if (scanList.rbegin()!=scanList.rend()) {
            sReport += "Last Few operators in reverse:\n";
 
            CIccCalcOpList::reverse_iterator opi;
            int i;
            for (i=0, opi=scanList.rbegin(); i<10 && opi!=scanList.rend(); i++, opi++) {
              opi->Describe(opDesc, 100); // TODO - propogate nVerboseness
              sReport += " ";
              sReport += opDesc;
            }
            sReport += "\n";
          }
          return NULL;
        }
        op.data.select.v1 = 0;
        op.data.select.v2 = 0;
        scanList.push_back(op);
        break;
    }
  }
  return NULL;
}

References CIccFuncTokenizer::CIccFuncTokenizer(), AppendOpList(), SIccCalcOp::def, SIccCalcOp::Describe(), SIccCalcOp::extra, CIccFuncTokenizer::GetEnvSig(), CIccFuncTokenizer::GetIndex(), CIccFuncTokenizer::GetNext(), CIccFuncTokenizer::GetPos(), CIccFuncTokenizer::GetSig(), CIccFuncTokenizer::GetValue(), icSigAbsoluteValOp, icSigAddOp, icSigAndOp, icSigApplyCalcOp, icSigApplyCLutOp, icSigApplyCurvesOp, icSigApplyElemOp, icSigApplyFromJabOp, icSigApplyMatrixOp, icSigApplyTintOp, icSigApplyToJabOp, icSigArcCosineOp, icSigArcSineOp, icSigArcTan2Op, icSigArcTangentOp, icSigCartesianToPolarOp, icSigCaseOp, icSigCeilingOp, icSigCopyOp, icSigCosineOp, icSigCubeOp, icSigCubeRootOp, icSigDataOp, icSigDefaultOp, icSigDivideOp, icSigElseOp, icSigEnvVarOp, icSigEqualOp, icSigExpOp, icSigFlipOp, icSigFloorOp, icSigGammaOp, icSigGreaterThanEqualOp, icSigGreaterThanOp, icSigIfOp, icSigInputChanOp, icSigLessThanEqualOp, icSigLessThanOp, icSigLogrithmOp, icSigMaximumOp, icSigMinimumOp, icSigModulusOp, icSigMultiplyOp, icSigNaturalLogOp, icSigNearOp, icSigNegOp, icSigNotEqualOp, icSigNotOp, icSigOrOp, icSigOutputChanOp, icSigPolarToCartesianOp, icSigPopOp, icSigPositionDupOp, icSigPowOp, icSigProductOp, icSigRealNumberOp, icSigRotateLeftOp, icSigRotateRightOp, icSigRoundOp, icSigScalarAddOp, icSigScalarDivideOp, icSigScalarMultiplyOp, icSigScalarSubtractOp, icSigSelectOp, icSigSignOp, icSigSineOp, icSigSolveOp, icSigSquareOp, icSigSquareRootOp, icSigSubtractOp, icSigSumOp, icSigTangentOp, icSigTempGetChanOp, icSigTempPutChanOp, icSigTempSaveChanOp, icSigToLabOp, icSigToXYZOp, icSigTransposeOp, icSigTruncateOp, icSigVectorAndOp, icSigVectorMaximumOp, icSigVectorMinimumOp, icSigVectorOrOp, SIccCalcOp::IsValidOp(), ParseFuncDef(), CIccFuncTokenizer::SetPos(), and SIccCalcOp::sig.

Referenced by ParseFuncDef(), and SetFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

Read()

bool CIccCalculatorFunc::Read ( icUInt32Number  size, CIccIO *  pIO  )

virtual

Name: CIccCalculatorFunc::Read

Purpose:

Args:

Return:

{
  icUInt32Number headerSize = sizeof(icUInt32Number);
 
  headerSize += sizeof(icChannelFuncSignature) + sizeof(icUInt32Number);
 
  if (headerSize > size)
    return false;
 
  if (!pIO) {
    return false;
  }
 
  icChannelFuncSignature sig;
 
  if (!pIO->Read32(&sig))
    return false;
 
  if (sig!= GetType())
    return false;
 
  if (!pIO->Read32(&m_nReserved))
    return false;
 
  if (!pIO->Read32(&m_nOps))
    return false;
 
  if ((icUInt64Number)m_nOps * sizeof(icUInt32Number) * 2 > (icUInt64Number)size - headerSize)
    return false;
 
  if (m_Op) {
    free(m_Op);
  }
 
  if (m_nOps) {
    m_Op = (SIccCalcOp*)calloc(m_nOps, sizeof(SIccCalcOp));
 
    if (!m_Op) {
      m_nOps = 0;
      return false;
    }
 
    icUInt32Number i;
    for (i=0; i<m_nOps; i++) {
      if (!pIO->Read32(&m_Op[i].sig))
        return false;
      if (!pIO->Read32(&m_Op[i].data.num))
        return false;
    }
  }
 
  return true;
}

References GetType(), m_nOps, m_nReserved, m_Op, CIccIO::Read32(), and SIccCalcOp::sig.

Referenced by CIccMpeCalculator::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

SequenceNeedTempReset()

bool CIccCalculatorFunc::SequenceNeedTempReset ( SIccCalcOp *  op, icUInt32Number  nOps, icUInt8Number *  tempUsage, icUInt32Number  nMaxTemp  )

protected

Name: CIccCalculatorFunc::SequenceNeedTempReset

Purpose:

Args:

Return:

{
  icUInt32Number i, j;
 
  for (i=0; i<nOps; i++) {
    icSigCalcOp sig = op[i].sig;
    if (sig==icSigTempGetChanOp) {
      icUInt32Number p = op[i].data.select.v1;
      icUInt32Number n = op[i].data.select.v2+1;
      for (j=0; j<n; j++) {
        if (!tempUsage[p+j]) {
          return true;
        }
      }
    }
    else if (sig==icSigTempPutChanOp) {
      icUInt32Number p = op[i].data.select.v1;
      icUInt32Number n = op[i].data.select.v2+1;
      memset(tempUsage+p, 1, n);
    }
    else if (sig==icSigTempSaveChanOp) {
      icUInt32Number p = op[i].data.select.v1;
      icUInt32Number n = op[i].data.select.v2+1;
      memset(tempUsage+p, 1, n);
    }
    else if (sig==icSigIfOp) {
      bool rv = false;
      icUInt8Number *ifTemps = (icUInt8Number *)malloc(nMaxTemp);
      icUInt32Number p;
      if (!ifTemps)
        return true;
 
      memcpy(ifTemps, tempUsage, nMaxTemp);
 
      p=i+2;
      rv = rv || SequenceNeedTempReset(&op[p], icIntMin(nOps-p, op[i].data.size), ifTemps, nMaxTemp);
 
      if (i<nOps && op[i+1].sig==icSigElseOp) {
        icUInt8Number *elseTemps = (icUInt8Number *)malloc(nMaxTemp);
        if (!elseTemps) {
          free(ifTemps);
          return true;
        }
 
        memcpy(elseTemps, tempUsage, nMaxTemp);
 
        p=i+2+op[i].data.size;
        rv = rv || SequenceNeedTempReset(&op[p], icIntMin(nOps-p, op[i+1].data.size), elseTemps, nMaxTemp);
 
        if (!rv) {
          for (j=0; j<nMaxTemp; j++) {
            tempUsage[j] |= (ifTemps[j] && elseTemps[j]);
          }
        }
 
        free(elseTemps);
 
        i += 1 + op[i].data.size + op[i+1].data.size;
      }
      else {
        i += op[i].data.size;
      }
 
      free(ifTemps);
 
      if (rv)
        return true;
    }
  }
  return false;
}

References icIntMin(), icSigElseOp, icSigIfOp, icSigTempGetChanOp, icSigTempPutChanOp, icSigTempSaveChanOp, SequenceNeedTempReset(), and SIccCalcOp::sig.

Referenced by NeedTempReset(), and SequenceNeedTempReset().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFunction() [1/2]

icFuncParseStatus CIccCalculatorFunc::SetFunction	(	CIccCalcOpList &	opList,
		std::string &	sReport
	)

Name: CIccCalculatorFunc::SetFunction

Purpose:

Args:

Return:

{
  if (m_Op) {
    free(m_Op);
    m_Op = NULL;
  }
 
  m_nOps = (icUInt32Number)opList.size();
 
  if (m_nOps) {
    CIccCalcOpList::iterator i;
    int j;
 
    m_Op = (SIccCalcOp*)calloc(m_nOps , sizeof(SIccCalcOp));
 
    for (i=opList.begin(), j=0; i!= opList.end(); i++, j++) {
      m_Op[j] = *i;
    }
  }
  else {
    return icFuncParseEmptyFunction;
  }
 
  if (!HasValidOperations(sReport))
    return icFuncParseInvalidOperation;
 
  return DoesStackUnderflowOverflow(sReport);
}

References DoesStackUnderflowOverflow(), HasValidOperations(), icFuncParseEmptyFunction, icFuncParseInvalidOperation, m_nOps, and m_Op.

Referenced by SetFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFunction() [2/2]

icFuncParseStatus CIccCalculatorFunc::SetFunction	(	const char *	szFuncDef,
		std::string &	sReport
	)

Name: CIccCalculatorFunc::SetFunction

Purpose:

Args:

Return:

{
  CIccCalcOpList opList;
 
  if (ParseFuncDef(szFuncDef, opList, sReport)) {
    return SetFunction(opList, sReport);
  }
  return icFuncParseSyntaxError;
}

References icFuncParseSyntaxError, ParseFuncDef(), and SetFunction().

Referenced by CIccMpeCalculator::SetCalcFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

SetOpDefs()

bool CIccCalculatorFunc::SetOpDefs

(

)

Name: CIccCalculatorFunc::SetOpDefs

Purpose:

Args:

Return:

{
  if (!m_Op)
    return false;
 
  icUInt32Number i;
  for (i=0; i<m_nOps; i++) {
    m_Op[i].def = CIccCalcOpMgr::getOpDef(m_Op[i].sig);
    if (!m_Op[i].def)
      return false;
  }
  return true;
}

References SIccCalcOp::def, CIccCalcOpMgr::getOpDef(), m_nOps, m_Op, and SIccCalcOp::sig.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

Validate()

icValidateStatus CIccCalculatorFunc::Validate ( std::string  sigPath, std::string &  sReport, const CIccMpeCalculator *  pChannelCalc = NULL, const CIccProfile *  pProfile = NULL  ) const

virtual

Name: CIccCalculatorFunc::Validate

Purpose:

Args:

Return:

{
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);
 
  icValidateStatus rv = icValidateOK;
  if (m_nReserved) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " function has non zero reserved data.\n";
    rv = icValidateWarning;
  }
 
  if (GetMaxTemp()>65535) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " accesses illegal temporary channels.\n";
    return icValidateCriticalError;
  }
 
  if (!HasValidOperations(sReport)) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " function has invalid operations.\n";
    return icValidateCriticalError;
  }
 
  if (HasUnsupportedOperations(sReport, pProfile)) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " function has unsupported operations.\r\n";
    rv = icValidateWarning;
  }
 
  if (DoesOverflowInput(pChannelCalc->NumInputChannels())) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " accesses illegal input channels.\n";
    return icValidateCriticalError;
  }
 
  if (DoesOverflowOutput(pChannelCalc->NumOutputChannels())) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " accesses illegal output channels.\n";
    return icValidateCriticalError;
  }
 
  icFuncParseStatus parseStat = DoesStackUnderflowOverflow(sReport);
  if (parseStat!=icFuncParseNoError) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    if (parseStat==icFuncParseStackUnderflow)
      sReport += " causes an evaluation stack underflow.\n";
    else
      sReport += " causes an evaluation stack overflow.\n";
    return icValidateCriticalError;
  }
 
  return rv;
}

References DoesOverflowInput(), DoesOverflowOutput(), DoesStackUnderflowOverflow(), GetMaxTemp(), CIccInfo::GetSigPathName(), HasUnsupportedOperations(), HasValidOperations(), icFuncParseNoError, icFuncParseStackUnderflow, icMsgValidateCriticalError, icMsgValidateWarning, icValidateCriticalError, icValidateOK, icValidateWarning, m_nReserved, CIccMultiProcessElement::NumInputChannels(), and CIccMultiProcessElement::NumOutputChannels().

Referenced by CIccMpeCalculator::Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

Write()

bool CIccCalculatorFunc::Write ( CIccIO *  pIO )

virtual

Name: CIccCalculatorFunc::Write

Purpose:

Args:

Return:

{
  if (!pIO)
    return false;
 
  icChannelFuncSignature sig;
  sig = GetType();
  if (!pIO->Write32(&sig))
    return false;
 
  if (!pIO->Write32(&m_nReserved))
    return false;
 
  if (!pIO->Write32(&m_nOps))
    return false;
 
  icUInt32Number i;
  for (i=0; i<m_nOps; i++)  {
    if (!pIO->Write32(&m_Op[i].sig))
      return false;
    if (!pIO->Write32(&m_Op[i].data.num))
      return false;
  }
 
  return true;
}

References GetType(), m_nOps, m_nReserved, m_Op, SIccCalcOp::sig, and CIccIO::Write32().

Referenced by CIccMpeCalculator::Write().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

m_nOps

icUInt32Number CIccCalculatorFunc::m_nOps

protected

Referenced by CIccCalculatorFunc(), CIccCalculatorFunc(), Apply(), Describe(), DoesOverflowInput(), DoesOverflowOutput(), DoesStackUnderflowOverflow(), GetMaxTemp(), HasUnsupportedOperations(), HasValidOperations(), InitSelectOps(), NeedTempReset(), operator=(), Read(), SetFunction(), SetOpDefs(), and Write().

m_nReserved

icUInt32Number CIccCalculatorFunc::m_nReserved

protected

Referenced by CIccCalculatorFunc(), CIccCalculatorFunc(), operator=(), Read(), Validate(), and Write().

m_Op

SIccCalcOp* CIccCalculatorFunc::m_Op

protected

Referenced by CIccCalculatorFunc(), CIccCalculatorFunc(), ~CIccCalculatorFunc(), Apply(), Describe(), DoesOverflowInput(), DoesOverflowOutput(), DoesStackUnderflowOverflow(), GetMaxTemp(), HasUnsupportedOperations(), HasValidOperations(), InitSelectOps(), NeedTempReset(), operator=(), Read(), SetFunction(), SetOpDefs(), and Write().

m_pCalc

CIccMpeCalculator* CIccCalculatorFunc::m_pCalc

protected

Referenced by CIccCalculatorFunc(), CIccCalculatorFunc(), Apply(), CheckUnderflowOverflow(), HasValidOperations(), and operator=().

---

The documentation for this class was generated from the following files:

• IccProfLib/IccMpeCalc.h
• IccProfLib/IccMpeCalc.cpp