/Users/xss/DemoIccMAX-hoyt-master/IccProfLib/IccMpeBasic.cpp

Bug Summary

File:	IccProfLib/IccMpeBasic.cpp
Warning:	line 187, column 5 Attempt to free released memory
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-apple-macosx14.0.0 -Wundef-prefix=TARGET_OS_ -Werror=undef-prefix -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name IccMpeBasic.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=osx -analyzer-checker=security.insecureAPI.decodeValueOfObjCType -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -ffp-contract=on -fno-rounding-math -funwind-tables=2 -target-sdk-version=14.0 -fcompatibility-qualified-id-block-type-checking -fvisibility-inlines-hidden-static-local-var -target-cpu penryn -tune-cpu generic -debugger-tuning=lldb -target-linker-version 1015.7 -fprofile-instrument=clang -fcoverage-mapping -fcoverage-compilation-dir=/Users/xss/DemoIccMAX-hoyt-master/build/IccProfLib -resource-dir /usr/local/Cellar/llvm/17.0.3/lib/clang/17 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk -D IccProfLib2_EXPORTS -I /Users/xss/DemoIccMAX-hoyt-master/build/Cmake/../../IccProfLib -I /Developer/Headers/FlatCarbon -F/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/System/Library/Frameworks -internal-isystem /usr/local/Cellar/llvm/17.0.3/bin/../include/c++/v1 -internal-isystem /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/usr/local/include -internal-isystem /usr/local/Cellar/llvm/17.0.3/lib/clang/17/include -internal-externc-isystem /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/usr/include -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/Users/xss/DemoIccMAX-hoyt-master/build/IccProfLib -ferror-limit 19 -fsanitize=address -fsanitize-system-ignorelist=/usr/local/Cellar/llvm/17.0.3/lib/clang/17/share/asan_ignorelist.txt -fno-sanitize-memory-param-retval -fsanitize-address-use-after-scope -fsanitize-address-globals-dead-stripping -fno-assume-sane-operator-new -stack-protector 1 -fblocks -fencode-extended-block-signature -fregister-global-dtors-with-atexit -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -fmax-type-align=16 -analyzer-output=html -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /var/folders/l9/sd9kj1px4yq2wc5_lkwhlt6w0000gn/T/scan-build-2023-10-28-102616-57860-1 -x c++ /Users/xss/DemoIccMAX-hoyt-master/IccProfLib/IccMpeBasic.cpp
1/** @file
  File:       IccMpeBasic.cpp

  Contains:   Implementation of Basic Multi Processing Elements

  Version:    V1

  Copyright:  � see ICC Software License
9*/

11/*
* The ICC Software License, Version 0.2
*
*
* Copyright (c) 2003-2012 The International Color Consortium. All rights 
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer. 
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in
*    the documentation and/or other materials provided with the
*    distribution.
*
* 3. In the absence of prior written permission, the names "ICC" and "The
*    International Color Consortium" must not be used to imply that the
*    ICC organization endorses or promotes products derived from this
*    software.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED.  IN NO EVENT SHALL THE INTERNATIONAL COLOR CONSORTIUM OR
* ITS CONTRIBUTING MEMBERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the The International Color Consortium. 
*
*
* Membership in the ICC is encouraged when this software is used for
* commercial purposes. 
*
*  
* For more information on The International Color Consortium, please
* see <http://www.color.org/>.
*  
* 
*/

64////////////////////////////////////////////////////////////////////// 
65// HISTORY:
66//
67// -Initial implementation by Max Derhak 1-30-2006
68//
69//////////////////////////////////////////////////////////////////////

71#ifdef WIN32
72#pragma warning( disable: 4786) //disable warning in <list.h>
73#endif

75#include <stdio.h>
76#include <math.h>
77#include <string.h>
78#include <stdlib.h>
79#include "IccMpeBasic.h"
80#include "IccIO.h"
81#include <map>
82#include "IccUtil.h"
83#include "IccCAM.h"

