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

Bug Summary

File:	IccProfLib/IccTagBasic.cpp
Warning:	line 5073, column 42 Array access (from variable 'zeroVals') results in a null pointer dereference
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 IccTagBasic.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=osx -analyzer-checker=security.insecureAPI.decodeValueOfObjCType -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -ffp-contract=on -fno-rounding-math -funwind-tables=2 -target-sdk-version=14.0 -fcompatibility-qualified-id-block-type-checking -fvisibility-inlines-hidden-static-local-var -target-cpu penryn -tune-cpu generic -debugger-tuning=lldb -target-linker-version 1015.7 -fprofile-instrument=clang -fcoverage-mapping -fcoverage-compilation-dir=/Users/xss/DemoIccMAX-hoyt-master/build/IccProfLib -resource-dir /usr/local/Cellar/llvm/17.0.3/lib/clang/17 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk -D IccProfLib2_EXPORTS -I /Users/xss/DemoIccMAX-hoyt-master/build/Cmake/../../IccProfLib -I /Developer/Headers/FlatCarbon -F/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/System/Library/Frameworks -internal-isystem /usr/local/Cellar/llvm/17.0.3/bin/../include/c++/v1 -internal-isystem /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/usr/local/include -internal-isystem /usr/local/Cellar/llvm/17.0.3/lib/clang/17/include -internal-externc-isystem /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/usr/include -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/Users/xss/DemoIccMAX-hoyt-master/build/IccProfLib -ferror-limit 19 -fsanitize=address -fsanitize-system-ignorelist=/usr/local/Cellar/llvm/17.0.3/lib/clang/17/share/asan_ignorelist.txt -fno-sanitize-memory-param-retval -fsanitize-address-use-after-scope -fsanitize-address-globals-dead-stripping -fno-assume-sane-operator-new -stack-protector 1 -fblocks -fencode-extended-block-signature -fregister-global-dtors-with-atexit -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -fmax-type-align=16 -analyzer-output=html -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /var/folders/l9/sd9kj1px4yq2wc5_lkwhlt6w0000gn/T/scan-build-2023-10-28-102616-57860-1 -x c++ /Users/xss/DemoIccMAX-hoyt-master/IccProfLib/IccTagBasic.cpp
1/** @file
  File:       IccTagBasic.cpp

  Contains:   Implementation of the CIccTag class and basic inherited classes

  Version:    V1

  Copyright:  � see ICC Software License
9*/

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

64////////////////////////////////////////////////////////////////////// 
65// HISTORY:
66//
67// -Initial implementation by Max Derhak 5-15-2003
68//
69//////////////////////////////////////////////////////////////////////

71#ifdef WIN32
#pragma warning( disable: 4786) //disable warning in <list.h>
#include <windows.h>
74#endif
75#include <stdio.h>
76#include <math.h>
77#include <string.h>
78#include <stdlib.h>
79#include "IccTag.h"
80#include "IccUtil.h"
81#include "IccProfile.h"
82#include "IccTagFactory.h"
83#include "IccConvertUTF.h"
84#include "IccSparseMatrix.h"
85#include "IccCmm.h"

87#ifdef ICC_USE_ZLIB
88#include "zlib.h"
89#endif


92#ifndef __minmin
93#include <algorithm>
94using std::min;
95#define __minmin min
96#endif

98#ifdef USEREFICCMAXNAMESPACE
99namespace refIccMAX {
100#endif


103/**
****************************************************************************
* Name: CIccTag::CIccTag
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
111CIccTag::CIccTag()
112{
m_nReserved = 0;
114}

116/**
****************************************************************************
* Name: CIccTag::CIccTag
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
124CIccTag::~CIccTag()
125{

127}

129/**
****************************************************************************
* Name: CIccTag::Create
* 
* Purpose: This is a static tag creator based upon tag signature type
* 
* Args: 
*  sig = tag type signature
* 
* Return: Pointer to Allocated tag 
*****************************************************************************
*/
141CIccTag* CIccTag::Create(icTagTypeSignature sig)
142{
return CIccTagCreator::CreateTag(sig);
144}


147/**
******************************************************************************
* Name: CIccTag::Validate
* 
* Purpose: Check tag data validity.  In base class we only look at the
*  tag's reserved data value
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
162icValidateStatus CIccTag::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
163{
icValidateStatus rv = icValidateOK;

if (m_nReserved != 0) {
  CIccInfo Info;
  sReport += icMsgValidateNonCompliant;
  sReport += Info.GetSigPathName(sigPath);
  sReport += " - Reserved Value must be zero.\r\n";

  rv = icValidateNonCompliant;
}

return rv;
176}


179/**
****************************************************************************
* Name: CIccTagUnknown::CIccTagUnknown
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
187CIccTagUnknown::CIccTagUnknown()
188{
m_nType = icSigUnknownType((icTagTypeSignature) 0x3f3f3f3f);
m_pData = NULL__null;
191}

193/**
****************************************************************************
* Name: CIccTagUnknown::CIccTagUnknown
* 
* Purpose: Copy Constructor
*
* Args:
*  ITU = The CIccTagUnknown object to be copied
*****************************************************************************
*/
203CIccTagUnknown::CIccTagUnknown(const CIccTagUnknown &ITU)
204{
m_nSize = ITU.m_nSize;
m_nType = ITU.m_nType;

m_pData = new icUInt8Number[m_nSize];
memcpy(m_pData, ITU.m_pData, sizeof(icUInt8Number)*m_nSize);
210}

212/**
****************************************************************************
* Name: CIccTagUnknown::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  UnknownTag = The CIccTagUnknown object to be copied
*****************************************************************************
*/
222CIccTagUnknown &CIccTagUnknown::operator=(const CIccTagUnknown &UnknownTag)
223{
if (&UnknownTag == this)
  return *this;

m_nSize = UnknownTag.m_nSize;
m_nType = UnknownTag.m_nType;

if (m_pData)
  delete [] m_pData;
m_pData = new icUInt8Number[m_nSize];
memcpy(m_pData, UnknownTag.m_pData, sizeof(icUInt8Number)*m_nSize);

return *this;
236}

238/**
****************************************************************************
* Name: CIccTagUnknown::~CIccTagUnknown
* 
* Purpose: Destructor
*****************************************************************************
*/
245CIccTagUnknown::~CIccTagUnknown()
246{
if (m_pData)
  delete [] m_pData;
249}


252/**
****************************************************************************
* Name: CIccTagUnknown::Read
* 
* Purpose: Read in an unknown tag type into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
266bool CIccTagUnknown::Read(icUInt32Number size, CIccIO *pIO)
267{
if (m_pData) {
  delete [] m_pData;
  m_pData = NULL__null;
}

if (size<sizeof(icTagTypeSignature) || !pIO) {
  return false;
}

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

m_nSize = size - sizeof(icTagTypeSignature);

if (m_nSize > 0) { // size could be stored as smaller than expected value, therefore the size check

  m_pData = new icUInt8Number[m_nSize];

  if (pIO->Read8(m_pData, m_nSize) != (icInt32Number)m_nSize) {
    return false;
  }
} else {
    return false;
}

return true;
294}


297/**
****************************************************************************
* Name: CIccTagUnknown::Write
* 
* Purpose: Write an unknown tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
310bool CIccTagUnknown::Write(CIccIO *pIO)
311{
if (!pIO)
 return false;

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

if (m_nSize && m_pData) {
 if (pIO->Write8(m_pData, m_nSize) != (icInt32Number)m_nSize)
   return false;
}

return true;
324}


327/**
****************************************************************************
* Name: CIccTagUnknown::Describe
* 
* Purpose: Dump data associated with unknown tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
337void CIccTagUnknown::Describe(std::string &sDescription)
338{
icChar buf[128];

sDescription = "Unknown Tag Type of ";
sprintf(buf, "%u Bytes.", m_nSize-4);
sDescription += buf;

sDescription += "\r\n\r\nData Follows:\r\n";

icMemDump(sDescription, m_pData+4, m_nSize-4);
348}


351/**
****************************************************************************
* Name: CIccTagText::CIccTagText
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
359CIccTagText::CIccTagText()
360{
m_szText = (icChar*)malloc(1);
m_szText[0] = '\0';
m_nBufSize = 1;
364}

366/**
****************************************************************************
* Name: CIccTagText::CIccTagText
* 
* Purpose: Copy Constructor
*
* Args:
*  ITT = The CIccTagText object to be copied
*****************************************************************************
*/
376CIccTagText::CIccTagText(const CIccTagText &ITT)
377{
m_szText = (icChar*)malloc(1);
m_szText[0] = '\0';
m_nBufSize = 1;
SetText(ITT.m_szText);
382}

384/**
****************************************************************************
* Name: CIccTagText::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  TextTag = The CIccTagText object to be copied
*****************************************************************************
*/
394CIccTagText &CIccTagText::operator=(const CIccTagText &TextTag)
395{
if (&TextTag == this)
  return *this;

m_szText = (icChar*)malloc(1);
m_szText[0] = '\0';
m_nBufSize = 1;
SetText(TextTag.m_szText);

return *this;
405}

407/**
****************************************************************************
* Name: CIccTagText::~CIccTagText
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
415CIccTagText::~CIccTagText()
416{
free(m_szText);
418}

420/**
****************************************************************************
* Name: CIccTagText::Read
* 
* Purpose: Read in a text type tag into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
434bool CIccTagText::Read(icUInt32Number size, CIccIO *pIO)
435{
icTagTypeSignature sig;

if (size<sizeof(icTagTypeSignature) || !pIO) {
  m_szText[0] = '\0';
  return false;
}

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

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

icUInt32Number nSize = size - sizeof(icTagTypeSignature) - sizeof(icUInt32Number);

icChar *pBuf = GetBuffer(nSize);

if (nSize) {
  if (pIO->Read8(pBuf, nSize) != (icInt32Number)nSize) {
    return false;
  }
}

Release();

return true;
462}

464/**
****************************************************************************
* Name: CIccTagText::Write
* 
* Purpose: Write a text type tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
477bool CIccTagText::Write(CIccIO *pIO)
478{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (!m_szText)
  return false;

icUInt32Number nSize = (icUInt32Number)strlen(m_szText)+1;

if (pIO->Write8(m_szText, nSize) != (icInt32Number)nSize)
  return false;

return true;
499}

501/**
****************************************************************************
* Name: CIccTagText::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
511void CIccTagText::Describe(std::string &sDescription)
512{
sDescription += "\"";
if (m_szText && *m_szText)
  sDescription += m_szText;

sDescription += "\"\r\n";
518}


521/**
****************************************************************************
* Name: CIccTagText::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
531void CIccTagText::SetText(const icChar *szText)
532{
if (!szText) 
  SetText("");

icUInt32Number len=(icUInt32Number)strlen(szText) + 1;
icChar *szBuf = GetBuffer(len);

strcpy(szBuf, szText);
Release();
541}

543/**
****************************************************************************
* Name: *CIccTagText::operator=
* 
* Purpose: Define assignment operator to associate text with tag.
* 
* Args: 
*  szText - zero terminated string to put in the tag
*
* Return: A pointer to the string assigned to the tag.
*****************************************************************************
*/
555const icChar *CIccTagText::operator=(const icChar *szText)
556{
SetText(szText);
return m_szText;
559}

561/**
******************************************************************************
* Name: CIccTagText::GetBuffer
* 
* Purpose: This function allocates room and returns pointer to data buffer to
*  put string into
* 
* Args: 
*  nSize = Requested size of data buffer.
* 
* Return: The character buffer array
*******************************************************************************
*/
574icChar *CIccTagText::GetBuffer(icUInt32Number nSize)
575{
if (m_nBufSize < nSize) {
  m_szText = (icChar*)icRealloc(m_szText, nSize+1);

  if (m_szText) {
    m_szText[nSize] = '\0';
    m_nBufSize = nSize;
  }
  else
    m_nBufSize = 0;
}

return m_szText;
588}

590/**
****************************************************************************
* Name: CIccTagText::Release
* 
* Purpose: This will resize the buffer to fit the zero terminated string in
*  the buffer.
*****************************************************************************
*/
598void CIccTagText::Release()
599{
icUInt32Number nSize = (icUInt32Number)strlen(m_szText)+1;

if (nSize < m_nBufSize-1) {
  m_szText=(icChar*)icRealloc(m_szText, nSize+1);
  m_nBufSize = nSize+1;
}
606}


609/**
610******************************************************************************
611* Name: CIccTagText::Validate
612* 
613* Purpose: Check tag data validity.
614* 
615* Args: 
616*  sig = signature of tag being validated,
617*  sReport = String to add report information to
618* 
619* Return: 
620*  icValidateStatusOK if valid, or other error status.
621******************************************************************************
622*/
623icValidateStatus CIccTagText::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
624{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);
icSignature sig = icGetFirstSigPathSig(sigPath);

if (m_nBufSize) {
  switch(sig) {
  case icSigCopyrightTag:
    break;
  case icSigCharTargetTag:
    if (m_nBufSize<7) {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sReport += " - Tag must have at least seven text characters.\r\n";
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
    break;
  default:
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " - Unknown Tag.\r\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
  int i;
  for (i=0; m_szText[i] && i<(int)m_nBufSize; i++) {
    if (m_szText[i]&0x80) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " - Text does not contain just 7-bit data.\r\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
  }
}
else {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty Tag.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}


return rv;
668}



672/**
****************************************************************************
* Name: CIccTagUtf8Text::CIccTagUtf8Text
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
680CIccTagUtf8Text::CIccTagUtf8Text()
681{
m_szText = (icUChar*)malloc(1);
m_szText[0] = '\0';
m_nBufSize = 1;
685}

687/**
****************************************************************************
* Name: CIccTagUtf8Text::CIccTagUtf8Text
* 
* Purpose: Copy Constructor
*
* Args:
*  ITT = The CIccTagText object to be copied
*****************************************************************************
*/
697CIccTagUtf8Text::CIccTagUtf8Text(const CIccTagUtf8Text &ITT)
698{
m_szText = (icUChar*)malloc(1);
m_szText[0] = '\0';
m_nBufSize = 1;
SetText(ITT.m_szText);
703}

705/**
****************************************************************************
* Name: CIccTagUtf8Text::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  TextTag = The CIccTagText object to be copied
*****************************************************************************
*/
715CIccTagUtf8Text &CIccTagUtf8Text::operator=(const CIccTagUtf8Text &TextTag)
716{
if (&TextTag == this)
  return *this;

m_szText = (icUChar*)malloc(1);
m_szText[0] = '\0';
m_nBufSize = 1;
SetText(TextTag.m_szText);

return *this;
726}

728/**
****************************************************************************
* Name: CIccTagUtf8Text::~CIccTagUtf8Text
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
736CIccTagUtf8Text::~CIccTagUtf8Text()
737{
free(m_szText);
739}

741/**
****************************************************************************
* Name: CIccTagUtf8Text::Read
* 
* Purpose: Read in a text type tag into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
755bool CIccTagUtf8Text::Read(icUInt32Number size, CIccIO *pIO)
756{
icTagTypeSignature sig;

if (size<sizeof(icTagTypeSignature) || !pIO) {
  m_szText[0] = '\0';
  return false;
}

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

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

if (size < sizeof(icTagTypeSignature) + sizeof(icUInt32Number))
  return false;

icUInt32Number nSize = size - sizeof(icTagTypeSignature) - sizeof(icUInt32Number);

icUChar *pBuf = GetBuffer(nSize);

if (nSize) {
  if (pIO->Read8(pBuf, nSize) != (icInt32Number)nSize) {
    return false;
  }
}

Release();

return true;
786}

788/**
****************************************************************************
* Name: CIccTagUtf8Text::Write
* 
* Purpose: Write a text type tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
801bool CIccTagUtf8Text::Write(CIccIO *pIO)
802{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (!m_szText)
  return false;

icUInt32Number nSize = (icUInt32Number)strlen((icChar*)m_szText)+1;

if (pIO->Write8(m_szText, nSize) != (icInt32Number)nSize)
  return false;

return true;
823}

825/**
****************************************************************************
* Name: CIccTagUtf8Text::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
835void CIccTagUtf8Text::Describe(std::string &sDescription)
836{
sDescription += "\"";
if (m_szText && *m_szText)
  sDescription += (icChar*)m_szText;

sDescription += "\"\r\n";
842}


845/**
****************************************************************************
* Name: CIccTagUtf8Text::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
855void CIccTagUtf8Text::SetText(const icUChar *szText)
856{
if (!szText) 
  SetText("");

icUInt32Number len=(icUInt32Number)strlen((icChar*)szText) + 1;
icUChar *szBuf = GetBuffer(len);

strcpy((icChar*)szBuf, (icChar*)szText);
Release();
865}


868/**
****************************************************************************
* Name: CIccTagUtf8Text::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
878void CIccTagUtf8Text::SetText(const icUChar16 *szText)
879{
if (!szText) 
  SetText("");

icUtf8Vector text;
icUInt32Number len;
for (len=0; szText[len]; len++);

icConvertUTF16toUTF8(szText, &szText[len], text, lenientConversion);

SetText((const icUChar*)&text[0]);
890}

892/**
****************************************************************************
* Name: *CIccTagUtf8Text::operator=
* 
* Purpose: Define assignment operator to associate text with tag.
* 
* Args: 
*  szText - zero terminated string to put in the tag
*
* Return: A pointer to the string assigned to the tag.
*****************************************************************************
*/
904const icUChar *CIccTagUtf8Text::operator=(const icUChar *szText)
905{
SetText(szText);
return (icUChar*)m_szText;
908}

910/**
******************************************************************************
* Name: CIccTagUtf8Text::GetBuffer
* 
* Purpose: This function allocates room and returns pointer to data buffer to
*  put string into
* 
* Args: 
*  nSize = Requested size of data buffer.
* 
* Return: The character buffer array
*******************************************************************************
*/
923icUChar *CIccTagUtf8Text::GetBuffer(icUInt32Number nSize)
924{
if (m_nBufSize < nSize) {
  m_szText = (icUChar*)icRealloc(m_szText, nSize+1);

  if (m_szText) {
    m_szText[nSize] = '\0';
    m_nBufSize = nSize;
  }
  else {
    m_nBufSize = 0;
  }
}

return m_szText;
938}

940/**
****************************************************************************
* Name: CIccTagUtf8Text::Release
* 
* Purpose: This will resize the buffer to fit the zero terminated string in
*  the buffer.
*****************************************************************************
*/
948void CIccTagUtf8Text::Release()
949{
icUInt32Number nSize = (icUInt32Number)strlen((icChar*)m_szText)+1;

if (nSize < m_nBufSize-1) {
  m_szText=(icUChar*)icRealloc(m_szText, nSize+1);
  m_nBufSize = nSize+1;
}
956}


959/**
960******************************************************************************
961* Name: CIccTagUtf8Text::Validate
962* 
963* Purpose: Check tag data validity.
964* 
965* Args: 
966*  sig = signature of tag being validated,
967*  sReport = String to add report information to
968* 
969* Return: 
970*  icValidateStatusOK if valid, or other error status.
971******************************************************************************
972*/
973icValidateStatus CIccTagUtf8Text::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
974{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!m_nBufSize) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty Tag.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}


return rv;
989}


992static unsigned char icFaultyXmlZipData[4] = { 0,0,0,1 };

994/**
****************************************************************************
* Name: CIccTagZipUtf8Text::CIccTagZipUtf8Text
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
1002CIccTagZipUtf8Text::CIccTagZipUtf8Text()
1003{
m_pZipBuf = NULL__null;
m_nBufSize = 0;
1006}

1008/**
****************************************************************************
* Name: CIccTagZipUtf8Text::CIccTagZipUtf8Text
* 
* Purpose: Copy Constructor
*
* Args:
*  ITT = The CIccTagText object to be copied
*****************************************************************************
*/
1018CIccTagZipUtf8Text::CIccTagZipUtf8Text(const CIccTagZipUtf8Text &ITT)
1019{
m_pZipBuf = NULL__null;
m_nBufSize = 0;
AllocBuffer(ITT.BufferSize());
if (m_pZipBuf) {
  memcpy(m_pZipBuf, ITT.GetBuffer(), m_nBufSize);
}
1026}

1028/**
****************************************************************************
* Name: CIccTagZipUtf8Text::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  TextTag = The CIccTagText object to be copied
*****************************************************************************
*/
1038CIccTagZipUtf8Text &CIccTagZipUtf8Text::operator=(const CIccTagZipUtf8Text &ITT)
1039{
if (&ITT == this)
  return *this;

AllocBuffer(ITT.BufferSize());
if (m_pZipBuf) {
  memcpy(m_pZipBuf, ITT.GetBuffer(), m_nBufSize);
}

return *this;
1049}

1051/**
****************************************************************************
* Name: CIccTagZipUtf8Text::~CIccTagZipUtf8Text
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
1059CIccTagZipUtf8Text::~CIccTagZipUtf8Text()
1060{
if (m_pZipBuf)
  free(m_pZipBuf);
1063}

1065/**
****************************************************************************
* Name: CIccTagZipUtf8Text::Read
* 
* Purpose: Read in a text type tag into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
1079bool CIccTagZipUtf8Text::Read(icUInt32Number size, CIccIO *pIO)
1080{
icTagTypeSignature sig;

if (size<sizeof(icTagTypeSignature) || !pIO) {
  AllocBuffer(0);
  return false;
}

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

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

icUInt32Number nSize = size - sizeof(icTagTypeSignature) - sizeof(icUInt32Number);

icUChar *pBuf = AllocBuffer(nSize);

if (m_nBufSize && pBuf) {
  if (pIO->Read8(pBuf, m_nBufSize) != (icInt32Number)m_nBufSize) {
    return false;
  }
}

return true;
1105}

1107/**
****************************************************************************
* Name: CIccTagZipUtf8Text::Write
* 
* Purpose: Write a text type tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
1120bool CIccTagZipUtf8Text::Write(CIccIO *pIO)
1121{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (m_pZipBuf) {
  if (pIO->Write8(m_pZipBuf, m_nBufSize) != (icInt32Number)m_nBufSize)
    return false;
}
return true;
1138}

1140/**
****************************************************************************
* Name: CIccTagZipUtf8Text::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
1150void CIccTagZipUtf8Text::Describe(std::string &sDescription)
1151{
std::string str;
1153#ifdef ICC_USE_ZLIB
if (!GetText(str)) {
  sDescription += "Error! - Unable to decompress text data.\r\n";
}
else if (m_nBufSize > 4 && !memcmp(m_pZipBuf, icFaultyXmlZipData, 4)) {
  sDescription += "Warning! - Correcting for improperly encoded ";
  sDescription += CIccTagCreator::GetTagTypeSigName(GetType());
  sDescription += " tag.\r\n\r\n";
}

sDescription += "ZLib Compressed String=\"";
sDescription += str;
sDescription += "\"\r\n";
1166#else
char size[30];
sprintf(size, "%d", m_nBufSize);
sDescription += "BEGIN_COMPESSED_DATA[\"";
sDescription += size;
sDescription += "]\r\n";
if (m_nBufSize) {
  icMemDump(str, m_pZipBuf, m_nBufSize);
  sDescription += str;
  sDescription += "\r\n";
}
sDescription += "END_COMPRESSED_DATA\r\n";
1178#endif
1179}

1181/**
****************************************************************************
* Name: CIccTagZipUtf8Text::GetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  text - string to put uncompressed text into
*****************************************************************************
*/
1191bool CIccTagZipUtf8Text::GetText(std::string &str) const
1192{
1193#ifndef ICC_USE_ZLIB
str="";
return false;
1196#else
int zstat;
z_stream zstr;
memset(&zstr, 0, sizeof(zstr));
unsigned char buf[32767] = { 0 };

zstat = inflateInit(&zstr);

if (zstat != Z_OK) {
  return false;
}

zstat = inflateReset(&zstr);

if (zstat != Z_OK) {
  return false;
}

if (m_nBufSize > 4 && !memcmp(m_pZipBuf, icFaultyXmlZipData, 4)) {
  //xrite creates invalid zipXMLType tags
  zstr.next_in = m_pZipBuf+4;
  zstr.avail_in = m_nBufSize-4;
}
else {
  zstr.next_in = m_pZipBuf;
  zstr.avail_in = m_nBufSize;
}

do {
  unsigned int i, n;

  zstr.next_out = buf;
  zstr.avail_out = sizeof(buf);

  zstat = inflate(&zstr, Z_SYNC_FLUSH);

  if (zstat != Z_OK && zstat != Z_STREAM_END) {
    inflateEnd(&zstr);
    return false;
  }

  n = sizeof(buf) - zstr.avail_out;

  for (i = 0; i < n; i++) {
    str += buf[i];
  }
} while (zstat != Z_STREAM_END);

inflateEnd(&zstr);

return true;
1247#endif
1248}


1251/**
****************************************************************************
* Name: CIccTagZipUtf8Text::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
1261bool CIccTagZipUtf8Text::SetText(const icUChar *szText)
1262{
1263#ifndef ICC_USE_ZLIB
return false;
1265#else
icUInt32Number nSize = (icUInt32Number)strlen((const char*)szText) + 1;
icUtf8Vector compress;
int i;

int zstat;
z_stream zstr;
unsigned char buf[32767];
memset(&zstr, 0, sizeof(zstr));

zstat = deflateInit(&zstr, Z_DEFAULT_COMPRESSION);

if (zstat != Z_OK) {
  return false;
}

zstat = deflateReset(&zstr);
zstr.next_in = (Bytef*)szText;
zstr.avail_in = nSize;

if (zstat != Z_OK) {
  return false;
}


do {
  int n;
  zstr.next_out = buf;
  zstr.avail_out = sizeof(buf);

  zstat = deflate(&zstr, Z_FINISH);

  if (zstat != Z_OK && zstat != Z_STREAM_END) {
    deflateEnd(&zstr);
    return false;
  }

  n = sizeof(buf) - zstr.avail_out;

  for (i = 0; i < n; i++) {
    compress.push_back(buf[i]);
  }
} while (zstat != Z_STREAM_END);

deflateEnd(&zstr);

icUChar *pBuf = AllocBuffer(compress.size());

if (pBuf) {
  for (i = 0; i < m_nBufSize; i++) {
    pBuf[i] = compress[i];
1316}
}

return true;
1320#endif
1321}

1323/**
****************************************************************************
* Name: CIccTagZipUtf8Text::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
1333bool CIccTagZipUtf8Text::SetText(const icUChar16 *szText)
1334{
if (!szText) 
  return SetText("");

icUtf8Vector text;
icUInt32Number len;
for (len=0; szText[len]; len++);

icConvertUTF16toUTF8(szText, &szText[len], text, lenientConversion);

return SetText((const icUChar*)&text[0]);
1345}



1349/**
******************************************************************************
* Name: CIccTagZipUtf8Text::AllocBuffer
* 
* Purpose: This function allocates room and returns pointer to data buffer to
*  put string into
* 
* Args: 
*  nSize = Requested size of data buffer.
* 
* Return: The character buffer array
*******************************************************************************
*/
1362icUChar *CIccTagZipUtf8Text::AllocBuffer(icUInt32Number nSize)
1363{
if (m_nBufSize != nSize) {
  if (!nSize) {
    if (m_pZipBuf)
      free(m_pZipBuf);

    m_nBufSize = nSize;
    return NULL__null;
  }

  if (!m_nBufSize)
    m_pZipBuf = (icUChar*)malloc(nSize);
  else
    m_pZipBuf = (icUChar*)icRealloc(m_pZipBuf, nSize);

  m_nBufSize = nSize;

}

return m_pZipBuf;
1383}


1386/**
1387******************************************************************************
1388* Name: CIccTagZipUtf8Text::Validate
1389* 
1390* Purpose: Check tag data validity.
1391* 
1392* Args: 
1393*  sig = signature of tag being validated,
1394*  sReport = String to add report information to
1395* 
1396* Return: 
1397*  icValidateStatusOK if valid, or other error status.
1398******************************************************************************
1399*/
1400icValidateStatus CIccTagZipUtf8Text::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
1401{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!m_nBufSize) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty Tag.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}
else {
1414#ifdef ICC_USE_ZLIB
  std::string sText;
  if (!GetText(sText)) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Unable to get text for tag (possibly corrupt compressed data).\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
  else if (m_nBufSize > 4 && !memcmp(m_pZipBuf, icFaultyXmlZipData, 4)) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Improperly encoded ";
    sReport += CIccTagCreator::GetTagTypeSigName(GetType());
    sReport += " tag.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
1430#else
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Zip compression not supported by CMM - unable to validate text compression.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
1435#endif
}

return rv;
1439}



1443/**
****************************************************************************
* Name: CIccTagUtf16Text::CIccTagUtf16Text
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
1451CIccTagUtf16Text::CIccTagUtf16Text()
1452{
m_szText = (icUChar16*)malloc(1*sizeof(icUChar16));
m_szText[0] = 0;
m_nBufSize = 1;
1456}

1458/**
****************************************************************************
* Name: CIccTagUtf16Text::CIccTagUtf16Text
* 
* Purpose: Copy Constructor
*
* Args:
*  ITT = The CIccTagText object to be copied
*****************************************************************************
*/
1468CIccTagUtf16Text::CIccTagUtf16Text(const CIccTagUtf16Text &ITT)
1469{
m_szText = (icUChar16*)malloc(1*sizeof(icUChar16));
m_szText[0] = 0;
m_nBufSize = 1;
SetText(ITT.m_szText);
1474}

1476/**
****************************************************************************
* Name: CIccTagUtf16Text::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  TextTag = The CIccTagText object to be copied
*****************************************************************************
*/
1486CIccTagUtf16Text &CIccTagUtf16Text::operator=(const CIccTagUtf16Text &TextTag)
1487{
if (&TextTag == this)
  return *this;

m_szText = (icUChar16*)malloc(1*sizeof(icUChar16));
m_szText[0] = '\0';
m_nBufSize = 1;
SetText(TextTag.m_szText);

return *this;
1497}

1499/**
****************************************************************************
* Name: CIccTagUtf16Text::~CIccTagUtf16Text
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
1507CIccTagUtf16Text::~CIccTagUtf16Text()
1508{
free(m_szText);
1510}

1512/**
****************************************************************************
* Name: CIccTagUtf16Text::GetLength
* 
* Purpose: Get length of utf16 string
* 
*****************************************************************************
*/
1520icUInt32Number CIccTagUtf16Text::GetLength() const
1521{
icUInt32Number n;
if (!m_szText || !m_nBufSize)
  return 0;

for (n=0; n<m_nBufSize && m_szText[n]; n++);

return n;
1529}

1531/**
****************************************************************************
* Name: CIccTagUtf16Text::Read
* 
* Purpose: Read in a text type tag into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
1545bool CIccTagUtf16Text::Read(icUInt32Number size, CIccIO *pIO)
1546{
icTagTypeSignature sig;

if (size<sizeof(icTagTypeSignature) || !pIO) {
  m_szText[0] = '\0';
  return false;
}

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

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

icUInt32Number nSize = (size - sizeof(icTagTypeSignature) - sizeof(icUInt32Number))/sizeof(icUChar16);

icUChar16 *pBuf = GetBuffer(nSize);

if (nSize) {
  if (pIO->Read16(pBuf, nSize) != (icInt32Number)nSize) {
    return false;
  }
}

Release();

return true;
1573}

1575/**
****************************************************************************
* Name: CIccTagUtf16Text::Write
* 
* Purpose: Write a text type tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
1588bool CIccTagUtf16Text::Write(CIccIO *pIO)
1589{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (!m_szText)
  return false;

icUInt32Number nSize = GetLength();

if (nSize) {
  if (pIO->Write16(m_szText, nSize) != (icInt32Number)nSize)
    return false;
}

return true;
1612}

1614/**
****************************************************************************
* Name: CIccTagUtf16Text::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
1624void CIccTagUtf16Text::Describe(std::string &sDescription)
1625{
sDescription += "\"";
if (m_szText && *m_szText) {
  std::string buf;
  sDescription += GetText(buf);
}

sDescription += "\"\r\n";
1633}

1635/**
****************************************************************************
* Name: CIccTagUtf16Text::GetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
1645const icChar *CIccTagUtf16Text::GetText(std::string &buf) const
1646{
icUtf8Vector str;

icConvertUTF16toUTF8(m_szText, &m_szText[GetLength()], str, lenientConversion);

buf.clear();
icUtf8Vector::iterator c;
c=str.begin();
if (str.size()>2 && (str[0]==0xff && str[1]==0xfe)) {
  c++; c++;
}
for (; c!=str.end(); c++)
  buf.push_back(*c);

return buf.c_str();
1661}


1664/**
****************************************************************************
* Name: CIccTagUtf16Text::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
1674void CIccTagUtf16Text::SetText(const icUChar16 *szText)
1675{
if (!szText) {
  icUChar16 c=0;
  SetText(&c);
}

icUInt32Number n;
for (n=0; szText[n]; n++);

icUInt32Number len=n + 1;
icUChar16 *szBuf = GetBuffer(len);

memcpy(szBuf, szText, len*sizeof(icUChar16));
Release();
1689}

1691/**
****************************************************************************
* Name: CIccTagUtf16Text::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
1701void CIccTagUtf16Text::SetText(const icUChar *szText)
1702{
if (!szText) {
  icUChar16 c=0;
  SetText(&c);
}

icUtf16Vector str;
icConvertUTF8toUTF16(szText, szText+strlen((icChar*)szText)+1, str, lenientConversion);

int pos = 0;
if (str[0]==0xfeff) {
  pos = 1;
}

icUInt32Number nSize = (icUInt32Number)(str.size()-pos);
icUChar16 *szBuf = GetBuffer(nSize);

if (nSize)
  memcpy(m_szText, &str[pos], nSize*sizeof(icUChar));
Release();
1722}

1724/**
****************************************************************************
* Name: *CIccTagUtf16Text::operator=
* 
* Purpose: Define assignment operator to associate text with tag.
* 
* Args: 
*  szText - zero terminated string to put in the tag
*
* Return: A pointer to the string assigned to the tag.
*****************************************************************************
*/
1736const icUChar16 *CIccTagUtf16Text::operator=(const icUChar16 *szText)
1737{
SetText(szText);
return (icUChar16*)m_szText;
1740}

1742/**
******************************************************************************
* Name: CIccTagUtf16Text::GetBuffer
* 
* Purpose: This function allocates room and returns pointer to data buffer to
*  put string into
* 
* Args: 
*  nSize = Requested size of data buffer.
* 
* Return: The utf16 character buffer array
*******************************************************************************
*/
1755icUChar16 *CIccTagUtf16Text::GetBuffer(icUInt32Number nSize)
1756{
if (m_nBufSize < nSize) {
  m_szText = (icUChar16*)icRealloc(m_szText, (nSize+1)*sizeof(icUChar16));

  m_szText[nSize] = 0;

  m_nBufSize = nSize;
}

return m_szText;
1766}

