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

Bug Summary

File:	IccProfLib/IccCmm.cpp
Warning:	line 6321, column 17 Assigned value is garbage or undefined
Annotated Source Code

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

  Contains:   Implementation of the CIccCmm class.

  Version:    V1

  Copyright:  � see ICC Software License
9*/

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

64////////////////////////////////////////////////////////////////////// 
65// HISTORY:
66//
67// -Initial implementation by Max Derhak 5-15-2003
68// -Added support for Monochrome ICC profile apply by Rohit Patil 12-03-2008
69// -Integrated changes for PCS adjustment by George Pawle 12-09-2008
70//
71//////////////////////////////////////////////////////////////////////

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

77#include "IccXformFactory.h"
78#include "IccTag.h"
79#include "IccMpeBasic.h"
80#include "IccArrayBasic.h"
81#include "IccStructBasic.h"
82#include "IccIO.h"
83#include "IccApplyBPC.h"
84#include "IccSparseMatrix.h"
85#include "IccEncoding.h"
86#include "IccMatrixMath.h"

88#ifdef USEREFICCMAXNAMESPACE
89namespace refIccMAX {
90#endif

92////
93// Useful Macros
94////

96static __inlineinline bool IsSpaceSpectralPCS(icUInt32Number sig)
97{
sig = icGetColorSpaceType(sig)((icColorSpaceSignature)(((icUInt32Number)sig)&0xffff0000
));

return sig==icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData) ||
       sig==icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData) ||
       sig==icSigRadiantSpectralPcsData((icColorSpaceSignature)icSigRadiantSpectralData) ||
       sig==icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData) ||
       sig==icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData);
105}

107#define IsSpaceColorimetricPCS(x)((x)==icSigXYZData || (x)==icSigLabData) ((x)==icSigXYZPcsDataicSigXYZData || (x)==icSigLabPcsDataicSigLabData)
108#define IsSpaceNChannel(x)(((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000)
)==icSigNChannelData) (icGetColorSpaceType(x)((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000))==icSigNChannelData)
109#define IsSpacePCS(x)(((x)==icSigXYZData || (x)==icSigLabData) || IsSpaceSpectralPCS
(x)) (IsSpaceColorimetricPCS(x)((x)==icSigXYZData || (x)==icSigLabData) || IsSpaceSpectralPCS(x))
110#define IsSpaceMCS(x)(((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000)
)==icSigSrcMCSChannelData) (icGetColorSpaceType(x)((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000))==icSigSrcMCSChannelData)
111#define IsSpaceCMYK(x)((x)==icSigCmykData || (x)==icSig4colorData) ((x)==icSigCmykData || (x)==icSig4colorData)

113#define IsNChannelCompat(x, y)(((((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000
))==icSigNChannelData) && (((icUInt32Number)x)&0x0000ffff
)==icGetSpaceSamples(y)) || ((((icColorSpaceSignature)(((icUInt32Number
)y)&0xffff0000))==icSigNChannelData) && (((icUInt32Number
)y)&0x0000ffff)==icGetSpaceSamples(x))) ((IsSpaceNChannel(x)(((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000)
)==icSigNChannelData) && icNumColorSpaceChannels(x)(((icUInt32Number)x)&0x0000ffff)==icGetSpaceSamples(y)) || (IsSpaceNChannel(y)(((icColorSpaceSignature)(((icUInt32Number)y)&0xffff0000)
)==icSigNChannelData) && icNumColorSpaceChannels(y)(((icUInt32Number)y)&0x0000ffff)==icGetSpaceSamples(x)))

115#define IsCompatSpace(x, y)((x)==(y) || ((((x)==icSigXYZData || (x)==icSigLabData) || IsSpaceSpectralPCS
(x)) && (((y)==icSigXYZData || (y)==icSigLabData) || IsSpaceSpectralPCS
(y))) || ((((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000
))==icSigSrcMCSChannelData) && (((icColorSpaceSignature
)(((icUInt32Number)y)&0xffff0000))==icSigSrcMCSChannelData
)) ) ((x)==(y) || (IsSpacePCS(x)(((x)==icSigXYZData || (x)==icSigLabData) || IsSpaceSpectralPCS
(x)) && IsSpacePCS(y)(((y)==icSigXYZData || (y)==icSigLabData) || IsSpaceSpectralPCS
(y))) || (IsSpaceMCS(x)(((icColorSpaceSignature)(((icUInt32Number)x)&0xffff0000)
)==icSigSrcMCSChannelData) && IsSpaceMCS(y)(((icColorSpaceSignature)(((icUInt32Number)y)&0xffff0000)
)==icSigSrcMCSChannelData))/* || (IsSpaceCMYK(x) && IsSpaceCMYK(y))*/)


118#define ICCPCSSTEPDUMPFMT" %.8f" ICCMTXSTEPDUMPFMT" %.8f"


121//////////////////////////////////////////////////////////////////////
122// Construction/Destruction
123//////////////////////////////////////////////////////////////////////

125/**
**************************************************************************
* Class CIccPCS Constructor
* 
* Purpose:
*  This is a class constructor.
* 
**************************************************************************
*/
134CIccPCS::CIccPCS()
135{
m_bIsV2Lab = false;
m_Space = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
m_bLastPcsXform = false;
139}

141/**
142**************************************************************************
143* Name: CIccPCS::Reset
144* 
145* Purpose:
146*  This is called with the initial color space and a bool 
147*  argument which is true if the PCS is version 2.
148* 
149* Args: 
150*  Startpsace = Starting Colorspace
151*  bUseLegacyPCS = legacy PCS flag
152**************************************************************************
153*/
154void CIccPCS::Reset(icColorSpaceSignature StartSpace, bool bUseLegacyPCS)
155{
m_bIsV2Lab = IsSpacePCS(StartSpace)(((StartSpace)==icSigXYZData || (StartSpace)==icSigLabData) ||
 IsSpaceSpectralPCS(StartSpace)) && bUseLegacyPCS;
m_Space = StartSpace;
158}

160/**
**************************************************************************
* Name: CIccPCS::Check
* 
* Purpose:
*  This is called before the apply of each profile's xform to adjust the PCS
*  to the xform's needed PCS.
* 
* Args: 
*   SrcPixel = source pixel data (this may need adjusting),
*   pXform = the xform that who's Apply function will shortly be called
* 
* Return: 
*  SrcPixel or ptr to adjusted pixel data (we dont want to modify the source data).
**************************************************************************
*/
176const icFloatNumber *CIccPCS::Check(const icFloatNumber *SrcPixel, const CIccXform *pXform)
177{
icColorSpaceSignature NextSpace = pXform->GetSrcSpace();
bool bIsV2 = pXform->UseLegacyPCS();
bool bIsNextV2Lab = bIsV2 && (NextSpace == icSigLabData);
const icFloatNumber *rv;
bool bNoClip = pXform->NoClipPCS();

if (m_bLastPcsXform) {
  rv = SrcPixel;
}
else if (m_bIsV2Lab && !bIsNextV2Lab) {
  Lab2ToLab4(m_Convert, SrcPixel, bNoClip);
  if (NextSpace==icSigXYZData) {
    LabToXyz(m_Convert, m_Convert, bNoClip);
  }
  rv = m_Convert;
}
else if (!m_bIsV2Lab && bIsNextV2Lab) {
  if (m_Space==icSigXYZData) {
    XyzToLab(m_Convert, SrcPixel, bNoClip);
    SrcPixel = m_Convert;
  }
  Lab4ToLab2(m_Convert, SrcPixel);
  rv = m_Convert;
}
else if (m_Space==NextSpace) {
  rv = SrcPixel;
}
else if (m_Space==icSigXYZData && NextSpace==icSigLabData) {
  XyzToLab(m_Convert, SrcPixel, bNoClip);
  rv = m_Convert;
}
else if (m_Space==icSigLabData && NextSpace==icSigXYZData) {
  LabToXyz(m_Convert, SrcPixel, bNoClip);
  rv = m_Convert;
}
else {
  rv = SrcPixel;
}

m_Space = pXform->GetDstSpace();
m_bIsV2Lab = bIsV2 && (m_Space == icSigLabData);
m_bLastPcsXform = (pXform->GetXformType()==icXformTypePCS);

return rv;
222}

224/**
**************************************************************************
* Name: CIccPCS::CheckLast
* 
* Purpose: 
*   Called after all xforms are applied to adjust PCS to final space if needed
*   Note: space will always be V4.
* 
* Args: 
*  Pixel = Pixel data,
*  DestSpace = destination color space
*  bNoClip = indicates whether PCS should be clipped
**************************************************************************
*/
238void CIccPCS::CheckLast(icFloatNumber *Pixel, icColorSpaceSignature DestSpace, bool bNoClip)
239{
if (m_bIsV2Lab) {
  Lab2ToLab4(Pixel, Pixel, bNoClip);
  if (DestSpace==icSigXYZData) {
    LabToXyz(Pixel, Pixel, bNoClip);
  }
}
else if (m_Space==DestSpace) {
  return;
}
else if (m_Space==icSigXYZData) {
  XyzToLab(Pixel, Pixel, bNoClip);
}
else if (m_Space==icSigLabData) {
  LabToXyz(Pixel, Pixel, bNoClip);
}
255}

257/**
**************************************************************************
* Name: CIccPCS::UnitClip
* 
* Purpose: 
*  Convert a double to an icUInt16Number with clipping
**************************************************************************
*/
265icFloatNumber CIccPCS::UnitClip(icFloatNumber v)
266{
if (v<0)
  v = 0;
if (v>1.0)
  v = 1.0;

return v;
273}

275/**
**************************************************************************
* Name: CIccPCS::NegClip
* 
* Purpose: 
*  Convert a double to an icUInt16Number with clipping of negative numbers
**************************************************************************
*/
283icFloatNumber CIccPCS::NegClip(icFloatNumber v)
284{
if (v<0)
  v=0;

return v;
289}

291/**
**************************************************************************
* Name: CIccPCS::LabToXyz
* 
* Purpose: 
*  Convert Lab to XYZ
**************************************************************************
*/
299void CIccPCS::LabToXyz(icFloatNumber *Dst, const icFloatNumber *Src, bool bNoClip)
300{
icFloatNumber Lab[3];

memcpy(&Lab,Src,sizeof(Lab));

icLabFromPcs(Lab);

icLabtoXYZ(Lab);

icXyzToPcs(Lab);

if (!bNoClip) {
  Dst[0] = UnitClip(Lab[0]);
  Dst[1] = UnitClip(Lab[1]);
  Dst[2] = UnitClip(Lab[2]);
}
else {
  Dst[0] = Lab[0];
  Dst[1] = Lab[1];
  Dst[2] = Lab[2];
}
321}


324/**
**************************************************************************
* Name: CIccPCS::XyzToLab
* 
* Purpose: 
*  Convert XYZ to Lab
**************************************************************************
*/
332void CIccPCS::XyzToLab(icFloatNumber *Dst, const icFloatNumber *Src, bool bNoClip)
333{
icFloatNumber XYZ[3];


if (!bNoClip) {
  XYZ[0] = UnitClip(Src[0]);
  XYZ[1] = UnitClip(Src[1]);
  XYZ[2] = UnitClip(Src[2]);
}
else {
  XYZ[0] = Src[0];
  XYZ[1] = Src[1];
  XYZ[2] = Src[2];
}

icXyzFromPcs(XYZ);

icXYZtoLab(XYZ);

icLabToPcs(XYZ);

if (!bNoClip) {
  Dst[0] = UnitClip(XYZ[0]);
  Dst[1] = UnitClip(XYZ[1]);
  Dst[2] = UnitClip(XYZ[2]);
}
else {
  Dst[0] = XYZ[0];
  Dst[1] = XYZ[1];
  Dst[2] = XYZ[2];
}
364}


367/**
**************************************************************************
* Name: CIccPCS::Lab2ToXyz
* 
* Purpose:
*  Convert version 2 Lab to XYZ
**************************************************************************
*/
375void CIccPCS::Lab2ToXyz(icFloatNumber *Dst, const icFloatNumber *Src, bool bNoClip)
376{
Lab2ToLab4(Dst, Src, bNoClip);
LabToXyz(Dst, Dst, bNoClip);
379}


382/**
**************************************************************************
* Name: CIccPCS::XyzToLab2
* 
* Purpose: 
*  Convert XYZ to version 2 Lab
**************************************************************************
*/
390void CIccPCS::XyzToLab2(icFloatNumber *Dst, const icFloatNumber *Src, bool bNoClip)
391{
XyzToLab(Dst, Src, bNoClip);
Lab4ToLab2(Dst, Dst);
394}


397/**
**************************************************************************
* Name: CIccPCS::Lab2ToLab4
* 
* Purpose: 
*  Convert version 2 Lab to version 4 Lab
**************************************************************************
*/
405void CIccPCS::Lab2ToLab4(icFloatNumber *Dst, const icFloatNumber *Src, bool bNoClip)
406{
if (bNoClip) {
  Dst[0] = (icFloatNumber)(Src[0] * 65535.0f / 65280.0f);
  Dst[1] = (icFloatNumber)(Src[1] * 65535.0f / 65280.0f);
  Dst[2] = (icFloatNumber)(Src[2] * 65535.0f / 65280.0f);
}
else {
  Dst[0] = UnitClip((icFloatNumber)(Src[0] * 65535.0f / 65280.0f));
  Dst[1] = UnitClip((icFloatNumber)(Src[1] * 65535.0f / 65280.0f));
  Dst[2] = UnitClip((icFloatNumber)(Src[2] * 65535.0f / 65280.0f));
}
417}

419/**
**************************************************************************
* Name: CIccPCS::Lab4ToLab2
* 
* Purpose: 
*  Convert version 4 Lab to version 2 Lab
**************************************************************************
*/
427void CIccPCS::Lab4ToLab2(icFloatNumber *Dst, const icFloatNumber *Src)
428{
Dst[0] = (icFloatNumber)(Src[0] * 65280.0f / 65535.0f);
Dst[1] = (icFloatNumber)(Src[1] * 65280.0f / 65535.0f);
Dst[2] = (icFloatNumber)(Src[2] * 65280.0f / 65535.0f);
432}

434/**
435**************************************************************************
436* Name: CIccCreateXformHintManager::CIccCreateXformHintManager
437* 
438* Purpose: 
439*  Destructor
440**************************************************************************
441*/
442CIccCreateXformHintManager::~CIccCreateXformHintManager()
443{
if (m_pList) {
IIccCreateXformHintList::iterator i;

for (i=m_pList->begin(); i!=m_pList->end(); i++) {
	if (i->ptr)
		delete i->ptr;
}

delete m_pList;
}
454}

456/**
457**************************************************************************
458* Name: CIccCreateXformHintManager::AddHint
459* 
460* Purpose:
461*  Adds and owns the passed named hint to it's list.
462* 
463* Args: 
464*  pHint = pointer to the hint object to be added
465* 
466* Return: 
467*  true = hint added to the list
468*  false = hint not added
469**************************************************************************
470*/
471bool CIccCreateXformHintManager::AddHint(IIccCreateXformHint* pHint)
472{
if (!m_pList) {
m_pList = new IIccCreateXformHintList;
}

if (pHint) {
if (GetHint(pHint->GetHintType())) {
	delete pHint;
	return false;
}
IIccCreateXformHintPtr Hint;
Hint.ptr = pHint;
m_pList->push_back(Hint);
return true;
}

return false;
489}

491/**
492**************************************************************************
493* Name: CIccCreateXformHintManager::DeleteHint
494* 
495* Purpose:
496*  Deletes the object referenced by the passed named hint pointer 
497*		and removes it from the list.
498* 
499* Args: 
500*  pHint = pointer to the hint object to be deleted
501* 
502* Return: 
503*  true = hint found and deleted
504*  false = hint not found
505**************************************************************************
506*/
507bool CIccCreateXformHintManager::DeleteHint(IIccCreateXformHint* pHint)
508{
if (m_pList && pHint) {
IIccCreateXformHintList::iterator i;
for (i=m_pList->begin(); i!=m_pList->end(); i++) {
	if (i->ptr) {
		if (i->ptr == pHint) {
			delete pHint;
			pHint = NULL__null;
			m_pList->erase(i);
			return true;
		}
	}
}
}

return false;
524}

526/**
527**************************************************************************
528* Name: CIccCreateXformHintManager::GetHint
529* 
530* Purpose:
531*  Finds and returns a pointer to the named hint.
532* 
533* Args: 
534*  hintName = name of the desired hint
535* 
536* Return: 
537*  Appropriate IIccCreateXformHint pointer
538**************************************************************************
539*/
540IIccCreateXformHint* CIccCreateXformHintManager::GetHint(const char* hintName)
541{
IIccCreateXformHint* pHint=NULL__null;

if (m_pList) {
IIccCreateXformHintList::iterator i;
for (i=m_pList->begin(); i!=m_pList->end(); i++) {
	if (i->ptr) {
		if (!strcmp(i->ptr->GetHintType(), hintName)) {
			pHint = i->ptr;
			break;
		}
	}
}
}

return pHint;
557}

559/**
**************************************************************************
* Name: CIccXform::CIccXform
* 
* Purpose: 
*  Constructor
**************************************************************************
*/
567CIccXform::CIccXform()
568{
m_pProfile = NULL__null;
m_bInput = true;
m_nIntent = icUnknownIntent((icRenderingIntent) 0x3f3f3f3f);
m_pAdjustPCS = NULL__null;
m_bAdjustPCS = false;
m_bAbsToRel = false;
m_nMCS = icNoMCS;
m_bUseSpectralPCS = false;
m_bSrcPcsConversion = true;
m_bDstPcsConversion = true;
m_pConnectionConditions = NULL__null;
m_pCmmEnvVarLookup = NULL__null;
581}


584/**
**************************************************************************
* Name: CIccXform::~CIccXform
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
592CIccXform::~CIccXform()
593{
if (m_pProfile)
  delete m_pProfile;

if (m_pAdjustPCS) {
delete m_pAdjustPCS;
}

if (m_pCmmEnvVarLookup) {
  delete m_pCmmEnvVarLookup;
}

605}


608void CIccXform::DetachAll()
609{
m_pProfile = NULL__null;
m_pConnectionConditions = NULL__null;
612}

614/**
**************************************************************************
* Name: CIccXform::Create
* 
* Purpose:
*  This is a static Creation function that creates derived CIccXform objects and
*  initializes them.
* 
* Args: 
*  pProfile = pointer to a CIccProfile object that will be owned by the transform.  This object will
*   be destroyed when the returned CIccXform object is destroyed.  The means that the CIccProfile
*   object needs to be allocated on the heap.
*  bInput = flag to indicate whether to use the input or output side of the profile,
*  nIntent = the rendering intent to apply to the profile,   
*  nInterp = the interpolation algorithm to use for N-D luts.
*  nLutType = selection of which transform lut to use
*  bUseD2BxB2DxTags = flag to indicate the use MPE flags if available
*  pHintManager = pointer to object that contains xform creation hints
* 
* Return: 
*  A suitable pXform object
**************************************************************************
*/
637CIccXform *CIccXform::Create(CIccProfile *pProfile,
                           bool bInput/* =true */,
                           icRenderingIntent nIntent/* =icUnknownIntent */, 
												 icXformInterp nInterp/* =icInterpLinear */, 
                           IIccProfileConnectionConditions *pPcc/*=NULL*/,
                           icXformLutType nLutType/* =icXformLutColor */, 
												 bool bUseD2BTags/* =true */, CIccCreateXformHintManager *pHintManager/* =NULL */)
