/Users/xss/DemoIccMAX-hoyt-master/IccXML/IccLibXML/IccMpeXml.cpp

Bug Summary

File:	IccXML/IccLibXML/IccMpeXml.cpp
Warning:	line 312, column 9 Memory allocated by 'new[]' should be deallocated by 'delete[]', not 'delete'
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 IccMpeXml.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/IccXML -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 IccXML2_EXPORTS -I /Users/xss/DemoIccMAX-hoyt-master/build/Cmake/../../IccProfLib -I /Library/Developer/CommandLineTools/SDKs/MacOSX12.sdk/usr/include/libxml2 -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/IccXML -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/IccXML/IccLibXML/IccMpeXml.cpp
1/** @file
  File:       IccMpeXml.cpp

  Contains:   Implementation of MultiProcessElementType Element XML
              conversion functionality

  Version:    V1

  Copyright:  (c) see ICC Software License
10*/

12/*
* 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#include "IccTagXml.h"
65#include "IccMpeXml.h"
66#include "IccUtilXml.h"
67#include "IccIoXml.h"
68#include "IccCAM.h"

70#include <cstring> /* C strings strcpy, memcpy ... */

72#ifdef WIN32
73#include <windows.h>
74#ifdef GetClassName
75#undef GetClassName
76#endif
77#endif

79#ifdef USEREFICCMAXNAMESPACE
80namespace refIccMAX {
81#endif

83bool CIccMpeXmlUnknown::ToXml(std::string &xml, std::string blanks/* = ""*/)
84{
icUInt8Number *m_ptr = m_pData;

char line[256];
char buf[256];
char fix[256];
sprintf(line, "<UnknownElement Type=\"%s\" InputChannels=\"%d\" OutputChannels=\"%d\"", 
         icFixXml(fix, icGetSigStr(buf, GetType())), NumInputChannels(), NumOutputChannels());
xml += blanks + line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%u\"", m_nReserved);
  xml += buf;
}
xml += ">\n";

icXmlDumpHexData(xml, blanks + "  ", m_pData, m_nSize);

xml += blanks + "</UnknownElement>\n";
return true;
104}


107bool CIccMpeXmlUnknown::ParseXml(xmlNode *pNode, std::string &parseStr)
108{
SetType((icElemTypeSignature)icXmlStrToSig(icXmlAttrValue(pNode, "type")));
SetChannels(atoi(icXmlAttrValue(pNode, "InputChannels")), atoi(icXmlAttrValue(pNode, "OutputChannels")));

if (pNode->children && pNode->children->type == XML_TEXT_NODE && pNode->children->content) {
  icUInt32Number nSize = icXmlGetHexDataSize((const char *)pNode->children->content);

  if (!SetDataSize(nSize, false)) 
    return false;

  icXmlGetHexData(m_pData, (const char *)pNode->children->content, nSize);
}
else {
  SetDataSize(0);
}
return true;
124}


127class CIccFormulaCurveSegmentXml : public CIccFormulaCurveSegment
128{
129public:
CIccFormulaCurveSegmentXml(icFloatNumber start, icFloatNumber end) : CIccFormulaCurveSegment(start, end) {}

bool ToXml(std::string &xml, std::string blanks/* = ""*/);
bool ParseXml(xmlNode *pNode, std::string &parseStr);
134};

136static char* icSegPos(char *buf, icFloatNumber pos)
137{
if (pos==icMinFloat32Number-3.402823466e+38F)
  strcpy(buf, "-infinity");
else if (pos==icMaxFloat32Number3.402823466e+38F)
  strcpy(buf, "+infinity");
else
  sprintf(buf, "%.8" ICFLOATSFX"f", pos);

return buf;
146}

148icFloatNumber icGetSegPos(const char *str)
149{
if (!strncmp(str, "-inf", 4)) {
  return icMinFloat32Number-3.402823466e+38F;
}
if (!strncmp(str, "+inf", 4)) {
  return icMaxFloat32Number3.402823466e+38F;
}

return (icFloatNumber)atof(str);
158}


161bool CIccFormulaCurveSegmentXml::ToXml(std::string &xml, std::string blanks)
162{
char buf[256];
char line[256];

sprintf(line, "<FormulaSegment Start=\"%s\"", icSegPos(buf, m_startPoint));
xml += blanks + line;

sprintf(line, " End=\"%s\"",icSegPos(buf, m_endPoint));
xml += line;
  
sprintf(line, " FunctionType=\"%d\"", m_nFunctionType);
xml += line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%d\"", m_nReserved);
  xml += line;
}
if (m_nReserved2) {
  sprintf(line, " Reserved2=\"%d\"", m_nReserved2);
  xml += line;
}
xml += ">\n";

CIccFloatArray::DumpArray(xml, blanks+"  ", m_params, m_nParameters, icConvertFloat, 8);

xml += blanks + "</FormulaSegment>\n";

return true;
190}


193bool CIccFormulaCurveSegmentXml::ParseXml(xmlNode *pNode, std::string &parseStr)
194{
xmlAttr *funcType = icXmlFindAttr(pNode, "FunctionType");

if (!funcType) {
  parseStr += "Bad FunctionType in Formula Segment\n";
  return false;
}

m_nReserved2 = atoi(icXmlAttrValue(pNode, "Reserved2"));
m_nFunctionType = atoi(icXmlAttrValue(funcType));

switch(m_nFunctionType) {
  case 0x0000:
    m_nParameters = 4;
    break;

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

  default:
    parseStr += "Unsupported FunctionType value in Formula Segment\n";
    return false;
}

CIccFloatArray args;

if (!args.ParseArray(pNode->children))
  return false;

if (args.GetSize()>m_nParameters)
  return false;

if (m_params) {
  free(m_params);
}

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

  memcpy(m_params, args.GetBuf(), m_nParameters * sizeof(icFloatNumber));
}
else
  m_params = NULL__null;

return true;
244}


247class CIccSampledCurveSegmentXml : public CIccSampledCurveSegment
248{
249public:
CIccSampledCurveSegmentXml(icFloatNumber start, icFloatNumber end) : CIccSampledCurveSegment(start, end) {}

bool ToXml(std::string &xml, std::string blanks/* = ""*/);
bool ParseXml(xmlNode *pNode, std::string &parseStr);
254};

256bool CIccSampledCurveSegmentXml::ToXml(std::string &xml, std::string blanks)
257{
char buf[256];
char line[256];

sprintf(line, "<SampledSegment Start=\"%s\"", icSegPos(buf, m_startPoint));
xml += blanks + line;

sprintf(line, " End=\"%s\">\n",icSegPos(buf, m_endPoint));
xml += line;

CIccFloatArray::DumpArray(xml, blanks+"  ", m_pSamples, m_nCount, icConvertFloat, 8);

xml += blanks + "</SampledSegment>\n";

return true;
272}


275bool CIccSampledCurveSegmentXml::ParseXml(xmlNode *pNode, std::string &parseStr)
276{
const char *filename = icXmlAttrValue(pNode, "Filename");

// file exists
if (filename[0]) {
18
←
Assuming the condition is true→
19
←
Taking true branch→
  CIccIO *file = IccOpenFileIO(filename, "rb");
  if (!file){
20
←
Assuming 'file' is non-null→
21
←
Taking false branch→
    parseStr += "Error! - File '";
    parseStr += filename;
    parseStr +="' not found.\n";
    delete file;
    return false;
  }

  const char *format = icXmlAttrValue(pNode, "Format");

  // format is text
  if (!strcmp(format, "text")) {
22
←
Taking true branch→
    icUInt32Number num = file->GetLength();
    char *buf = (char *) new char[num];
23
←
Memory is allocated→

    if (!buf23.1
'buf' is non-null
) {          
24
←
Taking false branch→
      perror("Memory Error");
      parseStr += "'";
      parseStr += filename;
      parseStr += "' may not be a valid text file.\n";
      delete buf;
      delete file;
      return false;
    }

    if (file->Read8(buf, num) !=num) {
25
←
Assuming the condition is true→
26
←
Taking true branch→
      perror("Read-File Error");
      parseStr += "'";
      parseStr += filename;
      parseStr += "' may not be a valid text file.\n";
      delete buf;
27
←
Memory allocated by 'new[]' should be deallocated by 'delete[]', not 'delete'
      delete file;             
      return false;
    }   

    CIccFloatArray data;

    //if (!data.ParseTextArray(buf)) {
    if (!data.ParseTextArrayNum(buf, num, parseStr)){
      parseStr += "File '";
      parseStr += filename;
      parseStr += "' is not a valid text file.\n";
      SetSize(0);
      delete buf;
      delete file;
      return false;
    }

    else {
      SetSize(data.GetSize());
      icFloatNumber *src = data.GetBuf();
      icFloatNumber *dst = m_pSamples;          

      icUInt32Number i;
      for (i=0; i<data.GetSize(); i++) {
        *dst = *src; 
        dst++;
        src++;
      }
    }  

    delete buf;
    delete file;
    return true;

  }
  // format is binary
  else if (!strcmp(format, "binary")) {
    const char *order = icXmlAttrValue(pNode, "Endian");
    bool little_endian = !strcmp(order, "little");

    icUInt16Number storageType = icValueTypeFloat32;
    xmlAttr *attr = icXmlFindAttr(pNode, "StorageType");
    if (attr) {
     storageType = (icUInt16Number)atoi(icXmlAttrValue(attr));
    }

    if (storageType == icValueTypeUInt8){
      icUInt32Number num = file->GetLength();
      icUInt8Number value;

      SetSize(num);
      icFloatNumber *dst =  m_pSamples;
      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->Read8(&value)) { 
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;
          return false;
        } 
        *dst++ = (icFloatNumber)value / 255.0f;
      }         
      delete file;
      return true;
    }        
    else if (storageType == icValueTypeUInt16){
      icUInt32Number num = file->GetLength() / sizeof(icUInt16Number);
      icUInt16Number value;
      icUInt8Number *m_ptr = (icUInt8Number*)&value;

      SetSize(num);
      icFloatNumber *dst = m_pSamples;
      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->Read16(&value)) {  //assumes data is big endian
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;              
          return false;
        }
397#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
        if (little_endian) {
399#else
        if (!little_endian) {
401#endif
          icUInt8Number t = m_ptr[0];
          m_ptr[0] = m_ptr[1];
          m_ptr[1] = t;
        }
        *dst++ = (icFloatNumber)value / 65535.0f;
      }
      delete file;
      return true;
    }
    else if (storageType == icValueTypeFloat16){
      icUInt32Number num = file->GetLength() / sizeof(icFloat16Number);
      icFloat16Number value;
      icUInt8Number *m_ptr = (icUInt8Number*)&value;

      SetSize(num);
      icFloatNumber *dst = m_pSamples;
      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->Read16(&value)) { //assumes data is big endian
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;              
          return false;
        }
428#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
        if (little_endian) {
430#else
        if (!little_endian) {
432#endif
          icUInt8Number t = m_ptr[0];
          m_ptr[0] = m_ptr[1];
          m_ptr[1] = t;
        }
        *dst++ = icF16toF(value);
      }
      delete file;
      return true;
    }
    else if (storageType == icValueTypeFloat32) {
      icUInt32Number num = file->GetLength()/sizeof(icFloat32Number);
      icFloat32Number value;
      icUInt8Number *m_ptr = (icUInt8Number*)&value;

      SetSize(num);
      icFloatNumber *dst = m_pSamples;

      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->ReadFloat32Float(&value)) {  //assumes data is big endian
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;
          return false;
        }