1768/**
****************************************************************************
* Name: CIccTagUtf16Text::Release
* 
* Purpose: This will resize the buffer to fit the zero terminated string in
*  the buffer.
*****************************************************************************
*/
1776void CIccTagUtf16Text::Release()
1777{
icUInt32Number nSize = GetLength()+1;

if (nSize < m_nBufSize-1) {
  m_szText=(icUChar16*)icRealloc(m_szText, (nSize+1)*sizeof(icUChar16));
  m_nBufSize = nSize+1;
}
1784}


1787/**
1788******************************************************************************
1789* Name: CIccTagUtf16Text::Validate
1790* 
1791* Purpose: Check tag data validity.
1792* 
1793* Args: 
1794*  sig = signature of tag being validated,
1795*  sReport = String to add report information to
1796* 
1797* Return: 
1798*  icValidateStatusOK if valid, or other error status.
1799******************************************************************************
1800*/
1801icValidateStatus CIccTagUtf16Text::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
1802{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!m_nBufSize) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty Tag.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}

return rv;
1816}



1820/**
****************************************************************************
* Name: CIccTagTextDescription::CIccTagTextDescription
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
1828CIccTagTextDescription::CIccTagTextDescription()
1829{
m_szText = (icChar*)malloc(1);
m_szText[0] = '\0';
m_nASCIISize = 1;

m_uzUnicodeText = (icUInt16Number*)malloc(sizeof(icUInt16Number));
m_uzUnicodeText[0] = 0;
m_nUnicodeSize = 1;
m_nUnicodeLanguageCode = 0;

m_nScriptSize = 0;
m_nScriptCode = 0;
memset(m_szScriptText, 0, sizeof(m_szScriptText));

m_bInvalidScript = false;
1844}

1846/**
****************************************************************************
* Name: CIccTagTextDescription::CIccTagTextDescription
* 
* Purpose: Copy Constructor
*
* Args:
*  ITTD = The CIccTagTextDescription object to be copied
*****************************************************************************
*/
1856CIccTagTextDescription::CIccTagTextDescription(const CIccTagTextDescription &ITTD)
1857{
m_nASCIISize = ITTD.m_nASCIISize;
m_nUnicodeSize = ITTD.m_nUnicodeSize;
m_nUnicodeLanguageCode = ITTD.m_nUnicodeLanguageCode;
m_nScriptSize = ITTD.m_nScriptSize;
m_nScriptCode = ITTD.m_nScriptCode;

if (m_nASCIISize) {
  m_szText = (icChar*)malloc(m_nASCIISize * sizeof(icChar));
  memcpy(m_szText, ITTD.m_szText, m_nASCIISize*sizeof(icChar));
}
else {
  m_nASCIISize = 1;
  m_szText = (icChar*)calloc(m_nASCIISize, sizeof(icChar));
  m_szText[0] = '\0';
}

if (m_nUnicodeSize) {
  m_uzUnicodeText = (icUInt16Number*)malloc((m_nUnicodeSize) * sizeof(icUInt16Number));
  memcpy(m_uzUnicodeText, ITTD.m_uzUnicodeText, m_nUnicodeSize*sizeof(icUInt16Number));
}
else {
  m_nUnicodeSize = 1;
  m_uzUnicodeText = (icUInt16Number*)calloc(m_nUnicodeSize, sizeof(icUInt16Number));
  m_uzUnicodeText[0] = 0;
}

memcpy(m_szScriptText, ITTD.m_szScriptText, sizeof(m_szScriptText));

m_bInvalidScript = ITTD.m_bInvalidScript;
1887}


1890/**
****************************************************************************
* Name: CIccTagTextDescription::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  TextDescTag = The CIccTagTextDescription object to be copied
*****************************************************************************
*/
1900CIccTagTextDescription &CIccTagTextDescription::operator=(const CIccTagTextDescription& TextDescTag)
1901{
if (&TextDescTag == this)
  return *this;

m_nASCIISize = TextDescTag.m_nASCIISize;
m_nUnicodeSize = TextDescTag.m_nUnicodeSize;
m_nUnicodeLanguageCode = TextDescTag.m_nUnicodeLanguageCode;
m_nScriptSize = TextDescTag.m_nScriptSize;
m_nScriptCode = TextDescTag.m_nScriptCode;

if (m_szText)
  free(m_szText);
if (m_nASCIISize) {
  m_szText = (icChar*)calloc(m_nASCIISize, sizeof(icChar));
  memcpy(m_szText, TextDescTag.m_szText, m_nASCIISize*sizeof(icChar));
} 
else {
  m_nASCIISize = 1;
  m_szText = (icChar*)calloc(m_nASCIISize, sizeof(icChar));
  m_szText[0] = '\0';
}

if (m_uzUnicodeText)
  free(m_uzUnicodeText);
if (m_nUnicodeSize) {
  m_uzUnicodeText = (icUInt16Number*)calloc(m_nUnicodeSize, sizeof(icUInt16Number));
  memcpy(m_uzUnicodeText, TextDescTag.m_uzUnicodeText, m_nUnicodeSize*sizeof(icUInt16Number));
}
else {
  m_nUnicodeSize = 1;
  m_uzUnicodeText = (icUInt16Number*)calloc(m_nUnicodeSize, sizeof(icUInt16Number));
  m_uzUnicodeText[0] = 0;
}

memcpy(m_szScriptText, TextDescTag.m_szScriptText, sizeof(m_szScriptText));

m_bInvalidScript = TextDescTag.m_bInvalidScript;

return *this;  
1940}

1942/**
****************************************************************************
* Name: CIccTagTextDescription::~CIccTagTextDescription
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
1950CIccTagTextDescription::~CIccTagTextDescription()
1951{
free(m_szText);
free(m_uzUnicodeText);
1954}

1956/**
****************************************************************************
* Name: CIccTagTextDescription::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
1970bool CIccTagTextDescription::Read(icUInt32Number size, CIccIO *pIO)
1971{
icTagTypeSignature sig;
icUInt32Number nEnd;

nEnd = pIO->Tell() + size;

if (size<3*sizeof(icUInt32Number) || !pIO) {
  m_szText[0] = '\0';
  return false;
}

icUInt32Number nSize;

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

if (3*sizeof(icUInt32Number) + nSize > size)
  return false;

icChar *pBuf = GetBuffer(nSize);

if (nSize) {
  if (pIO->Read8(pBuf, nSize) != (icInt32Number)nSize) {
    return false;
  }
}
else 
  m_szText[0] = '\0';

Release();

if (pIO->Tell() + 2 * sizeof(icUInt32Number) > nEnd)
  return false;

if (!pIO->Read32(&m_nUnicodeLanguageCode) ||
    !pIO->Read32(&nSize))
  return false;

icUInt16Number *pBuf16 = GetUnicodeBuffer(nSize);

if (nSize) {
  if (pIO->Read16(pBuf16, nSize) != (icInt32Number)nSize) {
    return false;
  }
}
else 
  pBuf16[0] = 0;

ReleaseUnicode();

if (pIO->Tell()+3 > (icInt32Number)nEnd)
  return false;

if (!pIO->Read16(&m_nScriptCode) ||
    !pIO->Read8(&m_nScriptSize))
   return false;

if (pIO->Tell() + m_nScriptSize> (icInt32Number)nEnd ||
    m_nScriptSize > sizeof(m_szScriptText))
  return false;

int nScriptLen = pIO->Read8(m_szScriptText, 67);

if (!nScriptLen)
  return false;

if (nScriptLen<67) {
  memset(&m_szScriptText[0], 0, 67-nScriptLen);
  m_bInvalidScript = true;
}

return true;
2045}

2047/**
****************************************************************************
* Name: CIccTagTextDescription::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
2060bool CIccTagTextDescription::Write(CIccIO *pIO)
2061{
icTagTypeSignature sig = GetType();
icUInt32Number zero = 0;

if (!pIO)
 return false;

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

if (m_nASCIISize) {
  if (pIO->Write8(m_szText, m_nASCIISize) != (icInt32Number)m_nASCIISize)
    return false;
}

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

if (m_nUnicodeSize > 1) {
  if (!pIO->Write32(&m_nUnicodeSize) ||
      pIO->Write16(m_uzUnicodeText, m_nUnicodeSize) != (icInt32Number)m_nUnicodeSize)
    return false;
}
else {
  if (!pIO->Write32(&zero))
    return false;
}

if (!pIO->Write16(&m_nScriptCode) ||
    !pIO->Write8(&m_nScriptSize) ||
    pIO->Write8(m_szScriptText, 67)!= 67)
  return false;

m_bInvalidScript = false;

return true;
2099}

2101/**
****************************************************************************
* Name: CIccTagTextDescription::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
2111void CIccTagTextDescription::Describe(std::string &sDescription)
2112{
sDescription += "\"";
if (m_szText && *m_szText)
  sDescription += m_szText;

sDescription += "\"\r\n";
2118}


2121/**
****************************************************************************
* Name: CIccTagTextDescription::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText - zero terminated string to put in tag
*****************************************************************************
*/
2131void CIccTagTextDescription::SetText(const icChar *szText)
2132{
m_bInvalidScript = false;

if (!szText) 
  SetText("");

icUInt32Number len=(icUInt32Number)strlen(szText) + 1;
icChar *szBuf = GetBuffer(len);

strcpy(szBuf, szText);
Release();
2143}

2145/**
****************************************************************************
* Name: CIccTagTextDescription::operator=
* 
* Purpose: Define assignment operator to associate text with tag.
* 
* Args: 
*  szText - zero terminated string to put in the tag
*
* Return: A pointer to the string assigned to the tag.
*****************************************************************************
*/
2157const icChar *CIccTagTextDescription::operator=(const icChar *szText)
2158{
SetText(szText);
return m_szText;
2161}

2163/**
****************************************************************************
* Name: CIccTagTextDescription::GetBuffer
* 
* Purpose: This function allocates room and returns pointer to data buffer to
*  put string into
* 
* Args: 
*  nSize = Requested size of data buffer.
* 
* Return: 
*****************************************************************************
*/
2176icChar *CIccTagTextDescription::GetBuffer(icUInt32Number nSize)
2177{
if (m_nASCIISize < nSize) {
  m_szText = (icChar*)icRealloc(m_szText, nSize+1);

  m_szText[nSize] = '\0';

  m_nASCIISize = nSize;
}

return m_szText;
2187}

2189/**
****************************************************************************
* Name: CIccTagTextDescription::Release
* 
* Purpose: This will resize the buffer to fit the zero terminated string in
*  the buffer.
*****************************************************************************
*/
2197void CIccTagTextDescription::Release()
2198{
icUInt32Number nSize = (icUInt32Number)strlen(m_szText);

if (nSize < m_nASCIISize-1) {
  m_szText=(icChar*)icRealloc(m_szText, nSize+1);
  m_nASCIISize = nSize+1;
}
2205}

2207/**
****************************************************************************
* Name: CIccTagTextDescription::GetUnicodeBuffer
* 
* Purpose: This function allocates room and returns pointer to data buffer to
*  put string into
* 
* Args: 
*  nSize = Requested size of data buffer.
* 
* Return: 
*****************************************************************************
*/
2220icUInt16Number *CIccTagTextDescription::GetUnicodeBuffer(icUInt32Number nSize)
2221{
if (m_nUnicodeSize < nSize) {
  m_uzUnicodeText = (icUInt16Number*)icRealloc(m_uzUnicodeText, (nSize+1)*sizeof(icUInt16Number));

  m_uzUnicodeText[nSize] = 0;

  m_nUnicodeSize = nSize;
}

return m_uzUnicodeText;
2231}

2233/**
****************************************************************************
* Name: CIccTagTextDescription::ReleaseUnicode
* 
* Purpose: This will resize the buffer to fit the zero terminated string in
*  the buffer.
*****************************************************************************
*/
2241void CIccTagTextDescription::ReleaseUnicode()
2242{
int i;
for (i=0; m_uzUnicodeText[i]; i++);

icUInt32Number nSize = i+1;

if (nSize < m_nUnicodeSize-1) {
  m_uzUnicodeText=(icUInt16Number*)icRealloc(m_uzUnicodeText, (nSize+1)*sizeof(icUInt16Number));
  m_nUnicodeSize = nSize+1;
}
2252}


2255/**
2256******************************************************************************
2257* Name: CIccTagTextDescription::Validate
2258* 
2259* Purpose: Check tag data validity.
2260* 
2261* Args: 
2262*  sig = signature of tag being validated,
2263*  sReport = String to add report information to
2264* 
2265* Return: 
2266*  icValidateStatusOK if valid, or other error status.
2267******************************************************************************
2268*/
2269icValidateStatus CIccTagTextDescription::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
2270{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (m_nScriptSize>67) {
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - ScriptCode count must not be greater than 67.\r\n";

  rv =icMaxStatus(rv, icValidateNonCompliant);
}

if (m_bInvalidScript) {
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - ScriptCode must contain 67 bytes.\r\n";

  rv =icMaxStatus(rv, icValidateNonCompliant);
}

return rv;
2293}

2295/**
****************************************************************************
* Name: CIccTagSignature::CIccTagSignature
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
2303CIccTagSignature::CIccTagSignature()
2304{
m_nSig = 0x3f3f3f3f; //'????';
2306}



2310/**
****************************************************************************
* Name: CIccTagSignature::CIccTagSignature
* 
* Purpose: Copy Constructor
*
* Args:
*  ITS = The CIccTagSignature object to be copied
*****************************************************************************
*/
2320CIccTagSignature::CIccTagSignature(const CIccTagSignature &ITS)
2321{
m_nSig = ITS.m_nSig;
2323}



2327/**
****************************************************************************
* Name: CIccTagSignature::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  SignatureTag = The CIccTagSignature object to be copied
*****************************************************************************
*/
2337CIccTagSignature &CIccTagSignature::operator=(const CIccTagSignature &SignatureTag)
2338{
if (&SignatureTag == this)
  return *this;

m_nSig = SignatureTag.m_nSig;

return *this;
2345}


2348/**
****************************************************************************
* Name: CIccTagSignature::~CIccTagSignature
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
2356CIccTagSignature::~CIccTagSignature()
2357{
2358}

2360/**
****************************************************************************
* Name: CIccTagSignature::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
2374bool CIccTagSignature::Read(icUInt32Number size, CIccIO *pIO)
2375{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 2*sizeof(icUInt32Number) > size)
  return false;

if (!pIO) {
  m_nSig = 0x3f3f3f3f; //'????';
  return false;
}

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

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

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

return true;
2396}

2398/**
****************************************************************************
* Name: CIccTagSignature::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
2411bool CIccTagSignature::Write(CIccIO *pIO)
2412{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

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

return true;
2428}


2431/**
****************************************************************************
* Name: CIccTagSignature::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
2441void CIccTagSignature::Describe(std::string &sDescription)
2442{
CIccInfo Fmt;

sDescription += Fmt.GetSigName(m_nSig);
sDescription += "\r\n";
2447}


2450/**
2451******************************************************************************
2452* Name: CIccTagSignature::Validate
2453* 
2454* Purpose: Check tag data validity.
2455* 
2456* Args: 
2457*  sig = signature of tag being validated,
2458*  sReport = String to add report information to
2459* 
2460* Return: 
2461*  icValidateStatusOK if valid, or other error status.
2462******************************************************************************
2463*/
2464icValidateStatus CIccTagSignature::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
2465{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);
icSignature sig = icGetFirstSigPathSig(sigPath);
char buf[128];

if (sig==icSigTechnologyTag) {
  switch(m_nSig) {
  case icSigFilmScanner:
  case icSigDigitalCamera:
  case icSigReflectiveScanner:
  case icSigInkJetPrinter:
  case icSigThermalWaxPrinter:
  case icSigElectrophotographicPrinter:
  case icSigElectrostaticPrinter:
  case icSigDyeSublimationPrinter:
  case icSigPhotographicPaperPrinter:
  case icSigFilmWriter:
  case icSigVideoMonitor:
  case icSigVideoCamera:
  case icSigProjectionTelevision:
  case icSigCRTDisplay:
  case icSigPMDisplay:
  case icSigAMDisplay:
  case icSigPhotoCD:
  case icSigPhotoImageSetter:
  case icSigGravure:
  case icSigOffsetLithography:
  case icSigSilkscreen:
  case icSigFlexography:
  case icSigMotionPictureFilmScanner:
  case icSigMotionPictureFilmRecorder:
  case icSigDigitalMotionPictureCamera:
  case icSigDigitalCinemaProjector:
    break;

  default:
    {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sprintf(buf, " - %s: Unknown Technology.\r\n", Info.GetSigName(m_nSig));
      sReport += buf;
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
  }
}
else if (sig==icSigPerceptualRenderingIntentGamutTag ||
         sig==icSigSaturationRenderingIntentGamutTag) {
  switch(m_nSig) {
  case icSigPerceptualReferenceMediumGamut:
    break;

  default:
    {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sprintf(buf, " - %s: Unknown Reference Medium Gamut.\r\n", Info.GetSigName(m_nSig));
      sReport += buf;
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
  }
}
else if (sig==icSigColorimetricIntentImageStateTag) {
  switch(m_nSig) {
    case icSigSceneColorimetryEstimates:
    case icSigSceneAppearanceEstimates:
    case icSigFocalPlaneColorimetryEstimates:
    case icSigReflectionHardcopyOriginalColorimetry:
    case icSigReflectionPrintOutputColorimetry:
      break;

    default:
    {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sprintf(buf, " - %s: Unknown Colorimetric Intent Image State.\r\n", Info.GetSigName(m_nSig));
      sReport += buf;
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
  }
}


return rv;
2551}

2553/**
****************************************************************************
* Name: CIccTagNamedColor2::CIccTagNamedColor2
* 
* Purpose: Constructor
* 
* Args:
*  nSize = number of named color entries,
*  nDeviceCoords = number of device channels
*****************************************************************************
*/
2564CIccTagNamedColor2::CIccTagNamedColor2(int nSize/*=1*/, int nDeviceCoords/*=0*/)
2565{
m_nSize = nSize <1 ? 1 : nSize;
m_nVendorFlags = 0;
m_nDeviceCoords = nDeviceCoords;
if (nDeviceCoords<0)
  m_nDeviceCoords = nDeviceCoords = 0;

if (nDeviceCoords>0)
  nDeviceCoords--;

m_szPrefix[0] = '\0';
m_szSufix[0] = '\0';
m_csPCS = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
m_csDevice = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);

m_nColorEntrySize = 32/*rootName*/ + (3/*PCS*/ + 1/*iAny*/ + nDeviceCoords)*sizeof(icFloatNumber);

m_NamedColor = (SIccNamedColorEntry*)calloc(nSize, m_nColorEntrySize);

m_NamedLab = NULL__null;
2585}


2588/**
****************************************************************************
* Name: CIccTagNamedColor2::CIccTagNamedColor2
* 
* Purpose: Copy Constructor
*
* Args:
*  ITNC = The CIccTagNamedColor2 object to be copied
*****************************************************************************
*/
2598CIccTagNamedColor2::CIccTagNamedColor2(const CIccTagNamedColor2 &ITNC)
2599{
m_nColorEntrySize = ITNC.m_nColorEntrySize;
m_nVendorFlags = ITNC.m_nVendorFlags;
m_nDeviceCoords = ITNC.m_nDeviceCoords;
m_nSize = ITNC.m_nSize;

m_csPCS = ITNC.m_csPCS;
m_csDevice = ITNC.m_csDevice;

memcpy(m_szPrefix, ITNC.m_szPrefix, sizeof(m_szPrefix));
memcpy(m_szSufix, ITNC.m_szSufix, sizeof(m_szSufix));

m_NamedColor = (SIccNamedColorEntry*)calloc(m_nSize, m_nColorEntrySize);
memcpy(m_NamedColor, ITNC.m_NamedColor, m_nColorEntrySize*m_nSize);

m_NamedLab = NULL__null;
2615}


2618/**
****************************************************************************
* Name: CIccTagNamedColor2::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  NamedColor2Tag = The CIccTagNamedColor2 object to be copied
*****************************************************************************
*/
2628CIccTagNamedColor2 &CIccTagNamedColor2::operator=(const CIccTagNamedColor2 &NamedColor2Tag)
2629{
if (&NamedColor2Tag == this)
  return *this;

m_nColorEntrySize = NamedColor2Tag.m_nColorEntrySize;
m_nVendorFlags = NamedColor2Tag.m_nVendorFlags;
m_nDeviceCoords = NamedColor2Tag.m_nDeviceCoords;
m_nSize = NamedColor2Tag.m_nSize;

m_csPCS = NamedColor2Tag.m_csPCS;
m_csDevice = NamedColor2Tag.m_csDevice;

memcpy(m_szPrefix, NamedColor2Tag.m_szPrefix, sizeof(m_szPrefix));
memcpy(m_szSufix, NamedColor2Tag.m_szSufix, sizeof(m_szSufix));

if (m_NamedColor)
  free(m_NamedColor);
m_NamedColor = (SIccNamedColorEntry*)calloc(m_nSize, m_nColorEntrySize);
memcpy(m_NamedColor, NamedColor2Tag.m_NamedColor, m_nColorEntrySize*m_nSize);

m_NamedLab = NULL__null;

return *this;
2652}


2655/**
****************************************************************************
* Name: CIccTagNamedColor2::~CIccTagNamedColor2
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
2663CIccTagNamedColor2::~CIccTagNamedColor2()
2664{
if (m_NamedColor)
  free(m_NamedColor);

if (m_NamedLab)
  delete [] m_NamedLab;
2670}

2672/**
****************************************************************************
* Name: CIccTagNamedColor2::SetSize
* 
* Purpose: Sets the size of the named color array.
* 
* Args: 
*  nSize - number of named color entries,
*  nDeviceCoords - number of device channels
*****************************************************************************
*/
2683bool CIccTagNamedColor2::SetSize(icUInt32Number nSize, icInt32Number nDeviceCoords/*=-1*/)
2684{
if (nSize <1)
  nSize = 1;
if (nDeviceCoords<0)
  nDeviceCoords = m_nDeviceCoords;

icInt32Number nNewCoords=nDeviceCoords;

if (nDeviceCoords>0)
  nDeviceCoords--;

icUInt32Number nColorEntrySize = 32/*rootName*/ + (3/*PCS*/ + 1/*iAny*/ + nDeviceCoords)*sizeof(icFloatNumber);

SIccNamedColorEntry* pNamedColor = (SIccNamedColorEntry*)calloc(nSize, nColorEntrySize);

if (!pNamedColor)
  return false;

icUInt32Number i, nCopy = __minmin(nSize, m_nSize);
icUInt32Number j, nCoords = __minmin(nNewCoords, (icInt32Number)m_nDeviceCoords);

for (i=0; i<nCopy; i++) {
  SIccNamedColorEntry *pFrom = (SIccNamedColorEntry*)((icChar*)m_NamedColor + i*m_nColorEntrySize);
  SIccNamedColorEntry *pTo = (SIccNamedColorEntry*)((icChar*)pNamedColor + i*nColorEntrySize);

  strcpy(pTo->rootName, pFrom->rootName);
  for (j=0; j<3; j++)
    pTo->pcsCoords[j] = pFrom->pcsCoords[j];

  for (j=0; j<nCoords; j++) {
    pTo->deviceCoords[j] = pFrom->deviceCoords[j];
  }
}
free(m_NamedColor);

m_nColorEntrySize = nColorEntrySize;

m_NamedColor = pNamedColor;
m_nSize = nSize;
m_nDeviceCoords = nNewCoords;

ResetPCSCache();

return true;
2728}


2731/**
2732****************************************************************************
2733* Name: CIccTagNamedColor2::SetPrefix
2734* 
2735* Purpose: Set contents of suffix member field
2736* 
2737* Args:
2738*  szPrefix - string to set prefix to
2739*****************************************************************************
2740*/
2741void CIccTagNamedColor2::SetPrefix(const icChar *szPrefix)
2742{
strncpy(m_szPrefix, szPrefix, sizeof(m_szPrefix));
m_szPrefix[sizeof(m_szPrefix)-1]='\0';
2745}


2748/**
2749****************************************************************************
2750* Name: CIccTagNamedColor2::SetSufix
2751* 
2752* Purpose: Set contents of suffix member field
2753* 
2754* Args:
2755*  szPrefix - string to set prefix to
2756*****************************************************************************
2757*/
2758void CIccTagNamedColor2::SetSufix(const icChar *szSufix)
2759{
strncpy(m_szSufix, szSufix, sizeof(m_szSufix));
m_szSufix[sizeof(m_szSufix)-1]='\0';
2762}


2765/**
****************************************************************************
* Name: CIccTagNamedColor2::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
2779bool CIccTagNamedColor2::Read(icUInt32Number size, CIccIO *pIO)
2780{
icTagTypeSignature sig;
icUInt32Number nNum, nCoords;

icUInt32Number nTagHdrSize = sizeof(icTagTypeSignature) + 
                             sizeof(icUInt32Number) + //m_nReserved=0
                             sizeof(icUInt32Number) + //VendorFlags
                             sizeof(icUInt32Number) + //Num Colors
                             sizeof(icUInt32Number) + //Num Device Coords
                             sizeof(m_szPrefix) + 
                             sizeof(m_szSufix); 
if (nTagHdrSize > size)
  return false;

if (!pIO) {
  return false;
}

if (!pIO->Read32(&sig) ||
    !pIO->Read32(&m_nReserved) ||
    !pIO->Read32(&m_nVendorFlags) ||
    !pIO->Read32(&nNum) ||
    !pIO->Read32(&nCoords) ||
    pIO->Read8(m_szPrefix, sizeof(m_szPrefix))!=sizeof(m_szPrefix) ||
    pIO->Read8(m_szSufix, sizeof(m_szSufix))!=sizeof(m_szSufix)) {
  return false;
}

size -= nTagHdrSize;

icUInt32Number nCount = size / (32+(3+nCoords)*sizeof(icUInt16Number));

if (nCount < nNum)
  return false;

if (!SetSize(nNum, nCoords))
  return false;

icUInt32Number i;
SIccNamedColorEntry *pNamedColor=m_NamedColor;

for (i=0; i<nNum; i++) {
  if (pIO->Read8(&pNamedColor->rootName, sizeof(pNamedColor->rootName))!=sizeof(pNamedColor->rootName) ||
      pIO->ReadUInt16Float(&pNamedColor->pcsCoords, 3)!=3)
    return false;
  if (nCoords) {
    if (pIO->ReadUInt16Float(&pNamedColor->deviceCoords, nCoords)!=(icInt32Number)nCoords)
      return false;
  }
  pNamedColor = (SIccNamedColorEntry*)((icChar*)pNamedColor + m_nColorEntrySize);
}

return true;
2833}


2836/**
****************************************************************************
* Name: CIccTagNamedColor2::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
2849bool CIccTagNamedColor2::Write(CIccIO *pIO)
2850{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

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

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

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

if (!pIO->Write8(m_szPrefix, sizeof(m_szPrefix)))
  return false;

if (!pIO->Write8(m_szSufix, sizeof(m_szSufix)))
  return false;

icUInt32Number i;
SIccNamedColorEntry *pNamedColor=m_NamedColor;

for (i=0; i<m_nSize; i++) {
  if (pIO->Write8(&pNamedColor->rootName, sizeof(pNamedColor->rootName))!=sizeof(pNamedColor->rootName) ||
      pIO->WriteUInt16Float(&pNamedColor->pcsCoords, 3)!=3)
    return false;
  if (m_nDeviceCoords) {
    if (pIO->WriteUInt16Float(&pNamedColor->deviceCoords, m_nDeviceCoords) != (icInt32Number)m_nDeviceCoords)
      return false;
  }
  pNamedColor = (SIccNamedColorEntry*)((icChar*)pNamedColor + m_nColorEntrySize);
}

return true;
2892}


2895/**
****************************************************************************
* Name: CIccTagNamedColor2::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
2905void CIccTagNamedColor2::Describe(std::string &sDescription)
2906{
icChar buf[128], szColorVal[40], szColor[40];

icUInt32Number i, j;
SIccNamedColorEntry *pNamedColor=m_NamedColor;

sDescription.reserve(sDescription.size() + m_nSize*79);

sprintf(buf, "BEGIN_NAMED_COLORS flags=%08x %u %u\r\n", m_nVendorFlags, m_nSize, m_nDeviceCoords);
sDescription += buf;

sprintf(buf, "Prefix=\"%s\"\r\n", m_szPrefix);
sDescription += buf;

sprintf(buf, "Sufix= \"%s\"\r\n", m_szSufix);
sDescription += buf;

for (i=0; i<m_nSize; i++) {
  sprintf(buf, "Color[%u]: %s :", i, pNamedColor->rootName);
  sDescription += buf;
  
  icFloatNumber pcsCoord[3];
  for (j=0; j<3; j++)
    pcsCoord[j] = pNamedColor->pcsCoords[j];

  if (m_csPCS==icSigLabData) {
    for (j=0; j<3; j++)
      pcsCoord[j] = (icFloatNumber)(pcsCoord[j] * 65535.0 / 65280.0);
  }

  for (j=0; j<3; j++) {
    icColorIndexName(szColor, m_csPCS, j, 3, "P");
    icColorValue(szColorVal, pcsCoord[j], m_csPCS, j);
    sprintf(buf, " %s=%s", szColor, szColorVal);
    sDescription += buf;
  }
  if (m_nDeviceCoords) {
    sDescription += " :";
    for (j=0; j<m_nDeviceCoords; j++) {
      icColorIndexName(szColor, m_csDevice, j, m_nDeviceCoords, "D");
      icColorValue(szColorVal, pNamedColor->deviceCoords[j], m_csDevice, j);
      sprintf(buf, " %s=%s", szColor, szColorVal);
      sDescription += buf;
    }
  }
  sDescription += "\r\n";

  pNamedColor = (SIccNamedColorEntry*)((icChar*)pNamedColor + m_nColorEntrySize);
}
2955}

2957/**
****************************************************************************
* Name: CIccTagNamedColor2::SetColorSpaces
* 
* Purpose: Set the device and PCS color space of the tag
* 
* Args: 
*  csPCS = PCS color space signature,
*  csDevice = Device color space signature
* 
*****************************************************************************
*/
2969void CIccTagNamedColor2::SetColorSpaces(icColorSpaceSignature csPCS, icColorSpaceSignature csDevice)
2970{
 m_csPCS = csPCS;
 m_csDevice = csDevice;
2973}

2975/**
****************************************************************************
* Name: CIccTagNamedColor2::FindRootColor
* 
* Purpose: Find the root color name
* 
* Args: 
*  szRootColor = string containing the root color name to be found
* 
* Return: Index of the named color array where the root color name was found,
*  if the color was not found -1 is returned
*****************************************************************************
*/
2988icInt32Number CIccTagNamedColor2::FindRootColor(const icChar *szRootColor) const
2989{
for (icUInt32Number i=0; i<m_nSize; i++) {
  if (stricmpstrcasecmp(m_NamedColor[i].rootName,szRootColor) == 0)
    return i;
}

return -1;
2996}

2998/**
****************************************************************************
* Name: CIccTagNamedColor2::ResetPCSCache
* 
* Purpose: This function is called if entry values change between calls
*  to FindPCSColor()
* 
*****************************************************************************
*/
3007void CIccTagNamedColor2::ResetPCSCache()
3008{
if (m_NamedLab) {
  delete [] m_NamedLab;
  m_NamedLab = NULL__null;
}
3013}

3015/**
3016****************************************************************************
3017* Name: CIccTagNamedColor2::InitFindPCSColor
3018* 
3019* Purpose: Initialization needed for using FindPCSColor
3020* 
3021* Return: 
3022*  true if successfull, false if failure
3023*****************************************************************************
3024*/
3025bool CIccTagNamedColor2::InitFindCachedPCSColor()
3026{
icFloatNumber *pXYZ, *pLab;

if (!m_NamedLab) {
  m_NamedLab = new SIccNamedLabEntry[m_nSize];
  if (!m_NamedLab)
    return false;

  if (m_csPCS != icSigLabData) {
    for (icUInt32Number i=0; i<m_nSize; i++) {
      pLab = m_NamedLab[i].lab;
      pXYZ = m_NamedColor[i].pcsCoords;
      icXyzFromPcs(pXYZ);
      icXYZtoLab(pLab, pXYZ);
    }
  }
  else {
    for (icUInt32Number i=0; i<m_nSize; i++) {
      pLab = m_NamedLab[i].lab;
      Lab2ToLab4(pLab, m_NamedColor[i].pcsCoords);
      icLabFromPcs(pLab);
    }
  }
}

return true;
3052}

3054/**
****************************************************************************
* Name: CIccTagNamedColor2::FindPCSColor
* 
* Purpose: Find the PCS color within the specified deltaE
* 
* Args: 
*  pPCS = PCS co-ordinates,
*  dMinDE = the minimum deltaE (tolerance)
* 
* Return: Index of the named color array where the PCS color was found,
*  if the color was not found within the tolerance -1 is returned
*****************************************************************************
*/
3068icInt32Number CIccTagNamedColor2::FindCachedPCSColor(icFloatNumber *pPCS, icFloatNumber dMinDE/*=1000.0*/) const
3069{
icFloatNumber dCalcDE, dLeastDE=0.0;
icFloatNumber pLabIn[3];
icFloatNumber *pXYZ, *pLab;
icInt32Number leastDEindex = -1;
if (m_csPCS != icSigLabData) {
  pXYZ = pPCS;
  icXyzFromPcs(pXYZ);
  icXYZtoLab(pLabIn,pXYZ);
}
else {
  Lab2ToLab4(pLabIn, pPCS);
  icLabFromPcs(pLabIn);
}

if (!m_NamedLab)
  return -1;

for (icUInt32Number i=0; i<m_nSize; i++) {
  pLab = m_NamedLab[i].lab;

  dCalcDE = icDeltaE(pLabIn, pLab);

  if (i==0) {
    dLeastDE = dCalcDE;
    leastDEindex = i;
  }

  if (dCalcDE<dMinDE) {
    if (dCalcDE<dLeastDE) {
      dLeastDE = dCalcDE;
      leastDEindex = i;
    }      
  }
}

return leastDEindex;
3106}

3108/**
3109****************************************************************************
3110* Name: CIccTagNamedColor2::FindPCSColor
3111* 
3112* Purpose: Find the PCS color within the specified deltaE
3113* 
3114* Args: 
3115*  pPCS = PCS co-ordinates,
3116*  dMinDE = the minimum deltaE (tolerance)
3117* 
3118* Return: Index of the named color array where the PCS color was found,
3119*  if the color was not found within the tolerance -1 is returned
3120*****************************************************************************
3121*/
3122icInt32Number CIccTagNamedColor2::FindPCSColor(icFloatNumber *pPCS, icFloatNumber dMinDE/*=1000.0*/)
3123{
if (!m_NamedLab)
  InitFindCachedPCSColor();

return FindCachedPCSColor(pPCS, dMinDE);
3128}

3130/**
****************************************************************************
* Name: CIccTagNamedColor2::FindColor
* 
* Purpose: Find the color with given name
* 
* Args: 
*  szColor = the color name
* 
* Return: Index of the named color array where the color name was found,
*  if the color was not found -1 is returned
*****************************************************************************
*/
3143icInt32Number CIccTagNamedColor2::FindColor(const icChar *szColor) const
3144{
std::string sColorName;
icInt32Number i, j;

j = (icInt32Number)strlen(m_szPrefix);
if (j != 0) {  
  if (strncmp(szColor, m_szPrefix, j))
    return -1;
}

j = (icInt32Number)strlen(m_szSufix);
i = (icInt32Number)strlen(szColor);
if (j != 0) {
  if (strncmp(szColor+(i-j), m_szSufix, j))
    return -1;    
}


for ( i=0; i<(icInt32Number)m_nSize; i++) {
  sColorName = m_szPrefix;
  sColorName += m_NamedColor[i].rootName;
  sColorName += m_szSufix;

  if (strcmp(sColorName.c_str(),szColor) == 0)
    return i;
}

return -1;
3172}

3174/**
****************************************************************************
* Name: CIccTagNamedColor2::FindDeviceColor
* 
* Purpose: Find the device color
* 
* Args: 
*  pDevColor = device color co-ordinates
* 
* Return: Index of the named color array where the closest device color
*  was found, if device representation is absent -1 is returned.
*****************************************************************************
*/
3187icInt32Number CIccTagNamedColor2::FindDeviceColor(icFloatNumber *pDevColor) const
3188{
if (!m_nDeviceCoords)
  return -1;

icFloatNumber dCalcDiff=0.0, dLeastDiff=0.0;
icFloatNumber *pDevOut;
icInt32Number leastDiffindex = -1;


for (icUInt32Number i=0; i<m_nSize; i++) {
  pDevOut = m_NamedColor[i].deviceCoords;

  for (icUInt32Number j=0; j<m_nDeviceCoords; j++) {
    dCalcDiff += (pDevColor[j]-pDevOut[j])*(pDevColor[j]-pDevOut[j]);
  }
  dCalcDiff = (icFloatNumber)sqrt(dCalcDiff);

  if (i==0) {
    dLeastDiff = dCalcDiff;
    leastDiffindex = i;
  }

  if (dCalcDiff<dLeastDiff) {
    dLeastDiff = dCalcDiff;
    leastDiffindex = i;
  }      

  dCalcDiff = 0.0;
}

return leastDiffindex;
3219}

3221/**
****************************************************************************
* Name: CIccTagNamedColor2::GetColorName
* 
* Purpose: Extracts the color name from the named color array
* 
* Args: 
*  sColorName = string where color name will be stored,
*  index = array index of the color name
* 
* Return: 
*  true = if the index is within range,
*  false = index out of range
*****************************************************************************
*/
3236bool CIccTagNamedColor2::GetColorName(std::string &sColorName, icInt32Number index) const
3237{
if (index > (icInt32Number)m_nSize-1)
  return false;

sColorName += m_szPrefix;
SIccNamedColorEntry * pNamedColor = (SIccNamedColorEntry*)((icChar*)m_NamedColor + m_nColorEntrySize * index);
sColorName += pNamedColor->rootName;
sColorName += m_szSufix;

return true;
3247}

3249/**
****************************************************************************
* Name: CIccTagNamedColor2::UnitClip
* 
* Purpose: Clip number so that its between 0-1
* 
* Args: 
*  v = number to be clipped
* 
* Return: Clipped number
*  
*****************************************************************************
*/
3262icFloatNumber CIccTagNamedColor2::UnitClip(icFloatNumber v) const
3263{
if (v<0)
  v = 0;
if (v>1.0)
  v = 1.0;

return v;
3270}

3272/**
****************************************************************************
* Name: CIccTagNamedColor2::NegClip
* 
* Purpose: Negative numbers are clipped to zero
* 
* Args: 
*  v = number to be clipped
* 
* Return: Clipped number
*  
*****************************************************************************
*/
3285icFloatNumber CIccTagNamedColor2::NegClip(icFloatNumber v) const
3286{
if (v<0)
  v=0;

return v;
3291}


3294/**
****************************************************************************
* Name: CIccTagNamedColor2::Lab2ToLab4
* 
* Purpose: Convert version 2 Lab to version 4 Lab
* 
* Args: 
*  Dst = array to store version 4 Lab coordinates,
*  Src = array containing version 2 Lab coordinates
* 
*****************************************************************************
*/
3306void CIccTagNamedColor2::Lab2ToLab4(icFloatNumber *Dst, const icFloatNumber *Src) const
3307{
Dst[0] = UnitClip((icFloatNumber)(Src[0] * 65535.0 / 65280.0));
Dst[1] = UnitClip((icFloatNumber)(Src[1] * 65535.0 / 65280.0));
Dst[2] = UnitClip((icFloatNumber)(Src[2] * 65535.0 / 65280.0));
3311}

3313/**
****************************************************************************
* Name: CIccTagNamedColor2::Lab4ToLab2
* 
* Purpose: Convert version 4 Lab to version 2 Lab
* 
* Args: 
*  Dst = array to store version 2 Lab coordinates,
*  Src = array containing version 4 Lab coordinates
* 
*****************************************************************************
*/
3325void CIccTagNamedColor2::Lab4ToLab2(icFloatNumber *Dst, const icFloatNumber *Src) const
3326{
Dst[0] = (icFloatNumber)(Src[0] * 65280.0 / 65535.0);
Dst[1] = (icFloatNumber)(Src[1] * 65280.0 / 65535.0);
Dst[2] = (icFloatNumber)(Src[2] * 65280.0 / 65535.0);
3330}


3333/**
3334******************************************************************************
3335* Name: CIccTagNamedColor2::Validate
3336* 
3337* Purpose: Check tag data validity.
3338* 
3339* Args: 
3340*  sig = signature of tag being validated,
3341*  sReport = String to add report information to
3342* 
3343* Return: 
3344*  icValidateStatusOK if valid, or other error status.
3345******************************************************************************
3346*/
3347icValidateStatus CIccTagNamedColor2::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
3348{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!m_nSize) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty tag!\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}