644{
CIccXform *rv = NULL__null;
icRenderingIntent nTagIntent = nIntent;
bool bUseSpectralPCS = false;
bool bAbsToRel = false;
bool bRelToAbs = false;
icMCSConnectionType nMCS = icNoMCS;
icXformLutType nUseLutType = nLutType;
bool bUseColorimeticTags = true;

if (nLutType == icXformLutSpectral) {
  nUseLutType = icXformLutColor;
  bUseD2BTags = true;
  bUseColorimeticTags = false;
}
else if (nLutType == icXformLutColorimetric) {
  nUseLutType = icXformLutColor;
}

if (pProfile->m_Header.deviceClass==icSigColorEncodingClass) {
  CIccProfile *pEncProfile;
  if (icConvertEncodingProfile(pEncProfile, pProfile)!=icEncConvertOk)
    return NULL__null;
  delete pProfile;
  pProfile = pEncProfile;
}
if (pProfile->m_Header.deviceClass==icSigLinkClass/* && nIntent==icAbsoluteColorimetric*/) {
  nIntent = icPerceptual;
}

if (nTagIntent == icUnknownIntent((icRenderingIntent) 0x3f3f3f3f))
  nTagIntent = icPerceptual;

switch (nUseLutType) {
  case icXformLutColor:
    if (bInput) {
      CIccTag *pTag = NULL__null;
      if (bUseD2BTags) {
        if (pProfile->m_Header.spectralPCS && nLutType!=icXformLutColorimetric) {
          pTag = pProfile->FindTag(icSigDToB0Tag + nTagIntent);

          if (!pTag && nTagIntent == icAbsoluteColorimetric) {
            pTag = pProfile->FindTag(icSigDToB1Tag);
            if (pTag)
              nTagIntent = icRelativeColorimetric;
          }
          else if (!pTag && nTagIntent == icRelativeColorimetric) {
            pTag = pProfile->FindTag(icSigDToB3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }

          if (pTag)
            bUseSpectralPCS = true;

          if (!pTag) {
            pTag = pProfile->FindTag(icSigDToB0Tag);
          }
          if (!pTag) {
            pTag = pProfile->FindTag(icSigDToB1Tag);
          }
          if (!pTag) {
            pTag = pProfile->FindTag(icSigDToB3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }
        }
        else if (pProfile->m_Header.version < icVersionNumberV50x05000000) {
          pTag = pProfile->FindTag(icSigDToB0Tag + nTagIntent);

          if (!pTag && nTagIntent ==icAbsoluteColorimetric) {
            pTag = pProfile->FindTag(icSigDToB1Tag);
            if (pTag)
              nTagIntent = icRelativeColorimetric;
          }

          //Apparently Using DtoB0 is not prescribed here by the v4 ICC Specification
          if (!pTag && pProfile->m_Header.version >= icVersionNumberV50x05000000) {
            pTag = pProfile->FindTag(icSigDToB0Tag);
          }
        }
      }

      if (bUseColorimeticTags) {
        if (!pTag) {
          pTag = pProfile->FindTag(icSigAToB0Tag + nTagIntent);
        }

        if (!pTag && nTagIntent == icAbsoluteColorimetric) {
          pTag = pProfile->FindTag(icSigAToB1Tag);
          if (pTag)
            nTagIntent = icRelativeColorimetric;
        }
        else if (!pTag && nTagIntent == icRelativeColorimetric) {
          pTag = pProfile->FindTag(icSigAToB3Tag);
          if (pTag) {
            nTagIntent = icAbsoluteColorimetric;
            bAbsToRel = true;
          }
        }

        if (!pTag) {
          pTag = pProfile->FindTag(icSigAToB0Tag);
        }
        if (!pTag) {
          pTag = pProfile->FindTag(icSigAToB1Tag);
        }
        if (!pTag) {
          pTag = pProfile->FindTag(icSigAToB3Tag);
          if (pTag) {
            nTagIntent = icAbsoluteColorimetric;
            bAbsToRel = true;
          }
        }
      }

      //Unsupported elements cause fall back behavior
      if (pTag && !pTag->IsSupported())
        pTag = NULL__null;

      if (!pTag) {
        if (pProfile->m_Header.version < icVersionNumberV50x05000000) {
          //Matrix/TRC profiles are deprecated in v5 profiles
          if (pProfile->m_Header.colorSpace == icSigRgbData) {
            rv = CIccXformCreator::CreateXform(icXformTypeMatrixTRC, NULL__null, pHintManager);
          }
          else if (pProfile->m_Header.colorSpace == icSigGrayData) {
            rv = CIccXformCreator::CreateXform(icXformTypeMonochrome, NULL__null, pHintManager);
          }
          else
            return NULL__null;
        }
        else
          return NULL__null;
      }
      else if (pTag->GetType()==icSigMultiProcessElementType) {
        rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag, pHintManager);
      }
      else {
        switch(pProfile->m_Header.colorSpace) {
          case icSigXYZData:
          case icSigLabData:
          case icSigLuvData:
          case icSigYCbCrData:
          case icSigYxyData:
          case icSigRgbData:
          case icSigHsvData:
          case icSigHlsData:
          case icSigCmyData:
          case icSig3colorData:
            rv = CIccXformCreator::CreateXform(icXformType3DLut, pTag, pHintManager);
            break;

          case icSigCmykData:
          case icSig4colorData:
            rv = CIccXformCreator::CreateXform(icXformType4DLut, pTag, pHintManager);
            break;

          default:
            rv = CIccXformCreator::CreateXform(icXformTypeNDLut, pTag, pHintManager);
            break;
        }
      }
    }
    else {
      CIccTag *pTag = NULL__null;

      if (nLutType == icXformLutColorimetric && pProfile->m_Header.version >= icVersionNumberV50x05000000) {
        bUseD2BTags = false;
      }
      
      if (bUseD2BTags) {
        pTag = pProfile->FindTag(icSigBToD0Tag + nTagIntent);

        //Additional precedence not prescribed by the v4 ICC Specification
        if (!pTag && pProfile->m_Header.version >= icVersionNumberV50x05000000) {
          pTag = pProfile->FindTag(icSigBToD0Tag);

          if (!pTag) {
            pTag = pProfile->FindTag(icSigBToD1Tag);
            if (pTag) {
              nTagIntent = icRelativeColorimetric;
              if (nTagIntent==icAbsoluteColorimetric)
                bRelToAbs = true;
            }
          }

          if (!pTag) {
            pTag = pProfile->FindTag(icSigBToD3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }
        }

        //Unsupported elements cause fall back behavior
        if (pTag && !pTag->IsSupported())
          pTag = NULL__null;

        if (pTag)
          bUseSpectralPCS = true;

        if (!pTag && nTagIntent == icAbsoluteColorimetric && pProfile->m_Header.version < icVersionNumberV50x05000000) {
          pTag = pProfile->FindTag(icSigBToD1Tag);

          //Unsupported elements cause fall back behavior
          if (pTag && !pTag->IsSupported())
            pTag = NULL__null;

          if (pTag)
            nTagIntent = icRelativeColorimetric;
        }
      }

      if (bUseColorimeticTags) {

        if (!pTag) {
          pTag = pProfile->FindTag(icSigBToA0Tag + nTagIntent);
        }

        if (!pTag && nTagIntent == icAbsoluteColorimetric) {
          pTag = pProfile->FindTag(icSigBToA1Tag);
          if (pTag)
            nTagIntent = icRelativeColorimetric;
        }

        if (!pTag) {
          pTag = pProfile->FindTag(icSigBToA0Tag);
        }

        //Additional precedence not prescribed by the v4 ICC Specification
        if (!pTag && pProfile->m_Header.version >= icVersionNumberV50x05000000) {

          pTag = pProfile->FindTag(icSigBToA1Tag);
          if (pTag) {
            nTagIntent = icRelativeColorimetric;
            if (nTagIntent == icAbsoluteColorimetric)
              bRelToAbs = true;
          }

          if (!pTag) {
            pTag = pProfile->FindTag(icSigBToA3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }
        }
      }

      if (!pTag) {
        if (pProfile->m_Header.version < icVersionNumberV50x05000000) {
          if (pProfile->m_Header.colorSpace == icSigRgbData) {
            rv = CIccXformCreator::CreateXform(icXformTypeMatrixTRC, pTag, pHintManager);
          }
          else if (pProfile->m_Header.colorSpace == icSigGrayData) {
            rv = CIccXformCreator::CreateXform(icXformTypeMonochrome, NULL__null, pHintManager);
          }
          else
            return NULL__null;
        }
        else
          return NULL__null;
      }
      else if (pTag->GetType()==icSigMultiProcessElementType) {
        rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag, pHintManager);
      }
      else {
        switch(pProfile->m_Header.pcs) {
          case icSigXYZData:
          case icSigLabData:
            rv = CIccXformCreator::CreateXform(icXformType3DLut, pTag, pHintManager);
            break;

        default:
          break;
        }
      }
    }
    break;

  case icXformLutNamedColor:
    {
      CIccTag *pTag = pProfile->FindTag(icSigNamedColor2Tag);
      if (!pTag)
        return NULL__null;

      CIccCreateNamedColorXformHint* pNamedColorHint = new CIccCreateNamedColorXformHint();
      pNamedColorHint->csPcs = pProfile->m_Header.pcs;
      pNamedColorHint->csDevice = pProfile->m_Header.colorSpace;
      pNamedColorHint->csSpectralPcs = pProfile->m_Header.spectralPCS;
      pNamedColorHint->spectralRange = pProfile->m_Header.spectralRange;
      pNamedColorHint->biSpectralRange = pProfile->m_Header.biSpectralRange;
		if (pHintManager) {
			pHintManager->AddHint(pNamedColorHint);
			rv = CIccXformCreator::CreateXform(icXformTypeNamedColor, pTag, pHintManager);
			pHintManager->DeleteHint(pNamedColorHint);
		}
		else {
			CIccCreateXformHintManager HintManager;
			HintManager.AddHint(pNamedColorHint);
			rv = CIccXformCreator::CreateXform(icXformTypeNamedColor, pTag, &HintManager);
		}

      if (pProfile->m_Header.spectralPCS)
        bUseSpectralPCS = true;
    }
    break;

  case icXformLutPreview:
    {
      bInput = false;
      CIccTag *pTag = pProfile->FindTag(icSigPreview0Tag + nTagIntent);
      if (!pTag) {
        pTag = pProfile->FindTag(icSigPreview0Tag);
      }
      if (!pTag) {
        return NULL__null;
      }
      else {
        switch(pProfile->m_Header.pcs) {
          case icSigXYZData:
          case icSigLabData:
            rv = CIccXformCreator::CreateXform(icXformType3DLut, pTag, pHintManager);

          default:
            break;
        }
      }
    }
    break;

  case icXformLutGamut:
    {
      bInput = false;
      CIccTag *pTag = pProfile->FindTag(icSigGamutTag);
      if (!pTag) {
        return NULL__null;
      }
      else {
        switch(pProfile->m_Header.pcs) {
          case icSigXYZData:
          case icSigLabData:
            rv = CIccXformCreator::CreateXform(icXformType3DLut, pTag, pHintManager);

          default:
            break;
        }
      }
    }
    break;

  case icXformLutBRDFParam:
  {
    // get the correct tag first

    CIccTag *pTag = NULL__null;
    if (bUseD2BTags) {
      if (pProfile->m_Header.spectralPCS) {

        pTag = pProfile->FindTag(icSigBrdfSpectralParameter0Tag + nTagIntent);

        if (pTag)
          bUseSpectralPCS = true;
      }
    }
    else
    {
      pTag = pProfile->FindTag(icSigBrdfColorimetricParameter0Tag + nTagIntent);

      //Unsupported elements cause fall back behavior
      if (pTag && !pTag->IsSupported())
        pTag = NULL__null;
    }

    // now extract the correct part from the structure
    CIccStructBRDF* pStructTag = dynamic_cast<CIccStructBRDF*>(pTag);

    if (pStructTag != NULL__null)
    {
      CIccTag *pTag2 = NULL__null;

        switch (nLutType) {
          case icXformLutBRDFParam:
            pTag2 = pStructTag->GetElem(icSigBrdfTransformMbr);
            break;
          default:
            // can't get here, get rid of warning
            break;
        }
        if (pTag2)
          rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag2, pHintManager);
    }
  }
  break;

  case icXformLutBRDFDirect:
  {
    // get the correct tag first

    CIccTag *pTag = NULL__null;
    if (bUseD2BTags) {
      if (pProfile->m_Header.spectralPCS) {

        pTag = pProfile->FindTag(icSigBRDFDToB0Tag + nTagIntent);

        if (pTag)
          bUseSpectralPCS = true;
      }
    }
    else
    {
      pTag = pProfile->FindTag(icSigBRDFAToB0Tag + nTagIntent);

      //Unsupported elements cause fall back behavior
      if (pTag && !pTag->IsSupported())
        pTag = NULL__null;
    }

    if (pTag != NULL__null)
    {
      rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag, pHintManager);
    }
  }
  break;

  case icXformLutBRDFMcsParam:
  {
    CIccTag *pTag = NULL__null;
    if (pProfile->m_Header.deviceClass == icSigMaterialVisualizationClass) {
      bInput = true;
      nMCS = icFromMCS;

      if (pProfile->m_Header.spectralPCS) {
        pTag = pProfile->FindTag(icSigBRDFMToS0Tag + nTagIntent);

        if (!pTag && nTagIntent == icAbsoluteColorimetric) {
          pTag = pProfile->FindTag(icSigBRDFMToS1Tag);
          if (pTag)
            nTagIntent = icRelativeColorimetric;
        }
        else if (!pTag && nTagIntent != icAbsoluteColorimetric) {
          pTag = pProfile->FindTag(icSigBRDFMToS3Tag);
          if (pTag) {
            nTagIntent = icAbsoluteColorimetric;
            bAbsToRel = true;
          }
        }

        if (!pTag) {
          pTag = pProfile->FindTag(icSigBRDFMToS0Tag);
        }
        if (!pTag) {
          pTag = pProfile->FindTag(icSigBRDFMToS1Tag);
        }
        if (!pTag) {
          pTag = pProfile->FindTag(icSigBRDFMToS3Tag);
          if (pTag) {
            nTagIntent = icAbsoluteColorimetric;
            bAbsToRel = true;
          }
        }

        if (pTag)
          bUseSpectralPCS = true;
      }
      if (!pTag && pProfile->m_Header.pcs != 0) {
        pTag = pProfile->FindTag(icSigBRDFMToB0Tag + nTagIntent);

        if (!pTag && nTagIntent == icAbsoluteColorimetric) {
          pTag = pProfile->FindTag(icSigBRDFMToB1Tag);
          if (pTag)
            nTagIntent = icRelativeColorimetric;
        }
        else if (!pTag && nTagIntent != icAbsoluteColorimetric) {
          pTag = pProfile->FindTag(icSigBRDFMToB3Tag);
          if (pTag) {
            nTagIntent = icAbsoluteColorimetric;
            bAbsToRel = true;
          }
        }
       if (!pTag) {
          pTag = pProfile->FindTag(icSigBRDFMToB0Tag);
        }
        if (!pTag) {
          pTag = pProfile->FindTag(icSigBRDFMToB1Tag);
        }
        if (!pTag) {
          pTag = pProfile->FindTag(icSigBRDFMToB3Tag);
          if (pTag) {
            nTagIntent = icAbsoluteColorimetric;
            bAbsToRel = true;
          }
        }
      }

      //Unsupported elements cause fall back behavior
      if (pTag && !pTag->IsSupported())
        pTag = NULL__null;

      //Unsupported elements cause fall back behavior
      if (pTag && !pTag->IsSupported())
        pTag = NULL__null;
    }
    if (pTag && pProfile->m_Header.mcs) {
      rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag, pHintManager);
    }
    else
      rv = NULL__null;
  }
  break;

  case icXformLutMCS:
    {
      CIccTag *pTag = NULL__null;
      if (pProfile->m_Header.deviceClass==icSigMaterialIdentificationClass ||
          pProfile->m_Header.deviceClass==icSigInputClass) {
        bInput = true;
        nMCS = icToMCS;
        pTag = pProfile->FindTag(icSigAToM0Tag);
      }
      else if (pProfile->m_Header.deviceClass==icSigMaterialVisualizationClass) {
        bInput = true;
        nMCS = icFromMCS;

        if (pProfile->m_Header.spectralPCS) {
          pTag = pProfile->FindTag(icSigMToS0Tag + nTagIntent);

          if (!pTag && nTagIntent == icAbsoluteColorimetric) {
            pTag = pProfile->FindTag(icSigMToS1Tag);
            if (pTag)
              nTagIntent = icRelativeColorimetric;
          }
          else if (!pTag && nTagIntent != icAbsoluteColorimetric) {
            pTag = pProfile->FindTag(icSigMToS3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }

          if (!pTag) {
            pTag = pProfile->FindTag(icSigMToS0Tag);
          }
          if (!pTag) {
            pTag = pProfile->FindTag(icSigMToS1Tag);
          }
          if (!pTag) {
            pTag = pProfile->FindTag(icSigMToS3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }

          if (pTag)
            bUseSpectralPCS = true;
        }
        if (!pTag && pProfile->m_Header.pcs!=0) {
          pTag = pProfile->FindTag(icSigMToB0Tag + nTagIntent);

          if (!pTag && nTagIntent == icAbsoluteColorimetric) {
            pTag = pProfile->FindTag(icSigMToB1Tag);
            if (pTag)
              nTagIntent = icRelativeColorimetric;
          }
          else if (!pTag && nTagIntent != icAbsoluteColorimetric) {
            pTag = pProfile->FindTag(icSigMToB3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }

          if (!pTag) {
            pTag = pProfile->FindTag(icSigMToB0Tag);
          }
          if (!pTag) {
            pTag = pProfile->FindTag(icSigMToB1Tag);
          }
          if (!pTag) {
            pTag = pProfile->FindTag(icSigMToB3Tag);
            if (pTag) {
              nTagIntent = icAbsoluteColorimetric;
              bAbsToRel = true;
            }
          }
        }

        //Unsupported elements cause fall back behavior
        if (pTag && !pTag->IsSupported())
          pTag = NULL__null;
      }
      else if (pProfile->m_Header.deviceClass==icSigMaterialLinkClass) {
        bInput = false;
        nMCS = icFromMCS;
        pTag = pProfile->FindTag(icSigMToA0Tag);
      }
      if (pTag && pProfile->m_Header.mcs) {
        rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag, pHintManager);
      }
      else
        rv = NULL__null;
    }
    break;

}

if (rv) {
  if (pPcc)
    rv->m_pConnectionConditions = pPcc;
  else
    rv->m_pConnectionConditions = pProfile;

  rv->SetParams(pProfile, bInput, nIntent, nTagIntent, bUseSpectralPCS, nInterp, pHintManager, bAbsToRel, nMCS);
}

return rv;
1267}

1269/**
1270**************************************************************************
1271* Name: CIccXform::Create
1272*
1273* Purpose:
1274*  This is a static Creation function that creates derived CIccXform objects and
1275*  initializes them.
1276*
1277* Args:
1278*  pProfile = pointer to a CIccProfile object that will be owned by the transform.  This object will
1279*   be destroyed when the returned CIccXform object is destroyed.  The means that the CIccProfile
1280*   object needs to be allocated on the heap.
1281*  pTag = tag that specifies transform to use.  It is assumed to use colorimetric PCS and have a lut type of icXformLutColor.
1282*  bInput = flag to indicate whether to use the input or output side of the profile,
1283*  nIntent = the rendering intent to apply to the profile,
1284*  nInterp = the interpolation algorithm to use for N-D luts.
1285*  pPcc = pointer to profile connection conditions to associate with transform
1286*  pHintManager = pointer to object that contains xform creation hints
1287*
1288* Return:
1289*  A suitable pXform object
1290**************************************************************************
1291*/
1292CIccXform *CIccXform::Create(CIccProfile *pProfile,
                           CIccTag *pTag,
                           bool bInput/* =true */,
                           icRenderingIntent nIntent/* =icUnknownIntent */,
                           icXformInterp nInterp/* =icInterpLinear */,
                           IIccProfileConnectionConditions *pPcc/*=NULL*/,
                           bool bUseSpectralPCS/* =false*/,
                           CIccCreateXformHintManager *pHintManager/* =NULL */)
1300{
CIccXform *rv = NULL__null;
icRenderingIntent nTagIntent = nIntent;
bool bAbsToRel = false;
bool bRelToAbs = false;
icMCSConnectionType nMCS = icNoMCS;

if (pProfile->m_Header.deviceClass == icSigColorEncodingClass) {
  return NULL__null;
}

if (pProfile->m_Header.deviceClass == icSigLinkClass/* && nIntent==icAbsoluteColorimetric*/) {
  nIntent = icPerceptual;
}

if (nTagIntent == icUnknownIntent((icRenderingIntent) 0x3f3f3f3f))
  nTagIntent = icPerceptual;

//Unsupported elements cause fall back behavior
if (pTag && !pTag->IsSupported())
  return NULL__null;

if (bInput) {
  if (pTag->GetType() == icSigMultiProcessElementType) {
    rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag, pHintManager);
  }
  else {
    switch (pProfile->m_Header.colorSpace) {
    case icSigXYZData:
    case icSigLabData:
    case icSigLuvData:
    case icSigYCbCrData:
    case icSigYxyData:
    case icSigRgbData:
    case icSigHsvData:
    case icSigHlsData:
    case icSigCmyData:
    case icSig3colorData:
      rv = CIccXformCreator::CreateXform(icXformType3DLut, pTag, pHintManager);
      break;

    case icSigCmykData:
    case icSig4colorData:
      rv = CIccXformCreator::CreateXform(icXformType4DLut, pTag, pHintManager);
      break;

    default:
      rv = CIccXformCreator::CreateXform(icXformTypeNDLut, pTag, pHintManager);
      break;
    }
  }
}
else {
  if (pTag->GetType() == icSigMultiProcessElementType) {
    rv = CIccXformCreator::CreateXform(icXformTypeMpe, pTag, pHintManager);
  }
  else {
    switch (pProfile->m_Header.pcs) {
    case icSigXYZData:
    case icSigLabData:
      rv = CIccXformCreator::CreateXform(icXformType3DLut, pTag, pHintManager);
      break;

    default:
      break;
    }
  }
}

if (rv) {
  if (pPcc)
    rv->m_pConnectionConditions = pPcc;
  else
    rv->m_pConnectionConditions = pProfile;

  rv->SetParams(pProfile, bInput, nIntent, nTagIntent, bUseSpectralPCS, nInterp, pHintManager, bAbsToRel, nMCS);
}

return rv;
1379}

1381/**
******************************************************************************
* Name: CIccXform::SetParams
* 
* Purpose: 
*   This is an accessor function to set private values.  
* 
* Args: 
*  pProfile = pointer to profile associated with transform
*  bInput = indicates whether profile is input profile
*  nIntent = rendering intent to apply to the profile
*  nInterp = the interpolation algorithm to use for N-D luts
******************************************************************************/
1394void CIccXform::SetParams(CIccProfile *pProfile, bool bInput, icRenderingIntent nIntent, icRenderingIntent nTagIntent,
                        bool bUseSpectralPCS, icXformInterp nInterp, CIccCreateXformHintManager *pHintManager/* =NULL */,
                        bool bAbsToRel/*=false*/, icMCSConnectionType nMCS/*=icNoMCS*/)
1397{
m_pProfile = pProfile;
m_bInput = bInput;
m_nIntent = nIntent;
m_nTagIntent = nTagIntent;
m_nInterp = nInterp;
m_pAdjustPCS = NULL__null;
m_bUseSpectralPCS = bUseSpectralPCS;
m_bAbsToRel = bAbsToRel;
m_nMCS = nMCS;
m_bLuminanceMatching = false;

if (pHintManager) {
  IIccCreateXformHint *pHint=NULL__null;

  pHint = pHintManager->GetHint("CIccCreateAdjustPCSXformHint");
  if (pHint) {
  CIccCreateAdjustPCSXformHint *pAdjustPCSHint = (CIccCreateAdjustPCSXformHint*)pHint;
  m_pAdjustPCS = pAdjustPCSHint->GetNewAdjustPCSXform();
 }

  pHint = pHintManager->GetHint("CIccCreateCmmEnvVarXformHint");
  if (pHint) {
    CIccCreateCmmEnvVarXformHint *pCmmEnvVarHint = (CIccCreateCmmEnvVarXformHint*)pHint;
    m_pCmmEnvVarLookup = pCmmEnvVarHint->GetNewCmmEnvVarLookup();
  }

  pHint = pHintManager->GetHint("CIccLuminanceMatchingHint");
  if (pHint) {
    m_bLuminanceMatching = true;
  }
}
1429}

1431/**
**************************************************************************
* Name: CIccXform::Create
* 
* Purpose:
*  This is a static Creation function that creates derived CIccXform objects and
*  initializes them.
* 
* Args: 
*  Profile = reference to a CIccProfile object that will be used to create the transform.
*   A copy of the CIccProfile object will be created and passed to the pointer based Create().
*   The copied object will be destroyed when the returned CIccXform object is destroyed.
*  bInput = flag to indicate whether to use the input or output side of the profile,
*  nIntent = the rendering intent to apply to the profile,   
*  nInterp = the interpolation algorithm to use for N-D luts.
*  nLutType = selection of which transform lut to use
*  bUseD2BxB2DxTags = flag to indicate the use MPE flags if available
*  pHint = pointer to object passed to CIccXform creation functionality
* 
* Return: 
*  A suitable pXform object
**************************************************************************
*/
1454CIccXform *CIccXform::Create(CIccProfile &Profile,
                           bool bInput/* =true */,
                           icRenderingIntent nIntent/* =icUnknownIntent */, 
												 icXformInterp nInterp/* =icInterpLinear */, 
                           IIccProfileConnectionConditions *pPcc/*=NULL*/,
                           icXformLutType nLutType/* =icXformLutColor */, 
												 bool bUseD2BxB2DxTags/* =true */,
                           CIccCreateXformHintManager *pHintManager/* =NULL */)
1462{
CIccProfile *pProfile = new CIccProfile(Profile);
CIccXform *pXform = Create(pProfile, bInput, nIntent, nInterp, pPcc, nLutType, bUseD2BxB2DxTags, pHintManager);

if (!pXform)
  delete pProfile;

return pXform;
1470}


1473/**
**************************************************************************
* Name: CIccXform::Begin
* 
* Purpose: 
*  This function will be called before the xform is applied.  Derived objects
*  should also call this base class function to initialize for Absolute Colorimetric
*  Intent handling which is performed through the use of the CheckSrcAbs and
*  CheckDstAbs functions.
**************************************************************************
*/
1484icStatusCMM CIccXform::Begin()
1485{
IIccProfileConnectionConditions *pCond = GetConnectionConditions();

icFloatNumber mediaXYZ[3];
icFloatNumber illumXYZ[3];

if (m_nIntent==icAbsoluteColorimetric) {
  if (pCond) {
    pCond->getMediaWhiteXYZ(mediaXYZ);

    m_MediaXYZ.X = icFtoF16(mediaXYZ[0]);
    m_MediaXYZ.Y = icFtoF16(mediaXYZ[1]);
    m_MediaXYZ.Z = icFtoF16(mediaXYZ[2]);
  }
  else {
    CIccTag *pTag = m_pProfile->FindTag(icSigMediaWhitePointTag);

    if (!pTag || pTag->GetType()!=icSigXYZType)
      return icCmmStatInvalidProfile;

    CIccTagXYZ *pXyzTag = (CIccTagXYZ*)pTag;

    m_MediaXYZ = (*pXyzTag)[0];
    mediaXYZ[0] = icFtoD(m_MediaXYZ.X);
    mediaXYZ[1] = icFtoD(m_MediaXYZ.Y);
    mediaXYZ[2] = icFtoD(m_MediaXYZ.Z);
  }
}

icXYZNumber illXYZ;
if (pCond) {
  pCond->getNormIlluminantXYZ(illumXYZ);
  illXYZ.X = icDtoF(illumXYZ[0]);
  illXYZ.Y = icDtoF(illumXYZ[1]);
  illXYZ.Z = icDtoF(illumXYZ[2]);
}
else {
  illXYZ = m_pProfile->m_Header.illuminant;
  illumXYZ[0] = icFtoD(illXYZ.X);
  illumXYZ[1] = icFtoD(illXYZ.Y);
  illumXYZ[2] = icFtoD(illXYZ.Z);
}

// set up for any needed PCS adjustment
if (m_nIntent == icAbsoluteColorimetric && 
  (m_MediaXYZ.X != illXYZ.X ||
   m_MediaXYZ.Y != illXYZ.Y ||
   m_MediaXYZ.Z != illXYZ.Z)) {

	icColorSpaceSignature Space = m_pProfile->m_Header.pcs;

	if (IsSpacePCS(Space)(((Space)==icSigXYZData || (Space)==icSigLabData) || IsSpaceSpectralPCS
(Space))) {
		m_bAdjustPCS = true;				// turn ON PCS adjustment

		// scale factors depend upon media white point
		// set up for input transform
      if (!m_bInput) {
        m_PCSScale[0] = illumXYZ[0] / mediaXYZ[0];	
        m_PCSScale[1] = illumXYZ[1] / mediaXYZ[1];
        m_PCSScale[2] = illumXYZ[2] / mediaXYZ[2];
      }
      else {
        m_PCSScale[0] = mediaXYZ[0] / illumXYZ[0];	
        m_PCSScale[1] = mediaXYZ[1] / illumXYZ[1];
        m_PCSScale[2] = mediaXYZ[2] / illumXYZ[2];

      }

		m_PCSOffset[0] = 0.0;
		m_PCSOffset[1] = 0.0;
		m_PCSOffset[2] = 0.0;
	}
}
else if (m_nIntent == icPerceptual && (IsVersion2() || !HasPerceptualHandling())) {
icColorSpaceSignature Space = m_pProfile->m_Header.pcs;

if (IsSpacePCS(Space)(((Space)==icSigXYZData || (Space)==icSigLabData) || IsSpaceSpectralPCS
(Space)) && m_pProfile->m_Header.deviceClass!=icSigAbstractClass) {
	m_bAdjustPCS = true;				// turn ON PCS adjustment

	// set up for input transform, which needs version 2 black point to version 4
	m_PCSScale[0] = (icFloatNumber) (1.0 - icPerceptualRefBlackX0.00336 / icPerceptualRefWhiteX0.9642);	// scale factors
	m_PCSScale[1] = (icFloatNumber) (1.0 - icPerceptualRefBlackY0.0034731 / icPerceptualRefWhiteY1.0000);
	m_PCSScale[2] = (icFloatNumber) (1.0 - icPerceptualRefBlackZ0.00287 / icPerceptualRefWhiteZ0.8249);

	m_PCSOffset[0] = (icFloatNumber) (icPerceptualRefBlackX0.00336 * 32768.0 / 65535.0);	// offset factors
	m_PCSOffset[1] = (icFloatNumber) (icPerceptualRefBlackY0.0034731 * 32768.0 / 65535.0);
	m_PCSOffset[2] = (icFloatNumber) (icPerceptualRefBlackZ0.00287 * 32768.0 / 65535.0);

	if (!m_bInput) {				// output transform must convert version 4 black point to version 2
		m_PCSScale[0] = (icFloatNumber) 1.0 / m_PCSScale[0];	// invert scale factors
		m_PCSScale[1] = (icFloatNumber) 1.0 / m_PCSScale[1];
		m_PCSScale[2] = (icFloatNumber) 1.0 / m_PCSScale[2];

		m_PCSOffset[0] = - m_PCSOffset[0] * m_PCSScale[0];	// negate offset factors
		m_PCSOffset[1] = - m_PCSOffset[1] * m_PCSScale[1];
		m_PCSOffset[2] = - m_PCSOffset[2] * m_PCSScale[2];
	}
}
}


if (m_pAdjustPCS) {
CIccProfile ProfileCopy(*m_pProfile);

// need to read in all the tags, so that a copy of the profile can be made
if (!ProfileCopy.ReadTags(m_pProfile)) {
	return icCmmStatInvalidProfile;
}

if (!m_pAdjustPCS->CalcFactors(&ProfileCopy, this, m_PCSScale, m_PCSOffset)) {
	return icCmmStatIncorrectApply;
}

m_bAdjustPCS = true;
delete m_pAdjustPCS;
m_pAdjustPCS = NULL__null;
}

return icCmmStatOk;
1604}

