IccTagXml.cpp File Reference

#include "IccTagXml.h"
#include "IccMpeXml.h"
#include "IccUtil.h"
#include "IccUtilXml.h"
#include "IccIoXml.h"
#include "IccSparseMatrix.h"
#include "IccProfileXml.h"
#include "IccStructFactory.h"
#include "IccArrayFactory.h"
#include <cstring>
#include <set>
#include <map>
#include <sstream>
#include <iomanip>

Include dependency graph for IccTagXml.cpp:

Go to the source code of this file.

Typedefs
typedef std::map< icUInt32Number, icTagSignature >	IccOffsetTagSigMap

Functions
CIccCLUT *	icCLutFromXml (xmlNode *pNode, int nIn, int nOut, icConvertType nType, std::string &parseStr)
bool	icCurvesFromXml (LPIccCurve *pCurve, icUInt32Number nChannels, xmlNode *pNode, icConvertType nType, std::string &parseStr)
bool	icCurvesToXml (std::string &xml, const char *szName, CIccCurve **pCurves, int numCurve, icConvertType nType, std::string blanks)
bool	icMatrixFromXml (CIccMatrix *pMatrix, xmlNode *pNode)
bool	icMatrixToXml (std::string &xml, CIccMatrix *pMatrix, std::string blanks)
bool	icMBBFromXml (CIccMBB *pMBB, xmlNode *pNode, icConvertType nType, std::string &parseStr)
bool	icMBBToXml (std::string &xml, CIccMBB *pMBB, icConvertType nType, std::string blanks="", bool bSaveGridPoints=false)
bool	icProfDescToXml (std::string &xml, CIccProfileDescStruct &p, std::string blanks="")
static bool	icXmlDumpTextData (std::string &xml, std::string blanks, const char *szText, bool bConvert=true)
bool	icXmlParseProfDesc (xmlNode *pNode, CIccProfileDescStruct &p, std::string &parseStr)
static std::string	icXmlParseTextString (xmlNode *pNode, std::string &parseStr, bool bConvert=true)

Detailed Description

File: IccTagXML.cpp

Contains: Implementation ICC tag XML format conversions

Version: V1

Copyright: © see ICC Software License

Definition in file IccTagXml.cpp.

Typedef Documentation

IccOffsetTagSigMap

typedef std::map<icUInt32Number, icTagSignature> IccOffsetTagSigMap

Function Documentation

icCLutFromXml()

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