if (m_nDeviceCoords) {
  if (pProfile) {
    icUInt32Number nCoords = icGetSpaceSamples(pProfile->m_Header.colorSpace);
    if (m_nDeviceCoords != nCoords) {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sReport += " - Incorrect number of device co-ordinates.\r\n";
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
  }
  else {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " - Tag validation incomplete: Pointer to profile unavailable.\r\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
}


return rv;
3381}


3384/**
****************************************************************************
* Name: CIccTagXYZ::CIccTagXYZ
* 
* Purpose: Constructor
*
* Args:
*  nSize = number of XYZ entries
* 
*****************************************************************************
*/
3395CIccTagXYZ::CIccTagXYZ(int nSize/*=1*/)
3396{
m_nSize = nSize;
if (m_nSize <1)
  m_nSize = 1;
m_XYZ = (icXYZNumber*)calloc(nSize, sizeof(icXYZNumber));
3401}


3404/**
****************************************************************************
* Name: CIccTagXYZ::CIccTagXYZ
* 
* Purpose: Copy Constructor
*
* Args:
*  ITXYZ = The CIccTagXYZ object to be copied
*****************************************************************************
*/
3414CIccTagXYZ::CIccTagXYZ(const CIccTagXYZ &ITXYZ)
3415{
m_nSize = ITXYZ.m_nSize;

m_XYZ = (icXYZNumber*)calloc(m_nSize, sizeof(icXYZNumber));
memcpy(m_XYZ, ITXYZ.m_XYZ, sizeof(icXYZNumber)*m_nSize);
3420}



3424/**
****************************************************************************
* Name: CIccTagXYZ::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  XYZTag = The CIccTagXYZ object to be copied
*****************************************************************************
*/
3434CIccTagXYZ &CIccTagXYZ::operator=(const CIccTagXYZ &XYZTag)
3435{
if (&XYZTag == this)
  return *this;

m_nSize = XYZTag.m_nSize;

if (m_XYZ)
  free(m_XYZ);
m_XYZ = (icXYZNumber*)calloc(m_nSize, sizeof(icXYZNumber));
memcpy(m_XYZ, XYZTag.m_XYZ, sizeof(icXYZNumber)*m_nSize);

return *this;
3447}


3450/**
****************************************************************************
* Name: CIccTagXYZ::~CIccTagXYZ
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
3458CIccTagXYZ::~CIccTagXYZ()
3459{
if (m_XYZ)
  free(m_XYZ);
3462}


3465/**
****************************************************************************
* Name: CIccTagXYZ::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
3479bool CIccTagXYZ::Read(icUInt32Number size, CIccIO *pIO)
3480{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icXYZNumber) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

icUInt32Number nNum=((size-2*sizeof(icUInt32Number)) / sizeof(icXYZNumber));
icUInt32Number nNum32 = nNum*sizeof(icXYZNumber)/sizeof(icUInt32Number);

if (!SetSize(nNum))
  return false;

if (pIO->Read32(m_XYZ, nNum32) != (icInt32Number)nNum32 )
  return false;

return true;
3508}


3511/**
****************************************************************************
* Name: CIccTagXYZ::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
3524bool CIccTagXYZ::Write(CIccIO *pIO)
3525{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

icUInt32Number nNum32 = m_nSize * sizeof(icXYZNumber)/sizeof(icUInt32Number);

if (
  pIO->Write32(m_XYZ, nNum32) != (icInt32Number)nNum32)
  return false;

return true;
3544}


3547/**
****************************************************************************
* Name: CIccTagXYZ::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
3557void CIccTagXYZ::Describe(std::string &sDescription)
3558{
icChar buf[128];

if (m_nSize == 1 ) {
  sprintf(buf, "X=%.4lf, Y=%.4lf, Z=%.4lf\r\n", icFtoD(m_XYZ[0].X), icFtoD(m_XYZ[0].Y), icFtoD(m_XYZ[0].Z));
  sDescription += buf;
}
else {
  icUInt32Number i;
  sDescription.reserve(sDescription.size() + m_nSize*79);

  for (i=0; i<m_nSize; i++) {
    sprintf(buf, "value[%u]: X=%.4lf, Y=%.4lf, Z=%.4lf\r\n", i, icFtoD(m_XYZ[i].X), icFtoD(m_XYZ[i].Y), icFtoD(m_XYZ[i].Z));
    sDescription += buf;
  }
}
3574}

3576/**
****************************************************************************
* Name: CIccTagXYZ::SetSize
* 
* Purpose: Sets the size of the XYZ array.
* 
* Args: 
*  nSize - number of XYZ entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
3587bool CIccTagXYZ::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
3588{
if (nSize==m_nSize)
  return true;

m_XYZ = (icXYZNumber*)icRealloc(m_XYZ, nSize*sizeof(icXYZNumber));

if (!m_XYZ) {
  m_nSize = 0;
  return false;
}

if (bZeroNew && m_nSize < nSize) {
  memset(&m_XYZ[m_nSize], 0, (nSize-m_nSize)*sizeof(icXYZNumber));
}
m_nSize = nSize;

return true;
3605}


3608/**
3609******************************************************************************
3610* Name: CIccTagXYZ::Validate
3611* 
3612* Purpose: Check tag data validity.
3613* 
3614* Args: 
3615*  sig = signature of tag being validated,
3616*  sReport = String to add report information to
3617* 
3618* Return: 
3619*  icValidateStatusOK if valid, or other error status.
3620******************************************************************************
3621*/
3622icValidateStatus CIccTagXYZ::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
3623{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!m_nSize) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty tag.\r\n";

  rv = icMaxStatus(rv, icValidateWarning);
  return rv;
}

for (int i=0; i<(int)m_nSize; i++) {
  rv = icMaxStatus(rv, Info.CheckData(sReport, m_XYZ[i], sSigPathName + ":XYZ"));
}

return rv;
3643}


3646/**
****************************************************************************
* Name: CIccTagChromaticity::CIccTagChromaticity
* 
* Purpose: Constructor
*
* Args:
*  nSize = number of xy entries
* 
*****************************************************************************
*/
3657CIccTagChromaticity::CIccTagChromaticity(int nSize/*=3*/)
3658{
m_nChannels = nSize;
if (m_nChannels <3)
  m_nChannels = 3;
m_xy = (icChromaticityNumber*)calloc(nSize, sizeof(icChromaticityNumber));
3663}


3666/**
****************************************************************************
* Name: CIccTagChromaticity::CIccTagChromaticity
* 
* Purpose: Copy Constructor
*
* Args:
*  ITCh = The CIccTagChromaticity object to be copied
*****************************************************************************
*/
3676CIccTagChromaticity::CIccTagChromaticity(const CIccTagChromaticity &ITCh)
3677{
m_nChannels = ITCh.m_nChannels;

m_xy = (icChromaticityNumber*)calloc(m_nChannels, sizeof(icChromaticityNumber));
memcpy(m_xy, ITCh.m_xy, sizeof(icChromaticityNumber)*m_nChannels);
3682}


3685/**
****************************************************************************
* Name: CIccTagChromaticity::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ChromTag = The CIccTagChromaticity object to be copied
*****************************************************************************
*/
3695CIccTagChromaticity &CIccTagChromaticity::operator=(const CIccTagChromaticity &ChromTag)
3696{
if (&ChromTag == this)
  return *this;

m_nChannels = ChromTag.m_nChannels;

if (m_xy)
  free(m_xy);
m_xy = (icChromaticityNumber*)calloc(m_nChannels, sizeof(icChromaticityNumber));
memcpy(m_xy, ChromTag.m_xy, sizeof(icChromaticityNumber)*m_nChannels);

return *this;  
3708}


3711/**
****************************************************************************
* Name: CIccTagChromaticity::~CIccTagChromaticity
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
3719CIccTagChromaticity::~CIccTagChromaticity()
3720{
if (m_xy)
  free(m_xy);
3723}


3726/**
****************************************************************************
* Name: CIccTagChromaticity::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
3740bool CIccTagChromaticity::Read(icUInt32Number size, CIccIO *pIO)
3741{
icTagTypeSignature sig;
icUInt16Number nChannels;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icUInt32Number) +
    sizeof(icChromaticityNumber) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

if (!pIO->Read16(&nChannels) ||
    !pIO->Read16(&m_nColorantType))
  return false;

icUInt32Number nNum = (size-3*sizeof(icUInt32Number)) / sizeof(icChromaticityNumber);
icUInt32Number nNum32 = nNum*sizeof(icChromaticityNumber)/sizeof(icU16Fixed16Number);

if (nNum < nChannels)
  return false;

if (!SetSize((icUInt16Number)nNum))
  return false;

if (pIO->Read32(&m_xy[0], nNum32) != (icInt32Number)nNum32 )
  return false;

return true;
3778}


3781/**
****************************************************************************
* Name: CIccTagChromaticity::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
3794bool CIccTagChromaticity::Write(CIccIO *pIO)
3795{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

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

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

icUInt32Number nNum32 = m_nChannels*sizeof(icChromaticityNumber)/sizeof(icU16Fixed16Number);

if (pIO->Write32(&m_xy[0], nNum32) != (icInt32Number)nNum32)
  return false;

return true;
3819}


3822/**
****************************************************************************
* Name: CIccTagChromaticity::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
3832void CIccTagChromaticity::Describe(std::string &sDescription)
3833{
icChar buf[128];
CIccInfo Fmt;

icUInt32Number i;
//sDescription.reserve(sDescription.size() + m_nChannels*79);
sprintf(buf, "Number of Channels : %u\r\n", m_nChannels);
sDescription += buf;

sprintf(buf, "Colorant Encoding : %s\r\n", Fmt.GetColorantEncoding((icColorantEncoding)m_nColorantType));
sDescription += buf;

for (i=0; i<m_nChannels; i++) {
  sprintf(buf, "value[%u]: x=%.3lf, y=%.3lf\r\n", i, icUFtoD(m_xy[i].x), icUFtoD(m_xy[i].y));
  sDescription += buf;
}

3850}

3852/**
****************************************************************************
* Name: CIccTagChromaticity::SetSize
* 
* Purpose: Sets the size of the xy chromaticity array.
* 
* Args: 
*  nSize - number of xy entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
3863bool CIccTagChromaticity::SetSize(icUInt16Number nSize, bool bZeroNew/*=true*/)
3864{
if (m_nChannels == nSize)
  return true;

m_xy = (icChromaticityNumber*)icRealloc(m_xy, nSize*sizeof(icChromaticityNumber));

if (!m_xy) {
  m_nChannels = 0;
  return false;
}

if (bZeroNew && nSize > m_nChannels) {
  memset(&m_xy[m_nChannels], 0, (nSize - m_nChannels)*sizeof(icChromaticityNumber));
}

m_nChannels = nSize;
return true;
3881}


3884/**
3885******************************************************************************
3886* Name: CIccTagChromaticity::Validate
3887* 
3888* Purpose: Check tag data validity.
3889* 
3890* Args: 
3891*  sig = signature of tag being validated,
3892*  sReport = String to add report information to
3893* 
3894* Return: 
3895*  icValidateStatusOK if valid, or other error status.
3896******************************************************************************
3897*/
3898icValidateStatus CIccTagChromaticity::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
3899{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (m_nColorantType) {

  if (m_nChannels!=3) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - Number of device channels must be three.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }

  switch(m_nColorantType) {
    case icColorantITU:
      {
        if ( (m_xy[0].x != icDtoUF((icFloatNumber)0.640)) || (m_xy[0].y != icDtoUF((icFloatNumber)0.330)) ||
             (m_xy[1].x != icDtoUF((icFloatNumber)0.300)) || (m_xy[1].y != icDtoUF((icFloatNumber)0.600)) ||
             (m_xy[2].x != icDtoUF((icFloatNumber)0.150)) || (m_xy[2].y != icDtoUF((icFloatNumber)0.060)) ) {
              sReport += icMsgValidateNonCompliant;
              sReport += sSigPathName;
              sReport += " - Chromaticity data does not match specification.\r\n";
              rv = icMaxStatus(rv, icValidateNonCompliant);
            }
        break;
      }

    case icColorantSMPTE:
      {
        if ( (m_xy[0].x != icDtoUF((icFloatNumber)0.630)) || (m_xy[0].y != icDtoUF((icFloatNumber)0.340)) ||
             (m_xy[1].x != icDtoUF((icFloatNumber)0.310)) || (m_xy[1].y != icDtoUF((icFloatNumber)0.595)) ||
             (m_xy[2].x != icDtoUF((icFloatNumber)0.155)) || (m_xy[2].y != icDtoUF((icFloatNumber)0.070)) ) {
            sReport += icMsgValidateNonCompliant;
            sReport += sSigPathName;
            sReport += " - Chromaticity data does not match specification.\r\n";
            rv = icMaxStatus(rv, icValidateNonCompliant);
          }
          break;
      }

    case icColorantEBU:
      {
        if ( (m_xy[0].x != icDtoUF((icFloatNumber)0.64)) || (m_xy[0].y != icDtoUF((icFloatNumber)0.33)) ||
             (m_xy[1].x != icDtoUF((icFloatNumber)0.29)) || (m_xy[1].y != icDtoUF((icFloatNumber)0.60)) ||
             (m_xy[2].x != icDtoUF((icFloatNumber)0.15)) || (m_xy[2].y != icDtoUF((icFloatNumber)0.06)) ) {
            sReport += icMsgValidateNonCompliant;
            sReport += sSigPathName;
            sReport += " - Chromaticity data does not match specification.\r\n";
            rv = icMaxStatus(rv, icValidateNonCompliant);
          }
          break;
      }

    case icColorantP22:
      {
        if ( (m_xy[0].x != icDtoUF((icFloatNumber)0.625)) || (m_xy[0].y != icDtoUF((icFloatNumber)0.340)) ||
             (m_xy[1].x != icDtoUF((icFloatNumber)0.280)) || (m_xy[1].y != icDtoUF((icFloatNumber)0.605)) ||
             (m_xy[2].x != icDtoUF((icFloatNumber)0.155)) || (m_xy[2].y != icDtoUF((icFloatNumber)0.070)) ) {
            sReport += icMsgValidateNonCompliant;
            sReport += sSigPathName;
            sReport += " - Chromaticity data does not match specification.\r\n";
            rv = icMaxStatus(rv, icValidateNonCompliant);
          }
          break;
      }

    default:
      {
        sReport += icMsgValidateNonCompliant;
        sReport += sSigPathName;
        sReport += " - Invalid colorant type encoding.\r\n";
        rv = icMaxStatus(rv, icValidateNonCompliant);
      }
  }
}

return rv;
3978}


3981/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::CIccTagSparseMatrixArray
* 
* Purpose: CIccTagSparseMatrixArray Constructor
* 
* Args:
*  nSize = number of data entries
* 
*****************************************************************************
*/
3992CIccTagSparseMatrixArray::CIccTagSparseMatrixArray(int nNumMatrices/* =1 */, int nChannelsPerMatrix/* =4 */)
3993{
m_nSize =  nNumMatrices;
m_nChannelsPerMatrix = nChannelsPerMatrix;
m_nMatrixType = icSparseMatrixFloat32;

if (m_nSize <1)
  m_nSize = 1;
if (nChannelsPerMatrix<4)
  m_nChannelsPerMatrix = 4;

m_RawData = (icUInt8Number*)calloc(m_nSize, GetBytesPerMatrix());

m_bNonZeroPadding = false;
4006}


4009/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::CIccTagSparseMatrixArray
* 
* Purpose: Copy Constructor
*
* Args:
*  ITFN = The CIccTagFixedNum object to be copied
*****************************************************************************
*/
4019CIccTagSparseMatrixArray::CIccTagSparseMatrixArray(const CIccTagSparseMatrixArray &ITSMA)
4020{
m_nSize = ITSMA.m_nSize;
m_nChannelsPerMatrix = ITSMA.m_nChannelsPerMatrix;
m_nMatrixType = ITSMA.m_nMatrixType;

m_RawData = (icUInt8Number*)calloc(m_nSize, GetBytesPerMatrix());
memcpy(m_RawData, ITSMA.m_RawData, m_nSize*GetBytesPerMatrix());

m_bNonZeroPadding = ITSMA.m_bNonZeroPadding;
4029}


4032/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ITFN = The CIccTagSparseMatrixArray object to be copied
*****************************************************************************
*/
4042CIccTagSparseMatrixArray &CIccTagSparseMatrixArray::operator=(const CIccTagSparseMatrixArray &ITSMA)
4043{
if (&ITSMA == this)
  return *this;

m_nSize = ITSMA.m_nSize;
m_nChannelsPerMatrix = ITSMA.m_nChannelsPerMatrix;

if (m_RawData)
  free(m_RawData);
m_RawData = (icUInt8Number*)calloc(m_nSize, m_nChannelsPerMatrix);
memcpy(m_RawData, ITSMA.m_RawData, m_nSize*GetBytesPerMatrix());

m_bNonZeroPadding = ITSMA.m_bNonZeroPadding;

return *this;
4058}



4062/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::~CIccTagSparseMatrixArray
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
4070CIccTagSparseMatrixArray::~CIccTagSparseMatrixArray()
4071{
if (m_RawData)
  free(m_RawData);
4074}


4077/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
4091bool CIccTagSparseMatrixArray::Read(icUInt32Number size, CIccIO *pIO)
4092{
icTagTypeSignature sig;
icUInt16Number nChannels;
icUInt16Number nMatrixType;
icUInt32Number nBytesPerMatrix;
icUInt32Number nNumMatrices;

icUInt32Number nHdrSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  2*sizeof(icUInt16Number) +
  sizeof(icUInt32Number);

if (nHdrSize +sizeof(icUInt16Number) > size)
  return false;

if (!pIO) {
  return false;
}

if (!pIO->Read32(&sig) ||
    !pIO->Read32(&m_nReserved) ||
    !pIO->Read16(&nChannels) ||
    !pIO->Read16(&nMatrixType) ||
    !pIO->Read32(&nNumMatrices))
  return false;

m_nMatrixType = (icSparseMatrixType)nMatrixType;

icUInt32Number nSizeLeft = size - nHdrSize;

Reset(nNumMatrices, nChannels);
nBytesPerMatrix = GetBytesPerMatrix();

if (m_nSize) {
  icUInt32Number pos;
  icUInt16Number nRows;

  int i, j;
  icUInt32Number n, nAligned;
  CIccSparseMatrix mtx;

  m_bNonZeroPadding = false;

  pos = nHdrSize;
  for (i=0; i<(int)m_nSize; i++) {
    icUInt8Number *pMatrix = m_RawData + i*nBytesPerMatrix;

    n=2*sizeof(icUInt16Number);

    if (nSizeLeft<n)
      return false;
    if (pIO->Read16(pMatrix, 2)!=2) {
      return false;
    }

    nSizeLeft -= n;
    pos += n;
    
    nRows = *((icUInt16Number*)pMatrix);

    n=(nRows+1)*sizeof(icUInt16Number);

    if (nSizeLeft<n)
      return false;
    if (pIO->Read16(pMatrix+2*sizeof(icUInt16Number), nRows+1)!=nRows+1) {
      return false;
    }

    nSizeLeft -= n;
    pos += n;
    mtx.Reset(pMatrix, nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);

    if (mtx.GetNumEntries()>mtx.MaxEntries(nChannels*sizeof(icFloatNumber), mtx.Rows(), sizeof(icFloatNumber)))
      return false;

    n=mtx.GetNumEntries()*sizeof(icUInt16Number);

    if (nSizeLeft<n)
      return false;

    if (pIO->Read16(mtx.GetColumnsForRow(0), mtx.GetNumEntries())!=mtx.GetNumEntries())
      return false;

    nSizeLeft -= n;
    pos += n;

    nAligned = ((pos+3)/4)*4;
    if (nAligned != pos) {
      n = nAligned - pos;
      if (nSizeLeft < n)
        return false;

      char zbuf[3];
      if (pIO->Read8(&zbuf[0], n)!=n)
        return false;
      for (j=0; j<(int)n; j++) {
        if (zbuf[j])
          m_bNonZeroPadding = true;
      }

      nSizeLeft -= n;
      pos += n;
    }

    switch(m_nMatrixType) {
      case icSparseMatrixUInt8:
        n=mtx.GetNumEntries()*sizeof(icUInt8Number);
        if (nSizeLeft<n)
          return false;

        if (pIO->ReadUInt8Float(mtx.GetData()->getPtr(0), mtx.GetNumEntries())!=mtx.GetNumEntries())
          return false;

        break;

      case icSparseMatrixUInt16:
        n=mtx.GetNumEntries()*sizeof(icUInt16Number);
        if (nSizeLeft<n)
          return false;

        if (pIO->ReadUInt16Float(mtx.GetData()->getPtr(0), mtx.GetNumEntries())!=mtx.GetNumEntries())
          return false;

        break;

      case icSparseMatrixFloat16:
        n=mtx.GetNumEntries()*sizeof(icFloat16Number);
        if (nSizeLeft<n)
          return false;

        if (pIO->ReadFloat16Float(mtx.GetData()->getPtr(0), mtx.GetNumEntries())!=mtx.GetNumEntries())
          return false;

        break;

      case icSparseMatrixFloat32:
        n=mtx.GetNumEntries()*sizeof(icFloat32Number);
        if (nSizeLeft<n)
          return false;

        if (pIO->ReadFloat32Float(mtx.GetData()->getPtr(0), mtx.GetNumEntries())!=mtx.GetNumEntries())
          return false;

        break;

      default:
        return false;
    }
    nSizeLeft -= n;
    pos += n;

    nAligned = ((pos+3)/4)*4;
    if (nAligned != pos) {
      n = nAligned - pos;
      if (nSizeLeft < n)
        return false;

      icUInt8Number zbuf[3];
      if (pIO->Read8(&zbuf[0], n)!=n)
        return false;
      for (j=0; j<(int)n; j++) {
        if (zbuf[j])
          m_bNonZeroPadding = true;
      }

      nSizeLeft -= n;
      pos += n;
    }
  }
  if (nSizeLeft) {
    icUInt8Number b;
    for (i=0; i<(int)nSizeLeft; i++) {
      if (!pIO->Read8(&b))
        return false;
      if (b)
        m_bNonZeroPadding = true;
    }
  }
}

return true;
4273}


4276/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
4289bool CIccTagSparseMatrixArray::Write(CIccIO *pIO)
4290{
icTagTypeSignature sig = GetType();
icUInt16Number nTemp = m_nMatrixType;

if (!pIO)
 return false;

if (!pIO->Write32(&sig) ||
    !pIO->Write32(&m_nReserved) ||
    !pIO->Write16(&m_nChannelsPerMatrix) ||
    !pIO->Write16(&nTemp) ||
    !pIO->Write32(&m_nSize))
    return false;

icUInt32Number nBytesPerMatrix = m_nChannelsPerMatrix * sizeof(icFloatNumber);
CIccSparseMatrix mtx;
icUInt16Number nRows;
int i, n;

for (i=0; i<(int)m_nSize; i++) {
  icUInt8Number *pMatrix = m_RawData + i*nBytesPerMatrix;
  mtx.Reset(pMatrix, nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);
  nRows = mtx.Rows();

  n=(nRows+3)*sizeof(icUInt16Number);

  if (pIO->Write16(pMatrix, nRows+3)!=nRows+3 ||
      pIO->Write16(mtx.GetColumnsForRow(0), mtx.GetNumEntries())!=mtx.GetNumEntries()) {
    return false;
  }

  if (!pIO->Align32())
    return false;

  switch(m_nMatrixType) {
    case icSparseMatrixUInt8:
      if (pIO->WriteUInt8Float(mtx.GetData()->getPtr(), mtx.GetNumEntries())!=mtx.GetNumEntries()) {
        return false;
      }
      break;
    case icSparseMatrixUInt16:
      if (pIO->WriteUInt16Float(mtx.GetData()->getPtr(), mtx.GetNumEntries())!=mtx.GetNumEntries()) {
        return false;
      }
      break;
    case icSparseMatrixFloat16:
      if (pIO->WriteFloat16Float(mtx.GetData()->getPtr(), mtx.GetNumEntries())!=mtx.GetNumEntries()) {
        return false;
      }
      break;
    case icSparseMatrixFloat32:
      if (pIO->WriteFloat32Float(mtx.GetData()->getPtr(), mtx.GetNumEntries())!=mtx.GetNumEntries()) {
        return false;
      }
      break;
    default:
      return false;
  }

  if (!pIO->Align32())
    return false;
  
}

return true;
4355}

4357/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
4367void CIccTagSparseMatrixArray::Describe(std::string &sDescription)
4368{
icChar buf[128];

sDescription += "Begin_SparseMatrix_Array\r\n";
sprintf(buf, "OutputChannels = %d\r\n", m_nChannelsPerMatrix);
sDescription += buf;
sprintf(buf, "MatrixType = %d\r\n", m_nMatrixType);
sDescription += buf;

int i, r, c;
icUInt32Number nBytesPerMatrix = m_nChannelsPerMatrix * sizeof(icFloatNumber);
for (i=0; i<(int)m_nSize; i++) {
  CIccSparseMatrix mtx(&m_RawData[i*nBytesPerMatrix], nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);

  sprintf(buf, "\r\nBegin_Matrix_%d\r\n", i);
  sDescription += buf;

  icUInt16Number *start = mtx.GetRowStart();
  icUInt16Number *cols = mtx.GetColumnsForRow(0);
  for (r=0; r<mtx.Rows(); r++) {
    icUInt16Number rs = start[r];
    icUInt16Number re = start[r+1];
    sprintf(buf, "Row%d:", r);
    sDescription += buf;

    for (c=rs; c<re; c++) {
      sprintf(buf, " (%d, %.4lf)", cols[c], mtx.GetData()->get(c));
      sDescription += buf;
    }
  }

  sprintf(buf, "End_Matrix_%d\r\n", i);
  sDescription += buf;
}
sDescription += "\r\nEnd_SparseMatrix_Array\r\n";

4404}

4406/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::Validate
* 
* Purpose: Validates tag data
* 
* Args: 
*  sigPath - signature path of tag in profile to validate
*  sReport - string to put validation report results
*  profile - pointer to profile that contains the tag
*****************************************************************************
*/
4418icValidateStatus CIccTagSparseMatrixArray::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
4419{
icValidateStatus rv = icValidateOK;
CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

switch(m_nMatrixType) {
  case icSparseMatrixUInt8:
  case icSparseMatrixUInt16:
  case icSparseMatrixFloat16:
  case icSparseMatrixFloat32:
    break;
  default:
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - Invalid Sparse Matrix Type.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);

}

bool bCheckPCS=false;

icSignature sig1 = icGetFirstSigPathSig(sigPath);
icSignature sig2 = icGetSecondSigPathSig(sigPath);

if (sig1==icSigSpectralWhitePointTag) {
  bCheckPCS = true;
}

if (bCheckPCS && pProfile) {
  if (!icIsSameColorSpaceType(pProfile->m_Header.spectralPCS, icSigSparseMatrixReflectanceData)((((icUInt32Number)pProfile->m_Header.spectralPCS)&0xffff0000
)==((icUInt32Number)(icSigSparseMatrixReflectanceData)))) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - SparseMatrix data incompatible with spectral PCS.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
  else if (icGetSpaceSamples((icColorSpaceSignature)pProfile->m_Header.spectralPCS)!=m_nChannelsPerMatrix) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - SparseMatrix Output channels doesn't match spectral PCS channels.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
}

if (m_bNonZeroPadding) {
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Non zero padding in matrices used.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

if (!m_nSize) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - No Matrices Defined.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
  return rv;
}

if (!m_RawData) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " - Data dont defined for matrices\r\n";
  rv = icMaxStatus(rv, icValidateCriticalError);
  return rv;
}

icUInt16Number nRows, nCols;
CIccSparseMatrix mtx;
int i;

icUInt16Number nBytesPerMatrix = m_nChannelsPerMatrix * sizeof(icFloatNumber);