85#ifdef USEREFICCMAXNAMESPACE
86namespace refIccMAX {
87#endif

89/**
******************************************************************************
* Name: CIccFormulaCurveSegment::CIccFormulaCurveSegment
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
99CIccFormulaCurveSegment::CIccFormulaCurveSegment(icFloatNumber start, icFloatNumber end)
100{
m_nReserved = 0;
m_nReserved2 = 0;
m_startPoint = start;
m_endPoint = end;

m_nFunctionType = 0;
m_nShortcutType = 0;
m_nParameters = 0;
m_params = NULL__null;
110}

112/**
******************************************************************************
* Name: CIccFormulaCurveSegment::CIccFormulaCurveSegment
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
122CIccFormulaCurveSegment::CIccFormulaCurveSegment(const CIccFormulaCurveSegment &seg)
123{
m_nReserved = seg.m_nReserved;
m_nReserved2 = seg.m_nReserved2;
m_startPoint = seg.m_startPoint;
m_endPoint = seg.m_endPoint;

m_nFunctionType = seg.m_nFunctionType;
m_nShortcutType = seg.m_nShortcutType;
m_nParameters = seg.m_nParameters;

if (seg.m_params) {
  m_params = (icFloatNumber*)malloc(m_nParameters*sizeof(icFloatNumber));
  memcpy(m_params, seg.m_params, m_nParameters*sizeof(icFloatNumber));
}
else
  m_params = NULL__null;
139}

141/**
******************************************************************************
* Name: &CIccFormulaCurveSegment::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
151CIccFormulaCurveSegment &CIccFormulaCurveSegment::operator=(const CIccFormulaCurveSegment &seg)
152{
if (m_params)
  free(m_params);

m_nReserved = seg.m_nReserved;
m_nReserved2 = seg.m_nReserved2;
m_startPoint = seg.m_startPoint;
m_endPoint = seg.m_endPoint;

m_nFunctionType = seg.m_nFunctionType;
m_nShortcutType = seg.m_nShortcutType;
m_nParameters = seg.m_nParameters;
if (seg.m_params) {
  m_params = (icFloatNumber*)malloc(m_nParameters*sizeof(icFloatNumber));
  memcpy(m_params, seg.m_params, m_nParameters*sizeof(icFloatNumber));
}
else
  m_params = NULL__null;

return (*this);
172}

174/**
******************************************************************************
* Name: CIccFormulaCurveSegment::~CIccFormulaCurveSegment
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
184CIccFormulaCurveSegment::~CIccFormulaCurveSegment()
185{
if (m_params79.1
Field 'm_params' is non-null
) {
80
←
Taking true branch→
  free(m_params);
81
←
Attempt to free released memory
}
189}

191/**
******************************************************************************
* Name: CIccFormulaCurveSegment::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
201void CIccFormulaCurveSegment::Describe(std::string &sDescription)
202{
icChar buf[128];

sDescription += "Segment [";
if (m_startPoint==icMinFloat32Number-3.402823466e+38F)
  sDescription += "-Infinity, ";
else {
sprintf(buf, "%.8f, ", m_startPoint);
sDescription += buf;
}
if (m_endPoint==icMaxFloat32Number3.402823466e+38F)
  sDescription += "+Infinity";
else {
sprintf(buf, "%.8f", m_endPoint);
sDescription += buf;
}
sprintf(buf, "]\r\nFunctionType: %04Xh\r\n", m_nFunctionType);
sDescription += buf;

switch(m_nFunctionType) {
case 0x0000:
  if (m_params[1]==0.0 && m_params[2]==0.0)
    sprintf(buf, "Y = %.8f\r\n\r\n", m_params[3]);
  else if (m_params[0]==1.0 && m_params[1]==1.0 && m_params[2]==0.0 && m_params[3]==0.0)
    sprintf(buf, "Y = X\r\n\r\n");
  else if (m_params[0]==1.0 && m_params[2]==0.0)
    sprintf(buf, "Y = %.8f * X + %.8f\r\n\r\n", 
            m_params[1], m_params[3]);
  else
    sprintf(buf, "Y = (%.8f * X + %.8f)^%.4f + %.8f\r\n\r\n", 
            m_params[1], m_params[2], m_params[0], m_params[3]);
  sDescription += buf;
  return;

case 0x0001:
  sprintf(buf, "Y = %.8f * log (%.8f * (X ^ %.8f)  + %.8f) + %.8f\r\n\r\n",
          m_params[1], m_params[2], m_params[0], m_params[3], m_params[4]);
  sDescription += buf;
  return;

case 0x0002:
  sprintf(buf, "Y = %.8f * (%.8f ^ (%.8f * X + %.8f)) + %.8f\r\n\r\n",
          m_params[0], m_params[1], m_params[2], m_params[3], m_params[4]);
  sDescription += buf;
  return;

case 0x0003:
  if (m_params[1]==0.0 && m_params[2]==0.0)
    sprintf(buf, "Y = %.8f\r\n\r\n", m_params[3]);
  else if (m_params[0]==1.0 && m_params[1]==1.0 && m_params[2]==1.0 && m_params[3]==0.0 && m_params[4]==0.0)
    sprintf(buf, "Y = X\r\n\r\n");
  else if (m_params[0]==1.0 && m_params[1]==1.0 && m_params[3]==0.0)
    sprintf(buf, "Y = %.8f * X + %.8f\r\n\r\n", 
            m_params[2], m_params[3]);
  else if (m_params[0]==1.0 && m_params[2]==1.0 && m_params[3]==0.0)
    sprintf(buf, "Y = %.8f * X + %.8f\r\n\r\n", 
    m_params[1], m_params[3]);
  else
    sprintf(buf, "Y = %8f * (%.8f * X + %.8f)^%.4f + %.8f\r\n\r\n", 
            m_params[1], m_params[2], m_params[3], m_params[0], m_params[4]);
  sDescription += buf;
  return;

default:
  int i;
  sprintf(buf, "Unknown Function with %d parameters:\r\n\r\n", m_nParameters);
  sDescription += buf;

  for (i=0; i<m_nParameters; i++) {
    sprintf(buf, "Param[%d] = %.8lf\r\n\r\n", i, m_params[i]);
    sDescription += buf;
  }
}
275}


278/**
******************************************************************************
* Name: CIccFormulaCurveSegment::SetFunction
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
288void CIccFormulaCurveSegment::SetFunction(icUInt16Number functionType, icUInt8Number num_parameters, icFloatNumber *parameters)
289{
if (m_params)
  free(m_params);

if (num_parameters) {
  m_params = (icFloatNumber*)malloc(num_parameters * sizeof(icFloatNumber));
  memcpy(m_params, parameters, num_parameters * sizeof(icFloatNumber));
}
else
  m_params = NULL__null;

m_nFunctionType = functionType;
m_nParameters = num_parameters;
302}

304/**
******************************************************************************
* Name: CIccFormulaCurveSegment::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
314bool CIccFormulaCurveSegment::Read(icUInt32Number size, CIccIO *pIO)
315{
icCurveSegSignature sig;

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number);

if (headerSize > size)
62
←
Assuming 'headerSize' is <= 'size'→
63
←
Taking false branch→
  return false;

if (!pIO63.1
'pIO' is non-null
) {
64
←
Taking false branch→
  return false;
}

if (!pIO->Read32(&sig))
65
←
Assuming the condition is false→
66
←
Taking false branch→
  return false;

if (!pIO->Read32(&m_nReserved))
67
←
Assuming the condition is false→
68
←
Taking false branch→
  return false;

if (!pIO->Read16(&m_nFunctionType))
69
←
Assuming the condition is false→
70
←
Taking false branch→
  return false;

if (!pIO->Read16(&m_nReserved2))
71
←
Assuming the condition is false→
72
←
Taking false branch→
  return false;

if (m_params) {
73
←
Assuming field 'm_params' is non-null→
74
←
Taking true branch→
  free(m_params);
75
←
Memory is released→
}

switch(m_nFunctionType) {
76
←
Control jumps to the 'default' case at line 357→
  case 0x0000:
    m_nParameters = 4;
    break;

  case 0x0001:
  case 0x0002:
  case 0x0003:
    m_nParameters = 5;
    break;

  default:
    return false;
}

if (m_nParameters) {

  m_params = (icFloatNumber*)malloc(m_nParameters * sizeof(icFloatNumber));
  if (!m_params)
    return false;

  if (pIO->ReadFloat32Float(m_params, m_nParameters)!= m_nParameters) {
    return false;
  }
}
else
  m_params = NULL__null;

return true;
375}

377/**
******************************************************************************
* Name: CIccFormulaCurveSegment::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
387bool CIccFormulaCurveSegment::Write(CIccIO *pIO)
388{
icCurveSegSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nFunctionType))
  return false;

if (!pIO->Write16(&m_nReserved2))
  return false;

switch(m_nFunctionType) {
  case 0x0000:
    if (m_nParameters!=4)
      return false;
    break;

  case 0x0001:
  case 0x0002:
  case 0x0003:
    if (m_nParameters!=5)
      return false;
    break;
}

if (m_nParameters) {
  if (pIO->WriteFloat32Float(m_params, m_nParameters)!=m_nParameters)
    return false;
}

return true;
426}

428/**
******************************************************************************
* Name: CIccFormulaCurveSegment::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
438bool CIccFormulaCurveSegment::Begin(CIccCurveSegment *pPrevSeg = NULL__null)
439{
switch (m_nFunctionType) {
case 0x0000:
  if (!m_params || m_nParameters<4)
    return false;

  if (m_params[0] == (icFloatNumber)1.0) { //don't apply gamma
    if (m_params[2] == (icFloatNumber)0.0 && m_params[3] == (icFloatNumber)0.0)
      m_nShortcutType = 1;
    else if (m_params[2] == 0.0)
      m_nShortcutType = 2;
    else if (m_params[3] == 0.0)
      m_nShortcutType = 3;
    else
      m_nShortcutType = 4;
  }
  else {
    m_nShortcutType = 0;
  }

  return true;

case 0x0001:
  if (!m_params || m_nParameters<5)
    return false;

  return true;

case 0x0002:
case 0x0003:
  if (!m_params || m_nParameters<5)
    return false;
  
  return true;

default:
  return false;
}

return true;
479}

481/**
******************************************************************************
* Name: CIccFormulaCurveSegment::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
491icFloatNumber CIccFormulaCurveSegment::Apply(icFloatNumber v) const
492{
switch (m_nFunctionType) {
case 0x0000:
  //Y = (a * X + b) ^ g  + c        : g a b c
  switch (m_nShortcutType) {
  case 0:
  default:
    return (icFloatNumber)(pow(m_params[1] * v + m_params[2], m_params[0]) + m_params[3]);
  case 1:
    return (m_params[1] * v);
  case 2:
    return (m_params[1] * v + m_params[3]);
  case 3:
    return (m_params[1] * v + m_params[2]);
  case 4:
    return (m_params[1] * v + m_params[2] + m_params[3]);
  }

case 0x0001:
  // Y = a * log (b * X^g + c) + d  : g a b c d
  return (icFloatNumber)(m_params[1] * log10(m_params[2] * pow(v, m_params[0]) + m_params[3]) + m_params[4]);

case 0x0002:
  //Y = a * b^(c*X+d) + e           : a b c d e
  return (icFloatNumber)(m_params[0] * pow(m_params[1], m_params[2] * v + m_params[3]) + m_params[4]);

case 0x0003:
  //Y = a * (b * X + c) ^ g  + d        : g a b c d
  return (icFloatNumber)(m_params[1] * pow(m_params[2] * v + m_params[3], m_params[0]) + m_params[4]);
}

//Shouldn't get here!
return v;
525}

527/**
******************************************************************************
* Name: CIccFormulaCurveSegment::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
537icValidateStatus CIccFormulaCurveSegment::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
538{
CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

icValidateStatus rv = icValidateOK;
if (m_nReserved || m_nReserved2) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " formula curve has non zero reserved data.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}

switch (m_nFunctionType) {
case 0x0000:
  if (!m_params || m_nParameters<4) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " formula curve has Invalid formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
  else if (m_nParameters > 4) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " formula curve has too many formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
  break;

case 0x0001:
  if (!m_params || m_nParameters<5) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " formula curve has Invalid formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
  else if (m_nParameters > 5) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " formula curve has too many formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
  break;

case 0x0002:
  if (!m_params || m_nParameters<5) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " formula curve has Invalid formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
  else if (m_nParameters > 5) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " formula curve has too many formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
  break;

case 0x0003:
  if (!m_params || m_nParameters<5) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " formula curve has Invalid formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
  else if (m_nParameters > 5) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " formula curve has too many formulaCurveSegment parameters.\r\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
  break;

default:
  {
    icChar buf[128];
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sprintf(buf, " formula curve uses unknown formulaCurveSegment function type %d\r\n", m_nFunctionType);
    sReport += buf;
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
}

return rv;
623}

625/**
******************************************************************************
* Name: CIccSampledCurveSegment::CIccSampledCurveSegment
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
635CIccSampledCurveSegment::CIccSampledCurveSegment(icFloatNumber start, icFloatNumber end)
636{
m_nReserved = 0;
m_startPoint = start;
m_endPoint = end;
m_nCount = 0;
m_pSamples = 0;
642}

644/**
******************************************************************************
* Name: CIccSampledCurveSegment::CIccSampledCurveSegment
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
654CIccSampledCurveSegment::CIccSampledCurveSegment(const CIccSampledCurveSegment &curve)
655{
m_nReserved = curve.m_nReserved;
m_startPoint = curve.m_startPoint;
m_endPoint = curve.m_endPoint;
m_nCount = curve.m_nCount;

if (m_nCount) {
  m_pSamples = (icFloatNumber*)malloc(m_nCount * sizeof(icFloatNumber));
  if (m_pSamples)
    memcpy(m_pSamples, curve.m_pSamples, m_nCount * sizeof(icFloatNumber));
  else
    m_nCount = 0;
}
else{
  m_pSamples = NULL__null;
}
671}

673/**
******************************************************************************
* Name: &CIccSampledCurveSegment::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
683CIccSampledCurveSegment &CIccSampledCurveSegment::operator=(const CIccSampledCurveSegment &curve)
684{
if (m_pSamples)
  free(m_pSamples);

m_nReserved = curve.m_nReserved;
m_startPoint = curve.m_startPoint;
m_endPoint = curve.m_endPoint;
m_nCount = curve.m_nCount;

if (m_nCount) {
  m_pSamples = (icFloatNumber*)malloc(m_nCount * sizeof(icFloatNumber));
  if (m_pSamples)
    memcpy(m_pSamples, curve.m_pSamples, m_nCount * sizeof(icFloatNumber));
  else
    m_nCount = 0;
}
else {
  m_pSamples = NULL__null;
}
return (*this);
704}

706/**
******************************************************************************
* Name: CIccSampledCurveSegment::~CIccSampledCurveSegment
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
716CIccSampledCurveSegment::~CIccSampledCurveSegment()
717{
if (m_pSamples)
  free(m_pSamples);
720}

722/**
******************************************************************************
* Name: CIccSampledCurveSegment::SetSize
* 
* Purpose: 
*  Sets size of sampled lookup table.  Previous data (if exists) is lost.
* 
* Args: 
*  nCount = number of elements in lut (must be >= 2).  Note: the m_pSample[0] is
*    initialized from the the previous segment.  It is not saved as part
*    of Write(), or loaded as part of Read().  It will be initialized during
*    the call to Begin(),  The actual count of elements written to the file
*    will be nCount-1
*  bZeroAlloc = flag to decide if memory should be set to zero.
* 
* Return: 
*  true if allocation successful.
******************************************************************************/
740bool CIccSampledCurveSegment::SetSize(icUInt32Number nCount, bool bZeroAlloc/*=true*/)
741{
if (!nCount) {
  if (m_pSamples)
    free(m_pSamples);
  m_pSamples = NULL__null;
  m_nCount = nCount;
  return true;
}

if (m_pSamples) {
  free(m_pSamples);
}

if (bZeroAlloc)
  m_pSamples = (icFloatNumber*)calloc(nCount, sizeof(icFloatNumber));
else
  m_pSamples = (icFloatNumber*)malloc(nCount * sizeof(icFloatNumber));

if (m_pSamples)
  m_nCount = nCount;
else
  m_nCount = 0;

return (m_pSamples != NULL__null);
765}

767/**
******************************************************************************
* Name: CIccSampledCurveSegment::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
777void CIccSampledCurveSegment::Describe(std::string &sDescription)
778{
icChar buf[128];

if (m_nCount<2) {
  sDescription += "Empty Segment [";
  if (m_startPoint==icMinFloat32Number-3.402823466e+38F)
    sDescription += "-Infinity, ";
  else {
  sprintf(buf, "%.8f, ", m_startPoint);
  sDescription += buf;
  }
  if (m_endPoint==icMaxFloat32Number3.402823466e+38F)
    sDescription += "+Infinity";
  else {
  sprintf(buf, "%.8f", m_endPoint);
  sDescription += buf;
  }

  sprintf(buf, "]\r\n");
  sDescription += buf;
}
else {
  sDescription += "Sampled Segment [";
  if (m_startPoint==icMinFloat32Number-3.402823466e+38F)
    sDescription += "-Infinity, ";
  else {
  sprintf(buf, "%.8f, ", m_startPoint);
  sDescription += buf;
  }
  if (m_endPoint==icMaxFloat32Number3.402823466e+38F)
    sDescription += "+Infinity";
  else {
  sprintf(buf, "%.8f", m_endPoint);
  sDescription += buf;
  }
  sprintf(buf, "]\r\n");
  sDescription += buf;
  sDescription += "IN  OUT\r\n";

  icUInt32Number i;

  icFloatNumber range = m_endPoint - m_startPoint;
  icFloatNumber last = (icFloatNumber)(m_nCount-1);

  for (i=1; i<m_nCount; i++) {
    sprintf(buf, "%.8f %.8f\r\n", m_startPoint + (icFloatNumber)i*range/last, m_pSamples[i]);
    sDescription += buf;
  }
}
sDescription += "\r\n";
828}

830/**
******************************************************************************
* Name: CIccSampledCurveSegment::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
840bool CIccSampledCurveSegment::Read(icUInt32Number size, CIccIO *pIO)
841{
icCurveSegSignature sig;

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt32Number);

if (headerSize > size)
  return false;

if (!pIO) {
  return false;
}

if (!pIO->Read32(&sig))
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read32(&m_nCount))
  return false;

if (m_nCount > size - headerSize || m_nCount * sizeof(icFloat32Number) > size - headerSize)
  return false;

//Reserve room for first point who's value comes from previous segment
m_nCount++;

if (!SetSize(m_nCount, false))
  return false;

if (m_nCount) {
  if (pIO->ReadFloat32Float(m_pSamples+1, m_nCount-1)!=(icInt32Number)(m_nCount-1))
    return false;
}

//Initialize first point with zero.  Properly initialized during Begin()
m_pSamples[0] = 0;

return true;
882}

884/**
******************************************************************************
* Name: CIccSampledCurveSegment::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
894bool CIccSampledCurveSegment::Write(CIccIO *pIO)
895{
icCurveSegSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

icUInt32Number nCount;

if (m_nCount)
  nCount = m_nCount -1;
else
  nCount = 0;

if (!pIO->Write32(&nCount))
  return false;

//First point in samples is ONLY for interpolation (not saved)
if (nCount) {
  if (pIO->WriteFloat32Float(m_pSamples+1, nCount)!=(icInt32Number)nCount)
    return false;
}

return true;
924}

926/**
******************************************************************************
* Name: CIccSampledCurveSegment::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
936bool CIccSampledCurveSegment::Begin(CIccCurveSegment *pPrevSeg = NULL__null)
937{
if (m_nCount<2)
  return false;

m_range = m_endPoint - m_startPoint;
m_last = (icFloatNumber)(m_nCount - 1);

if (m_endPoint-m_startPoint == 0.0)
  return false;

if (!pPrevSeg)
  return false;

//Set up interpolation from Application of last segment
m_pSamples[0] = pPrevSeg->Apply(m_startPoint);

return true;
954}

956/**
******************************************************************************
* Name: CIccSampledCurveSegment::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
966icFloatNumber CIccSampledCurveSegment::Apply(icFloatNumber v) const
967{
if (v<m_startPoint)
  v=m_startPoint;
else if (v>m_endPoint)
  v=m_endPoint;

icFloatNumber pos = (v-m_startPoint)/m_range * m_last;
icUInt32Number index = (icUInt32Number) pos;
icFloatNumber remainder = pos - (icFloatNumber)index;

if (remainder==0.0)
  return m_pSamples[index];

return (icFloatNumber)((1.0-remainder)*m_pSamples[index] + remainder*m_pSamples[index+1]);
981}

983/**
******************************************************************************
* Name: CIccSampledCurveSegment::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
993icValidateStatus CIccSampledCurveSegment::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
994{
CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

icValidateStatus rv = icValidateOK;
if (m_nReserved) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " sampled curve has non zero reserved data.\r\n";
  rv = icValidateWarning;
}

if (m_nCount<1) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " sampled curve has too few sample points.\r\n";
  rv = icMaxStatus(rv, icValidateCriticalError);
}
else if (m_endPoint-m_startPoint == 0.0) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " sampled curve has a range of zero.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}

return rv;
1020}



1024/**
1025******************************************************************************
1026* Name: CIccSingleSampledCurve::CIccSingleSampledCurve
1027* 
1028* Purpose: 
1029* 
1030* Args: 
1031* 
1032* Return: 
1033******************************************************************************/
1034CIccSingleSampledCurve::CIccSingleSampledCurve(icFloatNumber first, icFloatNumber last)
1035{
m_nReserved = 0;
m_nCount = 0;
m_pSamples = 0;

m_storageType = icValueTypeFloat32;
m_extensionType = icClipSingleSampledCurve;

if (first < last) {
  m_firstEntry = first;
  m_lastEntry = last;
}
else {
  m_firstEntry = last;
  m_lastEntry = first;
}

m_loIntercept = 0;
m_loSlope = 0;
m_hiIntercept = 1.0;
m_hiSlope = 0;
1056}

1058/**
1059******************************************************************************
1060* Name: CIccSingleSampledCurve::CIccSingleSampledCurve
1061* 
1062* Purpose: 
1063* 
1064* Args: 
1065* 
1066* Return: 
1067******************************************************************************/
1068CIccSingleSampledCurve::CIccSingleSampledCurve(const CIccSingleSampledCurve &curve)
1069{
m_nReserved = curve.m_nReserved;
m_nCount = curve.m_nCount;

m_storageType = curve.m_storageType;
m_extensionType = curve.m_extensionType;

if (m_nCount) {
  m_pSamples = (icFloatNumber*)malloc(m_nCount * sizeof(icFloatNumber));
  if (m_pSamples)
    memcpy(m_pSamples, curve.m_pSamples, m_nCount * sizeof(icFloatNumber));
  else
    m_nCount = 0;
}
else{
  m_pSamples = NULL__null;
}

m_firstEntry = curve.m_firstEntry;
m_lastEntry = curve.m_lastEntry;

m_loIntercept = curve.m_loIntercept;
m_loSlope = curve.m_loSlope;
m_hiIntercept = curve.m_hiIntercept;
m_hiSlope = curve.m_hiSlope;
1094}

1096/**
1097******************************************************************************
1098* Name: &CIccSingleSampledCurve::operator=
1099* 
1100* Purpose: 
1101* 
1102* Args: 
1103* 
1104* Return: 
1105******************************************************************************/
1106CIccSingleSampledCurve &CIccSingleSampledCurve::operator=(const CIccSingleSampledCurve &curve)
1107{
if (m_pSamples)
  free(m_pSamples);

m_nReserved = curve.m_nReserved;
m_nCount = curve.m_nCount;

m_storageType = curve.m_storageType;
m_extensionType = curve.m_extensionType;

if (m_nCount) {
  m_pSamples = (icFloatNumber*)malloc(m_nCount * sizeof(icFloatNumber));
  if (m_pSamples)
    memcpy(m_pSamples, curve.m_pSamples, m_nCount * sizeof(icFloatNumber));
  else
    m_nCount = 0;
}
else {
  m_pSamples = NULL__null;
}

m_firstEntry = curve.m_firstEntry;
m_lastEntry = curve.m_lastEntry;

m_loIntercept = curve.m_loIntercept;
m_loSlope = curve.m_loSlope;
m_hiIntercept = curve.m_hiIntercept;
m_hiSlope = curve.m_hiSlope;
return (*this);
1136}

1138/**
1139******************************************************************************
1140* Name: CIccSingleSampledCurve::~CIccSingleSampledCurve
1141* 
1142* Purpose: 
1143* 
1144* Args: 
1145* 
1146* Return: 
1147******************************************************************************/
1148CIccSingleSampledCurve::~CIccSingleSampledCurve()
1149{
if (m_pSamples)
  free(m_pSamples);
1152}

1154/**
1155******************************************************************************
1156* Name: CIccSingleSampledCurve::SetRange
1157* 
1158* Purpose: 
1159*  Sets range of sampled lookup table.
1160* 
1161* Args: 
1162*  first = first entry input position
1163*  last = last entry input position
1164******************************************************************************/
1165void CIccSingleSampledCurve::SetRange(icFloatNumber first/* =0.0f */, icFloatNumber last/* =1.0f */)
1166{
if (first < last) {
  m_firstEntry = first;
  m_lastEntry = last;
}
else {
  m_firstEntry = last;
  m_lastEntry = first;
}
1175}


1178/**
1179******************************************************************************
1180* Name: CIccSingleSampledCurve::SetExtensionType
1181*
1182* Purpose:
1183*  Sets extension type of the single sampled curve
1184*
1185* Args:
1186*  nExtensionType is type of extension to use
1187*
1188* Return:
1189*  true if valid extension type, false otherwise
1190******************************************************************************/
1191bool CIccSingleSampledCurve::SetExtensionType(icUInt16Number nExtensionType)
1192{
m_extensionType = nExtensionType;

switch (nExtensionType) {
  case icClipSingleSampledCurve:
  case icExtendSingleSampledCurve:
    return true;
}
return false;
1201}

1203/**
1204******************************************************************************
1205* Name: CIccSingleSampledCurve::SetStorageType
1206*
1207* Purpose:
1208*  Sets storate type of the data stored in the single sampled curve
1209*
1210* Args:
1211*  nStorageType is type of data to use
1212*
1213* Return:
1214*  true if valid storage type, false otherwise
1215******************************************************************************/
1216bool CIccSingleSampledCurve::SetStorageType(icUInt16Number nStorateType)
1217{
m_storageType = nStorateType;

switch (nStorateType) {
  case icValueTypeUInt8:
  case icValueTypeUInt16:
  case icValueTypeFloat16:
  case icValueTypeFloat32:
    return true;
}
return false;
1228}


1231/**
1232******************************************************************************
1233* Name: CIccSingleSampledCurve::SetSize
1234* 
1235* Purpose: 
1236*  Sets size of sampled lookup table.  Previous data (if exists) is lost.
1237* 
1238* Args: 
1239*  nCount = number of elements in lut (must be >= 2).  
1240*  bZeroAlloc = flag to decide if memory should be set to zero.
1241* 
1242* Return: 
1243*  true if allocation successful.
1244******************************************************************************/
1245bool CIccSingleSampledCurve::SetSize(icUInt32Number nCount, bool bZeroAlloc/*=true*/)
1246{
if (!nCount) {
  if (m_pSamples)
    free(m_pSamples);
  m_pSamples = NULL__null;
  m_nCount = nCount;
  return true;
}

if (m_pSamples) {
  free(m_pSamples);
}

if (bZeroAlloc)
  m_pSamples = (icFloatNumber*)calloc(nCount, sizeof(icFloatNumber));
else
  m_pSamples = (icFloatNumber*)malloc(nCount * sizeof(icFloatNumber));

if (m_pSamples)
  m_nCount = nCount;
else
  m_nCount = 0;

return (m_pSamples != NULL__null);
1270}

1272/**
1273******************************************************************************
1274* Name: CIccSingleSampledCurve::Describe
1275* 
1276* Purpose: 
1277* 
1278* Args: 
1279* 
1280* Return: 
1281******************************************************************************/
1282void CIccSingleSampledCurve::Describe(std::string &sDescription)
1283{
icChar buf[128];

if (m_nCount<2) {
  sDescription += "Empty Single Sampled Curve [";
  sprintf(buf, "%.8f, ", m_firstEntry);
  sDescription += buf;

  sprintf(buf, "%.8f", m_lastEntry);
  sDescription += buf;

  sprintf(buf, "]\r\n");
  sDescription += buf;
}
else {
  sDescription += "Single Sampled Curve [";

  sprintf(buf, "%.8f, ", m_firstEntry);
  sDescription += buf;

  sprintf(buf, "%.8f", m_lastEntry);
  sDescription += buf;

  sprintf(buf, "]\r\n");
  sDescription += buf;

  switch(m_storageType) {
    case icValueTypeUInt8:
      sDescription +="UInt8Number Array\n";
      break;
    case icValueTypeUInt16:
      sDescription +="UInt16Number Array\n";
      break;
    case icValueTypeFloat16:
      sDescription +="Float16Number Array\n";
      break;
    case icValueTypeFloat32:
      sDescription +="Float32Number Array\n";
      break;
    default:
      sDescription +="Unknown Data Type\n";
      break;
  }

  switch(m_extensionType) {
    case icClipSingleSampledCurve:
      sDescription += "Clip End Points\n";
      break;
    case icExtendSingleSampledCurve:
      sDescription += "Extend End Points\n";
      break;
    default:
      sDescription += "Unknown extension handling\n";
      break;
  }
  sDescription += "IN  OUT\r\n";

  icUInt32Number i;

  icFloatNumber range = m_lastEntry - m_firstEntry;
  icFloatNumber last = (icFloatNumber)(m_nCount-1);

  for (i=0; i<m_nCount; i++) {
    sprintf(buf, "%.8f %.8f\r\n", m_firstEntry + (icFloatNumber)i*range/last, m_pSamples[i]);
    sDescription += buf;
  }
}
sDescription += "\r\n";
1351}

1353/**
1354******************************************************************************
1355* Name: CIccSingleSampledCurve::Read
1356* 
1357* Purpose: 
1358* 
1359* Args: 
1360* 
1361* Return: 
1362******************************************************************************/
1363bool CIccSingleSampledCurve::Read(icUInt32Number size, CIccIO *pIO)
1364{
icCurveSegSignature sig;

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt32Number) +
  sizeof(icFloat32Number) +
  sizeof(icFloat32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number);

if (headerSize > size)
  return false;

if (!pIO) {
  return false;
}

if (!pIO->Read32(&sig) || sig!=GetType())
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read32(&m_nCount))
  return false;