460#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
        if (little_endian) {
462#else
        if (!little_endian) {
464#endif
          icUInt8Number tmp;
          tmp = m_ptr[0]; m_ptr[0] = m_ptr[3]; m_ptr[3] = tmp;
          tmp = m_ptr[1]; m_ptr[1] = m_ptr[2]; m_ptr[2] = tmp;
        }
        *dst++ = value;
      }        
      delete file;
      return true;
    }
    else { //not 8bit/16bit/float        
      delete file;
      return false;
    } 
  }
}
else {
  CIccFloatArray samples;

  if (!samples.ParseArray(pNode->children)) {
    return false;
  }

  if (!SetSize(samples.GetSize())) {
    return false;
  }

  memcpy(m_pSamples, samples.GetBuf(), samples.GetSize() * sizeof(icFloatNumber));
}

return true;
495}


498class CIccSinglSampledeCurveXml : public CIccSingleSampledCurve
499{
500public:
CIccSinglSampledeCurveXml(icFloatNumber first=0, icFloatNumber last=0) : CIccSingleSampledCurve(first, last) {}

bool ToXml(std::string &xml, std::string blanks/* = ""*/);
bool ParseXml(xmlNode *pNode, std::string &parseStr);
505};

507bool CIccSinglSampledeCurveXml::ToXml(std::string &xml, std::string blanks)
508{
char line[256];

xml += blanks;
sprintf(line, "<SingleSampledCurve FirstEntry=\"%.8f\"", m_firstEntry);
xml += line;

sprintf(line, " LastEntry=\"%.8f\"", m_lastEntry);
xml += line;

sprintf(line, " StorageType=\"%u\"", m_storageType);
xml += line;

sprintf(line, " ExtensionType=\"%u\">\n", m_extensionType);
xml += line;

CIccFloatArray::DumpArray(xml, blanks+"  ", m_pSamples, m_nCount, icConvertFloat, 8);

xml += blanks + "</SingleSampledCurve>\n";

return true;
529}


532bool CIccSinglSampledeCurveXml::ParseXml(xmlNode *pNode, std::string &parseStr)
533{
xmlAttr *attr = icXmlFindAttr(pNode, "FirstEntry");

if (!attr) {
  parseStr += "Bad FirstEntry in Simple Sampled Segment\n";
  return false;
}

m_firstEntry = (icFloatNumber)atof(icXmlAttrValue(attr));

attr = icXmlFindAttr(pNode, "LastEntry");

if (!attr) {
  parseStr += "Bad LastEntry in Simple Sampled Segment\n";
  return false;
}

m_lastEntry = (icFloatNumber)atof(icXmlAttrValue(attr));

m_storageType = icValueTypeFloat32;
attr = icXmlFindAttr(pNode, "StorageType");
if (attr) {
  m_storageType = (icUInt16Number)atoi(icXmlAttrValue(attr));
}

m_extensionType = icClipSingleSampledCurve;
attr = icXmlFindAttr(pNode, "ExtensionType");
if (attr) {
  m_extensionType = (icUInt16Number)atoi(icXmlAttrValue(attr));
}

const char *filename = icXmlAttrValue(pNode, "Filename");

// file exists
if (filename[0]) {
  CIccIO *file = IccOpenFileIO(filename, "rb");
  if (!file){
    parseStr += "Error! - File '";
    parseStr += filename;
    parseStr +="' not found.\n";
    delete file;
    return false;
  }

  const char *format = icXmlAttrValue(pNode, "Format");

  // format is text
  if (!strcmp(format, "text")) {
    icUInt32Number num = file->GetLength();
    char *buf = (char *) new char[num];

    if (!buf) {          
      perror("Memory Error");
      parseStr += "'";
      parseStr += filename;
      parseStr += "' may not be a valid text file.\n";
      free(buf);
      delete file;
      return false;
    }

    if (file->Read8(buf, num) !=num) {
      perror("Read-File Error");
      parseStr += "'";
      parseStr += filename;
      parseStr += "' may not be a valid text file.\n";
      free(buf);
      delete file;             
      return false;
    }         

    // lut8type
    if (m_storageType == icValueTypeUInt8) {
      CIccUInt8Array data;

      //if (!data.ParseTextArray(buf)) {
      if (!data.ParseTextArrayNum(buf, num, parseStr)){
        parseStr += "File '";
        parseStr += filename;
        parseStr += "' is not a valid text file.\n";
        SetSize(0);
        free(buf);
        delete file;
        return false;
      }

      else {
        SetSize(data.GetSize());
        icUInt8Number *src = data.GetBuf();
        icFloatNumber *dst = m_pSamples;

        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {  
          *dst = (icFloatNumber)(*src) / 255.0f;              
          dst++;
          src++;
        }

        //if (i!=256) {
        //printf("Error! - Input/Output table does not have 256 entries.\n");                            
        //SetSize(0);
        //return false;
        //}
        delete file;
        return true;
      }
    } 

    //lut16type
    else if (m_storageType == icValueTypeUInt16) {
      CIccUInt16Array data;

      //if (!data.ParseTextArray(buf)) {
      if (!data.ParseTextArrayNum(buf, num, parseStr)){
        parseStr += "File '";
        parseStr += filename;
        parseStr += "' is not a valid text file.\n";
        SetSize(0);
        free(buf);
        delete file;
        return false;
      }

      else {
        SetSize(data.GetSize());

        icUInt16Number *src = data.GetBuf();
        icFloatNumber *dst = m_pSamples;

        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst = (icFloatNumber)(*src) / 65535.0f; 
          dst++;
          src++;
        }
      }
      delete file;
      return true;
    }

    //float type
    else if (m_storageType == icValueTypeFloat32){
      CIccFloatArray data;

      //if (!data.ParseTextArray(buf)) {
      if (!data.ParseTextArrayNum(buf, num, parseStr)){
        parseStr += "File '";
        parseStr += filename;
        parseStr += "' is not a valid text file.\n";
        SetSize(0);
        free(buf);
        delete file;
        return false;
      }

      else {
        SetSize(data.GetSize());
        icFloatNumber *src = data.GetBuf();
        icFloatNumber *dst = m_pSamples;          

        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst = *src; 
          dst++;
          src++;
        }
      }  
      delete file;
      return true;
    }        
    else {
      delete file;
      return false;
    }
  }
  // format is binary
  else if (!strcmp(format, "binary")) {
    const char *order = icXmlAttrValue(pNode, "Endian");
    bool little_endian = !strcmp(order, "little");    

    if (m_storageType == icValueTypeUInt8){
      icUInt32Number num = file->GetLength();
      icUInt8Number value;

      SetSize(num);
      icFloatNumber *dst =  m_pSamples;
      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->Read8(&value)) { 
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;
          return false;
        } 
        *dst++ = (icFloatNumber)value / 255.0f;
      }         
      delete file;
      return true;
    }        
    else if (m_storageType == icValueTypeUInt16){
      icUInt32Number num = file->GetLength() / sizeof(icUInt16Number);
      icUInt16Number value;
      icUInt8Number *m_ptr = (icUInt8Number*)&value;

      SetSize(num);
      icFloatNumber *dst = m_pSamples;
      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->Read16(&value)) { //assumes data is big endian
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;              
          return false;
        }
751#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
        if (little_endian) {
753#else
        if (!little_endian) {
755#endif
          icUInt8Number t = m_ptr[0];
          m_ptr[0] = m_ptr[1];
          m_ptr[1] = t;
        }
        *dst++ = (icFloatNumber)value / 65535.0f;
      }
      delete file;
      return true;
    }
    else if (m_storageType == icValueTypeFloat16){
      icUInt32Number num = file->GetLength() / sizeof(icFloat16Number);
      icFloat16Number value;
      icUInt8Number *m_ptr = (icUInt8Number*)&value;

      SetSize(num);
      icFloatNumber *dst = m_pSamples;
      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->Read16(&value)) {  //assumes data is big endian
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;              
          return false;
        }
782#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
        if (little_endian) {
784#else
        if (!little_endian) {
786#endif
          icUInt8Number t = m_ptr[0];
          m_ptr[0] = m_ptr[1];
          m_ptr[1] = t;
        }
        *dst++ = icF16toF(value);
      }
      delete file;
      return true;
    }
    else if (m_storageType == icValueTypeFloat32) {
      icUInt32Number num = file->GetLength()/sizeof(icFloat32Number);
      icFloat32Number value;
      icUInt8Number *m_ptr = (icUInt8Number*)&value;

      SetSize(num);
      icFloatNumber *dst = m_pSamples;

      icUInt32Number i;
      for (i=0; i<num; i++) {
        if (!file->ReadFloat32Float(&value)) {
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid binary file.\n";
          delete file;
          return false;
        }
814#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
        if (little_endian) {
816#else
        if (!little_endian) {
818#endif
          icUInt8Number tmp;
          tmp = m_ptr[0]; m_ptr[0] = m_ptr[3]; m_ptr[3] = tmp;
          tmp = m_ptr[1]; m_ptr[1] = m_ptr[2]; m_ptr[2] = tmp;
        }
        *dst++ = value;
      }        
      delete file;
      return true;
    }
    else { //not 8bit/16bit/float        
      delete file;
      return false;
    } 
  }       
  else {//not text/binary
    delete file;
    return false;
  }
}    
// no file
else{
  CIccFloatArray samples;

  if (!samples.ParseArray(pNode->children)) {
    return false;
  }

  if (!SetSize(samples.GetSize())) {
    return false;
  }

  memcpy(m_pSamples, samples.GetBuf(), samples.GetSize() * sizeof(icFloatNumber));
}

return true;
854}


857bool CIccSegmentedCurveXml::ToXml(std::string &xml, std::string blanks)
858{
CIccCurveSegmentList::iterator seg;
xml += blanks + "<SegmentedCurve>\n";
for (seg = m_list->begin(); seg!=m_list->end(); seg++) {
  CIccCurveSegment* pSeg = *seg;
  if (pSeg && pSeg->GetType() == icSigFormulaCurveSeg) {
    if (!((CIccFormulaCurveSegmentXml*)pSeg)->ToXml(xml, blanks+"  "))
      return false;
  }
  else if (pSeg && pSeg->GetType() == icSigSampledCurveSeg) {
    if (!((CIccSampledCurveSegmentXml*)pSeg)->ToXml(xml, blanks+"  "))
      return false;
  }
  else
    return false;
}
xml += blanks + "</SegmentedCurve>\n";
return true;
876}


879bool CIccSegmentedCurveXml::ParseXml(xmlNode *pNode, std::string &parseStr)
880{
m_list->clear();
for (pNode=pNode->children; pNode; pNode=pNode->next) {
11
←
Loop condition is true.  Entering loop body→
  if (pNode->type == XML_ELEMENT_NODE) {
12
←
Assuming field 'type' is equal to XML_ELEMENT_NODE→
13
←
Taking true branch→
    icFloatNumber start = icGetSegPos(icXmlAttrValue(pNode, "Start"));
    icFloatNumber end = icGetSegPos(icXmlAttrValue(pNode, "End"));

    if (!icXmlStrCmp(pNode->name, "FormulaSegment")strcmp((const char *)(pNode->name), (const char*)("FormulaSegment"
))) {
14
←
Assuming the condition is false→
15
←
Taking false branch→
      CIccFormulaCurveSegmentXml *pSegXml = new CIccFormulaCurveSegmentXml(start, end);

      if (!pSegXml->ParseXml(pNode, parseStr)) {
        parseStr += "Unable to parse FormulaSegment\n";
        delete pSegXml;
        return false;
      }
      m_list->push_back(pSegXml);
    }
    else if (!icXmlStrCmp(pNode->name, "SampledSegment")strcmp((const char *)(pNode->name), (const char*)("SampledSegment"
))) {
16
←
Taking true branch→
      CIccSampledCurveSegmentXml *pSegXml = new CIccSampledCurveSegmentXml(start, end);

      if (!pSegXml->ParseXml(pNode, parseStr)) {
17
←
Calling 'CIccSampledCurveSegmentXml::ParseXml'→
        parseStr += "Unable to parse SampledSegment\n";
        delete pSegXml;
        return false;
      }
      m_list->push_back(pSegXml);
    }
    else {
      parseStr += "Bad Segment Type\n";
      return false;
    }
  }
}
return true;
914}