mtx.Reset(m_RawData, nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);
nRows = mtx.Rows();
nCols = mtx.Cols();
icUInt32Number nMaxElements = CIccSparseMatrix::MaxEntries(nBytesPerMatrix, nRows, sizeof(icFloatNumber));
char buf[128];
icUInt8Number *temp = new icUInt8Number[nBytesPerMatrix];

for (i=0; i<(int)m_nSize; i++) {
  mtx.Reset(m_RawData+i*nBytesPerMatrix, nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);
  if (mtx.Rows() != nRows || mtx.Cols() != nCols) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sprintf(buf, " - Matrix[%d] doesn't have matching rows and columns.\r\n", i);
    sReport += buf;
    rv = icMaxStatus(rv, icValidateCriticalError);
  }

  if (mtx.GetNumEntries()>nMaxElements) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sprintf(buf, " - Matrix[%d] entries exceeds number supported by Output channels.\r\n", i);
      sReport += buf;
    rv = icMaxStatus(rv, icValidateCriticalError);
  }

  if (!mtx.IsValid()) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sprintf(buf, " - Matrix[%d] has an invalid matrix structure.\r\n", i);
      sReport += buf;
    rv = icMaxStatus(rv, icValidateCriticalError);
  }

  if (i<(int)(m_nSize-1)) {
    CIccSparseMatrix umtx(temp, nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), false);
    CIccSparseMatrix mtx2(m_RawData+(i+1)*nBytesPerMatrix, nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);

    umtx.Init(nRows, nCols);
    if (!umtx.Union(mtx, mtx2)) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sprintf(buf, " - Interpolation from Matrix[%d] exceeds number of supported Output channels.\r\n", i);
      sReport += buf;
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
  }
}
delete [] temp;

return rv;
4541}


4544/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::Reset
* 
* Purpose: Sets the size of the data array erasing all previous values
* 
* Args: 
*  nNumMatrices - number of matrices
*  numChannelsPerMatrix - Equivalent number of output channels that
*   determines the fixed block size for each matrix
*****************************************************************************
*/
4556bool CIccTagSparseMatrixArray::Reset(icUInt32Number nNumMatrices, icUInt16Number nChannelsPerMatrix)
4557{
if (nNumMatrices==m_nSize && nChannelsPerMatrix==m_nChannelsPerMatrix)
  return true;

m_nSize = nNumMatrices;
m_nChannelsPerMatrix = nChannelsPerMatrix;

icUInt32Number nSize = m_nSize * GetBytesPerMatrix();

m_RawData = (icUInt8Number *)icRealloc(m_RawData, nSize);

if (!m_RawData) {
  m_nSize = 0;
  return false;
}

memset(m_RawData, 0, nSize);
return true;
4575}


4578/**
4579****************************************************************************
4580* Name: CIccTagSparseMatrixArray::GetValues
4581* 
4582* Purpose: Gets values from the num array tag as floating point numbers
4583* 
4584* Args: 
4585*  nSize - number of data entries,
4586*  bZeroNew - flag to zero newly formed values
4587*****************************************************************************
4588*/
4589bool CIccTagSparseMatrixArray::GetSparseMatrix(CIccSparseMatrix &mtx, int nIndex, bool bInitFromData/*=true*/)
4590{
if (nIndex<0 || nIndex>(int)m_nSize) {
  mtx.Reset(NULL__null, 0, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), false);
  return false;
}

icUInt32Number nBytesPerMatrix = GetBytesPerMatrix();

mtx.Reset(m_RawData+nIndex*GetBytesPerMatrix(), nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), bInitFromData);

return true;
4601}

4603bool CIccTagSparseMatrixArray::GetValues(icFloatNumber *DstVector, icUInt32Number nStart/*=0*/, icUInt32Number nVectorSize/*=1*/) const
4604{
icUInt32Number nBytesPerMatrix = GetBytesPerMatrix();
if (nVectorSize!=nBytesPerMatrix)
  return false;
if (nStart % nBytesPerMatrix != 0)
  return false;

if (nStart / nBytesPerMatrix > m_nSize)
  return false;

memcpy(DstVector, m_RawData+nStart, nVectorSize);
return true;
4616}


4619/**
4620****************************************************************************
4621* Name: CIccTagSparseMatrixArray::Interpolate
4622* 
4623* Purpose: Gets values from the num array tag as floating point numbers
4624* 
4625* Args: 
4626*  nSize - number of data entries,
4627*  bZeroNew - flag to zero newly formed values
4628*****************************************************************************
4629*/
4630bool CIccTagSparseMatrixArray::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                         icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
4632{
icUInt32Number nMatrix = m_nSize;

if (!nMatrix || nVectorSize != GetBytesPerMatrix())
  return false;

if (zeroVals)
  nMatrix ++;
else if (nMatrix<=1)
  return false;

if (pos<0.0)
  pos=0.0;
if (pos>1.0)
  pos=1.0;

icFloatNumber fpos = (icFloatNumber)(nMatrix-1) * pos;
icUInt32Number iPos = (icUInt32Number)fpos;
icFloatNumber x = fpos - iPos;

if (iPos == nMatrix-1) {
  iPos--;
  x = (icFloatNumber)1.0;
}

icUInt8Number *lo, *hi;

if (zeroVals) {
  if (!iPos) {
    lo = (icUInt8Number*)zeroVals;
    hi = m_RawData;
  }
  else {
    lo = &m_RawData[(iPos-1)*nVectorSize];
    hi = &lo[nVectorSize];
  }
}
else {
  lo = &m_RawData[iPos*nVectorSize];
  hi = &lo[nVectorSize];
}

CIccSparseMatrix mlo(lo, nVectorSize, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);
CIccSparseMatrix mhi(hi, nVectorSize, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);
CIccSparseMatrix dst((icUInt8Number*)DstVector, nVectorSize, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), false);

if (mlo.Rows()!=mhi.Rows() || mlo.Cols()!=mhi.Cols())
  return false;

if (!dst.Interp(1.0f-x, mlo, x, mhi))
  return false;

return true;
4685}


4688/**
4689****************************************************************************
4690* Name: CIccTagSparseMatrixArray::ValuePos
4691* 
4692* Purpose: Gets position of a value int the num array tag
4693* 
4694* Args: 
4695*  DstPos - position of val in array
4696*  val - value to look for in array.
4697*  bNoZero - flag indicating whether first entry is zero
4698*****************************************************************************
4699*/
4700bool CIccTagSparseMatrixArray::ValuePos(icFloatNumber &DstPos, icFloatNumber val, bool &bNoZero) const
4701{
//ValuePos not supported for Sparse Matrices
return false;
4704}


4707/**
****************************************************************************
* Name: CIccTagFixedNum::CIccTagFixedNum
* 
* Purpose: CIccTagFixedNumConstructor
* 
* Args:
*  nSize = number of data entries
* 
*****************************************************************************
*/
4718template <class T, icTagTypeSignature Tsig>
4719CIccTagFixedNum<T, Tsig>::CIccTagFixedNum(int nSize/*=1*/)
4720{
m_nSize = nSize;
if (m_nSize <1)
  m_nSize = 1;
m_Num = (T*)calloc(nSize, sizeof(T));
4725}


4728/**
****************************************************************************
* Name: CIccTagFixedNum::CIccTagFixedNum
* 
* Purpose: Copy Constructor
*
* Args:
*  ITFN = The CIccTagFixedNum object to be copied
*****************************************************************************
*/
4738template <class T, icTagTypeSignature Tsig>
4739CIccTagFixedNum<T, Tsig>::CIccTagFixedNum(const CIccTagFixedNum<T, Tsig> &ITFN)
4740{
m_nSize = ITFN.m_nSize;
m_Num = (T*)calloc(m_nSize, sizeof(T));
memcpy(m_Num, ITFN.m_Num, m_nSize*sizeof(T));
4744}


4747/**
****************************************************************************
* Name: CIccTagFixedNum::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ITFN = The CIccTagFixedNum object to be copied
*****************************************************************************
*/
4757template <class T, icTagTypeSignature Tsig>
4758CIccTagFixedNum<T, Tsig> &CIccTagFixedNum<T, Tsig>::operator=(const CIccTagFixedNum<T, Tsig> &ITFN)
4759{
if (&ITFN == this)
  return *this;

m_nSize = ITFN.m_nSize;

if (m_Num)
  free(m_Num);
m_Num = (T*)calloc(m_nSize, sizeof(T));
memcpy(m_Num, ITFN.m_Num, m_nSize*sizeof(T));

return *this;
4771}



4775/**
****************************************************************************
* Name: CIccTagFixedNum::~CIccTagFixedNum
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
4783template <class T, icTagTypeSignature Tsig>
4784CIccTagFixedNum<T, Tsig>::~CIccTagFixedNum()
4785{
if (m_Num)
  free(m_Num);
4788}

4790/**
****************************************************************************
* Name: CIccTagFixedNum::GetClassName
* 
* Purpose: Returns the tag type class name
* 
*****************************************************************************
*/
4798template <class T, icTagTypeSignature Tsig>
4799const icChar* CIccTagFixedNum<T, Tsig>::GetClassName() const
4800{
if (Tsig==icSigS15Fixed16ArrayType)
  return "CIccTagS15Fixed16";
else 
  return "CIccTagU16Fixed16";
4805}


4808/**
****************************************************************************
* Name: CIccTagFixedNum::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
4822template <class T, icTagTypeSignature Tsig>
4823bool CIccTagFixedNum<T, Tsig>::Read(icUInt32Number size, CIccIO *pIO)
4824{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(T) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

icUInt32Number nSize=((size-2*sizeof(icUInt32Number)) / sizeof(T));

if (!SetSize(nSize))
  return false;

if (pIO->Read32(m_Num, nSize) != (icInt32Number)nSize )
  return false;

return true;
4851}


4854/**
****************************************************************************
* Name: CIccTagFixedNum::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
4867template <class T, icTagTypeSignature Tsig>
4868bool CIccTagFixedNum<T, Tsig>::Write(CIccIO *pIO)
4869{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (pIO->Write32(m_Num, m_nSize) != (icInt32Number)m_nSize)
  return false;

return true;
4885}

4887/**
****************************************************************************
* Name: CIccTagFixedNum::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
4897template <class T, icTagTypeSignature Tsig>
4898void CIccTagFixedNum<T, Tsig>::Describe(std::string &sDescription)
4899{
icChar buf[128];

if (m_nSize == 1 ) {
  if (Tsig==icSigS15Fixed16ArrayType) 
    sprintf(buf, "Value = %.4lf\r\n", icFtoD(m_Num[0]));
  else
    sprintf(buf, "Value = %.4lf\r\n", icUFtoD(m_Num[0]));
  sDescription += buf;
}
else {
  icUInt32Number i;

  if (Tsig==icSigS15Fixed16ArrayType && m_nSize==9) {
    sDescription += "Matrix Form:\r\n";
    icMatrixDump(sDescription, (icS15Fixed16Number*)m_Num);

    sDescription += "\r\nArrayForm:\r\n";
  }
  sDescription.reserve(sDescription.size() + m_nSize*79);

  for (i=0; i<m_nSize; i++) {
    if (Tsig==icSigS15Fixed16ArrayType) 
      sprintf(buf, "Value[%u] = %8.4lf\r\n", i, icFtoD(m_Num[i]));
    else
      sprintf(buf, "Value[%u] = %8.4lf\r\n", i, icUFtoD(m_Num[i]));
    sDescription += buf;
  }
}
4928}

4930/**
****************************************************************************
* Name: CIccTagFixedNum::SetSize
* 
* Purpose: Sets the size of the data array.
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
4941template <class T, icTagTypeSignature Tsig>
4942bool CIccTagFixedNum<T, Tsig>::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
4943{
if (nSize==m_nSize)
  return true;

m_Num = (T*)icRealloc(m_Num, nSize*sizeof(T));

if (!m_Num) {
  m_nSize = 0;
  return false;
}

if (bZeroNew && m_nSize < nSize) {
  memset(&m_Num[m_nSize], 0, (nSize-m_nSize)*sizeof(T));
}
m_nSize = nSize;

return true;
4960}

4962/**
4963****************************************************************************
4964* Name: CIccTagFixedNum::GetValues
4965* 
4966* Purpose: Gets values from the num array tag as floating point numbers
4967* 
4968* Args: 
4969*  nSize - number of data entries,
4970*  bZeroNew - flag to zero newly formed values
4971*****************************************************************************
4972*/
4973template <class T, icTagTypeSignature Tsig>
4974bool CIccTagFixedNum<T, Tsig>::GetValues(icFloatNumber *DstVector, icUInt32Number nStart, icUInt32Number nVectorSize) const
4975{
if (nVectorSize+nStart >m_nSize)
  return false;

icUInt32Number i;

switch (Tsig) {
  case icSigS15Fixed16ArrayType:
    for (i=0; i<m_nSize; i++) {
      DstVector[i] = (icFloatNumber)icFtoD(m_Num[i+nStart]);
    }
    break;
  case icSigU16Fixed16ArrayType:
    for (i=0; i<m_nSize; i++) {
      DstVector[i] = (icFloatNumber)icUFtoD(m_Num[i+nStart]);
    }
    break;
  default:
    return false;
}
return true;
4996}


4999/**
5000****************************************************************************
5001* Name: CIccTagFixedNum::Interpolate
5002* 
5003* Purpose: Gets values from the num array tag as floating point numbers
5004* 
5005* Args: 
5006*  nSize - number of data entries,
5007*  bZeroNew - flag to zero newly formed values
5008*****************************************************************************
5009*/
5010template <class T, icTagTypeSignature Tsig>
5011bool CIccTagFixedNum<T, Tsig>::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                         icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
5013{
icUInt32Number nVector = m_nSize / nVectorSize;

if (!nVector)
1
Assuming 'nVector' is not equal to 0→
2
←
Taking false branch→
  return false;

if (zeroVals)
3
←
Assuming 'zeroVals' is null→
4
←
Taking false branch→
  nVector ++;
else if (nVector<=1)
5
←
Assuming 'nVector' is > 1→
6
←
Taking false branch→
  return false;

if (pos<0.0)
7
←
Assuming the condition is false→
8
←
Taking false branch→
  pos=0.0;
if (pos>1.0)
9
←
Assuming the condition is false→
10
←
Taking false branch→
  pos=1.0;

icFloatNumber fpos = (icFloatNumber)(nVector-1) * pos;
icUInt32Number iPos = (icUInt32Number)fpos;
icFloatNumber x = fpos - iPos;

if (iPos == nVector-1) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
  iPos--;
  x = (icFloatNumber)1.0;
}

T *lo, *hi;

if (zeroVals12.1
'zeroVals' is null
) {
13
←
Taking false branch→
  if (!iPos) {
    lo = NULL__null;
    hi = m_Num;
  }
  else {
    lo = &m_Num[(iPos-1)*nVectorSize];
    hi = &lo[nVectorSize];
  }
}
else {
  lo = &m_Num[iPos*nVectorSize];
  hi = &lo[nVectorSize];
}

icUInt32Number i;

switch (Tsig) {
14
←
Control jumps to 'case icSigU16Fixed16ArrayType:'  at line 5070→
  case icSigS15Fixed16ArrayType:
    if (!lo) {
      for (i=0; i<m_nSize; i++) {
        DstVector[i] = (icFloatNumber)(zeroVals[i]*(1.0f-x) + icFtoD(hi[i])*x);
      }
    }
    else {
      for (i=0; i<m_nSize; i++) {
        DstVector[i] = (icFloatNumber)(icFtoD(lo[i])*(1.0-x) + icFtoD(hi[i])*x);
      }
    }
    break;
  case icSigU16Fixed16ArrayType:
    if (!lo) {
15
←
Assuming 'lo' is null→
16
←
Taking true branch→
      for (i=0; i<m_nSize; i++) {
17
←
Assuming 'i' is < field 'm_nSize'→
18
←
Loop condition is true.  Entering loop body→
        DstVector[i] = (icFloatNumber)(zeroVals[i]*(1.0-x) + icUFtoD(hi[i])*x);
19
←
Array access (from variable 'zeroVals') results in a null pointer dereference
      }
    }
    else {
      for (i=0; i<m_nSize; i++) {
        DstVector[i] = (icFloatNumber)(icUFtoD(lo[i])*(1.0-x) + icUFtoD(hi[i])*x);
      }
    }
    break;
  default:
    return false;
}
return true;
5086}

5088/**
5089****************************************************************************
5090* Name: CIccTagFixedNum::ValuePos
5091* 
5092* Purpose: Gets position of a value int the num array tag
5093* 
5094* Args: 
5095*  DstPos - position of val in array
5096*  val - value to look for in array.
5097*  bNoZero - flag indicating whether first entry is zero
5098*****************************************************************************
5099*/
5100template <class T, icTagTypeSignature Tsig>
5101bool CIccTagFixedNum<T, Tsig>::ValuePos(icFloatNumber &DstPos, icFloatNumber val, bool &bNoZero) const
5102{
if(val<0.0)
  return false;

icFloatNumber nv, lv;
switch (Tsig) {
  case icSigS15Fixed16ArrayType:
    lv = icFtoD(m_Num[0]);
    break;
  case icSigU16Fixed16ArrayType:
    lv = icUFtoD(m_Num[0]);
    break;
  default:
    return false;
}
bNoZero = (lv!=0.0);

if (val<lv) {
  DstPos = val/lv - 1.0f;
  return true;
}

icUInt32Number i;
for (i=1; i<m_nSize; i++, lv=nv) {
  switch (Tsig) {
    case icSigS15Fixed16ArrayType:
      nv = icFtoD(m_Num[i]);
      break;
    case icSigU16Fixed16ArrayType:
      nv = icUFtoD(m_Num[i]);
      break;
    default:
      return false;
  }
  if (val<=nv) {
    DstPos = (val-lv)/(nv-lv) + i - 1.0f;
    return true;
  }
}

return false;
5143}


5146//Make sure typedef classes get built
5147template class CIccTagFixedNum<icS15Fixed16Number, icSigS15Fixed16ArrayType>;
5148template class CIccTagFixedNum<icU16Fixed16Number, icSigU16Fixed16ArrayType>;


5151/**
****************************************************************************
* Name: CIccTagNum::CIccTagNum
* 
* Purpose: Constructor
* 
* Args:
*  nSize = number of data entries
*****************************************************************************
*/
5161template <class T, icTagTypeSignature Tsig>
5162CIccTagNum<T, Tsig>::CIccTagNum(int nSize/*=1*/)
5163{
m_nSize = nSize;
if (m_nSize <1)
  m_nSize = 1;
m_Num = (T*)calloc(nSize, sizeof(T));
5168}


5171/**
****************************************************************************
* Name: CIccTagNum::CIccTagNum
* 
* Purpose: Copy Constructor
*
* Args:
*  ITNum = The CIccTagNum object to be copied
*****************************************************************************
*/
5181template <class T, icTagTypeSignature Tsig>
5182CIccTagNum<T, Tsig>::CIccTagNum(const CIccTagNum<T, Tsig> &ITNum)
5183{
m_nSize = ITNum.m_nSize;

m_Num = (T*)calloc(m_nSize, sizeof(T));
memcpy(m_Num, ITNum.m_Num, m_nSize * sizeof(T));
5188}


5191/**
****************************************************************************
* Name: CIccTagNum::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ITNum = The CIccTagNum object to be copied
*****************************************************************************
*/
5201template <class T, icTagTypeSignature Tsig>
5202CIccTagNum<T, Tsig> &CIccTagNum<T, Tsig>::operator=(const CIccTagNum<T, Tsig> &ITNum)
5203{
if (&ITNum == this)
  return *this;

m_nSize = ITNum.m_nSize;

m_Num = (T*)calloc(m_nSize, sizeof(T));
memcpy(m_Num, ITNum.m_Num, m_nSize * sizeof(T));

return *this;
5213}



5217/**
****************************************************************************
* Name: CIccTagNum::~CIccTagNum
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
5225template <class T, icTagTypeSignature Tsig>
5226CIccTagNum<T, Tsig>::~CIccTagNum()
5227{
if (m_Num)
  free(m_Num);
5230}

5232/**
****************************************************************************
* Name: CIccTagNum::GetClassName
* 
* Purpose: Returns the tag type class name
* 
*****************************************************************************
*/
5240template <class T, icTagTypeSignature Tsig>
5241const icChar *CIccTagNum<T, Tsig>::GetClassName() const
5242{
if (sizeof(T)==sizeof(icUInt8Number))
  return "CIccTagUInt8";
else if (sizeof(T)==sizeof(icUInt16Number))
  return "CIccTagUInt16";
else if (sizeof(T)==sizeof(icUInt32Number))
  return "CIccTagUInt32";
else if (sizeof(T)==sizeof(icUInt64Number))
  return "CIccTagUInt64";
else
  return "CIccTagNum<>";
5253}


5256/**
****************************************************************************
* Name: CIccTagNum::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
5270template <class T, icTagTypeSignature Tsig>
5271bool CIccTagNum<T, Tsig>::Read(icUInt32Number size, CIccIO *pIO)
5272{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(T) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

icUInt32Number nSize=((size-2*sizeof(icUInt32Number)) / sizeof(T));

if (!SetSize(nSize))
  return false;

if (sizeof(T)==sizeof(icUInt8Number)) {
  if (pIO->Read8(m_Num, nSize) != (icInt32Number)nSize )
    return false;
}
else if (sizeof(T)==sizeof(icUInt16Number)) {
  if (pIO->Read16(m_Num, nSize) != (icInt32Number)nSize )
    return false;
}
else if (sizeof(T)==sizeof(icUInt32Number)) {
  if (pIO->Read32(m_Num, nSize) != (icInt32Number)nSize )
    return false;
}
else if (sizeof(T)==sizeof(icUInt64Number)) {
  if (pIO->Read64(m_Num, nSize) != (icInt32Number)nSize )
    return false;
}
else
  return false;

return true;
5315}


5318/**
****************************************************************************
* Name: CIccTagNum::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
5331template <class T, icTagTypeSignature Tsig>
5332bool CIccTagNum<T, Tsig>::Write(CIccIO *pIO)
5333{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (sizeof(T)==sizeof(icUInt8Number)) {
  if (pIO->Write8(m_Num, m_nSize) != (icInt32Number)m_nSize)
    return false;
}
else if (sizeof(T)==sizeof(icUInt16Number)) {
  if (pIO->Write16(m_Num, m_nSize) != (icInt32Number)m_nSize)
    return false;
}
else if (sizeof(T)==sizeof(icUInt32Number)) {
  if (pIO->Write32(m_Num, m_nSize) != (icInt32Number)m_nSize)
    return false;
}
else if (sizeof(T)==sizeof(icUInt64Number)) {
  if (pIO->Write64(m_Num, m_nSize) != (icInt32Number)m_nSize)
    return false;
}
else
  return false;

return true;
5365}


5368/**
****************************************************************************
* Name: CIccTagNum::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
5378template <class T, icTagTypeSignature Tsig>
5379void CIccTagNum<T, Tsig>::Describe(std::string &sDescription)
5380{
icChar buf[128];

if (m_nSize == 1 ) {
  switch (sizeof(T)) {
    case 1:
      sprintf(buf, "Value = %u (0x02%x)\r\n", m_Num[0], m_Num[0]);
      break;
    case 2:
      sprintf(buf, "Value = %u (0x04%x)\r\n", m_Num[0], m_Num[0]);
      break;
    case 4:
      sprintf(buf, "Value = %u (0x08%x)\r\n", m_Num[0], m_Num[0]);
      break;
    case 8:
      sprintf(buf, "Value = %u (0x016%x)\r\n", m_Num[0], m_Num[0]);
      break;
    default:
      sprintf(buf, "Value = %u (0x%x)\r\n", m_Num[0], m_Num[0]);
      break;
  }
  sDescription += buf;
}
else {
  icUInt32Number i;
  sDescription.reserve(sDescription.size() + m_nSize*79);

  for (i=0; i<m_nSize; i++) {
    switch (sizeof(T)) {
    case 1:
      sprintf(buf, "Value = %u (0x02%x)\r\n", m_Num[i], m_Num[i]);
      break;
    case 2:
      sprintf(buf, "Value = %u (0x04%x)\r\n", m_Num[i], m_Num[i]);
      break;
    case 4:
      sprintf(buf, "Value = %u (0x08%x)\r\n", m_Num[i], m_Num[i]);
      break;
    case 8:
      sprintf(buf, "Value = %u (0x016%x)\r\n", m_Num[i], m_Num[i]);
      break;
    default:
      sprintf(buf, "Value = %u (0x%x)\r\n", m_Num[i], m_Num[i]);
      break;
    }
    sDescription += buf;
  }
}
5428}

5430template <class T, icTagTypeSignature Tsig>
5431icValidateStatus CIccTagNum<T, Tsig>::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile) const
5432{
icValidateStatus rv = icValidateOK;
//Check # of channels 
if (icGetFirstSigPathSig(sigPath) == icSigMaterialDefaultValuesTag && 
    pProfile &&
    m_nSize != icGetMaterialColorSpaceSamples(pProfile->m_Header.mcs)) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " - Number of material default values does not match MCS in header.\r\n";
  rv = icMaxStatus(rv, icValidateCriticalError);
}

rv = icMaxStatus(rv, CIccTagNumArray::Validate(sigPath, sReport, pProfile));

return rv;
5450}

5452// template function specialization to handle need for %llu and %llx for 64-bit ints
5453template <>
5454void CIccTagNum<icUInt64Number, icSigUInt64ArrayType>::Describe(std::string &sDescription)
5455{
icChar buf[128];

if (m_nSize == 1 ) {
  sprintf(buf, "Value = %llu (0x016%llx)\r\n", m_Num[0], m_Num[0]);
  sDescription += buf;
}
else {
  icUInt32Number i;
  sDescription.reserve(sDescription.size() + m_nSize*79);

  for (i=0; i<m_nSize; i++) {
    sprintf(buf, "Value = %llu (0x016%llx)\r\n", m_Num[i], m_Num[i]);
    sDescription += buf;
  }
}
5471}




5476/**
****************************************************************************
* Name: CIccTagNum::SetSize
* 
* Purpose: Sets the size of the data array.
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
5487template <class T, icTagTypeSignature Tsig>
5488bool CIccTagNum<T, Tsig>::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
5489{
if (nSize==m_nSize)
  return true;

m_Num = (T*)icRealloc(m_Num, nSize*sizeof(T));

if (!m_Num) {
  m_nSize = 0;
  return false;
}

if (bZeroNew && m_nSize < nSize) {
  memset(&m_Num[m_nSize], 0, (nSize-m_nSize)*sizeof(T));
}
m_nSize = nSize;

return true;
5506}

5508/**
5509****************************************************************************
5510* Name: CIccTagNum::GetValues
5511* 
5512* Purpose: Gets values from the num array tag as floating point numbers
5513* 
5514* Args: 
5515*  nSize - number of data entries,
5516*  bZeroNew - flag to zero newly formed values
5517*****************************************************************************
5518*/
5519template <class T, icTagTypeSignature Tsig>
5520bool CIccTagNum<T, Tsig>::GetValues(icFloatNumber *DstVector, icUInt32Number nStart, icUInt32Number nVectorSize) const
5521{
if (nVectorSize+nStart >m_nSize)
  return false;

icUInt32Number i;

switch (Tsig) {
  case icSigUInt8ArrayType:
    for (i=0; i<m_nSize; i++) {
      DstVector[i] = icU8toF((icUInt8Number)(m_Num[i+nStart]));
    }
    break;
  case icSigUInt16ArrayType:
    for (i=0; i<m_nSize; i++) {
      DstVector[i] = icU16toF((icUInt16Number)(m_Num[i+nStart]));
    }
    break;
  case icSigUInt32ArrayType: //Not Supported
  case icSigUInt64ArrayType: //Not Supported
  default:
    return false;
}
return true;
5544}

5546//Avoid casting warnings for 32 and 64 bit numbers
5547template <>
5548bool CIccTagNum<icUInt32Number, icSigUInt32ArrayType>::GetValues(icFloatNumber *DstVector, icUInt32Number nStart, icUInt32Number nVectorSize) const
5549{
return false;
5551}
5552template <>
5553bool CIccTagNum<icUInt64Number, icSigUInt64ArrayType>::GetValues(icFloatNumber *DstVector, icUInt32Number nStart, icUInt32Number nVectorSize) const
5554{
return false;
5556}

5558/**
5559****************************************************************************
5560* Name: CIccTagNum::Interpolate
5561* 
5562* Purpose: Gets values from the num array tag as floating point numbers
5563* 
5564* Args: 
5565*  nSize - number of data entries,
5566*  bZeroNew - flag to zero newly formed values
5567*****************************************************************************
5568*/
5569template <class T, icTagTypeSignature Tsig>
5570bool CIccTagNum<T, Tsig>::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                    icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
5572{
icUInt32Number nVector = m_nSize / nVectorSize;

if (!nVector)
  return false;

if (zeroVals)
  nVector ++;
else if (nVector<=1)
  return false;

if (pos<0.0)
  pos=0.0;
if (pos>1.0)
  pos=1.0;

icFloatNumber fpos = (icFloatNumber)(nVector-1) * pos;
icUInt32Number iPos = (icUInt32Number)fpos;
icFloatNumber x = fpos - iPos;

if (iPos == nVector-1) {
  iPos--;
  x = (icFloatNumber)1.0;
}

T *lo, *hi;

if (!zeroVals) {
  if (!iPos) {
    lo = NULL__null;
    hi = m_Num;
  }
  else {
    lo = &m_Num[(iPos-1)*nVectorSize];
    hi = &lo[nVectorSize];
  }
}
else {
  lo = &m_Num[iPos*nVectorSize];
  hi = &lo[nVectorSize];
}

icUInt32Number i;

switch (Tsig) {
  case icSigUInt8ArrayType:
    if (!lo) {
      for (i=0; i<m_nSize; i++) {
        DstVector[i] = zeroVals[i]*(1.0f-x) + icU8toF((icUInt8Number)hi[i])*x;
      }
    }
    else {
      for (i=0; i<m_nSize; i++) {
        DstVector[i] = icU8toF((icUInt8Number)lo[i])*(1.0f-x) + icU8toF((icUInt8Number)hi[i])*x;
      }
    }
    break;
  case icSigUInt16ArrayType:
    if (!lo) {
      for (i=0; i<m_nSize; i++) {
        DstVector[i] = zeroVals[i]*(1.0f-x) + icU16toF((icUInt16Number)hi[i])*x;
      }
    }
    else {
      for (i=0; i<m_nSize; i++) {
        DstVector[i] = icU16toF((icUInt16Number)lo[i])*(1.0f-x) + icU16toF((icUInt16Number)hi[i])*x;
      }
    }
    break;
  case icSigUInt32ArrayType:
  case icSigUInt64ArrayType:
  default:
    return false;
}
return true;
5647}


5650/**
5651****************************************************************************
5652* Name: CIccTagNum::ValuePos
5653* 
5654* Purpose: Gets position of a value int the num array tag
5655* 
5656* Args: 
5657*  DstPos - position of val in array
5658*  val - value to look for in array.
5659*  bNoZero - flag indicating whether first entry is zero
5660*****************************************************************************
5661*/
5662template <class T, icTagTypeSignature Tsig>
5663bool CIccTagNum<T, Tsig>::ValuePos(icFloatNumber &DstPos, icFloatNumber val, bool &bNoZero) const
5664{
if(val<0.0)
  return false;

icFloatNumber nv, lv;
switch (Tsig) {
  case icSigUInt8ArrayType:
    lv = icU8toF((icUInt8Number)m_Num[0]);
    break;
  case icSigUInt16ArrayType:
    lv = icU16toF((icUInt16Number)m_Num[0]);
    break;
  case icSigUInt32ArrayType:
  case icSigUInt64ArrayType:
  default:
    return false;
}
bNoZero = (lv!=0.0);

if (val<lv) {
  DstPos = val/lv - 1.0f;
  return true;
}

icUInt32Number i;
for (i=1; i<m_nSize; i++, lv=nv) {
  switch (Tsig) {
    case icSigUInt8ArrayType:
      nv = icU8toF((icUInt8Number)m_Num[i]);
      break;
    case icSigUInt16ArrayType:
      nv = icU16toF((icUInt16Number)m_Num[i]);
      break;
    case icSigUInt32ArrayType:
    case icSigUInt64ArrayType:
    default:
      return false;
  }
  if (val<=nv) {
    DstPos = (val-lv)/(nv-lv) + i - 1.0f;
    return true;
  }
}

return false;
5709}

5711//Avoid casting warnings for 32 and 64 bit numbers
5712template <>
5713bool CIccTagNum<icUInt32Number, icSigUInt32ArrayType>::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                                                 icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
5715{
return false;
5717}
5718template <>
5719bool CIccTagNum<icUInt64Number, icSigUInt64ArrayType>::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                                                 icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
5721{
return false;
5723}

5725template <>
5726bool CIccTagNum<icUInt32Number, icSigUInt32ArrayType>::ValuePos(icFloatNumber&DstPos, icFloatNumber val, bool &bNoZero) const
5727{
return false;
5729}
5730template <>
5731bool CIccTagNum<icUInt64Number, icSigUInt64ArrayType>::ValuePos(icFloatNumber&DstPos, icFloatNumber val, bool &bNoZero) const
5732{
return false;
5734}

5736//Make sure typedef classes get built
5737template class CIccTagNum<icUInt8Number, icSigUInt8ArrayType>;
5738template class CIccTagNum<icUInt16Number, icSigUInt16ArrayType>;
5739template class CIccTagNum<icUInt32Number, icSigUInt32ArrayType>;
5740template class CIccTagNum<icUInt64Number, icSigUInt64ArrayType>;


5743/**
****************************************************************************
* Name: CIccTagFloatNum::CIccTagFloatNum
* 
* Purpose: Constructor
* 
* Args:
*  nSize = number of data entries
*****************************************************************************
*/
5753template <class T, icTagTypeSignature Tsig>
5754CIccTagFloatNum<T, Tsig>::CIccTagFloatNum(int nSize/*=1*/)
5755{
m_nSize = nSize;
if (m_nSize <1)
  m_nSize = 1;
m_Num = (T*)calloc(nSize, sizeof(T));
5760}


5763/**
****************************************************************************
* Name: CIccTagFloatNum::CIccTagFloatNum
* 
* Purpose: Copy Constructor
*
* Args:
*  ITNum = The CIccTagNum object to be copied
*****************************************************************************
*/
5773template <class T, icTagTypeSignature Tsig>
5774CIccTagFloatNum<T, Tsig>::CIccTagFloatNum(const CIccTagFloatNum<T, Tsig> &ITNum)
5775{
m_nSize = ITNum.m_nSize;

m_Num = (T*)calloc(m_nSize, sizeof(T));
memcpy(m_Num, ITNum.m_Num, m_nSize * sizeof(T));
5780}


