IccTagBasic.cpp

Go to the documentation of this file.

/** @file
    File:       IccTagBasic.cpp
 
    Contains:   Implementation of the CIccTag class and basic inherited classes
 
    Version:    V1
 
    Copyright:  � see ICC Software License
*/
 
/*
 * 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/>.
 *  
 * 
 */
 
////////////////////////////////////////////////////////////////////// 
// HISTORY:
//
// -Initial implementation by Max Derhak 5-15-2003
//
//////////////////////////////////////////////////////////////////////
 
#ifdef WIN32
  #pragma warning( disable: 4786) //disable warning in <list.h>
  #include <windows.h>
#endif
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "IccTag.h"
#include "IccUtil.h"
#include "IccProfile.h"
#include "IccTagFactory.h"
#include "IccConvertUTF.h"
#include "IccSparseMatrix.h"
#include "IccCmm.h"
 
#ifdef ICC_USE_ZLIB
#include "zlib.h"
#endif
 
 
#ifndef __min
#include <algorithm>
using std::min;
#define __min min
#endif
 
#ifdef USEREFICCMAXNAMESPACE
namespace refIccMAX {
#endif
 
// For Describe() nVerboseness levels < 25, maximum length of strings
#define BRIEF_STRING_SIZE (1024)
 
/**
 ****************************************************************************
 * Name: CIccTag::CIccTag
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTag::CIccTag()
{
  m_nReserved = 0;
}
 
/**
 ****************************************************************************
 * Name: CIccTag::CIccTag
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTag::~CIccTag()
{
 
}
 
/**
 ****************************************************************************
 * 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 
 *****************************************************************************
 */
CIccTag* CIccTag::Create(icTagTypeSignature sig)
{
  return CIccTagCreator::CreateTag(sig);
}
 
 
/**
 ******************************************************************************
 * 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.
 ******************************************************************************
 */
icValidateStatus CIccTag::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  icValidateStatus rv = icValidateOK;
  
  if (m_nReserved != 0) {
    CIccInfo Info;
    sReport += icMsgValidateNonCompliant;
    sReport += Info.GetSigPathName(sigPath);
    sReport += " - Reserved Value must be zero.\n";
 
    rv = icValidateNonCompliant;
  }
 