{
  CIccCLUT *pCLUT = NULL;
 
  int nPrecision = 2;
  if (nType == icConvert8Bit)
    nPrecision = 1;  
 
  icUInt8Number nInput = (icUInt8Number)nIn;
  icUInt16Number nOutput = (icUInt16Number)nOut;
 
  pCLUT = new CIccCLUT(nInput, nOutput, nPrecision);
 
  if (!pCLUT){
    parseStr += "Error in creating CLUT Table. Check values of Precision, InputChannel, or OutputChannels.\n";
    return NULL;
  }
 
  xmlNode *grid = icXmlFindNode(pNode->children, "GridPoints");
  if (grid) {
    CIccUInt8Array points;
 
    if (points.ParseArray(grid->children)) {
      if (!pCLUT->Init(points.GetBuf())) {
        parseStr += "Error in setting the size of GridPoints. Check values of GridPoints, InputChannel, or OutputChannels.\n";
        delete pCLUT;
        return NULL;
      }
    }
    else {
      parseStr += "Error parsing GridPoints.\n";
      delete pCLUT;
      return NULL;
    }
  }
  else {
    icUInt8Number nGridGranularity;
 
    xmlAttr *gridGranularity = icXmlFindAttr(pNode, "GridGranularity");
 
    if (gridGranularity) {
      nGridGranularity = (icUInt8Number)atoi(icXmlAttrValue(gridGranularity));
    }
    else {
      delete pCLUT;
      return NULL;
    }
    if (!pCLUT->Init(nGridGranularity)) {
      parseStr += "Error in setting the size of GridGranularity. Check values of GridGranularity, InputChannel, or OutputChannels.\n";
      delete pCLUT;
      return NULL;
    }
  }
 
  xmlNode *table = icXmlFindNode(pNode->children, "TableData");
 
  if (table) {
    if (nType == icConvertVariable) {
      const char *precision = icXmlAttrValue(table, "Precision");
      if (precision && atoi(precision) == 1) {
        nType = icConvert8Bit;
        pCLUT->SetPrecision(1);
      }
      else {
        nType = icConvert16Bit;
        pCLUT->SetPrecision(2);
      }
    }
 
    const char *filename = icXmlAttrValue(table, "Filename");
    if (!filename || !filename[0]) {
      filename = icXmlAttrValue(table, "File");
    }
 
    if (filename[0]) {
      CIccIO *file = IccOpenFileIO(filename, "rb");
 
      if (!file) {
        // added error message
        parseStr += "Error! - File '";
        parseStr += filename;
        parseStr +="' not found.\n";
        delete pCLUT;
        return NULL;
      }
 
      const char *format = icXmlAttrValue(table, "Format");
 
      if (!strcmp(format, "text")) {
        icUInt32Number num = file->GetLength();
        char *buf = (char *)malloc(num);
 
        if (!buf) {  
          perror("Memory Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid text file.\n";
          delete file;
          delete pCLUT;
          return NULL;
        }
 
        //Allow for different encoding in text file than implied by the table type
        const char *encoding = icXmlAttrValue(table, "FileEncoding");
 
        if (!strcmp(encoding, "int8"))
          nType = icConvert8Bit;
        else if (!strcmp(encoding, "int16"))
          nType = icConvert16Bit;
        else if (!strcmp(encoding, "float"))
          nType = icConvertFloat;
        else if (encoding[0]) {
          parseStr+= "Unknown encoding \"";
          parseStr+= encoding;
          parseStr+= "\" - using default encoding\n";
        }
 
        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;
          delete pCLUT;
          return NULL;
        }
 
        if (nType == icConvert8Bit) {
          CIccUInt8Array data;
 
          if (!data.ParseTextArrayNum(buf, num, parseStr)) {
            parseStr += "File '";
            parseStr += filename;
            parseStr += "' is not a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
 
          if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {     
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
          icUInt8Number *src = data.GetBuf();
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst++ = (icFloatNumber)(*src++) / 255.0f;
          }
        }
        else if (nType == icConvert16Bit) {
          CIccUInt16Array data;
 
          if (!data.ParseTextArrayNum(buf, num, parseStr)) {
            parseStr += "File '";
            parseStr += filename;
            parseStr += "' is not a valid text file.\n";      
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
 
          if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
          icUInt16Number *src = data.GetBuf();
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst++ = (icFloatNumber)(*src++) / 65535.0f;
          }
        }
        else if (nType == icConvertFloat) {
          CIccFloatArray data;
 
          if (!data.ParseTextArrayNum(buf, num, parseStr)) {
            parseStr += "File '";
            parseStr += filename;
            parseStr += "' is not a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
 
          if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *src = data.GetBuf();
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst++ = *src++;
          }
        }
        else {
          parseStr += "Error! Unknown text data type.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL;
        }
        free(buf);
      }
      else if (!strcmp(format, "binary")) {
        const char *order = icXmlAttrValue(table, "Endian");
        bool little_endian = !strcmp(order, "little");
 
        if (nType==icConvertVariable) {
          //Allow encoding to be defined
          const char *encoding = icXmlAttrValue(table, "FileEncoding");
 
          if (!strcmp(encoding, "int8"))
            nType = icConvert8Bit;
          else if (!strcmp(encoding, "int16"))
            nType = icConvert16Bit;
          else if (!strcmp(encoding, "float"))
            nType = icConvertFloat;
          else if (encoding[0]) {
            parseStr+= "Unknown encoding \"";
            parseStr+= encoding;
            parseStr+= "\" - using int16.\n";
            nType = icConvert16Bit;
          }
          else {
            parseStr+= "CLUT TableData Encoding type not specified.\n";
          }
        }
 
        if (nType == icConvert8Bit){
          icUInt32Number num = file->GetLength();
          icUInt8Number value;      
          // if number of entries in file is not equal to size of CLUT table, flag as error
          if (num!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *dst = pCLUT->GetData(0);
          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;
              delete pCLUT;
              return NULL;
            }      
            *dst++ = (icFloatNumber)value / 255.0f;
          }
        }
        else if (nType == icConvert16Bit){
          icUInt32Number num = file->GetLength() / sizeof(icUInt16Number);
          icUInt16Number value;
          icUInt8Number *ptr = (icUInt8Number*)&value;
 
          if (num<pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<num; i++) {
            if (!file->Read16(&value)) {  //this assumes data is big endian
              perror("Read-File Error");
              parseStr += "'";
              parseStr += filename;
              parseStr += "' may not be a valid binary file.\n";
              delete file;
              delete pCLUT;
              return NULL;
            }
#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
            if (little_endian) {
#else
            if (!little_endian) {
#endif
              icUInt8Number t = ptr[0];
              ptr[0] = ptr[1];
              ptr[1] = t;
            }
            *dst++ = (icFloatNumber)value / 65535.0f;
          }
        }
        else if (nType == icConvertFloat){
          icUInt32Number num = file->GetLength()/sizeof(icFloat32Number);
          icFloat32Number value;
          icUInt8Number *ptr = (icUInt8Number*)&value;
 
          if (num<pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<num; i++) {
            if (!file->ReadFloat32Float(&value)) {  //this assumes data is big endian
              perror("Read-File Error");
              parseStr += "'";
              parseStr += filename;
              parseStr += "' may not be a valid binary file.\n";
              delete file;
              delete pCLUT;
              return NULL;
            }
#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
            if (little_endian) {
#else
            if (!little_endian) {
#endif
              icUInt8Number tmp;
              tmp = ptr[0]; ptr[0] = ptr[3]; ptr[3] = tmp;
              tmp = ptr[1]; ptr[1] = ptr[2]; ptr[2] = tmp;
            }
            *dst++ = value;
          }
        }
        else {
          parseStr += "Error! Unknown binary data type.\n";
          delete file;
          delete pCLUT;
          return NULL;
        }
 
      }
      else {
        parseStr += "Error! Unknown Format type.\n";
        delete pCLUT;
        return NULL;
      }
 
      delete file;
    }
    else { // no file
      if (nType == icConvert8Bit) {
        CIccUInt8Array data;
 
        if (!data.ParseArray(table->children)) {
          parseStr += "Error! - unable to parse data in CLUT.\n";
          delete pCLUT;
          return NULL;
        }
 
        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
          delete pCLUT;
          return NULL;
        }
        icUInt8Number *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);
 
        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = (icFloatNumber)(*src++) / 255.0f;
        }
      }
      else if (nType == icConvert16Bit || nType==icConvertVariable) {
        CIccUInt16Array data;
 
        if (!data.ParseArray(table->children)) {
          parseStr += "Error! - unable to parse data in CLUT.\n";
          delete pCLUT;
          return NULL;
        }
 
        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
          delete pCLUT;
          return NULL;
        }
        icUInt16Number *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);
 
        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = (icFloatNumber)(*src++) / 65535.0f;
        }    
      }      
      else if (nType == icConvertFloat){
        CIccFloatArray data;
 
        if (!data.ParseArray(table->children)) {
          parseStr += "Error! - unable to parse data in CLUT.\n";
          delete pCLUT;
          return NULL;
        }
 
        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
          delete pCLUT;
          return NULL;
        }
        icFloatNumber *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);
 
        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = *src++;
        }
      }
      else {
        parseStr += "Error! Unknown table data type.";
        delete pCLUT;
        return NULL;
      }
    }
  }
  else {
    parseStr += "Error! Cannot find table data.";
    delete pCLUT;
    return NULL;
  }
 
  return pCLUT;
}