5783/**
****************************************************************************
* Name: CIccTagFloatNum::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ITNum = The CIccTagNum object to be copied
*****************************************************************************
*/
5793template <class T, icTagTypeSignature Tsig>
5794CIccTagFloatNum<T, Tsig> &CIccTagFloatNum<T, Tsig>::operator=(const CIccTagFloatNum<T, Tsig> &ITNum)
5795{
if (&ITNum == this)
  return *this;

m_nSize = ITNum.m_nSize;

m_Num = (T*)calloc(m_nSize, sizeof(T));
memcpy(m_Num, ITNum.m_Num, m_nSize * sizeof(T));

return *this;
5805}



5809/**
****************************************************************************
* Name: CIccTagFloatNum::~CIccTagFloatNum
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
5817template <class T, icTagTypeSignature Tsig>
5818CIccTagFloatNum<T, Tsig>::~CIccTagFloatNum()
5819{
if (m_Num)
  free(m_Num);
5822}

5824/**
****************************************************************************
* Name: CIccTagFloatNum::GetClassName
* 
* Purpose: Returns the tag type class name
* 
*****************************************************************************
*/
5832template <class T, icTagTypeSignature Tsig>
5833const icChar *CIccTagFloatNum<T, Tsig>::GetClassName() const
5834{
if (Tsig==icSigFloat16ArrayType)
  return "CIccFlaot16";
if (Tsig==icSigFloat32ArrayType)
  return "CIccFloat32";
else if (Tsig==icSigFloat64ArrayType)
  return "CIccFloat64";
else
  return "CIccTagFloatNum<>";
5843}


5846/**
****************************************************************************
* Name: CIccTagFloatNum::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
5860template <class T, icTagTypeSignature Tsig>
5861bool CIccTagFloatNum<T, Tsig>::Read(icUInt32Number size, CIccIO *pIO)
5862{
icTagTypeSignature sig;

if (Tsig==icSigFloat16ArrayType) {
  if (sizeof(icTagTypeSignature) + 
      sizeof(icUInt32Number) + 
      sizeof(icFloat16Number) > size)
    return false;
}
else {
  if (sizeof(icTagTypeSignature) + 
      sizeof(icUInt32Number) + 
      sizeof(T) > size)
    return false;
}

if (!pIO) {
  return false;
}

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

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

if (Tsig==icSigFloat16ArrayType) {
  icUInt32Number nSize=((size-2*sizeof(icUInt32Number)) / sizeof(icFloat16Number));

  if (!SetSize(nSize))
    return false;

  if (pIO->ReadFloat16Float(&m_Num[0], nSize) != (icInt32Number)nSize)
    return false;
}
else if (Tsig==icSigFloat32ArrayType) {
  icUInt32Number nSize=((size-2*sizeof(icUInt32Number)) / sizeof(icFloat32Number));

  if (!SetSize(nSize))
    return false;

  if (pIO->Read32(m_Num, nSize) != (icInt32Number)nSize )
    return false;
}
else if (Tsig==icSigFloat64ArrayType) {
  icUInt32Number nSize=((size-2*sizeof(icUInt32Number)) / sizeof(icFloat64Number));

  if (!SetSize(nSize))
    return false;

  if (pIO->Read64(m_Num, nSize) != (icInt32Number)nSize )
    return false;
}
else
  return false;

return true;
5919}


5922/**
****************************************************************************
* Name: CIccTagFloatNum::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
5935template <class T, icTagTypeSignature Tsig>
5936bool CIccTagFloatNum<T, Tsig>::Write(CIccIO *pIO)
5937{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (Tsig==icSigFloat16ArrayType) {
  if (pIO->WriteFloat16Float(m_Num, m_nSize) != (icInt32Number)m_nSize)
    return false;
}
else if (Tsig == icSigFloat32ArrayType) {
  if (pIO->Write32(m_Num, m_nSize) != (icInt32Number)m_nSize)
    return false;
}
else if (Tsig == icSigFloat64ArrayType) {
  if (pIO->Write64(m_Num, m_nSize) != (icInt32Number)m_nSize)
    return false;
}
else
  return false;

return true;
5965}


5968/**
****************************************************************************
* Name: CIccTagFloatNum::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
5978template <class T, icTagTypeSignature Tsig>
5979void CIccTagFloatNum<T, Tsig>::Describe(std::string &sDescription)
5980{
icChar buf[128];

if (m_nSize == 1 ) {
  switch (sizeof(T)) {
    case 4:
      sprintf(buf, "Value = %.8f\r\n", m_Num[0]);
      break;
    case 8:
      sprintf(buf, "Value = %.16f\r\n", m_Num[0]);
      break;
    default:
      sprintf(buf, "Value = %.f\r\n", m_Num[0]);
      break;
  }
  sDescription += buf;
}
else {
  icUInt32Number i, n;
  sDescription.reserve(sDescription.size() + m_nSize*79);

  sprintf(buf, "Begin_Value_Array[%d]\r\n", m_nSize);
  sDescription += buf;

  if (sizeof(T)!=8)
    n=8;
  else
    n=4;
  
  for (i=0; i<m_nSize; i++) {
    if (i&& !(i%n))
      sDescription += "\r\n";
     
    switch (sizeof(T)) {
    case 4:
      sprintf(buf, " %.8f", m_Num[i]);
      break;
    case 8:
      sprintf(buf, " %.16f", m_Num[i]);
      break;
    default:
      sprintf(buf, " %f", m_Num[i]);
    }
    sDescription += buf;
  }
  if ((i%n)!=1)
    sDescription += "\r\n";
  sDescription += "End_Value_Array\r\n";
}
6029}


6032/**
****************************************************************************
* Name: CIccTagFloatNum::SetSize
* 
* Purpose: Sets the size of the data array.
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
6043template <class T, icTagTypeSignature Tsig>
6044bool  CIccTagFloatNum<T, Tsig>::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
6045{
if (nSize==m_nSize)
  return true;

m_Num = (T*)icRealloc(m_Num, nSize*sizeof(T));

if (!m_Num) {
  m_nSize = 0;
  return false;
}

if (bZeroNew && m_nSize < nSize) {
  memset(&m_Num[m_nSize], 0, (nSize-m_nSize)*sizeof(T));
}
m_nSize = nSize;

return true;
6062}

6064/**
6065****************************************************************************
6066* Name: CIccTagFloatNum::GetValues
6067* 
6068* Purpose: Gets values from the num array tag as floating point numbers
6069* 
6070* Args: 
6071*  nSize - number of data entries,
6072*  bZeroNew - flag to zero newly formed values
6073*****************************************************************************
6074*/
6075template <class T, icTagTypeSignature Tsig>
6076bool CIccTagFloatNum<T, Tsig>::GetValues(icFloatNumber *DstVector, icUInt32Number nStart, icUInt32Number nVectorSize) const
6077{
if (nVectorSize >m_nSize)
  return false;

icUInt32Number i;

for (i=0; i<m_nSize; i++) {
  DstVector[i] = (icFloatNumber)m_Num[i+nStart];
}
return true;
6087}


6090/**
6091****************************************************************************
6092* Name: CIccTagFloatNum::Interpolate
6093* 
6094* Purpose: Gets values from the num array tag as floating point numbers
6095* 
6096* Args: 
6097*  nSize - number of data entries,
6098*  bZeroNew - flag to zero newly formed values
6099*****************************************************************************
6100*/
6101template <class T, icTagTypeSignature Tsig>
6102icValidateStatus CIccTagFloatNum<T, Tsig>::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile) const
6103{
icValidateStatus rv = icValidateOK;
//Check # of channels 
if (icGetFirstSigPathSig(sigPath) == icSigMaterialDefaultValuesTag && 
  pProfile &&
  m_nSize != icGetMaterialColorSpaceSamples(pProfile->m_Header.mcs)) {
    CIccInfo Info;
    std::string sSigPathName = Info.GetSigPathName(sigPath);

    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - Number of material default values does not match MCS in header.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
}

rv = icMaxStatus(rv, CIccTagNumArray::Validate(sigPath, sReport, pProfile));

return rv;
6121}



6125/**
6126****************************************************************************
6127* Name: CIccTagFloatNum::Interpolate
6128* 
6129* Purpose: Gets values from the num array tag as floating point numbers
6130* 
6131* Args: 
6132*  nSize - number of data entries,
6133*  bZeroNew - flag to zero newly formed values
6134*****************************************************************************
6135*/
6136template <class T, icTagTypeSignature Tsig>
6137bool CIccTagFloatNum<T, Tsig>::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                    icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
6139{
icUInt32Number nVector = m_nSize / nVectorSize;

if (!nVector)
  return false;

if (zeroVals)
  nVector ++;
else if (nVector<=1)
  return false;

if (pos<0.0)
  pos=0.0;
if (pos>1.0)
  pos=1.0;

icFloatNumber fpos = (icFloatNumber)(nVector-1) * pos;
icUInt32Number iPos = (icUInt32Number)fpos;
icFloatNumber x = fpos - iPos;
icFloatNumber invx = (1.0f - x);

if (iPos == nVector-1) {
  iPos--;
  x = (icFloatNumber)1.0f;
  invx = (icFloatNumber)0.0f;
}

T *lo, *hi;

if (zeroVals) {
  if (!iPos) {
    lo = NULL__null;
    hi = m_Num;
  }
  else {
    lo = &m_Num[(iPos-1)*nVectorSize];
    hi = &lo[nVectorSize];
  }
}
else {
  lo = &m_Num[iPos*nVectorSize];
  hi = &lo[nVectorSize];
}

icUInt32Number i;

if (!lo) {
  for (i=0; i<nVectorSize; i++) {
    DstVector[i] = (icFloatNumber)(zeroVals[i]*invx + hi[i]*x);
  }
}
else {
  for (i=0; i<nVectorSize; i++) {
    DstVector[i] = (icFloatNumber)(lo[i]*invx + hi[i]*x);
  }
}
return true;
6196}


6199/**
6200****************************************************************************
6201* Name: CIccTagFloatNum::ValuePos
6202* 
6203* Purpose: Gets position of a value int the num array tag
6204* 
6205* Args: 
6206*  DstPos - position of val in array
6207*  val - value to look for in array.
6208*  bNoZero - flag indicating whether first entry is zero
6209*****************************************************************************
6210*/
6211template <class T, icTagTypeSignature Tsig>
6212bool CIccTagFloatNum<T, Tsig>::ValuePos(icFloatNumber &DstPos, icFloatNumber val, bool &bNoZero) const
6213{
if(val<0.0)
  return false;

icFloatNumber nv, lv;

lv = (icFloatNumber)m_Num[0];

bNoZero = (lv!=0.0);

if (val<lv) {
  DstPos = val/lv - 1.0f;
  return true;
}

icUInt32Number i;
for (i=1; i<m_nSize; i++, lv=nv) {
  nv = (icFloatNumber)m_Num[i];

  if (val<=nv) {
    DstPos = (val-lv)/(nv-lv) + i - 1.0f;
    return true;
  }
}

return false;
6239}


6242//Make sure typedef classes get built
6243template class CIccTagFloatNum<icFloat32Number, icSigFloat16ArrayType>;
6244template class CIccTagFloatNum<icFloat32Number, icSigFloat32ArrayType>;
6245template class CIccTagFloatNum<icFloat64Number, icSigFloat64ArrayType>;

6247/**
****************************************************************************
* Name: CIccTagMeasurement::CIccTagMeasurement
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
6255CIccTagMeasurement::CIccTagMeasurement()
6256{
memset(&m_Data, 0, sizeof(m_Data));
6258}


6261/**
****************************************************************************
* Name: CIccTagMeasurement::CIccTagMeasurement
* 
* Purpose: Copy Constructor
*
* Args:
*  ITM = The CIccTagMeasurement object to be copied
*****************************************************************************
*/
6271CIccTagMeasurement::CIccTagMeasurement(const CIccTagMeasurement &ITM)
6272{
memcpy(&m_Data, &ITM.m_Data, sizeof(m_Data));
6274}


6277/**
****************************************************************************
* Name: CIccTagMeasurement::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  MeasTag = The CIccTagMeasurement object to be copied
*****************************************************************************
*/
6287CIccTagMeasurement &CIccTagMeasurement::operator=(const CIccTagMeasurement &MeasTag)
6288{
if (&MeasTag == this)
  return *this;

memcpy(&m_Data, &MeasTag.m_Data, sizeof(m_Data));

return *this;
6295}



6299/**
****************************************************************************
* Name: CIccTagMeasurement::~CIccTagMeasurement
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
6307CIccTagMeasurement::~CIccTagMeasurement()
6308{
6309}


6312/**
****************************************************************************
* Name: CIccTagMeasurement::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
6326bool CIccTagMeasurement::Read(icUInt32Number size, CIccIO *pIO)
6327{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(m_Data) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

icUInt32Number nSize=sizeof(m_Data)/sizeof(icUInt32Number);

if (pIO->Read32(&m_Data,nSize) != (icInt32Number)nSize)
  return false;

return true;
6351}


6354/**
****************************************************************************
* Name: CIccTagMeasurement::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
6367bool CIccTagMeasurement::Write(CIccIO *pIO)
6368{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

icUInt32Number nSize=sizeof(m_Data)/sizeof(icUInt32Number);

if (pIO->Write32(&m_Data,nSize) != (icInt32Number)nSize)
  return false;

return true;
6386}


6389/**
****************************************************************************
* Name: CIccTagMeasurement::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
6399void CIccTagMeasurement::Describe(std::string &sDescription)
6400{
CIccInfo Fmt;
icChar buf[128];

 sDescription += Fmt.GetStandardObserverName(m_Data.stdObserver); sDescription += "\r\n";
 sprintf(buf, "Backing measurement: X=%.4lf, Y=%.4lf, Z=%.4lf\r\n",
         icFtoD(m_Data.backing.X),
         icFtoD(m_Data.backing.Y),
         icFtoD(m_Data.backing.Z)); 
 sDescription += buf;
 sDescription += Fmt.GetMeasurementGeometryName(m_Data.geometry); sDescription += "\r\n";
 sDescription += Fmt.GetMeasurementFlareName(m_Data.flare); sDescription += "\r\n";
 sDescription += Fmt.GetIlluminantName(m_Data.illuminant); sDescription += "\r\n";
6413}


6416/**
6417******************************************************************************
6418* Name: CIccTagMeasurement::Validate
6419* 
6420* Purpose: Check tag data validity.
6421* 
6422* Args: 
6423*  sig = signature of tag being validated,
6424*  sReport = String to add report information to
6425* 
6426* Return: 
6427*  icValidateStatusOK if valid, or other error status.
6428******************************************************************************
6429*/
6430icValidateStatus CIccTagMeasurement::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
6431{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

switch(m_Data.stdObserver) {
case icStdObsUnknown:
case icStdObs1931TwoDegrees:
case icStdObs1964TenDegrees:
  break;

default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid standard observer encoding.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

switch(m_Data.geometry) {
case icGeometryUnknown:
case icGeometry045or450:
case icGeometry0dord0:
  break;

default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid measurement geometry encoding.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

switch(m_Data.illuminant) {
case icIlluminantUnknown:
case icIlluminantD50:
case icIlluminantD65:
case icIlluminantD93:
case icIlluminantF2:
case icIlluminantD55:
case icIlluminantA:
case icIlluminantEquiPowerE:
case icIlluminantF8:
  break;

default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid standard illuminant encoding.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

return rv;
6483}


6486/**
****************************************************************************
* Name: CIccLocalizedUnicode::CIccLocalizedUnicode
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
6494CIccLocalizedUnicode::CIccLocalizedUnicode()
6495{
m_pBuf = (icUInt16Number*)malloc(1*sizeof(icUInt16Number));
*m_pBuf = 0;
m_nLength = 0;
6499}


6502/**
****************************************************************************
* Name: CIccLocalizedUnicode::CIccLocalizedUnicode
* 
* Purpose: Copy Constructor
*
* Args:
*  ILU = The CIccLocalizedUnicode object to be copied
*****************************************************************************
*/
6512CIccLocalizedUnicode::CIccLocalizedUnicode(const CIccLocalizedUnicode& ILU)
6513{
m_nLength = ILU.GetLength();
m_pBuf = (icUInt16Number*)malloc((m_nLength+1) * sizeof(icUInt16Number));
if (m_nLength)
  memcpy(m_pBuf, ILU.GetBuf(), m_nLength*sizeof(icUInt16Number));
m_pBuf[m_nLength] = 0;
m_nLanguageCode = ILU.m_nLanguageCode;
m_nCountryCode = ILU.m_nCountryCode;
6521}


6524/**
****************************************************************************
* Name: CIccLocalizedUnicode::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  UnicodeText = The CIccLocalizedUnicode object to be copied
*****************************************************************************
*/
6534CIccLocalizedUnicode &CIccLocalizedUnicode::operator=(const CIccLocalizedUnicode &UnicodeText)
6535{
if (&UnicodeText == this)
  return *this;

if (SetSize(UnicodeText.GetLength())) {
  memcpy(m_pBuf, UnicodeText.GetBuf(), m_nLength*sizeof(icUInt16Number));
}
m_nLanguageCode = UnicodeText.m_nLanguageCode;
m_nCountryCode = UnicodeText.m_nCountryCode;

return *this;
6546}


6549/**
****************************************************************************
* Name: CIccLocalizedUnicode::~CIccLocalizedUnicode
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
6557CIccLocalizedUnicode::~CIccLocalizedUnicode()
6558{
if (m_pBuf)
  free(m_pBuf);
6561}

6563/**
****************************************************************************
* Name: CIccLocalizedUnicode::GetAnsiSize
* 
* Purpose: Returns the size of the ANSI data buffer
*
*****************************************************************************
*/
6571icUInt32Number CIccLocalizedUnicode::GetAnsiSize()
6572{
icUInt32Number len;
6574#ifdef USE_WINDOWS_MB_SUPPORT
len = WideCharToMultiByte(CP_ACP, 0x00000400, (LPCWSTR)m_pBuf, m_nLength,  NULL__null, 0, NULL__null, NULL__null);
6576#else
len = m_nLength;   
6578#endif

return len;
6581}

6583/**
****************************************************************************
* Name: CIccLocalizedUnicode::GetAnsi
* 
* Purpose: Extracts the ANSI data buffer
*
* Args:
*  szBuf = pointer where the returned string buffer is to be stored
*  nBufSize = size of the buffer to be extracted
*
* Return:
*  Pointer to the ANSI data string
*****************************************************************************
*/
6597const icChar *CIccLocalizedUnicode::GetAnsi(icChar *szBuf, icUInt32Number nBufSize)
6598{
if (!szBuf)
  return NULL__null;

if (!m_nLength) {
  *szBuf='\0';
}
else {
6606#ifdef USE_WINDOWS_MB_SUPPORT
  int len = WideCharToMultiByte(CP_ACP, 0x00000400, (LPCWSTR)m_pBuf, m_nLength,  szBuf, nBufSize, NULL__null, NULL__null);
  szBuf[len]='\0';
6609#else
icUInt32Number i;

  for (i=0; i<m_nLength; i++) {
    if (m_pBuf[i]<256) {
      szBuf[i] = (icChar)m_pBuf[i];
    }
    else {
      szBuf[i] = '?';
    }
  }
6620#endif
}

return szBuf;
6624}

6626/**
6627****************************************************************************
6628* Name: CIccLocalizedUnicode::GetText
6629*
6630* Purpose: Sets a standard string with the text
6631*
6632* Args:
6633*  nSize - length of the string
6634*
6635*****************************************************************************
6636*/
6637bool CIccLocalizedUnicode::GetText(std::string &sText)
6638{
icUInt32Number size = GetAnsiSize();
char *buf = (char*)malloc(size+1);
if (buf) {
  GetAnsi(buf, size);
  sText = buf;
  free(buf);
  return true;
}
sText = "";
return false;
6649}


6652/**
****************************************************************************
* Name: CIccLocalizedUnicode::SetSize
* 
* Purpose: Sets the size of the string buffer.
* 
* Args: 
*  nSize - length of the string
*
*****************************************************************************
*/
6663bool CIccLocalizedUnicode::SetSize(icUInt32Number nSize)
6664{
if (nSize == m_nLength)
  return true;

m_pBuf = (icUInt16Number*)icRealloc(m_pBuf, (nSize+1)*sizeof(icUInt16Number));

if (!m_pBuf) {
  m_nLength = 0;
  return false;
}

m_nLength = nSize;

m_pBuf[nSize]=0;

return true;
6680}

6682/**
****************************************************************************
* Name: CIccLocalizedUnicode::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  szText = zero terminated string to put in tag,
*  nLanguageCode = the language code type as defined by icLanguageCode,
*  nRegionCode = the region code type as defined by icCountryCode
*****************************************************************************
*/
6694bool CIccLocalizedUnicode::SetText(const icChar *szText,
                                 icLanguageCode nLanguageCode/* = icLanguageCodeEnglish*/,
                                 icCountryCode nRegionCode/* = icCountryCodeUSA*/)
6697{
int len=(icInt32Number)strlen(szText), i;
icUInt16Number *pBuf;

if (!SetSize(len))
  return false;

pBuf = m_pBuf;
for (i=0; i<len; i++) {
  *pBuf++ = *szText++;
}
*pBuf = 0;

m_nLanguageCode = nLanguageCode;
m_nCountryCode = nRegionCode;

return true;
6714}

6716/**
****************************************************************************
* Name: CIccLocalizedUnicode::SetText
* 
* Purpose: Allows text data associated with the tag to be set.
* 
* Args: 
*  sszUnicode16Text = Unicode16 text to be set,
*  nLanguageCode = the language code type as defined by icLanguageCode,
*  nRegionCode = the region code type as defined by icCountryCode
*****************************************************************************
*/
6728bool CIccLocalizedUnicode::SetText(const icUInt16Number *sszUnicode16Text,
                                 icLanguageCode nLanguageCode/* = icLanguageCodeEnglish*/,
                                 icCountryCode nRegionCode/* = icCountryCodeUSA*/)
6731{
const icUInt16Number *pBuf=sszUnicode16Text;
int len;

for (len=0; *pBuf; len++, pBuf++);

if (!SetSize(len))
  return false;
memcpy(m_pBuf, sszUnicode16Text, (len+1)*sizeof(icUInt16Number));

m_nLanguageCode = nLanguageCode;
m_nCountryCode = nRegionCode;

return true;
6745}

6747/**
6748****************************************************************************
6749* Name: CIccLocalizedUnicode::SetText
6750* 
6751* Purpose: Allows text data associated with the tag to be set.
6752* 
6753* Args: 
6754*  sszUnicode32Text = Unicode32 text to be set,
6755*  nLanguageCode = the language code type as defined by icLanguageCode,
6756*  nRegionCode = the region code type as defined by icCountryCode
6757*****************************************************************************
6758*/
6759bool CIccLocalizedUnicode::SetText(const icUInt32Number *sszUnicode32Text,
                                 icLanguageCode nLanguageCode/* = icLanguageCodeEnglish*/,
                                 icCountryCode nRegionCode/* = icCountryCodeUSA*/)
6762{
const icUInt32Number *pBuf=sszUnicode32Text;
int len;

for (len=0; *pBuf; len++, pBuf++);
if (*pBuf)
  pBuf--;

if (!SetSize(len*2))
  return false;

const icUInt32Number *srcStart = sszUnicode32Text;
icUInt16Number *dstStart = m_pBuf;
icConvertUTF32toUTF16(&srcStart, &srcStart[len], &dstStart, &dstStart[len*2], lenientConversion);

*dstStart=0;
if (!SetSize((icUInt32Number)(dstStart - m_pBuf)))
  return false;

m_nLanguageCode = nLanguageCode;
m_nCountryCode = nRegionCode;

return true;
6785}


6788/**
****************************************************************************
* Name: CIccTagMultiLocalizedUnicode::CIccTagMultiLocalizedUnicode
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
6796CIccTagMultiLocalizedUnicode::CIccTagMultiLocalizedUnicode()
6797{
m_Strings = new(CIccMultiLocalizedUnicode);
6799}


6802/**
****************************************************************************
* Name: CIccTagMultiLocalizedUnicode::CIccTagMultiLocalizedUnicode
* 
* Purpose: Copy Constructor
*
* Args:
*  ITMLU = The CIccTagMultiLocalizedUnicode object to be copied
*****************************************************************************
*/
6812CIccTagMultiLocalizedUnicode::CIccTagMultiLocalizedUnicode(const CIccTagMultiLocalizedUnicode& ITMLU)
6813{
m_Strings = new(CIccMultiLocalizedUnicode);
*m_Strings = *ITMLU.m_Strings;
6816}


6819/**
****************************************************************************
* Name: CIccTagMultiLocalizedUnicode::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  MultiLocalizedTag = The CIccTagMultiLocalizedUnicode object to be copied
*****************************************************************************
*/
6829CIccTagMultiLocalizedUnicode &CIccTagMultiLocalizedUnicode::operator=(const CIccTagMultiLocalizedUnicode &MultiLocalizedTag)
6830{
if (&MultiLocalizedTag == this)
  return *this;

m_Strings->clear();
*m_Strings = *MultiLocalizedTag.m_Strings;

return *this;
6838}


6841/**
****************************************************************************
* Name: CIccTagMultiLocalizedUnicode::~CIccTagMultiLocalizedUnicode
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
6849CIccTagMultiLocalizedUnicode::~CIccTagMultiLocalizedUnicode()
6850{
delete m_Strings;
6852}


6855/**
****************************************************************************
* Name: CIccTagMultiLocalizedUnicode::Read
* 
* Purpose: Read in the tag contents into a data block
*
* Since MultiLocalizedUnicode tags can be embedded in other tags
* this function ensures that the current read pointer will be set to the
* position just after the last name record.
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
6873bool CIccTagMultiLocalizedUnicode::Read(icUInt32Number size, CIccIO *pIO)
6874{
icTagTypeSignature sig;
icUInt32Number nNumRec, nRecSize;
icLanguageCode nLanguageCode;
icCountryCode nRegionCode;
icUInt32Number nLength, nOffset, nNumChar;

if (!m_Strings->empty())
  m_Strings->clear();

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number)*3 > size)
  return false;

if (!pIO) {
  return false;
}

icUInt32Number nTagPos = pIO->Tell();

if (!pIO->Read32(&sig) ||
    !pIO->Read32(&m_nReserved) ||
    !pIO->Read32(&nNumRec) ||
    !pIO->Read32(&nRecSize))
  return false;


if (nRecSize!=12) { //Recognized version name records are 12 bytes each
  return false;
}

icUInt32Number i; 
CIccLocalizedUnicode Unicode;
icUInt32Number nLastPos = 0;

for (i=0; i<nNumRec; i++) {
  if (4*sizeof(icUInt32Number) + (i+1)*12 > size)
    return false;

  pIO->Seek(nTagPos+4*sizeof(icUInt32Number) + i*12, icSeekSet);

  if (!pIO->Read16(&nLanguageCode) ||
      !pIO->Read16(&nRegionCode) ||
      !pIO->Read32(&nLength) ||
      !pIO->Read32(&nOffset))
    return false;
  
  if (nOffset+nLength > size)
    return false;

  //Find out position of the end of last named record
  if (nOffset+nLength > nLastPos)
    nLastPos = nOffset + nLength;

  nNumChar = nLength / sizeof(icUInt16Number);

  if (!Unicode.SetSize(nNumChar))
    return false;

  Unicode.m_nLanguageCode = nLanguageCode;
  Unicode.m_nCountryCode = nRegionCode;

  pIO->Seek(nTagPos+nOffset, icSeekSet);

  if (pIO->Read16(Unicode.GetBuf(), nNumChar) != (icInt32Number)nNumChar)
    return false;

  m_Strings->push_back(Unicode);
}

//Now seek past the last named record
if (nLastPos > 0)
  pIO->Seek(nTagPos+nLastPos, icSeekSet);

return true;
6949}


6952/**
****************************************************************************
* Name: CIccTagMultiLocalizedUnicode::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
6965bool CIccTagMultiLocalizedUnicode::Write(CIccIO *pIO)
6966{
icTagTypeSignature sig = GetType();
icUInt32Number nNumRec=(icUInt32Number)m_Strings->size(), nRecSize=12;
icUInt32Number nLength;

if (!pIO) {
  return false;
}

if (!pIO->Write32(&sig) ||
    !pIO->Write32(&m_nReserved) ||
    !pIO->Write32(&nNumRec) ||
    !pIO->Write32(&nRecSize))
  return false;


icUInt32Number nPos = 4*sizeof(icUInt32Number) + nNumRec*12;

CIccMultiLocalizedUnicode::iterator i;

for (i=m_Strings->begin(); i!=m_Strings->end(); i++) {
  nLength = i->GetLength() * sizeof(icUInt16Number);

  if (!pIO->Write16(&i->m_nLanguageCode) ||
      !pIO->Write16(&i->m_nCountryCode) ||
      !pIO->Write32(&nLength) ||
      !pIO->Write32(&nPos))
    return false;
  nPos += nLength;
}

for (i=m_Strings->begin(); i!=m_Strings->end(); i++) {
  nLength = i->GetLength();

  if (nLength) {
    if (pIO->Write16(i->GetBuf(), nLength) != (icInt32Number)nLength)
      return false;
  }
}

return true;
7007}


7010/**
****************************************************************************
* Name: CIccTagMultiLocalizedUnicode::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
7020void CIccTagMultiLocalizedUnicode::Describe(std::string &sDescription)
7021{
icChar *szBuf = (icChar*)malloc(128);
int nSize = 127, nAnsiSize;
CIccMultiLocalizedUnicode::iterator i;

if (!szBuf) {
  sDescription += "***Allocation Error***\r\n";
  return;
}

for (i=m_Strings->begin(); i!=m_Strings->end(); i++) {
  if (i!=m_Strings->begin())
    sDescription += "\r\n";

  sprintf(szBuf, "Language = '%c%c', Region = '%c%c'\r\n",
    i->m_nLanguageCode>>8, i->m_nLanguageCode,
    i->m_nCountryCode>>8, i->m_nCountryCode);
  
  sDescription += szBuf;

  nAnsiSize = i->GetAnsiSize();

  if (nAnsiSize>nSize) {
    szBuf = (icChar*)icRealloc(szBuf, nAnsiSize+1);

    if (!szBuf)
      nSize = 0;
    else
    nSize = nAnsiSize;
  }
  if (szBuf) {
    i->GetAnsi(szBuf, nSize);
    sDescription += "\"";
    sDescription += szBuf;
    sDescription += "\"\r\n";
  }
  else {
    sDescription += "***Allocation Error***\r\n";
  }
}
7061}


7064/**
7065******************************************************************************
7066* Name: CIccTagMultiLocalizedUnicode::Validate
7067* 
7068* Purpose: Check tag data validity.
7069* 
7070* Args: 
7071*  sig = signature of tag being validated,
7072*  sReport = String to add report information to
7073* 
7074* Return: 
7075*  icValidateStatusOK if valid, or other error status.
7076******************************************************************************
7077*/
7078icValidateStatus CIccTagMultiLocalizedUnicode::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
7079{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!m_Strings->size()) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty tag!\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}

// TODO: Look at the ISO-639 and ISO-3166 documents for valid 
// Language and Region codes
7094/*
CIccMultiLocalizedUnicode::iterator i;
for (i=m_Strings->begin(); i!=m_Strings->end(); i++) {
  switch(i->m_nLanguageCode) {
  case :
    break;
  default:
  }

  switch(i->m_nRegionCode) {
  case :
    break;
  default:
  }
}
7109*/

return rv;
7112}

7114/**
7115****************************************************************************
7116* Name: refIccMAX::CIccTagMultiLocalizedUnicode::Find
7117* 
7118* Purpose: 
7119* 
7120* Args:
7121*  nLanguageCode
7122*  nRegionCode
7123*
7124* Return:
7125*  Pointer to CIccLocalizedUnicode object associated with the nLanguageCode
7126*  and nRegionCode or NULL if not found
7127*****************************************************************************
7128*/
7129CIccLocalizedUnicode *CIccTagMultiLocalizedUnicode::Find(icLanguageCode nLanguageCode /* = icLanguageCodeEnglish */,
                                                       icCountryCode nRegionCode /* = icCountryCodeUSA */)
7131{
CIccMultiLocalizedUnicode::iterator i;

for (i=m_Strings->begin(); i!=m_Strings->end(); i++) {
  if (i->m_nLanguageCode == nLanguageCode &&
    i->m_nCountryCode == nRegionCode) {
    return &(*i);
  }
}

return NULL__null;
7142}

7144/**
7145****************************************************************************
7146* Name: refIccMAX::CIccTagMultiLocalizedUnicode::SetText
7147* 
7148* Purpose: 
7149* 
7150* Args:
7151*  sszUnicodeText
7152*  nLanguageCode
7153*  RegionCode
7154*****************************************************************************
7155*/
7156void CIccTagMultiLocalizedUnicode::SetText(const icChar *szText, 
                                         icLanguageCode nLanguageCode /* = icLanguageCodeEnglish */,
                                         icCountryCode nRegionCode /* = icCountryCodeUSA */)
7159{
 CIccLocalizedUnicode *pText = Find(nLanguageCode, nRegionCode);

 if (!pText) {
   CIccLocalizedUnicode newText;
   newText.SetText(szText, nLanguageCode, nRegionCode);
   m_Strings->push_back(newText);
 }
 else {
   pText->SetText(szText, nLanguageCode, nRegionCode);
 }
7170}


7173/**
7174****************************************************************************
7175* Name: refIccMAX::CIccTagMultiLocalizedUnicode::SetText
7176* 
7177* Purpose: 
7178* 
7179* Args:
7180*  sszUnicodeText
7181*  nLanguageCode
7182*  RegionCode
7183*****************************************************************************
7184*/
7185void CIccTagMultiLocalizedUnicode::SetText(const icUInt16Number *sszUnicode16Text, 
                                         icLanguageCode nLanguageCode /* = icLanguageCodeEnglish */,
                                         icCountryCode nRegionCode /* = icCountryCodeUSA */)
7188{
CIccLocalizedUnicode *pText = Find(nLanguageCode, nRegionCode);

if (!pText) {
  CIccLocalizedUnicode newText;
  newText.SetText(sszUnicode16Text, nLanguageCode, nRegionCode);
  m_Strings->push_back(newText);
}
else {
  pText->SetText(sszUnicode16Text, nLanguageCode, nRegionCode);
}
7199}

7201/**
7202****************************************************************************
7203* Name: refIccMAX::CIccTagMultiLocalizedUnicode::SetText
7204* 
7205* Purpose: 
7206* 
7207* Args:
7208*  sszUnicodeText
7209*  nLanguageCode
7210*  RegionCode
7211*****************************************************************************
7212*/
7213void CIccTagMultiLocalizedUnicode::SetText(const icUInt32Number *sszUnicode32Text, 
                                         icLanguageCode nLanguageCode /* = icLanguageCodeEnglish */,
                                         icCountryCode nRegionCode /* = icCountryCodeUSA */)
7216{
CIccLocalizedUnicode *pText = Find(nLanguageCode, nRegionCode);

if (!pText) {
  CIccLocalizedUnicode newText;
  newText.SetText(sszUnicode32Text, nLanguageCode, nRegionCode);
  m_Strings->push_back(newText);
}
else {
  pText->SetText(sszUnicode32Text, nLanguageCode, nRegionCode);
}
7227}

7229//
7230// MD: Moved Curve and LUT tags to IccTagLut.cpp (4-30-05)
7231//


7234/**
****************************************************************************
* Name: CIccTagData::CIccTagData
* 
* Purpose: Constructor
*
* Args:
*  nSize = number of data entries
* 
*****************************************************************************
*/
7245CIccTagData::CIccTagData(int nSize/*=1*/)
7246{
m_nSize = nSize;
if (m_nSize <1)
  m_nSize = 1;
m_pData = (icUInt8Number*)calloc(nSize, sizeof(icUInt8Number));
7251}


7254/**
****************************************************************************
* Name: CIccTagData::CIccTagData
* 
* Purpose: Copy Constructor
*
* Args:
*  ITD = The CIccTagData object to be copied
*****************************************************************************
*/
7264CIccTagData::CIccTagData(const CIccTagData &ITD)
7265{
m_nDataFlag = ITD.m_nDataFlag;
m_nSize = ITD.m_nSize;

m_pData = (icUInt8Number*)calloc(m_nSize, sizeof(icUInt8Number));
memcpy(m_pData, ITD.m_pData, sizeof(icUInt8Number)*m_nSize);
7271}


7274/**
****************************************************************************
* Name: CIccTagData::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  DataTag = The CIccTagData object to be copied
*****************************************************************************
*/
7284CIccTagData &CIccTagData::operator=(const CIccTagData &DataTag)
7285{
if (&DataTag == this)
  return *this;

m_nDataFlag = DataTag.m_nDataFlag;
m_nSize = DataTag.m_nSize;

if (m_pData)
  free(m_pData);
m_pData = (icUInt8Number*)calloc(m_nSize, sizeof(icUInt8Number));
memcpy(m_pData, DataTag.m_pData, sizeof(icUInt8Number)*m_nSize);

return *this;
7298}


7301/**
****************************************************************************
* Name: CIccTagData::~CIccTagData
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
7309CIccTagData::~CIccTagData()
7310{
if (m_pData)
  free(m_pData);
7313}


7316/**
****************************************************************************
* Name: CIccTagData::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
7330bool CIccTagData::Read(icUInt32Number size, CIccIO *pIO)
7331{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icUInt32Number) +
    sizeof(icUInt8Number) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

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

icUInt32Number nNum = size-3*sizeof(icUInt32Number);

if (!SetSize(nNum))
  return false;

if (pIO->Read8(m_pData, nNum) != (icInt32Number)nNum)
  return false;

if (IsTypeCompressed()) {
  //Uncompress data here
}

return true;
7366}


7369/**
****************************************************************************
* Name: CIccTagData::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
7382bool CIccTagData::Write(CIccIO *pIO)
7383{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

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

if (IsTypeCompressed()) {
  icUInt32Number *pData = NULL__null;
  icInt32Number nSize = 0;
  //Compress data here

  if (pIO->Write8(pData, nSize) != (icInt32Number)nSize)
    return false;
}
else {
  if (pIO->Write8(m_pData, m_nSize) != (icInt32Number)m_nSize)
    return false;
}

return true;
7412}


7415/**
****************************************************************************
* Name: CIccTagData::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
7425void CIccTagData::Describe(std::string &sDescription)
7426{
icChar buf[128];

sDescription = "\r\n";
if (IsTypeCompressed())
  sDescription += "Compressed ";  // If data is compressed, prepend appropriate text

if (IsTypeAscii()) {
  sDescription = "Ascii Data:\r\n";

  for (int i=0; i<(int)m_nSize; i++)
    sDescription += (icChar)m_pData[i];
}
else if (IsTypeUtf()) {
  if (m_nSize>2 && 
      ((m_pData[0]==0xff && m_pData[1]==0xfe) ||  //UTF-16LE
       (m_pData[0]==0xfe && m_pData[1]==0xff))) { //UTF-16BE
    sprintf(buf, "UTF-16%s Data:", m_pData[0]==0xff ? "LE" : "BE" );
    sDescription = buf;

    icMemDump(sDescription, m_pData, m_nSize);
  }
  else { //UTF-8
    sDescription = "UTF-8 Data:\r\n";

    for (int i=0; i<(int)m_nSize; i++)
      sDescription += (icChar)m_pData[i];
  }
}
else {
  if (IsTypeBinary()) {
    sDescription = "Binary Data:\r\n";
  }
  else {
    sDescription = "Other Data:\r\n";
  }

  icMemDump(sDescription, m_pData, m_nSize);
}
sDescription += "\r\n";
7466}

7468/**
****************************************************************************
* Name: CIccTagData::SetSize
* 
* Purpose: Sets the size of the data array.
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
7479bool CIccTagData::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
7480{
if (m_nSize == nSize)
  return true;

m_pData = (icUInt8Number*)icRealloc(m_pData, nSize*sizeof(icUInt8Number));

if (!m_pData) {
  m_nSize = 0;
  return false;
}

if (bZeroNew && nSize > m_nSize) {
  memset(&m_pData[m_nSize], 0, (nSize-m_nSize)*sizeof(icUInt8Number));
}
m_nSize = nSize;

return true;
7497}


7500/**
7501******************************************************************************
7502* Name: CIccTagData::Validate
7503* 
7504* Purpose: Check tag data validity.
7505* 
7506* Args: 
7507*  sig = signature of tag being validated,
7508*  sReport = String to add report information to
7509* 
7510* Return: 
7511*  icValidateStatusOK if valid, or other error status.
7512******************************************************************************
7513*/
7514icValidateStatus CIccTagData::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
7515{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

// Mask bits to match processing in Describe() so warnings are appropriate
switch(m_nDataFlag&(icCompressedData0x00010000|icDataTypeMask0x0000ffff)) {
case icAsciiData:
  for (int i = 0; i < (int)m_nSize; i++) {
    if (m_pData[i] & 0x80) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " - Ascii Data is not just 7-bit data.\r\n";
      rv = icMaxStatus(rv, icValidateWarning);
      break;
    }
  }
  break;
case icBinaryData:
case icUtfData:
case icCompressedAsciiData:
case icCompressedBinaryData:
case icCompressedUtfData:
  break;
default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid data flag encoding.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

if (m_nDataFlag & ~(icCompressedData0x00010000 | icDataTypeMask0x0000ffff)) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Invalid data flag encoding (reserved high order bits).\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
}

return rv;
7555}