1606/**
1607**************************************************************************
1608* Name: CIccXform::GetNewApply
1609* 
1610* Purpose: 
1611*  This Factory function allocates data specific for the application of the xform.
1612*  This allows multiple threads to simultaneously use the same xform.
1613**************************************************************************
1614*/
1615CIccApplyXform *CIccXform::GetNewApply(icStatusCMM &status)
1616{
CIccApplyXform *rv = new CIccApplyXform(this);

if (!rv) {
  status = icCmmStatAllocErr;
  return NULL__null;
}

status = icCmmStatOk;
return rv;
1626}

1628/**
**************************************************************************
1630* Name: CIccXform::AdjustPCS
* 
* Purpose: 
1633*  This function will take care of any PCS adjustments 
1634*  needed by the xform (the PCS is always version 4 relative).
* 
* Args: 
1637*  DstPixel = Destination pixel where the result is stored,
1638*  SrcPixel = Source pixel which is to be applied.
* 
**************************************************************************
*/
1642void CIccXform::AdjustPCS(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
1643{
icColorSpaceSignature Space = m_pProfile->m_Header.pcs;

if (Space==icSigLabData) {
  if (UseLegacyPCS()) {
  	CIccPCS::Lab2ToXyz(DstPixel, SrcPixel, true);
  }
  else {
    CIccPCS::LabToXyz(DstPixel, SrcPixel, true);
  }
}
else {
  DstPixel[0] = SrcPixel[0];
  DstPixel[1] = SrcPixel[1];
  DstPixel[2] = SrcPixel[2];
}

DstPixel[0] = DstPixel[0] * m_PCSScale[0] + m_PCSOffset[0];
DstPixel[1] = DstPixel[1] * m_PCSScale[1] + m_PCSOffset[1];
DstPixel[2] = DstPixel[2] * m_PCSScale[2] + m_PCSOffset[2];

if (Space==icSigLabData) {
  if (UseLegacyPCS()) {

  	CIccPCS::XyzToLab2(DstPixel, DstPixel, true);
  }
  else {
    CIccPCS::XyzToLab(DstPixel, DstPixel, true);
  }
}
1673#ifndef SAMPLEICC_NOCLIPLABTOXYZ
else {
  DstPixel[0] = CIccPCS::NegClip(DstPixel[0]);
  DstPixel[1] = CIccPCS::NegClip(DstPixel[1]);
  DstPixel[2] = CIccPCS::NegClip(DstPixel[2]);
}
1679#endif
1680}

1682/**
**************************************************************************
* Name: CIccXform::CheckSrcAbs
* 
* Purpose: 
*  This function will be called by a derived CIccXform object's Apply() function
*  BEFORE the actual xform is performed to take care of Absolute to Relative
*  adjustments needed by the xform (IE the PCS is always version 4 relative).
* 
* Args: 
*  Pixel = src pixel data (will not be modified)
* 
* Return: 
*  returns Pixel or adjusted pixel data.
**************************************************************************
*/
1698const icFloatNumber *CIccXform::CheckSrcAbs(CIccApplyXform *pApply, const icFloatNumber *Pixel) const
1699{
if (m_bAdjustPCS && !m_bInput && m_bSrcPcsConversion) {
  icFloatNumber *pAbsLab = pApply->m_AbsLab;
AdjustPCS(pAbsLab, Pixel);
  return pAbsLab;
}

return Pixel;
1707}

1709/**
**************************************************************************
* Name: CIccXform::CheckDstAbs
* 
* Purpose: 
*  This function will be called by a derived CIccXform object's Apply() function
*  AFTER the actual xform is performed to take care of Absolute to Relative
*  adjustments needed by the xform (IE the PCS is always version 4 relative).
* 
* Args: 
*  Pixel = source pixel data which will be modified
*
**************************************************************************
*/
1723void CIccXform::CheckDstAbs(icFloatNumber *Pixel) const
1724{
if (m_bAdjustPCS && m_bInput && m_bDstPcsConversion) {
AdjustPCS(Pixel, Pixel);
}
1728}
      
1730/**
1731**************************************************************************
1732* Name: CIccXform::GetSrcSpace
1733* 
1734* Purpose: 
1735*  Return the color space that is input to the transform.  
1736*  If a device space is either XYZ/Lab it is changed to dXYZ/dLab to avoid
1737*  confusion with PCS encoding of these spaces.  Device encoding of XYZ
1738*  and Lab spaces left to the device.
1739**************************************************************************
1740*/
1741icColorSpaceSignature CIccXform::GetSrcSpace() const
1742{
icColorSpaceSignature rv;
icProfileClassSignature deviceClass = m_pProfile->m_Header.deviceClass;

if (m_bInput) {
  rv = m_pProfile->m_Header.colorSpace;

  if (deviceClass != icSigAbstractClass) {
    //convert signature to device colorspace signature (avoid confusion about encoding).
    if (rv==icSigXYZData) {
      rv = icSigDevXYZData((icColorSpaceSignature) 0x6458595A);
    }
    else if (rv==icSigLabData) {
      rv = icSigDevLabData((icColorSpaceSignature) 0x644C6162);
    }
  }
}
else if (!m_bUseSpectralPCS || !m_pProfile->m_Header.spectralPCS) {
  rv = m_pProfile->m_Header.pcs;
}
else {
  rv = icGetColorSpaceType(m_pProfile->m_Header.spectralPCS)((icColorSpaceSignature)(((icUInt32Number)m_pProfile->m_Header
.spectralPCS)&0xffff0000));
}

return rv;
1767}

1769/**
1770**************************************************************************
1771* Name: CIccXform::GetNumSrcSamples
1772* 
1773* Purpose: 
1774*  Return the color space that is input to the transform.  
1775*  If a device space is either XYZ/Lab it is changed to dXYZ/dLab to avoid
1776*  confusion with PCS encoding of these spaces.  Device encoding of XYZ
1777*  and Lab spaces left to the device.
1778**************************************************************************
1779*/
1780icUInt16Number CIccXform::GetNumSrcSamples() const
1781{
icUInt16Number rv;

if (m_nMCS==icFromMCS) {
  rv = (icUInt16Number)icGetSpaceSamples((icColorSpaceSignature)m_pProfile->m_Header.mcs);
}
else if (m_bInput) {
  rv = (icUInt16Number)icGetSpaceSamples(m_pProfile->m_Header.colorSpace);
}
else if (!m_bUseSpectralPCS || !m_pProfile->m_Header.spectralPCS) {
  rv = (icUInt16Number)icGetSpaceSamples(m_pProfile->m_Header.pcs);
}
else {
  rv = (icUInt16Number)icGetSpectralSpaceSamples(&m_pProfile->m_Header);
}

return rv;
1798}

1800/**
1801**************************************************************************
1802* Name: CIccXform::GetDstSpace
1803* 
1804* Purpose: 
1805*  Return the color space that is output by the transform.  
1806*  If a device space is either XYZ/Lab it is changed to dXYZ/dLab to avoid
1807*  confusion with PCS encoding of these spaces.  Device encoding of XYZ
1808*  and Lab spaces left to the device.
1809**************************************************************************
1810*/
1811icColorSpaceSignature CIccXform::GetDstSpace() const
1812{
icColorSpaceSignature rv;
icProfileClassSignature deviceClass = m_pProfile->m_Header.deviceClass;

if (m_nMCS==icToMCS) {
  rv = (icColorSpaceSignature)m_pProfile->m_Header.mcs;
}
else if (m_bInput) {
  if (m_bUseSpectralPCS && m_pProfile->m_Header.spectralPCS)
    rv = icGetColorSpaceType(m_pProfile->m_Header.spectralPCS)((icColorSpaceSignature)(((icUInt32Number)m_pProfile->m_Header
.spectralPCS)&0xffff0000));
  else
    rv = m_pProfile->m_Header.pcs;
}
else {
  rv = m_pProfile->m_Header.colorSpace;

  //convert signature to device colorspace signature (avoid confusion about encoding).
  if (deviceClass != icSigAbstractClass) {
    if (rv==icSigXYZData) {
      rv = icSigDevXYZData((icColorSpaceSignature) 0x6458595A);
    }
    else if (rv==icSigLabData) {
      rv = icSigDevLabData((icColorSpaceSignature) 0x644C6162);
    }
  }
}

return rv;
1840}

1842/**
1843**************************************************************************
1844* Name: CIccXform::GetNumDstSamples
1845* 
1846* Purpose: 
1847*  Return the color space that is input to the transform.  
1848*  If a device space is either XYZ/Lab it is changed to dXYZ/dLab to avoid
1849*  confusion with PCS encoding of these spaces.  Device encoding of XYZ
1850*  and Lab spaces left to the device.
1851**************************************************************************
1852*/
1853icUInt16Number CIccXform::GetNumDstSamples() const
1854{
icUInt16Number rv;

if (m_nMCS==icToMCS) {
  rv = (icUInt16Number)icGetSpaceSamples((icColorSpaceSignature)m_pProfile->m_Header.mcs);
}
else if (!m_bInput) {
  rv = (icUInt16Number)icGetSpaceSamples(m_pProfile->m_Header.colorSpace);
}
else if (!m_bUseSpectralPCS || !m_pProfile->m_Header.spectralPCS) {
  rv = (icUInt16Number)icGetSpaceSamples(m_pProfile->m_Header.pcs);
}
else {
  rv = (icUInt16Number)icGetSpectralSpaceSamples(&m_pProfile->m_Header);
}

return rv;
1871}


1874/**
1875**************************************************************************
1876* Name: CIccApplyXform::CIccApplyXform
1877* 
1878* Purpose: 
1879*  Constructor
1880**************************************************************************
1881*/
1882CIccApplyXform::CIccApplyXform(CIccXform *pXform)
1883{
m_pXform = pXform;
1885}

1887/**
1888**************************************************************************
1889* Name: CIccApplyXform::CIccApplyXform
1890* 
1891* Purpose: 
1892*  Destructor
1893**************************************************************************
1894*/
1895CIccApplyXform::~CIccApplyXform()
1896{
1897}


1900/**
1901**************************************************************************
1902* Name: CIccApplyPcsXform::CIccApplyPcsXform
1903* 
1904* Purpose: 
1905*  Constructor
1906**************************************************************************
1907*/
1908CIccApplyPcsXform::CIccApplyPcsXform(CIccXform *pXform) : CIccApplyXform(pXform)
1909{
m_list = new CIccApplyPcsStepList();
m_temp1 = NULL__null;
m_temp2 = NULL__null;
1913}

1915/**
1916**************************************************************************
1917* Name: CIccApplyPcsXform::~CIccApplyPcsXform
1918* 
1919* Purpose: 
1920*  Destructor
1921**************************************************************************
1922*/
1923CIccApplyPcsXform::~CIccApplyPcsXform()
1924{

if (m_list) {
  CIccApplyPcsStepList::iterator i;
  for (i=m_list->begin(); i!=m_list->end(); i++) {
    if (i->ptr)
      delete i->ptr;
  }

  delete m_list;
}

if (m_temp1)
  delete m_temp1;
if (m_temp2)
  delete m_temp2;
1940}

1942/**
1943**************************************************************************
1944* Name: CIccApplyPcsXform::Init
1945* 
1946* Purpose: 
1947*  Initialize temporary variables used during pcs processing
1948**************************************************************************
1949*/
1950bool CIccApplyPcsXform::Init()
1951{
CIccPcsXform *pXform = (CIccPcsXform*)m_pXform;
icUInt16Number nChan = pXform->MaxChannels();

if (nChan) {
  m_temp1 = new icFloatNumber[nChan];
  m_temp2 = new icFloatNumber[nChan];
}

return m_temp1!=NULL__null && m_temp2!=NULL__null;
1961}


1964void CIccApplyPcsXform::AppendApplyStep(CIccApplyPcsStep *pStep)
1965{
CIccApplyPcsStepPtr ptr;

if (pStep && m_list) {
  ptr.ptr = pStep;
  m_list->push_back(ptr);
}
1972}


1975/**
1976**************************************************************************
1977* Name: CIccPcsXform::CIccPcsXform
1978* 
1979* Purpose: 
1980*  Constructor
1981**************************************************************************
1982*/
1983CIccPcsXform::CIccPcsXform()
1984{
m_list = new CIccPcsStepList();

m_srcSpace = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
m_nSrcSamples = 0;

m_dstSpace = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
m_nDstSamples = 0;
1992}

1994/**
1995**************************************************************************
1996* Name: CIccPcsXform::~CIccPcsXform
1997* 
1998* Purpose: 
1999*  Destructor
2000**************************************************************************
2001*/
2002CIccPcsXform::~CIccPcsXform()
2003{
if (m_list) {
  CIccPcsStepList::iterator step;
  for (step=m_list->begin(); step!=m_list->end(); step++) {
    if (step->ptr) {
      delete step->ptr;
      step->ptr = NULL__null;
    }
  }
  delete m_list;
}
2014}

2016/**
**************************************************************************
* Name: CIccPcsXform::Connect
* 
* Purpose: 
*  Insert PCS transform operations to perform PCS processing between 
*  pFromXform and pToXform
**************************************************************************
*/
2025icStatusCMM CIccPcsXform::Connect(CIccXform *pFromXform, CIccXform *pToXform)
2026{
icStatusCMM stat;

if (!pFromXform || !pToXform)
  return icCmmStatBadXform;

if (pFromXform->IsMCS() && pToXform->IsMCS()) {
  CIccProfile *pFromProfile = pFromXform->GetProfilePtr();
  CIccProfile *pToProfile = pToXform->GetProfilePtr();

  if (!pFromProfile || !pToProfile) {
    return icCmmStatBadSpaceLink;
  }
  CIccTagArray *pFromChannels = (CIccTagArray*)(pFromProfile->FindTagOfType(icSigMaterialTypeArrayTag, icSigTagArrayType));
  CIccTagArray *pToChannels = (CIccTagArray*)(pToProfile->FindTagOfType(icSigMaterialTypeArrayTag, icSigTagArrayType));

  if (!pFromChannels || !pToChannels) {
    return icCmmStatBadSpaceLink;
  }
  if (pFromChannels->GetTagArrayType()!=icSigUtf8TextTypeArray ||
      pToChannels->GetTagArrayType()!=icSigUtf8TextTypeArray ||
      !pFromChannels->AreAllOfType(icSigUtf8TextType) ||
      !pToChannels->AreAllOfType(icSigUtf8TextType)) {
    return icCmmStatBadSpaceLink;
  }

  m_nSrcSamples = pFromXform->GetNumDstSamples();
  m_nDstSamples = pToXform->GetNumSrcSamples();

  if (pFromChannels->GetSize() != m_nSrcSamples || pToChannels->GetSize() != m_nDstSamples) {
    return icCmmStatBadSpaceLink;
  }
  int i, j;

  if (pFromProfile->m_Header.flags&icMCSNeedsSubsetTrue0x00000004) {
    for (i=0; i<m_nSrcSamples; i++) {
      const icUChar *szSrcChan = ((CIccTagUtf8Text*)pFromChannels->GetIndex(i))->GetText();
      for (j=0; j<m_nDstSamples; j++) {
        const icUChar *szDstChan = ((CIccTagUtf8Text*)pToChannels->GetIndex(i))->GetText();
        if (!icUtf8StrCmp(szSrcChan, szDstChan)strcmp((const char*)szSrcChan, (const char*)szDstChan))
          break;
      }
      if (j==m_nDstSamples)
        return icCmmStatBadMCSLink;
    }
  }

  if (pToProfile->m_Header.flags&icMCSNeedsSubsetTrue0x00000004) {
    for (i=0; i<m_nDstSamples; i++) {
      const icUChar *szDstChan = ((CIccTagUtf8Text*)pToChannels->GetIndex(i))->GetText();
      for (j=0; j<m_nSrcSamples; j++) {
        const icUChar *szSrcChan = ((CIccTagUtf8Text*)pFromChannels->GetIndex(i))->GetText();
        if (!icUtf8StrCmp(szSrcChan, szDstChan)strcmp((const char*)szSrcChan, (const char*)szDstChan))
          break;
      }
      if (j==m_nSrcSamples)
        return icCmmStatBadMCSLink;
    }
  }
  CIccTag *pTag = pToProfile->FindTag(icSigMaterialDefaultValuesTag);
  CIccTagNumArray *pDefaults = NULL__null;
  if (pTag && pTag->IsNumArrayType()) {
    pDefaults = (CIccTagNumArray *)pTag;
  }

  pushRouteMcs(pFromChannels, pToChannels, pDefaults);
}
else {
  if (!pFromXform->IsInput() || (pToXform->IsInput() && !pToXform->IsAbstract())) {
    return icCmmStatBadSpaceLink;
  }

  m_srcSpace = pFromXform->GetDstSpace();
  if (IsSpaceSpectralPCS(m_srcSpace))
    m_srcSpace = icGetColorSpaceType(m_srcSpace)((icColorSpaceSignature)(((icUInt32Number)m_srcSpace)&0xffff0000
));

  m_nSrcSamples = pFromXform->GetNumDstSamples();

  m_dstSpace = pToXform->GetSrcSpace();
  if (IsSpaceSpectralPCS(m_dstSpace))
    m_dstSpace = icGetColorSpaceType(m_dstSpace)((icColorSpaceSignature)(((icUInt32Number)m_dstSpace)&0xffff0000
));

  m_nDstSamples = pToXform->GetNumSrcSamples();

  switch (m_srcSpace) {
    case icSigLabPcsDataicSigLabData:
      switch (m_dstSpace) {
        case icSigLabPcsDataicSigLabData:
          if (pFromXform->UseLegacyPCS())
            pushLab2ToXyz(pFromXform->m_pConnectionConditions);
          else
            pushLabToXyz(pFromXform->m_pConnectionConditions);
          if (pFromXform->NeedAdjustPCS()) {
            pushScale3(pFromXform->m_PCSScale[0], pFromXform->m_PCSScale[1], pFromXform->m_PCSScale[2]);
            pushOffset3(pFromXform->m_PCSOffset[0], pFromXform->m_PCSOffset[1], pFromXform->m_PCSOffset[2]);
          }
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          if (pToXform->UseLegacyPCS())
            pushXyzToLab2(pToXform->m_pConnectionConditions);
          else
            pushXyzToLab(pToXform->m_pConnectionConditions);
          break;

        case icSigXYZPcsDataicSigXYZData:
          if (pFromXform->UseLegacyPCS())
            pushLab2ToXyz(pFromXform->m_pConnectionConditions);
          else
            pushLabToXyz(pFromXform->m_pConnectionConditions);
          if (pFromXform->NeedAdjustPCS()) {
            pushScale3(pFromXform->m_PCSScale[0], pFromXform->m_PCSScale[1], pFromXform->m_PCSScale[2]);
            pushOffset3(pFromXform->m_PCSOffset[0], pFromXform->m_PCSOffset[1], pFromXform->m_PCSOffset[2]);
          }
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                        pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                        pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          pushXyzToXyzIn();
          break;

        case icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData):
        case icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData):
        case icSigRadiantSpectralPcsData((icColorSpaceSignature)icSigRadiantSpectralData):
        case icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData):
        case icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData):
          return icCmmStatUnsupportedPcsLink;
      }
      break;

    case icSigXYZPcsDataicSigXYZData:
      switch (m_dstSpace) {
        case icSigLabPcsDataicSigLabData:
          pushXyzInToXyz();
          if (pFromXform->NeedAdjustPCS()) {
            pushScale3(pFromXform->m_PCSScale[0], pFromXform->m_PCSScale[1], pFromXform->m_PCSScale[2]);
            pushOffset3(pFromXform->m_PCSOffset[0], pFromXform->m_PCSOffset[1], pFromXform->m_PCSOffset[2]);
          }
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          if (pToXform->UseLegacyPCS())
            pushXyzToLab2(pToXform->m_pConnectionConditions);
          else
            pushXyzToLab(pToXform->m_pConnectionConditions);
          break;

        case icSigXYZPcsDataicSigXYZData:
          pushXyzInToXyz();
          if (pFromXform->NeedAdjustPCS()) {
            pushScale3(pFromXform->m_PCSScale[0], pFromXform->m_PCSScale[1], pFromXform->m_PCSScale[2]);
            pushOffset3(pFromXform->m_PCSOffset[0], pFromXform->m_PCSOffset[1], pFromXform->m_PCSOffset[2]);
          }
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          pushXyzToXyzIn();
          break;

        case icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData):
        case icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData):
        case icSigRadiantSpectralPcsData((icColorSpaceSignature)icSigRadiantSpectralData):
        case icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData):
        case icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData):
          return icCmmStatUnsupportedPcsLink;
      }
      break;

    case icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData):
    case icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData):
      switch (m_dstSpace) {
        case icSigLabPcsDataicSigLabData:
          pushRef2Xyz(pFromXform->m_pProfile, pFromXform->m_pConnectionConditions);
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                                pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                                pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          if (pToXform->UseLegacyPCS())
            pushXyzToLab2(pToXform->m_pConnectionConditions);
          else
            pushXyzToLab(pToXform->m_pConnectionConditions);
          break;

        case icSigXYZPcsDataicSigXYZData:
          pushRef2Xyz(pFromXform->m_pProfile, pFromXform->m_pConnectionConditions);
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          pushXyzToXyzIn();
          break;

        case icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData):
        case icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData):
            pushSpecToRange(pFromXform->m_pProfile->m_Header.spectralRange, 
                            pToXform->m_pProfile->m_Header.spectralRange);
          break;

        case icSigRadiantSpectralPcsData((icColorSpaceSignature)icSigRadiantSpectralData):
          pushApplyIllum(pFromXform->m_pProfile, pFromXform->m_pConnectionConditions);
          pushSpecToRange(pFromXform->m_pProfile->m_Header.spectralRange, 
                          pToXform->m_pProfile->m_Header.spectralRange);
          break;

        case icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData):
        case icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData):
          return icCmmStatUnsupportedPcsLink;
      }
      break;

    case icSigRadiantSpectralPcsData((icColorSpaceSignature)icSigRadiantSpectralData): {
      CIccProfile *pFromProfile = pFromXform->GetProfilePtr();
      CIccProfile *pToProfile = pToXform->GetProfilePtr();

      switch (m_dstSpace) {
        case icSigLabPcsDataicSigLabData:
          pushRad2Xyz(pFromProfile, pFromXform->m_pConnectionConditions, false);
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          if (pToXform->UseLegacyPCS())
            pushXyzToLab2(pToXform->m_pConnectionConditions);
          else
            pushXyzToLab(pToXform->m_pConnectionConditions);
          break;

        case icSigXYZPcsDataicSigXYZData:
          pushRad2Xyz(pFromProfile, pFromXform->m_pConnectionConditions, false);
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          pushXyzToXyzIn();
          break;

        case icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData):
        case icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData):
          return icCmmStatUnsupportedPcsLink;


        case icSigRadiantSpectralPcsData((icColorSpaceSignature)icSigRadiantSpectralData):
              pushSpecToRange(pFromXform->m_pProfile->m_Header.spectralRange, 
                                 pToXform->m_pProfile->m_Header.spectralRange);
          break;

        case icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData):
        case icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData):
          return icCmmStatUnsupportedPcsLink;
      }
    }
    break;

    case icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData):
    case icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData):
      switch (m_dstSpace) {
        case icSigLabPcsDataicSigLabData:
          pushBiRef2Xyz(pFromXform->m_pProfile, pFromXform->m_pConnectionConditions);
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          if (pToXform->UseLegacyPCS())
            pushXyzToLab2(pToXform->m_pConnectionConditions);
          else
            pushXyzToLab(pToXform->m_pConnectionConditions);
          break;

        case icSigXYZPcsDataicSigXYZData:
          if ((stat=pushBiRef2Xyz(pFromXform->m_pProfile, pFromXform->m_pConnectionConditions))!=icCmmStatOk) {
            return stat;
          }
          if ((stat=pushXYZConvert(pFromXform, pToXform))!=icCmmStatOk) {
            return stat;
          }
          if (pToXform->NeedAdjustPCS()) {
            pushOffset3(pToXform->m_PCSOffset[0]/pToXform->m_PCSScale[0],
                          pToXform->m_PCSOffset[1]/pToXform->m_PCSScale[1],
                          pToXform->m_PCSOffset[2]/pToXform->m_PCSScale[2]);
            pushScale3(pToXform->m_PCSScale[0], pToXform->m_PCSScale[1], pToXform->m_PCSScale[2]);
          }
          pushXyzToXyzIn();
          break;

        case icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData):
        case icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData):
          if ((stat=pushBiRef2Ref(pFromXform->m_pProfile, pFromXform->m_pConnectionConditions))!=icCmmStatOk) {
            return stat;
          }
          pushSpecToRange(pFromXform->m_pProfile->m_Header.spectralRange, 
                          pToXform->m_pProfile->m_Header.spectralRange);
          break;

        case icSigRadiantSpectralPcsData((icColorSpaceSignature)icSigRadiantSpectralData):
          if ((stat=pushBiRef2Rad(pFromXform->m_pProfile, pFromXform->m_pConnectionConditions))!=icCmmStatOk) {
            return stat;
          }
          pushSpecToRange(pFromXform->m_pProfile->m_Header.spectralRange, 
                          pToXform->m_pProfile->m_Header.spectralRange);
          break;

        case icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData):
          if (icSameSpectralRange(pFromXform->m_pProfile->m_Header.spectralRange, pToXform->m_pProfile->m_Header.spectralRange) &&
              icSameSpectralRange(pFromXform->m_pProfile->m_Header.biSpectralRange, pToXform->m_pProfile->m_Header.biSpectralRange))
              break;
          else
            return icCmmStatUnsupportedPcsLink;
        
        case icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData):
          return icCmmStatUnsupportedPcsLink;
      }
      break;
  }
}