if (!pIO->ReadFloat32Float(&m_firstEntry))
  return false;

if (!pIO->ReadFloat32Float(&m_lastEntry))
  return false;

if (!pIO->Read16(&m_extensionType))
  return false;

if (!pIO->Read16(&m_storageType))
  return false;

if (!SetSize(m_nCount, false))
  return false;

if (m_nCount > size - headerSize)
  return false;

if (m_nCount) {
  switch(m_storageType) {
    case icValueTypeUInt8:
      if (m_nCount * sizeof(icUInt8Number) > size - headerSize)
        return false;

      if (pIO->ReadUInt8Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    case icValueTypeUInt16:
      if (m_nCount * 2 > size - headerSize)
        return false;

      if (pIO->ReadUInt16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    case icValueTypeFloat16:
      if (m_nCount * 2 > size - headerSize)
        return false;

      if (pIO->ReadFloat16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    case icValueTypeFloat32:
      if (m_nCount * sizeof(icFloat32Number) > size - headerSize)
        return false;

      if (pIO->ReadFloat32Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    default:
      return false;
  }
}

return true;
1445}

1447/**
1448******************************************************************************
1449* Name: CIccSingleSampledCurve::Write
1450* 
1451* Purpose: 
1452* 
1453* Args: 
1454* 
1455* Return: 
1456******************************************************************************/
1457bool CIccSingleSampledCurve::Write(CIccIO *pIO)
1458{
icCurveElemSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write32(&m_nCount))
  return false;

if (!pIO->WriteFloat32Float(&m_firstEntry))
  return false;

if (!pIO->WriteFloat32Float(&m_lastEntry))
  return false;

if (!pIO->Write16(&m_extensionType))
  return false;

if (!pIO->Write16(&m_storageType))
  return false;

if (m_nCount) {

  switch(m_storageType) {
    case icValueTypeUInt8:
      if (pIO->WriteUInt8Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    case icValueTypeUInt16:
      if (pIO->WriteUInt16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    case icValueTypeFloat16:
      if (pIO->WriteFloat16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    case icValueTypeFloat32:
      if (pIO->WriteFloat32Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
        return false;
      break;
    default:
      return false;
  }
}

return true;
1510}

1512/**
1513******************************************************************************
1514* Name: CIccSingleSampledCurve::Begin
1515* 
1516* Purpose: 
1517* 
1518* Args: 
1519* 
1520* Return: 
1521******************************************************************************/
1522bool CIccSingleSampledCurve::Begin()
1523{
if (m_nCount<2)
  return false;

m_range = m_lastEntry - m_firstEntry;
m_last = (icFloatNumber)(m_nCount - 1);
icFloatNumber stepSize = m_range / m_last;

if (m_range == 0.0)
  return false;

switch(m_extensionType) {
  case icClipSingleSampledCurve:
    m_loSlope=0.0;
    m_loIntercept = m_pSamples[0];

    m_hiSlope=0.0;
    m_hiIntercept = m_pSamples[m_nCount-1];
    break;

  case icExtendSingleSampledCurve:
    m_loSlope = (m_pSamples[1]-m_pSamples[0])/stepSize;
    m_loIntercept = m_pSamples[0] - m_loSlope*m_firstEntry;

    m_hiSlope = (m_pSamples[m_nCount-1] - m_pSamples[m_nCount-2])/stepSize;
    m_hiIntercept = m_pSamples[m_nCount-1] - m_hiSlope*m_lastEntry;
    break;

  default:
    return false;
}

return true;
1556}

1558/**
1559******************************************************************************
1560* Name: CIccSingleSampledCurve::Apply
1561* 
1562* Purpose: 
1563* 
1564* Args: 
1565* 
1566* Return: 
1567******************************************************************************/
1568icFloatNumber CIccSingleSampledCurve::Apply(icFloatNumber v) const
1569{
if (v<m_firstEntry) {
  return m_loSlope * v + m_loIntercept;;
}
else if (v>m_lastEntry) {
  return m_hiSlope * v + m_hiIntercept;
}

icFloatNumber pos = (v-m_firstEntry)/m_range * m_last;
icUInt32Number index = (icUInt32Number) pos;
icFloatNumber remainder = pos - (icFloatNumber)index;

if (remainder==0.0)
  return m_pSamples[index];

return (icFloatNumber)((1.0-remainder)*m_pSamples[index] + remainder*m_pSamples[index+1]);
1585}

1587/**
1588******************************************************************************
1589* Name: CIccSingleSampledCurve::Validate
1590* 
1591* Purpose: 
1592* 
1593* Args: 
1594* 
1595* Return: 
1596******************************************************************************/
1597icValidateStatus CIccSingleSampledCurve::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
1598{
CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

icValidateStatus rv = icValidateOK;
if (m_nReserved) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " single sampled curve has non zero reserved data.\r\n";
  rv = icValidateWarning;
}

if (m_extensionType > icMaxSingleSampledCurveTypeicExtendSingleSampledCurve) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " single sampled curve has unknown extension type\r\n";
  rv = icMaxStatus(rv, icValidateCriticalError);
}

if (m_storageType > icMaxValueTypeicValueTypeUInt8) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " single sampled curve uses unknown value type\r\n";
  rv = icMaxStatus(rv, icValidateCriticalError);
}

if (m_nCount<2) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " single sampled curve has too few sample points.\r\n";
  rv = icMaxStatus(rv, icValidateCriticalError);
}

else if (m_lastEntry-m_firstEntry <= 0.0) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " single sampled curve has an invalid sample range.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}

return rv;
1639}

1641/**
******************************************************************************
* Name: CIccCurveSegment::Create
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1651CIccCurveSegment* CIccCurveSegment::Create(icCurveSegSignature sig, icFloatNumber start, icFloatNumber end)
1652{
switch(sig) {
case icSigFormulaCurveSeg:
  return new CIccFormulaCurveSegment(start, end);
case icSigSampledCurveSeg:
  return new CIccSampledCurveSegment(start, end);
default:
  return NULL__null;
}

1662}

1664/**
******************************************************************************
* Name: CIccSegmentedCurve::CIccSegmentedCurve
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1674CIccSegmentedCurve::CIccSegmentedCurve()
1675{
m_list = new CIccCurveSegmentList();
m_nReserved1 = 0;
m_nReserved2 = 0;

1680}


1683/**
******************************************************************************
* Name: CIccSegmentedCurve::CIccSegmentedCurve
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1693CIccSegmentedCurve::CIccSegmentedCurve(const CIccSegmentedCurve &curve)
1694{
CIccCurveSegmentList::iterator i;

m_list = new CIccCurveSegmentList();

for (i=curve.m_list->begin(); i!=curve.m_list->end(); i++) {
  m_list->push_back((*i)->NewCopy());
}
m_nReserved1 = curve.m_nReserved1;
m_nReserved2 = curve.m_nReserved2;
1704}


1707/**
******************************************************************************
* Name: &CIccSegmentedCurve::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1717CIccSegmentedCurve &CIccSegmentedCurve::operator=(const CIccSegmentedCurve &curve)
1718{
Reset();

CIccCurveSegmentList::iterator i;

for (i=curve.m_list->begin(); i!=curve.m_list->end(); i++) {
  m_list->push_back((*i)->NewCopy());
}
m_nReserved1 = curve.m_nReserved1;
m_nReserved2 = curve.m_nReserved2;

return (*this);
1730}


1733/**
******************************************************************************
* Name: CIccSegmentedCurve::~CIccSegmentedCurve
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1743CIccSegmentedCurve::~CIccSegmentedCurve()
1744{
Reset();
delete m_list;
1747}


1750/**
******************************************************************************
* Name: CIccSegmentedCurve::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1760void CIccSegmentedCurve::Describe(std::string &sDescription)
1761{
CIccCurveSegmentList::iterator i;

sDescription += "BEGIN_CURVE\r\n";
for (i=m_list->begin(); i!=m_list->end(); i++) {
  (*i)->Describe(sDescription);
}
1768}



1772/**
******************************************************************************
* Name: CIccSegmentedCurve::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1782bool CIccSegmentedCurve::Read(icUInt32Number size, CIccIO *pIO)
1783{
icCurveElemSignature sig;

icUInt32Number startPos = pIO->Tell();

icUInt32Number headerSize = sizeof(icCurveElemSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number);

if (headerSize > size)
41
←
Assuming 'headerSize' is <= 'size'→
42
←
Taking false branch→
  return false;

if (!pIO42.1
'pIO' is non-null
) {
43
←
Taking false branch→
  return false;
}

if (!pIO->Read32(&sig))
44
←
Assuming the condition is false→
45
←
Taking false branch→
  return false;

if (sig!=GetType())
46
←
Assuming the condition is false→
47
←
Taking false branch→
  return false;

if (!pIO->Read32(&m_nReserved1))
48
←
Assuming the condition is false→
49
←
Taking false branch→
  return false;

icUInt16Number nSegments;

if (!pIO->Read16(&nSegments))
50
←
Assuming the condition is false→
51
←
Taking false branch→
  return false;

if (!pIO->Read16(&m_nReserved2))
52
←
Assuming the condition is false→
53
←
Taking false branch→
  return false;

Reset();

icUInt32Number pos = pIO->Tell();
icCurveSegSignature segSig;
CIccCurveSegment *pSeg;

if (nSegments==1) {
54
←
Assuming 'nSegments' is equal to 1→
55
←
Taking true branch→
  if (sizeof(segSig) > size - headerSize)
56
←
Assuming the condition is false→
57
←
Taking false branch→
    return false;

  if (!pIO->Read32(&segSig))
58
←
Assuming the condition is false→
59
←
Taking false branch→
    return false;
  pSeg = CIccCurveSegment::Create(segSig, icMinFloat32Number-3.402823466e+38F, icMaxFloat32Number3.402823466e+38F);
  if (!pSeg59.1
'pSeg' is non-null
)
60
←
Taking false branch→
    return false;

  pIO->Seek(pos, icSeekSet);

  if (!pSeg->Read(size-(pos-startPos), pIO)) {
61
←
Calling 'CIccFormulaCurveSegment::Read'→
77
←
Returning; memory was released→
78
←
Taking true branch→
    delete pSeg;
79
←
Calling '~CIccFormulaCurveSegment'→
    return false;
  }

  m_list->push_back(pSeg);
}
else if (nSegments) {
  if (nSegments > size - headerSize)
    return false;

  icFloatNumber *breakpoints=(icFloatNumber*)calloc(nSegments-1, sizeof(icFloatNumber));

  if (!breakpoints)
    return false;

  if (pIO->ReadFloat32Float(breakpoints, nSegments-1)!=nSegments-1) {
    free(breakpoints);
    return false;
  }

  int i;
  for (i=0; i<nSegments; i++) {
    pos = pIO->Tell();
    if (!pIO->Read32(&segSig)) {
      free(breakpoints);
      return false;
    }
    if (pIO->Seek(pos, icSeekSet)!=(icInt32Number)pos)
      return false;;

    if (!i)
      pSeg = CIccCurveSegment::Create(segSig, icMinFloat32Number-3.402823466e+38F, breakpoints[i]);
    else if (i==nSegments-1) 
      pSeg = CIccCurveSegment::Create(segSig, breakpoints[i-1], icMaxFloat32Number3.402823466e+38F);
    else
      pSeg = CIccCurveSegment::Create(segSig, breakpoints[i-1], breakpoints[i]);
    
    if (!pSeg) {
      free(breakpoints);
      return false;
    }

    if (!pSeg->Read(size-(pos-startPos), pIO)) {
      delete pSeg;
      free(breakpoints);
      return false;
    }

    m_list->push_back(pSeg);
  }

  free(breakpoints);
}

return true;
1891}


1894/**
******************************************************************************
* Name: CIccSegmentedCurve::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1904bool CIccSegmentedCurve::Write(CIccIO *pIO)
1905{
icCurveElemSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved1))
  return false;

icUInt16Number nSegments = (icUInt16Number)m_list->size();

if (!pIO->Write16(&nSegments))
  return false;

if (!pIO->Write16(&m_nReserved2))
  return false;

CIccCurveSegmentList::iterator i;
if (nSegments>1) {
  icFloatNumber breakpoint;
  
  i=m_list->begin();
  for (i++; i!=m_list->end(); i++) {
    breakpoint = (*i)->StartPoint();
    if (!pIO->WriteFloat32Float(&breakpoint))
      return false;
  }
}
for (i=m_list->begin(); i!=m_list->end(); i++) {
  if (!(*i)->Write(pIO))
    return false;
}

return true;
1942}


1945/**
******************************************************************************
* Name: CIccSegmentedCurve::Reset
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1955void CIccSegmentedCurve::Reset()
1956{
CIccCurveSegmentList::iterator i;

for (i=m_list->begin(); i!=m_list->end(); i++) {
  delete (*i);
}
m_list->clear();
1963}


1966/**
******************************************************************************
* Name: CIccSegmentedCurve::Insert
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
1976bool CIccSegmentedCurve::Insert(CIccCurveSegment *pCurveSegment)
1977{
CIccCurveSegmentList::reverse_iterator last = m_list->rbegin();

if (last!=m_list->rend()) {
  if (pCurveSegment->StartPoint() == (*last)->EndPoint()) {
    m_list->push_back(pCurveSegment);
    return true;
  }
}
else {
  m_list->push_back(pCurveSegment);
  return true;
}

return false;
1992}


1995/**
******************************************************************************
* Name: CIccSegmentedCurve::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2005bool CIccSegmentedCurve::Begin()
2006{
if (m_list->size()==0)
  return false;

CIccCurveSegmentList::iterator i;
CIccCurveSegment *pLast = NULL__null;

for (i=m_list->begin(); i!=m_list->end(); i++) {
  if (!(*i)->Begin(pLast))
    return false;
  pLast = *i;
}

return true;
2020}


2023/**
******************************************************************************
* Name: CIccSegmentedCurve::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2033icFloatNumber CIccSegmentedCurve::Apply(icFloatNumber v) const
2034{
CIccCurveSegmentList::iterator i;

for (i=m_list->begin(); i!=m_list->end(); i++) {
  if (v <= (*i)->EndPoint())
    return (*i)->Apply(v);
}
return v;
2042}

2044/**
******************************************************************************
* Name: CIccSegmentedCurve::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2054icValidateStatus CIccSegmentedCurve::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
2055{
CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

icValidateStatus rv = icValidateOK;
if (m_nReserved1 || m_nReserved2) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " Segmented curve has non zero reserved data.\r\n";
  rv = icValidateWarning;
}

if (m_list->size()==0) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " Has Empty CurveSegment!\r\n";
  return icMaxStatus(rv, icValidateCriticalError);
}

CIccCurveSegmentList::iterator i;

for (i=m_list->begin(); i!=m_list->end(); i++) {
  rv = icMaxStatus(rv, (*i)->Validate(sigPath+icGetSigPath(GetType()), sReport, pMPE));
}

return rv;
2081}


2084/**
******************************************************************************
* Name: CIccCurveSetCurve::Create
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2094CIccCurveSetCurve* CIccCurveSetCurve::Create(icCurveElemSignature sig)
2095{
switch (sig) {
case icSigSegmentedCurve:
  return new CIccSegmentedCurve();
case icSigSingleSampledCurve:
  return new CIccSingleSampledCurve();
default:
  return NULL__null;
}
2104}

2106/**
******************************************************************************
* Name: CIccMpeCurveSet::CIccMpeCurveSet
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2116CIccMpeCurveSet::CIccMpeCurveSet(int nSize/*=0*/)
2117{
m_nReserved = 0;
if (nSize) {
  m_nInputChannels = m_nOutputChannels = nSize;
  m_curve = (icCurveSetCurvePtr*)calloc(nSize, sizeof(icCurveSetCurvePtr));
  m_position = (icPositionNumber*)calloc(nSize, sizeof(icPositionNumber));
}
else {
  m_nInputChannels = m_nOutputChannels = 0;
  m_curve = NULL__null;
  m_position = NULL__null;
}
2129}

2131typedef std::map<icCurveSetCurvePtr, icCurveSetCurvePtr> icCurveMap;

2133/**
******************************************************************************
* Name: CIccMpeCurveSet::CIccMpeCurveSet
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2143CIccMpeCurveSet::CIccMpeCurveSet(const CIccMpeCurveSet &curveSet)
2144{
m_nReserved = curveSet.m_nReserved;

if (curveSet.m_nInputChannels) {
  int i;

  m_nInputChannels = m_nOutputChannels = curveSet.m_nInputChannels;
  m_curve = (icCurveSetCurvePtr*)calloc(m_nInputChannels, sizeof(icCurveSetCurvePtr));
  m_position = (icPositionNumber*)calloc(m_nInputChannels, sizeof(icPositionNumber));

  icCurveMap map;
  for (i=0; i<m_nInputChannels; i++) {
    CIccCurveSetCurve *ptr = curveSet.m_curve[i];
    if (ptr) {
      if (!map[ptr]) {
        m_curve[i] = ptr->NewCopy();
        map[ptr] = m_curve[i];
      }
      else
        m_curve[i] = map[ptr];
    }
  }
}
else {
  m_nInputChannels = m_nOutputChannels = 0;
  m_curve = NULL__null;
}
2171}

2173/**
******************************************************************************
* Name: &CIccMpeCurveSet::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2183CIccMpeCurveSet &CIccMpeCurveSet::operator=(const CIccMpeCurveSet &curveSet)
2184{
m_nReserved = m_nReserved;

if (m_curve) {
  free(m_curve);
}

if (curveSet.m_nInputChannels) {
  int i;

  m_nInputChannels = m_nOutputChannels = curveSet.m_nInputChannels;
  m_curve = (icCurveSetCurvePtr*)calloc(m_nInputChannels, sizeof(icCurveSetCurvePtr));
  m_position = (icPositionNumber*)calloc(m_nInputChannels, sizeof(icPositionNumber));

  icCurveMap map;
  for (i=0; i<m_nInputChannels; i++) {
    CIccCurveSetCurve *ptr = curveSet.m_curve[i];
    if (ptr) {
      if (!map[ptr]) {
        m_curve[i] = ptr->NewCopy();
        map[ptr] = m_curve[i];
      }
      else
        m_curve[i] = map[ptr];
    }
  }
}
else {
  m_nInputChannels = m_nOutputChannels = 0;
  m_curve = NULL__null;
}

return *this;
2217}

2219/**
******************************************************************************
* Name: CIccMpeCurveSet::~CIccMpeCurveSet
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2229CIccMpeCurveSet::~CIccMpeCurveSet()
2230{
SetSize(0);
2232}

2234/**
******************************************************************************
* Name: CIccMpeCurveSet::SetSize
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2244bool CIccMpeCurveSet::SetSize(int nNewSize)
2245{
if (m_curve) {
  icCurveMap map;
  int i;

  for (i=0; i<m_nInputChannels; i++) {
    if (!map[m_curve[i]]) {
      map[m_curve[i]] = (CIccCurveSetCurve*)1;
      delete m_curve[i];
    }
  }
  free(m_curve);
}
if (m_position) {
  free(m_position);
}

if (nNewSize) {
  m_curve = (icCurveSetCurvePtr*)calloc(nNewSize, sizeof(icCurveSetCurvePtr));

  if (!m_curve) {
    m_position = NULL__null;
    m_nInputChannels = m_nOutputChannels = 0;
    return false;
  }

  m_position = (icPositionNumber*)calloc(nNewSize, sizeof(icPositionNumber));

  if (!m_position) {
    free(m_curve);
    m_curve = NULL__null;

    m_nInputChannels = m_nOutputChannels = 0;
    return false;
  }
  m_nInputChannels = m_nOutputChannels = nNewSize;
}
else {
  m_curve = NULL__null;
  m_nInputChannels = m_nOutputChannels = 0;
}

return true;
2288}

2290/**
******************************************************************************
* Name: CIccMpeCurveSet::SetCurve
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2300bool CIccMpeCurveSet::SetCurve(int nIndex, icCurveSetCurvePtr newCurve)
2301{
if (nIndex<0 || nIndex>m_nInputChannels)
  return false;

if (m_curve) {
  int i;

  for (i=0; i<m_nInputChannels; i++)
    if (i!=nIndex && m_curve[i]==m_curve[nIndex])
      break;

  if (i==m_nInputChannels && m_curve[nIndex]) {
    delete m_curve[nIndex];
  }
}
m_curve[nIndex] = newCurve;

return true;
2319}


2322/**
******************************************************************************
* Name: CIccMpeCurveSet::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2332void CIccMpeCurveSet::Describe(std::string &sDescription)
2333{
if (m_curve) {
  icChar buf[81];
  int i;

  sprintf(buf, "BEGIN_CURVE_SET %d\r\n", m_nInputChannels);
  sDescription += buf;

  for (i=0; i<m_nInputChannels; i++) {
    sprintf(buf, "Curve %d of %d\r\n", i+1, m_nInputChannels);
    sDescription += buf;
    if (m_curve[i]) {
      m_curve[i]->Describe(sDescription);
    }
  }
  sDescription += "END_CURVE_SET\r\n";
}
2350}

2352typedef std::map<icUInt32Number, CIccCurveSetCurve*> icCurveOffsetMap;
2353typedef std::map<CIccCurveSetCurve*, icPositionNumber> icCurvePtrMap;

2355/**
******************************************************************************
* Name: CIccMpeCurveSet::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2365bool CIccMpeCurveSet::Read(icUInt32Number size, CIccIO *pIO)
2366{
icElemTypeSignature sig;

icUInt32Number startPos = pIO->Tell();

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number);

if (headerSize > size)
1
Assuming 'headerSize' is <= 'size'→
2
←
Taking false branch→
  return false;

if (!pIO2.1
'pIO' is non-null
) {
3
←
Taking false branch→
  return false;
}

icUInt16Number nInputChannels, nOutputChannels;

if (!pIO->Read32(&sig))
4
←
Assuming the condition is false→
5
←
Taking false branch→
  return false;

if (!pIO->Read32(&m_nReserved))
6
←
Assuming the condition is false→
7
←
Taking false branch→
  return false;

if (!pIO->Read16(&nInputChannels))
8
←
Assuming the condition is false→
9
←
Taking false branch→
  return false;

if (!pIO->Read16(&nOutputChannels))
10
←
Assuming the condition is false→
11
←
Taking false branch→
  return false;

if (nInputChannels != nOutputChannels)
12
←
Assuming 'nInputChannels' is equal to 'nOutputChannels'→
  return false;

if (nInputChannels > size - headerSize || nInputChannels * 2*sizeof(icUInt32Number) > size - headerSize)
13
←
Assuming the condition is false→
14
←
Assuming the condition is false→
15
←
Taking false branch→
  return false;

if (!SetSize(nInputChannels))
16
←
Taking false branch→
  return false;

if (m_curve16.1
Field 'm_curve' is non-null
) {
17
←
Taking true branch→
  int i;

  if (headerSize + m_nInputChannels*2*sizeof(icUInt32Number) > size)
18
←
Assuming the condition is false→
19
←
Taking false branch→
    return false;

  for (i=0; i19.1
'i' is < field 'm_nInputChannels'
<m_nInputChannels; i++) {
20
←
Loop condition is true.  Entering loop body→
25
←
Assuming 'i' is >= field 'm_nInputChannels'→
26
←
Loop condition is false. Execution continues on line 2421→
    if (!pIO->Read32(&m_position[i].offset)) {
21
←
Assuming the condition is false→
22
←
Taking false branch→
      return false;
    }
    if (!pIO->Read32(&m_position[i].size)) {
23
←
Assuming the condition is false→
24
←
Taking false branch→
      return false;
    }
  }

  icCurveOffsetMap map;
  icCurveElemSignature curveSig;
  for (i=0; i<m_nInputChannels; i++) {
27
←
Loop condition is true.  Entering loop body→
    if (!map[m_position[i].offset]) {
28
←
Assuming the condition is true→
29
←
Taking true branch→
      icUInt32Number pos;
      if (!m_position[i].offset || !m_position[i].size) {
30
←
Assuming field 'offset' is not equal to 0→
31
←
Assuming field 'size' is not equal to 0→
32
←
Taking false branch→
        return false;
      }

      pos = startPos + m_position[i].offset;
      if (pIO->Seek(pos, icSeekSet)!=(icInt32Number)pos) {
33
←
Assuming the condition is false→
34
←
Taking false branch→
        return false;
      }
      
      if (!pIO->Read32(&curveSig)) {
35
←
Assuming the condition is false→
36
←
Taking false branch→
        return false;
      }
      m_curve[i] = CIccCurveSetCurve::Create(curveSig);

      if (!m_curve[i]) {
37
←
Taking false branch→
        return false;
      }

      if (pIO->Seek(pos, icSeekSet)!=(icInt32Number)pos) {
38
←
Assuming the condition is false→
39
←
Taking false branch→
        return false;
      }
    
      if (!m_curve[i]->Read(m_position[i].size, pIO)) {
40
←
Calling 'CIccSegmentedCurve::Read'→
        return false;
      }

      map[m_position[i].offset] = m_curve[i];
    }
    else {
      m_curve[i] = map[m_position[i].offset];
    }
  }
}

return true;
2461}

2463/**
******************************************************************************
* Name: CIccMpeCurveSet::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2473bool CIccMpeCurveSet::Write(CIccIO *pIO)
2474{
icElemTypeSignature sig = GetType();

if (!pIO)
  return false;

icUInt32Number elemStart = pIO->Tell();

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (m_curve && m_nInputChannels) {
  int i;
  icCurvePtrMap map;
  icUInt32Number start, end;
  icUInt32Number zeros[2] = { 0, 0};
  icPositionNumber position;

  icUInt32Number startTable = pIO->Tell();

  //First write empty position table
  for (i=0; i<m_nInputChannels; i++) {
    if (pIO->Write32(&zeros[0], 2)!=2)
      return false;
  }

  //Now Write curves
  for (i=0; i<m_nInputChannels; i++) {
    if (m_curve[i]) {
      if (map.find(m_curve[i])==map.end()) {
        start = pIO->Tell();
        m_curve[i]->Write(pIO);
        end = pIO->Tell();
        pIO->Align32();
        position.offset = start - elemStart;
        position.size = end - start;
        map[m_curve[i]] = position;
      }
      m_position[i] = map[m_curve[i]];
    }
  }
  end = pIO->Tell();
  
  //Back fill position table
  pIO->Seek(startTable, icSeekSet);
  for (i=0; i<m_nInputChannels; i++) {
    if (!pIO->Write32(&m_position[i].offset))
      return false;
    if (!pIO->Write32(&m_position[i].size))
      return false;
  }

  pIO->Seek(end, icSeekSet);
}

return true;
2539}

2541/**
******************************************************************************
* Name: CIccMpeCurveSet::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2551bool CIccMpeCurveSet::Begin(icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
2552{
if (!m_curve)
  return false;

int i;
for (i=0; i<m_nInputChannels; i++) {
  if (!m_curve[i] || !m_curve[i]->Begin())
    return false;
}

return true;
2563}

2565/**
******************************************************************************
* Name: CIccMpeCurveSet::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2575void CIccMpeCurveSet::Apply(CIccApplyMpe *pApply, icFloatNumber *pDestPixel, const icFloatNumber *pSrcPixel) const
2576{
int i;
for (i=0; i<m_nInputChannels; i++) {
  *pDestPixel++ = m_curve[i]->Apply(*pSrcPixel++);
}
2581}

2583/**
******************************************************************************
* Name: CIccMpeCurveSet::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2593icValidateStatus CIccMpeCurveSet::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
2594{
std::string mpeSigPath = sigPath + icGetSigPath(GetType());
icValidateStatus rv = CIccMultiProcessElement::Validate(sigPath, sReport, pMPE);

bool empty=false;
if (m_curve) {
  int i;
  for (i=0; !empty && i<m_nInputChannels; i++) {
    if (!m_curve[i]) {
      empty = true;
    }
    else {
      rv = icMaxStatus(rv, m_curve[i]->Validate(mpeSigPath, sReport, pMPE));
    }
  }
}
else
  empty = true;

if (empty) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " -  Has Empty Curve Element(s)!\r\n";
  return icValidateCriticalError;
}

return rv;
2624}

2626/**
******************************************************************************
* Name: CIccMpeTintArray::CIccMpeTintArray
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2636CIccMpeTintArray::CIccMpeTintArray(int nVectorSize/*=0*/)
2637{
m_nReserved = 0;
m_nInputChannels = 1;
m_nOutputChannels = nVectorSize;
m_Array = NULL__null;
2642}