917bool CIccMpeXmlCurveSet::ToXml(std::string &xml, std::string blanks/* = ""*/)
918{
char line[256];
sprintf(line, "<CurveSetElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
xml += blanks + line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%u\"", m_nReserved);
  xml += line;
}
xml += ">\n";

int i;

for (i=0; i<NumInputChannels(); i++) {
  CIccCurveSetCurve* curve = m_curve[i];
  if (curve->GetType() == icSigSingleSampledCurve) {
    CIccSinglSampledeCurveXml *m_ptr = (CIccSinglSampledeCurveXml*)m_curve[i];

    if (!(m_ptr->ToXml(xml, blanks + "  ")))
      return false;
  }
  else if (curve->GetType() == icSigSegmentedCurve) {
    CIccSegmentedCurveXml *m_ptr = (CIccSegmentedCurveXml*)m_curve[i];

    if (!(m_ptr->ToXml(xml, blanks + "  ")))
      return false;
  }
  else
    return false;
}

xml += blanks + "</CurveSetElement>\n";
return true;
951}


954bool CIccMpeXmlCurveSet::ParseXml(xmlNode *pNode, std::string &parseStr)
955{
icUInt16Number nChannels = (icUInt16Number)atoi(icXmlAttrValue(pNode, "InputChannels"));

if (!nChannels || atoi(icXmlAttrValue(pNode, "OutputChannels")) != nChannels) {
1
Assuming 'nChannels' is not equal to 0→
2
←
Assuming the condition is false→
3
←
Taking false branch→
  parseStr += "Invalid InputChannels or OutputChannels In CurveSetElement\n";
  return false;
}

SetSize(nChannels);
int nIndex = 0;
for (pNode = pNode->children, nIndex = 0;
4
←
Loop condition is true.  Entering loop body→
     pNode;
     pNode=pNode->next) {
  if (pNode->type == XML_ELEMENT_NODE) {
5
←
Assuming field 'type' is equal to XML_ELEMENT_NODE→
6
←
Taking true branch→
    if (nIndex >= nChannels) {
7
←
Assuming 'nIndex' is < 'nChannels'→
8
←
Taking false branch→
      return false;
    }
    else if (!strcmp((const char*)pNode->name, "SegmentedCurve")) {
9
←
Taking true branch→
      CIccSegmentedCurveXml *pCurve = new CIccSegmentedCurveXml();

      if (!pCurve->ParseXml(pNode, parseStr)) {
10
←
Calling 'CIccSegmentedCurveXml::ParseXml'→
        delete pCurve;
        return false;
      }
      if (!SetCurve(nIndex, pCurve))
        return false;
      nIndex++;
    }
    else if (!strcmp((const char*)pNode->name, "SingleSampledCurve")) {
      CIccSinglSampledeCurveXml *pCurve = new CIccSinglSampledeCurveXml();

      if (!pCurve->ParseXml(pNode, parseStr)) {
        delete pCurve;
        return false;
      }
      if (!SetCurve(nIndex, pCurve))
        return false;
      nIndex++;
    }
    else
      return false;
  }
}

if (!pNode && nIndex == nChannels)
  return true;

return false;
1003}


1006bool CIccMpeXmlMatrix::ToXml(std::string &xml, std::string blanks/* = ""*/)
1007{
char buf[128];
sprintf(buf, "<MatrixElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
xml += blanks + buf;

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml += buf;
}
xml += ">\n";

int i, j, n;

if (m_pMatrix) {
  xml += blanks + "  <MatrixData>\n";

  for (n=0, j=0; j<NumOutputChannels(); j++) {
    xml += blanks + "   ";
    for (i=0; i<NumInputChannels(); i++, n++) {
       sprintf(buf, " %.8f", m_pMatrix[n]);
       xml += buf;
    }
    xml += "\n";
  }
  xml += blanks + "  </MatrixData>\n";
}

if (m_pConstants) {
  for (i = 0; i < NumOutputChannels(); i++) {
    if (icNotZero(m_pConstants[i])((m_pConstants[i])>1.0e-8 || (m_pConstants[i])<-1.0e-8))
      break;
  }
  if (i < NumOutputChannels()) {
    xml += blanks + "  <ConstantData>\n";

    xml += blanks + "   ";
    for (i = 0; i < NumOutputChannels(); i++) {
      sprintf(buf, " %.8f", m_pConstants[i]);
      xml += buf;
    }
    xml += "\n";

    xml += blanks + "  </ConstantData>\n";
  }
}

xml += blanks + "</MatrixElement>\n";

return true;
1056}


1059bool CIccMpeXmlMatrix::ParseXml(xmlNode *pNode, std::string &parseStr)
1060{
icUInt16Number nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
icUInt16Number nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));
if (!nInputChannels || !nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In MatrixElement\n";
  return false;
}

xmlNode *pData;

pData = icXmlFindNode(pNode->children, "MatrixData");
if (pData) {
  SetSize(nInputChannels, nOutputChannels);

  if (!CIccFloatArray::ParseArray(m_pMatrix, m_nInputChannels*m_nOutputChannels, pData->children))
    return false;

  const char *invert = icXmlAttrValue(pData, "InvertMatrix", "false");
  if (!stricmpstrcasecmp(invert, "true")) {
    if (m_nInputChannels != m_nOutputChannels) {
      parseStr += "Inversion of MatrixData requires square matrix\n";
      return false;
    }
    IIccMatrixInverter *pInverter = IccGetDefaultMatrixInverter();
    if (!pInverter || !pInverter->Invert(m_pMatrix, m_nOutputChannels, m_nInputChannels)) {
      parseStr += "Unable to invert matrix!\n";
      return false;
    }
  }
}
else { //Having no MatrixData implies having a matrix full of zeros which is represented by m_pMatrix set to NULL
  SetSize(0, nOutputChannels); //Initialize with m_pMatrix set to NULL
  m_nInputChannels = nInputChannels; //Fix m_nInputChannels
}

pData = icXmlFindNode(pNode->children, "ConstantData");
if (pData) {
  if (!CIccFloatArray::ParseArray(m_pConstants, m_nOutputChannels, pData->children))
    return false;
}
return true;
1101}

1103bool CIccMpeXmlEmissionMatrix::ToXml(std::string &xml, std::string blanks/* = ""*/)
1104{
char buf[128];
sprintf(buf, "<EmissionMatrixElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
xml += blanks + buf;

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml += buf;
}
xml += ">\n";

sprintf(buf, "  <Wavelengths start=\"%.8f\" end=\"%.8f\" steps=\"%d\"/>\n", icF16toF(m_Range.start), icF16toF(m_Range.end), m_Range.steps);
xml += blanks + buf;

int i, j, n;

if (m_pWhite) {
  xml += blanks + "  <WhiteData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pWhite[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </WhiteData>\n";
}

if (m_pMatrix) {
  xml += blanks + "  <MatrixData>\n";

  for (n=0, j=0; j<numVectors(); j++) {
    xml += blanks + "   ";
    for (i=0; i<(int)m_Range.steps; i++, n++) {
      sprintf(buf, " %.8f", m_pMatrix[n]);
      xml += buf;
    }
    xml += "\n";
  }
  xml += blanks + "  </MatrixData>\n";
}

if (m_pOffset) {
  xml += blanks + "  <OffsetData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pOffset[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </OffsetData>\n";
}

xml += blanks + "</EmissionMatrixElement>\n";

return true;
1163}


1166bool CIccMpeXmlEmissionMatrix::ParseXml(xmlNode *pNode, std::string &parseStr)
1167{
icUInt16Number nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
icUInt16Number nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (!nInputChannels || !nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In MatrixElement\n";
  return false;
}

xmlNode *pData;

pData = icXmlFindNode(pNode->children, "Wavelengths");
if (pData) {
  icFloatNumber dStart = (icFloatNumber)atof(icXmlAttrValue(pData, "start"));
  icFloatNumber dEnd = (icFloatNumber)atof(icXmlAttrValue(pData, "end"));
  icUInt16Number nSteps = atoi(icXmlAttrValue(pData, "steps"));

  if (!nSteps) {
    parseStr += "Invalid Spectral Range\n";
    return false;
  }
  m_Range.start = icFtoF16(dStart);
  m_Range.end = icFtoF16(dEnd);
  m_Range.steps = nSteps;
}

SetSize(nInputChannels, nOutputChannels, m_Range);
if (!m_pWhite || !m_pMatrix || !m_pOffset) {
  parseStr += "Unable to SetSize\n";
  return false;
}

pData = icXmlFindNode(pNode->children, "WhiteData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pWhite, m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing MatrixData";
}

pData = icXmlFindNode(pNode->children, "MatrixData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pMatrix, numVectors()*(int)m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing MatrixData";
}

pData = icXmlFindNode(pNode->children, "OffsetData");
if (pData) {
  if (!CIccFloatArray::ParseArray(m_pOffset, m_Range.steps, pData->children))
    return false;
}
else {
  memset(m_pOffset, 0, (int)m_Range.steps*sizeof(icFloatNumber));
}
return true;
1228}

1230bool CIccMpeXmlInvEmissionMatrix::ToXml(std::string &xml, std::string blanks/* = ""*/)
1231{
char buf[128];
sprintf(buf, "<InvEmissionMatrixElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
xml += blanks + buf;

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml += buf;
}
xml += ">\n";

sprintf(buf, "  <Wavelengths start=\"%.8f\" end=\"%.8f\" steps=\"%d\"/>\n", icF16toF(m_Range.start), icF16toF(m_Range.end), m_Range.steps);
xml += blanks + buf;

int i, j, n;

if (m_pWhite) {
  xml += blanks + "  <WhiteData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pWhite[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </WhiteData>\n";
}

if (m_pMatrix) {
  xml += blanks + "  <MatrixData>\n";

  for (n=0, j=0; j<numVectors(); j++) {
    xml += blanks + "   ";
    for (i=0; i<(int)m_Range.steps; i++, n++) {
      sprintf(buf, " %.8f", m_pMatrix[n]);
      xml += buf;
    }
    xml += "\n";
  }
  xml += blanks + "  </MatrixData>\n";
}

if (m_pOffset) {
  xml += blanks + "  <OffsetData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pOffset[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </OffsetData>\n";
}

xml += blanks + "</InvEmissionMatrixElement>\n";

return true;
1290}