References CIccCLUT::CIccCLUT(), CIccXmlArrayType< T, Tsig >::GetBuf(), CIccCLUT::GetData(), CIccIO::GetLength(), CIccCLUT::GetOutputChannels(), CIccXmlArrayType< T, Tsig >::GetSize(), icConvert16Bit, icConvert8Bit, icConvertFloat, icConvertVariable, IccOpenFileIO(), icXmlAttrValue(), icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), CIccCLUT::Init(), CIccCLUT::Init(), CIccCLUT::NumPoints(), CIccXmlArrayType< T, Tsig >::ParseArray(), CIccXmlArrayType< T, Tsig >::ParseTextArrayNum(), CIccIO::Read16(), CIccIO::Read8(), CIccIO::ReadFloat32Float(), and CIccCLUT::SetPrecision().

Referenced by icMBBFromXml(), CIccMpeXmlCLUT::ParseXml(), CIccMpeXmlExtCLUT::ParseXml(), CIccMpeXmlEmissionCLUT::ParseXml(), and CIccMpeXmlReflectanceCLUT::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icCurvesFromXml()

bool icCurvesFromXml	(	LPIccCurve *	pCurve,
		icUInt32Number	nChannels,
		xmlNode *	pNode,
		icConvertType	nType,
		std::string &	parseStr
	)

{
  icUInt32Number i;
  xmlNode *pCurveNode;
 
  for (i=0, pCurveNode = pNode; i<nChannels && pCurveNode; pCurveNode=pCurveNode->next) {
    if (pCurveNode->type==XML_ELEMENT_NODE) {
      CIccCurve *pCurveTag = NULL;
      if (!icXmlStrCmp(pCurveNode->name, "Curve")) {
        pCurveTag = new CIccTagXmlCurve;
      }
      else if (!icXmlStrCmp(pCurveNode->name, "ParametricCurve")) {
        pCurveTag = new CIccTagXmlParametricCurve();
      }
 
      if (pCurveTag) {
        IIccExtensionTag *pExt = pCurveTag->GetExtension();
 
        if (pExt) {
          if (!strcmp(pExt->GetExtDerivedClassName(), "CIccCurveXml")) {
            CIccCurveXml *pCurveXml = (CIccCurveXml *)pExt;
 
            if (pCurveXml->ParseXml(pCurveNode, nType, parseStr)) {
              pCurve[i] = pCurveTag;
              i++;
            }
            // added else statement
            else  {
              char num[40];
              parseStr += "Unable to parse curve at Line";
              sprintf(num, "%d\n", pCurveNode->line);
              parseStr += num;
 
              delete pCurveTag;
              return false;
            }
          }
          else if (!strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
            CIccTagXml *pXmlTag = (CIccTagXml *)pExt;
 
            if (pXmlTag->ParseXml(pCurveNode, parseStr)) {
              pCurve[i] = pCurveTag;
              i++;
            }
            // added else statement
            else {
              char num[40];
              parseStr += "Unable to parse curve tag at Line";
              sprintf(num, "%d\n", pCurveNode->line);
              parseStr += num;
 
              delete pCurveTag;
              return false;
            }
          }
          else {
            delete pCurveTag;
            return false;
          }
        }
      }
    }
  }
  if (!i != nChannels) {
    parseStr += "Channel number mismatch!\n";
  }
  return i==nChannels;
}