icStatusCMM rv = Optimize();
if (rv!=icCmmStatOk)
  return rv;

if (m_list->begin()==m_list->end())
  return icCmmStatIdentityXform;

return icCmmStatOk;
2397}


2400/**
**************************************************************************
* Name: CIccPcsXform::Optimize
* 
* Purpose: 
*  Analyzes and concatenates/removes transforms in pcs transformation chain
**************************************************************************
*/
2408icStatusCMM CIccPcsXform::Optimize()
2409{
if (!m_list)
  return icCmmStatBadXform;

CIccPcsStepList steps = *m_list;
CIccPcsStepList::iterator next, last;
bool done=false;

2417#if 0
std::string str;
for (next = steps.begin(); next != steps.end(); next++) {
  next->ptr->dump(str);
}
printf("PCS_Steps:\r\n%s", str.c_str());
2423#endif

while (!done) {
  CIccPcsStepList newSteps;
  CIccPcsStepPtr ptr;

  done = true;

  next = steps.begin();
  if (next==steps.end()) {
    *m_list = steps;
    return icCmmStatIdentityXform;
  }
  last = next;
  next++;

  ptr.ptr = last->ptr;

  for (;next!=steps.end(); next++) {
    CIccPcsStep *pStep = ptr.ptr->concat(next->ptr);

    if (pStep) {
      done = false;

      delete ptr.ptr;
      delete next->ptr;
      ptr.ptr = pStep;
    }
    else {
      if (!ptr.ptr->isIdentity()) {
        newSteps.push_back(ptr);
      }
      ptr.ptr = next->ptr;
    }
  }
  if (!ptr.ptr->isIdentity()) {
    newSteps.push_back(ptr);
  }

  steps = newSteps;

2464//     for (next=steps.begin(); next!=steps.end(); next++) {
2465//       ptr.ptr = next->ptr;
2466//       done = true;
2467//     }

}

if (!steps.empty()) {
  CIccPcsStepList newSteps;
  CIccPcsStepPtr ptr;

  for (next=steps.begin(); next != steps.end(); next++) {
    ptr.ptr = next->ptr->reduce();
    if (ptr.ptr != next->ptr)
      delete next->ptr;
    newSteps.push_back(ptr);
  }
  steps = newSteps;
}

*m_list = steps;

return icCmmStatOk;
2487}


2490/**
**************************************************************************
* Name: CIccPcsXform::GetNewApply
* 
* Purpose: 
*  Allocates a CIccApplyXform based object that can store local data for
*  processing (needed by CIccPcsStepMpe).
**************************************************************************
*/
2499CIccApplyXform *CIccPcsXform::GetNewApply(icStatusCMM &status)
2500{
CIccApplyPcsXform *pNew = new CIccApplyPcsXform(this);

if (pNew) {
  if (!pNew->Init()) {
    delete pNew;
    status = icCmmStatAllocErr;
    return NULL__null;
  }
}
else {
  status = icCmmStatAllocErr;
  return NULL__null;
}

CIccPcsStepList::iterator i;
CIccApplyPcsStep *pStep;

for (i=m_list->begin(); i!=m_list->end(); i++) {
  pStep = i->ptr->GetNewApply();
  if (!pStep || status != icCmmStatOk) {
    delete pNew;
    return NULL__null;
  }
  pNew->AppendApplyStep(pStep);
}

return pNew;
2528}


2531/**
**************************************************************************
* Name: CIccPcsXform::MaxChannels
* 
* Purpose: 
*  Returns the maximum number of channels used by PCS xform steps
**************************************************************************
*/
2539icUInt16Number CIccPcsXform::MaxChannels()
2540{
icUInt16Number nMax = 0;
CIccPcsStepList::const_iterator s = m_list->begin();
if (s==m_list->end())
  return nMax;
nMax = s->ptr->GetDstChannels();
s++;
for (; s!= m_list->end(); s++) {
  if (s->ptr->GetSrcChannels()>nMax)
    nMax = s->ptr->GetSrcChannels();
}
return nMax;
2552}

2554/**
**************************************************************************
* Name: CIccPcsXform::pushRouteMcs
* 
* Purpose: 
*  Insert PCS step that routes MCS channel data from one profile to another
**************************************************************************
*/
2562void CIccPcsXform::pushRouteMcs(CIccTagArray *pSrcChannels, CIccTagArray *pDstChannels, CIccTagNumArray *pDefaults)
2563{
CIccPcsStepPtr ptr;

ptr.ptr = new CIccPcsStepRouteMcs(pSrcChannels, pDstChannels, pDefaults);
m_list->push_back(ptr);
2568}


2571/**
**************************************************************************
* Name: CIccPcsXform::pushLab2ToXyz
* 
* Purpose: 
*  Insert PCS step that converts from V2 Lab internal to actual XYZ
**************************************************************************
*/
2579void CIccPcsXform::pushLab2ToXyz( IIccProfileConnectionConditions *pPCC)
2580{
icFloatNumber xyzWhite[3];
pPCC->getNormIlluminantXYZ(xyzWhite);

CIccPcsStepPtr ptr;

ptr.ptr = new CIccPcsStepLab2ToXYZ(xyzWhite);
m_list->push_back(ptr);
2588}


2591/**
**************************************************************************
* Name: CIccPcsXform::pushXyzToLab2
* 
* Purpose: 
*  Insert PCS step that converts from actual XYZ to V2 Lab internal
**************************************************************************
*/
2599void CIccPcsXform::pushXyzToLab2(IIccProfileConnectionConditions *pPCC)
2600{
icFloatNumber xyzWhite[3];
pPCC->getNormIlluminantXYZ(xyzWhite);

CIccPcsStepPtr ptr;

ptr.ptr = new CIccPcsStepXYZToLab2(xyzWhite);
m_list->push_back(ptr);
2608}


2611/**
**************************************************************************
* Name: CIccPcsXform::pushLabToXyz
* 
* Purpose: 
*  Insert PCS step that converts from V4 Lab internal to actual XYZ
**************************************************************************
*/
2619void CIccPcsXform::pushLabToXyz(IIccProfileConnectionConditions *pPCC)
2620{
icFloatNumber xyzWhite[3];
pPCC->getNormIlluminantXYZ(xyzWhite);

CIccPcsStepPtr ptr;

ptr.ptr = new CIccPcsStepLabToXYZ(xyzWhite);
m_list->push_back(ptr);
2628}


2631/**
**************************************************************************
* Name: CIccPcsXform::pushXyzToLab
* 
* Purpose: 
*  Insert PCS step that converts from actual XYZ to V4 Lab internal
**************************************************************************
*/
2639void CIccPcsXform::pushXyzToLab( IIccProfileConnectionConditions *pPCC)
2640{
icFloatNumber xyzWhite[3];
pPCC->getNormIlluminantXYZ(xyzWhite);

CIccPcsStepPtr ptr;

ptr.ptr = new CIccPcsStepXYZToLab(xyzWhite);
m_list->push_back(ptr);
2648}

2650/**
**************************************************************************
* Name: CIccPcsXform::pushScale3
* 
* Purpose: 
*  Insert PCS step that individually scaled three channels (conceptually
*  equivalent to inserting a 3x3 diagonal matrix).
**************************************************************************
*/
2659void CIccPcsXform::pushScale3(icFloatNumber v1, icFloatNumber v2, icFloatNumber v3)
2660{
CIccPcsStepScale *scale;
CIccPcsStepPtr ptr;

scale = new CIccPcsStepScale(3);
icFloatNumber *data = scale->data();
data[0] = v1;
data[1] = v2;
data[2] = v3;

ptr.ptr = scale;
m_list->push_back(ptr);
2672}

2674/**
**************************************************************************
* Name: CIccPcsXform::pushXyzToXyzIn
* 
* Purpose: 
*  Insert PCS step that converts from actual XYZ to internal XYZ
**************************************************************************
*/
2682void CIccPcsXform::pushXyzToXyzIn()
2683{
icFloatNumber scale = (icFloatNumber) (32768.0 / 65535.0);
pushScale3(scale, scale, scale);
2686}


2689/**
**************************************************************************
* Name: CIccPcsXform::pushXyzInToXyz
* 
* Purpose: 
*  Insert PCS step that converts from internal XYZ to actual XYZ
**************************************************************************
*/
2697void CIccPcsXform::pushXyzInToXyz()
2698{
icFloatNumber scale = (icFloatNumber) (65535.0 / 32768.0);
return pushScale3(scale, scale, scale);
2701}


2704/**
2705**************************************************************************
2706* Name: CIccPcsXform::pushXyzToXyzLum
2707*
2708* Purpose:
2709*  Insert PCS step that converts from normalized XYZ to XYZ Luminance
2710**************************************************************************
2711*/
2712void CIccPcsXform::pushXyzToXyzLum(IIccProfileConnectionConditions *pPCC)
2713{
icFloatNumber XYZLum[3];
pPCC->getLumIlluminantXYZ(&XYZLum[0]);

icFloatNumber scale = XYZLum[1];

return pushScale3(scale, scale, scale);
2720}


2723/**
2724**************************************************************************
2725* Name: CIccPcsXform::pushXyzLumToXyz
2726*
2727* Purpose:
2728*  Insert PCS step that converts from XYZ Luminance to normalized XYZ
2729**************************************************************************
2730*/
2731void CIccPcsXform::pushXyzLumToXyz(IIccProfileConnectionConditions *pPCC)
2732{
icFloatNumber XYZLum[3];
pPCC->getLumIlluminantXYZ(&XYZLum[0]);

icFloatNumber scale = 1.0f / XYZLum[1];

return pushScale3(scale, scale, scale);
2739}


2742/**
**************************************************************************
* Name: CIccPcsXform::pushXyzToXyzIn
* 
* Purpose: 
*  Insert PCS step that adds an offset to 3 channels.  If bConvertIntXyzOffset
*  is true the the offset is assumed to be in Internal XYZ format and
*  will be converted to be an actual XYZ offset.
**************************************************************************
*/
2752void CIccPcsXform::pushOffset3(icFloatNumber v1, icFloatNumber v2, icFloatNumber v3, bool bConvertIntXyzOffset/*=true*/)
2753{
CIccPcsStepOffset *offset;
CIccPcsStepPtr ptr;

offset = new CIccPcsStepOffset(3);
icFloatNumber *data = offset->data();
if (bConvertIntXyzOffset) {
  data[0] = v1*65535.0f/32768.0f;
  data[1] = v2*65535.0f/32768.0f;
  data[2] = v3*65535.0f/32768.0f;
}
else {
  data[0] = v1;
  data[1] = v2;
  data[2] = v3;
}

ptr.ptr = offset;
m_list->push_back(ptr);
2772}


2775/**
**************************************************************************
* Name: CIccPcsXform::pushScale
* 
* Purpose: 
*  Insert PCS step that individually n channels (conceptually
*  equivalent to inserting a nxn diagonal matrix).
**************************************************************************
*/
2784void CIccPcsXform::pushScale(icUInt16Number n, const icFloatNumber *vals)
2785{
CIccPcsStepScale *scale = new CIccPcsStepScale(n);
memcpy(scale->data(), vals, n*sizeof(icFloatNumber));

CIccPcsStepPtr ptr;
ptr.ptr = scale;
m_list->push_back(ptr);
2792}


2795/**
**************************************************************************
* Name: CIccPcsXform::pushMatrix
* 
* Purpose: 
*  Insert PCS step defined by a nRows x nCols matrix with specified vals
**************************************************************************
*/
2803void CIccPcsXform::pushMatrix(icUInt16Number nRows, icUInt16Number nCols, const icFloatNumber *vals)
2804{
CIccPcsStepMatrix *mtx = new CIccPcsStepMatrix(nRows, nCols);
memcpy(mtx->entry(0), vals, nRows*nCols*sizeof(icFloatNumber));

CIccPcsStepPtr ptr;
ptr.ptr = mtx;
m_list->push_back(ptr);
2811}


2814/**
**************************************************************************
* Name: CIccPcsXform::pushXYZConvert
* 
* Purpose: 
*  Insert PCS step that converts from source XYZ colorimetry to dest XYZ
*  colorimetry accounting for possible changes in illuminant and/or observer.
*  Luminance matching is also accounted for.
**************************************************************************
*/
2824icStatusCMM CIccPcsXform::pushXYZConvert(CIccXform *pFromXform, CIccXform *pToXform)
2825{
IIccProfileConnectionConditions *pSrcPcc = pFromXform->GetConnectionConditions();
IIccProfileConnectionConditions *pDstPcc = pToXform->GetConnectionConditions();

if (!pSrcPcc || !pDstPcc)
  return icCmmStatBadConnection;

//If source and dest observer and illuminant are same then no transform is needed
if (pSrcPcc->isEquivalentPcc(*pDstPcc)) {
  return icCmmStatOk;
}

CIccPcsStepPtr ptr;

if (!pSrcPcc->isStandardPcc()) {

  CIccTagMultiProcessElement *pMpe = pSrcPcc->getCustomToStandardPcc();

  if (!pMpe || pMpe->NumInputChannels()!=3 || pMpe->NumOutputChannels()!=3)
    return icCmmStatBadSpaceLink;

  ptr.ptr = NULL__null;

  //push single matrix element as a CIccPcsStepMatrix so it can be optimized
  if (pMpe->NumElements()==1) {
    CIccMultiProcessElement *pElem = pMpe->GetElement(0);
    if (pElem) {
      if (pElem->GetType()==icSigMatrixElemType) {
        CIccMpeMatrix *pMatElem = (CIccMpeMatrix*)pElem;

        icFloatNumber *pMat = pMatElem->GetMatrix();
        icFloatNumber *pOffset = pMatElem->GetConstants();

        if (pMat && (!pOffset || (pOffset[0]==0.0 && pOffset[1]==0.0 && pOffset[2]==0.0))) {
          CIccPcsStepMatrix *pStepMtx = new CIccPcsStepMatrix(3, 3);

          if (pStepMtx ) {
            memcpy(pStepMtx->entry(0,0), pMat, 9*sizeof(icFloatNumber));
          }
          ptr.ptr = pStepMtx;
        }
      }
    }
  }

  if (!ptr.ptr) {
    CIccPcsStepMpe *pStepMpe = new CIccPcsStepMpe((CIccTagMultiProcessElement*)pMpe->NewCopy());

    if (!pStepMpe)
      return icCmmStatAllocErr;

    if (!pStepMpe->Begin()) {
      delete pStepMpe;
      return icCmmStatBadConnection;
    }

    ptr.ptr = pStepMpe;
  }

  m_list->push_back(ptr);
}

if (!pDstPcc->isStandardPcc()) {

  CIccTagMultiProcessElement *pMpe = pDstPcc->getStandardToCustomPcc();

  if (!pMpe || pMpe->NumInputChannels()!=3 || pMpe->NumOutputChannels()!=3)
    return icCmmStatBadSpaceLink;

  ptr.ptr = NULL__null;

  //push single matrix element as a CIccPcsStepMatrix so it can be optimized
  if (pMpe->NumElements()==1) {
    CIccMultiProcessElement *pElem = pMpe->GetElement(0);
    if (pElem) {
      if (pElem->GetType()==icSigMatrixElemType) {
        CIccMpeMatrix *pMatElem = (CIccMpeMatrix*)pElem;

        icFloatNumber *pMat = pMatElem->GetMatrix();
        icFloatNumber *pOffset = pMatElem->GetConstants();

        if (pMat && (!pOffset || (pOffset[0]==0.0 && pOffset[1]==0.0 && pOffset[2]==0.0))) {
          CIccPcsStepMatrix *pStepMtx = new CIccPcsStepMatrix(3, 3);

          if (pStepMtx ) {
            memcpy(pStepMtx->entry(0,0), pMat, 9*sizeof(icFloatNumber));
          }
          ptr.ptr = pStepMtx;
        }
      }
    }
  }

  if (!ptr.ptr) {
    CIccPcsStepMpe *pStepMpe = new CIccPcsStepMpe((CIccTagMultiProcessElement*)pMpe->NewCopy());

    if (!pStepMpe)
      return icCmmStatAllocErr;

    if (!pStepMpe->Begin()) {
      delete pStepMpe;
      return icCmmStatBadConnection;
    }

    ptr.ptr = pStepMpe;
  }

  m_list->push_back(ptr);
}

if (pFromXform->LuminanceMatching()) {
  pushXyzToXyzLum(pSrcPcc);
}
if (pToXform->LuminanceMatching()) {
  pushXyzLumToXyz(pDstPcc);
}

return icCmmStatOk;
2943}

2945void CIccPcsXform::pushXYZNormalize(IIccProfileConnectionConditions *pPcc, const icSpectralRange &srcRange, const icSpectralRange &dstRange)
2946{
const CIccTagSpectralViewingConditions *pView = pPcc->getPccViewingConditions();
CIccPcsXform tmp;

icSpectralRange illuminantRange;
const icFloatNumber *illuminant = pView->getIlluminant(illuminantRange);

icSpectralRange observerRange;
const icFloatNumber *observer = pView->getObserver(observerRange);

//make sure illuminant goes through identical conversion steps
if (!icSameSpectralRange(srcRange, illuminantRange) || !icSameSpectralRange(dstRange, illuminantRange)) {
  tmp.pushSpecToRange(illuminantRange, srcRange);
  tmp.pushSpecToRange(srcRange, dstRange);
  tmp.pushSpecToRange(dstRange, observerRange);
}
else {
  tmp.pushSpecToRange(illuminantRange, observerRange);
}
tmp.pushMatrix(3, observerRange.steps, observer);

icStatusCMM stat=icCmmStatOk;
CIccApplyXform *pApply = tmp.GetNewApply(stat);
if (pApply) {
  icFloatNumber xyz[3], normxyz[3], pccxyz[3];

  //Get absolute xyz for illuminant and observer
  tmp.Apply(pApply, xyz, illuminant);

  //calculate normalized XYZ
  normxyz[0] = xyz[0] / xyz[1];
  normxyz[1] = xyz[1] / xyz[1];
  normxyz[2] = xyz[2] / xyz[1];

  //get desired XYZ from pcc (might be slightly different from calculated normxyz)
  pPcc->getNormIlluminantXYZ(pccxyz);

2983#if 1
  //push scale factor to normalize XYZ values and correct for difference between calculated and desired XYZ
  pushScale3(pccxyz[0] / (normxyz[0] * xyz[1]), 
             pccxyz[1] / (normxyz[1] * xyz[1]),
             pccxyz[2] / (normxyz[2] * xyz[1]));
2988#else
  pushScale3(1.0f/xyz[1], 1.0f/xyz[1], 1.0f/xyz[1]);
2990#endif

  delete pApply;
}
2994}

2996/**
**************************************************************************
* Name: CIccPcsXform::pushRef2Xyz
* 
* Purpose: 
*  Insert PCS step that convert reflectance to XYZ colorimetry defined by the
*  observer and illuminant accessed through the Profile Connections Conditions
*  handle pPcc.
**************************************************************************
*/
3006void CIccPcsXform::pushRef2Xyz(CIccProfile *pProfile, IIccProfileConnectionConditions *pPcc)
3007{
const CIccTagSpectralViewingConditions *pView = pPcc->getPccViewingConditions();

if (pView) {
  icSpectralRange illuminantRange;
  const icFloatNumber *illuminant = pView->getIlluminant(illuminantRange);

  icSpectralRange observerRange;
  const icFloatNumber *observer = pView->getObserver(observerRange);

  pushSpecToRange(pProfile->m_Header.spectralRange, illuminantRange);
  pushScale(illuminantRange.steps, illuminant);
  pushSpecToRange(illuminantRange, observerRange);
  pushMatrix(3, observerRange.steps, observer);

  pushXYZNormalize(pPcc, illuminantRange, illuminantRange);
}
3024}


3027/**
**************************************************************************
* Name: CIccPcsXform::rangeMap
* 
* Purpose: 
*  This helper function generates a PCS step matrix that can be used to convert
*  spectral vectors from one spectral range to another using linear interpolation.
**************************************************************************
*/
3036CIccPcsStepMatrix *CIccPcsXform::rangeMap(const icSpectralRange &srcRange, const icSpectralRange &dstRange)
3037{
if (srcRange.steps != dstRange.steps ||
    srcRange.start != dstRange.start ||
    srcRange.end != dstRange.end) {
  CIccPcsStepMatrix *mtx = new CIccPcsStepMatrix(dstRange.steps, srcRange.steps);
  if (!mtx->SetRange(srcRange, dstRange))
  {
    delete mtx;
    return NULL__null;
  }
  return mtx;
}

return NULL__null;
3051}


3054/**
**************************************************************************
* Name: CIccPcsXform::pushSpecToRange
* 
* Purpose: 
*  Insert PCS step that res-samples spectral vector data from a source spectral
*  range to a destination spectral range.
**************************************************************************
*/
3063void CIccPcsXform::pushSpecToRange(const icSpectralRange &srcRange, const icSpectralRange &dstRange)
3064{
if (!icSameSpectralRange(srcRange, dstRange)) {
  CIccPcsStepPtr ptr;
  ptr.ptr = rangeMap(srcRange, dstRange);

  if (ptr.ptr)
    m_list->push_back(ptr);
}
3072}


3075/**
**************************************************************************
* Name: CIccPcsXform::pushApplyIllum
* 
* Purpose: 
*  Insert PCS step that applies an illuminant to incoming spectral transmissive
*  vectors to . Illuminant from Profile Connection
*  Conditions will be resampled to match the sampling range of the incoming
*  vectors.
**************************************************************************
*/
3086void CIccPcsXform::pushApplyIllum(CIccProfile *pProfile, IIccProfileConnectionConditions *pPcc)
3087{
const CIccTagSpectralViewingConditions *pView = pPcc->getPccViewingConditions();

if (pView) {
  CIccPcsStepPtr ptr;

  icSpectralRange illuminantRange;
  const icFloatNumber *illuminant = pView->getIlluminant(illuminantRange);

  CIccPcsStepScale *pScale = new CIccPcsStepScale(illuminantRange.steps);
  memcpy(pScale->data(), illuminant, illuminantRange.steps*sizeof(icFloatNumber));

  if (icSameSpectralRange(pProfile->m_Header.spectralRange, illuminantRange)) {
    ptr.ptr = pScale;
    m_list->push_back(ptr);
  }
  else {
    ptr.ptr  = rangeMap(pProfile->m_Header.spectralRange, illuminantRange);
    if (ptr.ptr) {
      m_list->push_back(ptr);
    }

    ptr.ptr = pScale;
    m_list->push_back(ptr);

    ptr.ptr = rangeMap(illuminantRange, pProfile->m_Header.spectralRange);
    if (ptr.ptr)
      m_list->push_back(ptr);
  }
}
3117}