2644typedef std::map<icCurveSetCurvePtr, icCurveSetCurvePtr> icCurveMap;

2646/**
******************************************************************************
* Name: CIccMpeTintArray::CIccMpeTintArray
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2656CIccMpeTintArray::CIccMpeTintArray(const CIccMpeTintArray &tintArray)
2657{
m_nReserved = tintArray.m_nReserved;

m_nInputChannels = tintArray.m_nInputChannels;
m_nOutputChannels = tintArray.m_nOutputChannels;

if (tintArray.m_Array)
  m_Array = (CIccTagNumArray*)tintArray.m_Array->NewCopy();

2666}

2668/**
******************************************************************************
* Name: &CIccMpeTintArray::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2678CIccMpeTintArray &CIccMpeTintArray::operator=(const CIccMpeTintArray &tintArray)
2679{
m_nReserved = m_nReserved;

if (m_Array) {
  delete m_Array;
}

m_nInputChannels = tintArray.m_nInputChannels;
m_nOutputChannels = tintArray.m_nOutputChannels;

if (tintArray.m_Array)
  m_Array = (CIccTagNumArray*)tintArray.m_Array->NewCopy();

return *this;
2693}

2695/**
******************************************************************************
* Name: CIccMpeTintArray::~CIccMpeTintArray
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2705CIccMpeTintArray::~CIccMpeTintArray()
2706{
if (m_Array)
  delete m_Array;
2709}

2711/**
******************************************************************************
* Name: CIccMpeTintArray::SetVectorSize
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2721void CIccMpeTintArray::SetVectorSize(int nVectorSize)
2722{
m_nOutputChannels = nVectorSize;
2724}

2726/**
******************************************************************************
* Name: CIccMpeTintArray::SetCurve
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2736void CIccMpeTintArray::SetArray(CIccTagNumArray *pArray)
2737{
if (m_Array)
  delete m_Array;

m_Array = pArray;
2742}


2745/**
******************************************************************************
* Name: CIccMpeTintArray::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2755void CIccMpeTintArray::Describe(std::string &sDescription)
2756{
if (m_Array) {
  icChar buf[81];

  sprintf(buf, "BEGIN_TINT_ARRAY %d\r\n", m_nOutputChannels);
  sDescription += buf;

  m_Array->Describe(sDescription);

  sDescription += "END_TINT_ARRAY\r\n";
}
2767}

2769/**
******************************************************************************
* Name: CIccMpeTintArray::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2779bool CIccMpeTintArray::Read(icUInt32Number size, CIccIO *pIO)
2780{
if (m_Array)
  delete m_Array;
m_Array = NULL__null;

icElemTypeSignature sig;

icUInt32Number startPos = pIO->Tell();

icUInt32Number headerSize = sizeof(icElemTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number);

if (headerSize +sizeof(icTagTypeSignature) > size)
  return false;

if (!pIO) {
  return false;
}

icUInt16Number nInputChannels, nOutputChannels;

if (!pIO->Read32(&sig))
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read16(&nInputChannels))
  return false;

if (!pIO->Read16(&nOutputChannels))
  return false;

if (nInputChannels != 1 || !nOutputChannels)
  return false;

m_nInputChannels = nInputChannels;
m_nOutputChannels = nOutputChannels;

icUInt32Number arrayPos = pIO->Tell();

icTagTypeSignature tagType;
if (!pIO->Read32(&tagType))
  return false;

CIccTag *pTag = CIccTag::Create(tagType);
if (!pTag)
  return false;

if (!pTag->IsNumArrayType()) {
  delete pTag;
}

m_Array = (CIccTagNumArray*)pTag;
pIO->Seek(arrayPos, icSeekSet);
if (!m_Array->Read(size-headerSize, pIO)) {
  return false;
}

icUInt32Number nVals = m_Array->GetNumValues();
if (nVals/m_nOutputChannels <2 || (nVals%m_nOutputChannels) != 0) {
  return false;
}

return true;
2847}

2849/**
******************************************************************************
* Name: CIccMpeTintArray::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2859bool CIccMpeTintArray::Write(CIccIO *pIO)
2860{
if (!m_Array)
  return false;

icElemTypeSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (!pIO->Write16(&m_nOutputChannels))
  return false;

return m_Array->Write(pIO);
2882}

2884/**
******************************************************************************
* Name: CIccMpeTintArray::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2894bool CIccMpeTintArray::Begin(icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
2895{
if (!m_Array)
  return false;

icUInt32Number nVals = m_Array->GetNumValues();

if (nVals/m_nOutputChannels<2 || nVals % m_nOutputChannels != 0)
  return false;

return true;
2905}

2907/**
******************************************************************************
* Name: CIccMpeTintArray::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2917void CIccMpeTintArray::Apply(CIccApplyMpe *pApply, icFloatNumber *pDestPixel, const icFloatNumber *pSrcPixel) const
2918{
if (m_Array) {
  m_Array->Interpolate(pDestPixel, *pSrcPixel, m_nOutputChannels);
}
else
  memset(pDestPixel, 0, m_nOutputChannels*sizeof(icFloatNumber));
2924}

2926/**
******************************************************************************
* Name: CIccMpeTintArray::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2936icValidateStatus CIccMpeTintArray::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
2937{
std::string mpeSigPath = sigPath + icGetSigPath(GetType());
icValidateStatus rv = CIccMultiProcessElement::Validate(sigPath, sReport, pMPE);

if (m_nInputChannels!=1) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " -  Bad number of input channels!\r\n";
  return icValidateCriticalError;
}

if (!m_nOutputChannels) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " -  Bad number of output channels!\r\n";
  return icValidateCriticalError;
}

if (!m_Array) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " -  Has no tint values(s)!\r\n";
  return icValidateCriticalError;
}
else {
  icUInt32Number nVals = m_Array->GetNumValues();
  bool bBad = false;
  
  /*
   * NOTE: nVals is unsigned as is m_nOutputChannels
   * so the result will never be < 0
   */
  /*
  if (nVals/m_nOutputChannels<0) {
    CIccInfo Info;
    std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " -  Needs two or more tint steps!\r\n";
    bBad = true;
  }
  */
  if ((nVals % m_nOutputChannels)!=0) {
    CIccInfo Info;
    std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " -  Array size must be multiple of output channels!\r\n";
    bBad = true;
  }

  if (bBad) {
    return icValidateCriticalError;
  }
}