References IIccExtensionTag::GetExtClassName(), IIccExtensionTag::GetExtDerivedClassName(), CIccTag::GetExtension(), CIccCurveXml::ParseXml(), and CIccTagXml::ParseXml().

Referenced by icMBBFromXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icCurvesToXml()

bool icCurvesToXml	(	std::string &	xml,
		const char *	szName,
		CIccCurve **	pCurves,
		int	numCurve,
		icConvertType	nType,
		std::string	blanks
	)

{
  if (pCurves) {
    int i;
 
    xml += blanks + "<" + szName + ">\n";
    for (i=0; i<numCurve; i++) {
      IIccExtensionTag *pTag = pCurves[i]->GetExtension();
      if (!pTag || strcmp(pTag->GetExtDerivedClassName(), "CIccCurveXml"))
        return false;
 
      if (!((CIccCurveXml *)pTag)->ToXml(xml, nType, blanks + "  "))
        return false;
    }
    xml += blanks + "</" + szName + ">\n";
  }
  return true;
}

References IIccExtensionTag::GetExtDerivedClassName(), CIccTag::GetExtension(), and CIccCurveXml::ToXml().

Referenced by icMBBToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icMatrixFromXml()

bool icMatrixFromXml	(	CIccMatrix *	pMatrix,
		xmlNode *	pNode
	)

{
  memset(pMatrix->m_e, 0, sizeof(pMatrix->m_e));
  pMatrix->m_bUseConstants = false;
 
  char attrName[15];
  int i;
 
  for (i=0; i<9; i++) {
    sprintf(attrName, "e%d", i+1);
    xmlAttr *attr = icXmlFindAttr(pNode, attrName);
    if (attr) {
      pMatrix->m_e[i] = (icFloatNumber)atof(icXmlAttrValue(attr));
    }
  }
  for (i=9; i<12; i++) {
    sprintf(attrName, "e%d", i+1);
    xmlAttr *attr = icXmlFindAttr(pNode, attrName);
    if (attr) {
      pMatrix->m_e[i] = (icFloatNumber)atof(icXmlAttrValue(attr));
      pMatrix->m_bUseConstants = true;
    }
  }
  return true;
}

References icXmlAttrValue(), icXmlFindAttr(), CIccMatrix::m_bUseConstants, and CIccMatrix::m_e.

Referenced by icMBBFromXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icMatrixToXml()

bool icMatrixToXml	(	std::string &	xml,
		CIccMatrix *	pMatrix,
		std::string	blanks
	)

{
  char buf[128];
  xml += blanks + "<Matrix\n";
 
  sprintf(buf, "  e1=\"" icXmlFloatFmt "\" e2=\"" icXmlFloatFmt "\" e3=\"" icXmlFloatFmt "\"\n", pMatrix->m_e[0], pMatrix->m_e[1], pMatrix->m_e[2]);
  xml += blanks + buf;
 
  sprintf(buf, "  e4=\"" icXmlFloatFmt "\" e5=\"" icXmlFloatFmt "\" e6=\"" icXmlFloatFmt "\"\n", pMatrix->m_e[3], pMatrix->m_e[4], pMatrix->m_e[5]);
  xml += blanks + buf;
 
  sprintf(buf, "  e7=\"" icXmlFloatFmt "\" e8=\"" icXmlFloatFmt "\" e9=\"" icXmlFloatFmt "\"", pMatrix->m_e[6], pMatrix->m_e[7], pMatrix->m_e[8]);
  xml += blanks + buf;
 
  if (pMatrix->m_bUseConstants) {
    xml += "\n";
    sprintf(buf, "  e10=\"" icXmlFloatFmt "\" e11=\"" icXmlFloatFmt "\" e12=\"" icXmlFloatFmt "\"", pMatrix->m_e[9], pMatrix->m_e[10], pMatrix->m_e[11]);
    xml += blanks + buf;
  }
  xml += "/>\n";
  return true;
}

References CIccMatrix::m_bUseConstants, and CIccMatrix::m_e.