  return rv;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagUnknown::CIccTagUnknown
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTagUnknown::CIccTagUnknown()
{
  m_nType = icSigUnknownType;
  m_pData = NULL;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUnknown::CIccTagUnknown
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITU = The CIccTagUnknown object to be copied
 *****************************************************************************
 */
CIccTagUnknown::CIccTagUnknown(const CIccTagUnknown &ITU)
{
  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);
}
 
/**
 ****************************************************************************
 * Name: CIccTagUnknown::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  UnknownTag = The CIccTagUnknown object to be copied
 *****************************************************************************
 */
CIccTagUnknown &CIccTagUnknown::operator=(const CIccTagUnknown &UnknownTag)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUnknown::~CIccTagUnknown
 * 
 * Purpose: Destructor
 *****************************************************************************
 */
CIccTagUnknown::~CIccTagUnknown()
{
  if (m_pData)
    delete [] m_pData;
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagUnknown::Read(icUInt32Number size, CIccIO *pIO)
{
  if (m_pData) {
    delete [] m_pData;
    m_pData = 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;
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagUnknown::Write(CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagUnknown::Describe
 * 
 * Purpose: Dump data associated with unknown tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagUnknown::Describe(std::string &sDescription, int nVerboseness)
{
  icChar buf[128];
 
  sDescription = "Unknown Tag Type of ";
  sprintf(buf, "%u Bytes.", m_nSize-4);
  sDescription += buf;
 
  if (nVerboseness > 50) {
    sDescription += "\n\nData Follows:\n";
 
    icMemDump(sDescription, m_pData+4, m_nSize-4);
  }
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagText::CIccTagText
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTagText::CIccTagText()
{
  m_szText = (icChar*)malloc(1);
  m_szText[0] = '\0';
  m_nBufSize = 1;
}
 
/**
 ****************************************************************************
 * Name: CIccTagText::CIccTagText
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITT = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagText::CIccTagText(const CIccTagText &ITT)
{
  m_szText = (icChar*)malloc(1);
  m_szText[0] = '\0';
  m_nBufSize = 1;
  SetText(ITT.m_szText);
}
 
/**
 ****************************************************************************
 * Name: CIccTagText::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  TextTag = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagText &CIccTagText::operator=(const CIccTagText &TextTag)
{
  if (&TextTag == this)
    return *this;
 
  m_szText = (icChar*)malloc(1);
  m_szText[0] = '\0';
  m_nBufSize = 1;
  SetText(TextTag.m_szText);
 
  return *this;
}
 
/**
 ****************************************************************************
 * Name: CIccTagText::~CIccTagText
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagText::~CIccTagText()
{
  free(m_szText);
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagText::Read(icUInt32Number size, CIccIO *pIO)
{
  icTagTypeSignature sig;
 
  // Defensive: initialize so error paths all have valid m_szText
  m_szText[0] = '\0';
 
  if (size < (sizeof(icTagTypeSignature) + sizeof(icUInt32Number)) || !pIO)
    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;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagText::Write(CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagText::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagText::Describe(std::string &sDescription, int nVerboseness)
{
  sDescription += "Text Length = ";
  if (m_szText && *m_szText) {
    char buf[40];
    sprintf(buf, "%zu bytes\n", strlen(m_szText));
    sDescription += buf;
  } else
    sDescription += "0 (NULL)";
 
  if (nVerboseness > 25) {
    sDescription += "\"";
    if (m_szText && *m_szText) {
      if ((nVerboseness > 50) || (strlen(m_szText) < BRIEF_STRING_SIZE)) {
        // output entire string if short or doing verbose
        sDescription += m_szText;  
      }
      else {
        // copy just first part of string to keep nVerboseness under control
        char buf[BRIEF_STRING_SIZE + 1];
        strncpy(buf, m_szText, BRIEF_STRING_SIZE);
        buf[BRIEF_STRING_SIZE] = '\0'; // ensure NULL termination
        sDescription += buf;
        sDescription += "\n... <!truncated!>";
      }
    }
    sDescription += "\"\n";
  }
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagText::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
void CIccTagText::SetText(const icChar *szText)
{
  if (!szText) 
    SetText("");
 
  icUInt32Number len=(icUInt32Number)strlen(szText) + 1;
  icChar *szBuf = GetBuffer(len);
 
  strcpy(szBuf, szText);
  Release();
}
 
/**
 ****************************************************************************
 * 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.
 *****************************************************************************
 */
const icChar *CIccTagText::operator=(const icChar *szText)
{
  SetText(szText);
  return m_szText;
}
 
/**
 ******************************************************************************
 * 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
 *******************************************************************************
 */
icChar *CIccTagText::GetBuffer(icUInt32Number nSize)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagText::Release
 * 
 * Purpose: This will resize the buffer to fit the zero terminated string in
 *  the buffer.
 *****************************************************************************
 */
void CIccTagText::Release()
{
  icUInt32Number nSize = (icUInt32Number)strlen(m_szText)+1;
 
  if (nSize < m_nBufSize-1) {
    m_szText=(icChar*)icRealloc(m_szText, nSize+1);
    m_nBufSize = nSize+1;
  }
}
 
 
/**
******************************************************************************
* Name: CIccTagText::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagText::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\n";
        rv = icMaxStatus(rv, icValidateNonCompliant);
      }
      break;
    default:
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " - Unknown Tag.\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.\n";
        rv = icMaxStatus(rv, icValidateWarning);
      }
    }
  }
  else {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " - Empty Tag.\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
 
 
  return rv;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::CIccTagUtf8Text
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTagUtf8Text::CIccTagUtf8Text()
{
  m_szText = (icUChar*)malloc(1);
  m_szText[0] = '\0';
  m_nBufSize = 1;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::CIccTagUtf8Text
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITT = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagUtf8Text::CIccTagUtf8Text(const CIccTagUtf8Text &ITT)
{
  m_szText = (icUChar*)malloc(1);
  m_szText[0] = '\0';
  m_nBufSize = 1;
  SetText(ITT.m_szText);
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  TextTag = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagUtf8Text &CIccTagUtf8Text::operator=(const CIccTagUtf8Text &TextTag)
{
  if (&TextTag == this)
    return *this;
 
  m_szText = (icUChar*)malloc(1);
  m_szText[0] = '\0';
  m_nBufSize = 1;
  SetText(TextTag.m_szText);
 
  return *this;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::~CIccTagUtf8Text
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagUtf8Text::~CIccTagUtf8Text()
{
  free(m_szText);
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagUtf8Text::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagUtf8Text::Write(CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagUtf8Text::Describe(std::string &sDescription, int nVerboseness)
{
  sDescription += "UTF8 Length = ";
  if (m_szText && *m_szText) {
    char buf[40];
    sprintf(buf, "%d bytes\n", m_nBufSize);
    sDescription += buf;
  }
  else
    sDescription += "0 (NULL)";
 
  if (nVerboseness > 25) {
    sDescription += "\"";
    if (m_szText && *m_szText) {
      if ((nVerboseness > 50) || (m_nBufSize < BRIEF_STRING_SIZE)) {
        // output entire string if short or doing verbose output
        sDescription += (icChar*)m_szText;  
      }
      else {
         // copy just first part of string to keep nVerboseness under control
         char buf[BRIEF_STRING_SIZE + 1];
         strncpy(buf, (icChar*)m_szText, BRIEF_STRING_SIZE);
         buf[BRIEF_STRING_SIZE] = '\0'; // ensure NULL termination
         sDescription += buf;
         sDescription += "\n... <!truncated!>";
      }
    }
    sDescription += "\"\n";
  }
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
void CIccTagUtf8Text::SetText(const icUChar *szText)
{
  if (!szText) 
    SetText("");
 
  icUInt32Number len=(icUInt32Number)strlen((icChar*)szText) + 1;
  icUChar *szBuf = GetBuffer(len);
 
  strcpy((icChar*)szBuf, (icChar*)szText);
  Release();
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
void CIccTagUtf8Text::SetText(const icUChar16 *szText)
{
  if (!szText) 
    SetText("");
 
  icUtf8Vector text;
  icUInt32Number len;
  for (len=0; szText[len]; len++);
 
  icConvertUTF16toUTF8(szText, &szText[len], text, lenientConversion);
 
  SetText((const icUChar*)&text[0]);
}
 
/**
 ****************************************************************************
 * 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.
 *****************************************************************************
 */
const icUChar *CIccTagUtf8Text::operator=(const icUChar *szText)
{
  SetText(szText);
  return (icUChar*)m_szText;
}
 
/**
 ******************************************************************************
 * 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
 *******************************************************************************
 */
icUChar *CIccTagUtf8Text::GetBuffer(icUInt32Number nSize)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf8Text::Release
 * 
 * Purpose: This will resize the buffer to fit the zero terminated string in
 *  the buffer.
 *****************************************************************************
 */
void CIccTagUtf8Text::Release()
{
  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;
  }
}
 
 
/**
******************************************************************************
* Name: CIccTagUtf8Text::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagUtf8Text::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
 
 
  return rv;
}
 
 
static unsigned char icFaultyXmlZipData[4] = { 0,0,0,1 };
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::CIccTagZipUtf8Text
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTagZipUtf8Text::CIccTagZipUtf8Text()
{
  m_pZipBuf = NULL;
  m_nBufSize = 0;
}
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::CIccTagZipUtf8Text
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITT = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagZipUtf8Text::CIccTagZipUtf8Text(const CIccTagZipUtf8Text &ITT)
{
  m_pZipBuf = NULL;
  m_nBufSize = 0;
  AllocBuffer(ITT.BufferSize());
  if (m_pZipBuf) {
    memcpy(m_pZipBuf, ITT.GetBuffer(), m_nBufSize);
  }
}
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  TextTag = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagZipUtf8Text &CIccTagZipUtf8Text::operator=(const CIccTagZipUtf8Text &ITT)
{
  if (&ITT == this)
    return *this;
 
  AllocBuffer(ITT.BufferSize());
  if (m_pZipBuf) {
    memcpy(m_pZipBuf, ITT.GetBuffer(), m_nBufSize);
  }
 
  return *this;
}
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::~CIccTagZipUtf8Text
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagZipUtf8Text::~CIccTagZipUtf8Text()
{
  if (m_pZipBuf)
    free(m_pZipBuf);
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagZipUtf8Text::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagZipUtf8Text::Write(CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagZipUtf8Text::Describe(std::string &sDescription, int nVerboseness)
{
  std::string str;
#ifdef ICC_USE_ZLIB
  if (!GetText(str)) {
    sDescription += "Error! - Unable to decompress text data.\n";
  }
  else if (m_nBufSize > 4 && !memcmp(m_pZipBuf, icFaultyXmlZipData, 4)) {
    sDescription += "Warning! - Correcting for improperly encoded ";
    sDescription += CIccTagCreator::GetTagTypeSigName(GetType());
    sDescription += " tag.\n\n";
  }
 
  sDescription += "ZLib Compressed String=\"";
  sDescription += str;
  sDescription += "\"\n";
#else
  char size[30];
  sprintf(size, "%d", m_nBufSize);
  sDescription += "BEGIN_COMPESSED_DATA[\"";
  sDescription += size;
  sDescription += "]\n";
  if (m_nBufSize) {
    icMemDump(str, m_pZipBuf, m_nBufSize);
    sDescription += str;
    sDescription += "\n";
  }
  sDescription += "END_COMPRESSED_DATA\n";
#endif
}
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::GetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  text - string to put uncompressed text into
 *****************************************************************************
 */
bool CIccTagZipUtf8Text::GetText(std::string &str) const
{
#ifndef ICC_USE_ZLIB
  str="";
  return false;
#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;
#endif
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
bool CIccTagZipUtf8Text::SetText(const icUChar *szText)
{
#ifndef ICC_USE_ZLIB
  return false;
#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((icUInt32Number)compress.size());
 
  if (pBuf) {
    for (i = 0; i < (int)m_nBufSize; i++) {
      pBuf[i] = compress[i];
}
  }
 
  return true;
#endif
}
 
/**
 ****************************************************************************
 * Name: CIccTagZipUtf8Text::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
bool CIccTagZipUtf8Text::SetText(const icUChar16 *szText)
{
  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]);
}
 
 
 
/**
 ******************************************************************************
 * 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
 *******************************************************************************
 */
icUChar *CIccTagZipUtf8Text::AllocBuffer(icUInt32Number nSize)
{
  if (m_nBufSize != nSize) {
    if (!nSize) {
      if (m_pZipBuf)
        free(m_pZipBuf);
 
      m_nBufSize = nSize;
      return NULL;
    }
 
    if (!m_nBufSize)
      m_pZipBuf = (icUChar*)malloc(nSize);
    else
      m_pZipBuf = (icUChar*)icRealloc(m_pZipBuf, nSize);
 
    m_nBufSize = nSize;
 
  }
 
  return m_pZipBuf;
}
 
 
/**
******************************************************************************
* Name: CIccTagZipUtf8Text::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagZipUtf8Text::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
  else {
#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).\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.\n";
      rv = icMaxStatus(rv, icValidateNonCompliant);
    }
#else
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " - Zip compression not supported by CMM - unable to validate text compression.\n";
    rv = icMaxStatus(rv, icValidateWarning);
#endif
  }
  
  return rv;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::CIccTagUtf16Text
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTagUtf16Text::CIccTagUtf16Text()
{
  m_szText = (icUChar16*)malloc(1*sizeof(icUChar16));
  m_szText[0] = 0;
  m_nBufSize = 1;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::CIccTagUtf16Text
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITT = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagUtf16Text::CIccTagUtf16Text(const CIccTagUtf16Text &ITT)
{
  m_szText = (icUChar16*)malloc(1*sizeof(icUChar16));
  m_szText[0] = 0;
  m_nBufSize = 1;
  SetText(ITT.m_szText);
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  TextTag = The CIccTagText object to be copied
 *****************************************************************************
 */
CIccTagUtf16Text &CIccTagUtf16Text::operator=(const CIccTagUtf16Text &TextTag)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::~CIccTagUtf16Text
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagUtf16Text::~CIccTagUtf16Text()
{
  free(m_szText);
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::GetLength
 * 
 * Purpose: Get length of utf16 string
 * 
 *****************************************************************************
 */
icUInt32Number CIccTagUtf16Text::GetLength() const
{
  icUInt32Number n;
  if (!m_szText || !m_nBufSize)
    return 0;
 
  for (n=0; n<m_nBufSize && m_szText[n]; n++);
 
  return n;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagUtf16Text::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagUtf16Text::Write(CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagUtf16Text::Describe(std::string &sDescription, int nVerboseness)
{
    sDescription += "UTF16 Length = ";
    if (m_szText && *m_szText) {
        char buf[40];
        sprintf(buf, "%d bytes\n", m_nBufSize);
        sDescription += buf;
    }
    else
        sDescription += "0 (NULL)";
 
    if (nVerboseness > 25) {
        sDescription += "\"";
        if (m_szText && *m_szText) {
            std::string   s;
            if ((nVerboseness > 50) || (m_nBufSize < BRIEF_STRING_SIZE)) {
                // output entire string if short or doing verbose
                sDescription += GetText(s);
            }
            else {
                // copy just first part of string to keep nVerboseness under control
                char buf[BRIEF_STRING_SIZE + 1];
                strncpy(buf, GetText(s), BRIEF_STRING_SIZE);
                buf[BRIEF_STRING_SIZE] = '\0'; // ensure NULL termination
                sDescription += buf;
                sDescription += "\n... <!truncated!>";
            }
        }
        sDescription += "\"\n";
    }
 
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::GetText
 * 
 * Purpose: Allows text data associated with the tag to be fetched.
 * 
 * Args: 
 *  buf - buffer to put tag data into. 
 * Returns: buf.c_str() 
 *****************************************************************************
 */
const icChar *CIccTagUtf16Text::GetText(std::string &buf) const
{
  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();
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
void CIccTagUtf16Text::SetText(const icUChar16 *szText)
{
  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();
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
void CIccTagUtf16Text::SetText(const icUChar *szText)
{
  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();
}
 
/**
 ****************************************************************************
 * 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.
 *****************************************************************************
 */
const icUChar16 *CIccTagUtf16Text::operator=(const icUChar16 *szText)
{
  SetText(szText);
  return (icUChar16*)m_szText;
}
 
/**
 ******************************************************************************
 * 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
 *******************************************************************************
 */
icUChar16 *CIccTagUtf16Text::GetBuffer(icUInt32Number nSize)
{
  if (m_nBufSize < nSize) {
    m_szText = (icUChar16*)icRealloc(m_szText, (nSize+1)*sizeof(icUChar16));
 
    m_szText[nSize] = 0;
 
    m_nBufSize = nSize;
  }
 
  return m_szText;
}
 
/**
 ****************************************************************************
 * Name: CIccTagUtf16Text::Release
 * 
 * Purpose: This will resize the buffer to fit the zero terminated string in
 *  the buffer.
 *****************************************************************************
 */
void CIccTagUtf16Text::Release()
{
  icUInt32Number nSize = GetLength()+1;
 
  if (nSize < m_nBufSize-1) {
    m_szText=(icUChar16*)icRealloc(m_szText, (nSize+1)*sizeof(icUChar16));
    m_nBufSize = nSize+1;
  }
}
 
 
/**
******************************************************************************
* Name: CIccTagUtf16Text::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagUtf16Text::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
 
  return rv;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::CIccTagTextDescription
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTagTextDescription::CIccTagTextDescription()
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::CIccTagTextDescription
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITTD = The CIccTagTextDescription object to be copied
 *****************************************************************************
 */
CIccTagTextDescription::CIccTagTextDescription(const CIccTagTextDescription &ITTD)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  TextDescTag = The CIccTagTextDescription object to be copied
 *****************************************************************************
 */
CIccTagTextDescription &CIccTagTextDescription::operator=(const CIccTagTextDescription& TextDescTag)
{
  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;  
}
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::~CIccTagTextDescription
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagTextDescription::~CIccTagTextDescription()
{
  free(m_szText);
  free(m_uzUnicodeText);
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagTextDescription::Read(icUInt32Number size, CIccIO *pIO)
{
  icTagTypeSignature sig;
  icUInt32Number nEnd;
 
  m_szText[0] = '\0';
  nEnd = pIO->Tell() + size;
 
  if (size<3*sizeof(icUInt32Number) || !pIO)
    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;
 
  // Calculations in GetUnicodeBuffer() can cause wrap-around error
  if (nSize == 0xFFFFFFFF) 
    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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
bool CIccTagTextDescription::Write(CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagTextDescription::Describe(std::string &sDescription, int nVerboseness)
{
  sDescription += "TextDescription Length = ";
  if (m_szText && *m_szText) {
    char buf[40];
    sprintf(buf, "%zu bytes\n", strlen(m_szText));
    sDescription += buf;
  }
  else
    sDescription += "0 (NULL)";
 
  if (nVerboseness > 25) {
    sDescription += "\"";
    if (m_szText && *m_szText) {
      if ((nVerboseness > 50) || (strlen(m_szText) < BRIEF_STRING_SIZE)) {
        // output entire string if short or doing verbose
         sDescription += m_szText;  
      }
      else {
        // copy just first part of string to keep nVerboseness under control
        char buf[BRIEF_STRING_SIZE+1];
        strncpy(buf, m_szText, BRIEF_STRING_SIZE);
        buf[BRIEF_STRING_SIZE] = '\0'; // ensure NULL termination
        sDescription += buf;
        sDescription += "\n... <!truncated!>";
      } 
    }
    sDescription += "\"\n";
  }
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::SetText
 * 
 * Purpose: Allows text data associated with the tag to be set.
 * 
 * Args: 
 *  szText - zero terminated string to put in tag
 *****************************************************************************
 */
void CIccTagTextDescription::SetText(const icChar *szText)
{
  m_bInvalidScript = false;
 
  if (!szText) 
    SetText("");
 
  icUInt32Number len=(icUInt32Number)strlen(szText) + 1;
  icChar *szBuf = GetBuffer(len);
 
  strcpy(szBuf, szText);
  Release();
}
 
/**
 ****************************************************************************
 * 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.
 *****************************************************************************
 */
const icChar *CIccTagTextDescription::operator=(const icChar *szText)
{
  SetText(szText);
  return m_szText;
}
 
/**
 ****************************************************************************
 * 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: 
 *****************************************************************************
 */
icChar *CIccTagTextDescription::GetBuffer(icUInt32Number nSize)
{
  if (m_nASCIISize < nSize) {
    m_szText = (icChar*)icRealloc(m_szText, nSize+1);
 
    m_szText[nSize] = '\0';
 
    m_nASCIISize = nSize;
  }
 
  return m_szText;
}
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::Release
 * 
 * Purpose: This will resize the buffer to fit the zero terminated string in
 *  the buffer.
 *****************************************************************************
 */
void CIccTagTextDescription::Release()
{
  icUInt32Number nSize = (icUInt32Number)strlen(m_szText);
 
  if (nSize < m_nASCIISize-1) {
    m_szText=(icChar*)icRealloc(m_szText, nSize+1);
    m_nASCIISize = nSize+1;
  }
}
 
/**
 ****************************************************************************
 * 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: 
 *****************************************************************************
 */
icUInt16Number *CIccTagTextDescription::GetUnicodeBuffer(icUInt32Number nSize)
{
  if (m_nUnicodeSize < nSize) {
    m_uzUnicodeText = (icUInt16Number*)icRealloc(m_uzUnicodeText, (nSize+1)*sizeof(icUInt16Number));
 
    m_uzUnicodeText[nSize] = 0;
 
    m_nUnicodeSize = nSize;
  }
 
  return m_uzUnicodeText;
}
 
/**
 ****************************************************************************
 * Name: CIccTagTextDescription::ReleaseUnicode
 * 
 * Purpose: This will resize the buffer to fit the zero terminated string in
 *  the buffer.
 *****************************************************************************
 */
void CIccTagTextDescription::ReleaseUnicode()
{
  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;
  }
}
 
 
/**
******************************************************************************
* Name: CIccTagTextDescription::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagTextDescription::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\n";
 
    rv =icMaxStatus(rv, icValidateNonCompliant);
  }
 
  if (m_bInvalidScript) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - ScriptCode must contain 67 bytes.\n";
 
    rv =icMaxStatus(rv, icValidateNonCompliant);
  }
 
  return rv;
}
 
/**
 ****************************************************************************
 * Name: CIccTagSignature::CIccTagSignature
 * 
 * Purpose: Constructor
 * 
 *****************************************************************************
 */
CIccTagSignature::CIccTagSignature()
{
  m_nSig = 0x3f3f3f3f; //'????';
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagSignature::CIccTagSignature
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITS = The CIccTagSignature object to be copied
 *****************************************************************************
 */
CIccTagSignature::CIccTagSignature(const CIccTagSignature &ITS)
{
  m_nSig = ITS.m_nSig;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagSignature::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  SignatureTag = The CIccTagSignature object to be copied
 *****************************************************************************
 */
CIccTagSignature &CIccTagSignature::operator=(const CIccTagSignature &SignatureTag)
{
  if (&SignatureTag == this)
    return *this;
 
  m_nSig = SignatureTag.m_nSig;
 
  return *this;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagSignature::~CIccTagSignature
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagSignature::~CIccTagSignature()
{
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagSignature::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagSignature::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
bool CIccTagSignature::Write(CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagSignature::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagSignature::Describe(std::string &sDescription, int nVerboseness)
{
  CIccInfo Fmt;
 
  sDescription += Fmt.GetSigName(m_nSig);
  sDescription += "\n";
}
 
 
/**
******************************************************************************
* Name: CIccTagSignature::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagSignature::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\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.\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.\n", Info.GetSigName(m_nSig));
        sReport += buf;
        rv = icMaxStatus(rv, icValidateNonCompliant);
      }
    }
  }
 
 
  return rv;
}
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::CIccTagNamedColor2
 * 
 * Purpose: Constructor
 * 
 * Args:
 *  nSize = number of named color entries,
 *  nDeviceCoords = number of device channels
 *****************************************************************************
 */
CIccTagNamedColor2::CIccTagNamedColor2(int nSize/*=1*/, int nDeviceCoords/*=0*/)
{
  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;
  m_csDevice = icSigUnknownData;
 
  m_nColorEntrySize = 32/*rootName*/ + (3/*PCS*/ + 1/*iAny*/ + nDeviceCoords)*sizeof(icFloatNumber);
 
  m_NamedColor = (SIccNamedColorEntry*)calloc(nSize, m_nColorEntrySize);
 
  m_NamedLab = NULL;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::CIccTagNamedColor2
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITNC = The CIccTagNamedColor2 object to be copied
 *****************************************************************************
 */
CIccTagNamedColor2::CIccTagNamedColor2(const CIccTagNamedColor2 &ITNC)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  NamedColor2Tag = The CIccTagNamedColor2 object to be copied
 *****************************************************************************
 */
CIccTagNamedColor2 &CIccTagNamedColor2::operator=(const CIccTagNamedColor2 &NamedColor2Tag)
{
  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;
 
  return *this;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::~CIccTagNamedColor2
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagNamedColor2::~CIccTagNamedColor2()
{
  if (m_NamedColor)
    free(m_NamedColor);
 
  if (m_NamedLab)
    delete [] m_NamedLab;
}
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::SetSize
 * 
 * Purpose: Sets the size of the named color array.
 * 
 * Args: 
 *  nSize - number of named color entries,
 *  nDeviceCoords - number of device channels
 *****************************************************************************
 */
bool CIccTagNamedColor2::SetSize(icUInt32Number nSize, icInt32Number nDeviceCoords/*=-1*/)
{
  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 = __min(nSize, m_nSize);
  icUInt32Number j, nCoords = __min(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;
}
 
 
/**
****************************************************************************
* Name: CIccTagNamedColor2::SetPrefix
* 
* Purpose: Set contents of suffix member field
* 
* Args:
*  szPrefix - string to set prefix to
*****************************************************************************
*/
void CIccTagNamedColor2::SetPrefix(const icChar *szPrefix)
{
  strncpy(m_szPrefix, szPrefix, sizeof(m_szPrefix));
  m_szPrefix[sizeof(m_szPrefix)-1]='\0';
}
 
 
/**
****************************************************************************
* Name: CIccTagNamedColor2::SetSufix
* 
* Purpose: Set contents of suffix member field
* 
* Args:
*  szPrefix - string to set prefix to
*****************************************************************************
*/
void CIccTagNamedColor2::SetSufix(const icChar *szSufix)
{
  strncpy(m_szSufix, szSufix, sizeof(m_szSufix));
  m_szSufix[sizeof(m_szSufix)-1]='\0';
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagNamedColor2::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
bool CIccTagNamedColor2::Write(CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagNamedColor2::Describe(std::string &sDescription, int nVerboseness)
{
  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\n", m_nVendorFlags, m_nSize, m_nDeviceCoords);
  sDescription += buf;
 
  sprintf(buf, "Prefix=\"%s\"\n", m_szPrefix);
  sDescription += buf;
 
  sprintf(buf, "Sufix= \"%s\"\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] ={0};
    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 += "\n";
 
    pNamedColor = (SIccNamedColorEntry*)((icChar*)pNamedColor + m_nColorEntrySize);
  }
}
 
/**
 ****************************************************************************
 * 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
 * 
 *****************************************************************************
 */
void CIccTagNamedColor2::SetColorSpaces(icColorSpaceSignature csPCS, icColorSpaceSignature csDevice)
{
   m_csPCS = csPCS;
   m_csDevice = csDevice;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
icInt32Number CIccTagNamedColor2::FindRootColor(const icChar *szRootColor) const
{
  for (icUInt32Number i=0; i<m_nSize; i++) {
    if (stricmp(m_NamedColor[i].rootName,szRootColor) == 0)
      return i;
  }
 
  return -1;
}
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::ResetPCSCache
 * 
 * Purpose: This function is called if entry values change between calls
 *  to FindPCSColor()
 * 
 *****************************************************************************
 */
void CIccTagNamedColor2::ResetPCSCache()
{
  if (m_NamedLab) {
    delete [] m_NamedLab;
    m_NamedLab = NULL;
  }
}
 
/**
****************************************************************************
* Name: CIccTagNamedColor2::InitFindPCSColor
* 
* Purpose: Initialization needed for using FindPCSColor
* 
* Return: 
*  true if successfull, false if failure
*****************************************************************************
*/
bool CIccTagNamedColor2::InitFindCachedPCSColor()
{
  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;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
icInt32Number CIccTagNamedColor2::FindCachedPCSColor(icFloatNumber *pPCS, icFloatNumber dMinDE/*=1000.0*/) const
{
  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;
}
 
/**
****************************************************************************
* 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
*****************************************************************************
*/
icInt32Number CIccTagNamedColor2::FindPCSColor(icFloatNumber *pPCS, icFloatNumber dMinDE/*=1000.0*/)
{
  if (!m_NamedLab)
    InitFindCachedPCSColor();
 
  return FindCachedPCSColor(pPCS, dMinDE);
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
icInt32Number CIccTagNamedColor2::FindColor(const icChar *szColor) const
{
  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;
}
 
/**
 ****************************************************************************
 * 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.
 *****************************************************************************
 */
icInt32Number CIccTagNamedColor2::FindDeviceColor(icFloatNumber *pDevColor) const
{
  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;
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagNamedColor2::GetColorName(std::string &sColorName, icInt32Number index) const
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::UnitClip
 * 
 * Purpose: Clip number so that its between 0-1
 * 
 * Args: 
 *  v = number to be clipped
 * 
 * Return: Clipped number
 *  
 *****************************************************************************
 */
icFloatNumber CIccTagNamedColor2::UnitClip(icFloatNumber v) const
{
  if (v<0)
    v = 0;
  if (v>1.0)
    v = 1.0;
 
  return v;
}
 
/**
 ****************************************************************************
 * Name: CIccTagNamedColor2::NegClip
 * 
 * Purpose: Negative numbers are clipped to zero
 * 
 * Args: 
 *  v = number to be clipped
 * 
 * Return: Clipped number
 *  
 *****************************************************************************
 */
icFloatNumber CIccTagNamedColor2::NegClip(icFloatNumber v) const
{
  if (v<0)
    v=0;
  
  return v;
}
 
 
/**
 ****************************************************************************
 * 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
 * 
 *****************************************************************************
 */
void CIccTagNamedColor2::Lab2ToLab4(icFloatNumber *Dst, const icFloatNumber *Src) const
{
  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));
}
 
/**
 ****************************************************************************
 * 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
 * 
 *****************************************************************************
 */
void CIccTagNamedColor2::Lab4ToLab2(icFloatNumber *Dst, const icFloatNumber *Src) const
{
  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);
}
 
 
/**
******************************************************************************
* Name: CIccTagNamedColor2::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagNamedColor2::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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!\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.\n";
        rv = icMaxStatus(rv, icValidateNonCompliant);
      }
    }
    else {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " - Tag validation incomplete: Pointer to profile unavailable.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
  }
 
 
  return rv;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagXYZ::CIccTagXYZ
 * 
 * Purpose: Constructor
 *
 * Args:
 *  nSize = number of XYZ entries
 * 
 *****************************************************************************
 */
CIccTagXYZ::CIccTagXYZ(int nSize/*=1*/)
{
  m_nSize = nSize;
  if (m_nSize <1)
    m_nSize = 1;
  m_XYZ = (icXYZNumber*)calloc(nSize, sizeof(icXYZNumber));
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagXYZ::CIccTagXYZ
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITXYZ = The CIccTagXYZ object to be copied
 *****************************************************************************
 */
CIccTagXYZ::CIccTagXYZ(const CIccTagXYZ &ITXYZ)
{
  m_nSize = ITXYZ.m_nSize;
 
  m_XYZ = (icXYZNumber*)calloc(m_nSize, sizeof(icXYZNumber));
  memcpy(m_XYZ, ITXYZ.m_XYZ, sizeof(icXYZNumber)*m_nSize);
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagXYZ::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  XYZTag = The CIccTagXYZ object to be copied
 *****************************************************************************
 */
CIccTagXYZ &CIccTagXYZ::operator=(const CIccTagXYZ &XYZTag)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagXYZ::~CIccTagXYZ
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagXYZ::~CIccTagXYZ()
{
  if (m_XYZ)
    free(m_XYZ);
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagXYZ::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagXYZ::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
bool CIccTagXYZ::Write(CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagXYZ::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagXYZ::Describe(std::string &sDescription, int nVerboseness)
{
  icChar buf[128];
 
  if (m_nSize == 1 ) {
    sprintf(buf, "X=%.4lf, Y=%.4lf, Z=%.4lf\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\n", i, icFtoD(m_XYZ[i].X), icFtoD(m_XYZ[i].Y), icFtoD(m_XYZ[i].Z));
      sDescription += buf;
    }
  }
}
 
/**
 ****************************************************************************
 * Name: CIccTagXYZ::SetSize
 * 
 * Purpose: Sets the size of the XYZ array.
 * 
 * Args: 
 *  nSize - number of XYZ entries,
 *  bZeroNew - flag to zero newly formed values
 *****************************************************************************
 */
bool CIccTagXYZ::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
{
  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;
}
 
 
/**
******************************************************************************
* Name: CIccTagXYZ::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagXYZ::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagChromaticity::CIccTagChromaticity
 * 
 * Purpose: Constructor
 *
 * Args:
 *  nSize = number of xy entries
 * 
 *****************************************************************************
 */
CIccTagChromaticity::CIccTagChromaticity(int nSize/*=3*/)
{
  m_nChannels = nSize;
  if (m_nChannels <3)
    m_nChannels = 3;
  m_xy = (icChromaticityNumber*)calloc(nSize, sizeof(icChromaticityNumber));
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagChromaticity::CIccTagChromaticity
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITCh = The CIccTagChromaticity object to be copied
 *****************************************************************************
 */
CIccTagChromaticity::CIccTagChromaticity(const CIccTagChromaticity &ITCh)
{
  m_nChannels = ITCh.m_nChannels;
 
  m_xy = (icChromaticityNumber*)calloc(m_nChannels, sizeof(icChromaticityNumber));
  memcpy(m_xy, ITCh.m_xy, sizeof(icChromaticityNumber)*m_nChannels);
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagChromaticity::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  ChromTag = The CIccTagChromaticity object to be copied
 *****************************************************************************
 */
CIccTagChromaticity &CIccTagChromaticity::operator=(const CIccTagChromaticity &ChromTag)
{
  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;  
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagChromaticity::~CIccTagChromaticity
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagChromaticity::~CIccTagChromaticity()
{
  if (m_xy)
    free(m_xy);
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagChromaticity::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
 
  // SetSize casts from icUInt32Number down to icUInt16Number. Check for overflow
  if (nNum > (icUInt16Number)nNum)
    return false;
 
  if (!SetSize((icUInt16Number)nNum))
    return false;
 
  if (pIO->Read32(&m_xy[0], nNum32) != (icInt32Number)nNum32 )
    return false;
 
  return true;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagChromaticity::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
bool CIccTagChromaticity::Write(CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagChromaticity::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagChromaticity::Describe(std::string &sDescription, int nVerboseness)
{
  icChar buf[128];
  CIccInfo Fmt;
 
  icUInt32Number i;
  //sDescription.reserve(sDescription.size() + m_nChannels*79);
  sprintf(buf, "Number of Channels : %u\n", m_nChannels);
  sDescription += buf;
 
  sprintf(buf, "Colorant Encoding : %s\n", Fmt.GetColorantEncoding((icColorantEncoding)m_nColorantType));
  sDescription += buf;
 
  for (i=0; i<m_nChannels; i++) {
    sprintf(buf, "value[%u]: x=%.3lf, y=%.3lf\n", i, icUFtoD(m_xy[i].x), icUFtoD(m_xy[i].y));
    sDescription += buf;
  }
 
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagChromaticity::SetSize(icUInt16Number nSize, bool bZeroNew/*=true*/)
{
  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;
}
 
 
/**
******************************************************************************
* Name: CIccTagChromaticity::Validate
* 
* Purpose: Check tag data validity.
* 
* Args: 
*  sig = signature of tag being validated,
*  sReport = String to add report information to
* 
* Return: 
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagChromaticity::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\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.\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.\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.\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.\n";
              rv = icMaxStatus(rv, icValidateNonCompliant);
            }
            break;
        }
 
      default:
        {
          sReport += icMsgValidateNonCompliant;
          sReport += sSigPathName;
          sReport += " - Invalid colorant type encoding.\n";
          rv = icMaxStatus(rv, icValidateNonCompliant);
        }
    }
  }
 
  return rv;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::CIccTagCicp
 *
 * Purpose: Constructor
 *
 * Args:
 *  nSize = number of XYZ entries
 *
 *****************************************************************************
 */
CIccTagCicp::CIccTagCicp()
{
  m_nColorPrimaries = 0;
  m_nTransferCharacteristics = 0;
  m_nMatrixCoefficients = 0;
  m_nVideoFullRangeFlag = 0;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::CIccTagCicp
 *
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITCICP = The CIccTagCicp object to be copied
 *****************************************************************************
 */
CIccTagCicp::CIccTagCicp(const CIccTagCicp& ITXYZ)
{
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::operator=
 *
 * Purpose: Copy Operator
 *
 * Args:
 *  cicpTag = The CIccTagCicp object to be copied
 *****************************************************************************
 */
CIccTagCicp& CIccTagCicp::operator=(const CIccTagCicp& cicpTag)
{
  if (&cicpTag == this)
    return *this;
 
  m_nColorPrimaries = cicpTag.m_nColorPrimaries;
  m_nTransferCharacteristics = cicpTag.m_nTransferCharacteristics;
  m_nMatrixCoefficients = cicpTag.m_nMatrixCoefficients;
  m_nVideoFullRangeFlag = cicpTag.m_nVideoFullRangeFlag;
 
  return *this;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::~CIccTagCicp
 *
 * Purpose: Destructor
 *
 *****************************************************************************
 */
CIccTagCicp::~CIccTagCicp()
{
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::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
 *****************************************************************************
 */
bool CIccTagCicp::Read(icUInt32Number size, CIccIO* pIO)
{
  icTagTypeSignature sig;
 
  if (sizeof(icTagTypeSignature) +
    sizeof(icUInt32Number) +
    sizeof(icUInt8Number)*4 > size)
    return false;
 
  if (!pIO) {
    return false;
  }
 
  if (!pIO->Read32(&sig))
    return false;
 
  if (!pIO->Read32(&m_nReserved))
    return false;
 
  if (!pIO->Read8(&m_nColorPrimaries) ||
      !pIO->Read8(&m_nTransferCharacteristics) ||
      !pIO->Read8(&m_nMatrixCoefficients) ||
      !pIO->Read8(&m_nVideoFullRangeFlag))
    return false;
 
  return true;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::Write
 *
 * Purpose: Write the tag to a file
 *
 * Args:
 *  pIO - The IO object to write tag to.
 *
 * Return:
 *  true = succesful, false = failure
 *****************************************************************************
 */
bool CIccTagCicp::Write(CIccIO* pIO)
{
  icTagTypeSignature sig = GetType();
 
  if (!pIO)
    return false;
 
  if (!pIO->Write32(&sig))
    return false;
 
  if (!pIO->Write32(&m_nReserved))
    return false;
 
  if (!pIO->Write8(&m_nColorPrimaries) ||
      !pIO->Write8(&m_nTransferCharacteristics) ||
      !pIO->Write8(&m_nMatrixCoefficients) ||
      !pIO->Write8(&m_nVideoFullRangeFlag))
    return false;
 
  return true;
}
 
 
static struct {
  const char* code;
  const char* interp;
} icExampleCicpCodes[] = {
  { "1-1-0-0",    "RGB narrow range representation specified in Recommendation ITU-R BT.709-6, Item 3.4"},
  { "1-13-0-1",   "RGB full range representation specified in IEC 61966-2-1 sRGB"},
  { "9-14-0-0",   "R’G’B’ narrow range representation specified in Recommendation ITU-R BT.2020-2, Table 5"},
  { "9-16-0-0",   "PQ R’G’B’ narrow range representation specified in Recommendation ITU-R BT.2100-2, Table 9"},
  { "9-16-0-1",   "PQ R’G’B’ full range representation specified in Recommendation ITU-R BT.2100-2, Table 9"},
  { "9-18-0-0 ",  "HLG R’G’B’ narrow range representation specified in Recommendation ITU-R BT.2100-2 "},
  { "9-18-0-1",   "HLG R’G’B’ full range representation specified in Recommendation ITU-R BT.2100-2"},
  { "1-1-1-0 ",   "YCbCr representation specified in Recommendation ITU-R BT.709-6, Item 3.4"},
  { "9-14-9-0",   "Y’Cb’Cr’ narrow range representation specified in Recommendation ITU-R BT.2020-2, Table 5"},
  { "9-16-9-0",   "PQ Y’Cb’Cr’ narrow range representation specified in Recommendation ITU-R BT.2100-2, Table 9"},
  { "9-16-14-0",  "PQ ICtCp narrow range representation specified in Recommendation ITU-R BT.2100-2, Table 9"},
  { "9-18-9-0",   "HLG Y’Cb’Cr’ narrow range representation specified in Recommendation ITU-R BT.2100-2"},
  { "9-18-14-0 ", "HLG ICtCp narrow range representation specified in Recommendation ITU-R BT.2100-2"},
  { NULL, NULL},
};
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::Describe
 *
 * Purpose: Dump data associated with the tag to a string
 *
 * Args:
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagCicp::Describe(std::string& sDescription, int nVerboseness)
{
  icChar buf[256], code[128];
  sprintf(code, "%u-%u-%u-%u", m_nColorPrimaries, m_nTransferCharacteristics, m_nMatrixCoefficients, m_nVideoFullRangeFlag);
 
  sprintf(buf, "ColorPrimaries=%u\r\n", m_nColorPrimaries);
  sDescription += buf;
 
  sprintf(buf, "TransferCharacteristics=%u\r\n", m_nTransferCharacteristics);
  sDescription += buf;
 
  sprintf(buf, "MatrixCoefficients=%u\r\n", m_nMatrixCoefficients);
  sDescription += buf;
 
  sprintf(buf, "VideoFullRangeFlag=%u\r\n\r\n", m_nVideoFullRangeFlag);
  sDescription += buf;
 
  sprintf(buf, "Combined Code: %s\r\n", code);
  sDescription += buf;
 
  int i;
  for (i = 0; icExampleCicpCodes[i].code; i++)
    if (!strcmp(code, icExampleCicpCodes[i].code))
      break;
 
  sDescription += "Interpretation: ";
  if (icExampleCicpCodes[i].code) {
    sDescription += icExampleCicpCodes[i].interp;
  }
  else {
    sDescription += "unknown";
  }
  sDescription += "\r\n";
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::GetFields
 *
 * Purpose: gets the ITU-T H.273 field values
 *
 * Args:
 *  meaning of args as named
 *****************************************************************************
 */
void CIccTagCicp::GetFields(icUInt8Number &colorPrimaries,
                            icUInt8Number &transferCharacteristics,
                            icUInt8Number &matrixCoefficients,
                            icUInt8Number &videoFullRangeFlag)
{
  colorPrimaries = m_nColorPrimaries;
  transferCharacteristics = m_nTransferCharacteristics;
  matrixCoefficients = m_nMatrixCoefficients;
  videoFullRangeFlag = m_nVideoFullRangeFlag;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagCicp::SetFields
 *
 * Purpose: Sets the ITU-T H.273 field values
 *
 * Args:
 *  meaning of args as named
 *****************************************************************************
 */
void CIccTagCicp::SetFields(icUInt8Number colorPrimaries, 
                            icUInt8Number transferCharacteristics,
                            icUInt8Number matrixCoefficients,
                            icUInt8Number videoFullRangeFlag)
{
  m_nColorPrimaries = colorPrimaries;
  m_nTransferCharacteristics = transferCharacteristics;
  m_nMatrixCoefficients =matrixCoefficients;
  m_nVideoFullRangeFlag = videoFullRangeFlag;
}
 
 
/**
******************************************************************************
* Name: CIccTagCicp::Validate
*
* Purpose: Check tag data validity.
*
* Args:
*  sig = signature of tag being validated,
*  sReport = String to add report information to
*  pProfile = profile containing tag
*
* Return:
*  icValidateStatusOK if valid, or other error status.
******************************************************************************
*/
icValidateStatus CIccTagCicp::Validate(std::string sigPath, std::string& sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);
 
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);
 
  if (!pProfile)
    return rv;
 
  if ((pProfile->m_Header.colorSpace == icSigRgbData || pProfile->m_Header.colorSpace == icSigXYZData) && m_nMatrixCoefficients) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - CICP MatrixCoefficients not zero for RGB or XYZ colour space data.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
 
  if (pProfile->m_Header.colorSpace == icSigYCbCrData && !m_nMatrixCoefficients) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - CICP MatrixCoefficients zero for YCbCr colour space data.\r\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
 
  return rv;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagSparseMatrixArray::CIccTagSparseMatrixArray
 * 
 * Purpose: CIccTagSparseMatrixArray Constructor
 * 
 * Args:
 *  nSize = number of data entries
 * 
 *****************************************************************************
 */
CIccTagSparseMatrixArray::CIccTagSparseMatrixArray(int nNumMatrices/* =1 */, int nChannelsPerMatrix/* =4 */)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagSparseMatrixArray::CIccTagSparseMatrixArray
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITFN = The CIccTagFixedNum object to be copied
 *****************************************************************************
 */
CIccTagSparseMatrixArray::CIccTagSparseMatrixArray(const CIccTagSparseMatrixArray &ITSMA)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagSparseMatrixArray::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  ITFN = The CIccTagSparseMatrixArray object to be copied
 *****************************************************************************
 */
CIccTagSparseMatrixArray &CIccTagSparseMatrixArray::operator=(const CIccTagSparseMatrixArray &ITSMA)
{
  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;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagSparseMatrixArray::~CIccTagSparseMatrixArray
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
CIccTagSparseMatrixArray::~CIccTagSparseMatrixArray()
{
  if (m_RawData)
    free(m_RawData);
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagSparseMatrixArray::Read(icUInt32Number size, CIccIO *pIO)
{
  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, 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] = { 0 };
        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] = { 0 };
        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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagSparseMatrixArray::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
bool CIccTagSparseMatrixArray::Write(CIccIO *pIO)
{
  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, 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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagSparseMatrixArray::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
void CIccTagSparseMatrixArray::Describe(std::string &sDescription, int nVerboseness)
{
  icChar buf[128];
 
  sDescription += "Begin_SparseMatrix_Array\n";
  sprintf(buf, "OutputChannels = %d\n", m_nChannelsPerMatrix);
  sDescription += buf;
  sprintf(buf, "MatrixType = %d\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, true);
 
    sprintf(buf, "\nBegin_Matrix_%d\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\n", i);
    sDescription += buf;
  }
  sDescription += "\nEnd_SparseMatrix_Array\n";
 
}
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
icValidateStatus CIccTagSparseMatrixArray::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile/*=NULL*/) const
{
  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.\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)) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " - SparseMatrix data incompatible with spectral PCS.\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.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
  }
 
  if (m_bNonZeroPadding) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Non zero padding in matrices used.\n";
    rv = icMaxStatus(rv, icValidateNonCompliant);
  }
 
  if (!m_nSize) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " - No Matrices Defined.\n";
    rv = icMaxStatus(rv, icValidateWarning);
    return rv;
  }
 
  if (!m_RawData) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - Data dont defined for matrices\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, 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, true);
    if (mtx.Rows() != nRows || mtx.Cols() != nCols) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sprintf(buf, " - Matrix[%d] doesn't have matching rows and columns.\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.\n", i);
        sReport += buf;
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
 
    if (!mtx.IsValid()) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sprintf(buf, " - Matrix[%d] has an invalid matrix structure.\n", i);
        sReport += buf;
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
 
    if (i<(int)(m_nSize-1)) {
      CIccSparseMatrix umtx(temp, nBytesPerMatrix, icSparseMatrixFloatNum, false);
      CIccSparseMatrix mtx2(m_RawData+(i+1)*nBytesPerMatrix, nBytesPerMatrix, icSparseMatrixFloatNum, 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.\n", i);
        sReport += buf;
        rv = icMaxStatus(rv, icValidateCriticalError);
      }
    }
  }
  delete [] temp;
 
  return rv;
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
bool CIccTagSparseMatrixArray::Reset(icUInt32Number nNumMatrices, icUInt16Number nChannelsPerMatrix)
{
  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;
}
 
 
/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::GetValues
* 
* Purpose: Gets values from the num array tag as floating point numbers
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
bool CIccTagSparseMatrixArray::GetSparseMatrix(CIccSparseMatrix &mtx, int nIndex, bool bInitFromData/*=true*/)
{
  if (nIndex<0 || nIndex>(int)m_nSize) {
    mtx.Reset(NULL, 0, icSparseMatrixFloatNum, false);
    return false;
  }
 
  icUInt32Number nBytesPerMatrix = GetBytesPerMatrix();
 
  mtx.Reset(m_RawData+nIndex*GetBytesPerMatrix(), nBytesPerMatrix, icSparseMatrixFloatNum, bInitFromData);
 
  return true;
}
 
bool CIccTagSparseMatrixArray::GetValues(icFloatNumber *DstVector, icUInt32Number nStart/*=0*/, icUInt32Number nVectorSize/*=1*/) const
{
  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;
}
 
 
/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::Interpolate
* 
* Purpose: Gets values from the num array tag as floating point numbers
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
bool CIccTagSparseMatrixArray::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                           icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
{
  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, true);
  CIccSparseMatrix mhi(hi, nVectorSize, icSparseMatrixFloatNum, true);
  CIccSparseMatrix dst((icUInt8Number*)DstVector, nVectorSize, icSparseMatrixFloatNum, 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;
}
 
 
/**
****************************************************************************
* Name: CIccTagSparseMatrixArray::ValuePos
* 
* Purpose: Gets position of a value int the num array tag
* 
* Args: 
*  DstPos - position of val in array
*  val - value to look for in array.
*  bNoZero - flag indicating whether first entry is zero
*****************************************************************************
*/
bool CIccTagSparseMatrixArray::ValuePos(icFloatNumber &DstPos, icFloatNumber val, bool &bNoZero) const
{
  //ValuePos not supported for Sparse Matrices
  return false;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::CIccTagFixedNum
 * 
 * Purpose: CIccTagFixedNumConstructor
 * 
 * Args:
 *  nSize = number of data entries
 * 
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagFixedNum<T, Tsig>::CIccTagFixedNum(int nSize/*=1*/)
{
  m_nSize = nSize;
  if (m_nSize <1)
    m_nSize = 1;
  m_Num = (T*)calloc(nSize, sizeof(T));
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::CIccTagFixedNum
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITFN = The CIccTagFixedNum object to be copied
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagFixedNum<T, Tsig>::CIccTagFixedNum(const CIccTagFixedNum<T, Tsig> &ITFN)
{
  m_nSize = ITFN.m_nSize;
  m_Num = (T*)calloc(m_nSize, sizeof(T));
  memcpy(m_Num, ITFN.m_Num, m_nSize*sizeof(T));
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  ITFN = The CIccTagFixedNum object to be copied
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagFixedNum<T, Tsig> &CIccTagFixedNum<T, Tsig>::operator=(const CIccTagFixedNum<T, Tsig> &ITFN)
{
  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;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::~CIccTagFixedNum
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagFixedNum<T, Tsig>::~CIccTagFixedNum()
{
  if (m_Num)
    free(m_Num);
}
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::GetClassName
 * 
 * Purpose: Returns the tag type class name
 * 
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
const icChar* CIccTagFixedNum<T, Tsig>::GetClassName() const
{
  if (Tsig==icSigS15Fixed16ArrayType)
    return "CIccTagS15Fixed16";
  else 
    return "CIccTagU16Fixed16";
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
bool CIccTagFixedNum<T, Tsig>::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
bool CIccTagFixedNum<T, Tsig>::Write(CIccIO *pIO)
{
  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;
}
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
void CIccTagFixedNum<T, Tsig>::Describe(std::string &sDescription, int nVerboseness)
{
  icChar buf[128] = { 0 };
 
  if (m_nSize == 1 ) {
    if (Tsig==icSigS15Fixed16ArrayType) 
      sprintf(buf, "Value = %.4lf\n", icFtoD(m_Num[0]));
    else
      sprintf(buf, "Value = %.4lf\n", icUFtoD(m_Num[0]));
    sDescription += buf;
  }
  else {
    icUInt32Number i;
 
    if (Tsig==icSigS15Fixed16ArrayType && m_nSize==9) {
      sDescription += "Matrix Form:\n";
      icMatrixDump(sDescription, (icS15Fixed16Number*)m_Num);
 
      sDescription += "\nArrayForm:\n";
    }
    sDescription.reserve(sDescription.size() + m_nSize*79);
 
    for (i=0; i<m_nSize; i++) {
      if (Tsig==icSigS15Fixed16ArrayType) 
        sprintf(buf, "Value[%u] = %8.4lf\n", i, icFtoD(m_Num[i]));
      else
        sprintf(buf, "Value[%u] = %8.4lf\n", i, icUFtoD(m_Num[i]));
      sDescription += buf;
    }
  }
}
 
/**
 ****************************************************************************
 * Name: CIccTagFixedNum::SetSize
 * 
 * Purpose: Sets the size of the data array.
 * 
 * Args: 
 *  nSize - number of data entries,
 *  bZeroNew - flag to zero newly formed values
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
bool CIccTagFixedNum<T, Tsig>::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
{
  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;
}
 
/**
****************************************************************************
* Name: CIccTagFixedNum::GetValues
* 
* Purpose: Gets values from the num array tag as floating point numbers
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
template <class T, icTagTypeSignature Tsig>
bool CIccTagFixedNum<T, Tsig>::GetValues(icFloatNumber *DstVector, icUInt32Number nStart, icUInt32Number nVectorSize) const
{
  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;
}
 
 
/**
****************************************************************************
* Name: CIccTagFixedNum::Interpolate
* 
* Purpose: Gets values from the num array tag as floating point numbers
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
template <class T, icTagTypeSignature Tsig>
bool CIccTagFixedNum<T, Tsig>::Interpolate(icFloatNumber *DstVector, icFloatNumber pos,
                                           icUInt32Number nVectorSize, icFloatNumber *zeroVals) const
{
  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;
      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 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) {
        for (i=0; i<m_nSize; i++) {
          DstVector[i] = (icFloatNumber)(zeroVals[i]*(1.0-x) + icUFtoD(hi[i])*x);
        }
      }
      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;
}
 
/**
****************************************************************************
* Name: CIccTagFixedNum::ValuePos
* 
* Purpose: Gets position of a value int the num array tag
* 
* Args: 
*  DstPos - position of val in array
*  val - value to look for in array.
*  bNoZero - flag indicating whether first entry is zero
*****************************************************************************
*/
template <class T, icTagTypeSignature Tsig>
bool CIccTagFixedNum<T, Tsig>::ValuePos(icFloatNumber &DstPos, icFloatNumber val, bool &bNoZero) const
{
  if(val<0.0)
    return false;
 
  icFloatNumber nv = 0.0;
  icFloatNumber lv = 0.0;
  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;
}
 
 
//Make sure typedef classes get built
template class CIccTagFixedNum<icS15Fixed16Number, icSigS15Fixed16ArrayType>;
template class CIccTagFixedNum<icU16Fixed16Number, icSigU16Fixed16ArrayType>;
 
 
/**
 ****************************************************************************
 * Name: CIccTagNum::CIccTagNum
 * 
 * Purpose: Constructor
 * 
 * Args:
 *  nSize = number of data entries
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagNum<T, Tsig>::CIccTagNum(int nSize/*=1*/)
{
  m_nSize = nSize;
  if (m_nSize <1)
    m_nSize = 1;
  m_Num = (T*)calloc(nSize, sizeof(T));
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNum::CIccTagNum
 * 
 * Purpose: Copy Constructor
 *
 * Args:
 *  ITNum = The CIccTagNum object to be copied
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagNum<T, Tsig>::CIccTagNum(const CIccTagNum<T, Tsig> &ITNum)
{
  m_nSize = ITNum.m_nSize;
 
  m_Num = (T*)calloc(m_nSize, sizeof(T));
  memcpy(m_Num, ITNum.m_Num, m_nSize * sizeof(T));
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNum::operator=
 * 
 * Purpose: Copy Operator
 *
 * Args:
 *  ITNum = The CIccTagNum object to be copied
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagNum<T, Tsig> &CIccTagNum<T, Tsig>::operator=(const CIccTagNum<T, Tsig> &ITNum)
{
  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;
}
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagNum::~CIccTagNum
 * 
 * Purpose: Destructor
 * 
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
CIccTagNum<T, Tsig>::~CIccTagNum()
{
  if (m_Num)
    free(m_Num);
}
 
/**
 ****************************************************************************
 * Name: CIccTagNum::GetClassName
 * 
 * Purpose: Returns the tag type class name
 * 
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
const icChar *CIccTagNum<T, Tsig>::GetClassName() const
{
  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<>";
}
 
 
/**
 ****************************************************************************
 * 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
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
bool CIccTagNum<T, Tsig>::Read(icUInt32Number size, CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNum::Write
 * 
 * Purpose: Write the tag to a file
 * 
 * Args: 
 *  pIO - The IO object to write tag to.
 * 
 * Return: 
 *  true = succesful, false = failure
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
bool CIccTagNum<T, Tsig>::Write(CIccIO *pIO)
{
  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;
}
 
 
/**
 ****************************************************************************
 * Name: CIccTagNum::Describe
 * 
 * Purpose: Dump data associated with the tag to a string
 * 
 * Args: 
 *  sDescription - string to concatenate tag dump to
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
void CIccTagNum<T, Tsig>::Describe(std::string &sDescription, int nVerboseness)
{
  icChar buf[128] = {0};
 
  if (m_nSize == 1 ) {
    switch (sizeof(T)) {
      case 1:
        sprintf(buf, "Value = %u (0x02%x)\n", m_Num[0], m_Num[0]);
        break;
      case 2:
        sprintf(buf, "Value = %u (0x04%x)\n", m_Num[0], m_Num[0]);
        break;
      case 4:
        sprintf(buf, "Value = %u (0x08%x)\n", m_Num[0], m_Num[0]);
        break;
      case 8:
        sprintf(buf, "Value = %u (0x016%x)\n", m_Num[0], m_Num[0]);
        break;
      default:
        sprintf(buf, "Value = %u (0x%x)\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)\n", m_Num[i], m_Num[i]);
        break;
      case 2:
        sprintf(buf, "Value = %u (0x04%x)\n", m_Num[i], m_Num[i]);
        break;
      case 4:
        sprintf(buf, "Value = %u (0x08%x)\n", m_Num[i], m_Num[i]);
        break;
      case 8:
        sprintf(buf, "Value = %u (0x016%x)\n", m_Num[i], m_Num[i]);
        break;
      default:
        sprintf(buf, "Value = %u (0x%x)\n", m_Num[i], m_Num[i]);
        break;
      }
      sDescription += buf;
    }
  }
}
 
template <class T, icTagTypeSignature Tsig>
icValidateStatus CIccTagNum<T, Tsig>::Validate(std::string sigPath, std::string &sReport, const CIccProfile* pProfile) const
{
  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.\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
 
  rv = icMaxStatus(rv, CIccTagNumArray::Validate(sigPath, sReport, pProfile));
 
  return rv;
}
 
// template function specialization to handle need for %llu and %llx for 64-bit ints
template <>
void CIccTagNum<icUInt64Number, icSigUInt64ArrayType>::Describe(std::string &sDescription, int nVerboseness)
{
  icChar buf[128];
 
  if (m_nSize == 1 ) {
    sprintf(buf, "Value = %llu (0x016%llx)\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)\n", m_Num[i], m_Num[i]);
      sDescription += buf;
    }
  }
}
 
 
 
 
/**
 ****************************************************************************
 * Name: CIccTagNum::SetSize
 * 
 * Purpose: Sets the size of the data array.
 * 
 * Args: 
 *  nSize - number of data entries,
 *  bZeroNew - flag to zero newly formed values
 *****************************************************************************
 */
template <class T, icTagTypeSignature Tsig>
bool CIccTagNum<T, Tsig>::SetSize(icUInt32Number nSize, bool bZeroNew/*=true*/)
{
  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;
}
 
/**
****************************************************************************
* Name: CIccTagNum::GetValues
* 
* Purpose: Gets values from the num array tag as floating point numbers
* 
* Args: 
*  nSize - number of data entries,
*  bZeroNew - flag to zero newly formed values
*****************************************************************************
*/
template <class T, icTagTypeSignature Tsig>
bool CIccTagNum<T, Tsig>::GetValues(icFloatNumber *DstVector, icUInt32Number nStart, icUInt32Number nVectorSize) const
{
  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;
}