7558/**
****************************************************************************
* Name: CIccTagDateTime::CIccTagDateTime
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
7566CIccTagDateTime::CIccTagDateTime()
7567{
memset(&m_DateTime, 0, sizeof(m_DateTime));
7569}


7572/**
****************************************************************************
* Name: CIccTagDateTime::CIccTagDateTime
* 
* Purpose: Copy Constructor
*
* Args:
*  ITDT = The CIccTagDateTime object to be copied
*****************************************************************************
*/
7582CIccTagDateTime::CIccTagDateTime(const CIccTagDateTime &ITDT)
7583{
memcpy(&m_DateTime, &ITDT.m_DateTime, sizeof(m_DateTime));
7585}


7588/**
****************************************************************************
* Name: CIccTagDateTime::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  DateTimeTag = The CIccTagDateTime object to be copied
*****************************************************************************
*/
7598CIccTagDateTime &CIccTagDateTime::operator=(const CIccTagDateTime &DateTimeTag)
7599{
if (&DateTimeTag == this)
  return *this;

memcpy(&m_DateTime, &DateTimeTag.m_DateTime, sizeof(m_DateTime));

return *this;
7606}


7609/**
****************************************************************************
* Name: CIccTagDateTime::~CIccTagDateTime
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
7617CIccTagDateTime::~CIccTagDateTime()
7618{
7619}



7623/**
****************************************************************************
* Name: CIccTagDateTime::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
7637bool CIccTagDateTime::Read(icUInt32Number size, CIccIO *pIO)
7638{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icDateTimeNumber) > size)
  return false;

if (!pIO) {
  return false;
}

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

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


icUInt32Number nsize = (size-2*sizeof(icUInt32Number))/sizeof(icUInt16Number);

if (nsize > sizeof(m_DateTime) / sizeof(icUInt16Number))
  return false;

if (pIO->Read16(&m_DateTime,nsize) != (icInt32Number)nsize)
  return false;

return true;
7666}



7670/**
****************************************************************************
* Name: CIccTagDateTime::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
7683bool CIccTagDateTime::Write(CIccIO *pIO)
7684{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (pIO->Write16(&m_DateTime,6) != 6)
  return false;

return true;
7700}



7704/**
****************************************************************************
* Name: CIccTagDateTime::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
7714void CIccTagDateTime::Describe(std::string &sDescription)
7715{
icChar buf[128];

sDescription = "Date = ";
sprintf(buf, "%u-%u-%u\r\n", m_DateTime.month, m_DateTime.day, m_DateTime.year);
sDescription += buf;

sDescription += "Time = ";
sprintf(buf, "%u:%u:%u\r\n", m_DateTime.hours, m_DateTime.minutes, m_DateTime.seconds);
sDescription += buf;
7725}


7728/**
7729******************************************************************************
7730* Name: CIccTagDateTime::Validate
7731* 
7732* Purpose: Check tag data validity.
7733* 
7734* Args: 
7735*  sig = signature of tag being validated,
7736*  sReport = String to add report information to
7737* 
7738* Return: 
7739*  icValidateStatusOK if valid, or other error status.
7740******************************************************************************
7741*/
7742icValidateStatus CIccTagDateTime::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
7743{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);
CIccInfo Info;

rv = icMaxStatus(rv, Info.CheckData(sReport, m_DateTime));

return rv;
7750}



7754/**
****************************************************************************
* Name: CIccTagColorantOrder::CIccTagColorantOrder
* 
* Purpose: Constructor
* 
* Args:
*  nSize = number of channels
* 
*****************************************************************************
*/
7765CIccTagColorantOrder::CIccTagColorantOrder(int nsize/*=1*/)
7766{
m_nCount = nsize;
if (m_nCount <1)
  m_nCount = 1;
m_pData = (icUInt8Number*)calloc(nsize, sizeof(icUInt8Number));
7771}



7775/**
****************************************************************************
* Name: CIccTagColorantOrder::CIccTagColorantOrder
* 
* Purpose: Copy Constructor
*
* Args:
*  ITCO = The CIccTagColorantOrder object to be copied
*****************************************************************************
*/
7785CIccTagColorantOrder::CIccTagColorantOrder(const CIccTagColorantOrder &ITCO)
7786{
m_nCount = ITCO.m_nCount;

m_pData = (icUInt8Number*)calloc(m_nCount, sizeof(icUInt8Number));
memcpy(m_pData, ITCO.m_pData, sizeof(icUInt8Number)*m_nCount);
7791}


7794/**
****************************************************************************
* Name: CIccTagColorantOrder::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ColorantOrderTag = The CIccTagColorantOrder object to be copied
*****************************************************************************
*/
7804CIccTagColorantOrder &CIccTagColorantOrder::operator=(const CIccTagColorantOrder &ColorantOrderTag)
7805{
if (&ColorantOrderTag == this)
  return *this;

m_nCount = ColorantOrderTag.m_nCount;

if (m_pData)
  free(m_pData);
m_pData = (icUInt8Number*)calloc(m_nCount, sizeof(icUInt8Number));
memcpy(m_pData, ColorantOrderTag.m_pData, sizeof(icUInt8Number)*m_nCount);

return *this;
7817}


7820/**
****************************************************************************
* Name: CIccTagColorantOrder::~CIccTagColorantOrder
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
7828CIccTagColorantOrder::~CIccTagColorantOrder()
7829{
if (m_pData)
  free(m_pData);
7832}



7836/**
****************************************************************************
* Name: CIccTagColorantOrder::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
7850bool CIccTagColorantOrder::Read(icUInt32Number size, CIccIO *pIO)
7851{
icTagTypeSignature sig;
icUInt32Number nCount;

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

if (!pIO) {
  return false;
}

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

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

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

icUInt32Number nNum = (size - 3*sizeof(icUInt32Number))/sizeof(icUInt8Number);

if (nNum < nCount)
  return false;

if (!SetSize((icUInt16Number)nCount))
  return false;

if (pIO->Read8(&m_pData[0], m_nCount) != (icInt32Number)m_nCount)
  return false;

return true;
7885}



7889/**
****************************************************************************
* Name: CIccTagColorantOrder::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
7902bool CIccTagColorantOrder::Write(CIccIO *pIO)
7903{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

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

if (pIO->Write8(&m_pData[0], m_nCount) != (icInt32Number)m_nCount)
  return false;

return true;
7922}



7926/**
****************************************************************************
* Name: CIccTagColorantOrder::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
7936void CIccTagColorantOrder::Describe(std::string &sDescription)
7937{
icChar buf[128];

sprintf(buf, "Colorant Count : %u\r\n", m_nCount);
sDescription += buf;
sDescription += "Order of Colorants:\r\n";

for (int i=0; i<(int)m_nCount; i++) {
  sprintf(buf, "%u\r\n", m_pData[i]);
  sDescription += buf;
}
7948}


7951/**
****************************************************************************
* Name: CIccTagColorantOrder::SetSize
* 
* Purpose: Sets the size of the data array.
* 
* Args: 
*  nSize - number of channels,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
7962bool CIccTagColorantOrder::SetSize(icUInt16Number nSize, bool bZeroNew/*=true*/)
7963{
if (m_nCount == nSize)
  return true;

m_pData = (icUInt8Number*)icRealloc(m_pData, nSize*sizeof(icUInt8Number));

if (!m_pData) {
  m_nCount = 0;
  return false;
}

if (bZeroNew && nSize > m_nCount) {
  memset(&m_pData[m_nCount], 0, (nSize - m_nCount)*sizeof(icUInt8Number));
}

m_nCount = nSize;

return true;
7981}


7984/**
7985******************************************************************************
7986* Name: CIccTagColorantOrder::Validate
7987* 
7988* Purpose: Check tag data validity.
7989* 
7990* Args: 
7991*  sig = signature of tag being validated,
7992*  sReport = String to add report information to
7993* 
7994* Return: 
7995*  icValidateStatusOK if valid, or other error status.
7996******************************************************************************
7997*/
7998icValidateStatus CIccTagColorantOrder::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
7999{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!pProfile) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Tag validation incomplete: Pointer to profile unavailable.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
  return rv;
}

if (sigPath==icGetSigPath(icSigColorantTableTag)) {
  if (m_nCount != icGetSpaceSamples(pProfile->m_Header.colorSpace)) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Incorrect number of colorants.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
}
else if (sigPath==icGetSigPath(icSigColorantTableOutTag)) {
  if (m_nCount != icGetSpaceSamples(pProfile->m_Header.pcs)) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Incorrect number of colorants.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
}
else {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Unknown number of required colorants.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}

return rv;
8037}



8041/**
****************************************************************************
* Name: CIccTagColorantTable::CIccTagColorantTable
* 
* Purpose: Constructor
* 
* Args:
*  nSize = number of entries
* 
*****************************************************************************
*/
8052CIccTagColorantTable::CIccTagColorantTable(int nSize/*=1*/)
8053{
m_nCount = nSize;
if (m_nCount<1)
  m_nCount = 1;

m_pData = (icColorantTableEntry*)calloc(nSize, sizeof(icColorantTableEntry));
8059}


8062/**
****************************************************************************
* Name: CIccTagColorantTable::CIccTagColorantTable
* 
* Purpose: Copy Constructor
*
* Args:
*  ITCT = The CIccTagUnknown object to be copied
*****************************************************************************
*/
8072CIccTagColorantTable::CIccTagColorantTable(const CIccTagColorantTable &ITCT)
8073{
m_PCS = ITCT.m_PCS;
m_nCount = ITCT.m_nCount;

m_pData = (icColorantTableEntry*)calloc(m_nCount, sizeof(icColorantTableEntry));
memcpy(m_pData, ITCT.m_pData, m_nCount*sizeof(icColorantTableEntry));
8079}


8082/**
****************************************************************************
* Name: CIccTagColorantTable::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ColorantTableTag = The CIccTagColorantTable object to be copied
*****************************************************************************
*/
8092CIccTagColorantTable &CIccTagColorantTable::operator=(const CIccTagColorantTable &ColorantTableTag)
8093{
if (&ColorantTableTag == this)
  return *this;

m_PCS = ColorantTableTag.m_PCS;
m_nCount = ColorantTableTag.m_nCount;

if (m_pData)
  free(m_pData);
m_pData = (icColorantTableEntry*)calloc(m_nCount, sizeof(icColorantTableEntry));
memcpy(m_pData, ColorantTableTag.m_pData, m_nCount*sizeof(icColorantTableEntry));

return *this;
8106}


8109/**
****************************************************************************
* Name: CIccTagColorantTable::~CIccTagColorantTable
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
8117CIccTagColorantTable::~CIccTagColorantTable()
8118{
if (m_pData)
  free(m_pData);
8121}


8124/**
****************************************************************************
* Name: CIccTagColorantTable::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
8138bool CIccTagColorantTable::Read(icUInt32Number size, CIccIO *pIO)
8139{
icTagTypeSignature sig;
icUInt32Number nCount;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icUInt32Number) +
    sizeof(icColorantTableEntry) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

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

icUInt32Number nNum = (size - 3*sizeof(icUInt32Number))/sizeof(icColorantTableEntry);
icUInt32Number nNum8 = sizeof(m_pData->name);
icUInt32Number nNum16 = sizeof(m_pData->data)/sizeof(icUInt16Number);

if (nNum < nCount || nCount > 0xffff)
  return false;

if (!SetSize((icUInt16Number)nCount))
  return false;

for (icUInt32Number i=0; i<nCount; i++) {
  if (pIO->Read8(&m_pData[i].name[0], nNum8) != (icInt32Number)nNum8)
    return false;

  if (pIO->Read16(&m_pData[i].data[0], nNum16) != (icInt32Number)nNum16)
    return false;
}

return true;
8181}


8184/**
****************************************************************************
* Name: CIccTagColorantTable::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
8197bool CIccTagColorantTable::Write(CIccIO *pIO)
8198{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

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

icUInt32Number nNum8 = sizeof(m_pData->name);
icUInt32Number nNum16 = sizeof(m_pData->data)/sizeof(icUInt16Number);

for (icUInt32Number i=0; i<m_nCount; i++) {
  if (pIO->Write8(&m_pData[i].name[0],nNum8) != (icInt32Number)nNum8)
    return false;

  if (pIO->Write16(&m_pData[i].data[0],nNum16) != (icInt32Number)nNum16)
    return false;
}

return true;
8225}


8228/**
****************************************************************************
* Name: CIccTagColorantTable::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
8238void CIccTagColorantTable::Describe(std::string &sDescription)
8239{
icChar buf[128];

icUInt32Number i, nLen, nMaxLen=0;
icFloatNumber Lab[3];

sprintf(buf, "BEGIN_COLORANTS %u\r\n", m_nCount);
sDescription += buf;

for (i=0; i<m_nCount; i++) {
  nLen = (icUInt32Number)strlen(m_pData[i].name);
  if (nLen>nMaxLen)
    nMaxLen =nLen;
}
sDescription += "# NAME ";

if (m_PCS == icSigXYZData) {
  sprintf(buf, "XYZ_X XYZ_Y XYZ_Z\r\n");
  sDescription += buf;
}
else {
  sprintf(buf, "Lab_L Lab_a Lab_b\r\n");
  sDescription += buf;
}
for (i=0; i<m_nCount; i++) {
  sprintf(buf, "%2u \"%s\"", i, m_pData[i].name);
  sDescription += buf;
  memset(buf, ' ', 128);
  buf[nMaxLen + 1 - strlen(m_pData[i].name)] ='\0';
  sDescription += buf;

  if (m_PCS == icSigXYZData) {
    sprintf(buf, "%7.4lf %7.4lf %7.4lf\r\n", icUSFtoD(m_pData[i].data[0]), icUSFtoD(m_pData[i].data[1]), icUSFtoD(m_pData[i].data[2]));
    sDescription += buf;
  }
  else {
    Lab[0] = icU16toF(m_pData[i].data[0]);
    Lab[1] = icU16toF(m_pData[i].data[1]);
    Lab[2] = icU16toF(m_pData[i].data[2]);
    icLabFromPcs(Lab);
    sprintf(buf, "%7.4lf %8.4lf %8.4lf\r\n", Lab[0], Lab[1], Lab[2]);
    sDescription += buf;
  }
}

8284}

8286/**
****************************************************************************
* Name: CIccTagColorantTable::SetSize
* 
* Purpose: Sets the size of the data array.
* 
* Args: 
*  nSize - number of entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
8297bool CIccTagColorantTable::SetSize(icUInt16Number nSize, bool bZeroNew/*=true*/)
8298{
if (m_nCount == nSize)
  return true;

m_pData = (icColorantTableEntry*)icRealloc(m_pData, nSize*sizeof(icColorantTableEntry));

if (!m_pData) {
  m_nCount = 0;
  return false;
}

if (bZeroNew && nSize > m_nCount) {
  memset(&m_pData[m_nCount], 0, (nSize-m_nCount)*sizeof(icColorantTableEntry));
}
m_nCount = nSize;

return true;
8315}


8318/**
8319******************************************************************************
8320* Name: CIccTagColorantTable::Validate
8321* 
8322* Purpose: Check tag data validity.
8323* 
8324* Args: 
8325*  sig = signature of tag being validated,
8326*  sReport = String to add report information to
8327* 
8328* Return: 
8329*  icValidateStatusOK if valid, or other error status.
8330******************************************************************************
8331*/
8332icValidateStatus CIccTagColorantTable::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
8333{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);
icSignature sig = icGetFirstSigPathSig(sigPath);

if (!pProfile) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Tag validation incomplete: Pointer to profile unavailable.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
  return rv;
}


if (sig==icSigColorantTableOutTag) {
  if (pProfile->m_Header.deviceClass!=icSigLinkClass) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Use of this tag is allowed only in DeviceLink Profiles.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
  if (m_nCount != icGetSpaceSamples(pProfile->m_Header.pcs)) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Incorrect number of colorants.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
}
else {
  if (m_nCount != icGetSpaceSamples(pProfile->m_Header.colorSpace)) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Incorrect number of colorants.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
}

return rv;
8373}


8376/**
****************************************************************************
* Name: CIccTagViewingConditions::CIccTagViewingConditions
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
8384CIccTagViewingConditions::CIccTagViewingConditions()
8385{
m_XYZIllum.X = 0;
m_XYZIllum.Y = 0;
m_XYZIllum.Z = 0;

m_XYZSurround.X = 0;
m_XYZSurround.Y = 0;
m_XYZSurround.Z = 0;

m_illumType = icIlluminantUnknown;
8395}


8398/**
****************************************************************************
* Name: CIccTagViewingConditions::CIccTagViewingConditions
* 
* Purpose: Copy Constructor
*
* Args:
*  ITVC = The CIccTagViewingConditions object to be copied
*****************************************************************************
*/
8408CIccTagViewingConditions::CIccTagViewingConditions(const CIccTagViewingConditions &ITVC)
8409{
m_illumType = ITVC.m_illumType;

memcpy(&m_XYZIllum, &ITVC.m_XYZIllum, sizeof(icXYZNumber));
memcpy(&m_XYZSurround, &ITVC.m_XYZSurround, sizeof(icXYZNumber));
8414}


8417/**
****************************************************************************
* Name: CIccTagViewingConditions::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ViewCondTag = The CIccTagViewingConditions object to be copied
*****************************************************************************
*/
8427CIccTagViewingConditions &CIccTagViewingConditions::operator=(const CIccTagViewingConditions &ViewCondTag)
8428{
if (&ViewCondTag == this)
  return *this;

m_illumType = ViewCondTag.m_illumType;

memcpy(&m_XYZIllum, &ViewCondTag.m_XYZIllum, sizeof(icXYZNumber));
memcpy(&m_XYZSurround, &ViewCondTag.m_XYZSurround, sizeof(icXYZNumber));

return *this;
8438}


8441/**
****************************************************************************
* Name: CIccTagViewingConditions::~CIccTagViewingConditions
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
8449CIccTagViewingConditions::~CIccTagViewingConditions()
8450{
8451}


8454/**
****************************************************************************
* Name: CIccTagViewingConditions::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
8468bool CIccTagViewingConditions::Read(icUInt32Number size, CIccIO *pIO)
8469{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 
    2*sizeof(icUInt32Number) + 
    2*sizeof(icXYZNumber) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

if (pIO->Read32(&m_XYZIllum.X, 3) != 3)
  return false;

if (pIO->Read32(&m_XYZSurround.X, 3) != 3)
  return false;

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

return true;
8497}


8500/**
****************************************************************************
* Name: CIccTagViewingConditions::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
8513bool CIccTagViewingConditions::Write(CIccIO *pIO)
8514{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

if (pIO->Write32(&m_XYZIllum.X, 3) !=3)
  return false;

if (pIO->Write32(&m_XYZSurround.X, 3) !=3)
  return false;

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

return true;
8536}


8539/**
****************************************************************************
* Name: CIccTagViewingConditions::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
8549void CIccTagViewingConditions::Describe(std::string &sDescription)
8550{
icChar buf[128];
CIccInfo Fmt;

sprintf(buf, "Illuminant Tristimulus values: X = %.4lf, Y = %.4lf, Z = %.4lf\r\n", 
             icFtoD(m_XYZIllum.X), 
             icFtoD(m_XYZIllum.Y),
             icFtoD(m_XYZIllum.Z));
sDescription += buf;

sprintf(buf, "Surround Tristimulus values: X = %.4lf, Y = %.4lf, Z = %.4lf\r\n",
             icFtoD(m_XYZSurround.X),
             icFtoD(m_XYZSurround.Y),
             icFtoD(m_XYZSurround.Z));
sDescription += buf;

sDescription += "Illuminant Type: ";

sDescription += Fmt.GetIlluminantName(m_illumType);
sDescription += "\r\n";

8571}


8574/**
8575******************************************************************************
8576* Name: CIccTagViewingConditions::Validate
8577* 
8578* Purpose: Check tag data validity.
8579* 
8580* Args: 
8581*  sig = signature of tag being validated,
8582*  sReport = String to add report information to
8583* 
8584* Return: 
8585*  icValidateStatusOK if valid, or other error status.
8586******************************************************************************
8587*/
8588icValidateStatus CIccTagViewingConditions::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
8589{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

rv = icMaxStatus(rv, Info.CheckData(sReport, m_XYZIllum, "XYZ Illuminant"));
rv = icMaxStatus(rv, Info.CheckData(sReport, m_XYZSurround, "XYZ Surround"));

return rv;
8599}


8602/**
****************************************************************************
* Name: CIccProfileDescText::CIccProfileDescText
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
8610CIccProfileDescText::CIccProfileDescText()
8611{
m_pTag = NULL__null;
m_bNeedsPading = false;
8614}


8617/**
****************************************************************************
* Name: CIccProfileDescText::CIccProfileDescText
* 
* Purpose: Copy Constructor
*
* Args:
*  IPDC = The CIccTagUnknown object to be copied
*****************************************************************************
*/
8627CIccProfileDescText::CIccProfileDescText(const CIccProfileDescText &IPDC)
8628{
if (IPDC.m_pTag) {
  m_pTag = IPDC.m_pTag->NewCopy();
  m_bNeedsPading = IPDC.m_bNeedsPading;
}
else {
  m_pTag = NULL__null;
  m_bNeedsPading = false;
}
8637}


8640/**
****************************************************************************
* Name: CIccProfileDescText::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ProfDescText = The CIccProfileDescText object to be copied
*****************************************************************************
*/
8650CIccProfileDescText &CIccProfileDescText::operator=(const CIccProfileDescText &ProfDescText)
8651{
if (&ProfDescText == this)
  return *this;

if (m_pTag)
  delete m_pTag;

if (ProfDescText.m_pTag) {
  m_pTag = ProfDescText.m_pTag->NewCopy();
  m_bNeedsPading = ProfDescText.m_bNeedsPading;
}
else {
  m_pTag = NULL__null;
  m_bNeedsPading = false;
}

return *this;
8668}


8671/**
****************************************************************************
* Name: CIccProfileDescText::~CIccProfileDescText
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
8679CIccProfileDescText::~CIccProfileDescText()
8680{
if (m_pTag)
  delete m_pTag;
8683}


8686/**
****************************************************************************
* Name: CIccProfileDescText::SetType
* 
* Purpose: Sets the type of the profile description text. Could be either 
*  a MultiLocalizedUnicodeType or a TextDescriptionType.
* 
* Args:
*  nType = the tag type signature
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
8700bool CIccProfileDescText::SetType(icTagTypeSignature nType)
8701{
if (m_pTag) {
  if (m_pTag->GetType() == nType)
    return true;

  delete m_pTag;
}

if (nType == icSigMultiLocalizedUnicodeType ||
    nType == icSigTextDescriptionType)
  m_pTag = CIccTag::Create(nType);
else
  m_pTag = NULL__null;

return(m_pTag != NULL__null);
8716}


8719/**
****************************************************************************
* Name: CIccProfileDescText::SetType
* 
* Purpose: Gets the type of the profile description text. Could be either 
*  a MultiLocalizedUnicodeType or a TextDescriptionType.
* 
*****************************************************************************
*/
8728icTagTypeSignature CIccProfileDescText::GetType() const
8729{
if (m_pTag)
  return m_pTag->GetType();

return icSigUnknownType((icTagTypeSignature) 0x3f3f3f3f);
8734}


8737/**
****************************************************************************
* Name: CIccProfileDescText::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
8747void CIccProfileDescText::Describe(std::string &sDescription)
8748{
if (m_pTag)
  m_pTag->Describe(sDescription);
8751}


8754/**
****************************************************************************
* Name: CIccProfileDescText::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
8768bool CIccProfileDescText::Read(icUInt32Number size, CIccIO *pIO)
8769{
icTagTypeSignature sig;
icUInt32Number nPos;

//Check for description tag type signature
nPos = pIO->Tell();

if ((nPos&0x03) != 0)
  m_bNeedsPading = true;

if (!pIO->Read32(&sig))
  return false;
pIO->Seek(nPos, icSeekSet);

if (sig==icSigTextDescriptionType)
  m_bNeedsPading = false;

if (!SetType(sig)) {
  //We couldn't find it, but we may be looking in the wrong place
  //Re-Sync to a 4 byte boundary
  pIO->Sync32();

  nPos = pIO->Tell();
  if (!pIO->Read32(&sig))
    return false;
  pIO->Seek(nPos, icSeekSet);

  if (!SetType(sig)) {
    return false;
  }
}

if (m_pTag) {
  return m_pTag->Read(size, pIO);
}

return false;
8806}


8809/**
****************************************************************************
* Name: CIccProfileDescText::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
8822bool CIccProfileDescText::Write(CIccIO *pIO)
8823{
if (!m_pTag)
  return false;

if (m_pTag->Write(pIO)) {
  if (m_pTag->GetType() != icSigTextDescriptionType)
    return pIO->Align32();
  else
    return true;
}

return false;
8835}



8839/**
****************************************************************************
* Name: CIccProfileDescStruct::CIccProfileDescStruct
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
8847CIccProfileDescStruct::CIccProfileDescStruct()
8848{
8849}


8852/**
****************************************************************************
* Name: CIccProfileDescStruct::CIccProfileDescStruct
* 
* Purpose: Copy Constructor
*
* Args:
*  IPDS = The CIccProfileDescStruct object to be copied
*****************************************************************************
*/
8862CIccProfileDescStruct::CIccProfileDescStruct(const CIccProfileDescStruct &IPDS)
8863{
m_deviceMfg = IPDS.m_deviceMfg;
m_deviceModel = IPDS.m_deviceModel;
m_attributes = IPDS.m_attributes;
m_technology = IPDS.m_technology;
m_deviceMfgDesc = IPDS.m_deviceMfgDesc;
m_deviceModelDesc = IPDS.m_deviceModelDesc;
8870}



8874/**
****************************************************************************
* Name: CIccProfileDescStruct::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ProfDescStruct = The CIccProfileDescStruct object to be copied
*****************************************************************************
*/
8884CIccProfileDescStruct &CIccProfileDescStruct::operator=(const CIccProfileDescStruct &ProfDescStruct)
8885{
if (&ProfDescStruct == this)
  return *this;

m_deviceMfg = ProfDescStruct.m_deviceMfg;
m_deviceModel = ProfDescStruct.m_deviceModel;
m_attributes = ProfDescStruct.m_attributes;
m_technology = ProfDescStruct.m_technology;
m_deviceMfgDesc = ProfDescStruct.m_deviceMfgDesc;
m_deviceModelDesc = ProfDescStruct.m_deviceModelDesc;

return *this;
8897}



8901/**
****************************************************************************
* Name: CIccTagProfileSeqDesc::CIccTagProfileSeqDesc
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
8909CIccTagProfileSeqDesc::CIccTagProfileSeqDesc()
8910{
m_Descriptions = new(CIccProfileSeqDesc);
8912}


8915/**
****************************************************************************
* Name: CIccTagProfileSeqDesc::CIccTagProfileSeqDesc
* 
* Purpose: Copy Constructor
*
* Args:
*  ITPSD = The CIccTagProfileSeqDesc object to be copied
*****************************************************************************
*/
8925CIccTagProfileSeqDesc::CIccTagProfileSeqDesc(const CIccTagProfileSeqDesc &ITPSD)
8926{
m_Descriptions = new(CIccProfileSeqDesc);
*m_Descriptions = *ITPSD.m_Descriptions;
8929}


8932/**
****************************************************************************
* Name: CIccTagProfileSeqDesc::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  ProfSeqDescTag = The CIccTagProfileSeqDesc object to be copied
*****************************************************************************
*/
8942CIccTagProfileSeqDesc &CIccTagProfileSeqDesc::operator=(const CIccTagProfileSeqDesc &ProfSeqDescTag)
8943{
if (&ProfSeqDescTag == this)
  return *this;

*m_Descriptions = *ProfSeqDescTag.m_Descriptions;

return *this;
8950}


8953/**
****************************************************************************
* Name: CIccTagProfileSeqDesc::~CIccTagProfileSeqDesc
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
8961CIccTagProfileSeqDesc::~CIccTagProfileSeqDesc()
8962{
delete m_Descriptions;
8964}


8967/**
****************************************************************************
* Name: CIccTagProfileSeqDesc::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
8981bool CIccTagProfileSeqDesc::Read(icUInt32Number size, CIccIO *pIO)
8982{
icTagTypeSignature sig;
icUInt32Number nCount, nEnd;

nEnd = pIO->Tell() + size;

if (sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number)*2 > size)
  return false;

if (!pIO) {
  return false;
}

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

if (!nCount)
  return true;

if (sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number)*2 +
  sizeof(CIccProfileDescStruct) > size)
  return false;

icUInt32Number i, nPos; 
CIccProfileDescStruct ProfileDescStruct;

for (i=0; i<nCount; i++) {

  if (!pIO->Read32(&ProfileDescStruct.m_deviceMfg) ||
      !pIO->Read32(&ProfileDescStruct.m_deviceModel) ||
      !pIO->Read64(&ProfileDescStruct.m_attributes) ||
      !pIO->Read32(&ProfileDescStruct.m_technology))
    return false;

  nPos = pIO->Tell();

  if (!ProfileDescStruct.m_deviceMfgDesc.Read(nEnd - nPos, pIO))
    return false;
  
  nPos = pIO->Tell();
  if (!ProfileDescStruct.m_deviceModelDesc.Read(nEnd - nPos, pIO))
    return false;

  m_Descriptions->push_back(ProfileDescStruct);
}

return true;
9033}


9036/**
****************************************************************************
* Name: CIccTagProfileSeqDesc::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
9049bool CIccTagProfileSeqDesc::Write(CIccIO *pIO)
9050{
icTagTypeSignature sig = GetType();
icUInt32Number nCount=(icUInt32Number)m_Descriptions->size();

if (!pIO) {
  return false;
}

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

CIccProfileSeqDesc::iterator i;

for (i=m_Descriptions->begin(); i!=m_Descriptions->end(); i++) {

  if (!pIO->Write32(&i->m_deviceMfg) ||
      !pIO->Write32(&i->m_deviceModel) ||
      !pIO->Write64(&i->m_attributes) ||
      !pIO->Write32(&i->m_technology))
    return false;

  if (!i->m_deviceMfgDesc.Write(pIO) ||
      !i->m_deviceModelDesc.Write(pIO))
    return false;
}

return true;
9079}


9082/**
****************************************************************************
* Name: CIccTagProfileSeqDesc::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
9092void CIccTagProfileSeqDesc::Describe(std::string &sDescription)
9093{
CIccProfileSeqDesc::iterator i;
icChar buf[128], buf2[28];
icUInt32Number count=0;

sprintf(buf, "Number of Profile Description Structures: %u\r\n", (icUInt32Number)m_Descriptions->size());
sDescription += buf;

for (i=m_Descriptions->begin(); i!=m_Descriptions->end(); i++, count++) {
  sDescription += "\r\n";

  sprintf(buf, "Profile Description Structure Number [%u] follows:\r\n", count+1);
  sDescription += buf;

  sprintf(buf, "Device Manufacturer Signature: %s\r\n", icGetSig(buf2, i->m_deviceMfg, false));
  sDescription += buf;

  sprintf(buf, "Device Model Signature: %s\r\n", icGetSig(buf2, i->m_deviceModel, false));
  sDescription += buf;

  sprintf(buf, "Device Attributes: %08x%08x\r\n", (icUInt32Number)(i->m_attributes >> 32), (icUInt32Number)(i->m_attributes));
  sDescription += buf;

  sprintf(buf, "Device Technology Signature: %s\r\n", icGetSig(buf2, i->m_technology, false));
  sDescription += buf;

  sprintf(buf, "Description of device manufacturer: \r\n");
  sDescription += buf;
  i->m_deviceMfgDesc.Describe(sDescription);

  sprintf(buf, "Description of device model: \r\n");
  sDescription += buf;
  i->m_deviceModelDesc.Describe(sDescription);
}
9127}


9130/**
9131******************************************************************************
9132* Name: CIccTagProfileSeqDesc::Validate
9133* 
9134* Purpose: Check tag data validity.
9135* 
9136* Args: 
9137*  sig = signature of tag being validated,
9138*  sReport = String to add report information to
9139* 
9140* Return: 
9141*  icValidateStatusOK if valid, or other error status.
9142******************************************************************************
9143*/
9144icValidateStatus CIccTagProfileSeqDesc::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
9145{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
char buf[128];
std::string sSigPathName = Info.GetSigPathName(sigPath);

CIccProfileSeqDesc::iterator i;
for (i=m_Descriptions->begin(); i!=m_Descriptions->end(); i++) {
  switch(i->m_technology) {
  case 0x00000000:  //Technology not defined
  case icSigFilmScanner:
  case icSigDigitalCamera:
  case icSigReflectiveScanner:
  case icSigInkJetPrinter:
  case icSigThermalWaxPrinter:
  case icSigElectrophotographicPrinter:
  case icSigElectrostaticPrinter:
  case icSigDyeSublimationPrinter:
  case icSigPhotographicPaperPrinter:
  case icSigFilmWriter:
  case icSigVideoMonitor:
  case icSigVideoCamera:
  case icSigProjectionTelevision:
  case icSigCRTDisplay:
  case icSigPMDisplay:
  case icSigAMDisplay:
  case icSigPhotoCD:
  case icSigPhotoImageSetter:
  case icSigGravure:
  case icSigOffsetLithography:
  case icSigSilkscreen:
  case icSigFlexography:
    break;

  default:
    {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sprintf(buf, " - %s: Unknown Technology.\r\n", Info.GetSigName(i->m_technology));
      sReport += buf;
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
  }

  if (i->m_deviceMfgDesc.m_bNeedsPading) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;

    sReport += " Contains non-aligned deviceMfgDesc text tag information\r\n";

    rv = icMaxStatus(rv, icValidateNonCompliant);
  }

  if (i->m_deviceModelDesc.m_bNeedsPading) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;

    sReport += " Contains non-aligned deviceModelDesc text tag information\r\n";

    rv = icMaxStatus(rv, icValidateNonCompliant);
  }

  rv = icMaxStatus(rv, i->m_deviceMfgDesc.GetTag()->Validate(sigPath+icGetSigPath(GetType()), sReport, pProfile));
  rv = icMaxStatus(rv, i->m_deviceModelDesc.GetTag()->Validate(sigPath+icGetSigPath(GetType()), sReport, pProfile));
}  

return rv;
9213}


9216/**
****************************************************************************
* Name: CIccResponseCurveStruct::CIccResponseCurveStruct
* 
* Purpose: Constructor
* 
* Args:
*  nChannels = number of channels
* 
*****************************************************************************
*/
9227CIccResponseCurveStruct::CIccResponseCurveStruct(icUInt16Number nChannels/*=0*/)
9228{
m_nChannels = nChannels;
m_maxColorantXYZ = (icXYZNumber*)calloc(nChannels, sizeof(icXYZNumber));
m_Response16ListArray = new CIccResponse16List[nChannels];
9232}


9235/**
****************************************************************************
* Name: CIccResponseCurveStruct::CIccResponseCurveStruct
* 
* Purpose: Constructor
*
* Args:
*  sig = measurement unit signature indicating the type of measurement data,
*  nChannels = number of channels
*****************************************************************************
*/
9246CIccResponseCurveStruct::CIccResponseCurveStruct(icMeasurementUnitSig sig,icUInt16Number nChannels/*=0*/)
9247{
m_nChannels = nChannels;
m_measurementUnitSig = sig;
m_maxColorantXYZ = (icXYZNumber*)calloc(nChannels, sizeof(icXYZNumber));
m_Response16ListArray = new CIccResponse16List[nChannels];
9252}

9254/**
****************************************************************************
* Name: CIccResponseCurveStruct::CIccResponseCurveStruct
* 
* Purpose: Copy Constructor
*
* Args:
*  IRCS = The CIccTagUnknown object to be copied
*****************************************************************************
*/
9264CIccResponseCurveStruct::CIccResponseCurveStruct(const CIccResponseCurveStruct &IRCS)
9265{
m_nChannels = IRCS.m_nChannels;
m_measurementUnitSig = IRCS.m_measurementUnitSig;

m_maxColorantXYZ = (icXYZNumber*)calloc(m_nChannels, sizeof(icXYZNumber));
memcpy(m_maxColorantXYZ, IRCS.m_maxColorantXYZ, m_nChannels*sizeof(icXYZNumber));

m_Response16ListArray = new CIccResponse16List[m_nChannels];
for (icUInt32Number i=0; i<m_nChannels; i++)
  m_Response16ListArray[i] = IRCS.m_Response16ListArray[i];
9275}


9278/**
****************************************************************************
* Name: CIccResponseCurveStruct::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  RespCurveStruct = The CIccResponseCurveStruct object to be copied
*****************************************************************************
*/
9288CIccResponseCurveStruct &CIccResponseCurveStruct::operator=(const CIccResponseCurveStruct &RespCurveStruct)
9289{
if (&RespCurveStruct == this)
  return *this;

m_nChannels = RespCurveStruct.m_nChannels;
m_measurementUnitSig = RespCurveStruct.m_measurementUnitSig;

if (m_maxColorantXYZ)
  free(m_maxColorantXYZ);

m_maxColorantXYZ = (icXYZNumber*)calloc(m_nChannels, sizeof(icXYZNumber));
memcpy(m_maxColorantXYZ, RespCurveStruct.m_maxColorantXYZ, m_nChannels*sizeof(icXYZNumber));

if (m_Response16ListArray)
  delete [] m_Response16ListArray;
m_Response16ListArray = new CIccResponse16List[m_nChannels];
for (icUInt32Number i=0; i<m_nChannels; i++)
  m_Response16ListArray[i] = RespCurveStruct.m_Response16ListArray[i];

return *this;
9309}


9312/**
****************************************************************************
* Name: CIccResponseCurveStruct::~CIccResponseCurveStruct
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
9320CIccResponseCurveStruct::~CIccResponseCurveStruct()
9321{
if (m_maxColorantXYZ)
  free(m_maxColorantXYZ);

if (m_Response16ListArray)
  delete [] m_Response16ListArray;
9327}


9330/**
****************************************************************************
* Name: CIccResponseCurveStruct::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
9344bool CIccResponseCurveStruct::Read(icUInt32Number size, CIccIO *pIO)
9345{
if (!m_nChannels)
  return false;

if (sizeof(icTagTypeSignature) + 
    m_nChannels * (sizeof(icUInt32Number) +
      sizeof(icXYZNumber) + 
      sizeof(icResponse16Number)) > size)
  return false;

if (!pIO) {
  return false;
}

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

icUInt32Number* nMeasurements = new icUInt32Number[m_nChannels];

if (pIO->Read32(&nMeasurements[0],m_nChannels) != m_nChannels) {
  delete[] nMeasurements;
  return false;
}

icUInt32Number nNum32 = m_nChannels*sizeof(icXYZNumber)/sizeof(icS15Fixed16Number);
if (pIO->Read32(&m_maxColorantXYZ[0], nNum32) != (icInt32Number)nNum32) {
  delete[] nMeasurements;
  return false;
}

icResponse16Number nResponse16;
CIccResponse16List nResponseList;

for (int i = 0; i<m_nChannels; i++) {
  if (!nResponseList.empty())
    nResponseList.clear();
  for (int j=0; j<(int)nMeasurements[i]; j++) {
    if (!pIO->Read16(&nResponse16.deviceCode) ||
       !pIO->Read16(&nResponse16.reserved)   ||
       !pIO->Read32(&nResponse16.measurementValue)) {
      delete[] nMeasurements;
      return false;
    }
    nResponseList.push_back(nResponse16);
  }
  m_Response16ListArray[i] = nResponseList;
}

delete [] nMeasurements;
return true;
9395}


9398/**
****************************************************************************
* Name: CIccResponseCurveStruct::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
9411bool CIccResponseCurveStruct::Write(CIccIO *pIO)
9412{
if (!m_nChannels)
  return false;

icMeasurementUnitSig sig = GetMeasurementType();

if (!pIO) {
  return false;
}

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

if (m_nChannels) {

  icUInt32Number* nMeasurements = new icUInt32Number[m_nChannels];
  for (int i=0; i<m_nChannels; i++)
    nMeasurements[i] = (icUInt32Number)m_Response16ListArray[i].size();

  if (pIO->Write32(&nMeasurements[0],m_nChannels) != m_nChannels)
    return false;
  delete [] nMeasurements;

  icUInt32Number nNum32 = m_nChannels*sizeof(icXYZNumber)/sizeof(icS15Fixed16Number);
  if (pIO->Write32(&m_maxColorantXYZ[0], nNum32) != (icInt32Number)nNum32)
    return false;
}
else
  return false;

CIccResponse16List nResponseList;
CIccResponse16List::iterator j;

for (int i = 0; i<m_nChannels; i++) {
  nResponseList = m_Response16ListArray[i];
  for (j=nResponseList.begin(); j!=nResponseList.end(); j++) {
    if (!pIO->Write16(&j->deviceCode) ||
       !pIO->Write16(&j->reserved)   ||
       !pIO->Write32(&j->measurementValue))
      return false;
  }
  nResponseList.clear();
}

return true;
9457}


9460/**
****************************************************************************
* Name: CIccResponseCurveStruct::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
9470void CIccResponseCurveStruct::Describe(std::string &sDescription)
9471{
icChar buf[128];
CIccInfo Fmt;
CIccResponse16List nResponseList;
CIccResponse16List::iterator j;

sDescription += "Measurement Unit: ";
sDescription += Fmt.GetMeasurementUnit((icSignature)GetMeasurementType()); sDescription += "\r\n";


for (int i=0; i<m_nChannels; i++) {
  nResponseList = m_Response16ListArray[i];

  sDescription += "\r\n";
  sprintf(buf, "Maximum Colorant XYZ Measurement for Channel-%u : X=%.4lf, Y=%.4lf, Z=%.4lf\r\n", i+1, 
    icFtoD(m_maxColorantXYZ[i].X), icFtoD(m_maxColorantXYZ[i].Y), icFtoD(m_maxColorantXYZ[i].Z));
  sDescription += buf;

  sprintf(buf, "Number of Measurements for Channel-%u : %u\r\n", i+1, (icUInt32Number)nResponseList.size());
  sDescription += buf;

  sprintf(buf, "Measurement Data for Channel-%u follows:\r\n", i+1);
  sDescription += buf;

  for (j=nResponseList.begin(); j!=nResponseList.end(); j++) {
    sprintf(buf, "Device Value= %u : Measurement Value= %.4lf\r\n", j->deviceCode, icFtoD(j->measurementValue));
    sDescription += buf;
  }
}
9500}


9503/**
9504******************************************************************************
9505* Name: CIccResponseCurveStruct::Validate
9506* 
9507* Purpose: Check tag data validity.
9508* 
9509* Args: 
9510*  sig = signature of tag being validated,
9511*  sReport = String to add report information to
9512* 
9513* Return: 
9514*  icValidateStatusOK if valid, or other error status.
9515******************************************************************************
9516*/
9517icValidateStatus CIccResponseCurveStruct::Validate(std::string &sReport)
9518{
icValidateStatus rv = icValidateOK;

CIccInfo Info;
std::string sSigName = Info.GetSigName(m_measurementUnitSig);
switch(m_measurementUnitSig) {
case icSigStatusA:
case icSigStatusE:
case icSigStatusI:
case icSigStatusT:
case icSigStatusM:
case icSigDN:
case icSigDNP:
case icSigDNN:
case icSigDNNP:
  break;

default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigName;
  sReport += " - Unknown measurement unit signature.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

if (!m_nChannels) {
  sReport += icMsgValidateNonCompliant;
  sReport += sSigName;
  sReport += " - Incorrect number of channels.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
  return rv;
}
for (int i=0; i<m_nChannels; i++) {
  rv = icMaxStatus(rv, Info.CheckData(sReport, m_maxColorantXYZ[i], "Max Colorant XYZ"));
}

return rv;
9554}



9558/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::CIccTagResponseCurveSet16
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
9566CIccTagResponseCurveSet16::CIccTagResponseCurveSet16()
9567{
m_nChannels = 0;

m_ResponseCurves = new(CIccResponseCurveSet);
m_Curve = new(CIccResponseCurveSetIter);
m_Curve->inited = false;
9573}


9576/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::CIccTagResponseCurveSet16
* 
* Purpose: Copy Constructor
*
* Args:
*  ITRCS = The CIccTagResponseCurveSet16 object to be copied
*****************************************************************************
*/
9586CIccTagResponseCurveSet16::CIccTagResponseCurveSet16(const CIccTagResponseCurveSet16 &ITRCS)
9587{
m_nChannels = ITRCS.m_nChannels;
m_ResponseCurves = new(CIccResponseCurveSet);
*m_ResponseCurves = *ITRCS.m_ResponseCurves;
m_Curve = new(CIccResponseCurveSetIter);
*m_Curve = *ITRCS.m_Curve;
9593}


9596/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  RespCurveSet16Tag = The CIccTagResponseCurveSet16 object to be copied
*****************************************************************************
*/
9606CIccTagResponseCurveSet16 &CIccTagResponseCurveSet16::operator=(const CIccTagResponseCurveSet16 &RespCurveSet16Tag)
9607{
if (&RespCurveSet16Tag == this)
  return *this;

if (!m_ResponseCurves->empty())
  m_ResponseCurves->clear();

m_nChannels = RespCurveSet16Tag.m_nChannels;
*m_ResponseCurves = *RespCurveSet16Tag.m_ResponseCurves;
*m_Curve = *RespCurveSet16Tag.m_Curve;

return *this;
9619}


9622/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::~CIccTagResponseCurveSet16
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
9630CIccTagResponseCurveSet16::~CIccTagResponseCurveSet16()
9631{
if (!m_ResponseCurves->empty())
  m_ResponseCurves->clear();

delete m_ResponseCurves;
delete m_Curve;
9637}


9640/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
9654bool CIccTagResponseCurveSet16::Read(icUInt32Number size, CIccIO *pIO)
9655{
icTagTypeSignature sig;

icUInt32Number startPos = pIO->Tell();

unsigned long headerSize = sizeof(icTagTypeSignature) +
                           sizeof(icUInt32Number) +
                           sizeof(icUInt16Number) * 2;
if (headerSize > size)
  return false;

if (!pIO) {
  return false;
}

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

icUInt16Number nCountMeasmntTypes;

if (!pIO->Read16(&m_nChannels) ||
    !pIO->Read16(&nCountMeasmntTypes))
  return false;

if ((icUInt32Number)nCountMeasmntTypes * sizeof(icUInt32Number) > size - headerSize)
  return false;

icUInt32Number* nOffset = new icUInt32Number[nCountMeasmntTypes];

if (pIO->Read32(&nOffset[0], nCountMeasmntTypes) != nCountMeasmntTypes) {
  delete[] nOffset;
  return false;
}

CIccResponseCurveStruct entry;

for (icUInt16Number i=0; i<nCountMeasmntTypes; i++) {
  if (nOffset[i] + 4 > size) {
    delete[] nOffset;
    return false;
  }
  pIO->Seek(startPos + nOffset[i], icSeekSet);
  entry = CIccResponseCurveStruct(m_nChannels);
  if (!entry.Read(size-nOffset[i], pIO)) {
    delete[] nOffset;
    return false;
  }

  m_ResponseCurves->push_back(entry);
}
delete[] nOffset;


m_Curve->inited = false;

return true;
9712}


9715/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
9728bool CIccTagResponseCurveSet16::Write(CIccIO *pIO)
9729{
icTagTypeSignature sig = GetType();
icUInt16Number nCountMeasmntTypes = (icUInt16Number)m_ResponseCurves->size();

if (!pIO) {
  return false;
}

icUInt32Number startPos = pIO->GetLength();

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


if (!pIO->Write16(&m_nChannels) ||
    !pIO->Write16(&nCountMeasmntTypes))
  return false;

icUInt32Number offsetPos = pIO->GetLength();
icUInt32Number* nOffset = new icUInt32Number[nCountMeasmntTypes];


int j;
for (j=0; j<nCountMeasmntTypes; j++) {
  nOffset[j] = 0;
  if (!pIO->Write32(&nOffset[j]))
    return false;
}

CIccResponseCurveSet::iterator i;

for (i=m_ResponseCurves->begin(), j=0; i!=m_ResponseCurves->end(); i++, j++) {
  nOffset[j] = pIO->GetLength() - startPos;
  if (!i->Write(pIO))
    return false;
}

icUInt32Number curPOs = pIO->GetLength();

pIO->Seek(offsetPos,icSeekSet);

for (j=0; j<nCountMeasmntTypes; j++) {
  if (!pIO->Write32(&nOffset[j]))
    return false;
}

pIO->Seek(curPOs,icSeekSet);
delete [] nOffset;

return true;
9780}


9783/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
9793void CIccTagResponseCurveSet16::Describe(std::string &sDescription)
9794{
CIccResponseCurveSet::iterator i;
icChar buf[128];

sprintf(buf, "Number of Channels: %u\r\n", m_nChannels);
sDescription += buf;

sprintf(buf, "Number of Measurement Types used: %u\r\n", (icUInt32Number)m_ResponseCurves->size());
sDescription += buf;

int count = 0;
for (i=m_ResponseCurves->begin(); i!=m_ResponseCurves->end(); i++, count++) {
   sDescription += "\r\n";

  sprintf(buf, "Response Curve for measurement type [%u] follows:\r\n", count+1);
  sDescription += buf;

  i->Describe(sDescription);
}
9813}


9816/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::SetNumChannels
* 
* Purpose: Sets the number of channels. This will delete any prior Response
*  curves from the set.
* 
* Args: 
*  nChannels = number of channels
*****************************************************************************
*/
9827void CIccTagResponseCurveSet16::SetNumChannels(icUInt16Number nChannels)
9828{
m_nChannels = nChannels;

if (!m_ResponseCurves->empty())
  m_ResponseCurves->clear();
9833}


9836/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::NewResponseCurves
* 
* Purpose: Creates and adds a new set of response curves to the list. 
*  SetNumChannels() must be called before calling this function.
* 
* Args: 
*  sig = measurement unit signature
*****************************************************************************
*/
9847CIccResponseCurveStruct *CIccTagResponseCurveSet16::NewResponseCurves(icMeasurementUnitSig sig)
9848{
if (!m_nChannels)
  return NULL__null;

CIccResponseCurveStruct *pResponseCurveStruct;
pResponseCurveStruct = GetResponseCurves(sig);

if (pResponseCurveStruct)
  return pResponseCurveStruct;

CIccResponseCurveStruct entry;
entry = CIccResponseCurveStruct(sig, m_nChannels);
m_ResponseCurves->push_back(entry);
m_Curve->inited = false;

return GetResponseCurves(sig);
9864}


9867/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::GetResponseCurves
* 
* Purpose: Returns pointer to the requested set of response curves
* 
* Args: 
*  sig = measurement unit signature of the response curve set desired
*****************************************************************************
*/
9877CIccResponseCurveStruct *CIccTagResponseCurveSet16::GetResponseCurves(icMeasurementUnitSig sig)
9878{
if (!m_nChannels)
  return NULL__null;

CIccResponseCurveSet::iterator i;

for (i=m_ResponseCurves->begin(); i!=m_ResponseCurves->end(); i++) {
  if (i->GetMeasurementType() == sig)
    return (i->GetThis());
}

return NULL__null;
9890}


9893/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::GetFirstCurves
* 
* Purpose: Returns pointer to the first set of response curves in the list.
* 
*****************************************************************************
*/
9901CIccResponseCurveStruct *CIccTagResponseCurveSet16::GetFirstCurves()
9902{
if (!m_Curve)
  return NULL__null;

m_Curve->item = m_ResponseCurves->begin();
if (m_Curve->item == m_ResponseCurves->end()) {
  m_Curve->inited = false;
  return NULL__null;
}
m_Curve->inited = true;
return m_Curve->item->GetThis();
9913}


9916/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::GetNextCurves
* 
* Purpose: Serves as an iterator for the list containing response curves.
*   GetFirstCurves() must be called before calling this function.
* 
*****************************************************************************
*/
9925CIccResponseCurveStruct *CIccTagResponseCurveSet16::GetNextCurves()
9926{
if (!m_Curve || !m_Curve->inited)
  return NULL__null;

m_Curve->item++;
if (m_Curve->item==m_ResponseCurves->end()) {
  m_Curve->inited = false;
  return NULL__null;
}
return m_Curve->item->GetThis();
9936}


9939/**
****************************************************************************
* Name: CIccTagResponseCurveSet16::GetNumResponseCurveTypes
* 
* Purpose: Get the number of response curve types.
*   
*****************************************************************************
*/
9947icUInt16Number CIccTagResponseCurveSet16::GetNumResponseCurveTypes() const
9948{
return(icUInt16Number) m_ResponseCurves->size();
9950}


9953/**
9954******************************************************************************
9955* Name: CIccTagResponseCurveSet16::Validate
9956* 
9957* Purpose: Check tag data validity.
9958* 
9959* Args: 
9960*  sig = signature of tag being validated,
9961*  sReport = String to add report information to
9962* 
9963* Return: 
9964*  icValidateStatusOK if valid, or other error status.
9965******************************************************************************
9966*/
9967icValidateStatus CIccTagResponseCurveSet16::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
9968{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

if (!pProfile) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Tag validation incomplete: Pointer to profile unavailable.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
  return rv;
}

if (m_nChannels!=icGetSpaceSamples(pProfile->m_Header.colorSpace)) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Incorrect number of channels.\r\n";
}

if (!GetNumResponseCurveTypes()) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " - Empty Tag!.\r\n";
  rv = icMaxStatus(rv, icValidateWarning);
}
else {
  CIccResponseCurveSet::iterator i;
  for (i=m_ResponseCurves->begin(); i!=m_ResponseCurves->end(); i++) {
    rv = icMaxStatus(rv, i->Validate(sReport));
  }
}

return rv;
10002}


10005/**
****************************************************************************
* Name: CIccTagSpectralDataInfo::CIccTagSpectralDataInfo
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
10013CIccTagSpectralDataInfo::CIccTagSpectralDataInfo()
10014{
m_nSig = 0;
memset(&m_spectralRange, 0, sizeof(m_spectralRange));
memset(&m_biSpectralRange, 0, sizeof(m_biSpectralRange));
10018}



10022/**
****************************************************************************
* Name: CIccTagSpectralDataInfo::CIccTagSpectralDataInfo
* 
* Purpose: Copy Constructor
*
* Args:
*  ITS = The CIccTagSpectralDataInfo object to be copied
*****************************************************************************
*/
10032CIccTagSpectralDataInfo::CIccTagSpectralDataInfo(const CIccTagSpectralDataInfo &ITS)
10033{
m_nSig = ITS.m_nSig;
m_spectralRange = ITS.m_spectralRange;
m_biSpectralRange = ITS.m_biSpectralRange;
10037}



10041/**
****************************************************************************
* Name: CIccTagSpectralDataInfo::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  SignatureTag = The CIccTagSignature object to be copied
*****************************************************************************
*/
10051CIccTagSpectralDataInfo &CIccTagSpectralDataInfo::operator=(const CIccTagSpectralDataInfo &ITS)
10052{
if (&ITS == this)
  return *this;

m_nSig = ITS.m_nSig;
m_spectralRange = ITS.m_spectralRange;
m_biSpectralRange = ITS.m_biSpectralRange;

return *this;
10061}


10064/**
****************************************************************************
* Name: CIccTagSpectralDataInfo::~CIccTagSpectralDataInfo
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
10072CIccTagSpectralDataInfo::~CIccTagSpectralDataInfo()
10073{
10074}

10076/**
****************************************************************************
* Name: CIccTagSpectralDataInfo::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
10090bool CIccTagSpectralDataInfo::Read(icUInt32Number size, CIccIO *pIO)
10091{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) + 2*sizeof(icUInt32Number) + 6*sizeof(icUInt16Number) > size)
  return false;

if (!pIO) {
  m_nSig = 0; 
  memset(&m_spectralRange, 0, sizeof(m_spectralRange));
  memset(&m_biSpectralRange, 0, sizeof(m_biSpectralRange));
  return false;
}

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

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

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

if (!pIO->Read16(&m_spectralRange.start))
  return false;

if (!pIO->Read16(&m_spectralRange.end))
  return false;

if (!pIO->Read16(&m_spectralRange.steps))
  return false;

if (!pIO->Read16(&m_biSpectralRange.start))
  return false;

if (!pIO->Read16(&m_biSpectralRange.end))
  return false;

if (!pIO->Read16(&m_biSpectralRange.steps))
  return false;

return true;
10132}

10134/**
****************************************************************************
* Name: CIccTagSpectralDataInfo::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
10147bool CIccTagSpectralDataInfo::Write(CIccIO *pIO)
10148{
icTagTypeSignature sig = GetType();

if (!pIO)
 return false;

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

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

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

if (!pIO->Write16(&m_spectralRange.start))
  return false;

if (!pIO->Write16(&m_spectralRange.end))
  return false;

if (!pIO->Write16(&m_spectralRange.steps))
  return false;

if (!pIO->Write16(&m_biSpectralRange.start))
  return false;

if (!pIO->Write16(&m_biSpectralRange.end))
  return false;

if (!pIO->Write16(&m_biSpectralRange.steps))
  return false;
return true;
10181}


10184/**
****************************************************************************
* Name: CIccTagSpectralDataInfo::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
10194void CIccTagSpectralDataInfo::Describe(std::string &sDescription)
10195{
char buf[256];

sDescription += "ColorSignature: ";
sDescription += icGetColorSigStr(buf, m_nSig);
sDescription += "\r\n";

sprintf(buf, "SpectralRange: start %fnm end %fnm with %d steps\r\n", icF16toF(m_spectralRange.start), icF16toF(m_spectralRange.end), m_spectralRange.steps);
sDescription += buf;
if (m_biSpectralRange.steps) {
  sprintf(buf, "BiSpectralRange: start %fnm end %fnm with %d steps\r\n", icF16toF(m_spectralRange.start), icF16toF(m_spectralRange.end), m_spectralRange.steps);
  sDescription += buf;
}
10208}


10211/**
10212******************************************************************************
10213* Name: CIccTagSpectralDataInfo::Validate
10214* 
10215* Purpose: Check tag data validity.
10216* 
10217* Args: 
10218*  sig = signature of tag being validated,
10219*  sReport = String to add report information to
10220* 
10221* Return: 
10222*  icValidateStatusOK if valid, or other error status.
10223******************************************************************************
10224*/
10225icValidateStatus CIccTagSpectralDataInfo::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
10226{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);
icSignature sig = icGetFirstSigPathSig(sigPath);

if (sig==icSigSpectralDataInfoTag && pProfile->m_Header.spectralPCS) {
  const icHeader *pHdr = &pProfile->m_Header;

  if (m_nSig != pHdr->spectralPCS ||
      memcmp(&m_spectralRange, &pHdr->spectralRange, sizeof(m_spectralRange)) ||
      memcmp(&m_biSpectralRange, &pHdr->biSpectralRange, sizeof(m_biSpectralRange))) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - SpectralDataInfo should be the same as the profile spectralPCS.\r\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
}
rv = icMaxStatus(rv, Info.CheckData(sReport, m_spectralRange, "Spectral Range"));
if (m_biSpectralRange.steps)
  rv = icMaxStatus(rv, Info.CheckData(sReport, m_biSpectralRange, "Bispectral Range"));
return rv;
10249}


10252/**
****************************************************************************
* Name: CIccTagSpectralViewingConditions::CIccTagSpectralViewingConditions
* 
* Purpose: Constructor
* 
*****************************************************************************
*/
10260CIccTagSpectralViewingConditions::CIccTagSpectralViewingConditions()
10261{
m_stdObserver = icStdObs1931TwoDegrees;
m_observerRange.start = 0;
m_observerRange.end = 0;
m_observerRange.steps = 0;
m_observer = NULL__null;

m_stdIlluminant = icIlluminantD50;
m_colorTemperature = 5000.0f;

m_illuminantRange.start = 0;
m_illuminantRange.end = 0;
m_illuminantRange.steps = 0;

m_illuminant = 0;

m_illuminantXYZ.X = 0;
m_illuminantXYZ.Y = 0;
m_illuminantXYZ.Z = 0;

m_surroundXYZ.X = 0;
m_surroundXYZ.Y = 0;
m_surroundXYZ.Z = 0;
10284}


10287/**
****************************************************************************
* Name: CIccTagSpectralViewingConditions::CIccTagSpectralViewingConditions
* 
* Purpose: Copy Constructor
*
* Args:
*  SVCT = The CIccTagSpectralViewingConditions object to be copied
*****************************************************************************
*/
10297CIccTagSpectralViewingConditions::CIccTagSpectralViewingConditions(const CIccTagSpectralViewingConditions &SVCT)
10298{
m_stdObserver = SVCT.m_stdObserver;
m_observerRange.start = SVCT.m_observerRange.start;
m_observerRange.end = SVCT.m_observerRange.end;
m_observerRange.steps = SVCT.m_observerRange.steps;

if (SVCT.m_observer && SVCT.m_observerRange.steps) {
  m_observer = new icFloat32Number[SVCT.m_observerRange.steps*3];
  if (m_observer) {
    memcpy(m_observer, SVCT.m_observer, SVCT.m_observerRange.steps*3*sizeof(icFloat32Number));
  }
}
else {
  m_observer = NULL__null;
}

m_stdIlluminant = SVCT.m_stdIlluminant;
m_colorTemperature = SVCT.m_colorTemperature;

m_illuminantRange.start = 0;
m_illuminantRange.end = 0;
m_illuminantRange.steps = 0;

if (SVCT.m_illuminant && SVCT.m_illuminantRange.steps) {
  m_illuminant = new icFloat32Number[SVCT.m_illuminantRange.steps];
  if (m_illuminant) {
    memcpy(m_illuminant, SVCT.m_illuminant, SVCT.m_illuminantRange.steps*sizeof(icFloat32Number));
  }
}
else {
  m_illuminant = NULL__null;
}

m_illuminantXYZ.X = 0;
m_illuminantXYZ.Y = 0;
m_illuminantXYZ.Z = 0;

m_surroundXYZ.X = 0;
m_surroundXYZ.Y = 0;
m_surroundXYZ.Z = 0;
10338}


10341/**
****************************************************************************
* Name: CIccTagSpectralViewingConditions::operator=
* 
* Purpose: Copy Operator
*
* Args:
*  specViewCondTag = The CIccTagSpectralViewingConditions object to be copied
*****************************************************************************
*/
10351CIccTagSpectralViewingConditions &CIccTagSpectralViewingConditions::operator=(const CIccTagSpectralViewingConditions &SVCT)
10352{
m_stdObserver = SVCT.m_stdObserver;
m_observerRange.start = SVCT.m_observerRange.start;
m_observerRange.end = SVCT.m_observerRange.end;
m_observerRange.steps = SVCT.m_observerRange.steps;

if (SVCT.m_observer && SVCT.m_observerRange.steps) {
  m_observer = new icFloat32Number[SVCT.m_observerRange.steps*3];
  if (m_observer) {
    memcpy(m_observer, SVCT.m_observer, SVCT.m_observerRange.steps*3*sizeof(icFloat32Number));
  }
}
else {
  m_observer = NULL__null;
}

m_stdIlluminant = SVCT.m_stdIlluminant;
m_colorTemperature = SVCT.m_colorTemperature;

m_illuminantRange.start = 0;
m_illuminantRange.end = 0;
m_illuminantRange.steps = 0;

if (SVCT.m_illuminant && SVCT.m_illuminantRange.steps) {
  m_illuminant = new icFloat32Number[SVCT.m_illuminantRange.steps];
  if (m_illuminant) {
    memcpy(m_illuminant, SVCT.m_illuminant, SVCT.m_illuminantRange.steps*sizeof(icFloat32Number));
  }
}
else {
  m_illuminant = NULL__null;
}

m_illuminantXYZ.X = 0;
m_illuminantXYZ.Y = 0;
m_illuminantXYZ.Z = 0;

m_surroundXYZ.X = 0;
m_surroundXYZ.Y = 0;
m_surroundXYZ.Z = 0;

return *this;
10394}


10397/**
****************************************************************************
* Name: CIccTagSpectralViewingConditions::~CIccTagResponseCurveSet16
* 
* Purpose: Destructor
* 
*****************************************************************************
*/
10405CIccTagSpectralViewingConditions::~CIccTagSpectralViewingConditions()
10406{
if (m_observer)
  delete [] m_observer;

if (m_illuminant)
  delete [] m_illuminant;
10412}


10415/**
****************************************************************************
* Name: CIccTagSpectralViewingConditions::Read
* 
* Purpose: Read in the tag contents into a data block
* 
* Args:
*  size - # of bytes in tag,
*  pIO - IO object to read tag from
* 
* Return: 
*  true = successful, false = failure
*****************************************************************************
*/
10429bool CIccTagSpectralViewingConditions::Read(icUInt32Number size, CIccIO *pIO)
10430{
icTagTypeSignature sig;

//check size properly
icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
                            sizeof(icUInt32Number)*4;
if (headerSize > size)
  return false;

if (!pIO) {
  return false;
}

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


if (!pIO->Read32(&m_stdObserver) ||
    !pIO->Read16(&m_observerRange.start) ||
    !pIO->Read16(&m_observerRange.end) ||
    !pIO->Read16(&m_observerRange.steps) ||
    !pIO->Read16(&m_reserved2))
  return false;

icUInt32Number vals;

if (m_observer) {
  delete [] m_observer;
  m_observer = NULL__null;
}

icUInt32Number observerSize = 0;

if (m_observerRange.steps) {
  vals = m_observerRange.steps * 3;

  observerSize = vals * sizeof(icFloat32Number);

  if (headerSize + observerSize > size)
    return false;
  
  m_observer = new icFloat32Number[vals];
  if (!m_observer)
    return false;

  if (pIO->ReadFloat32Float(&m_observer[0], vals) != vals)
    return false;
}

icUInt32Number illumInfoSize = 2 * sizeof(icUInt32Number) + 4 * sizeof(icUInt16Number);
if (headerSize + observerSize +illumInfoSize > size)
  return false;

if (!pIO->Read32(&m_stdIlluminant) ||
    !pIO->ReadFloat32Float(&m_colorTemperature) ||
    !pIO->Read16(&m_illuminantRange.start) ||
    !pIO->Read16(&m_illuminantRange.end) ||
    !pIO->Read16(&m_illuminantRange.steps) ||
    !pIO->Read16(&m_reserved3))
  return false;


if (m_illuminant) {
  delete [] m_illuminant;
  m_illuminant = NULL__null;
}

icUInt32Number illuminantSize = 0;

if (m_illuminantRange.steps) {
  vals = m_illuminantRange.steps;

  illuminantSize = vals * sizeof(icFloat32Number);

  if (headerSize + observerSize + illumInfoSize + illuminantSize > size)
    return false;

  m_illuminant = new icFloat32Number[vals];
  if (!m_illuminant)
    return false;

  if (pIO->ReadFloat32Float(&m_illuminant[0], vals) != vals)
    return false;
}
else {
  setIlluminant(m_stdIlluminant, m_illuminantRange, NULL__null, m_colorTemperature);
}

if (headerSize + observerSize + illumInfoSize + illuminantSize + 6*sizeof(icFloat32Number) > size)
  return false;

if (pIO->ReadFloat32Float(&m_illuminantXYZ, 3)!=3 ||
    pIO->ReadFloat32Float(&m_surroundXYZ, 3)!=3)
  return false;

return true;
10527}


10530/**
****************************************************************************
* Name: CIccTagSpectralViewingConditions::Write
* 
* Purpose: Write the tag to a file
* 
* Args: 
*  pIO - The IO object to write tag to.
* 
* Return: 
*  true = succesful, false = failure
*****************************************************************************
*/
10543bool CIccTagSpectralViewingConditions::Write(CIccIO *pIO)
10544{
icTagTypeSignature sig = GetType();

if (!pIO) {
  return false;
}

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


if (!pIO->Write32(&m_stdObserver) ||
    !pIO->Write16(&m_observerRange.start) ||
    !pIO->Write16(&m_observerRange.end) ||
    !pIO->Write16(&m_observerRange.steps) ||
    !pIO->Write16(&m_reserved2))
  return false;

icUInt32Number vals = m_observerRange.steps*3;

if (vals)
  if (pIO->WriteFloat32Float(&m_observer[0], vals) != vals)
    return false;

if (!pIO->Write32(&m_stdIlluminant) ||
  !pIO->WriteFloat32Float(&m_colorTemperature) ||
  !pIO->Write16(&m_illuminantRange.start) ||
  !pIO->Write16(&m_illuminantRange.end) ||
  !pIO->Write16(&m_illuminantRange.steps) ||
  !pIO->Write16(&m_reserved3))
  return false;

vals = m_illuminantRange.steps;

if (vals)
  if (pIO->WriteFloat32Float(&m_illuminant[0], vals) != vals)
    return false;

if (pIO->WriteFloat32Float(&m_illuminantXYZ, 3)!=3 ||
    pIO->WriteFloat32Float(&m_surroundXYZ, 3)!=3)
  return false;

return true;
10588}


10591/**
****************************************************************************
* Name: CIccTagSpectralViewingConditions::Describe
* 
* Purpose: Dump data associated with the tag to a string
* 
* Args: 
*  sDescription - string to concatenate tag dump to
*****************************************************************************
*/
10601void CIccTagSpectralViewingConditions::Describe(std::string &sDescription)
10602{
icChar buf[128];
CIccInfo info;

sprintf(buf, "StdObserver: %s\r\n\r\n", info.GetStandardObserverName(m_stdObserver));
sDescription += buf;

sprintf(buf, "Illuminant Tristimulus values: X = %.4lf, Y = %.4lf, Z = %.4lf\r\n\r\n", 
  m_illuminantXYZ.X, m_illuminantXYZ.Y,m_illuminantXYZ.Z);
sDescription += buf;

if (m_observer) {
  sprintf(buf, "Observer Functions: start=%.1fnm end=%.1fnm, steps=%d\r\n", 
          icF16toF(m_observerRange.start), icF16toF(m_observerRange.end), m_observerRange.steps);
  sDescription += buf;
  icFloat32Number *ptr = m_observer;
  int i, j;
  for (j=0; j<3; j++) {
    for (i=0; i<m_observerRange.steps; i++) {
      sprintf(buf, " %.4f", *ptr);
      sDescription += buf;
      ptr++;
    }
    sDescription += "\r\n\r\n";
  }
}
else {
  sDescription += "No custom Observer defined\r\n\r\n";
}

sDescription += "StdIlluminant Type: ";

sDescription += info.GetIlluminantName(m_stdIlluminant);
sDescription += "\r\n";

sprintf(buf, "Color Temperature: %.1fK\r\n\r\n", m_colorTemperature);
sDescription += buf;

if (m_illuminant) {
  sprintf(buf, "Illuminant SPD: start=%.1fm end=%.1fnm, steps=%d\r\n", 
    icF16toF(m_illuminantRange.start), icF16toF(m_illuminantRange.end), m_illuminantRange.steps);
  sDescription += buf;
  icFloat32Number *ptr = m_illuminant;
  int i;
  for (i=0; i<m_illuminantRange.steps; i++) {
    sprintf(buf, " %.4f", *ptr);
    sDescription += buf;
    ptr++;
  }
  sDescription += "\r\n\r\n";
}
else {
  sDescription += "No custom Observer defined\r\n\r\n";
}

sprintf(buf, "Surround Tristimulus values: X = %.4lf, Y = %.4lf, Z = %.4lf\r\n",
  m_surroundXYZ.X, m_surroundXYZ.Y, m_surroundXYZ.Z);
sDescription += buf;
10660}



10664/**
10665******************************************************************************
10666* Name: CIccTagSpectralViewingConditions::Validate
10667* 
10668* Purpose: Check tag data validity.
10669* 
10670* Args: 
10671*  sig = signature of tag being validated,
10672*  sReport = String to add report information to
10673* 
10674* Return: 
10675*  icValidateStatusOK if valid, or other error status.
10676******************************************************************************
10677*/
10678icValidateStatus CIccTagSpectralViewingConditions::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
10679{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

rv = icMaxStatus(rv, Info.CheckData(sReport, m_illuminantXYZ, sSigPathName+":>illuminantXYZ"));
rv = icMaxStatus(rv, Info.CheckData(sReport, m_surroundXYZ, sSigPathName + ":>surroundXYZ"));

rv = icMaxStatus(rv, Info.CheckLuminance(sReport, m_illuminantXYZ, sSigPathName + ":>illuminantXYZ"));
rv = icMaxStatus(rv, Info.CheckLuminance(sReport, m_surroundXYZ, sSigPathName + ":>surroundXYZ"));

if (m_observerRange.steps)
  rv = icMaxStatus(rv, Info.CheckData(sReport, m_observerRange, sSigPathName + ":>observerRange"));
if (m_illuminantRange.steps)
  rv = icMaxStatus(rv, Info.CheckData(sReport, m_illuminantRange, sSigPathName + ":>illuminantRange"));

return rv;
10697}

10699icFloatNumber *CIccTagSpectralViewingConditions::applyRangeToObserver(const icSpectralRange &newRange) const
10700{
int n = newRange.steps*3;
icFloatNumber *rv = (icFloatNumber*)malloc(n*sizeof(icFloatNumber));

CIccMatrixMath *range = CIccMatrixMath::rangeMap(m_observerRange, newRange);
if (range) {
  range->VectorMult(rv, m_observer);
  range->VectorMult(&rv[newRange.steps], &m_observer[m_observerRange.steps]);
  range->VectorMult(&rv[newRange.steps*2], &m_observer[m_observerRange.steps*2]);
  delete range;
}
else {
  memcpy(rv, m_observer, m_observerRange.steps*3*sizeof(icFloatNumber));
}

return rv;
10716}

10718CIccMatrixMath *CIccTagSpectralViewingConditions::getObserverMatrix(const icSpectralRange &newRange) const
10719{
CIccMatrixMath *pMtx=new CIccMatrixMath(3, newRange.steps);

CIccMatrixMath *range = CIccPcsXform::rangeMap(m_observerRange, newRange);
if (range) {
  range->VectorMult(pMtx->entry(0), m_observer);
  range->VectorMult(pMtx->entry(1), &m_observer[m_observerRange.steps]);
  range->VectorMult(pMtx->entry(2), &m_observer[m_observerRange.steps*2]);
  delete range;
}
else {
  memcpy(pMtx->entry(0), m_observer, m_observerRange.steps*3*sizeof(icFloatNumber));
}

return pMtx;
10734}

10736const icFloatNumber *CIccTagSpectralViewingConditions::getIlluminant(icSpectralRange &illumRange) const
10737{
illumRange = m_illuminantRange;
return m_illuminant;
10740}

10742bool CIccTagSpectralViewingConditions::setIlluminant(icIlluminant illumId, const icSpectralRange &illumRange, const icFloatNumber *illum, icFloatNumber illumCCT/* = 0.0f*/)
10743{
m_stdIlluminant = illumId;
m_colorTemperature = illumCCT;

if (m_illuminant) {
  free(m_illuminant);
}

m_illuminantRange = illumRange;

if (illumRange.steps && illum) {
  icUInt32Number size = illumRange.steps * sizeof(icFloatNumber);
  m_illuminant = (icFloatNumber *)malloc(size);
  if (m_illuminant)
    memcpy(m_illuminant, illum, size);
  else {
    memset(&m_illuminantRange, 0, sizeof(m_illuminantRange));
    return false;
  }
}
else {
  if (!illum)
    memset(&m_illuminantRange, 0, sizeof(m_illuminantRange));

  m_illuminant = NULL__null;
}

return true;
10771}

10773bool CIccTagSpectralViewingConditions::setIlluminant(icFloatNumber *pWhiteXYZ)
10774{
icSpectralRange zeroRange;
memset(&zeroRange, 0, sizeof(zeroRange));
icFloatNumber white[3];
white[0] = pWhiteXYZ[0] / pWhiteXYZ[1];
white[1] = 1.0;
white[2] = pWhiteXYZ[2] / pWhiteXYZ[1];

if (!pWhiteXYZ || !icNotZero(pWhiteXYZ[1])((pWhiteXYZ[1])>1.0e-8 || (pWhiteXYZ[1])<-1.0e-8)) {
  setIlluminant(icIlluminantUnknown, zeroRange, NULL__null);
  return false;
}

if (m_stdObserver == icStdObs1931TwoDegrees) {
  if ((icIsNear(white[0], icD50XYZ[0]) && icIsNear(white[2], icD50XYZ[2])) ||
      (icIsNear(white[0], 0.9642f, 0.0001f) && icIsNear(white[2], 0.8251f, 0.0001f))) {
    return setIlluminant(icIlluminantD50, zeroRange, NULL__null, 5000);
  }
  else if (icIsNear(white[0], 0.9505f, 0.0001f) && icIsNear(white[2], 1.0888f, 0.0001f)) {
    return setIlluminant(icIlluminantD65, zeroRange, NULL__null, 6504);
  }
}
10796//   else if (m_stdObserver == icStdObs1964TenDegrees) {
10797//     setIlluminant(icIlluminantUnknown, zeroRange, NULL);
10798//     return false;
10799//   }

setIlluminant(icIlluminantUnknown, zeroRange, NULL__null);
return false;
10803}

10805const icFloatNumber *CIccTagSpectralViewingConditions::getObserver(icSpectralRange &observerRange) const
10806{
observerRange = m_observerRange;
return m_observer;
10809}

10811bool CIccTagSpectralViewingConditions::setObserver(icStandardObserver observerId, const icSpectralRange &observerRange, const icFloatNumber *observer)
10812{
m_stdObserver = observerId;
m_observerRange = observerRange;
if (m_observer) {
  free(m_observer);
}

if (observerRange.steps && observer) {
  icUInt32Number size = observerRange.steps * sizeof(icFloatNumber) * 3;
  m_observer = (icFloatNumber *)malloc(size);
  if (m_observer)
    memcpy(m_observer, observer, size);
  else {
    memset(&m_observerRange, 0, sizeof(m_observerRange));
    return false;
  }
}
else {
  if (!observer)
    memset(&m_observerRange, 0, sizeof(m_illuminantRange));

  m_observer = NULL__null;
}

return true;
10837}


10840bool icGetTagText(CIccTag *pTag, std::string &text)
10841{
if (!pTag) {
  text = "";
  return false;
}
switch (pTag->GetType()) {
  case icSigTextType:
  {
    CIccTagText *pTextTag = (CIccTagText*)pTag;
    const char *szText = pTextTag->GetText();
    if (szText) {
      text = szText;
      return true;
    }
  }
  text = "";
  return false;

  case icSigUtf8TextType:
  {
    CIccTagUtf8Text *pTextTag = (CIccTagUtf8Text*)pTag;
    const char *szText = (const char*)pTextTag->GetText();
    if (szText) {
      text = szText;
      return true;
    }
  }
  text = "";
  return false;

  case icSigZipUtf8TextType:
  {
    CIccTagZipUtf8Text *pTextTag = (CIccTagZipUtf8Text*)pTag;
    bool rv = pTextTag->GetText(text);
    return rv;
  }

  case icSigUtf16TextType:
  {
    CIccTagUtf16Text *pTextTag = (CIccTagUtf16Text*)pTag;
    const icChar *szText = pTextTag->GetText(text);
    if (szText)
      return true;
  }
  return false;

  case icSigTextDescriptionType:
  {
    CIccTagTextDescription *pTextTag = (CIccTagTextDescription*)pTag;
    const char *szText = pTextTag->GetText();
    if (szText) {
      text = szText;
      return true;
    }
  }
  text = "";
  return false;

  case icSigMultiLocalizedUnicodeType:
  {
    CIccTagMultiLocalizedUnicode *pTextTag = (CIccTagMultiLocalizedUnicode*)pTag;
    CIccLocalizedUnicode *pText = pTextTag->Find();
    if (pText) {
      bool rv = pText->GetText(text);
      return rv;
    }
  }
  text = "";
  return false;

  default:
    text = "";
    return false;
}
10915}


10918/**
10919****************************************************************************
10920* Name: CIccEmbeddedHeightImage::CIccEmbeddedHeightImage
10921*
10922* Purpose: Constructor
10923*
10924* Args:
10925*  nSize =size of embedded image
10926*
10927*****************************************************************************
10928*/
10929CIccTagEmbeddedHeightImage::CIccTagEmbeddedHeightImage(int nSize/*=1*/)
10930{
m_nSize = nSize;
if (m_nSize <1)
  m_nSize = 1;
m_pData = (icUInt8Number*)calloc(nSize, sizeof(icUInt8Number));
m_nSeamlesIndicator = 0;
m_nEncodingFormat = icPngImageType;
m_fMetersMinPixelValue = 0;
m_fMetersMaxPixelValue = 0;
10939}


10942/**
10943****************************************************************************
10944* Name: CIccTagEmbeddedHeightImage::CIccTagEmbeddedHeightImage
10945*
10946* Purpose: Copy Constructor
10947*
10948* Args:
10949*  ITD = The CIccEmbeddedHeightImage object to be copied
10950*****************************************************************************
10951*/
10952CIccTagEmbeddedHeightImage::CIccTagEmbeddedHeightImage(const CIccTagEmbeddedHeightImage &IEHI)
10953{
m_nSeamlesIndicator = IEHI.m_nSeamlesIndicator;
m_nEncodingFormat = IEHI.m_nEncodingFormat;
m_fMetersMinPixelValue = IEHI.m_fMetersMinPixelValue;
m_fMetersMaxPixelValue = IEHI.m_fMetersMaxPixelValue;
m_nSize = IEHI.m_nSize;

m_pData = (icUInt8Number*)calloc(m_nSize, sizeof(icUInt8Number));
memcpy(m_pData, IEHI.m_pData, sizeof(icUInt8Number)*m_nSize);
10962}


10965/**
10966****************************************************************************
10967* Name: CIccTagEmbeddedHeightImage::operator=
10968*
10969* Purpose: Copy Operator
10970*
10971* Args:
10972*  DataTag = The CIccTagData object to be copied
10973*****************************************************************************
10974*/
10975CIccTagEmbeddedHeightImage &CIccTagEmbeddedHeightImage::operator=(const CIccTagEmbeddedHeightImage &HeightImageTag)
10976{
if (&HeightImageTag == this)
  return *this;

m_nSeamlesIndicator = HeightImageTag.m_nSeamlesIndicator;
m_nEncodingFormat = HeightImageTag.m_nEncodingFormat;
m_fMetersMinPixelValue = HeightImageTag.m_fMetersMinPixelValue;
m_fMetersMaxPixelValue = HeightImageTag.m_fMetersMaxPixelValue;
m_nSize = HeightImageTag.m_nSize;

if (m_pData)
  free(m_pData);
m_pData = (icUInt8Number*)calloc(m_nSize, sizeof(icUInt8Number));
memcpy(m_pData, HeightImageTag.m_pData, sizeof(icUInt8Number)*m_nSize);

return *this;
10992}


10995/**
10996****************************************************************************
10997* Name: CIccTagEmbeddedHeightImage::~CIccTagEmbeddedHeightImage
10998*
10999* Purpose: Destructor
11000*
11001*****************************************************************************
11002*/
11003CIccTagEmbeddedHeightImage::~CIccTagEmbeddedHeightImage()
11004{
if (m_pData)
  free(m_pData);
11007}


11010/**
11011****************************************************************************
11012* Name: CIccTagEmbeddedHeightImage::Read
11013*
11014* Purpose: Read in the tag contents into a data block
11015*
11016* Args:
11017*  size - # of bytes in tag,
11018*  pIO - IO object to read tag from
11019*
11020* Return:
11021*  true = successful, false = failure
11022*****************************************************************************
11023*/
11024bool CIccTagEmbeddedHeightImage::Read(icUInt32Number size, CIccIO *pIO)
11025{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) +
  sizeof(icUInt32Number) +
  sizeof(icUInt32Number) +
  sizeof(icUInt32Number) +
  sizeof(icFloat32Number) +
  sizeof(icFloat32Number) +
  sizeof(icUInt8Number) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

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

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

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

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

icUInt32Number nNum = size - 6 * sizeof(icUInt32Number);

if (!SetSize(nNum))
  return false;

if (pIO->Read8(m_pData, nNum) != (icInt32Number)nNum)
  return false;

return true;
11068}


11071/**
11072****************************************************************************
11073* Name: CIccTagEmbeddedHeightImage::Write
11074*
11075* Purpose: Write the tag to a file
11076*
11077* Args:
11078*  pIO - The IO object to write tag to.
11079*
11080* Return:
11081*  true = succesful, false = failure
11082*****************************************************************************
11083*/
11084bool CIccTagEmbeddedHeightImage::Write(CIccIO *pIO)
11085{
icTagTypeSignature sig = GetType();

if (!pIO)
  return false;

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

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

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

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

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

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

if (pIO->Write8(m_pData, m_nSize) != (icInt32Number)m_nSize)
  return false;

return true;
11113}


11116/**
11117****************************************************************************
11118* Name: CIccTagEmbeddedHeightImage::Describe
11119*
11120* Purpose: Dump data associated with the tag to a string
11121*
11122* Args:
11123*  sDescription - string to concatenate tag dump to
11124*****************************************************************************
11125*/
11126void CIccTagEmbeddedHeightImage::Describe(std::string &sDescription)
11127{
icChar buf[128];

sprintf(buf, "\r\nSeamlessIndicater: %d\r\n", m_nSeamlesIndicator);
sDescription += buf;

switch (m_nEncodingFormat) {
case icPngImageType:
  strcpy(buf, "EncodingFormat: PNG\r\n");
  break;
case icTiffImageType:
  strcpy(buf, "EncodingFormat: TIFF\r\n");
  break;
default:
  sprintf(buf, "EncodingFormat: %d", m_nEncodingFormat);
  break;
}
sDescription += buf;

sprintf(buf, "Height minimum pixel: %.4fmeters\r\n", m_fMetersMinPixelValue);
sprintf(buf, "Height maximum pixel: %.4fmeters\r\n", m_fMetersMaxPixelValue);

sDescription += "\r\nImage Data:\r\n";

for (int i = 0; i<(int)m_nSize; i++) {
  if (!(i & 0x1f))
    sDescription += "\r\n";
  sprintf(buf, "%02X", m_pData[i]);
  sDescription += buf;
}
sDescription += "\r\n";
11158}

11160/**
11161****************************************************************************
11162* Name: CIccTagEmbeddedHeightImage::SetSize
11163*
11164* Purpose: Sets the size of the data array.
11165*
11166* Args:
11167*  nSize - number of data entries,
11168*  bZeroNew - flag to zero newly formed values
11169*****************************************************************************
11170*/
11171bool CIccTagEmbeddedHeightImage::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
11172{
if (m_nSize == nSize)
  return true;

m_pData = (icUInt8Number*)icRealloc(m_pData, nSize * sizeof(icUInt8Number));

if (!m_pData) {
  m_nSize = 0;
  return false;
}

if (bZeroNew && nSize > m_nSize) {
  memset(&m_pData[m_nSize], 0, (nSize - m_nSize) * sizeof(icUInt8Number));
}
m_nSize = nSize;

return true;
11189}


11192/**
11193******************************************************************************
11194* Name: CIccTagEmbeddedHeightImage::Validate
11195*
11196* Purpose: Check tag data validity.
11197*
11198* Args:
11199*  sig = signature of tag being validated,
11200*  sReport = String to add report information to
11201*
11202* Return:
11203*  icValidateStatusOK if valid, or other error status.
11204******************************************************************************
11205*/
11206icValidateStatus CIccTagEmbeddedHeightImage::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
11207{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

switch (m_nSeamlesIndicator) {
case 0:
case 1:
  break;
default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid data flag Seamless Indicator.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

switch (m_nEncodingFormat) {
case icPngImageType:
case icTiffImageType:
  break;
default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid data flag Encoding Image Type.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

return rv;
11236}



11240/**
11241****************************************************************************
11242* Name: CIccTagEmbeddedNormalImage::CIccTagEmbeddedNormalImage
11243*
11244* Purpose: Constructor
11245*
11246* Args:
11247*  nSize =size of embedded image
11248*
11249*****************************************************************************
11250*/
11251CIccTagEmbeddedNormalImage::CIccTagEmbeddedNormalImage(int nSize/*=1*/)
11252{
m_nSize = nSize;
if (m_nSize < 1)
  m_nSize = 1;
m_pData = (icUInt8Number*)calloc(nSize, sizeof(icUInt8Number));
m_nSeamlesIndicator = 0;
m_nEncodingFormat = icPngImageType;
11259}


11262/**
11263****************************************************************************
11264* Name: CIccTagEmbeddedNormalImage::CIccTagEmbeddedNormalImage
11265*
11266* Purpose: Copy Constructor
11267*
11268* Args:
11269*  ITD = The CIccEmbeddedNormalImage object to be copied
11270*****************************************************************************
11271*/
11272CIccTagEmbeddedNormalImage::CIccTagEmbeddedNormalImage(const CIccTagEmbeddedNormalImage &IENI)
11273{
m_nSeamlesIndicator = IENI.m_nSeamlesIndicator;
m_nEncodingFormat = IENI.m_nEncodingFormat;
m_nSize = IENI.m_nSize;

m_pData = (icUInt8Number*)calloc(m_nSize, sizeof(icUInt8Number));
memcpy(m_pData, IENI.m_pData, sizeof(icUInt8Number)*m_nSize);
11280}


11283/**
11284****************************************************************************
11285* Name: CIccTagEmbeddedNormalImage::operator=
11286*
11287* Purpose: Copy Operator
11288*
11289* Args:
11290*  DataTag = The CIccTagData object to be copied
11291*****************************************************************************
11292*/
11293CIccTagEmbeddedNormalImage &CIccTagEmbeddedNormalImage::operator=(const CIccTagEmbeddedNormalImage &NormalImageTag)
11294{
if (&NormalImageTag == this)
  return *this;

m_nSeamlesIndicator = NormalImageTag.m_nSeamlesIndicator;
m_nEncodingFormat = NormalImageTag.m_nEncodingFormat;
m_nSize = NormalImageTag.m_nSize;

if (m_pData)
  free(m_pData);
m_pData = (icUInt8Number*)calloc(m_nSize, sizeof(icUInt8Number));
memcpy(m_pData, NormalImageTag.m_pData, sizeof(icUInt8Number)*m_nSize);

return *this;
11308}


11311/**
11312****************************************************************************
11313* Name: CIccTagEmbeddedNormalImage::~CIccTagEmbeddedNormalImage
11314*
11315* Purpose: Destructor
11316*
11317*****************************************************************************
11318*/
11319CIccTagEmbeddedNormalImage::~CIccTagEmbeddedNormalImage()
11320{
if (m_pData)
  free(m_pData);
11323}


11326/**
11327****************************************************************************
11328* Name: CIccTagEmbeddedNormalImage::Read
11329*
11330* Purpose: Read in the tag contents into a data block
11331*
11332* Args:
11333*  size - # of bytes in tag,
11334*  pIO - IO object to read tag from
11335*
11336* Return:
11337*  true = successful, false = failure
11338*****************************************************************************
11339*/
11340bool CIccTagEmbeddedNormalImage::Read(icUInt32Number size, CIccIO *pIO)
11341{
icTagTypeSignature sig;

if (sizeof(icTagTypeSignature) +
  sizeof(icUInt32Number) +
  sizeof(icUInt32Number) +
  sizeof(icUInt32Number) +
  sizeof(icUInt8Number) > size)
  return false;

if (!pIO) {
  return false;
}

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

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

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

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

icUInt32Number nNum = size - 4 * sizeof(icUInt32Number);

if (!SetSize(nNum))
  return false;

if (pIO->Read8(m_pData, nNum) != (icInt32Number)nNum)
  return false;

return true;
11376}


11379/**
11380****************************************************************************
11381* Name: CIccTagEmbeddedNormalImage::Write
11382*
11383* Purpose: Write the tag to a file
11384*
11385* Args:
11386*  pIO - The IO object to write tag to.
11387*
11388* Return:
11389*  true = succesful, false = failure
11390*****************************************************************************
11391*/
11392bool CIccTagEmbeddedNormalImage::Write(CIccIO *pIO)
11393{
icTagTypeSignature sig = GetType();

if (!pIO)
  return false;

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

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

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

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

if (pIO->Write8(m_pData, m_nSize) != (icInt32Number)m_nSize)
  return false;

return true;
11415}


11418/**
11419****************************************************************************
11420* Name: CIccTagEmbeddedNormalImage::Describe
11421*
11422* Purpose: Dump data associated with the tag to a string
11423*
11424* Args:
11425*  sDescription - string to concatenate tag dump to
11426*****************************************************************************
11427*/
11428void CIccTagEmbeddedNormalImage::Describe(std::string &sDescription)
11429{
icChar buf[128];

sprintf(buf, "\r\nSeamlessIndicater: %d\r\n", m_nSeamlesIndicator);
sDescription += buf;

switch (m_nEncodingFormat) {
case icPngImageType:
  strcpy(buf, "EncodingFormat: PNG\r\n");
  break;
case icTiffImageType:
  strcpy(buf, "EncodingFormat: TIFF\r\n");
  break;
default:
  sprintf(buf, "EncodingFormat: %d", m_nEncodingFormat);
  break;
}
sDescription += buf;

sDescription += "\r\nImage Data:\r\n";

for (int i = 0; i < (int)m_nSize; i++) {
  if (!(i & 0x1f))
    sDescription += "\r\n";
  sprintf(buf, "%02X", m_pData[i]);
  sDescription += buf;
}
sDescription += "\r\n";
11457}

11459/**
11460****************************************************************************
11461* Name: CIccTagEmbeddedNormalImage::SetSize
11462*
11463* Purpose: Sets the size of the data array.
11464*
11465* Args:
11466*  nSize - number of data entries,
11467*  bZeroNew - flag to zero newly formed values
11468*****************************************************************************
11469*/
11470bool CIccTagEmbeddedNormalImage::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
11471{
if (m_nSize == nSize)
  return true;

m_pData = (icUInt8Number*)icRealloc(m_pData, nSize * sizeof(icUInt8Number));

if (!m_pData) {
  m_nSize = 0;
  return false;
}

if (bZeroNew && nSize > m_nSize) {
  memset(&m_pData[m_nSize], 0, (nSize - m_nSize) * sizeof(icUInt8Number));
}
m_nSize = nSize;

return true;
11488}


11491/**
11492******************************************************************************
11493* Name: CIccTagEmbeddedNormalImage::Validate
11494*
11495* Purpose: Check tag data validity.
11496*
11497* Args:
11498*  sig = signature of tag being validated,
11499*  sReport = String to add report information to
11500*
11501* Return:
11502*  icValidateStatusOK if valid, or other error status.
11503******************************************************************************
11504*/
11505icValidateStatus CIccTagEmbeddedNormalImage::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
11506{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);

CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

switch (m_nSeamlesIndicator) {
case 0:
case 1:
  break;
default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid data flag Seamless Indicator.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

switch (m_nEncodingFormat) {
case icPngImageType:
  if (m_nSize > 4 && m_pData) {
    unsigned char PNGhdr[] = { 'P', 'N', 'G' };
    if (memcmp(m_pData+1, PNGhdr, 3)) {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sReport += " - Non-PNG file stored as Embedded image.\r\n";
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
  }
  break;
case icTiffImageType:
  if (m_nSize > 4 && m_pData) {
    unsigned char IIhdr[] = { 'I', 'I', 42, 0 };
    unsigned char MMhdr[] = { 'M', 'M', 0, 42 };

    if (memcmp(m_pData, IIhdr, 4) && memcmp(m_pData, MMhdr, 4)) {
      sReport += icMsgValidateNonCompliant;
      sReport += sSigPathName;
      sReport += " - Non-TIFF file stored as Embedded image.\r\n";
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
  }
  break;
default:
  sReport += icMsgValidateNonCompliant;
  sReport += sSigPathName;
  sReport += " - Invalid data flag Encoding Image Type.\r\n";
  rv = icMaxStatus(rv, icValidateNonCompliant);
}

return rv;
11556}



11560#ifdef USEREFICCMAXNAMESPACE
11561} //namespace refIccMAX
11562#endif