Referenced by icMBBToXml().

Here is the caller graph for this function:

icMBBFromXml()

bool icMBBFromXml	(	CIccMBB *	pMBB,
		xmlNode *	pNode,
		icConvertType	nType,
		std::string &	parseStr
	)

{
  xmlNode *pChannels = icXmlFindNode(pNode, "Channels");
 
  if (!pChannels)
    return false;
 
  xmlAttr *in = icXmlFindAttr(pChannels, "InputChannels");
  xmlAttr *out = icXmlFindAttr(pChannels, "OutputChannels");
 
  if (!in || !out)
    return false;
 
  int nIn = atoi(icXmlAttrValue(in));
  int nOut = atoi(icXmlAttrValue(out));
 
  pMBB->Init(nIn, nOut);
 
  for (; pNode; pNode = pNode->next) {
    if (pNode->type == XML_ELEMENT_NODE) {
      if (!icXmlStrCmp(pNode->name, "ACurves") && !pMBB->GetCurvesA()) {
        LPIccCurve *pCurves = pMBB->NewCurvesA();
        if (!icCurvesFromXml(pCurves, !pMBB->IsInputB() ? nIn : nOut, pNode->children, nType, parseStr)) {
          parseStr += "Error! - Failed to parse ACurves.\n";
          return false;
        }
      }
      else if (!icXmlStrCmp(pNode->name, "BCurves") && !pMBB->GetCurvesB()) {
        LPIccCurve *pCurves = pMBB->NewCurvesB();
        if (!icCurvesFromXml(pCurves, pMBB->IsInputB() ? nIn : nOut, pNode->children, nType, parseStr)) {
          parseStr += "Error! - Failed to parse BCurves.\n";
          return false;
        }
      }
      else if (!icXmlStrCmp(pNode->name, "MCurves") && !pMBB->GetCurvesM()) {
        LPIccCurve *pCurves = pMBB->NewCurvesM();
        if (!icCurvesFromXml(pCurves, !pMBB->IsInputMatrix() ? nIn : nOut, pNode->children, nType, parseStr)) {
          parseStr += "Error! - Failed to parse MCurves.\n";
          return false;
        }
      }
      else if (!icXmlStrCmp(pNode->name, "Matrix") && !pMBB->GetMatrix()) {
        CIccMatrix *pMatrix = pMBB->NewMatrix();
        if (!icMatrixFromXml(pMatrix, pNode)) {
          parseStr += "Error! - Failed to parse Matrix.\n";
          return false;
        }
      }
      else if (!icXmlStrCmp(pNode->name, "CLUT") && !pMBB->GetCLUT()) {
        CIccCLUT *pCLUT = icCLutFromXml(pNode, nIn, nOut, nType, parseStr);
        if (pCLUT) {
          if (!pMBB->SetCLUT(pCLUT)) {
            parseStr += "Error! - Failed to set CLUT to LUT.\n";
            return false;
          }
        }
        else {
          parseStr += "Error! - Failed to parse CLUT.\n";
          return false;
        }
      }
    }
  }
 
  return true;
}

References CIccMBB::GetCLUT(), CIccMBB::GetCurvesA(), CIccMBB::GetCurvesB(), CIccMBB::GetCurvesM(), CIccMBB::GetMatrix(), icCLutFromXml(), icCurvesFromXml(), icMatrixFromXml(), icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), CIccMBB::Init(), CIccMBB::IsInputB(), CIccMBB::IsInputMatrix(), CIccMBB::NewCurvesA(), CIccMBB::NewCurvesB(), CIccMBB::NewCurvesM(), CIccMBB::NewMatrix(), and CIccMBB::SetCLUT().

Referenced by CIccTagXmlLutAtoB::ParseXml(), CIccTagXmlLutBtoA::ParseXml(), CIccTagXmlLut8::ParseXml(), and CIccTagXmlLut16::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icMBBToXml()

bool icMBBToXml	(	std::string &	xml,
		CIccMBB *	pMBB,
		icConvertType	nType,
		std::string	blanks = "",
		bool	bSaveGridPoints = false
	)