3120/**
**************************************************************************
* Name: CIccPcsXform::pushRad2Xyz
* 
* Purpose: 
*  Insert PCS step that converts from source spectral radiometric vectors to
*  actual XYZ colorimetry based upon observer information in Profile
*  Connection Conditions.
**************************************************************************
*/
3130void CIccPcsXform::pushRad2Xyz(CIccProfile* pProfile, IIccProfileConnectionConditions *pPcc, bool bAbsoluteCIEColorimetry)
3131{
const CIccTagSpectralViewingConditions *pProfView = pProfile ? pProfile->getPccViewingConditions() : NULL__null;
const CIccTagSpectralViewingConditions *pView = pPcc->getPccViewingConditions();
if (pProfView && pView) {
  icSpectralRange illuminantRange;
  const icFloatNumber *illuminant = pView->getIlluminant(illuminantRange);

  icSpectralRange observerRange;
  const icFloatNumber *observer = pView->getObserver(observerRange);

  //Preserve smallest step size
  icFloatNumber dPCSStepSize = (icF16toF(pProfile->m_Header.spectralRange.end) - icF16toF(pProfile->m_Header.spectralRange.start))/(icFloatNumber)pProfile->m_Header.spectralRange.steps;
  icFloatNumber dObsStepSize = (icF16toF(observerRange.end) - icF16toF(observerRange.start)) / (icFloatNumber) observerRange.steps;

  if (dPCSStepSize<dObsStepSize) {
    icFloatNumber *obs = pView->applyRangeToObserver(pProfile->m_Header.spectralRange);

    pushMatrix(3, pProfile->m_Header.spectralRange.steps, obs);
    free(obs);
  }
  else {
    pushSpecToRange(pProfile->m_Header.spectralRange, observerRange);
    pushMatrix(3, observerRange.steps, observer);

  }
  icFloatNumber k;
  if (bAbsoluteCIEColorimetry) {
    k = 683;
  }
  else {
    k = 1.0f / pPcc->getObserverWhiteScaleFactor(illuminant, illuminantRange);
  }
  pushScale3(k, k, k);
}
3165}


3168/**
**************************************************************************
* Name: CIccPcsXform::pushBiRef2Rad
* 
* Purpose: 
*  Insert PCS steps that apply an illuminant to incoming bi-spectral reflectance
*  matrices to get estimate of light "reflected" by surface.
**************************************************************************
*/
3177icStatusCMM CIccPcsXform::pushBiRef2Rad(CIccProfile *pProfile, IIccProfileConnectionConditions *pPcc)
3178{
const CIccTagSpectralViewingConditions *pView = pPcc->getPccViewingConditions();

if (pView) {
  icSpectralRange illuminantRange;
  const icFloatNumber *illuminant = pView->getIlluminant(illuminantRange);

  if (icGetColorSpaceType(pProfile->m_Header.spectralPCS)((icColorSpaceSignature)(((icUInt32Number)pProfile->m_Header
.spectralPCS)&0xffff0000))==icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData)) {
    CIccPcsStepSrcSparseMatrix *pMtx = new CIccPcsStepSrcSparseMatrix(pProfile->m_Header.spectralRange.steps, 
                                                                      pProfile->m_Header.biSpectralRange.steps,
                                                                      (icUInt16Number)icGetSpaceSamples((icColorSpaceSignature)pProfile->m_Header.spectralPCS));
    if (!pMtx)
      return icCmmStatAllocErr;

    CIccPcsStepMatrix *illumMtx = rangeMap(illuminantRange, pProfile->m_Header.biSpectralRange);
    if (illumMtx) {
      illumMtx->Apply(NULL__null, pMtx->data(), illuminant);
      delete illumMtx; 
    }
    else {
      memcpy(pMtx->data(), illuminant, illuminantRange.steps*sizeof(icFloatNumber));
    }

    CIccPcsStepPtr ptr;
    ptr.ptr = pMtx;
    m_list->push_back(ptr);

  }
  else {
    CIccPcsStepSrcMatrix *pMtx = new CIccPcsStepSrcMatrix(pProfile->m_Header.spectralRange.steps, pProfile->m_Header.biSpectralRange.steps);
    if (!pMtx)
      return icCmmStatAllocErr;

    CIccPcsStepMatrix *illumMtx = rangeMap(illuminantRange, pProfile->m_Header.biSpectralRange);
    if (illumMtx) {
      illumMtx->Apply(NULL__null, pMtx->data(), illuminant);
      delete illumMtx; 
    }
    else {
      memcpy(pMtx->data(), illuminant, illuminantRange.steps*sizeof(icFloatNumber));
    }

    CIccPcsStepPtr ptr;
    ptr.ptr = pMtx;
    m_list->push_back(ptr);

  }
}

return icCmmStatOk;
3228}


3231/**
**************************************************************************
* Name: CIccPcsXform::pushBiRef2Xyz
* 
* Purpose: 
*  Insert PCS step that applies an illuminant to incoming bi-spectral reflectance
*  matrices to get actual XYZ values.  The illuminant from the Profile
*  Connection Conditions is re-sampled to match the number of columns in
*  the incoming matrices.
**************************************************************************
*/
3242icStatusCMM CIccPcsXform::pushBiRef2Xyz(CIccProfile *pProfile, IIccProfileConnectionConditions *pPcc)
3243{
icStatusCMM stat = pushBiRef2Rad(pProfile, pPcc);
if (stat!=icCmmStatOk)
  return stat;

const CIccTagSpectralViewingConditions *pView = pPcc->getPccViewingConditions();

if (pView) {
  icSpectralRange observerRange;
  const icFloatNumber *observer = pView->getObserver(observerRange);

  pushSpecToRange(pProfile->m_Header.spectralRange, observerRange);
  pushMatrix(3, observerRange.steps, observer);
  pushXYZNormalize(pPcc, pProfile->m_Header.biSpectralRange, pProfile->m_Header.spectralRange);
}
else {
  return icCmmStatBadConnection;
}

return icCmmStatOk;
3263}


3266/**
**************************************************************************
* Name: CIccPcsXform::pushBiRef2Ref
* 
* Purpose: 
*  Insert PCS steps that apply an illuminant to incoming bi-spectral reflectance
*  matrices and then normalizes by the illuminant to get an estimate of
*  reflectance factor under that illuminant.
**************************************************************************
*/
3276icStatusCMM CIccPcsXform::pushBiRef2Ref(CIccProfile *pProfile, IIccProfileConnectionConditions *pPcc)
3277{
icStatusCMM stat = pushBiRef2Rad(pProfile, pPcc);
if (stat!=icCmmStatOk)
  return stat;

const CIccTagSpectralViewingConditions *pView = pPcc->getPccViewingConditions();

if (pView) {
  icSpectralRange illuminantRange;
  const icFloatNumber *illuminant = pView->getIlluminant(illuminantRange);

  CIccPcsStepScale *pScale = new CIccPcsStepScale(pProfile->m_Header.spectralRange.steps);

  if (pScale) {
    icFloatNumber *pData = pScale->data();
    CIccPcsStepMatrix *illumMtx = rangeMap(illuminantRange, pProfile->m_Header.spectralRange);
    int i;

    if (illumMtx) {
      illumMtx->Apply(NULL__null, pData, illuminant);
      for (i=0; i<pProfile->m_Header.spectralRange.steps; i++)
        pData[i] = 1.0f / pData[i];

      delete illumMtx;

      CIccPcsStepPtr ptr;
      ptr.ptr = pScale;
      m_list->push_back(ptr);
    }
    else {
      for (i=0; i<pProfile->m_Header.spectralRange.steps; i++) {
        pData[i] = 1.0f / illuminant[i];
      }
    }
  }
  else
    return icCmmStatAllocErr;
}
else
  return icCmmStatBadConnection;

return icCmmStatOk;
3319}


3322#ifdef _DEBUG
3323//#define DUMPCSSTEPRESULTS
3324#ifdef DUMPCSSTEPRESULTS
#define ICCDUMPPIXEL(n, pix) \
if ((n)<96) { \
  printf("["); \
  int i; \
  for (i=0; i<(n); i++) { \
    if (i && !(i%12)) \
      printf("...\n"); \
    printf(" %.5f", pix[i]); \
  } \
  printf("]\n"); \
} \
else { \
  printf("[ BigAray with %d elements]\n", (n)); \
}
3339#else
#define ICCDUMPPIXEL(n, pix)
3341#endif
3342#else
#define ICCDUMPPIXEL(n, pix)
3344#endif


3347/**
3348**************************************************************************
3349* Name: CIccPcsXform::Apply
3350* 
3351* Purpose: 
3352*  Applies the PcsXfrom steps using the apply pXform data to SrcPixel to get DstPixel
3353**************************************************************************
3354*/
3355void CIccPcsXform::Apply(CIccApplyXform *pXform, icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
3356{
CIccApplyPcsXform *pApplyXform = (CIccApplyPcsXform*)pXform;
CIccApplyPcsStepList *pList = pApplyXform->m_list;

ICCDUMPPIXEL(GetNumSrcSamples(), SrcPixel);

if (!pList) {
  memcpy(DstPixel, SrcPixel, GetNumSrcSamples()*sizeof(icFloatNumber));
  ICCDUMPPIXEL(GetNumSrcSamples(), DstPixel);
  return;
}

CIccApplyPcsStepList::iterator s, n;
s = n =pList->begin();

if (s==pList->end()) {
  memcpy(DstPixel, SrcPixel, GetNumSrcSamples()*sizeof(icFloatNumber));
  ICCDUMPPIXEL(GetNumSrcSamples(), DstPixel);
  return;
}

n++;

if (n==pList->end()) {
  s->ptr->Apply(DstPixel, SrcPixel);
  ICCDUMPPIXEL(s->ptr->GetStep()->GetDstChannels(), DstPixel);
}
else {
  const icFloatNumber *src = SrcPixel;
  icFloatNumber *p1 = pApplyXform->m_temp1;
  icFloatNumber *p2 = pApplyXform->m_temp2;
  icFloatNumber *t;

  for (;n!=pList->end(); s=n, n++) {
    s->ptr->Apply(p1, src);
    ICCDUMPPIXEL(s->ptr->GetStep()->GetDstChannels(), p1);
    src=p1;
    t=p1; p1=p2; p2=t;
  }
  s->ptr->Apply(DstPixel, src);
  ICCDUMPPIXEL(s->ptr->GetStep()->GetDstChannels(), DstPixel);
}
3398}

3400/**
3401**************************************************************************
3402* Name: CIccPcsStep::GetNewApply
3403* 
3404* Purpose: 
3405*  Allocates a new CIccApplyPcsStep to be used with processing.
3406**************************************************************************
3407*/
3408CIccApplyPcsStep* CIccPcsStep::GetNewApply()
3409{
return new CIccApplyPcsStep(this);
3411}


3414/**
3415**************************************************************************
3416* Name: CIccPcsStepIdentity::Apply
3417* 
3418* Purpose: 
3419*  Copies pSrc to pDst
3420**************************************************************************
3421*/
3422void CIccPcsStepIdentity::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
3423{
if (pDst != pSrc)
  memcpy(pDst, pSrc, m_nChannels*sizeof(icFloatNumber));
3426}


3429/**
3430**************************************************************************
3431* Name: CIccPcsStepIdentity::dump
3432* 
3433* Purpose: 
3434*  dumps the context of the step
3435**************************************************************************
3436*/
3437void CIccPcsStepIdentity::dump(std::string &str) const
3438{
str += "\nCIccPcsStepIdentity\n\n";
3440}


3443/**
3444**************************************************************************
3445* Name: CIccPcsStepIdentity::CIccPcsStepIdentity
3446* 
3447* Purpose: 
3448*  Constructor
3449**************************************************************************
3450*/
3451CIccPcsStepRouteMcs::CIccPcsStepRouteMcs(CIccTagArray *pSrcChannels, CIccTagArray *pDstChannels, CIccTagNumArray *pDefaults)
3452{
m_nSrcChannels = (icUInt16Number)pSrcChannels->GetSize();
m_nDstChannels = (icUInt16Number)pDstChannels->GetSize();
m_Index = new int[m_nDstChannels];
m_Defaults = new icFloatNumber[m_nDstChannels];

memset(m_Defaults, 0, m_nDstChannels*sizeof(icFloatNumber));

if (pDefaults) {
  pDefaults->GetValues(m_Defaults, 0, m_nDstChannels);
}

int i, j;
char *szSrc;

for (i=0; i<m_nDstChannels; i++) {
  const icUChar *szDstChan = ((CIccTagUtf8Text*)(pDstChannels->GetIndex(i)))->GetText();
  for (j=0; j<m_nSrcChannels; j++) {
    const icUChar *szSrcChan = ((CIccTagUtf8Text*)(pSrcChannels->GetIndex(j)))->GetText();
    szSrc = (char*)szSrcChan;
    if (!icUtf8StrCmp(szDstChan, szSrcChan)strcmp((const char*)szDstChan, (const char*)szSrcChan))
      break;
  }
  if (j==m_nSrcChannels) {
    m_Index[i] = -1;
  }
  else {
    m_Index[i] = j;
  }
  //printf("%d - %d %s\n", m_Index[i], i, szDstChan);
}
3483}


3486/**
3487**************************************************************************
3488* Name: CIccPcsStepIdentity::~CIccPcsStepIdentity
3489* 
3490* Purpose: 
3491*  Destructor
3492**************************************************************************
3493*/
3494CIccPcsStepRouteMcs::~CIccPcsStepRouteMcs()
3495{
if (m_Index)
  delete [] m_Index;
if (m_Defaults)
  delete [] m_Defaults;
3500}


3503/**
3504**************************************************************************
3505* Name: CIccPcsStepRouteMcs::isIdentity
3506* 
3507* Purpose: 
3508*  Determines if applying this step will result in negligible change in data
3509**************************************************************************
3510*/
3511bool CIccPcsStepRouteMcs::isIdentity() const
3512{
if (m_nSrcChannels!=m_nDstChannels)
  return false;

int i;
for (i=0; i<m_nDstChannels; i++) {
  if (m_Index[i]!=i)
    return false;
}

return true;
3523}



3527/**
3528**************************************************************************
3529* Name: CIccPcsStepRouteMcs::Apply
3530* 
3531* Purpose: 
3532*  Copies pSrc to pDst
3533**************************************************************************
3534*/
3535void CIccPcsStepRouteMcs::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
3536{
if (pDst != pSrc) {
  int i;
  for (i=0; i<m_nDstChannels; i++) {
    if (m_Index[i]>=0)
      pDst[i] = pSrc[m_Index[i]];
    else
      pDst[i] = m_Defaults[i];
  }
}
3546}


3549/**
3550**************************************************************************
3551* Name: CIccPcsStepRouteMcs::dump
3552* 
3553* Purpose: 
3554*  dumps the context of the step
3555**************************************************************************
3556*/
3557void CIccPcsStepRouteMcs::dump(std::string &str) const
3558{
str += "\nCIccPcsStepRouteMcs\n\n";
3560}

3562extern icFloatNumber icD50XYZ[3];

3564/**
3565**************************************************************************
3566* Name: CIccPcsLabStep::isSameWhite
3567* 
3568* Purpose: 
3569*  Determines if this step has same white point as that passed in
3570**************************************************************************
3571*/
3572bool CIccPcsLabStep::isSameWhite(const icFloatNumber *xyzWhite)
3573{
return (m_xyzWhite[0]==xyzWhite[0] &&
        m_xyzWhite[1]==xyzWhite[1] &&
        m_xyzWhite[2]==xyzWhite[2]);
3577}



3581/**
3582**************************************************************************
3583* Name: CIccPcsStepLabToXYZ::CIccPcsStepLabToXYZ
3584* 
3585* Purpose: 
3586*  Constructor
3587**************************************************************************
3588*/
3589CIccPcsStepLabToXYZ::CIccPcsStepLabToXYZ(const icFloatNumber *xyzWhite/*=NULL*/)
3590{
if (xyzWhite) {
  memcpy(m_xyzWhite, xyzWhite, sizeof(m_xyzWhite));
}
else {
  memcpy(m_xyzWhite, icD50XYZ, sizeof(m_xyzWhite));
}
3597}


3600/**
3601**************************************************************************
3602* Name: CIccPcsStepLabToXYZ::Apply
3603* 
3604* Purpose: 
3605*  Converts from V4 Internal Lab to actual XYZ
3606**************************************************************************
3607*/
3608void CIccPcsStepLabToXYZ::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
3609{
icFloatNumber Lab[3];

//lab4 to XYZ
Lab[0] = pSrc[0] * 100.0f;
Lab[1] = (icFloatNumber)(pSrc[1]*255.0f - 128.0f);
Lab[2] = (icFloatNumber)(pSrc[2]*255.0f - 128.0f);

icLabtoXYZ(pDst, Lab, m_xyzWhite);
3618}


3621/**
3622**************************************************************************
3623* Name: CIccPcsStepLabToXYZ::dump
3624* 
3625* Purpose: 
3626*  dumps the context of the step
3627**************************************************************************
3628*/
3629void CIccPcsStepLabToXYZ::dump(std::string &str) const
3630{
str += "\nCIccPcsStepLabToXYZ\n\n";
3632}


3635/**
3636**************************************************************************
3637* Name: CIccPcsStepLabToXYZ::concat
3638* 
3639* Purpose: 
3640*  Determines if this step can be combined with the next step.
3641*  Checks if next step is an icPcsStepXyzToLab step resulting in a combined
3642*  identity transform.
3643**************************************************************************
3644*/
3645CIccPcsStep *CIccPcsStepLabToXYZ::concat(CIccPcsStep *pNext) const
3646{
if (pNext && pNext->GetType()==icPcsStepXYZToLab) {
  CIccPcsLabStep *pStep = (CIccPcsLabStep *)pNext;
  if (pStep->isSameWhite(m_xyzWhite))
    return new CIccPcsStepIdentity(3);
}
return NULL__null;
3653}


3656/**
3657**************************************************************************
3658* Name: CIccPcsStepXYZToLab::CIccPcsStepXYZToLab
3659* 
3660* Purpose: 
3661*  Constructor
3662**************************************************************************
3663*/
3664CIccPcsStepXYZToLab::CIccPcsStepXYZToLab(const icFloatNumber *xyzWhite/*=NULL*/)
3665{
if (xyzWhite) {
  memcpy(m_xyzWhite, xyzWhite, sizeof(m_xyzWhite));
}
else {
  memcpy(m_xyzWhite, icD50XYZ, sizeof(m_xyzWhite));
}
3672}


3675/**
3676**************************************************************************
3677* Name: CIccPcsStepXYZToLab::Apply
3678* 
3679* Purpose: 
3680*  Converts from actual XYZ to V4 Internal Lab
3681**************************************************************************
3682*/
3683void CIccPcsStepXYZToLab::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
3684{
icFloatNumber Lab[3];
icXYZtoLab(Lab, (icFloatNumber*)pSrc, m_xyzWhite);
//lab4 from XYZ
pDst[0] = Lab[0] / 100.0f;
pDst[1] = (icFloatNumber)((Lab[1] + 128.0f) / 255.0f);
pDst[2] = (icFloatNumber)((Lab[2] + 128.0f) / 255.0f);
3691}


3694/**
3695**************************************************************************
3696* Name: CIccPcsStepXYZToLab::dump
3697* 
3698* Purpose: 
3699*  dumps the context of the step
3700**************************************************************************
3701*/
3702void CIccPcsStepXYZToLab::dump(std::string &str) const
3703{
str += "\nCIccPcsStepXYZToLab\n\n";
3705}


3708/**
3709**************************************************************************
3710* Name: CIccPcsStepXYZToLab::concat
3711* 
3712* Purpose: 
3713*  Determines if this step can be combined with the next step.
3714*  Checks if next step is an icPcsStepLabToXYZ step resulting in a combined
3715*  identity transform.
3716**************************************************************************
3717*/
3718CIccPcsStep *CIccPcsStepXYZToLab::concat(CIccPcsStep *pNext) const
3719{
if (pNext && pNext->GetType()==icPcsStepLabToXYZ) {
  CIccPcsLabStep *pStep = (CIccPcsLabStep *)pNext;
  if (pStep->isSameWhite(m_xyzWhite))
    return new CIccPcsStepIdentity(3);
}
return NULL__null;
3726}


3729/**
3730**************************************************************************
3731* Name: CIccPcsStepLab2ToXYZ::CIccPcsStepLab2ToXYZ
3732* 
3733* Purpose: 
3734*  Constructor
3735**************************************************************************
3736*/
3737CIccPcsStepLab2ToXYZ::CIccPcsStepLab2ToXYZ(const icFloatNumber *xyzWhite/*=NULL*/)
3738{
if (xyzWhite) {
  memcpy(m_xyzWhite, xyzWhite, sizeof(m_xyzWhite));
}
else {
  memcpy(m_xyzWhite, icD50XYZ, sizeof(m_xyzWhite));
}
3745}

3747/**
3748**************************************************************************
3749* Name: CIccPcsStepLab2ToXYZ::Apply
3750* 
3751* Purpose: 
3752*  Converts from actual XYZ to V2 Internal Lab
3753**************************************************************************
3754*/
3755void CIccPcsStepLab2ToXYZ::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
3756{
icFloatNumber Lab[3];

//lab2 to XYZ
Lab[0] = pSrc[0] * (65535.0f / 65280.0f) * 100.0f;
Lab[1] = (icFloatNumber)(pSrc[1] * 65535.0f / 65280.0f * 255.0f - 128.0f);
Lab[2] = (icFloatNumber)(pSrc[2] * 65535.0f / 65280.0f * 255.0f - 128.0f);

icLabtoXYZ(pDst, Lab, m_xyzWhite);
3765}


3768/**
3769**************************************************************************
3770* Name: CIccPcsStepLab2ToXYZ::dump
3771* 
3772* Purpose: 
3773*  dumps the context of the step
3774**************************************************************************
3775*/
3776void CIccPcsStepLab2ToXYZ::dump(std::string &str) const
3777{
str += "\nCIccPcsStepLab2ToXYZ\n\n";
3779}


3782/**
3783**************************************************************************
3784* Name: CIccPcsStepLab2ToXYZ::concat
3785* 
3786* Purpose: 
3787*  Determines if this step can be combined with the next step.
3788*  Checks if next step is an icPcsStepXYZToLab2 step resulting in a combined
3789*  identity transform.
3790**************************************************************************
3791*/
3792CIccPcsStep *CIccPcsStepLab2ToXYZ::concat(CIccPcsStep *pNext) const
3793{
if (pNext && pNext->GetType()==icPcsStepXYZToLab2) {
  CIccPcsLabStep *pStep = (CIccPcsLabStep *)pNext;
  if (pStep->isSameWhite(m_xyzWhite))
    return new CIccPcsStepIdentity(3);
}
return NULL__null;
3800}


3803/**
3804**************************************************************************
3805* Name: CIccPcsStepXYZToLab2::CIccPcsStepXYZToLab2
3806* 
3807* Purpose: 
3808*  Constructor
3809**************************************************************************
3810*/
3811CIccPcsStepXYZToLab2::CIccPcsStepXYZToLab2(const icFloatNumber *xyzWhite/*=NULL*/)
3812{
if (xyzWhite) {
  memcpy(m_xyzWhite, xyzWhite, sizeof(m_xyzWhite));
}
else {
  memcpy(m_xyzWhite, icD50XYZ, sizeof(m_xyzWhite));
}
3819}


3822/**
3823**************************************************************************
3824* Name: CIccPcsStepXYZToLab2::Apply
3825* 
3826* Purpose: 
3827*  Converts from V2 Internal Lab to actual XYZ
3828**************************************************************************
3829*/
3830void CIccPcsStepXYZToLab2::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
3831{
icFloatNumber Lab[3];
icXYZtoLab(Lab, (icFloatNumber*)pSrc, m_xyzWhite);
//lab2 from XYZ
pDst[0] = (Lab[0] / 100.0f) * (65280.0f / 65535.0f);
pDst[1] = (icFloatNumber)((Lab[1] + 128.0f) / 255.0f) * (65280.0f / 65535.0f);
pDst[2] = (icFloatNumber)((Lab[2] + 128.0f) / 255.0f) * (65280.0f / 65535.0f);
3838}


3841/**
3842**************************************************************************
3843* Name: CIccPcsStepXYZToLab2::dump
3844* 
3845* Purpose: 
3846*  dumps the context of the step
3847**************************************************************************
3848*/
3849void CIccPcsStepXYZToLab2::dump(std::string &str) const
3850{
str += "\nCIccPcsStepXYZToLab2\n\n";
3852}


3855/**
3856**************************************************************************
3857* Name: CIccPcsStepXYZToLab2::concat
3858* 
3859* Purpose: 
3860*  Determines if this step can be combined with the next step.
3861*  Checks if next step is an icPcsStepLab2ToXYZ step resulting in a combined
3862*  identity transform.
3863**************************************************************************
3864*/
3865CIccPcsStep *CIccPcsStepXYZToLab2::concat(CIccPcsStep *pNext) const
3866{
if (pNext && pNext->GetType()==icPcsStepLab2ToXYZ) {
  CIccPcsLabStep *pStep = (CIccPcsLabStep *)pNext;
  if (pStep->isSameWhite(m_xyzWhite))
    return new CIccPcsStepIdentity(3);
}
return NULL__null;
3873}


3876/**
3877**************************************************************************
3878* Name: CIccPcsStepOffset::CIccPcsStepOffset
3879* 
3880* Purpose: 
3881*  Constructor
3882**************************************************************************
3883*/
3884CIccPcsStepOffset::CIccPcsStepOffset(icUInt16Number nChannels)
3885{
m_nChannels = nChannels;
m_vals = new icFloatNumber[nChannels];
3888}


3891/**
3892**************************************************************************
3893* Name: CIccPcsStepOffset::CIccPcsStepOffset
3894* 
3895* Purpose: 
3896*  Destructor
3897**************************************************************************
3898*/
3899CIccPcsStepOffset::~CIccPcsStepOffset()
3900{
if (m_vals)
  delete m_vals;
3903}


3906/**
3907**************************************************************************
3908* Name: CIccPcsStepOffset::Apply
3909* 
3910* Purpose: 
3911*  Added a fixed offset to the pSrc vector passed in
3912**************************************************************************
3913*/
3914void CIccPcsStepOffset::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
3915{
if (m_nChannels==3) {
  pDst[0] = m_vals[0] + pSrc[0];
  pDst[1] = m_vals[1] + pSrc[1];
  pDst[2] = m_vals[2] + pSrc[2];
}
else {
  int i;
  for (i=0; i<m_nChannels; i++) {
    pDst[i] = m_vals[i] + pSrc[i];
  }
}
3927}


3930/**
3931**************************************************************************
3932* Name: CIccPcsStepOffset::dump
3933* 
3934* Purpose: 
3935*  dumps the context of the step
3936**************************************************************************
3937*/
3938void CIccPcsStepOffset::dump(std::string &str) const
3939{
str += "\nCIccPcsStepOffset\n\n";
char buf[80];
for (int i=0; i<m_nChannels; i++) {
  sprintf(buf, ICCPCSSTEPDUMPFMT" %.8f", m_vals[i]);
  str += buf;
}
str +="\n";
3947}


3950/**
3951**************************************************************************
3952* Name: CIccPcsStepOffset::Apply
3953* 
3954* Purpose: 
3955*  Creates a new CIccPcsStepOffet step that is the result of adding the
3956*  offset of this object to the offset of another object.
3957**************************************************************************
3958*/
3959CIccPcsStepOffset *CIccPcsStepOffset::Add(const CIccPcsStepOffset *offset) const
3960{
if (offset->m_nChannels != m_nChannels)
  return NULL__null;

CIccPcsStepOffset *pNew = new CIccPcsStepOffset(m_nChannels);

if (pNew) {
  int i;
  for (i=0; i<m_nChannels; i++) {
    pNew->m_vals[i] = m_vals[i] + offset->m_vals[i]; 
  }
}

return pNew;
3974}

3976/**
3977**************************************************************************
3978* Name: CIccPcsStepOffset::concat
3979* 
3980* Purpose: 
3981*  Determines if this step can be combined with the next step.
3982*  Checks if next step is a compatible icPcsStepOffset step resulting in a 
3983*  single combined offset.
3984**************************************************************************
3985*/
3986CIccPcsStep *CIccPcsStepOffset::concat(CIccPcsStep *pNext) const
3987{
if (pNext && pNext->GetType()==icPcsStepOffset && m_nChannels==pNext->GetSrcChannels())
  return Add((const CIccPcsStepOffset*)pNext);

return NULL__null;
3992}


3995/**
3996**************************************************************************
3997* Name: CIccPcsStepOffset::isIdentity
3998* 
3999* Purpose: 
4000*  Determines if applying this step will result in negligible change in data
4001**************************************************************************
4002*/
4003bool CIccPcsStepOffset::isIdentity() const
4004{
int i;
for (i=0; i<m_nChannels; i++) {
  if (m_vals[i]<-icNearRange0.000001 || m_vals[i]>icNearRange0.000001)
    return false;
}

return true;
4012}


4015/**
4016**************************************************************************
4017* Name: CIccPcsStepScale::CIccPcsStepScale
4018* 
4019* Purpose: 
4020*  Constructor
4021**************************************************************************
4022*/
4023CIccPcsStepScale::CIccPcsStepScale(icUInt16Number nChannels)
4024{
m_nChannels = nChannels;
m_vals = new icFloatNumber[nChannels];
4027}


4030/**
4031**************************************************************************
4032* Name: CIccPcsStepScale::~CIccPcsStepScale
4033* 
4034* Purpose: 
4035*  Destructor
4036**************************************************************************
4037*/
4038CIccPcsStepScale::~CIccPcsStepScale()
4039{
if (m_vals)
  delete m_vals;
4042}

4044/**
4045**************************************************************************
4046* Name: CIccPcsStepScale::Apply
4047* 
4048* Purpose: 
4049*  Multiplies fixed scale values to the pSrc vector passed in
4050**************************************************************************
4051*/
4052void CIccPcsStepScale::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
4053{
if (m_nChannels==3) {
  pDst[0] = m_vals[0] * pSrc[0];
  pDst[1] = m_vals[1] * pSrc[1];
  pDst[2] = m_vals[2] * pSrc[2];
}
else {
  int i;
  for (i=0; i<m_nChannels; i++) {
    pDst[i] = m_vals[i] * pSrc[i];
  }
}
4065}


4068/**
4069**************************************************************************
4070* Name: CIccPcsStepScale::dump
4071* 
4072* Purpose: 
4073*  dumps the context of the step
4074**************************************************************************
4075*/
4076void CIccPcsStepScale::dump(std::string &str) const
4077{
str += "\nCIccPcsStepScale\n\n";
char buf[80];
for (int i=0; i<m_nChannels; i++) {
  sprintf(buf, ICCPCSSTEPDUMPFMT" %.8f", m_vals[i]);
  str += buf;
}
str +="\n";
4085}


4088/**
4089**************************************************************************
4090* Name: CIccPcsStepScale::Mult
4091* 
4092* Purpose: 
4093*  Creates a new CIccPcsStepScale step that is the result of multiplying the
4094*  scale of this object to the scale of another object.
4095**************************************************************************
4096*/
4097CIccPcsStepScale *CIccPcsStepScale::Mult(const CIccPcsStepScale *scale) const
4098{
if (scale->m_nChannels != m_nChannels)
  return NULL__null;

CIccPcsStepScale *pNew = new CIccPcsStepScale(m_nChannels);

if (pNew) {
  int i;
  for (i=0; i<m_nChannels; i++) {
    pNew->m_vals[i] = m_vals[i] * scale->m_vals[i]; 
  }
}
return pNew;
4111}

4113/**
4114**************************************************************************
4115* Name: CIccPcsStepScale::Mult
4116* 
4117* Purpose: 
4118*  Creates a new CIccPcsStepMatrix step that is the result of multiplying the
4119*  scale of this object to the scale of another matrix.
4120**************************************************************************
4121*/
4122CIccPcsStepMatrix *CIccPcsStepScale::Mult(const CIccPcsStepMatrix *matrix) const
4123{
if (matrix->GetSrcChannels() != m_nChannels)
  return NULL__null;

CIccPcsStepMatrix *pNew = new CIccPcsStepMatrix(matrix->GetDstChannels(), matrix->GetSrcChannels());

if (pNew) {
  int i, j;
  for (j=0; j<matrix->GetDstChannels(); j++) {
    const icFloatNumber *row = matrix->entry(j);
    icFloatNumber *to=pNew->entry(j);

    for (i=0; i<m_nChannels; i++) {
      to[i] = m_vals[i] * row[i]; 
    }
  }
}

return pNew;
4142}

4144/**
4145**************************************************************************
4146* Name: CIccPcsStepScale::Mult
4147*
4148* Purpose:
4149*  Creates a new CIccPcsStepMatrix step that is the result of multiplying the
4150*  scale of this object to the scale of another matrix.
4151**************************************************************************
4152*/
4153CIccPcsStepMatrix *CIccPcsStepScale::Mult(const CIccMpeMatrix *matrix) const
4154{
if (matrix->NumInputChannels() != m_nChannels)
  return NULL__null;

CIccPcsStepMatrix *pNew = new CIccPcsStepMatrix(matrix->NumOutputChannels(), matrix->NumInputChannels());

if (pNew) {
  int i, j;
  icFloatNumber *mtx = matrix->GetMatrix();
  for (j = 0; j < matrix->NumOutputChannels(); j++) {
    const icFloatNumber *row = &mtx[j*matrix->NumInputChannels()];
    icFloatNumber *to = pNew->entry(j);

    for (i = 0; i < m_nChannels; i++) {
      to[i] = m_vals[i] * row[i];
    }
  }
}

return pNew;
4174}


4177/**
4178**************************************************************************
4179* Name: CIccPcsStepScale::concat
4180* 
4181* Purpose: 
4182*  Determines if this step can be combined with the next step.
4183*  Checks if next step is a compatible icPcsStepScale or icPcsStepMatrix step
4184*  resulting in a single combined object.
4185**************************************************************************
4186*/
4187CIccPcsStep *CIccPcsStepScale::concat(CIccPcsStep *pNext) const
4188{
if (pNext) {
  if (pNext->GetType()==icPcsStepScale && m_nChannels==pNext->GetSrcChannels())
    return Mult((const CIccPcsStepScale*)pNext);
  if (pNext->GetType()==icPcsStepMatrix && m_nChannels==pNext->GetSrcChannels())
    return Mult((const CIccPcsStepMatrix*)pNext);
  if (pNext->GetType() == icPcsStepMpe && m_nChannels == pNext->GetSrcChannels()) {
    CIccPcsStepMpe *pMpe = (CIccPcsStepMpe*)pNext;
    CIccMpeMatrix *pMatrix = pMpe->GetMatrix();
    if (pMatrix)
      return Mult(pMatrix);
  }
}

return NULL__null;
4203}


4206/**
4207**************************************************************************
4208* Name: CIccPcsStepScale::isIdentity
4209* 
4210* Purpose: 
4211*  Determines if applying this step will result in negligible change in data
4212**************************************************************************
4213*/
4214bool CIccPcsStepScale::isIdentity() const
4215{
int i;
for (i=0; i<m_nChannels; i++) {
  if (m_vals[i]<1.0f-icNearRange0.000001 || m_vals[i]>1.0f+icNearRange0.000001)
    return false;
}

return true;
4223}



4227/**
4228**************************************************************************
4229* Name: CIccPcsStepMatrix::dump
4230* 
4231* Purpose: 
4232*  dumps the context of the step
4233**************************************************************************
4234*/
4235void CIccPcsStepMatrix::dump(std::string &str) const
4236{
str += "\nCIccPcsStepMatrix\n\n";
dumpMtx(str);
4239}


4242/**
4243**************************************************************************
4244* Name: CIccPcsStepMatrix::Mult
4245* 
4246* Purpose: 
4247*  Creates a new CIccPcsStepMatrix step that is the result of multiplying the
4248*  matrix of this object to the scale of another object.
4249**************************************************************************
4250*/
4251CIccPcsStepMatrix *CIccPcsStepMatrix::Mult(const CIccPcsStepScale *scale) const
4252{
icUInt16Number mCols = scale->GetSrcChannels();
icUInt16Number mRows = mCols;

if (m_nRows != mCols)
  return NULL__null;

CIccPcsStepMatrix *pNew = new CIccPcsStepMatrix(m_nRows, m_nCols);
const icFloatNumber *data = scale->data();

int i, j;
for (j=0; j<m_nRows; j++) {
  const icFloatNumber *row = entry(j);
  icFloatNumber *to = pNew->entry(j);
  for (i=0; i<m_nCols; i++) {
    to[i] = data[j] * row[i];
  }
}

return pNew;
4272}

4274/**
4275**************************************************************************
4276* Name: CIccPcsStepMatrix::Mult
4277* 
4278* Purpose: 
4279*  Creates a new CIccPcsStepMatrix step that is the result of concatentating
4280*  another matrix with this matrix. (IE result = matrix * this).
4281**************************************************************************
4282*/
4283CIccPcsStepMatrix *CIccPcsStepMatrix::Mult(const CIccPcsStepMatrix *matrix) const
4284{
icUInt16Number mCols = matrix->m_nCols;
icUInt16Number mRows = matrix->m_nRows;

if (m_nRows != mCols)
  return NULL__null;

CIccPcsStepMatrix *pNew = new CIccPcsStepMatrix(mRows, m_nCols);

int i, j, k;
for (j=0; j<mRows; j++) {
  const icFloatNumber *row = matrix->entry(j);
  for (i=0; i<m_nCols; i++) {
    icFloatNumber *to = pNew->entry(j, i);
    const icFloatNumber *from = entry(0, i);

    *to = 0.0f;
    for (k=0; k<m_nRows; k++) {
      *to += row[k] * (*from);
      from += m_nCols;
    }
  }
}

return pNew;
4309}


4312/**
4313**************************************************************************
4314* Name: CIccPcsStepMatrix::concat
4315* 
4316* Purpose: 
4317*  Determines if this step can be combined with the next step.
4318*  Checks if next step is a compatible icPcsStepScale or icPcsStepMatrix step
4319*  resulting in a single combined object.
4320**************************************************************************
4321*/
4322CIccPcsStep *CIccPcsStepMatrix::concat(CIccPcsStep *pNext) const
4323{
if (pNext) {
  if (pNext->GetType()==icPcsStepScale && GetDstChannels()==pNext->GetSrcChannels())
    return Mult((const CIccPcsStepScale*)pNext);
  if (pNext->GetType()==icPcsStepMatrix && GetDstChannels()==pNext->GetSrcChannels())
    return Mult((const CIccPcsStepMatrix*)pNext);
}

return NULL__null;
4332}

4334/**
4335**************************************************************************
4336* Name: CIccPcsStepMatrix::concat
4337* 
4338* Purpose: 
4339*  Determines if this step can be combined with the next step.
4340*  Checks if next step is a compatible icPcsStepScale or icPcsStepMatrix step
4341*  resulting in a single combined object.
4342**************************************************************************
4343*/
4344CIccPcsStep *CIccPcsStepMatrix::reduce() const
4345{
int nVals = m_nRows*m_nCols;
int nNonZeros = 0;
int i;

for (i=0; i<nVals; i++) {
  icFloatNumber v = m_vals[i];
  if (icNotZero(v)((v)>1.0e-8 || (v)<-1.0e-8))
    nNonZeros++;
}
if (nNonZeros<nVals*3/4) {
  icUInt32Number nMatrixBytes = CIccSparseMatrix::MemSize(nNonZeros, m_nRows, sizeof(icFloatNumber))+4*sizeof(icFloatNumber);
  CIccPcsStepSparseMatrix *pMtx = new CIccPcsStepSparseMatrix(m_nRows, m_nCols, nMatrixBytes);
  CIccSparseMatrix mtx(pMtx->data(), nMatrixBytes);
  mtx.Init(m_nRows, m_nCols, true);
  mtx.FillFromFullMatrix(m_vals);
  return pMtx;
}

return (CIccPcsStep*)this;
4365}



4369/**
4370**************************************************************************
4371* Name: CIccPcsStepMpe::CIccPcsStepMpe
4372* 
4373* Purpose: 
4374*  Constructor
4375**************************************************************************
4376*/
4377CIccPcsStepMpe::CIccPcsStepMpe(CIccTagMultiProcessElement *pMpe)
4378{
m_pMpe = pMpe;
4380}


4383/**
4384**************************************************************************
4385* Name: CIccPcsStepMpe::~CIccPcsStepMpe
4386* 
4387* Purpose: 
4388*  Destructor
4389**************************************************************************
4390*/
4391CIccPcsStepMpe::~CIccPcsStepMpe()
4392{
if (m_pMpe)
  delete m_pMpe;
4395}


4398/**
4399**************************************************************************
4400* Name: CIccPcsStepMpe::GetNewApply
4401* 
4402* Purpose: 
4403*  Allocates a new CIccApplyPcsStep to be used with processing.
4404**************************************************************************
4405*/
4406CIccApplyPcsStep* CIccPcsStepMpe::GetNewApply()
4407{
CIccApplyPcsStepMpe *rv = new CIccApplyPcsStepMpe(this, m_pMpe->GetNewApply());

return rv;
4411}


4414/**
4415**************************************************************************
4416* Name: CIccPcsStepMpe::Apply
4417* 
4418* Purpose: 
4419*  Applies a MultiProcessingElement to a Source vector to get a Dest vector
4420**************************************************************************
4421*/
4422void CIccPcsStepMpe::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
4423{
CIccApplyPcsStepMpe *pMpeApply = (CIccApplyPcsStepMpe*)pApply;

m_pMpe->Apply(pMpeApply->m_pApply, pDst, pSrc);
4427}


4430/**
4431**************************************************************************
4432* Name: CIccPcsStepMpe::dump
4433* 
4434* Purpose: 
4435*  dumps the context of the step
4436**************************************************************************
4437*/
4438void CIccPcsStepMpe::dump(std::string &str) const
4439{
str += "\nCIccPcsStepMpe\n\n";
m_pMpe->Describe(str);
4442}


4445/**
4446**************************************************************************
4447* Name: CIccPcsStepMpe::isIdentity
4448* 
4449* Purpose: 
4450*  Determines if applying this step will obviously result in no change in data
4451**************************************************************************
4452*/
4453bool CIccPcsStepMpe::isIdentity() const
4454{
if (!m_pMpe || !m_pMpe->NumElements())
  return true;
return false;
4458}

4460/**
4461**************************************************************************
4462* Name: CIccPcsStepMpe::GetSrcChannels
4463* 
4464* Purpose: 
4465*  Returns the number of channels of data required going into the multi-
4466*  processing element
4467**************************************************************************
4468*/
4469icUInt16Number CIccPcsStepMpe::GetSrcChannels() const
4470{
return m_pMpe->NumInputChannels();
4472}


4475/**
4476**************************************************************************
4477* Name: CIccPcsStepMpe::GetDstChannels
4478* 
4479* Purpose: 
4480*  Returns the number of channels of data coming out of the multi-
4481*  processing element
4482**************************************************************************
4483*/
4484icUInt16Number CIccPcsStepMpe::GetDstChannels() const
4485{
return m_pMpe->NumOutputChannels();
4487}


4490/**
4491**************************************************************************
4492* Name: CIccPcsStepMpe::GetMatrix()
4493*
4494* Purpose:
4495*  Returns single CIccMpeMatrix element associated with PCS step or
4496*  NULL if the MPE is more complex
4497**************************************************************************
4498*/
4499CIccMpeMatrix *CIccPcsStepMpe::GetMatrix() const
4500{
//Must be single element
if (m_pMpe->NumElements() == 1) {
  CIccMultiProcessElement *pElem = m_pMpe->GetElement(0);
  //Must be a matrix
  if (pElem && pElem->GetType() == icSigMatrixElemType) {
    CIccMpeMatrix *pMtx = (CIccMpeMatrix*)pElem;

    //Should not apply any constants
    if (!pMtx->GetConstants() || !pMtx->GetApplyConstants())
      return pMtx;
  }
}

return NULL__null;
4515}




4520/**
4521**************************************************************************
4522* Name: CIccPcsStepMpe::Begin
4523* 
4524* Purpose: 
4525*  Initializes multi-processing element for processing.  Must be called before
4526*  Apply is called
4527**************************************************************************
4528*/
4529bool CIccPcsStepMpe::Begin()
4530{
return m_pMpe->Begin();
4532}


4535/**
4536**************************************************************************
4537* Name: CIccPcsStepSrcMatrix::CIccPcsStepSrcMatrix
4538* 
4539* Purpose: 
4540*  Constructor
4541**************************************************************************
4542*/
4543CIccPcsStepSrcMatrix::CIccPcsStepSrcMatrix(icUInt16Number nRows, icUInt16Number nCols)
4544{
m_nRows = nRows;
m_nCols = nCols;
m_vals = new icFloatNumber[nCols];
4548}


4551/**
4552**************************************************************************
4553* Name: CIccPcsStepSrcMatrix::~CIccPcsStepSrcMatrix
4554* 
4555* Purpose: 
4556*  Destructor
4557**************************************************************************
4558*/
4559CIccPcsStepSrcMatrix::~CIccPcsStepSrcMatrix()
4560{
if (m_vals)
  delete m_vals;
4563}


4566/**
4567**************************************************************************
4568* Name: CIccPcsStepSrcMatrix::Apply
4569* 
4570* Purpose: 
4571*  Multiplies illuminant stored in m_vals by pSrc matrix passed in resulting
4572*  in a pDst vector
4573**************************************************************************
4574*/
4575void CIccPcsStepSrcMatrix::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
4576{
int i, j;
const icFloatNumber *row = pSrc;
for (j=0; j<m_nRows; j++) {
  pDst[j] = 0.0f;
  for (i=0; i<m_nCols; i++) {
    pDst[j] += row[i] * m_vals[i];
  }
  row += m_nCols;
}
4586}


4589/**
4590**************************************************************************
4591* Name: CIccPcsStepSrcMatrix::dump
4592* 
4593* Purpose: 
4594*  dumps the context of the step
4595**************************************************************************
4596*/
4597void CIccPcsStepSrcMatrix::dump(std::string &str) const
4598{
str += "\nCIccPcsStepSrcMatrix\n\n";
char buf[80];
for (int i=0; i<m_nCols; i++) {
  sprintf(buf, ICCPCSSTEPDUMPFMT" %.8f", m_vals[i]);
  str += buf;
}
str += "\n";
4606}


4609/**
4610**************************************************************************
4611* Name: CIccPcsStepSparseMatrix::CIccPcsStepSparseMatrix
4612* 
4613* Purpose: 
4614*  Constructor
4615**************************************************************************
4616*/
4617CIccPcsStepSparseMatrix::CIccPcsStepSparseMatrix(icUInt16Number nRows, icUInt16Number nCols, icUInt32Number nBytesPerMatrix)
4618{
m_nRows = nRows;
m_nCols = nCols;
m_nBytesPerMatrix = nBytesPerMatrix;

m_vals = new icFloatNumber[m_nBytesPerMatrix/sizeof(icFloatNumber)];
4624}


4627/**
4628**************************************************************************
4629* Name: CIccPcsStepSparseMatrix::~CIccPcsStepSparseMatrix
4630* 
4631* Purpose: 
4632*  Destructor
4633**************************************************************************
4634*/
4635CIccPcsStepSparseMatrix::~CIccPcsStepSparseMatrix()
4636{
if (m_vals)
  delete [] m_vals;
4639}


4642/**
4643**************************************************************************
4644* Name: CIccPcsStepSparseMatrix::Apply
4645* 
4646* Purpose: 
4647*  Multiplies illuminant stored in m_vals by pSrc matrix passed in resulting
4648*  in a pDst vector
4649**************************************************************************
4650*/
4651void CIccPcsStepSparseMatrix::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
4652{
CIccSparseMatrix mtx((icUInt8Number*)m_vals, m_nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);

mtx.MultiplyVector(pDst, pSrc);
4656}


4659/**
4660**************************************************************************
4661* Name: CIccPcsStepSparseMatrix::dump
4662* 
4663* Purpose: 
4664*  dumps the context of the step
4665**************************************************************************
4666*/
4667void CIccPcsStepSparseMatrix::dump(std::string &str) const
4668{
str += "\nCIccPcsStepSparseMatrix\n\n";
4670//   char buf[80];
4671//   for (int i=0; i<m_nCols; i++) {
4672//     sprintf(buf, ICCPCSSTEPDUMPFMT, m_vals[i]);
4673//     str += buf;
4674//   }
4675//   str += "\n";
4676}


4679/**
4680**************************************************************************
4681* Name: CIccPcsStepSrcSparseMatrix::CIccPcsStepSrcSparseMatrix
4682* 
4683* Purpose: 
4684*  Constructor
4685**************************************************************************
4686*/
4687CIccPcsStepSrcSparseMatrix::CIccPcsStepSrcSparseMatrix(icUInt16Number nRows, icUInt16Number nCols, icUInt16Number nChannels)
4688{
m_nRows = nRows;
m_nCols = nCols;
m_nChannels = nChannels;
m_nBytesPerMatrix = nChannels * sizeof(icFloatNumber);

m_vals = new icFloatNumber[nCols];
4695}


4698/**
4699**************************************************************************
4700* Name: CIccPcsStepSrcSparseMatrix::~CIccPcsSrcStepSparseMatrix
4701* 
4702* Purpose: 
4703*  Destructor
4704**************************************************************************
4705*/
4706CIccPcsStepSrcSparseMatrix::~CIccPcsStepSrcSparseMatrix()
4707{
if (m_vals)
  delete [] m_vals;
4710}


4713/**
4714**************************************************************************
4715* Name: CIccPcsStepSrcSparseMatrix::Apply
4716* 
4717* Purpose: 
4718*  Multiplies illuminant stored in m_vals by pSrc matrix passed in resulting
4719*  in a pDst vector
4720**************************************************************************
4721*/
4722void CIccPcsStepSrcSparseMatrix::Apply(CIccApplyPcsStep *pApply, icFloatNumber *pDst, const icFloatNumber *pSrc) const
4723{
CIccSparseMatrix mtx((icUInt8Number*)pSrc, m_nBytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);

mtx.MultiplyVector(pDst, m_vals);
4727}


4730/**
4731**************************************************************************
4732* Name: CIccPcsStepSrcSparseMatrix::dump
4733* 
4734* Purpose: 
4735*  dumps the context of the step
4736**************************************************************************
4737*/
4738void CIccPcsStepSrcSparseMatrix::dump(std::string &str) const
4739{
str += "\nCIccPcsStepSrcSparseMatrix\n\n";
char buf[80];
for (int i=0; i<m_nCols; i++) {
  sprintf(buf, ICCPCSSTEPDUMPFMT" %.8f", m_vals[i]);
  str += buf;
}
str += "\n";
4747}


4750/**
4751**************************************************************************
4752* Name: CIccXformMonochrome::CIccXformMonochrome
4753* 
4754* Purpose: 
4755*  Constructor
4756**************************************************************************
4757*/
4758CIccXformMonochrome::CIccXformMonochrome()
4759{
m_Curve = NULL__null;
m_ApplyCurvePtr = NULL__null;
m_bFreeCurve = false;
4763}

4765/**
4766**************************************************************************
4767* Name: CIccXformMonochrome::~CIccXformMonochrome
4768* 
4769* Purpose: 
4770*  Destructor
4771**************************************************************************
4772*/
4773CIccXformMonochrome::~CIccXformMonochrome()
4774{
if (m_bFreeCurve && m_Curve) {
delete m_Curve;
}
4778}

4780/**
4781**************************************************************************
4782* Name: CIccXformMonochrome::Begin
4783* 
4784* Purpose: 
4785*  Does the initialization of the Xform before Apply() is called.
4786*  Must be called before Apply().
4787*
4788**************************************************************************
4789*/
4790icStatusCMM CIccXformMonochrome::Begin()
4791{
icStatusCMM status;

status = CIccXform::Begin();
if (status != icCmmStatOk)
return status;

m_ApplyCurvePtr = NULL__null;

if (m_bInput) {
m_Curve = GetCurve(icSigGrayTRCTag);

if (!m_Curve) {
	return icCmmStatProfileMissingTag;
}
}
else {
m_Curve = GetInvCurve(icSigGrayTRCTag);
m_bFreeCurve = true;

if (!m_Curve) {
	return icCmmStatProfileMissingTag;
}
}

m_Curve->Begin();
if (!m_Curve->IsIdentity()) {
m_ApplyCurvePtr = m_Curve;
}

return icCmmStatOk;
4822}

4824/**
4825**************************************************************************
4826* Name: CIccXformMonochrome::Apply
4827* 
4828* Purpose: 
4829*  Does the actual application of the Xform.
4830*  
4831* Args:
4832*  pApply = ApplyXform object containing temporary storage used during Apply
4833*  DstPixel = Destination pixel where the result is stored,
4834*  SrcPixel = Source pixel which is to be applied.
4835**************************************************************************
4836*/
4837void CIccXformMonochrome::Apply(CIccApplyXform* pApply, icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
4838{
icFloatNumber Pixel[3];
SrcPixel = CheckSrcAbs(pApply, SrcPixel);

if (m_bInput) {
Pixel[0] = SrcPixel[0];

if (m_ApplyCurvePtr) {
	Pixel[0] = m_ApplyCurvePtr->Apply(Pixel[0]);
}

DstPixel[0] = icFloatNumber(icPerceptualRefWhiteX0.9642); 
DstPixel[1] = icFloatNumber(icPerceptualRefWhiteY1.0000);
DstPixel[2] = icFloatNumber(icPerceptualRefWhiteZ0.8249);

icXyzToPcs(DstPixel);

if (m_pProfile->m_Header.pcs==icSigLabData) {
	if (UseLegacyPCS()) {
		CIccPCS::XyzToLab2(DstPixel, DstPixel, true);
	}
	else {
		CIccPCS::XyzToLab(DstPixel, DstPixel, true);
	}
}

DstPixel[0] *= Pixel[0];
DstPixel[1] *= Pixel[0];
DstPixel[2] *= Pixel[0];
}
else {
Pixel[0] = icFloatNumber(icPerceptualRefWhiteX0.9642); 
Pixel[1] = icFloatNumber(icPerceptualRefWhiteY1.0000);
Pixel[2] = icFloatNumber(icPerceptualRefWhiteZ0.8249);

icXyzToPcs(Pixel);

if (m_pProfile->m_Header.pcs==icSigLabData) {
	if (UseLegacyPCS()) {
		CIccPCS::XyzToLab2(Pixel, Pixel, true);
	}
	else {
		CIccPCS::XyzToLab(Pixel, Pixel, true);
	}
	DstPixel[0] = SrcPixel[0]/Pixel[0];
}
else {
	DstPixel[0] = SrcPixel[1]/Pixel[1];
}

if (m_ApplyCurvePtr) {
	DstPixel[0] = m_ApplyCurvePtr->Apply(DstPixel[0]);
}
}

CheckDstAbs(DstPixel);
4894}

4896/**
4897**************************************************************************
4898* Name: CIccXformMonochrome::GetCurve
4899* 
4900* Purpose: 
4901*  Gets the curve having the passed signature, from the profile.
4902*  
4903* Args:
4904*  sig = signature of the curve to be found
4905*
4906* Return:
4907*  Pointer to the curve.
4908**************************************************************************
4909*/
4910CIccCurve *CIccXformMonochrome::GetCurve(icSignature sig) const
4911{
CIccTag *pTag = m_pProfile->FindTag(sig);

if (pTag && (pTag->GetType()==icSigCurveType || pTag->GetType()==icSigParametricCurveType)) {
return (CIccCurve*)pTag;
}

return NULL__null;
4919}

4921/**
4922**************************************************************************
4923* Name: CIccXformMonochrome::GetInvCurve
4924* 
4925* Purpose: 
4926*  Gets the inverted curve having the passed signature, from the profile.
4927*  
4928* Args:
4929*  sig = signature of the curve to be inverted
4930*
4931* Return:
4932*  Pointer to the inverted curve.
4933**************************************************************************
4934*/
4935CIccCurve *CIccXformMonochrome::GetInvCurve(icSignature sig) const
4936{
CIccCurve *pCurve;
CIccTagCurve *pInvCurve;

if (!(pCurve = GetCurve(sig)))
return NULL__null;

pCurve->Begin();

pInvCurve = new CIccTagCurve(2048);

int i;
icFloatNumber x;
icFloatNumber *Lut = &(*pInvCurve)[0];

for (i=0; i<2048; i++) {
x=(icFloatNumber)i / 2047;

Lut[i] = pCurve->Find(x);
}

return pInvCurve;
4958}

4960/**
4961**************************************************************************
4962* Name: CIccXformMonochrome::ExtractInputCurves
4963* 
4964* Purpose: 
4965*  Gets the input curves. Should be called only after Begin() 
4966*  has been called. Once the curves are extracted, they will 
4967*  not be used by the Apply() function.
4968*  WARNING:  caller owns the curves and must be deleted by the caller.
4969*  
4970* Return:
4971*  Pointer to the input curves.
4972**************************************************************************
4973*/
4974LPIccCurve* CIccXformMonochrome::ExtractInputCurves()
4975{
if (m_bInput) {
if (m_Curve) {
	LPIccCurve* Curve = new LPIccCurve[1];
	Curve[0] = (LPIccCurve)(m_Curve->NewCopy());
	m_ApplyCurvePtr = NULL__null;
	return Curve;
}
}

return NULL__null;
4986}

4988/**
4989**************************************************************************
4990* Name: CIccXformMonochrome::ExtractOutputCurves
4991* 
4992* Purpose: 
4993*  Gets the output curves. Should be called only after Begin() 
4994*  has been called. Once the curves are extracted, they will 
4995*  not be used by the Apply() function.
4996*  WARNING:  caller owns the curves and must be deleted by the caller.
4997*  
4998* Return:
4999*  Pointer to the output curves.
5000**************************************************************************
5001*/
5002LPIccCurve* CIccXformMonochrome::ExtractOutputCurves()
5003{
if (!m_bInput) {
if (m_Curve) {
	LPIccCurve* Curve = new LPIccCurve[1];
	Curve[0] = (LPIccCurve)(m_Curve->NewCopy());
	m_ApplyCurvePtr = NULL__null;
	return Curve;
}
}

return NULL__null;
5014}

5016/**
**************************************************************************
* Name: CIccXformMatrixTRC::CIccXformMatrixTRC
* 
* Purpose: 
*  Constructor
**************************************************************************
*/
5024CIccXformMatrixTRC::CIccXformMatrixTRC()
5025{
m_Curve[0] = m_Curve[1] = m_Curve[2] = NULL__null;
m_ApplyCurvePtr = NULL__null;
m_bFreeCurve = false;
5029}

5031/**
**************************************************************************
* Name: CIccXformMatrixTRC::~CIccXformMatrixTRC
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
5039CIccXformMatrixTRC::~CIccXformMatrixTRC()
5040{
if (m_bFreeCurve) {
  if (m_Curve[0])
    delete m_Curve[0];
  if (m_Curve[1])
    delete m_Curve[1];
  if (m_Curve[2])
    delete m_Curve[2];
}
5049}

5051/**
**************************************************************************
* Name: CIccXformMatrixTRC::Begin
* 
* Purpose: 
*  Does the initialization of the Xform before Apply() is called.
*  Must be called before Apply().
*
**************************************************************************
*/
5061icStatusCMM CIccXformMatrixTRC::Begin()
5062{
icStatusCMM status;
const CIccTagXYZ *pXYZ;

status = CIccXform::Begin();
if (status != icCmmStatOk)
  return status;

pXYZ = GetColumn(icSigRedMatrixColumnTag);
if (!pXYZ) {
  return icCmmStatProfileMissingTag;
}

m_e[0] = icFtoD((*pXYZ)[0].X);
m_e[3] = icFtoD((*pXYZ)[0].Y);
m_e[6] = icFtoD((*pXYZ)[0].Z);

pXYZ = GetColumn(icSigGreenMatrixColumnTag);
if (!pXYZ) {
  return icCmmStatProfileMissingTag;
}

m_e[1] = icFtoD((*pXYZ)[0].X);
m_e[4] = icFtoD((*pXYZ)[0].Y);
m_e[7] = icFtoD((*pXYZ)[0].Z);

pXYZ = GetColumn(icSigBlueMatrixColumnTag);
if (!pXYZ) {
  return icCmmStatProfileMissingTag;
}

m_e[2] = icFtoD((*pXYZ)[0].X);
m_e[5] = icFtoD((*pXYZ)[0].Y);
m_e[8] = icFtoD((*pXYZ)[0].Z);

m_ApplyCurvePtr = NULL__null;

if (m_bInput) {
  m_Curve[0] = GetCurve(icSigRedTRCTag);
  m_Curve[1] = GetCurve(icSigGreenTRCTag);
  m_Curve[2] = GetCurve(icSigBlueTRCTag);

  if (!m_Curve[0] || !m_Curve[1] || !m_Curve[2]) {
    return icCmmStatProfileMissingTag;
  }

}
else {
  if (m_pProfile->m_Header.pcs!=icSigXYZData) {
    return icCmmStatBadSpaceLink;
  }

  m_Curve[0] = GetInvCurve(icSigRedTRCTag);
  m_Curve[1] = GetInvCurve(icSigGreenTRCTag);
  m_Curve[2] = GetInvCurve(icSigBlueTRCTag);

  m_bFreeCurve = true;

  if (!m_Curve[0] || !m_Curve[1] || !m_Curve[2]) {
    return icCmmStatProfileMissingTag;
  }

  if (!icMatrixInvert3x3(m_e)) {
    return icCmmStatInvalidProfile;
  }
}

m_Curve[0]->Begin();
m_Curve[1]->Begin();
m_Curve[2]->Begin();

if (!m_Curve[0]->IsIdentity() || !m_Curve[1]->IsIdentity() || !m_Curve[2]->IsIdentity()) {
  m_ApplyCurvePtr = m_Curve;
}

return icCmmStatOk;
5138}


5141static icFloatNumber XYZScale(icFloatNumber v)
5142{
v = (icFloatNumber)(v * 32768.0 / 65535.0);
return v;
5145}

5147static icFloatNumber XYZDescale(icFloatNumber v)
5148{
return (icFloatNumber)(v * 65535.0 / 32768.0);
5150}

5152static icFloatNumber RGBClip(icFloatNumber v, CIccCurve *pCurve)
5153{
if (v<=0)
  return(pCurve->Apply(0));
else if (v>=1.0)
  return (pCurve->Apply(1.0));

return pCurve->Apply(v);
5160}

5162/**
**************************************************************************
* Name: CIccXformMatrixTRC::Apply
* 
* Purpose: 
*  Does the actual application of the Xform.
*  
* Args:
*  pApply = ApplyXform object containging temporary storage used during Apply
*  DstPixel = Destination pixel where the result is stored,
*  SrcPixel = Source pixel which is to be applied.
**************************************************************************
*/
5175void CIccXformMatrixTRC::Apply(CIccApplyXform* pApply, icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
5176{
icFloatNumber Pixel[3];

SrcPixel = CheckSrcAbs(pApply, SrcPixel);
Pixel[0] = SrcPixel[0];
Pixel[1] = SrcPixel[1];
Pixel[2] = SrcPixel[2];

if (m_bInput) {

  double LinR, LinG, LinB;
  if (m_ApplyCurvePtr) {
    LinR = m_ApplyCurvePtr[0]->Apply(Pixel[0]);
    LinG = m_ApplyCurvePtr[1]->Apply(Pixel[1]);
    LinB = m_ApplyCurvePtr[2]->Apply(Pixel[2]);
  }
  else {
    LinR = Pixel[0];
    LinG = Pixel[1];
    LinB = Pixel[2];
  }

  DstPixel[0] = XYZScale((icFloatNumber)(m_e[0] * LinR + m_e[1] * LinG + m_e[2] * LinB));
  DstPixel[1] = XYZScale((icFloatNumber)(m_e[3] * LinR + m_e[4] * LinG + m_e[5] * LinB));
  DstPixel[2] = XYZScale((icFloatNumber)(m_e[6] * LinR + m_e[7] * LinG + m_e[8] * LinB));
}
else {
  double X = XYZDescale(Pixel[0]);
  double Y = XYZDescale(Pixel[1]);
  double Z = XYZDescale(Pixel[2]);

  if (m_ApplyCurvePtr) {
    DstPixel[0] = RGBClip((icFloatNumber)(m_e[0] * X + m_e[1] * Y + m_e[2] * Z), m_ApplyCurvePtr[0]);
    DstPixel[1] = RGBClip((icFloatNumber)(m_e[3] * X + m_e[4] * Y + m_e[5] * Z), m_ApplyCurvePtr[1]);
    DstPixel[2] = RGBClip((icFloatNumber)(m_e[6] * X + m_e[7] * Y + m_e[8] * Z), m_ApplyCurvePtr[2]);
  }
  else {
    DstPixel[0] = (icFloatNumber)(m_e[0] * X + m_e[1] * Y + m_e[2] * Z);
    DstPixel[1] = (icFloatNumber)(m_e[3] * X + m_e[4] * Y + m_e[5] * Z);
    DstPixel[2] = (icFloatNumber)(m_e[6] * X + m_e[7] * Y + m_e[8] * Z);
  }
}

CheckDstAbs(DstPixel);
5220}

5222/**
**************************************************************************
* Name: CIccXformMatrixTRC::GetCurve
* 
* Purpose: 
*  Gets the curve having the passed signature, from the profile.
*  
* Args:
*  sig = signature of the curve to be found
*
* Return:
*  Pointer to the curve.
**************************************************************************
*/
5236CIccCurve *CIccXformMatrixTRC::GetCurve(icSignature sig) const
5237{
CIccTag *pTag = m_pProfile->FindTag(sig);

if (pTag->GetType()==icSigCurveType || pTag->GetType()==icSigParametricCurveType) {
  return (CIccCurve*)pTag;
}

return NULL__null;
5245}

5247/**
**************************************************************************
* Name: CIccXformMatrixTRC::GetColumn
* 
* Purpose: 
*  Gets the XYZ tag from the profile.
*  
* Args:
*  sig = signature of the XYZ tag to be found.
* 
* Return:
*  Pointer to the XYZ tag.
**************************************************************************
*/
5261CIccTagXYZ *CIccXformMatrixTRC::GetColumn(icSignature sig) const
5262{
CIccTag *pTag = m_pProfile->FindTag(sig);

if (!pTag || pTag->GetType()!=icSigXYZType) {
  return NULL__null;
}

return (CIccTagXYZ*)pTag;
5270}

5272/**
**************************************************************************
* Name: CIccXformMatrixTRC::GetInvCurve
* 
* Purpose: 
*  Gets the inverted curve having the passed signature, from the profile.
*  
* Args:
*  sig = signature of the curve to be inverted
*
* Return:
*  Pointer to the inverted curve.
**************************************************************************
*/
5286CIccCurve *CIccXformMatrixTRC::GetInvCurve(icSignature sig) const
5287{
CIccCurve *pCurve;
CIccTagCurve *pInvCurve;

if (!(pCurve = GetCurve(sig)))
  return NULL__null;

pCurve->Begin();

pInvCurve = new CIccTagCurve(2048);

int i;
icFloatNumber x;
icFloatNumber *Lut = &(*pInvCurve)[0];

for (i=0; i<2048; i++) {
  x=(icFloatNumber)i / 2047;

  Lut[i] = pCurve->Find(x);
}

return pInvCurve;
5309}

5311/**
5312**************************************************************************
5313* Name: CIccXformMatrixTRC::ExtractInputCurves
5314* 
5315* Purpose: 
5316*  Gets the input curves. Should be called only after Begin() 
5317*  has been called. Once the curves are extracted, they will 
5318*  not be used by the Apply() function.
5319*  WARNING:  caller owns the curves and must be deleted by the caller.
5320*  
5321* Return:
5322*  Pointer to the input curves.
5323**************************************************************************
5324*/
5325LPIccCurve* CIccXformMatrixTRC::ExtractInputCurves()
5326{
if (m_bInput) {
  if (m_Curve[0]) {
	LPIccCurve* Curve = new LPIccCurve[3];
	Curve[0] = (LPIccCurve)(m_Curve[0]->NewCopy());
	Curve[1] = (LPIccCurve)(m_Curve[1]->NewCopy());
	Curve[2] = (LPIccCurve)(m_Curve[2]->NewCopy());
    m_ApplyCurvePtr = NULL__null;
    return Curve;
  }
}

return NULL__null;
5339}

5341/**
5342**************************************************************************
5343* Name: CIccXformMatrixTRC::ExtractOutputCurves
5344* 
5345* Purpose: 
5346*  Gets the output curves. Should be called only after Begin() 
5347*  has been called. Once the curves are extracted, they will 
5348*  not be used by the Apply() function.
5349*  WARNING:  caller owns the curves and must be deleted by the caller.
5350*  
5351* Return:
5352*  Pointer to the output curves.
5353**************************************************************************
5354*/
5355LPIccCurve* CIccXformMatrixTRC::ExtractOutputCurves()
5356{
if (!m_bInput) {
  if (m_Curve[0]) {
	LPIccCurve* Curve = new LPIccCurve[3];
	Curve[0] = (LPIccCurve)(m_Curve[0]->NewCopy());
	Curve[1] = (LPIccCurve)(m_Curve[1]->NewCopy());
	Curve[2] = (LPIccCurve)(m_Curve[2]->NewCopy());
    m_ApplyCurvePtr = NULL__null;
    return Curve;
  }
}

return NULL__null;
5369}

5371/**
**************************************************************************
* Name: CIccXform3DLut::CIccXform3DLut
* 
* Purpose: 
*  Constructor
*
* Args:
*   pTag = Pointer to the tag of type CIccMBB 
**************************************************************************
*/
5382CIccXform3DLut::CIccXform3DLut(CIccTag *pTag)
5383{
if (pTag && pTag->IsMBBType()) {
  m_pTag = (CIccMBB*)pTag;
}
else
  m_pTag = NULL__null;

m_ApplyCurvePtrA = m_ApplyCurvePtrB = m_ApplyCurvePtrM = NULL__null;
m_ApplyMatrixPtr = NULL__null;
5392}

5394/**
**************************************************************************
* Name: CIccXform3DLut::~CIccXform3DLut
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
5402CIccXform3DLut::~CIccXform3DLut()
5403{
5404}

5406/**
**************************************************************************
* Name: CIccXform3DLut::Begin
* 
* Purpose: 
*  Does the initialization of the Xform before Apply() is called.
*  Must be called before Apply().
*
**************************************************************************
*/
icStatusCMM CIccXform3DLut::Begin()
5417{
icStatusCMM status;
CIccCurve **Curve;
int i;

status = CIccXform::Begin();
if (status != icCmmStatOk)
  return status;

if (!m_pTag ||
    m_pTag->InputChannels()!=3) {
  return icCmmStatInvalidLut;
}

m_ApplyCurvePtrA = NULL__null;
m_ApplyCurvePtrB = NULL__null;
m_ApplyCurvePtrM = NULL__null;

if (m_pTag->m_bInputMatrix) {
  if (m_pTag->m_CurvesB) {
    Curve = m_pTag->m_CurvesB;

    Curve[0]->Begin();
    Curve[1]->Begin();
    Curve[2]->Begin();

    if (!Curve[0]->IsIdentity() || !Curve[1]->IsIdentity() || !Curve[2]->IsIdentity()) {
      m_ApplyCurvePtrB = Curve;
    }
  }

  if (m_pTag->m_CurvesM) {
    Curve = m_pTag->m_CurvesM;

    Curve[0]->Begin();
    Curve[1]->Begin();
    Curve[2]->Begin();
    
    if (!Curve[0]->IsIdentity() || !Curve[1]->IsIdentity() || !Curve[2]->IsIdentity()) {
      m_ApplyCurvePtrM = Curve;
    }
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Begin();
  }

  if (m_pTag->m_CurvesA) {
    Curve = m_pTag->m_CurvesA;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrA = Curve;
        break;
      }
    }
  }

}
else {
  if (m_pTag->m_CurvesA) {
    Curve = m_pTag->m_CurvesA;

    Curve[0]->Begin();
    Curve[1]->Begin();
    Curve[2]->Begin();

    if (!Curve[0]->IsIdentity() || !Curve[1]->IsIdentity() || !Curve[2]->IsIdentity()) {
      m_ApplyCurvePtrA = Curve;
    }
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Begin();
  }

  if (m_pTag->m_CurvesM) {
    Curve = m_pTag->m_CurvesM;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrM = Curve;
        break;
      }
    }
  }

  if (m_pTag->m_CurvesB) {
    Curve = m_pTag->m_CurvesB;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrB = Curve;
        break;
      }
    }
  }
}