1293bool CIccMpeXmlInvEmissionMatrix::ParseXml(xmlNode *pNode, std::string &parseStr)
1294{
icUInt16Number nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
icUInt16Number nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (!nInputChannels || !nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In MatrixElement\n";
  return false;
}

xmlNode *pData;

pData = icXmlFindNode(pNode->children, "Wavelengths");
if (pData) {
  icFloatNumber dStart = (icFloatNumber)atof(icXmlAttrValue(pData, "start"));
  icFloatNumber dEnd = (icFloatNumber)atof(icXmlAttrValue(pData, "end"));
  icUInt16Number nSteps = atoi(icXmlAttrValue(pData, "steps"));

  if (!nSteps) {
    parseStr += "Invalid Spectral Range\n";
    return false;
  }
  m_Range.start = icFtoF16(dStart);
  m_Range.end = icFtoF16(dEnd);
  m_Range.steps = nSteps;
}

SetSize(nInputChannels, nOutputChannels, m_Range);
if (!m_pWhite || !m_pMatrix || !m_pOffset) {
  parseStr += "Unable to SetSize\n";
  return false;
}

pData = icXmlFindNode(pNode->children, "WhiteData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pWhite, m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing White Data";
}

pData = icXmlFindNode(pNode->children, "MatrixData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pMatrix, numVectors()*(int)m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing Matrix Data";
}

pData = icXmlFindNode(pNode->children, "OffsetData");
if (pData) {
  if (!CIccFloatArray::ParseArray(m_pOffset, m_Range.steps, pData->children))
    return false;
}
else {
  memset(m_pOffset, 0, (int)m_Range.steps*sizeof(icFloatNumber));
}
return true;
1355}

1357bool CIccMpeXmlTintArray::ToXml(std::string &xml, std::string blanks/* = ""*/)
1358{
char buf[128], line[128];
sprintf(buf, "<TintArrayElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
xml += blanks + buf;

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml += buf;
}
xml += ">\n";

IIccExtensionTag *pTagEx;
if (m_Array && (pTagEx=m_Array->GetExtension()) && !strcmp(pTagEx->GetExtClassName(), "CIccTagXml")) {
  CIccTagXml *pTagXml = (CIccTagXml*)pTagEx;
  const icChar* tagSig = icGetTagSigTypeName(m_Array->GetType());

  sprintf(line, "  <%s>\n",  tagSig); //parent node is the tag type
  xml += line; 				

  //convert the rest of the tag to xml
  if (!pTagXml->ToXml(xml, "    ")) {
    printf("Unable to output tag with type %s\n", icGetSigStr(buf, m_Array->GetType()));
    return false;
  }
  sprintf(line, "  </%s>\n",  tagSig);
  xml += line; 	
}

xml += blanks + "</TintArrayElement>\n";

return true;
1389}


1392bool CIccMpeXmlTintArray::ParseXml(xmlNode *pNode, std::string &parseStr)
1393{
icUInt16Number nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
icUInt16Number nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));
if (!nInputChannels || !nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In MatrixElement\n";
  return false;
}
m_nInputChannels = nInputChannels;
m_nOutputChannels = nOutputChannels;

for (pNode = pNode->children; pNode && pNode->type != XML_ELEMENT_NODE; pNode = pNode->next);
if (pNode) {
  CIccTag *pTag = NULL__null;
  icSignature sigTag = (icSignature)0;

  // get the tag signature
  std::string nodeName = (icChar*) pNode->name;
  icTagTypeSignature sigType = icGetTypeNameTagSig (nodeName.c_str());

  if (sigType==icSigUnknownType((icTagTypeSignature) 0x3f3f3f3f)){
    xmlAttr *attr = icXmlFindAttr(pNode, "type");
    sigType = (icTagTypeSignature)icGetSigVal((icChar*) icXmlAttrValue(attr));
  }

  CIccInfo info;

  // create a tag based on the signature
  pTag = CIccTag::Create(sigType);

  if (!pTag && !pTag->IsNumArrayType()) {
    parseStr+= "Invalid data type for Tint Array!\n";
    delete pTag;
    return false;
  }

  IIccExtensionTag *pExt;

  if (pTag && (pExt = pTag->GetExtension()) && !strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
    CIccTagXml* pXmlTag = (CIccTagXml*)pExt;
    xmlAttr *attr;

    if (pXmlTag->ParseXml(pNode->children, parseStr)) {
      if ((attr=icXmlFindAttr(pNode, "reserved"))) {
        sscanf(icXmlAttrValue(attr), "%u", &pTag->m_nReserved);
      }
      m_Array = (CIccTagNumArray*)pTag;
    }
    else {
      parseStr += "Unable to Parse \"";
      parseStr += info.GetTagTypeSigName(sigType);
      parseStr += "\" (";
      parseStr += nodeName;
      parseStr += ") Tint Tag\n";
      delete pTag;
      return false;
    }
  }
  else {
    parseStr += "Invalid tag extension for \"";
    parseStr += info.GetTagTypeSigName(sigType);
    parseStr += "\" (";
    parseStr += nodeName;
    parseStr += ") Tint Tag\n";
    if (pTag)
      delete pTag;
    return false;
  }
}
else {
  parseStr += "Tint Array missing tint values\n";
  return false;
}
return true;
1466}


1469extern CIccCLUT *icCLutFromXml(xmlNode *pNode, int nIn, int nOut, icConvertType nType, std::string &parseStr);

1471bool CIccMpeXmlCLUT::ToXml(std::string &xml, std::string blanks/* = ""*/)
1472{
char attrs[256];

if (m_nReserved) {
  sprintf(attrs, " InputChannels=\"%d\" OutputChannels=\"%d\" Reserved=\"%u\"", NumInputChannels(), NumOutputChannels(), m_nReserved);
}
else {
  sprintf(attrs, " InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
}

return icCLUTToXml(xml, m_pCLUT, icConvertFloat, blanks, true, attrs, "CLutElement");
1483}

1485bool CIccMpeXmlCLUT::ParseXml(xmlNode *pNode, std::string &parseStr)
1486{
m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (!m_nInputChannels || !m_nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In CLutElement\n";
  return false;
}

CIccCLUT *pCLut = icCLutFromXml(pNode, m_nInputChannels, m_nOutputChannels, icConvertFloat, parseStr);
if (pCLut) {
  SetCLUT(pCLut);
  if (m_pCLUT)
    return true;
}

return false;
1503}

1505bool CIccMpeXmlExtCLUT::ToXml(std::string &xml, std::string blanks/* = ""*/)
1506{
char attrs[256];
std::string reserved;

if (m_nReserved) {
  sprintf(attrs, " Reserved=\"%u\"", m_nReserved);
  reserved = attrs;
}

if (m_nReserved2) {
  sprintf(attrs, " Reserved2=\"%u\"", m_nReserved2);
  reserved += attrs;
}

sprintf(attrs, " InputChannels=\"%d\" OutputChannels=\"%d\"%s StorageType=\"%d\"", NumInputChannels(), NumOutputChannels(), reserved.c_str(), m_storageType);

return icCLUTToXml(xml, m_pCLUT, icConvertFloat, blanks, true, attrs, "ExtCLutElement");
1523}

1525bool CIccMpeXmlExtCLUT::ParseXml(xmlNode *pNode, std::string &parseStr)
1526{
m_storageType = (icUInt16Number)atoi(icXmlAttrValue(pNode, "StorageType", "0"));
m_nReserved2 = atoi(icXmlAttrValue(pNode, "Reserved2", "0"));

m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (!m_nInputChannels || !m_nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In ExtCLutElement\n";
  return false;
}

CIccCLUT *pCLut = icCLutFromXml(pNode, m_nInputChannels, m_nOutputChannels, icConvertFloat, parseStr);
if (pCLut) {
  SetCLUT(pCLut);
  if (m_pCLUT)
    return true;
}

return false;
1546}

1548bool CIccMpeXmlBAcs::ToXml(std::string &xml, std::string blanks/* = ""*/)
1549{
char line[256];
char buf[256], fix[256];

sprintf(line, "<BAcsElement InputChannels=\"%d\" OutputChannels=\"%d\" Signature=\"%s\"", NumInputChannels(), NumOutputChannels(),
              icFixXml(fix, icGetSigStr(buf, m_signature)));
xml += blanks + line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%u\"", m_nReserved);
  xml += line;
}

if (m_pData && m_nDataSize) {
  icUInt8Number *m_ptr = m_pData;

  xml += ">\n";

  icXmlDumpHexData(xml, blanks+"  ", m_pData, m_nDataSize);

  xml += blanks + "</BAcsElement>\n";
}
else {
  xml += "/>\n";
}

return true;
1576}


1579bool CIccMpeXmlBAcs::ParseXml(xmlNode *pNode, std::string &parseStr)
1580{
m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (!m_nInputChannels || !m_nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In BAcsElement\n";
  return false;
}

m_signature = icXmlStrToSig(icXmlAttrValue(pNode, "Signature"));

if (pNode->children && pNode->children->type == XML_TEXT_NODE && pNode->children->content) {
  icUInt32Number nSize = icXmlGetHexDataSize((const char*)pNode->children->content);

  if (nSize) {
    if (!AllocData(nSize))
      return false;
    icXmlGetHexData(m_pData, (const char *)pNode->children->content, nSize);
  }
}
return true;
1601}


1604bool CIccMpeXmlEAcs::ToXml(std::string &xml, std::string blanks/* = ""*/)
1605{
char line[256];
char buf[256], fix[256];

sprintf(line, "<EAcsElement InputChannels=\"%d\" OutputChannels=\"%d\" Signature=\"%s\"", NumInputChannels(), NumOutputChannels(),
  icFixXml(fix, icGetSigStr(buf, m_signature)));
xml += blanks + line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%u\"", m_nReserved);
  xml += line;
}

if (m_pData && m_nDataSize) {
  icUInt8Number *m_ptr = m_pData;

  xml += ">\n";
  icXmlDumpHexData(xml, blanks+"  ", m_pData, m_nDataSize);
  xml += blanks + "</EAcsElement>\n";
}
else {
  xml += "/>\n";
}

return true;
1630}


1633bool CIccMpeXmlEAcs::ParseXml(xmlNode *pNode, std::string &parseStr)
1634{
m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (!m_nInputChannels || !m_nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In EAcsElement\n";
  return false;
}

m_signature = icXmlStrToSig(icXmlAttrValue(pNode, "Signature"));

if (pNode->children && pNode->children->type == XML_TEXT_NODE && pNode->children->content) {
  icUInt32Number nSize = icXmlGetHexDataSize((const char*)pNode->children->content);

  if (nSize) {
    if (!AllocData(nSize))
      return false;
    icXmlGetHexData(m_pData, (const char *)pNode->children->content, nSize);
  }
}
return true;
1655}

1657static bool icXmlDumpColorAppearanceParams(std::string &xml, std::string blanks, CIccCamConverter *pCam)
1658{
char line[256];
icFloatNumber xyz[3];

xml += blanks + "<ColorAppearanceParams>\n";

pCam->GetParameter_WhitePoint(&xyz[0]);
sprintf(line, "  <XYZNumber X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"/>", xyz[0], xyz[1], xyz[2]);

xml += blanks + " <WhitePoint>\n";
xml += blanks + line;
xml += blanks + " </WhitePoint>\n";

sprintf(line, " <Luminance>%f</Luminance>\n", pCam->GetParameter_La());
xml += blanks + line;

sprintf(line, " <BackgroundLuminance>%.8f</BackgroundLuminance>\n", pCam->GetParameter_Yb());
xml += blanks + line;

sprintf(line, " <ImpactSurround>%f</ImpactSurround>\n", pCam->GetParameter_C());
xml += blanks + line;

sprintf(line, " <ChromaticInductionFactor>%f</ChromaticInductionFactor>\n", pCam->GetParameter_Nc());
xml += blanks + line;

sprintf(line, " <AdaptationFactor>%f</AdaptationFactor>\n", pCam->GetParameter_F());
xml += blanks + line;

xml += "</ColorAppearanceParams>\n";

return true;
1689}

1691static bool icXmlParseColorAppearanceParams(xmlNode *pNode, std::string &parseStr, CIccCamConverter *pCam)
1692{
 xmlNode *pChild = icXmlFindNode(pNode, "WhitePoint");
 if (!pChild) {
   parseStr += "Unable to find CAM Whitepoint\n";
   return false;
 }

 xmlNode *xyzNode = icXmlFindNode(pChild->children, "XYZNumber");

 if (!xyzNode) {
   parseStr += "Unable to find valid CAM WhitePoint XYZ\n";
   return false;
 }

 xmlAttr *x = icXmlFindAttr(xyzNode, "X");
 xmlAttr *y = icXmlFindAttr(xyzNode, "Y");
 xmlAttr *z = icXmlFindAttr(xyzNode, "Z");

 icFloatNumber xyz[3];
 if (x && y && z) {
   xyz[0] = (icFloatNumber)atof(icXmlAttrValue(x));
   xyz[1] = (icFloatNumber)atof(icXmlAttrValue(y));
   xyz[2] = (icFloatNumber)atof(icXmlAttrValue(z));
 }
 else {
   parseStr += "Invalid CAM WhitePoint XYZNumber\n";
   return false;
 }
 pCam->SetParameter_WhitePoint(&xyz[0]);

 pChild = icXmlFindNode(pNode, "Luminance");
 if (!pChild || !pChild->children || !pChild->children->content) {
   parseStr += "Invalid CAM Luminance\n";
   return false;
 }
 pCam->SetParameter_La((icFloatNumber)atof((const char*)pChild->children->content));

 pChild = icXmlFindNode(pNode, "BackgroundLuminance");
 if (!pChild || !pChild->children || !pChild->children->content) {
   parseStr += "Invalid CAM Luminance\n";
   return false;
 }
 pCam->SetParameter_Yb((icFloatNumber)atof((const char*)pChild->children->content));

 pChild = icXmlFindNode(pNode, "ImpactSurround");
 if (!pChild || !pChild->children || !pChild->children->content) {
   parseStr += "Invalid CAM ImpactSurround\n";
   return false;
 }
 pCam->SetParameter_C((icFloatNumber)atof((const char*)pChild->children->content));

 pChild = icXmlFindNode(pNode, "ChromaticInductionFactor");
 if (!pChild || !pChild->children || !pChild->children->content) {
   parseStr += "Invalid CAM ChromaticInductionFactor\n";
   return false;
 }
 pCam->SetParameter_Nc((icFloatNumber)atof((const char*)pChild->children->content));

 pChild = icXmlFindNode(pNode, "AdaptationFactor");
 if (!pChild || !pChild->children || !pChild->children->content) {
   parseStr += "Invalid CAM AdaptationFactor\n";
   return false;
 }
 pCam->SetParameter_F((icFloatNumber)atof((const char*)pChild->children->content));

 return true;
1758}

1760bool CIccMpeXmlJabToXYZ::ToXml(std::string &xml, std::string blanks/* = ""*/)
1761{
char line[256];

sprintf(line, "<JabToXYZElement InputChannels=\"%d\" OutputChannels=\"%d\"" , NumInputChannels(), NumOutputChannels());
xml += blanks + line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%u\"", m_nReserved);
  xml += line;
}
xml += ">\n";

if (m_pCAM) {
  icXmlDumpColorAppearanceParams(xml, blanks+"  ", m_pCAM);
  xml += blanks + "</JabToXYZElement>\n";
}

return true;
1779}


1782bool CIccMpeXmlJabToXYZ::ParseXml(xmlNode *pNode, std::string &parseStr)
1783{
m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (m_nInputChannels!=3 || m_nOutputChannels!=3) {
  parseStr += "Invalid InputChannels or OutputChannels In JabToXYZElement\n";
  return false;
}
xmlNode *pChild = icXmlFindNode(pNode->children, "ColorAppearanceParams");

if (pChild) {
  CIccCamConverter *pCAM = new CIccCamConverter();

  if (!icXmlParseColorAppearanceParams(pChild->children, parseStr, pCAM)) {
    delete pCAM;
    return false;
  }

  SetCAM(pCAM);
}
else {
  parseStr += "Unable to find ColorAppearanceParams\n";
  return false;
}

return true;
1809}

1811bool CIccMpeXmlXYZToJab::ToXml(std::string &xml, std::string blanks/* = ""*/)
1812{
char line[256];

sprintf(line, "<XYZToJabElement InputChannels=\"%d\" OutputChannels=\"%d\"" , NumInputChannels(), NumOutputChannels());
  xml += blanks + line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%u\"", m_nReserved);
  xml += line;
}
xml += ">\n";

if (m_pCAM) {
  icXmlDumpColorAppearanceParams(xml, blanks+"  ", m_pCAM);
  xml += blanks + "</XYZToJabElement>\n";
}

return true;
1830}


1833bool CIccMpeXmlXYZToJab::ParseXml(xmlNode *pNode, std::string &parseStr)
1834{
m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));

if (m_nInputChannels!=3 || m_nOutputChannels!=3) {
  parseStr += "Invalid InputChannels or OutputChannels In XYZToJabElement\n";
  return false;
}
xmlNode *pChild = icXmlFindNode(pNode->children, "ColorAppearanceParams");

if (pChild) {
  CIccCamConverter *pCAM = new CIccCamConverter();

  if (!icXmlParseColorAppearanceParams(pChild->children, parseStr, pCAM)) {
    delete pCAM;
    return false;
  }

  SetCAM(pCAM);
}
else {
  parseStr += "Unable to find ColorAppearanceParams\n";
  return false;
}

return true;
1860}


1863bool CIccMpeXmlCalculator::ToXml(std::string &xml, std::string blanks/* = ""*/)
1864{
char line[256];
std::string blanks2 = blanks + "  ";

sprintf(line, "<CalculatorElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
xml += blanks + line;

if (m_nReserved) {
  sprintf(line, " Reserved=\"%u\"", m_nReserved);
  xml += line;
}
xml += ">\n";

int i;

if (m_SubElem && m_nSubElem) {
  xml += blanks2 + "<SubElements>\n";
  for (i=0; i<(int)m_nSubElem; i++) {
    if (m_SubElem[i]) {
      IIccExtensionMpe *pExt = m_SubElem[i]->GetExtension();
      if (pExt && !strcmp(pExt->GetExtClassName(), "CIccMpeXml")) {
        CIccMpeXml *pMpe = (CIccMpeXml*)pExt;
        pMpe->ToXml(xml, blanks2+"  ");
      }
      else {
        return false;
      }
    }
    else {
      return false;
    }
  }
  xml += blanks2 + "</SubElements>\n";
}

if (m_calcFunc) {
  std::string desc;

  xml += blanks2 + "<MainFunction>\n";

  m_calcFunc->Describe(desc, (int)blanks2.size()+2);
  xml += desc;

  xml+= blanks2 + "</MainFunction>\n";
}

xml += blanks + "</CalculatorElement>\n";
return true;
1912}

1914bool CIccMpeXmlCalculator::validNameChar(char c, bool bFirst)
1915{
if (bFirst && !((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_')))
  return false;
else if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (c == '_')))
  return false;

return true;
1922}

1924bool CIccMpeXmlCalculator::validName(const char *szName)
1925{
const char *ptr;
if (!szName || !*szName) {
  return false;
}

for (ptr = szName; *ptr; ptr++) {
  if (!validNameChar(*ptr, ptr == szName))
    return false;
}

return true;
1937}

1939bool CIccMpeXmlCalculator::ParseImport(xmlNode *pNode, std::string importPath, std::string &parseStr)
1940{
xmlNode *pChild, *pNext;
xmlAttr *attr;

pChild = icXmlFindNode(pNode->children, "Imports");
if (pChild) {
  for (pNext = pChild->children; pNext; pNext = pNext->next) {
    if (pNext->type == XML_ELEMENT_NODE) {
      if (!strcmp((icChar*)pNext->name, "Import")) {
        if ((attr = icXmlFindAttr(pNext, "Filename"))) {
          std::string file = icXmlAttrValue(attr);
          xmlDoc *doc = NULL__null;
          xmlNode *root_element = NULL__null;

          std::string look = "*";
          look += file;
          look += "*";

          if (strstr(importPath.c_str(), look.c_str())) {
            //Already imported this file
            continue;
          }

          /*parse the file and get the DOM */
          doc = xmlReadFile(file.c_str(), NULL__null, 0);

          if (doc == NULL__null) {
            parseStr += "Unable to import '";
            parseStr += file;
            parseStr += '\n';
            return false;
          }

          /*Get the root element node */
          root_element = xmlDocGetRootElement(doc);
          if (strcmp((icChar*)root_element->name, "IccCalcImport")) {
            parseStr += "Invalid calc element import file '" + file + "'\n";
            return false;
          }

          bool rv = ParseImport(root_element, importPath+file+"*", parseStr);

          xmlFreeDoc(doc);
        }
        else {
          parseStr += "Missing import file specifier\n";
          return false;
        }
      }
      else {
        parseStr += "Invalid import specifier\n";
        return false;
      }
    }
  }
}

pChild = icXmlFindNode(pNode->children, "Variables");
if (pChild) {
  for (pNext = pChild->children; pNext; pNext = pNext->next) {
    if (pNext->type == XML_ELEMENT_NODE) {
      if (!strcmp((icChar*)pNext->name, "Declare")) {
        if ((attr = icXmlFindAttr(pNext, "Name"))) {
          std::string name = icXmlAttrValue(attr);
          if (!validName(name.c_str())) {
            parseStr += "Invalid calc element variable name '" + name + "'\n'";
            return false;
          }

          TempDeclVarMap::iterator v = m_declVarMap.find(name);
          if (v != m_declVarMap.end()) {
            parseStr += "Calc element variable '" + name + "' was previously declared\n";
            return false;
          }
          int offset = -1;
          icUInt16Number size = 1;

          if ((attr = icXmlFindAttr(pNext, "Position"))) {
            offset = atoi(icXmlAttrValue(attr));
            if (offset && importPath != "*") {
              parseStr += "Position cannot be specified for imported variables";
              return false;
            }
          }
          if ((attr = icXmlFindAttr(pNext, "Size"))) {
            size = (icUInt16Number)atoi(icXmlAttrValue(attr));
          }
          if (size < 1) size = 1;

          CIccTempDeclVar var = CIccTempDeclVar(name, offset, size);
          if (pNext->children && pNext->children->content) {
            CIccFuncTokenizer parse((icChar*)pNext->children->content);
            offset = 0;

            while (parse.GetNext()) {
              icUInt16Number extra = 0;
              std::string member = parse.GetName();
              if (!validName(member.c_str())) {
                parseStr += "Invalid member name '" + member + "' for calc element variable '" + name + "'\n";
                return false;
              }
              size = 0; extra = 0;
              parse.GetIndex(size, extra, 1, 0);
              size++;
              if (size < 1) 
                size = 1;

              var.m_members.push_back(CIccTempVar(member, offset, size));
              offset += size;
            }
            if (var.m_size < offset)
              var.m_size = offset;
          }
          m_declVarMap[name] = var;
        }
        else {
          parseStr += "Missing calc element variable name definition\n";
          return false;
        }
      }
      else {
        parseStr += "Invalid calc element variable declaration\n";
        return false;
      }
    }
  }
}

pChild = icXmlFindNode(pNode->children, "Macros");
if (pChild) {
  for (pNext = pChild->children; pNext; pNext = pNext->next) {
    if (pNext->type == XML_ELEMENT_NODE) {
      if (!strcmp((icChar*)pNext->name, "Macro")) {
        if ((attr = icXmlFindAttr(pNext, "Name"))) {
          std::string name = icXmlAttrValue(attr);
          if (!validName(name.c_str())) {
            parseStr += "Invalid Macro name '" + name + "'\n'";
            return false;
          }
          if (!pNext->children || !pNext->children->content || !pNext->children->content[0]) {
            parseStr += "Missing content for macro '" + name + "'\n'";
            return false;
          }
          MacroMap::iterator m = m_macroMap.find(name);
          if (m != m_macroMap.end()) {
            if (!strcmp(m->second.c_str(), (icChar*)pNext->children->content))
              continue;
            parseStr += "Calc Element macro '" + name + "' was previously defined differently\n";
            return false;
          }
          m_macroMap[name] = (icChar*)(pNext->children->content);

          if ((attr = icXmlFindAttr(pNext, "Local"))) {
            icUInt16Number offset, size;
            CIccTempDeclVar var = CIccTempDeclVar(name, 0, 0);
            std::string locals = icXmlAttrValue(attr);
            CIccFuncTokenizer parse(locals.c_str());
            offset = 0;

            while (parse.GetNext()) {
              icUInt16Number extra = 0;
              std::string member = parse.GetName();
              if (!validName(member.c_str())) {
                parseStr += "Invalid local name '" + member + "' for calc element macro '" + name + "'\n";
                return false;
              }
              size = 0; extra = 0;
              parse.GetIndex(size, extra, 1, 0);
              size++;
              if (size < 1)
                size = 1;

              var.m_members.push_back(CIccTempVar(member, offset, size));
              offset += size;
            }
            if (var.m_size < offset)
              var.m_size = offset;

            m_macroLocalMap[name] = var;
          }
        }
        else {
          parseStr += "Missing macro name\n";
          return false;
        }
      }
      else {
        parseStr += "Invalid macro declaration\n";
        return false;
      }
    }
  }
}

pChild = icXmlFindNode(pNode->children, "SubElements");
if (pChild) {
  for (pNext = pChild->children; pNext; pNext = pNext->next) {
    if (pNext->type == XML_ELEMENT_NODE) {
      std::string name;

      if ((attr = icXmlFindAttr(pNext, "Name"))) {
        name = icXmlAttrValue(attr);
        if (!validName(name.c_str())) {
          parseStr += "Invalid SubElement name '" + name + "'\n'";
          return false;
        }
      }
      if (name.empty()) {
        if (importPath != "*") {
          parseStr += "Imported Calc SubElments must be named.";
          return false;
        }
      }
      else {
        MpePtrMap::iterator se = m_mpeMap.find(name);
        if (se != m_mpeMap.end()) {
          parseStr += "Duplicate declaration of SubElement '" + name + "'\n";
          return false;
        }
      }

      CIccMultiProcessElement *pMpe = CIccTagXmlMultiProcessElement::CreateElement((const icChar*)pNext->name);

      if (!pMpe) {
        parseStr += std::string("Unknown Sub-Element Type (") + (const icChar*)pNext->name + ")\n";
        return false;
      }

      if (!strcmp(pMpe->GetClassName(), "CIccMpeXmlCalculator")) {
        CIccMpeXmlCalculator *pSubCalc = (CIccMpeXmlCalculator*)pMpe;
        pSubCalc->m_sImport = importPath;
      }

      xmlAttr *attr;
      IIccExtensionMpe *pExt = pMpe->GetExtension();

      if (pExt) {
        if (!strcmp(pExt->GetExtClassName(), "CIccMpeXml")) {
          CIccMpeXml* pXmlMpe = (CIccMpeXml*)pExt;

          if (pXmlMpe->ParseXml(pNext, parseStr)) {
            if ((attr = icXmlFindAttr(pNode, "Reserved"))) {
              sscanf(icXmlAttrValue(attr), "%u", &pMpe->m_nReserved);
            }

            if (name.empty()) {
              m_mpeList.push_back(CIccMpePtr(pMpe, m_nNextMpe));
              m_nNextMpe++;
            }
            else {
              m_mpeMap[name] = CIccMpePtr(pMpe);
            }
          }
          else {
            char str[100];
            sprintf(str, " starting on line %d", pNext->line);
            parseStr += std::string("Unable to parse element of type ") + pMpe->GetClassName() + str + "\n";
            delete pMpe;
            return false;
          }
        }
        else {
          parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
          delete pMpe;
          return false;
        }
      }
      else {
        parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
        delete pMpe;
        return false;
      }
    }
  }
}
return true;
2216}

2218bool CIccMpeXmlCalculator::ValidMacroCalls(const char *szMacroText, std::string macroStack, std::string &parseStr) const
2219{
const char *ptr;
for (ptr = strstr(szMacroText, "call{"); ptr; ptr = strstr(ptr, "call{")) {
  CIccFuncTokenizer parse(ptr, true);
  parse.GetNext();

  std::string name = parse.GetReference();
  MacroMap::const_iterator m = m_macroMap.find(name);
  if (m == m_macroMap.end()) {
    parseStr += "Call to undefined macro '" + name + "'\n";
    return false;
  }
  std::string sm = "*";
  sm += name + "*";
  if (strstr(macroStack.c_str(), sm.c_str())) {
    parseStr += "Macro recursion detected in call to '" + name + "'\n";
    return false;
  }
  if (!ValidMacroCalls(m->second.c_str(), macroStack + name + "*", parseStr)) {
    return false;
  }
  ptr++;
}
return true;
2243}

2245bool CIccMpeXmlCalculator::ValidateMacroCalls(std::string &parseStr) const
2246{
MacroMap::const_iterator m;

for (m = m_macroMap.begin(); m != m_macroMap.end(); m++) {
  if (!ValidMacroCalls(m->second.c_str(), "*", parseStr)) {
    return false;
  }
}
return true;
2255}

2257bool CIccMpeXmlCalculator::Flatten(std::string &flatStr, std::string macroName, const char *szFunc, std::string &parseStr, icUInt32Number nLocalsOffset)
2258{
CIccFuncTokenizer parse(szFunc, true);

while (parse.GetNext()) {
  std::string token = parse.GetLast();
  const char *tok = token.c_str();
  if (!strncmp(tok, "call{", 5) ||
      tok[0] == '#') {
    std::string nameiter;
    std::string name;

    if (tok[0] == '#')
      nameiter = token.substr(1);
    else
      nameiter = parse.GetReference();

    const char *ptr;
    for (ptr = nameiter.c_str(); *ptr && *ptr != '[' && *ptr != '('; ptr++) name += *ptr;
    int iter = 1;
2277//       if (*ptr) {
2278//         iter = atoi(ptr + 1);
2279//         if (iter < 1)
2280//           iter = 1;
2281//         else if (iter>1024)
2282//           iter = 1024;
2283//       }

    MacroMap::iterator m = m_macroMap.find(name.c_str());
    if (m != m_macroMap.end()) {
      icUInt16Number nLocalsSize = 0;
      TempDeclVarMap::iterator locals = m_macroLocalMap.find(macroName);
      if (locals != m_macroLocalMap.end()) {
        nLocalsSize = locals->second.m_size;
      }
      
      int i;
      for (i = 0; i < iter; i++) {
        Flatten(flatStr, name, m->second.c_str(), parseStr, nLocalsOffset+nLocalsSize);
      }
    }
    else {
      parseStr += "Call to undefined macro '" + name + "'\n";
      return false;
    }
  }
  else if (!strncmp(tok, "in{", 3) ||
           !strncmp(tok, "out{", 4)) {
    std::string op = parse.GetName();
    std::string ref = parse.GetReference();
    std::string refroot;
    for (const char *ptr = ref.c_str(); *ptr && *ptr != ',' && *ptr != '(' && *ptr != '['; ptr++) refroot += *ptr;

    ChanVarMap *pMap;
    int nChan;
    if (op == "in") {
      pMap = &m_inputMap;
      nChan = m_nInputChannels;
    }
    else {
      pMap = &m_outputMap;
      nChan = m_nOutputChannels;
    }

    ChanVarMap::iterator ci = pMap->find(refroot);
    if (ci == pMap->end()) {
      parseStr += "Invalid '" + op + "' operation channel reference '" + refroot + "'\n";
      return false;
    }
    if (refroot != ref) {
      std::string select = ref.substr(refroot.size());
      int offset = 0;
      int size = 1;

      if (select[0] == '[' || select[1] == '(') {
        const char *ptr;
        offset = atoi(select.c_str() + 1);
        for (ptr = select.c_str() + 1; *ptr && *ptr != ')' && *ptr != ']'; ptr++);
        select = ptr + 1;
      }

      if (select[0]==',')
        size = atoi(select.c_str() + 1);

      if (size < 0 || offset<0 || ci->second.first + offset + size > m_nInputChannels) {
        parseStr += "Invalid '" + op + "' operation channel offset or size '" + refroot + "'\n";
        return false;
      }
      char index[80];
      sprintf(index, "(%d,%d)", ci->second.first+offset, size);
      flatStr += op + index + " ";
    }
    else if (ci->second.second>1) {
      char index[80];
      sprintf(index, "(%d,%d)", ci->second.first, ci->second.second);
      flatStr += op + index + " ";
    }
    else {
      char index[80];
      sprintf(index, "(%d)", ci->second.first);
      flatStr += op + index + " ";
    }
  }
  else if (!strncmp(tok, "tget{", 5) ||
           !strncmp(tok, "tput{", 5) ||
           !strncmp(tok, "tsav{", 5)) {
    std::string op = parse.GetName();
    std::string ref = parse.GetReference();
    std::string refroot;
    for (const char *ptr = ref.c_str(); *ptr && *ptr != '[' && *ptr != '('; ptr++) refroot += *ptr;

    if (macroName.size() && refroot.size() && refroot[0] == '@') {
      std::string localName = refroot.substr(1);
      TempDeclVarMap::iterator locals = m_macroLocalMap.find(macroName);
      if (locals == m_macroLocalMap.end()) {
        parseStr += "Reference to undeclared local variable '" + localName + "' in macro '" + macroName + "'\n";
        return false;
      }

      unsigned long nLocalOffset = 0;
      unsigned long nLocalSize = 0;
      TempVarList::iterator m = locals->second.m_members.begin();
      for (; m != locals->second.m_members.end(); m++) {
        if (localName == m->m_name) {
          nLocalOffset = m->m_pos;
          nLocalSize = m->m_size;
          break;
        }
      }
      if (m == locals->second.m_members.end()) {
        parseStr += "Reference to undeclared local variable '" + localName + "' in macro '" + macroName + "'\n";
        return false;
      }
      int voffset, vsize;

      if (ref != refroot) {
        CIccFuncTokenizer p2(ref.c_str());
        p2.GetNext();
        icUInt16Number _voffset = 0, _vsize = 1;
        p2.GetIndex(_voffset, _vsize, 0, 1);
        voffset = _voffset;
        vsize = _vsize + 1;
      }
      else {
        voffset = 0;
        vsize = (int)nLocalSize;
      }

      if (voffset + vsize > (int)nLocalSize) {
        parseStr += "Out of bounds indexing of local '" + refroot + "' in macro '" + macroName + "'\n";
        return false;
      }

      if (nLocalsOffset + nLocalOffset + voffset + vsize > 65536) {
        parseStr += "Temporary variable addressing out of bounds\n";
        return false;
      }
      char idx[80];
      if (vsize == 1) {
        sprintf(idx, "[%lu]", nLocalsOffset + nLocalOffset + voffset);
      }
      else {
        sprintf(idx, "[%lu,%d]", nLocalsOffset + nLocalOffset + voffset, vsize);
      }
      flatStr += "l";
      flatStr += op.substr(1);
      flatStr += idx;
      flatStr += " ";
    }
    else {
      TempVarMap::iterator var = m_varMap.find(refroot);
      if (var == m_varMap.end()) {
        std::string root;
        for (const char *ptr = refroot.c_str(); *ptr && *ptr != '.'; ptr++) root += *ptr;

        TempVarMap::iterator rootVar = m_varMap.find(root);
        if (refroot != root && rootVar == m_varMap.end()) {
          parseStr += "Reference to undeclared variable '" + ref + "'\n";
          return false;
        }

        TempDeclVarMap::iterator decl = m_declVarMap.find(root);
        if (decl == m_declVarMap.end()) {
          parseStr += "Reference to undeclared variable '" + ref + "'\n";
          return false;
        }

        if (decl->second.m_pos < 0) {
          m_varMap[root] = CIccTempVar(root, m_nNextVar, decl->second.m_size);
          decl->second.m_pos = m_nNextVar;

          if (strchr(refroot.c_str(), '.')) {
            TempVarList::iterator m = decl->second.m_members.begin();
            for (; m != decl->second.m_members.end(); m++) {
              std::string vm = root + "." + m->m_name;
              m_varMap[vm] = CIccTempVar(vm, m_nNextVar + m->m_pos, m->m_size);
            }
          }

          if (m_nNextVar + decl->second.m_size > 65536) {
            parseStr += "Temporary variable addressing out of bounds\n";
            return false;
          }
          m_nNextVar += decl->second.m_size;
        }
        else {
          m_varMap[root] = CIccTempVar(root, decl->second.m_pos, decl->second.m_size);

          if (strchr(refroot.c_str(), '.')) {
            TempVarList::iterator m = decl->second.m_members.begin();
            for (; m != decl->second.m_members.end(); m++) {
              std::string vm = root + "." + m->m_name;
              m_varMap[vm] = CIccTempVar(vm, decl->second.m_pos + m->m_pos, m->m_size);
            }
          }
          if (decl->second.m_pos + decl->second.m_size > 65536) {
            parseStr += "Temporary variable addressing out of bounds\n";
            return false;
          }
        }

        var = m_varMap.find(refroot);
        if (var == m_varMap.end()) {
          parseStr += "Reference to undeclared variable '" + refroot + "'\n";
          return false;
        }
      }
      int voffset, vsize;

      if (ref != refroot) {
        CIccFuncTokenizer p2(ref.c_str());
        p2.GetNext();
        icUInt16Number _voffset = 0, _vsize = 1;
        p2.GetIndex(_voffset, _vsize, 0, 1);
        voffset = _voffset;
        vsize = _vsize + 1;
      }
      else {
        voffset = 0;
        vsize = var->second.m_size;
      }

      if (voffset + vsize > var->second.m_size) {
        parseStr += "Out of bounds indexing of '" + refroot + "'\n";
        return false;
      }
      if (var->second.m_pos + voffset + vsize > 65536) {
        parseStr += "Temporary variable addressing out of bounds\n";
        return false;
      }
      char idx[80];
      if (vsize == 1) {
        sprintf(idx, "[%d]", var->second.m_pos + voffset);
      }
      else {
        sprintf(idx, "[%d,%d]", var->second.m_pos + voffset, vsize);
      }
      flatStr += op + idx + " ";
    }
  }
  else if (!strncmp(tok, "elem{", 5) ||
           !strncmp(tok, "curv{", 5) ||
           !strncmp(tok, "clut{", 5) ||
           !strncmp(tok, "mtx{", 4) ||
           !strncmp(tok, "fJab{", 5) ||
           !strncmp(tok, "tJab{", 5) ||
           !strncmp(tok, "calc{", 5) ||
           !strncmp(tok, "tint{", 5)) {
    std::string op = parse.GetName();
    std::string ref = parse.GetReference();
    MpePtrMap::iterator e = m_mpeMap.find(ref);
    if (e == m_mpeMap.end()) {
      parseStr += "Unknown sub element reference to " + token + "\n";
      return false;
    }
    if (e->second.m_nIndex<0) {
      if (e->second.m_ptr) {
        m_mpeList.push_back(CIccMpePtr(e->second.m_ptr, m_nNextMpe));
        e->second.m_ptr = NULL__null;
        e->second.m_nIndex = m_nNextMpe;
        m_nNextMpe++;
      }
      else {
        parseStr += "Invalid sub-element reference:  " + token + "\n";
        return false;
      }
    }
    char idx[80];
    sprintf(idx, "(%d)", e->second.m_nIndex);
    flatStr += op + idx + " ";
  }
  else {
    flatStr += tok;
    flatStr += " ";
  }
}

return true;
2555}

2557bool CIccMpeXmlCalculator::UpdateLocals(std::string &func, std::string sFunc, std::string &parseStr, int nLocalsOffset)
2558{
func.clear();
CIccFuncTokenizer parse(sFunc.c_str(), true);

while (parse.GetNext()) {
  std::string token = parse.GetLast();
  const char *tok = token.c_str();

  if (!strncmp(tok, "lget[", 5) ||
      !strncmp(tok, "lput[", 5) ||
      !strncmp(tok, "lsav[", 5)) {
    std::string op = parse.GetName();
    int voffset, vsize;

    CIccFuncTokenizer p2(tok+4);
    icUInt16Number _voffset = 0, _vsize = 1;
    p2.GetIndex(_voffset, _vsize, 0, 1);
    voffset = _voffset + nLocalsOffset;
    vsize = _vsize + 1;

    if (voffset + vsize > 65535) {
      parseStr += "Local variable out of bounds - too many variables.\n";
      return false;
    }

    char idx[80];
    if (vsize == 1) {
      sprintf(idx, "[%d]", voffset);
    }
    else {
      sprintf(idx, "[%d,%d]", voffset, vsize);
    }
    func +="t";
    func += op.substr(1);
    func += idx;
    func += " ";
  }
  else {
    func += tok;
    func += " ";
  }
}

return true;
2602}
2603void CIccMpeXmlCalculator::clean()
2604{
m_sImport = "*";
m_declVarMap.clear();
m_varMap.clear();
m_macroMap.clear();

MpePtrList::iterator ml;
for (ml = m_mpeList.begin(); ml != m_mpeList.end(); ml++) {
  if (ml->m_ptr)
    delete ml->m_ptr;
}
m_mpeList.clear();

MpePtrMap::iterator mm;
for (mm = m_mpeMap.begin(); mm != m_mpeMap.end(); mm++) {
  if (mm->second.m_ptr)
    delete mm->second.m_ptr;
}
m_mpeMap.clear();
m_nNextVar = 0;
m_nNextMpe = 0;
2625}

2627bool CIccMpeXmlCalculator::ParseChanMap(ChanVarMap& chanMap, const char *szNames, int nChannels)
2628{
chanMap.clear();

if (!szNames)
  return false;

int i;
const char *ptr;
std::string name;
IndexSizePair isp;
int size = 1;

for (i = 0, ptr = szNames; *ptr && i < nChannels; ptr++) {
  bool bFirst = name.empty();
  if (*ptr == ' ') {
    if (!bFirst) {
      isp.first = i;
      isp.second = size;
      chanMap[name] = isp;
      name.clear();
      i += size;
      size = 1;
    }
  }
  else if (*ptr == '[' || *ptr == '(') {
    size = atoi(ptr + 1);
    if (size<0 || i + size>nChannels)
      return 0;

    for (; *ptr && *ptr != ']' && *ptr != ')'; ptr++);
    if (!*ptr)
      ptr--;
  }
  else if (validNameChar(*ptr, bFirst)) {
    name += *ptr;
  }
  else {
    return false;
  }
}

if (!name.empty() && i < nChannels) {
  isp.first = i;
  isp.second = size;
  chanMap[name] = isp;
}

return true;
2676}

2678bool CIccMpeXmlCalculator::ParseXml(xmlNode *pNode, std::string &parseStr)
2679{
xmlNode *pChild;

SetSize(atoi(icXmlAttrValue(pNode, "InputChannels")),
        atoi(icXmlAttrValue(pNode, "OutputChannels")));

clean();

if (!ParseChanMap(m_inputMap, icXmlAttrValue(pNode, "InputNames"), m_nInputChannels)) {
  parseStr += "Invalid name for InputChannels";
  return false;
}

if (!ParseChanMap(m_outputMap, icXmlAttrValue(pNode, "OutputNames"), m_nOutputChannels)) {
  parseStr += "Invalid name for InputChannels";
  return false;
}

if (!ParseImport(pNode, "*", parseStr))
  return false;

if (!ValidateMacroCalls(parseStr)) {
  return false;
}

pChild = icXmlFindNode(pNode->children, "MainFunction");
if (pChild && pNode->children && pChild->children->content) {
  char *content = (char*)pChild->children->content;
  std::string flatFunc;

  //Move new variables to after allocated variables
  TempDeclVarMap::iterator declVar;
  for (declVar = m_declVarMap.begin(); declVar != m_declVarMap.end(); declVar++) {
    if (declVar->second.m_pos >= 0) {
      int next = declVar->second.m_pos + declVar->second.m_size;
      if (next > m_nNextVar)
        m_nNextVar = next;
    }
  }

  if (!Flatten(flatFunc, "", content, parseStr, 0)) {
    return false;
  }

  if (m_macroLocalMap.size()) {
    std::string localFunc;
    if (!UpdateLocals(localFunc, flatFunc, parseStr, m_nNextVar)) {
      return false;
    }
    flatFunc = localFunc;
  }
  //copy MPE subelmeents used by Main Function to returned object
  int n;
  MpePtrList::iterator m;
  for (m = m_mpeList.begin(), n = 0; m != m_mpeList.end(); m++, n++) {
    this->SetSubElem(n, m->m_ptr);
    m->m_ptr = NULL__null;
  }

2738#if 0
  FILE *ff = fopen("flatfunc.txt", "wb");
  fwrite(flatFunc.c_str(), flatFunc.size(), 1, ff);
  fclose(ff);
2742#endif

  icFuncParseStatus stat = SetCalcFunc(flatFunc.c_str(), parseStr);
  if (stat!=icFuncParseNoError) {
    char buf[65];
    int len = icIntMin(64, (int)strlen(flatFunc.c_str()));
    strncpy(buf, flatFunc.c_str(), len);
    buf[len]=0;

    switch(stat) {
      case icFuncParseSyntaxError:
        parseStr += "Syntax Error occurred while parsing Main Calculator Function from \"";
        break;
      case icFuncParseInvalidOperation:
        parseStr += "Invalid Operation found while parsing Main Calculator Function from \"";
        break;
      case icFuncParseStackUnderflow:
        parseStr += "Stack underflow detected while parsing Main Calculator Function from \"";
        break;
      case icFuncParseInvalidChannel:
        parseStr += "Invalid Channel detected while parsing Main Calculator Function from \"";
        break;
      default:
        parseStr += "Unable to parse Main Calculator Function from \"";
    }
    parseStr += buf;
    parseStr += "\"\r\n";
    return false;
  }
}
clean();

return true;
2775}


2778bool CIccMpeXmlEmissionCLUT::ToXml(std::string &xml, std::string blanks/* = ""*/)
2779{
char buf[256];
std::string reserved;

xml += blanks + "<EmissionCLutElement";

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml +=  buf;
}

sprintf(buf, " InputChannels=\"%d\" OutputChannels=\"%d\" Flags=\"%d\" StorageType=\"%d\">\n", NumInputChannels(), NumOutputChannels(), m_flags, m_nStorageType);
xml += buf;

sprintf(buf, "  <Wavelengths start=\"%.8f\" end=\"%.8f\" steps=\"%d\"/>\n", icF16toF(m_Range.start), icF16toF(m_Range.end), m_Range.steps);
xml += blanks + buf;

int i;

if (m_pWhite) {
  xml += blanks + "  <WhiteData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pWhite[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </WhiteData>\n";
}

if (!icCLUTDataToXml(xml, m_pCLUT, icConvertFloat, blanks, true))
  return false;

xml += blanks + "</EmissionCLutElement>\n";

return true;
2817}

2819bool CIccMpeXmlEmissionCLUT::ParseXml(xmlNode *pNode, std::string &parseStr)
2820{
m_nStorageType = (icUInt16Number)atoi(icXmlAttrValue(pNode, "StorageType", "0"));

m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));
m_flags = atoi(icXmlAttrValue(pNode, "Flags", 0));

if (!m_nInputChannels || !m_nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In CLutElement\n";
  return false;
}

xmlNode *pData;

pData = icXmlFindNode(pNode->children, "Wavelengths");
if (pData) {
  icFloatNumber dStart = (icFloatNumber)atof(icXmlAttrValue(pData, "start"));
  icFloatNumber dEnd = (icFloatNumber)atof(icXmlAttrValue(pData, "end"));
  icUInt16Number nSteps = atoi(icXmlAttrValue(pData, "steps"));

  if (dStart >= dEnd ||!nSteps) {
    parseStr += "Invalid Spectral Range\n";
    return false;
  }
  m_Range.start = icFtoF16(dStart);
  m_Range.end = icFtoF16(dEnd);
  m_Range.steps = nSteps;
}
else {
  parseStr += "Missing Spectral Range\n";
  return false;
}

if (m_pWhite)
  free(m_pWhite);

m_pWhite = (icFloatNumber *)malloc(m_Range.steps*sizeof(icFloatNumber));
if (!m_pWhite) {
  parseStr += "White buffer memory error\n";
  return false;
}

pData = icXmlFindNode(pNode->children, "WhiteData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pWhite, m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing White Data";
}

if (m_pCLUT) {
  delete m_pCLUT;
  m_pCLUT = NULL__null;
}

if (m_pApplyCLUT) {
  delete m_pApplyCLUT;
  m_pApplyCLUT = NULL__null;
}

CIccCLUT *pCLut = icCLutFromXml(pNode, m_nInputChannels, m_Range.steps, icConvertFloat, parseStr);
if (pCLut) {
  m_pCLUT = pCLut;
  return true;
}

return false;
2889}

2891bool CIccMpeXmlReflectanceCLUT::ToXml(std::string &xml, std::string blanks/* = ""*/)
2892{
char buf[256];
std::string reserved;

xml += blanks + "<ReflectanceCLutElem";

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml +=  buf;
}

sprintf(buf, " InputChannels=\"%d\" OutputChannels=\"%d\" Flags=\"%d\">\n", NumInputChannels(), NumOutputChannels(), m_flags);
xml += buf;

sprintf(buf, "  <Wavelengths start=\"%.8f\" end=\"%.8f\" steps=\"%d\"/>\n", icF16toF(m_Range.start), icF16toF(m_Range.end), m_Range.steps);
xml += buf;

int i;

if (m_pWhite) {
  xml += blanks + "  <WhiteData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pWhite[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </WhiteData>\n";
}

if (!icCLUTDataToXml(xml, m_pCLUT, icConvertFloat, blanks, true))
  return false;

xml += blanks + "</ReflectanceCLutElem>\n";

return true;
2930}

2932bool CIccMpeXmlReflectanceCLUT::ParseXml(xmlNode *pNode, std::string &parseStr)
2933{
m_nStorageType = (icUInt16Number)atoi(icXmlAttrValue(pNode, "StorageType", "0"));

m_nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
m_nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));
m_flags = atoi(icXmlAttrValue(pNode, "Flags", 0));

if (!m_nInputChannels || !m_nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In CLutElement\n";
  return false;
}

xmlNode *pData;

pData = icXmlFindNode(pNode->children, "Wavelengths");
if (pData) {
  icFloatNumber dStart = (icFloatNumber)atof(icXmlAttrValue(pData, "start"));
  icFloatNumber dEnd = (icFloatNumber)atof(icXmlAttrValue(pData, "end"));
  icUInt16Number nSteps = atoi(icXmlAttrValue(pData, "steps"));

  if (dStart >= dEnd ||!nSteps) {
    parseStr += "Invalid Spectral Range\n";
    return false;
  }
  m_Range.start = icFtoF16(dStart);
  m_Range.end = icFtoF16(dEnd);
  m_Range.steps = nSteps;
}
else {
  parseStr += "Missing Spectral Range\n";
  return false;
}

if (m_pWhite)
  free(m_pWhite);

m_pWhite = (icFloatNumber *)malloc(m_Range.steps*sizeof(icFloatNumber));
if (!m_pWhite) {
  parseStr += "White buffer memory error\n";
  return false;
}

pData = icXmlFindNode(pNode->children, "WhiteData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pWhite, m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing WhiteData";
}

if (m_pCLUT) {
  delete m_pCLUT;
  m_pCLUT = NULL__null;
}

if (m_pApplyCLUT) {
  delete m_pApplyCLUT;
  m_pApplyCLUT = NULL__null;
}

CIccCLUT *pCLut = icCLutFromXml(pNode, m_nInputChannels, m_Range.steps, icConvertFloat, parseStr);
if (pCLut) {
  m_pCLUT = pCLut;
  return true;
}

return false;
3002}

3004bool CIccMpeXmlEmissionObserver::ParseXml(xmlNode *pNode, std::string &parseStr)
3005{
icUInt16Number nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
icUInt16Number nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));
m_flags = atoi(icXmlAttrValue(pNode, "Flags"));

if (!nInputChannels || !nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In EmissionObserverElement\n";
  return false;
}

xmlNode *pData;

pData = icXmlFindNode(pNode->children, "Wavelengths");
if (pData) {
  icFloatNumber dStart = (icFloatNumber)atof(icXmlAttrValue(pData, "start"));
  icFloatNumber dEnd = (icFloatNumber)atof(icXmlAttrValue(pData, "end"));
  icUInt16Number nSteps = atoi(icXmlAttrValue(pData, "steps"));

  if (dStart >= dEnd || nSteps != nInputChannels) {
    parseStr += "Invalid Spectral Range\n";
    return false;
  }
  m_Range.start = icFtoF16(dStart);
  m_Range.end = icFtoF16(dEnd);
  m_Range.steps = nSteps;
}

SetSize(nInputChannels, nOutputChannels, m_Range);
if (!m_pWhite) {
  parseStr += "Unable to SetSize\n";
  return false;
}

pData = icXmlFindNode(pNode->children, "WhiteData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pWhite, m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing White Data";
}

return true;
3049}

3051bool CIccMpeXmlEmissionObserver::ToXml(std::string &xml, std::string blanks/* = ""*/)
3052{
char buf[128];
sprintf(buf, "<EmissionObserverElement InputChannels=\"%d\" OutputChannels=\"%d\" Flags=\"%d\"", NumInputChannels(), NumOutputChannels(), m_flags);
xml += blanks + buf;

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml += buf;
}
xml += ">\n";

sprintf(buf, "  <Wavelengths start=\"%.8f\" end=\"%.8f\" steps=\"%d\"/>\n", icF16toF(m_Range.start), icF16toF(m_Range.end), m_Range.steps);
xml += buf;

int i;

if (m_pWhite) {
  xml += blanks + "  <WhiteData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pWhite[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </WhiteData>\n";
}

xml += blanks + "</EmissionObserverElement>\n";

return true;
3084}

3086bool CIccMpeXmlReflectanceObserver::ParseXml(xmlNode *pNode, std::string &parseStr)
3087{
icUInt16Number nInputChannels = atoi(icXmlAttrValue(pNode, "InputChannels"));
icUInt16Number nOutputChannels = atoi(icXmlAttrValue(pNode, "OutputChannels"));
m_flags = atoi(icXmlAttrValue(pNode, "Flags"));

if (!nInputChannels || !nOutputChannels) {
  parseStr += "Invalid InputChannels or OutputChannels In ReflectanceObserverElement\n";
  return false;
}

xmlNode *pData;

pData = icXmlFindNode(pNode->children, "Wavelengths");
if (pData) {
  icFloatNumber dStart = (icFloatNumber)atof(icXmlAttrValue(pData, "start"));
  icFloatNumber dEnd = (icFloatNumber)atof(icXmlAttrValue(pData, "end"));
  icUInt16Number nSteps = atoi(icXmlAttrValue(pData, "steps"));

  if (dStart >= dEnd || nSteps != nInputChannels) {
    parseStr += "Invalid Spectral Range\n";
    return false;
  }
  m_Range.start = icFtoF16(dStart);
  m_Range.end = icFtoF16(dEnd);
  m_Range.steps = nSteps;
}

SetSize(nInputChannels, nOutputChannels, m_Range);
if (!m_pWhite) {
  parseStr += "Unable to SetSize\n";
  return false;
}

pData = icXmlFindNode(pNode->children, "WhiteData");
if (pData) {

  if (!CIccFloatArray::ParseArray(m_pWhite, m_Range.steps, pData->children))
    return false;
}
else {
  parseStr += "Missing White Data";
}

return true;
3131}

3133bool CIccMpeXmlReflectanceObserver::ToXml(std::string &xml, std::string blanks/* = ""*/)
3134{
char buf[128];
sprintf(buf, "<ReflectanceObserverElement InputChannels=\"%d\" OutputChannels=\"%d\" Flags=\"%d\"", NumInputChannels(), NumOutputChannels(), m_flags);
xml += blanks + buf;

if (m_nReserved) {
  sprintf(buf, " Reserved=\"%u\"", m_nReserved);
  xml += buf;
}
xml += ">\n";

sprintf(buf, "  <Wavelengths start=\"%.8f\" end=\"%.8f\" steps=\"%d\"/>\n", icF16toF(m_Range.start), icF16toF(m_Range.end), m_Range.steps);
xml += buf;

int i;

if (m_pWhite) {
  xml += blanks + "  <WhiteData>\n";

  xml += blanks + "   ";
  for (i=0; i<(int)m_Range.steps; i++) {
    sprintf(buf, " %.8f", m_pWhite[i]);
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "  </WhiteData>\n";
}

xml += blanks + "</ReflectanceObserverElement>\n";

return true;
3166}

3168#ifdef USEREFICCMAXNAMESPACE
3169}
3170#endif