{
  //blanks += "  ";
  char buf[256];
 
  sprintf(buf, "<Channels InputChannels=\"%d\" OutputChannels=\"%d\"/>\n", pMBB->InputChannels(), pMBB->OutputChannels());
  xml += blanks + buf;
 
  if (pMBB->IsInputMatrix()) {
    if (pMBB->SwapMBCurves()) {
      if (pMBB->GetMatrix()) {
        // added if-statement 
        if (!icMatrixToXml(xml, pMBB->GetMatrix(), blanks)) {
          return false;
        }
      }
 
      if (pMBB->GetCurvesB()) {
        // added if-statement 
        if (!icCurvesToXml(xml, "BCurves", pMBB->GetCurvesM(), pMBB->InputChannels(), nType, blanks)) {
          return false;
        }
      }
    }
    else {
      if (pMBB->GetCurvesB()) {
        // added if-statement 
        if (!icCurvesToXml(xml, "BCurves", pMBB->GetCurvesB(), pMBB->InputChannels(), nType, blanks)) {
          return false;
        }
      }
 
      if (pMBB->GetMatrix()) {
        // added if-statement 
        if (!icMatrixToXml(xml, pMBB->GetMatrix(), blanks)) {
          return false;
        }
      }
 
      if (pMBB->GetCurvesM()) {
        // added if-statement 
        if (!icCurvesToXml(xml, "MCurves", pMBB->GetCurvesM(), 3, nType, blanks)){
          return false;
        }
      }
    }
 
    if (pMBB->GetCLUT()) {
      // added if-statement 
      if (!icCLUTToXml(xml, pMBB->GetCLUT(), nType, blanks, bSaveGridPoints)){
        return false;
      }
    }
 
    if (pMBB->GetCurvesA()) {
      // added if-statement 
      if (!icCurvesToXml(xml, "ACurves", pMBB->GetCurvesA(), pMBB->OutputChannels(), nType, blanks)){
        return false;
      }
    }
  }
  else {
    if (pMBB->GetCurvesA()) {
      // added if-statement 
      if (!icCurvesToXml(xml, "ACurves", pMBB->GetCurvesA(), pMBB->InputChannels(), nType, blanks)){
        return false;
      }
    }
 
    if (pMBB->GetCLUT()) {
      // added if-statement 
      if (!icCLUTToXml(xml, pMBB->GetCLUT(), nType, blanks, bSaveGridPoints)){
        return false;
      }
    }
 
    if (pMBB->GetCurvesM()) {
      // added if-statement 
      if (!icCurvesToXml(xml, "MCurves", pMBB->GetCurvesM(), 3, nType, blanks)){
        return false;
      }
    }
 
    if (pMBB->GetMatrix()) {
      // added if-statement 
      if (!icMatrixToXml(xml, pMBB->GetMatrix(), blanks)) {
        return false;
      }
    }
 
    if (pMBB->GetCurvesB()) {
      // added if-statement 
      if (!icCurvesToXml(xml, "BCurves", pMBB->GetCurvesB(), pMBB->OutputChannels(), nType, blanks)){
        return false;
      }
    }
  }
  return true;
}

References CIccMBB::GetCLUT(), CIccMBB::GetCurvesA(), CIccMBB::GetCurvesB(), CIccMBB::GetCurvesM(), CIccMBB::GetMatrix(), icCLUTToXml(), icCurvesToXml(), icMatrixToXml(), CIccMBB::InputChannels(), CIccMBB::IsInputMatrix(), CIccMBB::OutputChannels(), and CIccMBB::SwapMBCurves().

Referenced by CIccTagXmlLutAtoB::ToXml(), CIccTagXmlLutBtoA::ToXml(), CIccTagXmlLut8::ToXml(), and CIccTagXmlLut16::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icProfDescToXml()

bool icProfDescToXml	(	std::string &	xml,
		CIccProfileDescStruct &	p,
		std::string	blanks = ""
	)

{
  char fix[256];
  char buf[256];
  char data[256];
 
  sprintf(buf, "<ProfileDesc>\n");
  xml += blanks + buf;
 
  sprintf(buf,   "<DeviceManufacturerSignature>%s</DeviceManufacturerSignature>\n", icFixXml(fix, icGetSigStr(data, p.m_deviceMfg)));
  xml += blanks + blanks + buf;
 
  sprintf(buf,  "<DeviceModelSignature>%s</DeviceModelSignature>\n", icFixXml(fix, icGetSigStr(data, p.m_deviceModel)));
  xml += blanks + blanks + buf;
 
  std::string szAttributes = icGetDeviceAttrName(p.m_attributes);
  //sprintf(buf, "<DeviceAttributes>\"%016lX\" technology=\"%s\">\n", p.m_attributes, icFixXml(fix, icGetSigStr(data, p.m_technology)));
  //xml += buf;
  xml += blanks + blanks + icGetDeviceAttrName(p.m_attributes);
 
  sprintf(buf, "<Technology>%s</Technology>\n", icFixXml(fix, icGetSigStr(data, p.m_technology)));
  xml += blanks + blanks + buf;
 
  CIccTag *pTag = p.m_deviceMfgDesc.GetTag();
  CIccTagXml *pExt;
 
  if (pTag) {
 
    pExt = (CIccTagXml*)(pTag->GetExtension());
 
    if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
      return false;
 
    xml += blanks + blanks + "<DeviceManufacturer>\n";
 
    const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());
    sprintf(buf, "<%s>\n", tagSig);
    xml += blanks + blanks + blanks + buf;
 
    if (!pExt->ToXml(xml, blanks + "        "))
      return false;
 
    sprintf(buf, "</%s>\n", tagSig);
    xml += blanks + blanks + blanks + buf;
 
    xml += blanks + blanks +"</DeviceManufacturer>\n";
  }
 
  pTag = p.m_deviceModelDesc.GetTag();
 
  if (pTag) {
    pExt = (CIccTagXml*)(pTag->GetExtension());
 
    if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
      return false;
 
    xml += blanks + blanks + "<DeviceModel>\n";
 
    const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());
    sprintf(buf, "<%s>\n", tagSig);
    xml += blanks + blanks + blanks + buf;
 
    if (!pExt->ToXml(xml, blanks + "        "))
      return false;
 
    sprintf(buf, "</%s>\n", tagSig);
    xml += blanks + blanks + blanks + buf;
 
    xml += blanks + "  </DeviceModel>\n";
  }
 
  xml += blanks + "</ProfileDesc>\n";
 
  return true;
}