m_ApplyMatrixPtr = NULL__null;
if (m_pTag->m_Matrix) {
  if (m_pTag->m_bInputMatrix) {
    if (m_pTag->m_nInput!=3) {
      return icCmmStatInvalidProfile;
    }
  }
  else {
    if (m_pTag->m_nOutput!=3) {
      return icCmmStatInvalidProfile;
    }
  }

  if (!m_pTag->m_Matrix->IsIdentity()) {
    m_ApplyMatrixPtr = m_pTag->m_Matrix;
  }
}

return icCmmStatOk;
5547}

5549/**
**************************************************************************
* Name: CIccXform3DLut::Apply
* 
* Purpose: 
*  Does the actual application of the Xform.
*  
* Args:
*  pApply = ApplyXform object containing temporary storage used during Apply
*  DstPixel = Destination pixel where the result is stored,
*  SrcPixel = Source pixel which is to be applied.
**************************************************************************
*/
5562void CIccXform3DLut::Apply(CIccApplyXform* pApply, icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
5563{
icFloatNumber Pixel[16];
int i;

SrcPixel = CheckSrcAbs(pApply, SrcPixel);
Pixel[0] = SrcPixel[0];
Pixel[1] = SrcPixel[1];
Pixel[2] = SrcPixel[2];

if (m_pTag->m_bInputMatrix) {
  if (m_ApplyCurvePtrB) {
    Pixel[0] = m_ApplyCurvePtrB[0]->Apply(Pixel[0]);
    Pixel[1] = m_ApplyCurvePtrB[1]->Apply(Pixel[1]);
    Pixel[2] = m_ApplyCurvePtrB[2]->Apply(Pixel[2]);
  }

  if (m_ApplyMatrixPtr) {
    m_ApplyMatrixPtr->Apply(Pixel);
  }

  if (m_ApplyCurvePtrM) {
    Pixel[0] = m_ApplyCurvePtrM[0]->Apply(Pixel[0]);
    Pixel[1] = m_ApplyCurvePtrM[1]->Apply(Pixel[1]);
    Pixel[2] = m_ApplyCurvePtrM[2]->Apply(Pixel[2]);
  }

  if (m_pTag->m_CLUT) {
    if (m_nInterp==icInterpLinear)
      m_pTag->m_CLUT->Interp3d(Pixel, Pixel);
    else
      m_pTag->m_CLUT->Interp3dTetra(Pixel, Pixel);
  }

  if (m_ApplyCurvePtrA) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrA[i]->Apply(Pixel[i]);
    }
  }

}
else {
  if (m_ApplyCurvePtrA) {
    Pixel[0] = m_ApplyCurvePtrA[0]->Apply(Pixel[0]);
    Pixel[1] = m_ApplyCurvePtrA[1]->Apply(Pixel[1]);
    Pixel[2] = m_ApplyCurvePtrA[2]->Apply(Pixel[2]);
  }

  if (m_pTag->m_CLUT) {
    if (m_nInterp==icInterpLinear)
      m_pTag->m_CLUT->Interp3d(Pixel, Pixel);
    else
      m_pTag->m_CLUT->Interp3dTetra(Pixel, Pixel);
  }

  if (m_ApplyCurvePtrM) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrM[i]->Apply(Pixel[i]);
    }
  }

  if (m_ApplyMatrixPtr) {
    m_ApplyMatrixPtr->Apply(Pixel);
  }

  if (m_ApplyCurvePtrB) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrB[i]->Apply(Pixel[i]);
    }
  }
}

for (i=0; i<m_pTag->m_nOutput; i++) {
  DstPixel[i] = Pixel[i];
}

CheckDstAbs(DstPixel);
5639}

5641/**
5642**************************************************************************
5643* Name: CIccXform3DLut::ExtractInputCurves
5644* 
5645* Purpose: 
5646*  Gets the input curves. Should be called only after Begin() 
5647*  has been called. Once the curves are extracted, they will 
5648*  not be used by the Apply() function.
5649*  WARNING:  caller owns the curves and must be deleted by the caller.
5650*  
5651* Return:
5652*  Pointer to the input curves.
5653**************************************************************************
5654*/
5655LPIccCurve* CIccXform3DLut::ExtractInputCurves()
5656{
if (m_bInput) {
  if (m_pTag->m_bInputMatrix) {
    if (m_pTag->m_CurvesB) {
      LPIccCurve* Curve = new LPIccCurve[3];
		Curve[0] = (LPIccCurve)(m_pTag->m_CurvesB[0]->NewCopy());
		Curve[1] = (LPIccCurve)(m_pTag->m_CurvesB[1]->NewCopy());
		Curve[2] = (LPIccCurve)(m_pTag->m_CurvesB[2]->NewCopy());
      m_ApplyCurvePtrB = NULL__null;
      return Curve;
    }
  }
  else {
    if (m_pTag->m_CurvesA) {
      LPIccCurve* Curve = new LPIccCurve[3];
		Curve[0] = (LPIccCurve)(m_pTag->m_CurvesA[0]->NewCopy());
		Curve[1] = (LPIccCurve)(m_pTag->m_CurvesA[1]->NewCopy());
		Curve[2] = (LPIccCurve)(m_pTag->m_CurvesA[2]->NewCopy());
      m_ApplyCurvePtrA = NULL__null;
      return Curve;
    }
  }
}

return NULL__null;
5681}

5683/**
5684**************************************************************************
5685* Name: CIccXform3DLut::ExtractOutputCurves
5686* 
5687* Purpose: 
5688*  Gets the output curves. Should be called only after Begin() 
5689*  has been called. Once the curves are extracted, they will 
5690*  not be used by the Apply() function.
5691*  WARNING:  caller owns the curves and must be deleted by the caller.
5692*  
5693* Return:
5694*  Pointer to the output curves.
5695**************************************************************************
5696*/
5697LPIccCurve* CIccXform3DLut::ExtractOutputCurves()
5698{
if (!m_bInput) {
  if (m_pTag->m_bInputMatrix) {
    if (m_pTag->m_CurvesA) {
      LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nOutput];
		for (int i=0; i<m_pTag->m_nOutput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesA[i]->NewCopy());
		}
      m_ApplyCurvePtrA = NULL__null;
      return Curve;
    }
  }
  else {
    if (m_pTag->m_CurvesB) {
      LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nOutput];
		for (int i=0; i<m_pTag->m_nOutput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesB[i]->NewCopy());
		}
      m_ApplyCurvePtrB = NULL__null;
      return Curve;
    }
  }
}

return NULL__null;
5723}

5725/**
**************************************************************************
* Name: CIccXform4DLut::CIccXform4DLut
* 
* Purpose: 
*  Constructor
*
* Args:
*   pTag = Pointer to the tag of type CIccMBB 
**************************************************************************
*/
5736CIccXform4DLut::CIccXform4DLut(CIccTag *pTag)
5737{
if (pTag && pTag->IsMBBType()) {
  m_pTag = (CIccMBB*)pTag;
}
else
  m_pTag = NULL__null;

m_ApplyCurvePtrA = m_ApplyCurvePtrB = m_ApplyCurvePtrM = NULL__null;
m_ApplyMatrixPtr = NULL__null;
5746}


5749/**
**************************************************************************
* Name: CIccXform4DLut::~CIccXform4DLut
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
5757CIccXform4DLut::~CIccXform4DLut()
5758{
5759}


5762/**
**************************************************************************
* Name: CIccXform4DLut::Begin
* 
* Purpose: 
*  Does the initialization of the Xform before Apply() is called.
*  Must be called before Apply().
*
**************************************************************************
*/
5772icStatusCMM CIccXform4DLut::Begin()
5773{
icStatusCMM status;
CIccCurve **Curve;
int i;

status = CIccXform::Begin();
if (status != icCmmStatOk) {
  return status;
}

if (!m_pTag ||
    m_pTag->InputChannels()!=4) {
  return icCmmStatInvalidLut;
}

m_ApplyCurvePtrA = m_ApplyCurvePtrB = m_ApplyCurvePtrM = NULL__null;

if (m_pTag->m_bInputMatrix) {
  if (m_pTag->m_CurvesB) {
    Curve = m_pTag->m_CurvesB;

    Curve[0]->Begin();
    Curve[1]->Begin();
    Curve[2]->Begin();
    Curve[3]->Begin();

    if (!Curve[0]->IsIdentity() || !Curve[1]->IsIdentity() ||
        !Curve[2]->IsIdentity() || !Curve[3]->IsIdentity()) 
    {
      m_ApplyCurvePtrB = Curve;
    }
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Begin();
  }

  if (m_pTag->m_CurvesA) {
    Curve = m_pTag->m_CurvesA;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrA = Curve;
        break;
      }
    }
  }

}
else {
  if (m_pTag->m_CurvesA) {
    Curve = m_pTag->m_CurvesA;

    Curve[0]->Begin();
    Curve[1]->Begin();
    Curve[2]->Begin();
    Curve[3]->Begin();

    if (!Curve[0]->IsIdentity() || !Curve[1]->IsIdentity() ||
        !Curve[2]->IsIdentity() || !Curve[3]->IsIdentity()) 
    {
      m_ApplyCurvePtrA = Curve;
    }
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Begin();
  }

  if (m_pTag->m_CurvesM) {
    Curve = m_pTag->m_CurvesM;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrM = Curve;
        break;
      }
    }
  }

  if (m_pTag->m_CurvesB) {
    Curve = m_pTag->m_CurvesB;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrB = Curve;
        break;
      }
    }
  }
}

m_ApplyMatrixPtr = NULL__null;
if (m_pTag->m_Matrix) {
  if (m_pTag->m_bInputMatrix) {
    return icCmmStatInvalidProfile;
  }
  else {
    if (m_pTag->m_nOutput!=3) {
      return icCmmStatInvalidProfile;
    }
  }

  if (!m_pTag->m_Matrix->IsIdentity()) {
    m_ApplyMatrixPtr = m_pTag->m_Matrix;
  }
}

return icCmmStatOk;
5894}


5897/**
**************************************************************************
* Name: CIccXform4DLut::Apply
* 
* Purpose: 
*  Does the actual application of the Xform.
*  
* Args:
*  pApply = ApplyXform object containging temporary storage used during Apply
*  DstPixel = Destination pixel where the result is stored,
*  SrcPixel = Source pixel which is to be applied.
**************************************************************************
*/
5910void CIccXform4DLut::Apply(CIccApplyXform* pApply, icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
5911{
icFloatNumber Pixel[16];
int i;

SrcPixel = CheckSrcAbs(pApply, SrcPixel);
Pixel[0] = SrcPixel[0];
Pixel[1] = SrcPixel[1];
Pixel[2] = SrcPixel[2];
Pixel[3] = SrcPixel[3];

if (m_pTag->m_bInputMatrix) {
  if (m_ApplyCurvePtrB) {
    Pixel[0] = m_ApplyCurvePtrB[0]->Apply(Pixel[0]);
    Pixel[1] = m_ApplyCurvePtrB[1]->Apply(Pixel[1]);
    Pixel[2] = m_ApplyCurvePtrB[2]->Apply(Pixel[2]);
    Pixel[3] = m_ApplyCurvePtrB[3]->Apply(Pixel[3]);
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Interp4d(Pixel, Pixel);
  }

  if (m_ApplyCurvePtrA) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrA[i]->Apply(Pixel[i]);
    }
  }

}
else {
  if (m_ApplyCurvePtrA) {
    Pixel[0] = m_ApplyCurvePtrA[0]->Apply(Pixel[0]);
    Pixel[1] = m_ApplyCurvePtrA[1]->Apply(Pixel[1]);
    Pixel[2] = m_ApplyCurvePtrA[2]->Apply(Pixel[2]);
    Pixel[3] = m_ApplyCurvePtrA[3]->Apply(Pixel[3]);
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Interp4d(Pixel, Pixel);
  }

  if (m_ApplyCurvePtrM) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrM[i]->Apply(Pixel[i]);
    }
  }

  if (m_ApplyMatrixPtr) {
    m_ApplyMatrixPtr->Apply(Pixel);
  }

  if (m_ApplyCurvePtrB) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrB[i]->Apply(Pixel[i]);
    }
  }
}

for (i=0; i<m_pTag->m_nOutput; i++) {
  DstPixel[i] = Pixel[i];
}

CheckDstAbs(DstPixel);
5974}

5976/**
5977**************************************************************************
5978* Name: CIccXform4DLut::ExtractInputCurves
5979* 
5980* Purpose: 
5981*  Gets the input curves. Should be called only after Begin() 
5982*  has been called. Once the curves are extracted, they will 
5983*  not be used by the Apply() function.
5984*  WARNING:  caller owns the curves and must be deleted by the caller.
5985*  
5986* Return:
5987*  Pointer to the input curves.
5988**************************************************************************
5989*/
5990LPIccCurve* CIccXform4DLut::ExtractInputCurves()
5991{
if (m_bInput) {
if (m_pTag->m_bInputMatrix) {
	if (m_pTag->m_CurvesB) {
		LPIccCurve* Curve = new LPIccCurve[4];
		Curve[0] = (LPIccCurve)(m_pTag->m_CurvesB[0]->NewCopy());
		Curve[1] = (LPIccCurve)(m_pTag->m_CurvesB[1]->NewCopy());
		Curve[2] = (LPIccCurve)(m_pTag->m_CurvesB[2]->NewCopy());
		Curve[3] = (LPIccCurve)(m_pTag->m_CurvesB[3]->NewCopy());
		m_ApplyCurvePtrB = NULL__null;
		return Curve;
	}
}
else {
	if (m_pTag->m_CurvesA) {
		LPIccCurve* Curve = new LPIccCurve[4];
		Curve[0] = (LPIccCurve)(m_pTag->m_CurvesA[0]->NewCopy());
		Curve[1] = (LPIccCurve)(m_pTag->m_CurvesA[1]->NewCopy());
		Curve[2] = (LPIccCurve)(m_pTag->m_CurvesA[2]->NewCopy());
		Curve[3] = (LPIccCurve)(m_pTag->m_CurvesA[3]->NewCopy());
		m_ApplyCurvePtrA = NULL__null;
		return Curve;
	}
}
}

return NULL__null;
6018}

6020/**
6021**************************************************************************
6022* Name: CIccXform4DLut::ExtractOutputCurves
6023* 
6024* Purpose: 
6025*  Gets the output curves. Should be called only after Begin() 
6026*  has been called. Once the curves are extracted, they will 
6027*  not be used by the Apply() function.
6028*  WARNING:  caller owns the curves and must be deleted by the caller.
6029*  
6030* Return:
6031*  Pointer to the output curves.
6032**************************************************************************
6033*/
6034LPIccCurve* CIccXform4DLut::ExtractOutputCurves()
6035{
if (!m_bInput) {
if (m_pTag->m_bInputMatrix) {
	if (m_pTag->m_CurvesA) {
		LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nOutput];
		for (int i=0; i<m_pTag->m_nOutput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesA[i]->NewCopy());
		}
		m_ApplyCurvePtrA = NULL__null;
		return Curve;
	}
}
else {
	if (m_pTag->m_CurvesB) {
		LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nOutput];
		for (int i=0; i<m_pTag->m_nOutput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesB[i]->NewCopy());
		}
		m_ApplyCurvePtrB = NULL__null;
		return Curve;
	}
}
}

return NULL__null;
6060}


6063/**
**************************************************************************
* Name: CIccXformNDLut::CIccXformNDLut
* 
* Purpose: 
*  Constructor
*
* Args:
*   pTag = Pointer to the tag of type CIccMBB 
**************************************************************************
*/
6074CIccXformNDLut::CIccXformNDLut(CIccTag *pTag)
6075{
if (pTag && pTag->IsMBBType()) {
  m_pTag = (CIccMBB*)pTag;
}
else
  m_pTag = NULL__null;

m_ApplyCurvePtrA = m_ApplyCurvePtrB = m_ApplyCurvePtrM = NULL__null;
m_ApplyMatrixPtr = NULL__null;
6084}


6087/**
**************************************************************************
* Name: CIccXformNDLut::~CIccXformNDLut
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
6095CIccXformNDLut::~CIccXformNDLut()
6096{
6097}


6100/**
**************************************************************************
* Name: CIccXformNDLut::Begin
* 
* Purpose: 
*  Does the initialization of the Xform before Apply() is called.
*  Must be called before Apply().
*
**************************************************************************
*/
6110icStatusCMM CIccXformNDLut::Begin()
6111{
icStatusCMM status;
CIccCurve **Curve;
int i;

status = CIccXform::Begin();
if (status != icCmmStatOk) {
  return status;
}

if (!m_pTag || (m_pTag->InputChannels()>2 && m_pTag->InputChannels()<5)) {
  return icCmmStatInvalidLut;
}

m_nNumInput = m_pTag->m_nInput;

m_ApplyCurvePtrA = m_ApplyCurvePtrB = m_ApplyCurvePtrM = NULL__null;

if (m_pTag->m_bInputMatrix) {
  if (m_pTag->m_CurvesB) {
    Curve = m_pTag->m_CurvesB;

    for (i=0; i<m_nNumInput; i++)
      Curve[i]->Begin();

    for (i=0; i<m_nNumInput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrB = Curve;
        break;
      }
    }
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Begin();
  }

  if (m_pTag->m_CurvesA) {
    Curve = m_pTag->m_CurvesA;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrA = Curve;
        break;
      }
    }
  }

}
else {
  if (m_pTag->m_CurvesA) {
    Curve = m_pTag->m_CurvesA;

    for (i=0; i<m_nNumInput; i++)
      Curve[i]->Begin();

    for (i=0; i<m_nNumInput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrA = Curve;
        break;
      }
    }
  }

  if (m_pTag->m_CLUT) {
    m_pTag->m_CLUT->Begin();
  }

  if (m_pTag->m_CurvesM) {
    Curve = m_pTag->m_CurvesM;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrM = Curve;
        break;
      }
    }
  }

  if (m_pTag->m_CurvesB) {
    Curve = m_pTag->m_CurvesB;

    for (i=0; i<m_pTag->m_nOutput; i++) {
      Curve[i]->Begin();
    }

    for (i=0; i<m_pTag->m_nOutput; i++) {
      if (!Curve[i]->IsIdentity()) {
        m_ApplyCurvePtrB = Curve;
        break;
      }
    }
  }
}

m_ApplyMatrixPtr = NULL__null;
if (m_pTag->m_Matrix) {
  if (m_pTag->m_bInputMatrix) {
    return icCmmStatInvalidProfile;
  }
  else {
    if (m_pTag->m_nOutput!=3) {
      return icCmmStatInvalidProfile;
    }
  }

  if (!m_pTag->m_Matrix->IsIdentity()) {
    m_ApplyMatrixPtr = m_pTag->m_Matrix;
  }
}

return icCmmStatOk;
6231}


6234/**
**************************************************************************
* Name: CIccXformNDLut::Apply
* 
* Purpose: 
*  Does the actual application of the Xform.
*  
* Args:
*  pApply = ApplyXform object containging temporary storage used during Apply
*  DstPixel = Destination pixel where the result is stored,
*  SrcPixel = Source pixel which is to be applied.
**************************************************************************
*/
6247void CIccXformNDLut::Apply(CIccApplyXform* pApply, icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
6248{
icFloatNumber Pixel[16];
int i;

SrcPixel = CheckSrcAbs(pApply, SrcPixel);
for (i=0; i<m_nNumInput; i++)
1
Assuming 'i' is >= field 'm_nNumInput'→
2
←
Loop condition is false. Execution continues on line 6256→
  Pixel[i] = SrcPixel[i];

if (m_pTag->m_bInputMatrix) {
3
←
Assuming field 'm_bInputMatrix' is true→
4
←
Taking true branch→
  if (m_ApplyCurvePtrB) {
5
←
Assuming field 'm_ApplyCurvePtrB' is null→
6
←
Taking false branch→
    for (i=0; i<m_nNumInput; i++)
      Pixel[i] = m_ApplyCurvePtrB[i]->Apply(Pixel[i]);
  }

  if (m_pTag->m_CLUT) {
7
←
Assuming field 'm_CLUT' is null→
8
←
Taking false branch→
    switch(m_nNumInput) {
    case 5:
      m_pTag->m_CLUT->Interp5d(Pixel, Pixel);
      break;
    case 6:
      m_pTag->m_CLUT->Interp6d(Pixel, Pixel);
      break;
    default:
      m_pTag->m_CLUT->InterpND(Pixel, Pixel);
      break;
    }
  }

  if (m_ApplyCurvePtrA) {
9
←
Assuming field 'm_ApplyCurvePtrA' is null→
10
←
Taking false branch→
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrA[i]->Apply(Pixel[i]);
    }
  }

}
else {
  if (m_ApplyCurvePtrA) {
    for (i=0; i<m_nNumInput; i++)
      Pixel[i] = m_ApplyCurvePtrA[i]->Apply(Pixel[i]);
  }

  if (m_pTag->m_CLUT) {
    switch(m_nNumInput) {
    case 5:
      m_pTag->m_CLUT->Interp5d(Pixel, Pixel);
      break;
    case 6:
      m_pTag->m_CLUT->Interp6d(Pixel, Pixel);
      break;
    default:
      m_pTag->m_CLUT->InterpND(Pixel, Pixel);
      break;
    }
  }

  if (m_ApplyCurvePtrM) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrM[i]->Apply(Pixel[i]);
    }
  }

  if (m_ApplyMatrixPtr) {
    m_ApplyMatrixPtr->Apply(Pixel);
  }

  if (m_ApplyCurvePtrB) {
    for (i=0; i<m_pTag->m_nOutput; i++) {
      Pixel[i] = m_ApplyCurvePtrB[i]->Apply(Pixel[i]);
    }
  }
}

for (i=0; i<m_pTag->m_nOutput; i++) {
11
←
The value 0 is assigned to 'i'→
12
←
Assuming 'i' is < field 'm_nOutput'→
13
←
Loop condition is true.  Entering loop body→
  DstPixel[i] = Pixel[i];
14
←
Assigned value is garbage or undefined
}

CheckDstAbs(DstPixel);
6325}

6327/**
6328**************************************************************************
6329* Name: CIccXformNDLut::ExtractInputCurves
6330* 
6331* Purpose: 
6332*  Gets the input curves. Should be called only after Begin() 
6333*  has been called. Once the curves are extracted, they will 
6334*  not be used by the Apply() function.
6335*  WARNING:  caller owns the curves and must be deleted by the caller.
6336*  
6337* Return:
6338*  Pointer to the input curves.
6339**************************************************************************
6340*/
6341LPIccCurve* CIccXformNDLut::ExtractInputCurves()
6342{
if (m_bInput) {
if (m_pTag->m_bInputMatrix) {
	if (m_pTag->m_CurvesB) {
		LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nInput];
		for (int i=0; i<m_pTag->m_nInput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesB[i]->NewCopy());
		}
		m_ApplyCurvePtrB = NULL__null;
		return Curve;
	}
}
else {
	if (m_pTag->m_CurvesA) {
		LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nInput];
		for (int i=0; i<m_pTag->m_nInput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesA[i]->NewCopy());
		}
		m_ApplyCurvePtrA = NULL__null;
		return Curve;
	}
}
}

return NULL__null;
6367}

6369/**
6370**************************************************************************
6371* Name: CIccXformNDLut::ExtractOutputCurves
6372* 
6373* Purpose: 
6374*  Gets the output curves. Should be called only after Begin() 
6375*  has been called. Once the curves are extracted, they will 
6376*  not be used by the Apply() function.
6377*  WARNING:  caller owns the curves and must be deleted by the caller.
6378*  
6379* Return:
6380*  Pointer to the output curves.
6381**************************************************************************
6382*/
6383LPIccCurve* CIccXformNDLut::ExtractOutputCurves()
6384{
if (!m_bInput) {
if (m_pTag->m_bInputMatrix) {
	if (m_pTag->m_CurvesA) {
		LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nOutput];
		for (int i=0; i<m_pTag->m_nOutput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesA[i]->NewCopy());
		}
		m_ApplyCurvePtrA = NULL__null;
		return Curve;
	}
}
else {
	if (m_pTag->m_CurvesB) {
		LPIccCurve* Curve = new LPIccCurve[m_pTag->m_nOutput];
		for (int i=0; i<m_pTag->m_nOutput; i++) {
			Curve[i] = (LPIccCurve)(m_pTag->m_CurvesB[i]->NewCopy());
		}
		m_ApplyCurvePtrB = NULL__null;
		return Curve;
	}
}
}

return NULL__null;
6409}

6411/**
**************************************************************************
* Name: CIccXformNamedColor::CIccXformNamedColor
* 
* Purpose: 
*  Constructor
*
* Args:
*  pTag = Pointer to the tag of type CIccTagNamedColor2,
*  csPCS = PCS color space,
*  csDevice = Device color space 
**************************************************************************
*/
6424CIccXformNamedColor::CIccXformNamedColor(CIccTag *pTag, icColorSpaceSignature csPcs, icColorSpaceSignature csDevice, 
                                       icSpectralColorSignature csSpectralPcs/* =icSigNoSpectralData */,
                                       const icSpectralRange *pSpectralRange /* = NULL */,
                                       const icSpectralRange *pBiSpectralRange /* = NULL */)
6428{
if (pTag) {
  if (pTag->GetType()==icSigNamedColor2Type) {
    m_pTag = (CIccTagNamedColor2*)pTag;
    m_pArray = NULL__null;

    m_pTag->SetColorSpaces(csPcs, csDevice);
  }
  else if (pTag->GetTagArrayType()==icSigNamedColorArray) {
    CIccTagArray *pArray = (CIccTagArray*)pTag;
    CIccArrayNamedColor *pNamed = (CIccArrayNamedColor*)pArray->GetArrayHandler();

    if (pNamed) {
      m_pTag = NULL__null;
      m_pArray = pNamed;
      pNamed->SetColorSpaces(csPcs, csDevice, csSpectralPcs, pSpectralRange, pBiSpectralRange);
    }
  }
}

m_nSrcSpace = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
m_nDestSpace = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
6450}


6453/**
**************************************************************************
* Name: CIccXformNamedColor::CIccXformNamedColor
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
6461CIccXformNamedColor::~CIccXformNamedColor()
6462{
6463}

6465/**
**************************************************************************
* Name: CIccXformNamedColor::Begin
* 
* Purpose: 
*  Does the initialization of the Xform before Apply() is called.
*  Must be called before Apply().
*
**************************************************************************
*/
6475icStatusCMM CIccXformNamedColor::Begin()
6476{
icStatusCMM status;

status = CIccXform::Begin();
if (status != icCmmStatOk)
  return status;

if (m_pTag==NULL__null && m_pArray==NULL__null) {
  return icCmmStatProfileMissingTag;
}

if (m_nSrcSpace==icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f) ||
    m_nDestSpace==icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
  return icCmmStatIncorrectApply;
}

if (m_nSrcSpace != icSigNamedData) {
  if (m_nDestSpace != icSigNamedData) {
    m_nApplyInterface = icApplyPixel2Pixel;
  }
  else {
    m_nApplyInterface = icApplyPixel2Named;
  }
}
else {
  if (m_nDestSpace != icSigNamedData) {
    m_nApplyInterface = icApplyNamed2Pixel;
  }
  else {
    return icCmmStatIncorrectApply;
  }
}

if (m_pTag && !m_pTag->InitFindCachedPCSColor())
  return icCmmStatAllocErr;