return rv;
3005}

3007/**
******************************************************************************
* Name: CIccMpeMatrix::CIccMpeMatrix
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3017CIccMpeMatrix::CIccMpeMatrix()
3018{
m_nReserved = 0;
m_nInputChannels = m_nOutputChannels = 0;
m_size = 0;
m_pMatrix = NULL__null;
m_pConstants = NULL__null;
3024}


3027/**
******************************************************************************
* Name: CIccMpeMatrix::CIccMpeMatrix
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3037CIccMpeMatrix::CIccMpeMatrix(const CIccMpeMatrix &matrix)
3038{
m_nReserved = matrix.m_nReserved;

m_nInputChannels = matrix.m_nInputChannels;
m_nOutputChannels = matrix.m_nOutputChannels;

m_size = matrix.m_size;
if(matrix.m_pMatrix) {
  int num = m_size * sizeof(icFloatNumber);
  m_pMatrix = (icFloatNumber*)malloc(num);
  memcpy(m_pMatrix, matrix.m_pMatrix, num);
}
else
  m_pMatrix = NULL__null;

if (matrix.m_pConstants) {
  int num = m_nOutputChannels*sizeof(icFloatNumber);
  m_pConstants = (icFloatNumber*)malloc(num);
  memcpy(m_pConstants, matrix.m_pConstants, num);
}
else
  m_pConstants = NULL__null;

m_bApplyConstants = true;
3062}

3064/**
******************************************************************************
* Name: &CIccMpeMatrix::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3074CIccMpeMatrix &CIccMpeMatrix::operator=(const CIccMpeMatrix &matrix)
3075{
m_nReserved = matrix.m_nReserved;

m_nInputChannels = matrix.m_nInputChannels;
m_nOutputChannels = matrix.m_nOutputChannels;

if (m_pMatrix)
  free(m_pMatrix);

m_size = matrix.m_size;
if (matrix.m_pMatrix) {
  int num = m_size * sizeof(icFloatNumber);
  m_pMatrix = (icFloatNumber*)malloc(num);
  memcpy(m_pMatrix, matrix.m_pMatrix, num);
}
else
  m_pMatrix = NULL__null;

if (m_pConstants)
  free(m_pConstants);

if (matrix.m_pConstants) {
  int num = m_nOutputChannels*sizeof(icFloatNumber);
  m_pConstants = (icFloatNumber*)malloc(num);
  memcpy(m_pConstants, matrix.m_pConstants, num);
}
else
  m_pConstants = NULL__null;

m_bApplyConstants = matrix.m_bApplyConstants;

return *this;
3107}

3109/**
******************************************************************************
* Name: CIccMpeMatrix::~CIccMpeMatrix
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3119CIccMpeMatrix::~CIccMpeMatrix()
3120{
if (m_pMatrix)
  free(m_pMatrix);

if (m_pConstants)
  free(m_pConstants);
3126}

3128/**
******************************************************************************
* Name: CIccMpeMatrix::SetSize
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3138bool CIccMpeMatrix::SetSize(icUInt16Number nInputChannels, icUInt16Number nOutputChannels, bool bUseConstants)
3139{
if (m_pMatrix) {
  free(m_pMatrix);
  m_pMatrix = NULL__null;
}
if (m_pConstants) {
  free(m_pConstants);
  m_pConstants = NULL__null;
}

m_size = (icUInt32Number)nInputChannels * nOutputChannels;

if (m_size) {
  m_pMatrix = (icFloatNumber*)calloc(m_size, sizeof(icFloatNumber));
  if (!m_pMatrix)
    return false;
}

if (bUseConstants) {
  m_pConstants = (icFloatNumber*)calloc(nOutputChannels, sizeof(icFloatNumber));

  if (!m_pConstants)
    return false;
}

m_nInputChannels = nInputChannels;
m_nOutputChannels = nOutputChannels;

return true;
3168}

3170/**
******************************************************************************
* Name: CIccMpeMatrix::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3180void CIccMpeMatrix::Describe(std::string &sDescription)
3181{
icChar buf[81];
int i, j;
icFloatNumber *data = m_pMatrix;

sprintf(buf, "BEGIN_ELEM_MATRIX %d %d\r\n", m_nInputChannels, m_nOutputChannels);
sDescription += buf;

for (j=0; j<m_nOutputChannels; j++) {
  if (data) {
    for (i=0; i<m_nInputChannels; i++) {
      if (i)
        sDescription += " ";
      sprintf(buf, "%12.8lf", data[i]);
      sDescription += buf;
    }
    if (m_pConstants) {
      sprintf(buf, "  +  %12.8lf\r\n", m_pConstants[j]);
      sDescription += buf;
    }
    data += i;
  }
  else {
    sprintf(buf, "ZeroRow  +  %12.8lf\r\n", m_pConstants[j]);
    sDescription += buf;
  }
}
sDescription += "END_ELEM_MATRIX\r\n";
3209}

3211/**
******************************************************************************
* Name: CIccMpeMatrix::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3221bool CIccMpeMatrix::Read(icUInt32Number size, CIccIO *pIO)
3222{
icElemTypeSignature sig;

icUInt32Number headerSize = sizeof(icElemTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number);

if (headerSize > size)
  return false;

icUInt32Number dataSize = size - headerSize;

if (!pIO) {
  return false;
}

icUInt16Number nInputChannels, nOutputChannels;

if (!pIO->Read32(&sig))
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read16(&nInputChannels))
  return false;

if (!pIO->Read16(&nOutputChannels))
  return false;

if (dataSize >= (icUInt32Number)nInputChannels * nOutputChannels * sizeof(icFloatNumber) &&
    dataSize < ((icUInt32Number)nInputChannels+1) * nOutputChannels * sizeof(icFloatNumber)) {
  //Matrix with no constants
  if (!SetSize(nInputChannels, nOutputChannels, false))
    return false;

  if (!m_pMatrix)
    return false;

  //Read Matrix data
  if (pIO->ReadFloat32Float(m_pMatrix, m_size) != (icInt32Number)m_size)
    return false;
}
else if (dataSize < (icUInt32Number)nInputChannels * nOutputChannels *sizeof(icFloatNumber) &&
         dataSize >= (icUInt32Number)nOutputChannels * sizeof(icFloatNumber)) {
  //Constants with no matrix
  if (!SetSize(0, nOutputChannels))
    return false;

  m_nInputChannels = nInputChannels;

  //Read Constant data
  if (pIO->ReadFloat32Float(m_pConstants, m_nOutputChannels)!=m_nOutputChannels)
    return false;
}
else {
  if ((icUInt32Number)nInputChannels*nOutputChannels > dataSize ||
      ((icUInt32Number)nInputChannels*nOutputChannels + nOutputChannels) > dataSize ||
      ((icUInt32Number)nInputChannels*nOutputChannels + nOutputChannels) * sizeof(icFloat32Number) > dataSize)
    return false;

  //Matrix with constants
  if (!SetSize(nInputChannels, nOutputChannels))
    return false;

  if (!m_pMatrix) 
    return false;

  if ((m_size + nOutputChannels)*sizeof(icFloat32Number) > dataSize)
    return false;

  //Read Matrix data
  if (pIO->ReadFloat32Float(m_pMatrix, m_size)!=(icInt32Number)m_size)
    return false;

  //Read Constant data
  if (pIO->ReadFloat32Float(m_pConstants, m_nOutputChannels)!=m_nOutputChannels)
    return false;
}

return true;
3304}

3306/**
******************************************************************************
* Name: CIccMpeMatrix::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3316bool CIccMpeMatrix::Write(CIccIO *pIO)
3317{
icElemTypeSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (!pIO->Write16(&m_nOutputChannels))
  return false;

if (m_pMatrix) {
  if (pIO->WriteFloat32Float(m_pMatrix, m_size)!=(icInt32Number)m_size)
    return false;
}

//Write Constant data
if (m_pConstants) {
  if (pIO->WriteFloat32Float(m_pConstants, m_nOutputChannels)!=m_nOutputChannels)
    return false;
}
else {
  //Write zero constants because spec says it they have to be there
  icFloat32Number zero = 0;
  int i;
  for (i = 0; i < m_nOutputChannels; i++) {
    if (!pIO->WriteFloat32Float(&zero, 1))
      return false;
  }
}

return true;
3356}

3358/**
******************************************************************************
* Name: CIccMpeMatrix::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3368bool CIccMpeMatrix::Begin(icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
3369{
m_bApplyConstants = false;
if (m_pConstants) {
  int i;
  for (i = 0; i < m_nOutputChannels; i++) {
    if (icNotZero(m_pConstants[i])((m_pConstants[i])>1.0e-8 || (m_pConstants[i])<-1.0e-8)) {
      m_bApplyConstants = true;
      break;
    }
  }
}

if (m_nInputChannels==3 && m_nOutputChannels==3)
  m_type = ic3x3Matrix;
else if (m_nInputChannels==3 && m_nOutputChannels==4)
  m_type = ic3x4Matrix;
else if (m_nInputChannels==4 && m_nOutputChannels==3)
  m_type = ic4x3Matrix;
else if (m_nInputChannels==4 && m_nOutputChannels==4)
  m_type = ic4x4Matrix;
else
  m_type = icOtherMatrix;

return true;
3393}

3395/**
******************************************************************************
* Name: CIccMpeMatrix::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3405void CIccMpeMatrix::Apply(CIccApplyMpe *pApply, icFloatNumber *dstPixel, const icFloatNumber *srcPixel) const
3406{
icFloatNumber *data = m_pMatrix;
if (data) {
  if (m_bApplyConstants) {
    switch (m_type) {
      case ic3x3Matrix:
        *dstPixel++ = data[ 0]*srcPixel[0] + data[ 1]*srcPixel[1] + data[ 2]*srcPixel[2] + m_pConstants[0];
        *dstPixel++ = data[ 3]*srcPixel[0] + data[ 4]*srcPixel[1] + data[ 5]*srcPixel[2] + m_pConstants[1];
        *dstPixel   = data[ 6]*srcPixel[0] + data[ 7]*srcPixel[1] + data[ 8]*srcPixel[2] + m_pConstants[2];
        break;

      case ic3x4Matrix:
        *dstPixel++ = data[ 0]*srcPixel[0] + data[ 1]*srcPixel[1] + data[ 2]*srcPixel[2] + m_pConstants[0];
        *dstPixel++ = data[ 3]*srcPixel[0] + data[ 4]*srcPixel[1] + data[ 5]*srcPixel[2] + m_pConstants[1];
        *dstPixel++ = data[ 6]*srcPixel[0] + data[ 7]*srcPixel[1] + data[ 8]*srcPixel[2] + m_pConstants[2];
        *dstPixel   = data[ 9]*srcPixel[0] + data[10]*srcPixel[1] + data[11]*srcPixel[2] + m_pConstants[3];
        break;

      case ic4x3Matrix:
        *dstPixel++ = data[ 0]*srcPixel[0] + data[ 1]*srcPixel[1] + data[ 2]*srcPixel[2] + data[ 3]*srcPixel[3] + m_pConstants[0];
        *dstPixel++ = data[ 4]*srcPixel[0] + data[ 5]*srcPixel[1] + data[ 6]*srcPixel[2] + data[ 7]*srcPixel[3] + m_pConstants[1];
        *dstPixel   = data[ 8]*srcPixel[0] + data[ 9]*srcPixel[1] + data[10]*srcPixel[2] + data[11]*srcPixel[3] + m_pConstants[2];
        break;

      case ic4x4Matrix:
        *dstPixel++ = data[ 0]*srcPixel[0] + data[ 1]*srcPixel[1] + data[ 2]*srcPixel[2] + data[ 3]*srcPixel[3] + m_pConstants[0];
        *dstPixel++ = data[ 4]*srcPixel[0] + data[ 5]*srcPixel[1] + data[ 6]*srcPixel[2] + data[ 7]*srcPixel[3] + m_pConstants[1];
        *dstPixel++ = data[ 8]*srcPixel[0] + data[ 9]*srcPixel[1] + data[10]*srcPixel[2] + data[11]*srcPixel[3] + m_pConstants[2];
        *dstPixel   = data[12]*srcPixel[0] + data[13]*srcPixel[1] + data[14]*srcPixel[2] + data[15]*srcPixel[3] + m_pConstants[3];
        break;
    
      case icOtherMatrix:
      default:
        {
          int i, j;

          for (j=0; j<m_nOutputChannels; j++) {
            *dstPixel = m_pConstants[j];

            for (i=0; i<m_nInputChannels; i++) {
              *dstPixel += data[i]*srcPixel[i];
            }

            data += i;
            dstPixel++;
          }
        }
        break;
    }
  }
  else {
    switch (m_type) {
      case ic3x3Matrix:
        *dstPixel++ = data[0] * srcPixel[0] + data[1] * srcPixel[1] + data[2] * srcPixel[2];
        *dstPixel++ = data[3] * srcPixel[0] + data[4] * srcPixel[1] + data[5] * srcPixel[2];
        *dstPixel = data[6] * srcPixel[0] + data[7] * srcPixel[1] + data[8] * srcPixel[2];
        break;

      case ic3x4Matrix:
        *dstPixel++ = data[0] * srcPixel[0] + data[1] * srcPixel[1] + data[2] * srcPixel[2];
        *dstPixel++ = data[3] * srcPixel[0] + data[4] * srcPixel[1] + data[5] * srcPixel[2];
        *dstPixel++ = data[6] * srcPixel[0] + data[7] * srcPixel[1] + data[8] * srcPixel[2];
        *dstPixel = data[9] * srcPixel[0] + data[10] * srcPixel[1] + data[11] * srcPixel[2];
        break;

      case ic4x3Matrix:
        *dstPixel++ = data[0] * srcPixel[0] + data[1] * srcPixel[1] + data[2] * srcPixel[2] + data[3] * srcPixel[3];
        *dstPixel++ = data[4] * srcPixel[0] + data[5] * srcPixel[1] + data[6] * srcPixel[2] + data[7] * srcPixel[3];
        *dstPixel = data[8] * srcPixel[0] + data[9] * srcPixel[1] + data[10] * srcPixel[2] + data[11] * srcPixel[3];
        break;

      case ic4x4Matrix:
        *dstPixel++ = data[0] * srcPixel[0] + data[1] * srcPixel[1] + data[2] * srcPixel[2] + data[3] * srcPixel[3];
        *dstPixel++ = data[4] * srcPixel[0] + data[5] * srcPixel[1] + data[6] * srcPixel[2] + data[7] * srcPixel[3];
        *dstPixel++ = data[8] * srcPixel[0] + data[9] * srcPixel[1] + data[10] * srcPixel[2] + data[11] * srcPixel[3];
        *dstPixel = data[12] * srcPixel[0] + data[13] * srcPixel[1] + data[14] * srcPixel[2] + data[15] * srcPixel[3];
        break;

      case icOtherMatrix:
      default:
        {
          int i, j;

          for (j = 0; j < m_nOutputChannels; j++) {
            *dstPixel = 0.0f;

            for (i = 0; i < m_nInputChannels; i++) {
              *dstPixel += data[i] * srcPixel[i];
            }

            data += i;
            dstPixel++;
          }
        }
        break;
    }
  }
}
else if (m_bApplyConstants) {
  memcpy(dstPixel, m_pConstants, m_nOutputChannels*sizeof(icFloatNumber));
}
else {
  memset(dstPixel, 0, m_nOutputChannels * sizeof(icFloatNumber));
}
3510}

3512/**
******************************************************************************
* Name: CIccMpeMatrix::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3522icValidateStatus CIccMpeMatrix::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
3523{
std::string mpeSigPath = sigPath + icGetSigPath(GetType());
icValidateStatus rv = CIccMultiProcessElement::Validate(sigPath, sReport, pMPE);

if (!m_pConstants) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " - Has Empty Matrix Constant data!\r\n";
  return icValidateCriticalError;
}

return rv;
3538}


3541static icFloatNumber NoClip(icFloatNumber v)
3542{
return v;
3544}

3546/**
******************************************************************************
* Name: CIccMpeCLUT::CIccMpeCLUT
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3556CIccMpeCLUT::CIccMpeCLUT()
3557{
m_pCLUT = NULL__null;
m_nInputChannels = 0;
m_nOutputChannels = 0;

m_nReserved = 0;
3563}

3565/**
******************************************************************************
* Name: CIccMpeCLUT::CIccMpeCLUT
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3575CIccMpeCLUT::CIccMpeCLUT(const CIccMpeCLUT &clut)
3576{
if (clut.m_pCLUT)
  m_pCLUT = new CIccCLUT(*clut.m_pCLUT);
else
  m_pCLUT = NULL__null;

m_nReserved = clut.m_nReserved;
m_nInputChannels = clut.m_nInputChannels;
m_nOutputChannels = clut.m_nOutputChannels;
3585}

3587/**
******************************************************************************
* Name: &CIccMpeCLUT::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3597CIccMpeCLUT &CIccMpeCLUT::operator=(const CIccMpeCLUT &clut)
3598{
if (m_pCLUT)
  delete m_pCLUT;

if (clut.m_pCLUT)
  m_pCLUT = new CIccCLUT(*clut.m_pCLUT);
else
  m_pCLUT = NULL__null;

m_nReserved = clut.m_nReserved;
m_nInputChannels = clut.m_nInputChannels;
m_nOutputChannels = clut.m_nOutputChannels;

return *this;
3612}

3614/**
******************************************************************************
* Name: CIccMpeCLUT::~CIccMpeCLUT
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3624CIccMpeCLUT::~CIccMpeCLUT()
3625{
if (m_pCLUT)
  delete m_pCLUT;
3628}

3630/**
******************************************************************************
* Name: CIccMpeCLUT::SetCLUT
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3640void CIccMpeCLUT::SetCLUT(CIccCLUT *pCLUT)
3641{
if (m_pCLUT)
  delete m_pCLUT;

m_pCLUT = pCLUT;
if (pCLUT) {
  pCLUT->SetClipFunc(NoClip);
  m_nInputChannels = pCLUT->GetInputDim();
  m_nOutputChannels = pCLUT->GetOutputChannels();
}
3651}

3653/**
******************************************************************************
* Name: CIccMpeCLUT::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3663void CIccMpeCLUT::Describe(std::string &sDescription)
3664{
if (m_pCLUT) {
  m_pCLUT->DumpLut(sDescription, "ELEM_CLUT", icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f), icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f));
}
3668}

3670/**
******************************************************************************
* Name: CIccMpeCLUT::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3680bool CIccMpeCLUT::Read(icUInt32Number size, CIccIO *pIO)
3681{
icTagTypeSignature sig;

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number) + 
  16 * sizeof(icUInt8Number);

if (headerSize > size)
  return false;

icUInt32Number dataSize = size - headerSize;

if (!pIO) {
  return false;
}

if (!pIO->Read32(&sig))
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read16(&m_nInputChannels))
  return false;

if (!pIO->Read16(&m_nOutputChannels))
  return false;

icUInt8Number gridPoints[16];

if (pIO->Read8(gridPoints, 16)!=16) {
  return false;
}

icUInt32Number nPoints = (icUInt32Number)m_nInputChannels * m_nOutputChannels;

if (m_nInputChannels > 16 || nPoints > dataSize || nPoints * sizeof (icFloat32Number) > dataSize)
  return false;

m_pCLUT = new CIccCLUT((icUInt8Number)m_nInputChannels, (icUInt16Number)m_nOutputChannels, 4);

if (!m_pCLUT)
  return false;

m_pCLUT->SetClipFunc(NoClip);

m_pCLUT->Init(gridPoints);

icFloatNumber *pData = m_pCLUT->GetData(0);

if (!pData)
  return false;

nPoints = m_pCLUT->NumPoints()*m_nOutputChannels;

if (pIO->ReadFloat32Float(pData,nPoints)!= nPoints)
  return false;

return true;
3742}

3744/**
******************************************************************************
* Name: CIccMpeCLUT::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3754bool CIccMpeCLUT::Write(CIccIO *pIO)
3755{
icElemTypeSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (!pIO->Write16(&m_nOutputChannels))
  return false;

if (m_pCLUT) {
  icUInt8Number gridPoints[16];
  int i;

  for (i=0; i<16; i++)
    gridPoints[i] = m_pCLUT->GridPoint(i);

  if (pIO->Write8(gridPoints, 16)!=16)
    return false;

  icFloatNumber *pData = m_pCLUT->GetData(0);
  icInt32Number nPoints = m_pCLUT->NumPoints()*m_nOutputChannels;

  if (pIO->WriteFloat32Float(pData, nPoints) != nPoints) 
    return false;
}

return true;
3791}

3793/**
******************************************************************************
* Name: CIccMpeCLUT::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3803bool CIccMpeCLUT::Begin(icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
3804{
if (!m_pCLUT)
  return false;

m_pCLUT->Begin();

switch (m_nInputChannels) {
case 1:
  m_interpType = ic1dInterp;
  break;
case 2:
  m_interpType = ic2dInterp;
  break;
case 3:
  if (nInterp==icElemInterpTetra)
    m_interpType = ic3dInterpTetra;
  else
    m_interpType = ic3dInterp;
  break;
case 4:
  m_interpType = ic4dInterp;
  break;
case 5:
  m_interpType = ic5dInterp;
  break;
case 6:
  m_interpType = ic6dInterp;
  break;
default:
  m_interpType = icNdInterp;
  break;
}
return true;
3837}

3839/**
******************************************************************************
* Name: CIccMpeCLUT::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3849void CIccMpeCLUT::Apply(CIccApplyMpe *pApply, icFloatNumber *dstPixel, const icFloatNumber *srcPixel) const
3850{
const CIccCLUT *pCLUT = m_pCLUT;

switch(m_interpType) {
case ic1dInterp:
  pCLUT->Interp1d(dstPixel, srcPixel);
  break;
case ic2dInterp:
  pCLUT->Interp2d(dstPixel, srcPixel);
  break;
case ic3dInterpTetra:
  pCLUT->Interp3dTetra(dstPixel, srcPixel);
  break;
case ic3dInterp:
  pCLUT->Interp3d(dstPixel, srcPixel);
  break;
case ic4dInterp:
  pCLUT->Interp4d(dstPixel, srcPixel);
  break;
case ic5dInterp:
  pCLUT->Interp5d(dstPixel, srcPixel);
  break;
case ic6dInterp:
  pCLUT->Interp6d(dstPixel, srcPixel);
  break;
case icNdInterp:
  pCLUT->InterpND(dstPixel, srcPixel);
  break;
}
3879}

3881/**
******************************************************************************
* Name: CIccMpeCLUT::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3891icValidateStatus CIccMpeCLUT::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
3892{
std::string mpeSigPath = sigPath + icGetSigPath(GetType());
icValidateStatus rv = CIccMultiProcessElement::Validate(sigPath, sReport, pMPE);

if (!m_pCLUT) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " - Has No CLUT!\r\n";
  return icValidateCriticalError;
}

return rv;
3907}

3909/**
3910******************************************************************************
3911* Name: CIccMpeExtCLUT::CIccMpeExtCLUT
3912* 
3913* Purpose: 
3914* 
3915* Args: 
3916* 
3917* Return: 
3918******************************************************************************/
3919CIccMpeExtCLUT::CIccMpeExtCLUT()
3920{
m_pCLUT = NULL__null;
m_nInputChannels = 0;
m_nOutputChannels = 0;

m_nReserved = 0;
m_nReserved2 = 0;

m_storageType = icValueTypeFloat32;
3929}

3931/**
3932******************************************************************************
3933* Name: CIccMpeExtCLUT::CIccMpeExtCLUT
3934* 
3935* Purpose: 
3936* 
3937* Args: 
3938* 
3939* Return: 
3940******************************************************************************/
3941CIccMpeExtCLUT::CIccMpeExtCLUT(const CIccMpeExtCLUT &clut) : CIccMpeCLUT(clut)
3942{
m_nReserved2 = clut.m_nReserved2;
m_storageType = clut.m_storageType;
3945}

3947/**
3948******************************************************************************
3949* Name: &CIccMpeExtCLUT::operator=
3950* 
3951* Purpose: 
3952* 
3953* Args: 
3954* 
3955* Return: 
3956******************************************************************************/
3957CIccMpeExtCLUT &CIccMpeExtCLUT::operator=(const CIccMpeExtCLUT &clut)
3958{
CIccMpeCLUT::operator=(clut);

m_nReserved2 = clut.m_nReserved2;
m_storageType = clut.m_storageType;

return *this;
3965}

3967/**
3968******************************************************************************
3969* Name: CIccMpeExtCLUT::Describe
3970* 
3971* Purpose: 
3972* 
3973* Args: 
3974* 
3975* Return: 
3976******************************************************************************/
3977void CIccMpeExtCLUT::Describe(std::string &sDescription)
3978{
if (m_pCLUT) {
  char desc[256];
  sprintf(desc, "EXT_ELEM_CLUT(%d)", m_storageType);

  m_pCLUT->DumpLut(sDescription, desc, icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f), icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f));
}
3985}

3987/**
3988******************************************************************************
3989* Name: CIccMpeExtCLUT::SetStorageType
3990*
3991* Purpose:
3992*  Sets storage type of the data stored in the CLUT
3993*
3994* Args:
3995*  nStorageType is type of data to use
3996*
3997* Return:
3998*  true if valid storage type, false otherwise
3999******************************************************************************/
4000bool CIccMpeExtCLUT::SetStorageType(icUInt16Number nStorateType)
4001{
m_storageType = nStorateType;

switch (nStorateType) {
case icValueTypeUInt8:
case icValueTypeUInt16:
case icValueTypeFloat16:
case icValueTypeFloat32:
  return true;
}
return false;
4012}


4015/**
4016******************************************************************************
4017* Name: CIccMpeExtCLUT::Read
4018* 
4019* Purpose: 
4020* 
4021* Args: 
4022* 
4023* Return: 
4024******************************************************************************/
4025bool CIccMpeExtCLUT::Read(icUInt32Number size, CIccIO *pIO)
4026{
icTagTypeSignature sig;

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number) +
  sizeof(icUInt16Number) +
  16 * sizeof(icUInt8Number);

if (headerSize > size)
  return false;

icUInt32Number dataSize = size - headerSize;

if (!pIO) {
  return false;
}

if (!pIO->Read32(&sig))
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read16(&m_nInputChannels))
  return false;

if (!pIO->Read16(&m_nOutputChannels))
  return false;

if (!pIO->Read16(&m_storageType))
  return false;

if (!pIO->Read16(&m_nReserved2))
  return false;

icUInt8Number gridPoints[16];

if (pIO->Read8(gridPoints, 16)!=16) {
  return false;
}

icUInt32Number nPoints = (icUInt32Number)m_nInputChannels * m_nOutputChannels;

if (m_nInputChannels > 16 || nPoints > dataSize)
  return false;

m_pCLUT = new CIccCLUT((icUInt8Number)m_nInputChannels, (icUInt16Number)m_nOutputChannels, 4);

if (!m_pCLUT)
  return false;

m_pCLUT->SetClipFunc(NoClip);

if (!m_pCLUT->Init(gridPoints, dataSize, icGetStorageTypeBytes(m_storageType)))
  return false;

icFloatNumber *pData = m_pCLUT->GetData(0);

if (!pData)
  return false;

nPoints = m_pCLUT->NumPoints()*m_nOutputChannels;

if (nPoints > dataSize)
  return false;

switch(m_storageType) {
  case icValueTypeUInt8:
    if (pIO->ReadUInt8Float(pData,nPoints)!= nPoints)
      return false;
    break;

  case icValueTypeUInt16:
    if (nPoints * 2 > dataSize)
      return false;

    if (pIO->ReadUInt16Float(pData,nPoints)!= nPoints)
      return false;
    break;

  case icValueTypeFloat16:
    if (nPoints * 2 > dataSize)
      return false;

    if (pIO->ReadFloat16Float(pData,nPoints)!= nPoints)
      return false;
    break;

  case icValueTypeFloat32:
    if (pIO->ReadFloat32Float(pData,nPoints)!= nPoints)
      return false;
    break;

  default:
    return false;
}
return true;
4126}

4128/**
4129******************************************************************************
4130* Name: CIccMpeExtCLUT::Write
4131* 
4132* Purpose: 
4133* 
4134* Args: 
4135* 
4136* Return: 
4137******************************************************************************/
4138bool CIccMpeExtCLUT::Write(CIccIO *pIO)
4139{
icElemTypeSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (!pIO->Write16(&m_nOutputChannels))
  return false;

if (!pIO->Write16(&m_storageType))
  return false;

if (!pIO->Write16(&m_nReserved2))
  return false;

if (m_pCLUT) {
  icUInt8Number gridPoints[16];
  int i;

  for (i=0; i<16; i++)
    gridPoints[i] = m_pCLUT->GridPoint(i);

  if (pIO->Write8(gridPoints, 16)!=16)
    return false;

  icFloatNumber *pData = m_pCLUT->GetData(0);
  icInt32Number nPoints = m_pCLUT->NumPoints()*m_nOutputChannels;

  switch(m_storageType) {
  case icValueTypeUInt8:
    if (pIO->WriteUInt8Float(pData,nPoints)!= nPoints)
      return false;
    break;

  case icValueTypeUInt16:
    if (pIO->WriteUInt16Float(pData,nPoints)!= nPoints)
      return false;
    break;

  case icValueTypeFloat16:
    if (pIO->WriteFloat16Float(pData,nPoints)!= nPoints)
      return false;
    break;

  case icValueTypeFloat32:
    if (pIO->WriteFloat32Float(pData,nPoints)!= nPoints)
      return false;
    break;

  default:
    return false;
  }
}

return true;
4203}


4206/**
4207******************************************************************************
4208* Name: CIccMpeExtCLUT::Validate
4209* 
4210* Purpose: 
4211* 
4212* Args: 
4213* 
4214* Return: 
4215******************************************************************************/
4216icValidateStatus CIccMpeExtCLUT::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
4217{
std::string mpeSigPath = sigPath + icGetSigPath(GetType());
icValidateStatus rv = CIccMpeCLUT::Validate(sigPath, sReport, pMPE);

if (m_storageType>icMaxValueTypeicValueTypeUInt8) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(mpeSigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " - Invalid value type!\r\n";
  return icValidateCriticalError;
}

return rv;
4232}


4235CIccMpeCAM::CIccMpeCAM()
4236{
m_pCAM = NULL__null;
m_nInputChannels = 3;
m_nOutputChannels = 3;
m_nReserved = 0;
4241}

4243CIccMpeCAM::~CIccMpeCAM()
4244{
if (m_pCAM)
  delete m_pCAM;
4247}

4249bool CIccMpeCAM::Read(icUInt32Number size, CIccIO *pIO)
4250{
icTagTypeSignature sig;

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number)*2 + 
  8 * sizeof(icFloat32Number);

if (headerSize > size)
  return false;

if (!pIO) {
  return false;
}

if (!pIO->Read32(&sig))
  return false;

if (sig!=GetType())
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read16(&m_nInputChannels))
  return false;

if (!pIO->Read16(&m_nOutputChannels))
  return false;

icFloatNumber param[8];

if (pIO->ReadFloat32Float(param, 8)!=8)
  return false;

if (m_pCAM)
  delete m_pCAM;

m_pCAM = new CIccCamConverter;

m_pCAM->SetParameter_WhitePoint(&param[0]);
m_pCAM->SetParameter_La(param[3]);
m_pCAM->SetParameter_Yb(param[4]);
m_pCAM->SetParameter_C(param[5]);
m_pCAM->SetParameter_Nc(param[6]);
m_pCAM->SetParameter_F(param[7]);

return true;
4298}

4300bool CIccMpeCAM::Write(CIccIO *pIO)
4301{
if (!m_pCAM)
  return false;

icElemTypeSignature sig = GetType();

if (!pIO)
  return false;

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (!pIO->Write16(&m_nOutputChannels))
  return false;


icFloatNumber param[8];

m_pCAM->GetParameter_WhitePoint(&param[0]); //sets param[0], param[1], and param[2]
param[3] = m_pCAM->GetParameter_La();
param[4] = m_pCAM->GetParameter_Yb();
param[5] = m_pCAM->GetParameter_C();
param[6] = m_pCAM->GetParameter_Nc();
param[7] = m_pCAM->GetParameter_F();

if (pIO->WriteFloat32Float(&param, 8)!=8)
  return false;

return true;
4336}

4338bool CIccMpeCAM::Begin(icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
4339{
if (m_pCAM) {
  return true;
}
return false;
4344}

4346void CIccMpeCAM::SetCAM(CIccCamConverter *pCAM)
4347{
if (m_pCAM)
  delete m_pCAM;
m_pCAM = pCAM;
4351}

4353void CIccMpeCAM::Describe(std::string &sDescription)
4354{
sDescription += "Begin ";
sDescription += GetXformName();
sDescription += "\n";

if (m_pCAM) {
  char line[256];

  icFloatNumber xyz[3];
  m_pCAM->GetParameter_WhitePoint(xyz);
  sprintf(line, "WhitePoint (X=%f, Y=%f, Z=%f)\n", xyz[0], xyz[1], xyz[2]);
  sDescription += line;

  sprintf(line, "Luminance(La)=%f cd/m^2\n", m_pCAM->GetParameter_La());
  sDescription += line;

  sprintf(line, "Background Luminance(Yb)=%f cd/m^2\n", m_pCAM->GetParameter_Yb());
  sDescription += line;

  sprintf(line, "Impact Surround(C)=%f\n", m_pCAM->GetParameter_C());
  sDescription += line;

  sprintf(line, "Chromatic Induction Factor(Nc)=%f\n", m_pCAM->GetParameter_Nc());
  sDescription += line;

  sprintf(line, "Adaptation Factor(F)=%f\n", m_pCAM->GetParameter_F());
  sDescription += line;

}
sDescription += "End";
sDescription += GetXformName();
sDescription += "\n";
4386}


4389icValidateStatus CIccMpeCAM::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
4390{
icValidateStatus rv = icValidateOK;

if (m_nInputChannels!=3) {
  sReport += icMsgValidateCriticalError;
  sReport += "CAM Element Must have 3 input channels\n";
  rv = icMaxStatus(icValidateCriticalError, rv);
}
if (m_nOutputChannels!=3) {
  sReport += icMsgValidateCriticalError;
  sReport += "CAM Element Must have 3 output channels";
  return icMaxStatus(icValidateCriticalError, rv);
}
if (!m_pCAM) {
  sReport += icMsgValidateCriticalError;
  sReport += "Invalid CAM";
  return icMaxStatus(icValidateCriticalError, rv);
}

return rv;
4410}

4412CIccMpeJabToXYZ::CIccMpeJabToXYZ() : CIccMpeCAM()
4413{
4414}

4416CIccMpeJabToXYZ::CIccMpeJabToXYZ(const CIccMpeJabToXYZ &cam)
4417{
if (cam.m_pCAM) {
  m_pCAM = new CIccCamConverter();
  icFloatNumber xyz[3];
  cam.m_pCAM->GetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_La(cam.m_pCAM->GetParameter_La());
  m_pCAM->SetParameter_Yb(cam.m_pCAM->GetParameter_Yb());
  m_pCAM->SetParameter_C(cam.m_pCAM->GetParameter_C());
  m_pCAM->SetParameter_Nc(cam.m_pCAM->GetParameter_Nc());
  m_pCAM->SetParameter_F(cam.m_pCAM->GetParameter_F());
}
else
  m_pCAM = NULL__null;
4431}

4433CIccMpeJabToXYZ &CIccMpeJabToXYZ::operator=(const CIccMpeJabToXYZ &cam)
4434{
if (cam.m_pCAM) {
  if (m_pCAM)
    delete m_pCAM;

  m_pCAM = new CIccCamConverter();
  icFloatNumber xyz[3];
  
  cam.m_pCAM->GetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_La(cam.m_pCAM->GetParameter_La());
  m_pCAM->SetParameter_Yb(cam.m_pCAM->GetParameter_Yb());
  m_pCAM->SetParameter_C(cam.m_pCAM->GetParameter_C());
  m_pCAM->SetParameter_Nc(cam.m_pCAM->GetParameter_Nc());
  m_pCAM->SetParameter_F(cam.m_pCAM->GetParameter_F());
}
else
  m_pCAM = NULL__null;

return *this;
4454}

4456CIccMpeJabToXYZ::~CIccMpeJabToXYZ()
4457{
4458}

4460void CIccMpeJabToXYZ::Apply(CIccApplyMpe *pApply, icFloatNumber *dstPixel, const icFloatNumber *srcPixel) const
4461{
if (m_pCAM)
  m_pCAM->JabToXYZ(srcPixel, dstPixel, 1);
4464}

4466CIccMpeXYZToJab::CIccMpeXYZToJab() : CIccMpeCAM()
4467{
4468}

4470CIccMpeXYZToJab::CIccMpeXYZToJab(const CIccMpeXYZToJab &cam)
4471{
if (cam.m_pCAM) {
  m_pCAM = new CIccCamConverter();
  icFloatNumber xyz[3];

  cam.m_pCAM->GetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_La(cam.m_pCAM->GetParameter_La());
  m_pCAM->SetParameter_Yb(cam.m_pCAM->GetParameter_Yb());
  m_pCAM->SetParameter_C(cam.m_pCAM->GetParameter_C());
  m_pCAM->SetParameter_Nc(cam.m_pCAM->GetParameter_Nc());
  m_pCAM->SetParameter_F(cam.m_pCAM->GetParameter_F());
}
else
  m_pCAM = NULL__null;
4486}

4488CIccMpeXYZToJab &CIccMpeXYZToJab::operator=(const CIccMpeXYZToJab &cam)
4489{
if (cam.m_pCAM) {
  if (m_pCAM)
    delete m_pCAM;

  m_pCAM = new CIccCamConverter();
  icFloatNumber xyz[3];

  cam.m_pCAM->GetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_WhitePoint(xyz);
  m_pCAM->SetParameter_La(cam.m_pCAM->GetParameter_La());
  m_pCAM->SetParameter_Yb(cam.m_pCAM->GetParameter_Yb());
  m_pCAM->SetParameter_C(cam.m_pCAM->GetParameter_C());
  m_pCAM->SetParameter_Nc(cam.m_pCAM->GetParameter_Nc());
  m_pCAM->SetParameter_F(cam.m_pCAM->GetParameter_F());
}
else
  m_pCAM = NULL__null;

return *this;
4509}

4511CIccMpeXYZToJab::~CIccMpeXYZToJab()
4512{
4513}

4515void CIccMpeXYZToJab::Apply(CIccApplyMpe *pApply, icFloatNumber *dstPixel, const icFloatNumber *srcPixel) const
4516{
if (m_pCAM)
  m_pCAM->XYZToJab(srcPixel, dstPixel, 1);
4519}


4522#ifdef USEREFICCMAXNAMESPACE
4523} //namespace refIccMAX
4524#endif