References CIccTagXml::GetExtClassName(), CIccTag::GetExtension(), CIccProfileDescText::GetTag(), CIccTag::GetType(), icFixXml(), icGetDeviceAttrName(), icGetSigStr(), icGetTagSigTypeName(), CIccProfileDescStruct::m_attributes, CIccProfileDescStruct::m_deviceMfg, CIccProfileDescStruct::m_deviceMfgDesc, CIccProfileDescStruct::m_deviceModel, CIccProfileDescStruct::m_deviceModelDesc, CIccProfileDescStruct::m_technology, and CIccTagXml::ToXml().

Referenced by CIccTagXmlProfileSeqDesc::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icXmlDumpTextData()

static bool icXmlDumpTextData ( std::string &  xml, std::string  blanks, const char *  szText, bool  bConvert = true  )

static

{
  if (strstr(szText, "]]>")) {
    xml += blanks + "<HexTextData>";
    icXmlDumpHexData(xml, blanks+" ", (void*)szText, (icUInt32Number)strlen(szText));
    xml += blanks + "</HexTextData>\n";
  }
  else {
    std::string buf;
 
    xml += blanks + "<TextData>";
    xml += "<![CDATA[";
    if (bConvert)
      xml += icAnsiToUtf8(buf, szText);
    else
      xml += szText;
    xml += "]]></TextData>\n"; 
  }
 
  return true;
}

References icAnsiToUtf8(), and icXmlDumpHexData().

Referenced by CIccTagXmlText::ToXml(), CIccTagXmlUtf8Text::ToXml(), CIccTagXmlUtf16Text::ToXml(), and CIccTagXmlTextDescription::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icXmlParseProfDesc()

bool icXmlParseProfDesc	(	xmlNode *	pNode,
		CIccProfileDescStruct &	p,
		std::string &	parseStr
	)

{
  if (pNode->type==XML_ELEMENT_NODE && !icXmlStrCmp(pNode->name, "ProfileDesc")) {
    xmlNode *pDescNode;  
 
    for (pDescNode = pNode->children; pDescNode; pDescNode=pDescNode->next) {
      if (pDescNode->type == XML_ELEMENT_NODE) {
        if (!icXmlStrCmp(pDescNode->name, "DeviceManufacturerSignature")){
          p.m_deviceMfg = icXmlStrToSig(pDescNode->children ? (const icChar*)pDescNode->children->content: "");
        }
        else if (!icXmlStrCmp(pDescNode->name, "DeviceModelSignature")){
          p.m_deviceModel = icXmlStrToSig(pDescNode->children ? (const icChar*)pDescNode->children->content : "");
        }
        else if (!icXmlStrCmp(pDescNode->name, "DeviceAttributes")){
          p.m_attributes = icGetDeviceAttrValue(pDescNode);      
        }
        else if (!icXmlStrCmp(pDescNode->name, "Technology")){
          p.m_technology = (icTechnologySignature)icXmlStrToSig(pDescNode->children ? (const icChar*)pDescNode->children->content : "");
        }
        else if (!icXmlStrCmp(pDescNode->name, "DeviceManufacturer")) {  
          xmlNode *pDevManNode = icXmlFindNode(pDescNode->children, "multiLocalizedUnicodeType");
 
          if (!pDevManNode){
            pDevManNode = icXmlFindNode(pDescNode->children, "textDescriptionType");
          }      
 
          if (pDevManNode){
            icTagTypeSignature tagSig = icGetTypeNameTagSig ((icChar*) pDevManNode->name);
 
            if (!p.m_deviceMfgDesc.SetType(tagSig)){
              return false;         
            }        
            CIccTag *pTag = p.m_deviceMfgDesc.GetTag();
 
            if (!pTag)
              return false;
 
            CIccTagXml *pExt = (CIccTagXml*)(pTag->GetExtension());
 
            if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
              return false;
 
            pExt->ParseXml(pDevManNode->children, parseStr);
          }            
        }
        else if (!icXmlStrCmp(pDescNode->name, "DeviceModel")) {
          xmlNode *pDevModNode = icXmlFindNode(pDescNode->children, "multiLocalizedUnicodeType");
 
          if (!pDevModNode){
            pDevModNode = icXmlFindNode(pDescNode->children, "textDescriptionType");
          }
 
          if (pDevModNode){
            icTagTypeSignature tagSig = icGetTypeNameTagSig ((icChar*) pDevModNode->name);
 
            if (!p.m_deviceModelDesc.SetType(tagSig)) {
              return false;
            }
            CIccTag *pTag = p.m_deviceModelDesc.GetTag();
 
            if (!pTag)
              return false;
 
            CIccTagXml *pExt = (CIccTagXml*)(pTag->GetExtension());
 
            if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
              return false;
 
            pExt->ParseXml(pDevModNode->children, parseStr);
          }
        }
      }
    }
  }
  else
    return false;
 
  if (!p.m_deviceMfgDesc.GetTag() || !p.m_deviceModelDesc.GetTag())
    return false;
 
  return true;
}

References CIccTagXml::GetExtClassName(), CIccTag::GetExtension(), CIccProfileDescText::GetTag(), icGetDeviceAttrValue(), icGetTypeNameTagSig(), icXmlFindNode(), icXmlStrToSig(), CIccProfileDescStruct::m_attributes, CIccProfileDescStruct::m_deviceMfg, CIccProfileDescStruct::m_deviceMfgDesc, CIccProfileDescStruct::m_deviceModel, CIccProfileDescStruct::m_deviceModelDesc, CIccProfileDescStruct::m_technology, CIccTagXml::ParseXml(), and CIccProfileDescText::SetType().

Referenced by CIccTagXmlProfileSeqDesc::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icXmlParseTextString()

static std::string icXmlParseTextString ( xmlNode *  pNode, std::string &  parseStr, bool  bConvert = true  )

static

{
  std::string str;
 
  while (pNode) {
    if (pNode->type==XML_ELEMENT_NODE) {
      if (!icXmlStrCmp(pNode->name, "HexTextData") && pNode->children && pNode->children->content) {
        CIccUInt8Array buf;
        if (!buf.SetSize(icXmlGetHexDataSize((const icChar*)pNode->children->content) ||
          icXmlGetHexData(buf.GetBuf(), (const icChar*)pNode->children->content, buf.GetSize())!=buf.GetSize()))
          return str;
 
        str += (char*)buf.GetBuf();
      }      
      else if (!icXmlStrCmp(pNode->name, "TextData") ) {
        std::string buf;
        const icChar *filename = icXmlAttrValue(pNode, "File");
 
        // file exists
        if (filename[0]) {        
          CIccIO *file = IccOpenFileIO(filename, "rb");        
          if (!file){          
            parseStr += "Error! - File '";
            parseStr += filename;
            parseStr +="' not found.\n";
            delete file;
            return str;
          }
 
          icUInt32Number fileLength = file->GetLength();  
          char *ansiStr = (char *)malloc(fileLength+1);
 
          if (!ansiStr) {
            perror("Memory Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid text file.\n";
            delete file;
            return str;
          }
          // read the contents of the file
          if (file->ReadLine(ansiStr, fileLength)!=fileLength) {
            parseStr += "Error while reading file '";
            parseStr += filename;
            parseStr += "'. Size read is not equal to file length. File may not be a valid text file.\n";
            free(ansiStr);
            delete file;             
            return str;
          }   
          // convert utf8 (xml format) to ansi (icc format)
          if (bConvert)
            icUtf8ToAnsi(buf, ansiStr);
          else
            buf = ansiStr;
          free(ansiStr);
          delete file;
        }
        // file does not exist
        else if (pNode->children && pNode->children->content){
          if (bConvert)
            icUtf8ToAnsi(buf, (const icChar*)pNode->children->content);      
          else
            buf = (const icChar*)pNode->children->content;
        }      
        str += buf;      
      } 
    }
    pNode = pNode->next; 
  }
 
  return str;
}

References CIccXmlArrayType< T, Tsig >::GetBuf(), CIccIO::GetLength(), CIccXmlArrayType< T, Tsig >::GetSize(), IccOpenFileIO(), icUtf8ToAnsi(), icXmlAttrValue(), icXmlGetHexData(), icXmlGetHexDataSize(), CIccIO::ReadLine(), and CIccXmlArrayType< T, Tsig >::SetSize().

Referenced by CIccTagXmlText::ParseXml(), CIccTagXmlUtf8Text::ParseXml(), CIccTagXmlZipUtf8Text::ParseXml(), CIccTagXmlZipXml::ParseXml(), CIccTagXmlUtf16Text::ParseXml(), and CIccTagXmlTextDescription::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function: