/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;
else if (m_pArray && !m_pArray->Begin())
  return icCmmStatAllocErr;

return icCmmStatOk;
6515}



6519/**
**************************************************************************
* Name: CIccXformNamedColor::Apply
* 
* Purpose: 
*  Does the actual application of the Xform.
*  
* Args:
*  pApply = ApplyXform object containging temporary storage used during Apply
*  DstColorName = Destination string where the color name result is stored,
*  SrcPixel = Source pixel which is to be applied.
**************************************************************************
*/
6532icStatusCMM CIccXformNamedColor::Apply(CIccApplyXform* pApply, icChar *DstColorName, const icFloatNumber *SrcPixel) const
6533{

if (m_pArray) {
  const CIccArrayNamedColor *pArray = m_pArray;
  CIccStructNamedColor *pColor;

  std::string NamedColor;

  if (IsSrcPCS()) {
    if (IsSpaceSpectralPCS(m_nSrcSpace)) {
      pColor = pArray->FindSpectralColor(SrcPixel);
      if (pColor)
        NamedColor = pColor->getName();
      else 
        return icCmmStatColorNotFound;
    }
    else {
      SrcPixel = CheckSrcAbs(pApply, SrcPixel);
      icFloatNumber pix[3];
      memcpy(pix, SrcPixel, 3*sizeof(icFloatNumber));

      if (m_nSrcSpace == icSigLabPcsDataicSigLabData)
        icLabFromPcs(pix);
      else {
        icXyzFromPcs(pix);
        icXYZtoLab(pix, pix);
      }

      pColor = pArray->FindPcsColor(pix);
      if (pColor) 
        NamedColor = pColor->getName();
      else 
        return icCmmStatColorNotFound;
    }
  }
  else {
    pColor = pArray->FindDeviceColor(SrcPixel);
    if (pColor)
      NamedColor = pColor->getName();
    else 
      return icCmmStatColorNotFound;
  }

  sprintf(DstColorName, "%s", NamedColor.c_str());
}
else if (m_pTag) {
  const CIccTagNamedColor2 *pTag = m_pTag;

  icFloatNumber DevicePix[16], PCSPix[3];
  std::string NamedColor;
  icUInt32Number i, j;

  if (IsSrcPCS()) {
    SrcPixel = CheckSrcAbs(pApply, SrcPixel);
    for(i=0; i<3; i++)
      PCSPix[i] = SrcPixel[i];

    j = pTag->FindCachedPCSColor(PCSPix);
    pTag->GetColorName(NamedColor, j);
  }
  else {
    for(i=0; i<m_pTag->GetDeviceCoords(); i++)
      DevicePix[i] = SrcPixel[i];

    j = pTag->FindDeviceColor(DevicePix);
    pTag->GetColorName(NamedColor, j);
  }

  sprintf(DstColorName, "%s", NamedColor.c_str());
}
else
  return icCmmStatBadXform;

return icCmmStatOk;
6607}


6610/**
6611**************************************************************************
6612* Name: CIccXformNamedColor::Apply
6613* 
6614* Purpose: 
6615*  Does the actual application of the Xform.
6616*  
6617* Args:
6618*  pApply = ApplyXform object containing temporary storage used during Apply
6619*  DstPixel = Destination pixel where the result is stored,
6620*  SrcColorName = Source color name which is to be applied.
6621**************************************************************************
6622*/
6623icStatusCMM CIccXformNamedColor::Apply(CIccApplyXform* pApply, icFloatNumber *DstPixel, const icChar *SrcColorName, icFloatNumber tint) const
6624{

if (m_pArray) {
  const CIccArrayNamedColor *pArray = m_pArray;

  CIccStructNamedColor *pColor;

  if (m_nSrcSpace != icSigNamedData)
    return icCmmStatBadSpaceLink;

  pColor = pArray->FindColor(SrcColorName);
  if (!pColor)
    return icCmmStatColorNotFound;

  if (IsDestPCS()) {
    if (IsSpaceSpectralPCS(m_nDestSpace)) {
      if (!pArray->GetSpectralTint(DstPixel, pColor, tint))
        return icCmmStatBadTintXform;
    }
    else {
      if (!pArray->GetPcsTint(DstPixel, pColor, tint))
        return icCmmStatBadTintXform;

      if (m_nDestSpace == icSigLabData) {
        icLabToPcs(DstPixel);
      }
      else {
        icXyzToPcs(DstPixel);
      }
      CheckDstAbs(DstPixel);
    }
  }
  else {
    if (!pArray->GetDeviceTint(DstPixel, pColor, tint))
      return icCmmStatBadTintXform;
  }
}
else if (m_pTag) {
  const CIccTagNamedColor2 *pTag = m_pTag;

  icInt32Number j;

  if (m_nSrcSpace != icSigNamedData)
    return icCmmStatBadSpaceLink;

  if (IsDestPCS()) {

    j = pTag->FindColor(SrcColorName);
    if (j<0)
      return icCmmStatColorNotFound;

    if (m_nDestSpace == icSigLabData) {
      memcpy(DstPixel, pTag->GetEntry(j)->pcsCoords, 3*sizeof(icFloatNumber));
    }
    else {
      memcpy(DstPixel, pTag->GetEntry(j)->pcsCoords, 3*sizeof(icFloatNumber));
    }
    CheckDstAbs(DstPixel);
  }
  else {
    j = pTag->FindColor(SrcColorName);
    if (j<0)
      return icCmmStatColorNotFound;
    memcpy(DstPixel, pTag->GetEntry(j)->deviceCoords, pTag->GetDeviceCoords()*sizeof(icFloatNumber));
  }
}

return icCmmStatOk;
6692}

6694/**
**************************************************************************
* Name: CIccXformNamedColor::SetSrcSpace
* 
* Purpose: 
*  Sets the source space of the Xform
*  
* Args:
*  nSrcSpace = signature of the color space to be set
**************************************************************************
*/
6705icStatusCMM CIccXformNamedColor::SetSrcSpace(icColorSpaceSignature nSrcSpace)
6706{
if (m_pArray) {

}
else if (m_pTag) {
  CIccTagNamedColor2 *pTag = m_pTag;

  if (nSrcSpace!=pTag->GetPCS())
    if (nSrcSpace!=pTag->GetDeviceSpace())
      if (nSrcSpace!=icSigNamedData)
        return icCmmStatBadSpaceLink;
}

m_nSrcSpace = nSrcSpace;

return icCmmStatOk;
6722}

6724/**
**************************************************************************
* Name: CIccXformNamedColor::SetDestSpace
* 
* Purpose: 
*  Sets the destination space of the Xform
*  
* Args:
*  nDestSpace = signature of the color space to be set
**************************************************************************
*/
6735icStatusCMM CIccXformNamedColor::SetDestSpace(icColorSpaceSignature nDestSpace)
6736{
if (m_nSrcSpace == nDestSpace)
  return icCmmStatBadSpaceLink;

if (m_pArray) {

}
else if (m_pTag) {
  CIccTagNamedColor2 *pTag = (CIccTagNamedColor2*)m_pTag;

  if (nDestSpace!=pTag->GetPCS())
    if (nDestSpace!=pTag->GetDeviceSpace())
      if (nDestSpace!=icSigNamedData)
        return icCmmStatBadSpaceLink;
}

m_nDestSpace = nDestSpace;

return icCmmStatOk;
6755}

6757/**
**************************************************************************
* Name: CIccXformNamedColor::IsSrcPCS
* 
* Purpose: 
*  Sets the source space is a PCS space
**************************************************************************
*/
6765bool CIccXformNamedColor::IsSrcPCS() const
6766{
if (m_pTag) {
  return m_nSrcSpace == m_pTag->GetPCS();
}
else if (m_pArray) {
  return IsSpacePCS(m_nSrcSpace)(((m_nSrcSpace)==icSigXYZData || (m_nSrcSpace)==icSigLabData)
 || IsSpaceSpectralPCS(m_nSrcSpace));
}
else 
  return false;
6775}


6778/**
**************************************************************************
* Name: CIccXformNamedColor::IsDestPCS
* 
* Purpose: 
*  Sets the destination space is a PCS space
**************************************************************************
*/
6786bool CIccXformNamedColor::IsDestPCS() const
6787{
if (m_pTag) {
  return m_nDestSpace == m_pTag->GetPCS();
}
else if (m_pArray) {
  return IsSpacePCS(m_nDestSpace)(((m_nDestSpace)==icSigXYZData || (m_nDestSpace)==icSigLabData
) || IsSpaceSpectralPCS(m_nDestSpace));
}
else 
  return false;
6796}


6799/**
6800**************************************************************************
6801* Name: CIccXformMPE::CIccXformMPE
6802* 
6803* Purpose: 
6804*  Constructor
6805**************************************************************************
6806*/
6807CIccXformMpe::CIccXformMpe(CIccTag *pTag)
6808{
if (pTag && pTag->GetType()==icSigMultiProcessElementType)
  m_pTag = (CIccTagMultiProcessElement*)pTag;
else
  m_pTag = NULL__null;

m_bUsingAcs = false;
m_pAppliedPCC = NULL__null;
m_bDeleteAppliedPCC = false;
6817}

6819/**
6820**************************************************************************
6821* Name: CIccXformMPE::~CIccXformMPE
6822* 
6823* Purpose: 
6824*  Destructor
6825**************************************************************************
6826*/
6827CIccXformMpe::~CIccXformMpe()
6828{
if (m_pAppliedPCC && m_bDeleteAppliedPCC)
  delete m_pAppliedPCC;
6831}

6833/**
6834**************************************************************************
6835* Name: CIccXformMPE::Create
6836* 
6837* Purpose:
6838*  This is a static Creation function that creates derived CIccXform objects and
6839*  initializes them.
6840* 
6841* Args: 
6842*  pProfile = pointer to a CIccProfile object that will be owned by the transform.  This object will
6843*   be destroyed when the returned CIccXform object is destroyed.  The means that the CIccProfile
6844*   object needs to be allocated on the heap.
6845*  bInput = flag to indicate whether to use the input or output side of the profile,
6846*  nIntent = the rendering intent to apply to the profile,   
6847*  nInterp = the interpolation algorithm to use for N-D luts.
6848*  nLutType = selection of which transform lut to use
6849*  pHintManager = hints for creating the xform
6850* 
6851* Return: 
6852*  A suitable pXform object
6853**************************************************************************
6854*/
6855CIccXform *CIccXformMpe::Create(CIccProfile *pProfile, bool bInput/* =true */, icRenderingIntent nIntent/* =icUnknownIntent */,
														icXformInterp nInterp/* =icInterpLinear */, icXformLutType nLutType/* =icXformLutColor */, 
														CIccCreateXformHintManager *pHintManager/* =NULL */)
6858{
CIccXform *rv = NULL__null;
icRenderingIntent nTagIntent = nIntent;
bool bUseSpectralPCS = false;
bool bAbsToRel = false;
icXformLutType nUseLutType = nLutType;
bool bUseColorimeticTags = true;
bool bUseDToB = true;

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

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

switch (nUseLutType) {
  case icXformLutColor:
    if (bInput) {
      CIccTag *pTag = NULL__null;
      if (bUseDToB) {
        pTag = pProfile->FindTag(icSigDToB0Tag + nTagIntent);

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

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

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

      if (pTag && pProfile->m_Header.spectralPCS) {
        bUseSpectralPCS = true;
      }

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

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

      if (!pTag) {
        if (bUseColorimeticTags && pProfile->m_Header.colorSpace == icSigRgbData && pProfile->m_Header.version < icVersionNumberV50x05000000) {
          rv = new CIccXformMatrixTRC();
        }
        else
          return NULL__null;
      }
      else if (pTag->GetType()==icSigMultiProcessElementType) {
        rv = new CIccXformMpe(pTag);
      }
      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 = new CIccXform3DLut(pTag);
            break;

          case icSigCmykData:
          case icSig4colorData:
            rv = new CIccXform4DLut(pTag);
            break;

          default:
            rv = new CIccXformNDLut(pTag);
            break;
        }
      }
    }
    else {
      CIccTag *pTag = NULL__null; 
      
      if (bUseDToB) {
        pTag = pProfile->FindTag(icSigBToD0Tag + nTagIntent);

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

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

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

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

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

      if (!pTag) {
        if (bUseColorimeticTags && pProfile->m_Header.colorSpace == icSigRgbData && pProfile->m_Header.version<icVersionNumberV50x05000000) {
          rv = new CIccXformMatrixTRC();
        }
        else
          return NULL__null;
      }

      if (pTag->GetType()==icSigMultiProcessElementType) {
        rv = new CIccXformMpe(pTag);
      }
      else {
        switch(pProfile->m_Header.pcs) {
          case icSigXYZData:
          case icSigLabData:
            rv = new CIccXform3DLut(pTag);

          default:
            break;
        }
      }
    }
    break;

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

      rv = new CIccXformNamedColor(pTag, pProfile->m_Header.pcs, pProfile->m_Header.colorSpace,
                                   pProfile->m_Header.spectralPCS,
                                   &pProfile->m_Header.spectralRange,
                                   &pProfile->m_Header.biSpectralRange);
    }
    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 = new CIccXform3DLut(pTag);

          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 = new CIccXform3DLut(pTag);

          default:
            break;
        }
      }
    }
    break;
}

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

return rv;
7086}

7088/**
7089**************************************************************************
7090* Name: CIccXformMPE::IsLateBinding
7091* 
7092* Purpose: 
7093*  Determines if any processing elements are late binding with connection
7094*  conditions
7095**************************************************************************
7096*/
7097bool CIccXformMpe::IsLateBinding() const
7098{
if (m_pTag)
  return m_pTag->IsLateBinding();

return false;
7103}

7105/**
7106**************************************************************************
7107* Name: CIccXformMPE::IsLateBindingReflectance
7108* 
7109* Purpose: 
7110*  Determines if any processing elements are late binding with connection
7111*  conditions
7112**************************************************************************
7113*/
7114bool CIccXformMpe::IsLateBindingReflectance() const
7115{
if (m_pTag)
  return m_pTag->IsLateBindingReflectance();

return false;
7120}

7122/**
7123**************************************************************************
7124* Name: CIccXformMPE::GetConnectionConditions
7125* 
7126* Purpose: 
7127*  Gets appropriate connection conditions
7128**************************************************************************
7129*/
7130IIccProfileConnectionConditions *CIccXformMpe::GetConnectionConditions() const
7131{
if (m_pAppliedPCC)
  return m_pAppliedPCC;

return m_pConnectionConditions;
7136}

7138/**
7139**************************************************************************
7140* Name: CIccXformMPE::SetAppliedCC
7141* 
7142* Purpose: 
7143*  This creates combined connection conditions based on profile, 
7144*  alternate connection conditions and whether reflectance is used
7145*  by any late binding processing elements.
7146**************************************************************************
7147*/
7148void CIccXformMpe::SetAppliedCC(IIccProfileConnectionConditions *pPCC)
7149{
if (!pPCC) {
  if (m_pAppliedPCC && m_bDeleteAppliedPCC) {
    delete m_pAppliedPCC;
  }
  m_pAppliedPCC = NULL__null;
  m_bDeleteAppliedPCC = false;
  return;
}

if (m_pTag) {
  bool bReflectance = m_pTag->IsLateBindingReflectance();

  if (pPCC != (IIccProfileConnectionConditions *)m_pProfile) {
    if (!bReflectance) {
      const CIccTagSpectralViewingConditions *pViewPCC = pPCC ? pPCC->getPccViewingConditions() : NULL__null;
      const CIccTagSpectralViewingConditions *pViewProfile = m_pProfile ? m_pProfile->getPccViewingConditions() : NULL__null;

      if (pViewPCC && pViewProfile &&
        pViewPCC->getStdIllumiant() == pViewProfile->getStdIllumiant() &&
        pViewPCC->getIlluminantCCT() == pViewProfile->getIlluminantCCT() &&
        pViewPCC->getStdIllumiant() != icIlluminantUnknown) {
        m_pAppliedPCC = pPCC;
        m_bDeleteAppliedPCC = false;
      }
      else {
        m_pAppliedPCC = new CIccCombinedConnectionConditions(m_pProfile, pPCC, bReflectance);
        m_bDeleteAppliedPCC = true;
      }
    }
    else {
      m_pAppliedPCC = new CIccCombinedConnectionConditions(m_pProfile, pPCC, bReflectance);
      m_bDeleteAppliedPCC = true;
    }
  }
  else {
    m_pAppliedPCC = NULL__null;
  }
}
else {
  m_pAppliedPCC = pPCC;
  m_bDeleteAppliedPCC = false;
}
7192}


7195/**
7196**************************************************************************
7197* Name: CIccXformMPE::Begin
7198* 
7199* Purpose: 
7200*  This function will be called before the xform is applied.  Derived objects
7201*  should also call the base class function to initialize for Absolute Colorimetric
7202*  Intent handling which is performed through the use of the CheckSrcAbs and
7203*  CheckDstAbs functions.
7204**************************************************************************
7205*/
7206icStatusCMM CIccXformMpe::Begin()
7207{
icStatusCMM status;
status = CIccXform::Begin();

if (status != icCmmStatOk)
  return status;

if (!m_pTag) {
  return icCmmStatInvalidLut;
}

if (!m_pTag->Begin(icElemInterpLinear, GetProfileCC(), GetConnectionConditions(), GetCmmEnvVarLookup())) {
  return icCmmStatInvalidProfile;
}

return icCmmStatOk;
7223}


7226/**
7227**************************************************************************
7228* Name: CIccXformMpe::GetNewApply
7229* 
7230* Purpose: 
7231*  This Factory function allocates data specific for the application of the xform.
7232*  This allows multiple threads to simultaneously use the same xform.
7233**************************************************************************
7234*/
7235CIccApplyXform *CIccXformMpe::GetNewApply(icStatusCMM &status)
7236{
if (!m_pTag)
  return NULL__null;

CIccApplyXformMpe *rv= new CIccApplyXformMpe(this); 

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

rv->m_pApply = m_pTag->GetNewApply();
if (!rv->m_pApply) {
  status = icCmmStatAllocErr;
  delete rv;
  return NULL__null;
}

status = icCmmStatOk;
return rv;
7256}


7259/**
7260**************************************************************************
7261* Name: CIccXformMPE::Apply
7262* 
7263* Purpose: 
7264*  Does the actual application of the Xform.
7265*  
7266* Args:
7267*  pApply = ApplyXform object containging temporary storage used during Apply
7268*  DstPixel = Destination pixel where the result is stored,
7269*  SrcPixel = Source pixel which is to be applied.
7270**************************************************************************
7271*/
7272void CIccXformMpe::Apply(CIccApplyXform* pApply, icFloatNumber *DstPixel, const icFloatNumber *SrcPixel) const
7273{
const CIccTagMultiProcessElement *pTag = m_pTag;

if (!m_bInput) { //PCS comming in?
  if (m_nIntent != icAbsoluteColorimetric || m_nIntent != m_nTagIntent) {  //B2D3 tags don't need abs conversion
    SrcPixel = CheckSrcAbs(pApply, SrcPixel);
  }

  //Since MPE tags use "real" values for PCS we need to convert from 
  //internal encoding used by IccProfLib
  icFloatNumber temp[3];
  switch (GetSrcSpace()) {
    case icSigXYZData:
      memcpy(&temp[0], SrcPixel, 3*sizeof(icFloatNumber));
      icXyzFromPcs(temp);
      SrcPixel = &temp[0];
      break;

    case icSigLabData:
      memcpy(&temp[0], SrcPixel, 3*sizeof(icFloatNumber));
      icLabFromPcs(temp);
      SrcPixel = &temp[0];
      break;

    default:
      break;
  }
}

//Note: pApply should be a CIccApplyXformMpe type here
CIccApplyXformMpe *pApplyMpe = (CIccApplyXformMpe *)pApply;

pTag->Apply(pApplyMpe->m_pApply, DstPixel, SrcPixel);

if (m_bInput) { //PCS going out?
  //Since MPE tags use "real" values for PCS we need to convert to
  //internal encoding used by IccProfLib
  switch(GetDstSpace()) {
    case icSigXYZData:
      icXyzToPcs(DstPixel);
      break;

    case icSigLabData:
      icLabToPcs(DstPixel);
      break;

    default:
      break;
  }

  if (m_nIntent != icAbsoluteColorimetric || m_nIntent != m_nTagIntent) { //D2B3 tags don't need abs conversion
    CheckDstAbs(DstPixel);
  }
}
7327}

7329/**
7330**************************************************************************
7331* Name: CIccApplyXformMpe::CIccApplyXformMpe
7332* 
7333* Purpose: 
7334*  Constructor
7335**************************************************************************
7336*/
7337CIccApplyXformMpe::CIccApplyXformMpe(CIccXformMpe *pXform) : CIccApplyXform(pXform)
7338{
7339}

7341/**
7342**************************************************************************
7343* Name: CIccApplyXformMpe::~CIccApplyXformMpe
7344* 
7345* Purpose: 
7346*  Destructor
7347**************************************************************************
7348*/
7349CIccApplyXformMpe::~CIccApplyXformMpe()
7350{
7351}


7354/**
7355**************************************************************************
7356* Name: CIccApplyCmm::CIccApplyCmm
7357* 
7358* Purpose: 
7359*  Constructor
7360*
7361* Args:
7362*  pCmm = ptr to CMM to apply against
7363**************************************************************************
7364*/
7365CIccApplyCmm::CIccApplyCmm(CIccCmm *pCmm)
7366{
m_pCmm = pCmm;
m_pPCS = m_pCmm->GetPCS();

m_Xforms = new CIccApplyXformList;
m_Xforms->clear();

m_Pixel = NULL__null;
m_Pixel2 = NULL__null;
7375}

7377/**
7378**************************************************************************
7379* Name: CIccApplyCmm::~CIccApplyCmm
7380* 
7381* Purpose: 
7382*  Destructor
7383**************************************************************************
7384*/
7385CIccApplyCmm::~CIccApplyCmm()
7386{
if (m_Xforms) {
  CIccApplyXformList::iterator i;

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

  delete m_Xforms;
}

if (m_pPCS)
  delete m_pPCS;

if (m_Pixel)
  free(m_Pixel);
if (m_Pixel2)
  free(m_Pixel2);
7405}

7407bool CIccApplyCmm::InitPixel()
7408{
if (m_Pixel && m_Pixel2)
  return true;

icUInt16Number nSamples = 16;
CIccApplyXformList::iterator i;

for (i=m_Xforms->begin(); i!=m_Xforms->end(); i++) {
  if (i->ptr->GetXform()) {
    icUInt16Number nXformSamples = i->ptr->GetXform()->GetNumDstSamples();
    if (nXformSamples>nSamples)
      nSamples=nXformSamples;
  }
}
m_Pixel = (icFloatNumber*)malloc(nSamples*sizeof(icFloatNumber));
m_Pixel2 = (icFloatNumber*)malloc(nSamples*sizeof(icFloatNumber));

if (!m_Pixel || !m_Pixel2)
  return false;

return true;
7429}


7432/**
7433**************************************************************************
7434* Name: CIccApplyCmm::Apply
7435* 
7436* Purpose: 
7437*  Does the actual application of the Xforms in the list.
7438*  
7439* Args:
7440*  DstPixel = Destination pixel where the result is stored,
7441*  SrcPixel = Source pixel which is to be applied.
7442**************************************************************************
7443*/
7444icStatusCMM CIccApplyCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel)
7445{
icFloatNumber *pDst, *pTmp;
const icFloatNumber *pSrc;
CIccApplyXformList::iterator i;
const CIccXform *pLastXform;
int j, n = (int)m_Xforms->size();
bool bNoClip;

if (!n)
  return icCmmStatBadXform;

if (!m_Pixel && !InitPixel()) {
  return icCmmStatAllocErr;
}

m_pPCS->Reset(m_pCmm->m_nSrcSpace);

pSrc = SrcPixel;
pDst = m_Pixel;

if (n>1) {
  for (j=0, i=m_Xforms->begin(); j<n-1 && i!=m_Xforms->end(); i++, j++) {

    i->ptr->Apply(pDst, m_pPCS->Check(pSrc, i->ptr->GetXform()));
    pTmp = (icFloatNumber*)pSrc;
    pSrc = pDst;
    if (pTmp == SrcPixel)
      pDst = m_Pixel2;
    else
      pDst = pTmp;
  }

  pLastXform = i->ptr->GetXform();   
  i->ptr->Apply(DstPixel, m_pPCS->Check(pSrc, pLastXform));
  bNoClip = pLastXform->NoClipPCS();
}
else if (n==1) {
  i = m_Xforms->begin();

  pLastXform = i->ptr->GetXform();
  i->ptr->Apply(DstPixel, m_pPCS->Check(SrcPixel, pLastXform));
  bNoClip = pLastXform->NoClipPCS();
}
else {
  bNoClip = true;
}

m_pPCS->CheckLast(DstPixel, m_pCmm->m_nDestSpace, bNoClip);

return icCmmStatOk;
7495}

7497/**
7498**************************************************************************
7499* Name: CIccApplyCmm::Apply
7500* 
7501* Purpose: 
7502*  Does the actual application of the Xforms in the list.
7503*  
7504* Args:
7505*  DstPixel = Destination pixel where the result is stored,
7506*  SrcPixel = Source pixel which is to be applied.
7507**************************************************************************
7508*/
7509icStatusCMM CIccApplyCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel, icUInt32Number nPixels)
7510{
icFloatNumber *pDst, *pTmp;
const icFloatNumber *pSrc;
CIccApplyXformList::iterator i;
int j, n = (int)m_Xforms->size();
icUInt32Number k;

if (!n)
  return icCmmStatBadXform;

if (!m_Pixel && !InitPixel()) {
  return icCmmStatAllocErr;
}

for (k=0; k<nPixels; k++) {
  m_pPCS->Reset(m_pCmm->m_nSrcSpace);

  pSrc = SrcPixel;
  pDst = m_Pixel;

  if (n>1) {
    for (j=0, i=m_Xforms->begin(); j<n-1 && i!=m_Xforms->end(); i++, j++) {

      i->ptr->Apply(pDst, m_pPCS->Check(pSrc, i->ptr->GetXform()));
      pTmp = (icFloatNumber*)pSrc;
      pSrc = pDst;
      if (pTmp==SrcPixel)
        pDst = m_Pixel2;
      else
        pDst = pTmp;
    }

    i->ptr->Apply(DstPixel, m_pPCS->Check(pSrc, i->ptr->GetXform()));
  }
  else if (n==1) {
    i = m_Xforms->begin();
    i->ptr->Apply(DstPixel, m_pPCS->Check(SrcPixel, i->ptr->GetXform()));
  }

  m_pPCS->CheckLast(DstPixel, m_pCmm->m_nDestSpace);

  DstPixel += m_pCmm->GetDestSamples();
  SrcPixel += m_pCmm->GetSourceSamples();
}

return icCmmStatOk;
7556}

7558void CIccApplyCmm::AppendApplyXform(CIccApplyXform *pApplyXform)
7559{
CIccApplyXformPtr ptr;
ptr.ptr = pApplyXform;

m_Xforms->push_back(ptr);
7564}

7566/**
**************************************************************************
* Name: CIccCmm::CIccCmm
* 
* Purpose: 
*  Constructor
*
* Args:
*  nSrcSpace = signature of the source color space,
*  nDestSpace = signature of the destination color space,
*  bFirstInput = true if the first profile added is an input profile
**************************************************************************
*/
7579CIccCmm::CIccCmm(icColorSpaceSignature nSrcSpace /*=icSigUnknownData*/,
               icColorSpaceSignature nDestSpace /*=icSigUnknownData*/,
               bool bFirstInput /*=true*/)
7582{
m_bValid = false;

m_bLastInput = !bFirstInput;
m_nSrcSpace = nSrcSpace;
m_nDestSpace = nDestSpace;

m_nLastSpace = nSrcSpace;
m_nLastIntent = icUnknownIntent((icRenderingIntent) 0x3f3f3f3f);

m_Xforms = new CIccXformList;
m_Xforms->clear();

m_pApply = NULL__null;
7596}

7598/**
**************************************************************************
* Name: CIccCmm::~CIccCmm
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
7606CIccCmm::~CIccCmm()
7607{
if (m_Xforms) {
  CIccXformList::iterator i;

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

  delete m_Xforms;
}

if (m_pApply)
  delete m_pApply;
7621}

7623const icChar* CIccCmm::GetStatusText(icStatusCMM stat)
7624{
switch (stat) {
case icCmmStatBad:
  return "Bad CMM";
case icCmmStatOk:
  return "OK";
case icCmmStatCantOpenProfile:
  return "Cannot open profile";
case icCmmStatBadSpaceLink:
  return "Invalid space link";
case icCmmStatInvalidProfile:
  return "Invalid profile";
case icCmmStatBadXform:
  return "Invalid profile transform";
case icCmmStatInvalidLut:
  return "Invalid Look-Up Table";
case icCmmStatProfileMissingTag:
  return "Missing tag in profile";
case icCmmStatColorNotFound:
  return "Color not found";
case icCmmStatIncorrectApply:
  return "Incorrect Apply object";
case icCmmStatBadColorEncoding:
  return "Invalid color encoding used";
case icCmmStatAllocErr:
  return "Memory allocation error";
case icCmmStatBadLutType:
  return "Invalid Look-Up Table type";
case icCmmStatIdentityXform:
  return "Identity transform used";
case icCmmStatUnsupportedPcsLink:
  return "Unsupported PCS Link used";
case icCmmStatBadConnection:
  return "Invalid profile connection";
case icCmmStatBadTintXform:
  return "Invalid tint transform";
case icCmmStatTooManySamples:
  return "Too many samples used";
case icCmmStatBadMCSLink:
  return "Invalid MCS link connection";
default:
  return "Unknown CMM Status value";

}
7668}

7670/**
**************************************************************************
* Name: CIccCmm::AddXform
* 
* Purpose: 
*  Adds a profile at the end of the Xform list 
* 
* Args: 
*  szProfilePath = file name of the profile to be added,
*  nIntent = rendering intent to be used with the profile,
*  nInterp = type of interpolation to be used with the profile,
*  nLutType = selection of which transform lut to use
*  pHintManager = hints for creating the xform
* 
* Return: 
*  icCmmStatOk, if the profile was added to the list succesfully
**************************************************************************
*/
7688icStatusCMM CIccCmm::AddXform(const icChar *szProfilePath,
                            icRenderingIntent nIntent /*=icUnknownIntent*/,
                            icXformInterp nInterp /*icXformInterp*/,
                            IIccProfileConnectionConditions *pPcc/*=NULL*/,
                            icXformLutType nLutType /*=icXformLutColor*/,
                            bool bUseD2BxB2DxTags /*=true*/,
                            CIccCreateXformHintManager *pHintManager /*=NULL*/,
                            bool bUseSubProfile /*=false*/)
7696{
CIccProfile *pProfile = OpenIccProfile(szProfilePath, bUseSubProfile);

if (!pProfile) 
  return icCmmStatCantOpenProfile;

icStatusCMM rv = AddXform(pProfile, nIntent, nInterp, pPcc, nLutType, bUseD2BxB2DxTags, pHintManager);

if (rv != icCmmStatOk)
  delete pProfile;

return rv;
7708}


7711/**
7712**************************************************************************
7713* Name: CIccCmm::AddXform
7714* 
7715* Purpose: 
7716*  Adds a profile at the end of the Xform list 
7717* 
7718* Args: 
7719*  pProfileMem = ptr to profile loaded into memory. Note: this memory
7720*   needs to be available until after the Begin() function is called.
7721*  nProfileLen = size in bytes of profile loaded into memory
7722*  nIntent = rendering intent to be used with the profile,
7723*  nInterp = type of interpolation to be used with the profile,
7724*  nLutType = selection of which transform lut to use
7725*  bUseD2BxB2DxTags = flag to indicate the use MPE flags if available
7726*  pHintManager = hints for creating the xform
7727* 
7728* Return: 
7729*  icCmmStatOk, if the profile was added to the list succesfully
7730**************************************************************************
7731*/
7732icStatusCMM CIccCmm::AddXform(icUInt8Number *pProfileMem,
                            icUInt32Number nProfileLen,
                            icRenderingIntent nIntent /*=icUnknownIntent*/,
                            icXformInterp nInterp /*icXformInterp*/,
                            IIccProfileConnectionConditions *pPcc/*=NULL*/,
                            icXformLutType nLutType /*=icXformLutColor*/,
                            bool bUseD2BxB2DxTags /*=true*/,
                            CIccCreateXformHintManager *pHintManager /*=NULL*/,
                            bool bUseSubProfile /*=false*/)
7741{
CIccMemIO *pFile = new CIccMemIO;

if (!pFile || !pFile->Attach(pProfileMem, nProfileLen, bUseSubProfile))
  return icCmmStatCantOpenProfile;

CIccProfile *pProfile = new CIccProfile;

if (!pProfile)
  return icCmmStatCantOpenProfile;

if (!pProfile->Attach(pFile)) {
  delete pFile;
  delete pProfile;
  return icCmmStatCantOpenProfile;
}

icStatusCMM rv = AddXform(pProfile, nIntent, nInterp, pPcc, nLutType, bUseD2BxB2DxTags, pHintManager);

if (rv != icCmmStatOk)
  delete pProfile;

return rv;
7764}


7767/**
**************************************************************************
* Name: CIccCmm::AddXform
* 
* Purpose: 
*  Adds a profile at the end of the Xform list 
* 
* Args: 
*  pProfile = pointer to the CIccProfile object to be added,
*  nIntent = rendering intent to be used with the profile,
*  nInterp = type of interpolation to be used with the profile,
*  nLutType = selection of which transform lut to use
*  bUseD2BxB2DxTags = flag to indicate the use MPE flags if available
*  pHintManager = hints for creating the xform
* 
* Return: 
*  icCmmStatOk, if the profile was added to the list succesfully
**************************************************************************
*/
7786icStatusCMM CIccCmm::AddXform(CIccProfile *pProfile,
                            icRenderingIntent nIntent /*=icUnknownIntent*/,
                            icXformInterp nInterp /*=icInterpLinear*/,
                            IIccProfileConnectionConditions *pPcc/*=NULL*/,
                            icXformLutType nLutType /*=icXformLutColor*/,
                            bool bUseD2BxB2DxTags /*=true*/,
                            CIccCreateXformHintManager *pHintManager /*=NULL*/)
7793{
icColorSpaceSignature nSrcSpace, nDstSpace;
bool bInput = !m_bLastInput;

if (!pProfile)
  return icCmmStatInvalidProfile;

switch(pProfile->m_Header.deviceClass) {
  case icSigMaterialIdentificationClass:
  case icSigMaterialVisualizationClass:
  case icSigMaterialLinkClass:
    nIntent = icPerceptual;
    nLutType = icXformLutMCS;

  default:
    break;
}

switch (nLutType) {
  case icXformLutColor:
  case icXformLutColorimetric:
  case icXformLutSpectral:
  {
    //Check pProfile if nIntent and input can be found.
    if (bInput) {
      nSrcSpace = pProfile->m_Header.colorSpace;

      if (nLutType == icXformLutSpectral || (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS && nLutType != icXformLutColorimetric))
        nDstSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
      else
        nDstSpace = pProfile->m_Header.pcs;
    }
    else {
      if (pProfile->m_Header.deviceClass == icSigLinkClass) {
        return icCmmStatBadSpaceLink;
      }
      if (pProfile->m_Header.deviceClass == icSigAbstractClass) {
        bInput = true;
        nIntent = icPerceptual; // Note: icPerceptualIntent = 0
      }

      if (nLutType == icXformLutSpectral || (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS && nLutType != icXformLutColorimetric))
        nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
      else
        nSrcSpace = pProfile->m_Header.pcs;

      nDstSpace = pProfile->m_Header.colorSpace;
    }
  }
  break;

  case icXformLutPreview:
    nSrcSpace = pProfile->m_Header.pcs;
    nDstSpace = pProfile->m_Header.pcs;
    bInput = false;
    break;

  case icXformLutGamut:
    nSrcSpace = pProfile->m_Header.pcs;
    nDstSpace = icSigGamutData((icColorSpaceSignature) 0x67616D74);
    bInput = true;
    break;

  case icXformLutBRDFParam:
    if (!bInput)
      return icCmmStatBadSpaceLink;
    nSrcSpace = pProfile->m_Header.colorSpace;
    nDstSpace = icSigBRDFParameters((icColorSpaceSignature) 0x62700000);
    bInput = true;
    break;

  case icXformLutBRDFDirect:
    if (!bInput)
      return icCmmStatBadSpaceLink;
    nSrcSpace = icSigBRDFDirect((icColorSpaceSignature) 0x62640000);
    nDstSpace = pProfile->m_Header.pcs;
    bInput = true;
    break;

  case icXformLutBRDFMcsParam:
    if (!bInput)
      return icCmmStatBadSpaceLink;
    nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.mcs;
    nDstSpace = icSigBRDFParameters((icColorSpaceSignature) 0x62700000);
    break;

  case icXformLutMCS:
    if (bInput) {
      nSrcSpace = pProfile->m_Header.colorSpace;
      nDstSpace = (icColorSpaceSignature)pProfile->m_Header.mcs;
    }
    else {
      if (m_Xforms->size()) {
        CIccXformList::iterator prev = --(m_Xforms->end());
        
        //Make sure previous profile connects with an icXformLutMCS
        if (prev->ptr->GetXformType()!=icXformLutMCS) {
          //check to see if we can convert previous xform to connect via an MCS
          if (!prev->ptr->GetProfile()->m_Header.mcs) {
            return icCmmStatBadMCSLink;
          }

          CIccXform *pPrev = prev->ptr;
          CIccXform *pNew = CIccXform::Create(pPrev->GetProfilePtr(), pPrev->IsInput(), pPrev->GetIntent(), pPrev->GetInterp(),
                                              pPrev->GetConnectionConditions(), icXformLutMCS, bUseD2BxB2DxTags, pHintManager);

          if (pNew) {
            pPrev->DetachAll();
            delete pPrev;
          }

          prev->ptr = pNew;

        }
      }
      else {
        return icCmmStatBadMCSLink;
      }

      nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.mcs;
      if (pProfile->m_Header.deviceClass==icSigMaterialVisualizationClass) {
        if (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS) {
          nDstSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
        }
        else {
          nDstSpace = pProfile->m_Header.pcs;
        }
      }
      else if (pProfile->m_Header.deviceClass==icSigMaterialLinkClass) {
        nDstSpace = pProfile->m_Header.colorSpace;
      }
      else {
        return icCmmStatBadSpaceLink;
      }
    }
    break;

  default:
    return icCmmStatBadLutType;
}

//Make sure colorspaces match with previous xforms
if (!m_Xforms->size()) {
  if (m_nSrcSpace == icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
    m_nLastSpace = nSrcSpace;
    m_nSrcSpace = nSrcSpace;
  }
  else if (!IsCompatSpace(m_nSrcSpace, nSrcSpace)((m_nSrcSpace)==(nSrcSpace) || ((((m_nSrcSpace)==icSigXYZData
 || (m_nSrcSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nSrcSpace
)) && (((nSrcSpace)==icSigXYZData || (nSrcSpace)==icSigLabData
) || IsSpaceSpectralPCS(nSrcSpace))) || ((((icColorSpaceSignature
)(((icUInt32Number)m_nSrcSpace)&0xffff0000))==icSigSrcMCSChannelData
) && (((icColorSpaceSignature)(((icUInt32Number)nSrcSpace
)&0xffff0000))==icSigSrcMCSChannelData)) )) {
    return icCmmStatBadSpaceLink;
  }
}
else if (!IsCompatSpace(m_nLastSpace, nSrcSpace)((m_nLastSpace)==(nSrcSpace) || ((((m_nLastSpace)==icSigXYZData
 || (m_nLastSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nLastSpace
)) && (((nSrcSpace)==icSigXYZData || (nSrcSpace)==icSigLabData
) || IsSpaceSpectralPCS(nSrcSpace))) || ((((icColorSpaceSignature
)(((icUInt32Number)m_nLastSpace)&0xffff0000))==icSigSrcMCSChannelData
) && (((icColorSpaceSignature)(((icUInt32Number)nSrcSpace
)&0xffff0000))==icSigSrcMCSChannelData)) )) {
  return icCmmStatBadSpaceLink;
}

if (nSrcSpace==icSigNamedData)
  return icCmmStatBadSpaceLink;

//Automatic creation of intent from header/last profile
if (nIntent==icUnknownIntent((icRenderingIntent) 0x3f3f3f3f)) {
  if (bInput) {
    nIntent = (icRenderingIntent)pProfile->m_Header.renderingIntent;
  }
  else {
    nIntent = m_nLastIntent;
  }
  if (nIntent == icUnknownIntent((icRenderingIntent) 0x3f3f3f3f))
    nIntent = icPerceptual;
}

CIccXformPtr Xform;

Xform.ptr = CIccXform::Create(pProfile, bInput, nIntent, nInterp, pPcc, nLutType, bUseD2BxB2DxTags, pHintManager);

if (!Xform.ptr) {
  return icCmmStatBadXform;
}

if (pProfile->m_Header.deviceClass==icSigMaterialVisualizationClass) {
  bInput = true;
}

m_nLastSpace = nDstSpace;
m_nLastIntent = nIntent;
m_bLastInput = bInput;

m_Xforms->push_back(Xform);

return icCmmStatOk;
7982}

7984/**
7985**************************************************************************
7986* Name: CIccCmm::AddXform
7987*
7988* Purpose:
7989*  Adds a profile at the end of the Xform list
7990*
7991* Args:
7992*  pProfile = pointer to the CIccProfile object to be added,
7993*  nIntent = rendering intent to be used with the profile,
7994*  nInterp = type of interpolation to be used with the profile,
7995*  nLutType = selection of which transform lut to use
7996*  bUseD2BxB2DxTags = flag to indicate the use MPE flags if available
7997*  pHintManager = hints for creating the xform
7998*
7999* Return:
8000*  icCmmStatOk, if the profile was added to the list succesfully
8001**************************************************************************
8002*/
8003icStatusCMM CIccCmm::AddXform(CIccProfile *pProfile,
                            CIccTag *pXformTag,
                            icRenderingIntent nIntent/*= icUnknownIntent*/,
                            icXformInterp nInterp /*=icInterpLinear*/,
                            IIccProfileConnectionConditions *pPcc/*=NULL*/,
                            bool bUseSpectralPCS /*=false*/,
                            CIccCreateXformHintManager *pHintManager /*=NULL*/)
8010{
icColorSpaceSignature nSrcSpace, nDstSpace;
bool bInput = !m_bLastInput;

if (!pProfile)
  return icCmmStatInvalidProfile;

switch (pProfile->m_Header.deviceClass) {
case icSigMaterialIdentificationClass:
case icSigMaterialVisualizationClass:
case icSigMaterialLinkClass:
  return icCmmStatBadLutType;

default:
  break;
}

//Check pProfile if nIntent and input can be found.
if (bInput) {
  nSrcSpace = pProfile->m_Header.colorSpace;

  if (bUseSpectralPCS && pProfile->m_Header.spectralPCS)
    nDstSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
  else {
    nDstSpace = pProfile->m_Header.pcs;
    bUseSpectralPCS = false;
  }
}
else {
  if (pProfile->m_Header.deviceClass == icSigLinkClass) {
    return icCmmStatBadSpaceLink;
  }
  if (pProfile->m_Header.deviceClass == icSigAbstractClass) {
    bInput = true;
    nIntent = icPerceptual; // Note: icPerceptualIntent = 0
  }

  if (bUseSpectralPCS && pProfile->m_Header.spectralPCS)
    nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
  else {
    nSrcSpace = pProfile->m_Header.pcs;
    bUseSpectralPCS = false;
  }

  nDstSpace = pProfile->m_Header.colorSpace;
}

//Make sure colorspaces match with previous xforms
if (!m_Xforms->size()) {
  if (m_nSrcSpace == icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
    m_nLastSpace = nSrcSpace;
    m_nSrcSpace = nSrcSpace;
  }
  else if (!IsCompatSpace(m_nSrcSpace, nSrcSpace)((m_nSrcSpace)==(nSrcSpace) || ((((m_nSrcSpace)==icSigXYZData
 || (m_nSrcSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nSrcSpace
)) && (((nSrcSpace)==icSigXYZData || (nSrcSpace)==icSigLabData
) || IsSpaceSpectralPCS(nSrcSpace))) || ((((icColorSpaceSignature
)(((icUInt32Number)m_nSrcSpace)&0xffff0000))==icSigSrcMCSChannelData
) && (((icColorSpaceSignature)(((icUInt32Number)nSrcSpace
)&0xffff0000))==icSigSrcMCSChannelData)) )) {
    return icCmmStatBadSpaceLink;
  }
}
else if (!IsCompatSpace(m_nLastSpace, nSrcSpace)((m_nLastSpace)==(nSrcSpace) || ((((m_nLastSpace)==icSigXYZData
 || (m_nLastSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nLastSpace
)) && (((nSrcSpace)==icSigXYZData || (nSrcSpace)==icSigLabData
) || IsSpaceSpectralPCS(nSrcSpace))) || ((((icColorSpaceSignature
)(((icUInt32Number)m_nLastSpace)&0xffff0000))==icSigSrcMCSChannelData
) && (((icColorSpaceSignature)(((icUInt32Number)nSrcSpace
)&0xffff0000))==icSigSrcMCSChannelData)) )) {
  return icCmmStatBadSpaceLink;
}

if (nSrcSpace == icSigNamedData)
  return icCmmStatBadSpaceLink;

//Automatic creation of intent from header/last profile
if (nIntent == icUnknownIntent((icRenderingIntent) 0x3f3f3f3f)) {
  if (bInput) {
    nIntent = (icRenderingIntent)pProfile->m_Header.renderingIntent;
  }
  else {
    nIntent = m_nLastIntent;
  }
  if (nIntent == icUnknownIntent((icRenderingIntent) 0x3f3f3f3f))
    nIntent = icPerceptual;
}

CIccXformPtr Xform;

Xform.ptr = CIccXform::Create(pProfile, pXformTag, bInput, nIntent, nInterp, pPcc, bUseSpectralPCS, pHintManager);

if (!Xform.ptr) {
  return icCmmStatBadXform;
}

m_nLastSpace = nDstSpace;
m_nLastIntent = nIntent;
m_bLastInput = bInput;

m_Xforms->push_back(Xform);

return icCmmStatOk;
8101}

8103/**
**************************************************************************
* Name: CIccCmm::AddXform
* 
* Purpose: 
*  Adds a profile at the end of the Xform list 
* 
* Args: 
*  Profile = reference a CIccProfile object that will be copies and added,
*  nIntent = rendering intent to be used with the profile,
*  nInterp = type of interpolation to be used with the profile,
*  nLutType = selection of which transform lut to use
*  bUseD2BxB2DxTags = flag to indicate the use MPE flags if available
*  pHintManager = hints for creating the xform
* 
* Return: 
*  icCmmStatOk, if the profile was added to the list succesfully
**************************************************************************
*/
8122icStatusCMM CIccCmm::AddXform(CIccProfile &Profile,
                            icRenderingIntent nIntent /*=icUnknownIntent*/,
                            icXformInterp nInterp /*=icInterpLinear*/,
                            IIccProfileConnectionConditions *pPcc/*=NULL*/,
                            icXformLutType nLutType /*=icXformLutColor*/,
                            bool bUseD2BxB2DxTags /*=true*/,
                            CIccCreateXformHintManager *pHintManager /*=NULL*/)
8129{
CIccProfile *pProfile = new CIccProfile(Profile);

if (!pProfile) 
  return icCmmStatAllocErr;

icStatusCMM stat = AddXform(pProfile, nIntent, nInterp, pPcc, nLutType, bUseD2BxB2DxTags, pHintManager);

if (stat != icCmmStatOk)
  delete pProfile;

return stat;
8141}

8143icStatusCMM CIccCmm::CheckPCSConnections(bool bUsePCSConversions/*=false*/)
8144{
icStatusCMM rv = icCmmStatOk;

CIccXformList::iterator last, next;
CIccXformList xforms;
CIccXformPtr ptr;
bool bUsesPcsXforms = false;

next=m_Xforms->begin();

if (next!=m_Xforms->end()) {
  last = next;
  next++;

  xforms.push_back(*last);

  for (;next!=m_Xforms->end(); last=next, next++) {
    if ((last->ptr->IsInput() && last->ptr->IsMCS() && next->ptr->IsMCS()) ||
        (IsSpaceSpectralPCS(last->ptr->GetDstSpace()) || IsSpaceSpectralPCS(next->ptr->GetSrcSpace())) ||
        (!bUsePCSConversions && 
         (IsSpaceColorimetricPCS(last->ptr->GetDstSpace())((last->ptr->GetDstSpace())==icSigXYZData || (last->
ptr->GetDstSpace())==icSigLabData) || IsSpaceColorimetricPCS(next->ptr->GetSrcSpace())((next->ptr->GetSrcSpace())==icSigXYZData || (next->
ptr->GetSrcSpace())==icSigLabData)))) {
        last->ptr->SetDstPCSConversion(false);
        next->ptr->SetSrcPCSConversion(false);
        CIccPcsXform *pPcs = new CIccPcsXform();

        if (!pPcs) {
          return icCmmStatAllocErr;
        }

        rv = pPcs->Connect(last->ptr, next->ptr);

        if (rv!=icCmmStatOk && rv!=icCmmStatIdentityXform)
          return rv;

        if (rv!=icCmmStatIdentityXform) {
          ptr.ptr = pPcs;
          xforms.push_back(ptr);
        }
        else {
          delete pPcs;
        }

        bUsesPcsXforms = true;
    }
    xforms.push_back(*next);
  }
}

if (bUsesPcsXforms) {
  *m_Xforms = xforms;
}

return rv;
8197}

8199/**
8200**************************************************************************
8201* Name: CIccCmm::SetLateBindingCC
8202* 
8203* Purpose: 
8204*  Initializes the LateBinding Connection Conditions used by 
8205*  colorimetric based transforms
8206*
8207**************************************************************************
8208*/
8209void CIccCmm::SetLateBindingCC()
8210{
CIccXformList::iterator i;
CIccXform *pLastXform = NULL__null;

for (i=m_Xforms->begin(); i!=m_Xforms->end(); i++) {
  if (i->ptr->IsInput()) {
    if (i->ptr->IsLateBinding()) {
      CIccXformList::iterator j=i;
      j++;
      if (j!=m_Xforms->end()) {
        if (j->ptr->IsLateBinding()) {
          i->ptr->SetAppliedCC(i->ptr->GetConnectionConditions());
          j->ptr->SetAppliedCC(i->ptr->GetConnectionConditions());
          pLastXform = i->ptr;
        }
        else {
          i->ptr->SetAppliedCC(i->ptr->GetConnectionConditions());
          j->ptr->SetAppliedCC(j->ptr->GetConnectionConditions());
          pLastXform = NULL__null;
        }
      }
      else {
        i->ptr->SetAppliedCC(i->ptr->GetConnectionConditions());
        pLastXform = NULL__null;
      }
    }
    else if (IsSpaceSpectralPCS(i->ptr->GetDstSpace())) {
      CIccXformList::iterator j=i;
      j++;
      if (j!=m_Xforms->end()) {
        if (j->ptr->IsLateBinding()) {
          j->ptr->SetAppliedCC(i->ptr->GetConnectionConditions());
          pLastXform = i->ptr;
        }
        else if (!j->ptr->IsAbstract()){
          j->ptr->SetAppliedCC(j->ptr->GetConnectionConditions());
          pLastXform = NULL__null;
        }
      }
    }
    else {
      pLastXform = NULL__null;
    }
  }
  else {
    if (!pLastXform) 
      i->ptr->SetAppliedCC(i->ptr->GetConnectionConditions());
    else
      pLastXform = NULL__null;
  }
}
8261}


8264/**
8265**************************************************************************
8266* Name: CIccCmm::Begin
8267* 
8268* Purpose: 
8269*  Does the initialization of the Xforms before Apply() is called.
8270*  Must be called before Apply().
8271*
8272**************************************************************************
8273*/
8274icStatusCMM CIccCmm::Begin(bool bAllocApplyCmm/*=true*/, bool bUsePCSConversions/*=false*/)
8275{
if (m_pApply)
  return icCmmStatOk;

if (m_nDestSpace==icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
  m_nDestSpace = m_nLastSpace;
}
else if (!IsCompatSpace(m_nDestSpace, m_nLastSpace)((m_nDestSpace)==(m_nLastSpace) || ((((m_nDestSpace)==icSigXYZData
 || (m_nDestSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nDestSpace
)) && (((m_nLastSpace)==icSigXYZData || (m_nLastSpace
)==icSigLabData) || IsSpaceSpectralPCS(m_nLastSpace))) || (((
(icColorSpaceSignature)(((icUInt32Number)m_nDestSpace)&0xffff0000
))==icSigSrcMCSChannelData) && (((icColorSpaceSignature
)(((icUInt32Number)m_nLastSpace)&0xffff0000))==icSigSrcMCSChannelData
)) )) {
  return icCmmStatBadSpaceLink;
}

if (m_nSrcSpace==icSigNamedData || m_nDestSpace==icSigNamedData) {
  return icCmmStatBadSpaceLink;
}

SetLateBindingCC();

icStatusCMM rv;
CIccXformList::iterator i;

for (i=m_Xforms->begin(); i!=m_Xforms->end(); i++) {

  rv = i->ptr->Begin();

  if (rv!= icCmmStatOk)
    return rv;
}

rv = CheckPCSConnections(bUsePCSConversions);
if (rv != icCmmStatOk && rv!=icCmmStatIdentityXform)
  return rv;

if (bAllocApplyCmm) {
  m_pApply = GetNewApplyCmm(rv);
}
else
  rv = icCmmStatOk;

return rv;
8314}


8317/**
**************************************************************************
* Name: CIccCmm::GetNewApplyCmm
* 
* Purpose: 
*  Allocates an CIccApplyCmm object that does the initialization of the Xforms
*  that provides an Apply() function.
*  Multiple CIccApplyCmm objects can be allocated and used in separate threads.
*
**************************************************************************
*/
8328CIccApplyCmm *CIccCmm::GetNewApplyCmm(icStatusCMM &status)
8329{
CIccApplyCmm *pApply = new CIccApplyCmm(this);

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

CIccXformList::iterator i;
CIccApplyXform *pXform;

for (i=m_Xforms->begin(); i!=m_Xforms->end(); i++) {
  pXform = i->ptr->GetNewApply(status);
  if (!pXform || status != icCmmStatOk) {
    delete pApply;
    return NULL__null;
  }
  pApply->AppendApplyXform(pXform);
}

m_bValid = true;

status = icCmmStatOk;

return pApply;
8354}


8357/**
8358**************************************************************************
8359* Name: CIccCmm::Apply
8360* 
8361* Purpose: 
8362*  Uses the m_pApply object allocated during Begin to Apply the transformations
8363*  associated with the CMM.
8364*
8365**************************************************************************
8366*/
8367icStatusCMM CIccCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel)
8368{
return m_pApply->Apply(DstPixel, SrcPixel);
8370}


8373/**
8374**************************************************************************
8375* Name: CIccCmm::Apply
8376* 
8377* Purpose: 
8378*  Uses the m_pApply object allocated during Begin to Apply the transformations
8379*  associated with the CMM.
8380*
8381**************************************************************************
8382*/
8383icStatusCMM CIccCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel, icUInt32Number nPixels)
8384{
return m_pApply->Apply(DstPixel, SrcPixel, nPixels);
8386}


8389/**
8390**************************************************************************
8391* Name: CIccCmm::RemoveAllIO()
8392* 
8393* Purpose: 
8394*  Remove any attachments to CIccIO objects associated with the profiles
8395*  related to the transforms attached to the CMM.
8396*  Must be called after Begin().
8397*
8398*  Return:
8399*   icCmmStatOK - All IO objects removed
8400*   icCmmStatBadXform - Begin() has not been performed.
8401**************************************************************************
8402*/
8403icStatusCMM CIccCmm::RemoveAllIO()
8404{
if (!Valid())
  return icCmmStatBadXform;

CIccXformList::iterator i;

for (i=m_Xforms->begin(); i!=m_Xforms->end(); i++) {
  i->ptr->RemoveIO();
}

return icCmmStatOk;
8415}

8417/**
*************************************************************************
** Name: CIccCmm::IsInGamut
**
** Purpose:
**  Function to check if internal representation of gamut is in gamut.  Note
**  since gamut table is 8 bit and a color is considered to be in out of gamut
**  if the value is not zero.  Then we need to check where the 8 bit representation
**  of the internal value is not zero.
**
**  Args:
**   pInternal = internal pixel representation of gamut value
**
**  Return:
**    true if in gamut, false if out of gamut
**************************************************************************/
8433bool CIccCmm::IsInGamut(icFloatNumber *pInternal)
8434{
if (!((unsigned int)((*pInternal)*255.0)))
  return true;
return false;
8438}


8441/**
**************************************************************************
* Name: CIccCmm::ToInternalEncoding
* 
* Purpose: 
*  Functions for converting to Internal representation of pixel colors.
*  
* Args:
*  nSpace = color space signature of the data,
*  nEncode = icFloatColorEncoding type of the data,
*  pInternal = converted data is stored here,
*  pData = the data to be converted
*  bClip = flag to clip to internal range
**************************************************************************
*/
8456icStatusCMM CIccCmm::ToInternalEncoding(icColorSpaceSignature nSpace, icFloatColorEncoding nEncode,
                                      icFloatNumber *pInternal, const icFloatNumber *pData,
                                      bool bClip)
8459{
int nSamples = icGetSpaceSamples(nSpace);
if (!nSamples)
  return icCmmStatBadColorEncoding;


icUInt16Number i;
CIccPixelBuf pInput(nSamples);

if (!pInput.get())
  return icCmmStatAllocErr;

memcpy(pInput, pData, nSamples*sizeof(icFloatNumber));
bool bCLRspace = icIsSpaceCLR(nSpace);

switch(icGetColorSpaceType(nSpace)((icColorSpaceSignature)(((icUInt32Number)nSpace)&0xffff0000
)))
{
  case icSigReflectanceSpectralPcsData((icColorSpaceSignature)icSigReflectanceSpectralData):
  case icSigTransmissionSpectralPcsData((icColorSpaceSignature)icSigTransmisionSpectralData):
  case icSigBiDirReflectanceSpectralPcsData((icColorSpaceSignature)icSigBiSpectralReflectanceData):
  case icSigSparseMatrixSpectralPcsData((icColorSpaceSignature)icSigSparseMatrixReflectanceData):
    bCLRspace = true;
    break;
}

switch(nSpace) {

  case icSigLabData:
    {
      switch(nEncode) {
      case icEncodeValue:
        {
          icLabToPcs(pInput);
          break;
        }
      case icEncodeFloat:
        {
          break;
        }
      case icEncode8Bit:
        {
          pInput[0] = icU8toF((icUInt8Number)pInput[0])*100.0f;
          pInput[1] = icU8toAB((icUInt8Number)pInput[1]);
          pInput[2] = icU8toAB((icUInt8Number)pInput[2]);

          icLabToPcs(pInput);
          break;
        }
      case icEncode16Bit:
        {
          pInput[0] = icU16toF((icUInt16Number)pInput[0]);
          pInput[1] = icU16toF((icUInt16Number)pInput[1]);
          pInput[2] = icU16toF((icUInt16Number)pInput[2]);
          break;
        }
      case icEncode16BitV2:
        {
          pInput[0] = icU16toF((icUInt16Number)pInput[0]);
          pInput[1] = icU16toF((icUInt16Number)pInput[1]);
          pInput[2] = icU16toF((icUInt16Number)pInput[2]);

          CIccPCS::Lab2ToLab4(pInput, pInput);
          break;
        }
      default:
          return icCmmStatBadColorEncoding;
          break;
      }
      break;
    }

  case icSigXYZData:
    {
      switch(nEncode) {
      case icEncodeValue:
        {
          pInput[0] = (icFloatNumber)pInput[0];
          pInput[1] = (icFloatNumber)pInput[1];
          pInput[2] = (icFloatNumber)pInput[2];
          icXyzToPcs(pInput);
          break;
        }
      case icEncodePercent:
        {
          pInput[0] = (icFloatNumber)(pInput[0] / 100.0);
          pInput[1] = (icFloatNumber)(pInput[1] / 100.0);
          pInput[2] = (icFloatNumber)(pInput[2] / 100.0);
          icXyzToPcs(pInput);
          break;
        }
      case icEncodeFloat:
        {
          icXyzToPcs(pInput);
          break;
        }
        
      case icEncode16Bit:
      case icEncode16BitV2:
        {
          pInput[0] = icUSFtoD((icU1Fixed15Number)pInput[0]);
          pInput[1] = icUSFtoD((icU1Fixed15Number)pInput[1]);
          pInput[2] = icUSFtoD((icU1Fixed15Number)pInput[2]);
          break;
        }
        
      default:
          return icCmmStatBadColorEncoding;
          break;
      }
      break;
    }

  case icSigNamedData:
    return icCmmStatBadColorEncoding;

  default:
    {
      switch(nEncode) {
      case icEncodeValue:
        {
          if (!bCLRspace || nSamples<3) {
            return icCmmStatBadColorEncoding;
          }
          if (nSamples==3)
            icLabToPcs(pInput);
          break;
        }

      case icEncodePercent:
        {
          if (bClip) {
            for(i=0; i<nSamples; i++) {
              pInput[i] = (icFloatNumber)(pInput[i]/100.0);
              if (pInput[i] < 0.0) pInput[i] = 0.0;
              if (pInput[i] > 1.0) pInput[i] = 1.0;
            }
          }
          else {
            for(i=0; i<nSamples; i++) {
              pInput[i] = (icFloatNumber)(pInput[i]/100.0);
            }
          }
          break;
        }
      
      case icEncodeFloat:
        {
          if (bClip) {
            for(i=0; i<nSamples; i++) {
              if (pInput[i] < 0.0) pInput[i] = 0.0;
              if (pInput[i] > 1.0) pInput[i] = 1.0;
            }
          }
          break;
        }
        
      case icEncode8Bit:
        {
          for(i=0; i<nSamples; i++) {
            pInput[i] = icU8toF((icUInt8Number)pInput[i]);
          }
          break;
        }
        
      case icEncode16Bit:
      case icEncode16BitV2:
        {
          for(i=0; i<nSamples; i++) {
            pInput[i] = icU16toF((icUInt16Number)pInput[i]);
          }
          break;
        }
      
      default:
          return icCmmStatBadColorEncoding;
          break;
      }
      break;
    }
}

memcpy(pInternal, pInput, nSamples*sizeof(icFloatNumber));
return icCmmStatOk;
8642}


8645/**
8646**************************************************************************
8647* Name: CIccCmm::ToInternalEncoding
8648* 
8649* Purpose: 
8650*  Functions for converting to Internal representation of 8 bit pixel colors.
8651*  
8652* Args:
8653*  nSpace = color space signature of the data,
8654*  nEncode = icFloatColorEncoding type of the data,
8655*  pInternal = converted data is stored here,
8656*  pData = the data to be converted
8657*  bClip = flag to clip to internal range
8658**************************************************************************
8659*/
8660icStatusCMM CIccCmm::ToInternalEncoding(icColorSpaceSignature nSpace, icFloatNumber *pInternal,
                                      const icUInt8Number *pData)
8662{
switch(nSpace) {
  case icSigRgbData:
  {
    pInternal[0] = (icFloatNumber)((icFloatNumber)pData[0] / 255.0);
    pInternal[1] = (icFloatNumber)((icFloatNumber)pData[1] / 255.0);
    pInternal[2] = (icFloatNumber)((icFloatNumber)pData[2] / 255.0);

    return icCmmStatOk;
  }
  case icSigCmykData:
  {
    pInternal[0] = (icFloatNumber)((icFloatNumber)pData[0] / 255.0);
    pInternal[1] = (icFloatNumber)((icFloatNumber)pData[1] / 255.0);
    pInternal[2] = (icFloatNumber)((icFloatNumber)pData[2] / 255.0);
    pInternal[3] = (icFloatNumber)((icFloatNumber)pData[3] / 255.0);
    return icCmmStatOk;
  }
  default:
  {
    icUInt32Number i;
    icUInt32Number nSamples = icGetSpaceSamples(nSpace);
    CIccPixelBuf FloatPixel(nSamples);
    if (!FloatPixel.get())
      return icCmmStatAllocErr;

    for(i=0; i<nSamples; i++) {
      FloatPixel[i] = (icFloatNumber)pData[i];    
    }
    return ToInternalEncoding(nSpace, icEncode8Bit, pInternal, FloatPixel);
  }
}

8695}


8698/**
8699**************************************************************************
8700* Name: CIccCmm::ToInternalEncoding
8701* 
8702* Purpose: 
8703*  Functions for converting to Internal representation of 16 bit pixel colors.
8704*  
8705* Args:
8706*  nSpace = color space signature of the data,
8707*  nEncode = icFloatColorEncoding type of the data,
8708*  pInternal = converted data is stored here,
8709*  pData = the data to be converted
8710*  bClip = flag to clip to internal range
8711**************************************************************************
8712*/
8713icStatusCMM CIccCmm::ToInternalEncoding(icColorSpaceSignature nSpace, icFloatNumber *pInternal,
                                      const icUInt16Number *pData)
8715{
switch(nSpace) {
  case icSigRgbData:
  {
    pInternal[0] = (icFloatNumber)((icFloatNumber)pData[0] / 65535.0);
    pInternal[1] = (icFloatNumber)((icFloatNumber)pData[1] / 65535.0);
    pInternal[2] = (icFloatNumber)((icFloatNumber)pData[2] / 65535.0);

    return icCmmStatOk;
  }
  case icSigCmykData:
  {
    pInternal[0] = (icFloatNumber)((icFloatNumber)pData[0] / 65535.0);
    pInternal[1] = (icFloatNumber)((icFloatNumber)pData[1] / 65535.0);
    pInternal[2] = (icFloatNumber)((icFloatNumber)pData[2] / 65535.0);
    pInternal[3] = (icFloatNumber)((icFloatNumber)pData[3] / 65535.0);
    return icCmmStatOk;
  }
  default:
  {
    icUInt32Number i;
    icUInt32Number nSamples = icGetSpaceSamples(nSpace);
    CIccPixelBuf pFloatPixel(nSamples);
    if (!pFloatPixel.get())
      return icCmmStatAllocErr;

    for(i=0; i<nSamples; i++) {
      pFloatPixel[i] = (icFloatNumber)pData[i];    
    }
    return ToInternalEncoding(nSpace, icEncode16Bit, pInternal, pFloatPixel);
  }
}
8747}


8750/**
**************************************************************************
* Name: CIccCmm::FromInternalEncoding
* 
* Purpose: 
*  Functions for converting from Internal representation of pixel colors.
*  
* Args:
*  nSpace = color space signature of the data,
*  nEncode = icFloatColorEncoding type of the data,
*  pData = converted data is stored here,
*  pInternal = the data to be converted
*  bClip = flag to clip data to internal range
**************************************************************************
*/
8765icStatusCMM CIccCmm::FromInternalEncoding(icColorSpaceSignature nSpace, icFloatColorEncoding nEncode,
                                        icFloatNumber *pData, const icFloatNumber *pInternal, bool bClip)
8767{
int nSamples = icGetSpaceSamples(nSpace);
if (!nSamples)
  return icCmmStatBadColorEncoding;

icUInt16Number i;
CIccPixelBuf pInput(nSamples);

if (!pInput.get())
  return icCmmStatAllocErr;

memcpy(pInput, pInternal, nSamples*sizeof(icFloatNumber));
bool bCLRspace = (icIsSpaceCLR(nSpace) || (nSpace == icSigDevLabData((icColorSpaceSignature) 0x644C6162)) || (nSpace==icSigDevXYZData((icColorSpaceSignature) 0x6458595A)));

switch(nSpace) {

  case icSigLabData:
    {
      switch(nEncode) {
      case icEncodeValue:
        {
          icLabFromPcs(pInput);
          break;
        }
      case icEncodeUnitFloat:
      case icEncodeFloat:
        {
          break;
        }
      case icEncode8Bit:
        {
          icLabFromPcs(pInput);

          pInput[0] = (icUInt8Number)(pInput[0]/100.0 * 255.0 + 0.5);
          pInput[1] = icABtoU8(pInput[1]);
          pInput[2] = icABtoU8(pInput[2]);
          break;
        }
      case icEncode16Bit:
        {
          pInput[0] = icFtoU16(pInput[0]);
          pInput[1] = icFtoU16(pInput[1]);
          pInput[2] = icFtoU16(pInput[2]);
          break;
        }
      case icEncode16BitV2:
        {
          CIccPCS::Lab4ToLab2(pInput, pInput);

          pInput[0] = icFtoU16(pInput[0]);
          pInput[1] = icFtoU16(pInput[1]);
          pInput[2] = icFtoU16(pInput[2]);
          break;
        }
      default:
          return icCmmStatBadColorEncoding;
          break;
      }
      break;
    }

  case icSigXYZData:
  {
      switch(nEncode) {
      case icEncodeValue:
        {
          icXyzFromPcs(pInput);
          break;
        }
      case icEncodePercent:
        {
          icXyzFromPcs(pInput);
          pInput[0] = (icFloatNumber)(pInput[0] * 100.0);
          pInput[1] = (icFloatNumber)(pInput[1] * 100.0);
          pInput[2] = (icFloatNumber)(pInput[2] * 100.0);            
          break;
        }
      case icEncodeFloat:
      case icEncodeUnitFloat:
        {
          icXyzFromPcs(pInput);
          break;
        }
        
      case icEncode16Bit:
      case icEncode16BitV2:
        {
          icXyzFromPcs(pInput);
          pInput[0] = icDtoUSF(pInput[0]);
          pInput[1] = icDtoUSF(pInput[1]);
          pInput[2] = icDtoUSF(pInput[2]);
          break;
        }
        
      default:
          return icCmmStatBadColorEncoding;
          break;
      }
      break;
    }

  case icSigNamedData:
    return icCmmStatBadColorEncoding;

  default:
    {
      switch(nEncode) {
      case icEncodeValue:
        {
          if (nSpace == icSigDevXYZData((icColorSpaceSignature) 0x6458595A)) {
            icXyzFromPcs(pInput);
          }
          else if (bCLRspace && nSamples >=3) {
            icLabFromPcs(pInput);
          }
          break;
        }
      case icEncodePercent:
        {
          if (bClip) {
            for(i=0; i<nSamples; i++) {
              if (pInput[i] < 0.0) pInput[i] = 0.0;
              if (pInput[i] > 1.0) pInput[i] = 1.0;
              pInput[i] = (icFloatNumber)(pInput[i]*100.0);
            }
          }
          else {
            for(i=0; i<nSamples; i++) {
              pInput[i] = (icFloatNumber)(pInput[i]*100.0);
            }
          }
          break;
        }
      
      case icEncodeFloat:
        break;

      case icEncodeUnitFloat:
        {
          if (bClip) {
            for(i=0; i<nSamples; i++) {
              if (pInput[i] < 0.0) pInput[i] = 0.0;
              if (pInput[i] > 1.0) pInput[i] = 1.0;
            }
          }
          break;
        }
        
      case icEncode8Bit:
        {
          for(i=0; i<nSamples; i++) {
            pInput[i] = icFtoU8(pInput[i]);
          }
          break;
        }
        
      case icEncode16Bit:
      case icEncode16BitV2:
        {
          for(i=0; i<nSamples; i++) {
            pInput[i] = icFtoU16(pInput[i]);
          }
          break;
        }
      
      default:
          return icCmmStatBadColorEncoding;
          break;
      }
      break;
    }
}

memcpy(pData, pInput, nSamples*sizeof(icFloatNumber));
return icCmmStatOk;
8942}


8945/**
8946**************************************************************************
8947* Name: CIccCmm::FromInternalEncoding
8948* 
8949* Purpose: 
8950*  Functions for converting from Internal representation of 8 bit pixel colors.
8951*  
8952* Args:
8953*  nSpace = color space signature of the data,
8954*  nEncode = icFloatColorEncoding type of the data,
8955*  pData = converted data is stored here,
8956*  pInternal = the data to be converted
8957*  bClip = flag to clip data to internal range
8958**************************************************************************
8959*/
8960icStatusCMM CIccCmm::FromInternalEncoding(icColorSpaceSignature nSpace, icUInt8Number *pData,
                                        const icFloatNumber *pInternal)
8962{
switch(nSpace) {
  case icSigRgbData:
  {
    pData[0] = icFtoU8(pInternal[0]);
    pData[1] = icFtoU8(pInternal[1]);
    pData[2] = icFtoU8(pInternal[2]);

    return icCmmStatOk;
  }
  case icSigCmykData:
  {
    pData[0] = icFtoU8(pInternal[0]);
    pData[1] = icFtoU8(pInternal[1]);
    pData[2] = icFtoU8(pInternal[2]);
    pData[3] = icFtoU8(pInternal[3]);

    return icCmmStatOk;
  }
  default:
  {
    icUInt32Number i;
    icUInt32Number nSamples = icGetSpaceSamples(nSpace);

    CIccPixelBuf pFloatPixel(nSamples);
    icStatusCMM convertStat;

    if (!pFloatPixel.get())
      return icCmmStatAllocErr;

    convertStat = FromInternalEncoding(nSpace, icEncode8Bit, pFloatPixel, pInternal);
    if (convertStat)
      return convertStat;
    for(i=0; i<nSamples; i++) {
      pData[i] = (icUInt8Number)(pFloatPixel[i] + 0.5);    
    }

    return icCmmStatOk;
  }
}
9002}


9005/**
9006**************************************************************************
9007* Name: CIccCmm::FromInternalEncoding
9008* 
9009* Purpose: 
9010*  Functions for converting from Internal representation of 16 bit pixel colors.
9011*  
9012* Args:
9013*  nSpace = color space signature of the data,
9014*  nEncode = icFloatColorEncoding type of the data,
9015*  pData = converted data is stored here,
9016*  pInternal = the data to be converted
9017*  bClip = flag to clip data to internal range
9018**************************************************************************
9019*/
9020icStatusCMM CIccCmm::FromInternalEncoding(icColorSpaceSignature nSpace, icUInt16Number *pData,
                                        const icFloatNumber *pInternal)
9022{
switch(nSpace) {
  case icSigRgbData:
  {
    pData[0] = icFtoU16(pInternal[0]);
    pData[1] = icFtoU16(pInternal[1]);
    pData[2] = icFtoU16(pInternal[2]);

    return icCmmStatOk;
  }
  case icSigCmykData:
  {
    pData[0] = icFtoU16(pInternal[0]);
    pData[1] = icFtoU16(pInternal[1]);
    pData[2] = icFtoU16(pInternal[2]);
    pData[3] = icFtoU16(pInternal[3]);

    return icCmmStatOk;
  }
  default:
  {
    icUInt32Number i;
    icUInt32Number nSamples = icGetSpaceSamples(nSpace);
    CIccPixelBuf pFloatPixel(nSamples);
    icStatusCMM convertStat;

    if (!pFloatPixel.get())
      return icCmmStatAllocErr;

    convertStat = FromInternalEncoding(nSpace, icEncode16Bit, pFloatPixel, pInternal);
    if (convertStat)
      return convertStat;
    for(i=0; i<nSamples; i++) {
      pData[i] = (icUInt16Number)(pFloatPixel[i] + 0.5);    
    }

    return icCmmStatOk;
  }
}
9061}


9064/**
**************************************************************************
* Name: CIccCmm::GetFloatColorEncoding
* 
* Purpose: 
*  Converts the encoding type to characters for printing
*  
* Args:
*  val = encoding type
* 
* Return:
*  characters for printing
**************************************************************************
*/
9078const icChar* CIccCmm::GetFloatColorEncoding(icFloatColorEncoding val)
9079{
switch(val) {

  case icEncodeValue:
    return "icEncodeValue";

  case icEncodeFloat:
    return "icEncodeFloat";

  case icEncodeUnitFloat:
    return "icEncodeUnitFloat";

  case icEncodePercent:
    return "icEncodePercent";

  case icEncode8Bit:
    return "icEncode8Bit";

  case icEncode16Bit:
    return "icEncode16Bit";

  case icEncode16BitV2:
    return "icEncode16BitV2";

  default:
    return "icEncodeUnknown";
}
9106}

9108/**
**************************************************************************
* Name: CIccCmm::GetFloatColorEncoding
* 
* Purpose: 
*  Converts the string containing encoding type to icFloatColorEncoding
*  
* Args:
*  val = string containing encoding type
* 
* Return:
*  encoding type
**************************************************************************
*/
9122icFloatColorEncoding CIccCmm::GetFloatColorEncoding(const icChar* val)
9123{
if (!stricmpstrcasecmp(val, "icEncodePercent")) {
  return icEncodePercent;
}
else if (!stricmpstrcasecmp(val, "icEncodeUnitFloat")) {
  return icEncodeUnitFloat;
}
else if (!stricmpstrcasecmp(val, "icEncodeFloat")) {
  return icEncodeFloat;
}
else if (!stricmpstrcasecmp(val, "icEncode8Bit")) {
  return icEncode8Bit;
}
else if (!stricmpstrcasecmp(val, "icEncode16Bit")) {
  return icEncode16Bit;
}
else if (!stricmpstrcasecmp(val, "icEncode16BitV2")) {
  return icEncode16BitV2;
}
else if (!stricmpstrcasecmp(val, "icEncodeValue")) {
  return icEncodeValue;
}
else {
  return icEncodeUnknown;
}

9149}

9151/**
**************************************************************************
* Name: CIccCmm::GetNumXforms
* 
* Purpose: 
*  Get number of xforms in the xform list
*  
* Return:
* number of m_Xforms
**************************************************************************
*/
9162icUInt32Number CIccCmm::GetNumXforms() const
9163{
return (icUInt32Number)m_Xforms->size();
9165}


9168/**
9169**************************************************************************
9170* Name: CIccCmm::GetFirstXformSource
9171* 
9172* Purpose: 
9173*  Get source colorspace of first transform (similar to m_nSrcSpace with differences in dev colorimetric spaces)
9174*  
9175* Return:
9176* colorspace
9177**************************************************************************
9178*/
9179icColorSpaceSignature CIccCmm::GetFirstXformSource()
9180{
if (!m_Xforms->size())
  return m_nSrcSpace;

return m_Xforms->begin()->ptr->GetSrcSpace();
9185}

9187/**
9188**************************************************************************
9189* Name: CIccCmm::GetNumXforms
9190* 
9191* Purpose: 
9192*  Get source colorspace of last transform (similar to m_nSrcSpace with differences in dev colorimetric spaces)
9193*  
9194* Return:
9195* colorspace
9196**************************************************************************
9197*/
9198icColorSpaceSignature CIccCmm::GetLastXformDest()
9199{
if (!m_Xforms->size())
  return m_nDestSpace;

return m_Xforms->rbegin()->ptr->GetDstSpace();
9204}

9206/**
9207**************************************************************************
9208* Name: CIccApplyCmm::CIccApplyCmm
9209* 
9210* Purpose: 
9211*  Constructor
9212*
9213* Args:
9214*  pCmm = ptr to CMM to apply against
9215**************************************************************************
9216*/
9217CIccApplyNamedColorCmm::CIccApplyNamedColorCmm(CIccNamedColorCmm *pCmm) : CIccApplyCmm(pCmm)
9218{
9219}


9222/**
9223**************************************************************************
9224* Name: CIccApplyCmm::CIccApplyCmm
9225* 
9226* Purpose: 
9227*  Destructor
9228**************************************************************************
9229*/
9230CIccApplyNamedColorCmm::~CIccApplyNamedColorCmm()
9231{
9232}


9235/**
9236**************************************************************************
9237* Name: CIccApplyNamedColorCmm::Apply
9238* 
9239* Purpose: 
9240*  Does the actual application of the Xforms in the list.
9241*  
9242* Args:
9243*  DstPixel = Destination pixel where the result is stored,
9244*  SrcPixel = Source pixel which is to be applied.
9245**************************************************************************
9246*/
9247icStatusCMM CIccApplyNamedColorCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel)
9248{
icFloatNumber *pDst, *pTmp;
const icFloatNumber *pSrc;
CIccApplyXformList::iterator i;
int j, n = (int)m_Xforms->size();
CIccApplyXform *pApply;
const CIccXform *pApplyXform;
CIccXformNamedColor *pXform;

if (!n)
  return icCmmStatBadXform;

if (!m_Pixel && !InitPixel()) {
  return icCmmStatAllocErr;
}

icChar NamedColor[256];
icStatusCMM rv;

m_pPCS->Reset(m_pCmm->GetSourceSpace());

pSrc = SrcPixel;
pDst = m_Pixel;

if (n>1) {
  for (j=0, i=m_Xforms->begin(); j<n-1 && i!=m_Xforms->end(); i++, j++) {

    pApply = i->ptr;
    pApplyXform = pApply->GetXform();
    if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
      pXform = (CIccXformNamedColor*)pApplyXform;

      switch(pXform->GetInterface()) {
      case icApplyPixel2Pixel:
        pXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyPixel2Named:
        pXform->Apply(pApply, NamedColor, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyNamed2Pixel:
        if (j==0) {
          return icCmmStatIncorrectApply;
        }

        rv = pXform->Apply(pApply, pDst, NamedColor);

        if (rv) {
          return rv;
        }
        break;

      default:
        break;
      }
    }
    else {
      pApplyXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pApplyXform));
    }
    pTmp = (icFloatNumber*)pSrc;
    pSrc = pDst;
    if (pTmp==SrcPixel)
      pDst = m_Pixel2;
    else
      pDst = pTmp;
  }

  pApply = i->ptr;
  pApplyXform = pApply->GetXform();
  if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
    pXform = (CIccXformNamedColor*)pApplyXform;

    switch(pXform->GetInterface()) {
    case icApplyPixel2Pixel:
      pXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pXform));
      break;

    case icApplyPixel2Named:
    default:
      return icCmmStatIncorrectApply;
      break;

    case icApplyNamed2Pixel:
      rv = pXform->Apply(pApply, DstPixel, NamedColor);
      if (rv) {
        return rv;
      }
      break;

    }
  }
  else {
    pApplyXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pApplyXform));
  }

}
else if (n==1) {
  i = m_Xforms->begin();

  pApply = i->ptr;
  pApplyXform = pApply->GetXform();
  if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
    return icCmmStatIncorrectApply;
  }

  pApplyXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pApplyXform));
}

m_pPCS->CheckLast(DstPixel, m_pCmm->GetDestSpace(), true);

return icCmmStatOk;
9360}


9363/**
9364**************************************************************************
9365* Name: CIccApplyNamedColorCmm::Apply
9366* 
9367* Purpose: 
9368*  Does the actual application of the Xforms in the list.
9369*  
9370* Args:
9371*  DstPixel = Destination pixel where the result is stored,
9372*  SrcPixel = Source pixel which is to be applied.
9373**************************************************************************
9374*/
9375icStatusCMM CIccApplyNamedColorCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel, icUInt32Number nPixels)
9376{
icFloatNumber *pDst;
const icFloatNumber *pSrc;
CIccApplyXformList::iterator i;
int j, n = (int)m_Xforms->size();
CIccApplyXform *pApply;
const CIccXform *pApplyXform;
CIccXformNamedColor *pXform;
icUInt32Number k; 

if (!n)
  return icCmmStatBadXform;

if (!m_Pixel && !InitPixel()) {
  return icCmmStatAllocErr;
}

icChar NamedColor[255];
icStatusCMM rv;

for (k=0; k<nPixels; k++) {
  m_pPCS->Reset(m_pCmm->GetSourceSpace());

  pSrc = SrcPixel;
  pDst = m_Pixel;

  if (n>1) {
    for (j=0, i=m_Xforms->begin(); j<n-1 && i!=m_Xforms->end(); i++, j++) {

      pApply = i->ptr;
      pApplyXform = pApply->GetXform();
      if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
        pXform = (CIccXformNamedColor*)pApplyXform;

        switch(pXform->GetInterface()) {
        case icApplyPixel2Pixel:
          pXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pXform));
          break;

        case icApplyPixel2Named:
          pXform->Apply(pApply, NamedColor, m_pPCS->Check(pSrc, pXform));
          break;

        case icApplyNamed2Pixel:
          if (j==0) {
            return icCmmStatIncorrectApply;
          }

          rv = pXform->Apply(pApply, pDst, NamedColor);

          if (rv) {
            return rv;
          }
          break;

        default:
          break;
        }
      }
      else {
        pApplyXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pApplyXform));
      }
      pSrc = pDst;
    }

    pApply = i->ptr;
    pApplyXform = pApply->GetXform();
    if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
      pXform = (CIccXformNamedColor*)pApplyXform;

      switch(pXform->GetInterface()) {
      case icApplyPixel2Pixel:
        pXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyPixel2Named:
      default:
        return icCmmStatIncorrectApply;
        break;

      case icApplyNamed2Pixel:
        rv = pXform->Apply(pApply, DstPixel, NamedColor);
        if (rv) {
          return rv;
        }
        break;

      }
    }
    else {
      pApplyXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pApplyXform));
    }

  }
  else if (n==1) {
    i = m_Xforms->begin();

    pApply = i->ptr;
    pApplyXform = pApply->GetXform();
    if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
      return icCmmStatIncorrectApply;
    }

    pApplyXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pApplyXform));
  }

  m_pPCS->CheckLast(DstPixel, m_pCmm->GetDestSpace());

  SrcPixel += m_pCmm->GetSourceSamples();
  DstPixel += m_pCmm->GetDestSamples();
}

return icCmmStatOk;
9489}


9492/**
9493**************************************************************************
9494* Name: CIccApplyNamedColorCmm::Apply
9495* 
9496* Purpose: 
9497*  Does the actual application of the Xforms in the list.
9498*  
9499* Args:
9500*  DstColorName = Destination string where the result is stored,
9501*  SrcPixel = Source pixel which is to be applied.
9502**************************************************************************
9503*/
9504icStatusCMM CIccApplyNamedColorCmm::Apply(icChar* DstColorName, const icFloatNumber *SrcPixel)
9505{
icFloatNumber *pDst, *pTmp;
const icFloatNumber *pSrc;
CIccApplyXformList::iterator i;
int j, n = (int)m_Xforms->size();
CIccApplyXform *pApply;
const CIccXform *pApplyXform;
CIccXformNamedColor *pXform;

if (!n)
  return icCmmStatBadXform;

if (!m_Pixel && !InitPixel()) {
  return icCmmStatAllocErr;
}

icChar NamedColor[256];
icStatusCMM rv;

m_pPCS->Reset(m_pCmm->GetSourceSpace());

pSrc = SrcPixel;
pDst = m_Pixel;

if (n>1) {
  for (j=0, i=m_Xforms->begin(); j<n-1 && i!=m_Xforms->end(); i++, j++) {

    pApply = i->ptr;
    pApplyXform = pApply->GetXform();
    if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
      pXform = (CIccXformNamedColor*)pApplyXform;
      switch(pXform->GetInterface()) {
      case icApplyPixel2Pixel:
        pXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyPixel2Named:
        pXform->Apply(pApply, NamedColor, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyNamed2Pixel:
        if (j==0) {
          return icCmmStatIncorrectApply;
        }
        rv = pXform->Apply(pApply, pDst, NamedColor);
        if (rv) {
          return rv;
        }
        break;

      default:
        break;
      }
    }
    else {
      pApplyXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pApplyXform));
    }
    pTmp = (icFloatNumber*)pSrc;
    pSrc = pDst;
    if (pTmp==SrcPixel)
      pDst = m_Pixel2;
    else
      pDst = pTmp;
  }

  pApply = i->ptr;
  pApplyXform = pApply->GetXform();
  if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
    pXform = (CIccXformNamedColor*)pApplyXform;
    switch(pXform->GetInterface()) {

    case icApplyPixel2Named:
      pXform->Apply(pApply, DstColorName, m_pPCS->Check(pSrc, pXform));
      break;

    case icApplyPixel2Pixel:
    case icApplyNamed2Pixel:
    default:
      return icCmmStatIncorrectApply;
      break;
    }
  }
  else {
    return icCmmStatIncorrectApply;
  }

}
else if (n==1) {
  i = m_Xforms->begin();
  pApply = i->ptr;
  pApplyXform = pApply->GetXform();
  if (pApplyXform->GetXformType()!=icXformTypeNamedColor) {
    return icCmmStatIncorrectApply;
  }

  pXform = (CIccXformNamedColor*)pApplyXform;
  pXform->Apply(pApply, DstColorName, m_pPCS->Check(pSrc, pXform));
}

return icCmmStatOk;
9605}


9608/**
9609**************************************************************************
9610* Name: CIccApplyNamedColorCmm::Apply
9611* 
9612* Purpose: 
9613*  Does the actual application of the Xforms in the list.
9614*  
9615* Args:
9616*  DstPixel = Destination pixel where the result is stored,
9617*  SrcColorName = Source color name which is to be searched.
9618**************************************************************************
9619*/
9620icStatusCMM CIccApplyNamedColorCmm::Apply(icFloatNumber *DstPixel, const icChar *SrcColorName, icFloatNumber tint/*=1.0*/)
9621{
icFloatNumber *pDst, *pTmp;
const icFloatNumber *pSrc;
CIccApplyXformList::iterator i;
int j, n = (int)m_Xforms->size();
CIccApplyXform *pApply;
const CIccXform *pApplyXform;
CIccXformNamedColor *pXform;

if (!n)
  return icCmmStatBadXform;

if (!m_Pixel && !InitPixel()) {
  return icCmmStatAllocErr;
}

icChar NamedColor[255];
icStatusCMM rv;

i=m_Xforms->begin();
pApply = i->ptr;
pApplyXform = pApply->GetXform();
if (pApplyXform->GetXformType()!=icXformTypeNamedColor)
  return icCmmStatIncorrectApply;

pXform = (CIccXformNamedColor*)pApplyXform;  
m_pPCS->Reset(pXform->GetSrcSpace(), pXform->UseLegacyPCS());

pDst = m_Pixel;

if (n>1) {
  rv = pXform->Apply(pApply, pDst, SrcColorName, tint);
  if (rv) {
    return rv;
  }

  pSrc = pDst;
  pDst = m_Pixel2;

  for (j=0, i++; j<n-2 && i!=m_Xforms->end(); i++, j++) {

    pApply = i->ptr;
    pApplyXform = pApply->GetXform();
    if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
      CIccXformNamedColor *pXform = (CIccXformNamedColor*)pApplyXform;
      switch(pXform->GetInterface()) {
      case icApplyPixel2Pixel:
        pXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyPixel2Named:
        pXform->Apply(pApply, NamedColor, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyNamed2Pixel:
        rv = pXform->Apply(pApply, pDst, NamedColor);
        if (rv) {
          return rv;
        }
        break;

      default:
        break;
      }
    }
    else {
      pApplyXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pApplyXform));
    }
    pTmp = (icFloatNumber*)pSrc;
    pSrc = pDst;
    pDst = pTmp;
  }

  pApply = i->ptr;
  pApplyXform = pApply->GetXform();
  if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
    pXform = (CIccXformNamedColor*)pApplyXform;
    switch(pXform->GetInterface()) {
    case icApplyPixel2Pixel:
      pXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pXform));
      break;

    case icApplyPixel2Named:
    default:
      return icCmmStatIncorrectApply;
      break;

    case icApplyNamed2Pixel:
      rv = pXform->Apply(pApply, DstPixel, NamedColor);
      if (rv) {
        return rv;
      }
      break;

    }
  }
  else {
    pApplyXform->Apply(pApply, DstPixel, m_pPCS->Check(pSrc, pApplyXform));
  }

}
else if (n==1) {
  rv = pXform->Apply(pApply, DstPixel, SrcColorName, tint);
  if (rv) {
    return rv;
  }
  m_pPCS->Check(DstPixel, pXform);
}

m_pPCS->CheckLast(DstPixel, m_pCmm->GetDestSpace());

return icCmmStatOk;
9733}

9735/**
9736**************************************************************************
9737* Name: CIccApplyNamedColorCmm::Apply
9738* 
9739* Purpose: 
9740*  Does the actual application of the Xforms in the list.
9741*  
9742* Args:
9743*  DstColorName = Destination string where the result is stored, 
9744*  SrcColorName = Source color name which is to be searched.
9745**************************************************************************
9746*/
9747icStatusCMM CIccApplyNamedColorCmm::Apply(icChar *DstColorName, const icChar *SrcColorName, icFloatNumber tint/*=1.0*/)
9748{
icFloatNumber *pDst, *pTmp;
const icFloatNumber *pSrc;
CIccApplyXformList::iterator i;
int j, n = (int)m_Xforms->size();
icChar NamedColor[256];
icStatusCMM rv;
CIccApplyXform *pApply;
const CIccXform *pApplyXform;
CIccXformNamedColor *pXform;

if (!n)
  return icCmmStatBadXform;

if (!m_Pixel && !InitPixel()) {
  return icCmmStatAllocErr;
}

i=m_Xforms->begin();

pApply = i->ptr;
pApplyXform = pApply->GetXform();
if (pApplyXform->GetXformType()!=icXformTypeNamedColor)
  return icCmmStatIncorrectApply;

pXform = (CIccXformNamedColor*)pApplyXform;

m_pPCS->Reset(pXform->GetSrcSpace(), pXform->UseLegacyPCS());

pDst = m_Pixel;

if (n>1) {
  rv = pXform->Apply(pApply, pDst, SrcColorName, tint);

  if (rv) {
    return rv;
  }

  pSrc = pDst;
  pDst = m_Pixel2;

  for (j=0, i++; j<n-2 && i!=m_Xforms->end(); i++, j++) {

    pApply = i->ptr;
    pApplyXform = pApply->GetXform();
    if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
      pXform = (CIccXformNamedColor*)pApplyXform;
      switch(pXform->GetInterface()) {
      case icApplyPixel2Pixel:
        pXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pXform));
        break;


      case icApplyPixel2Named:
        pXform->Apply(pApply, NamedColor, m_pPCS->Check(pSrc, pXform));
        break;

      case icApplyNamed2Pixel:
        rv = pXform->Apply(pApply, pDst, NamedColor);
        if (rv) {
          return rv;
        }
        break;

      default:
        break;
      }
    }
    else {
      pApplyXform->Apply(pApply, pDst, m_pPCS->Check(pSrc, pXform));
    }
    pTmp = (icFloatNumber*)pSrc;
    pSrc = pDst;
    pDst = pTmp;
  }

  pApply = i->ptr;
  pApplyXform = pApply->GetXform();
  if (pApplyXform->GetXformType()==icXformTypeNamedColor) {
    pXform = (CIccXformNamedColor*)pApplyXform;
    switch(pXform->GetInterface()) {
    case icApplyPixel2Named:
      pXform->Apply(pApply, DstColorName, m_pPCS->Check(pSrc, pXform));
      break;

    case icApplyPixel2Pixel:
    case icApplyNamed2Pixel:
    default:
      return icCmmStatIncorrectApply;
      break;
    }
  }
  else {
    return icCmmStatIncorrectApply;
  }

}
else if (n==1) {
  return icCmmStatIncorrectApply;
}

return icCmmStatOk;
9850}

9852/**
**************************************************************************
* Name: CIccNamedColorCmm::CIccNamedColorCmm
* 
* Purpose: 
*  Constructor
*
* Args:
*  nSrcSpace = signature of the source color space,
*  nDestSpace = signature of the destination color space,
*  bFirstInput = true if the first profile added is an input profile
**************************************************************************
*/
9865CIccNamedColorCmm::CIccNamedColorCmm(icColorSpaceSignature nSrcSpace, icColorSpaceSignature nDestSpace,
                                   bool bFirstInput) : CIccCmm(nSrcSpace, nDestSpace, bFirstInput)
9867{
m_nApplyInterface = icApplyPixel2Pixel;
9869}

9871/**
**************************************************************************
* Name: CIccNamedColorCmm::~CIccNamedColorCmm
* 
* Purpose: 
*  Destructor
**************************************************************************
*/
9879CIccNamedColorCmm::~CIccNamedColorCmm()
9880{
9881}


9884/**
**************************************************************************
* Name: CIccNamedColorCmm::AddXform
* 
* Purpose: 
*  Adds a profile at the end of the Xform list 
* 
* Args: 
*  szProfilePath = file name of the profile to be added,
*  nIntent = rendering intent to be used with the profile,
*  nInterp = type of interpolation to be used with the profile
*  pHintManager = hints for creating the xform
* 
* Return: 
*  icCmmStatOk, if the profile was added to the list succesfully
**************************************************************************
*/
9901icStatusCMM CIccNamedColorCmm::AddXform(const icChar *szProfilePath,
                                      icRenderingIntent nIntent /*=icUnknownIntent*/,
                                      icXformInterp nInterp /*icXformInterp*/,
                                      IIccProfileConnectionConditions *pPcc/*=NULL*/,
                                      icXformLutType nLutType /*=icXformLutColor*/,
                                      bool bUseD2BxB2DxTags /*=true*/,
                                      CIccCreateXformHintManager *pHintManager /*=NULL*/,
                                      bool bUseSubProfile /*=false*/)
9909{
CIccProfile *pProfile = OpenIccProfile(szProfilePath, bUseSubProfile);

if (!pProfile) 
  return icCmmStatCantOpenProfile;

icStatusCMM rv = AddXform(pProfile, nIntent, nInterp, pPcc, nLutType, bUseD2BxB2DxTags, pHintManager);

if (rv != icCmmStatOk)
  delete pProfile;

return rv;
9921}

9923/**
**************************************************************************
* Name: CIccNamedColorCmm::AddXform
* 
* Purpose: 
*  Adds a profile at the end of the Xform list 
* 
* Args: 
*  pProfile = pointer to the CIccProfile object to be added,
*  nIntent = rendering intent to be used with the profile,
*  nInterp = type of interpolation to be used with the profile
*  nLutType = type of lut to use from the profile
*  pHintManager = hints for creating the xform
* 
* Return: 
*  icCmmStatOk, if the profile was added to the list succesfully
**************************************************************************
*/
9941icStatusCMM CIccNamedColorCmm::AddXform(CIccProfile *pProfile,
                                      icRenderingIntent nIntent /*=icUnknownIntent*/,
                                      icXformInterp nInterp /*=icInterpLinear*/,
                                      IIccProfileConnectionConditions *pPcc/*=NULL*/,
                                      icXformLutType nLutType /*=icXformLutColor*/,
                                      bool bUseD2BxB2DxTags /*=true*/,
                                      CIccCreateXformHintManager *pHintManager /*=NULL*/)
9948{
icColorSpaceSignature nSrcSpace, nDstSpace;
CIccXformPtr Xform;
bool bInput = !m_bLastInput;
icStatusCMM rv;
icXformLutType nUseLutType = nLutType;

switch(pProfile->m_Header.deviceClass) {
  case icSigMaterialIdentificationClass:
  case icSigMaterialLinkClass:
    nIntent = icPerceptual;
    nLutType = icXformLutMCS;
    break;

  case icSigMaterialVisualizationClass:
    nLutType = icXformLutMCS;
    break;

  default:
    break;
}

Xform.ptr = NULL__null;
switch (nUseLutType) {
  //Automatically choose which one
  case icXformLutColor:
  case icXformLutColorimetric:
  case icXformLutSpectral:
  case icXformLutNamedColor:
  {
    CIccTag *pTag = pProfile->FindTag(icSigNamedColor2Tag);

    if (pTag && (pProfile->m_Header.deviceClass==icSigNamedColorClass || nLutType == icXformLutNamedColor)) {
      if (bInput) {
        nSrcSpace = icSigNamedData;
      }
      else if (nLutType == icXformLutSpectral || (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS && nLutType != icXformLutColorimetric)) {
        nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
        bUseD2BxB2DxTags = true;
      }
      else {
        nSrcSpace = pProfile->m_Header.pcs;
      }

      if (!m_Xforms->size()) {
        if (m_nSrcSpace==icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
          m_nSrcSpace = nSrcSpace;
        }
        else {
          nSrcSpace = m_nSrcSpace;
        }
      }
      else {
        if (m_nLastSpace==icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
          m_nLastSpace = nSrcSpace;
        }
        else {
          nSrcSpace = m_nLastSpace;
        }
      }

      if (nSrcSpace==icSigNamedData) {
        if (nLutType == icXformLutSpectral || (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS && nLutType != icXformLutColorimetric)) {
          nDstSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS; 
          bUseD2BxB2DxTags = true;
        }
        else {
          nDstSpace = pProfile->m_Header.pcs;
        }
        bInput = true;
      }
      else {
        nDstSpace = icSigNamedData;
        bInput = false;
      }

      Xform.ptr = CIccXform::Create(pProfile, bInput, nIntent, nInterp, pPcc, icXformLutNamedColor, bUseD2BxB2DxTags, pHintManager);
      if (!Xform.ptr) {
        return icCmmStatBadXform;
      }
      CIccXformNamedColor *pXform = (CIccXformNamedColor *)Xform.ptr;
      rv = pXform->SetSrcSpace(nSrcSpace);
      if (rv)
        return rv;

      rv = pXform->SetDestSpace(nDstSpace);
      if (rv)
        return rv;
    }
    else {
      //It isn't named color so make we will use color lut.
      if (nUseLutType==icXformLutNamedColor)
        nUseLutType = icXformLutColor;

      //Check pProfile if nIntent and input can be found.
      if (bInput) {
        nSrcSpace = pProfile->m_Header.colorSpace;

        if (nLutType == icXformLutSpectral || (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS && nLutType != icXformLutColorimetric)) {
          nDstSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
          bUseD2BxB2DxTags = true;
        }
        else
          nDstSpace = pProfile->m_Header.pcs;
      }
      else {
        if (pProfile->m_Header.deviceClass == icSigLinkClass) {
          return icCmmStatBadSpaceLink;
        }
        if (pProfile->m_Header.deviceClass == icSigAbstractClass) {
          bInput = true;
          nIntent = icPerceptual; // Note: icPerceptualIntent = 0
        }

        if (nLutType == icXformLutSpectral || (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS && nLutType != icXformLutColorimetric)) {
          nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
          bUseD2BxB2DxTags = true;
        }
        else
          nSrcSpace = pProfile->m_Header.pcs;

        nDstSpace = pProfile->m_Header.colorSpace;
      }
    }
  }
  break;

  case icXformLutPreview:
    nSrcSpace = pProfile->m_Header.pcs;
    nDstSpace = pProfile->m_Header.pcs;
    bInput = false;
    break;

  case icXformLutGamut:
    nSrcSpace = pProfile->m_Header.pcs;
    nDstSpace = icSigGamutData((icColorSpaceSignature) 0x67616D74);
    bInput = true;
    break;

  case icXformLutBRDFParam:
    nSrcSpace = pProfile->m_Header.colorSpace;
    nDstSpace = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
    break;

  case icXformLutBRDFDirect:
    nSrcSpace = pProfile->m_Header.colorSpace;
    nDstSpace = icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f);
    break;

  case icXformLutMCS:
    switch(pProfile->m_Header.deviceClass)
    {
      case icSigInputClass:
      case icSigMaterialIdentificationClass:
        nSrcSpace = pProfile->m_Header.colorSpace;
        nDstSpace = (icColorSpaceSignature)pProfile->m_Header.mcs;
        break;
      case icSigMaterialVisualizationClass:
        nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.mcs;
        if (bUseD2BxB2DxTags && pProfile->m_Header.spectralPCS) {
          nDstSpace = (icColorSpaceSignature)pProfile->m_Header.spectralPCS;
        }
        else {
          nDstSpace = pProfile->m_Header.pcs;
        }
        bInput = true;
        break;

      case icSigMaterialLinkClass:
        nSrcSpace = (icColorSpaceSignature)pProfile->m_Header.mcs;
        nDstSpace = pProfile->m_Header.colorSpace;
        break;

      default:
        return icCmmStatBadLutType;
    }
    break;

  default:
    return icCmmStatBadLutType;
}

//Make sure color spaces match with previous xforms
if (!m_Xforms->size()) {
  if (m_nSrcSpace == icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
    m_nLastSpace = nSrcSpace;
    m_nSrcSpace = nSrcSpace;
  }
  else if (!IsCompatSpace(m_nSrcSpace, nSrcSpace)((m_nSrcSpace)==(nSrcSpace) || ((((m_nSrcSpace)==icSigXYZData
 || (m_nSrcSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nSrcSpace
)) && (((nSrcSpace)==icSigXYZData || (nSrcSpace)==icSigLabData
) || IsSpaceSpectralPCS(nSrcSpace))) || ((((icColorSpaceSignature
)(((icUInt32Number)m_nSrcSpace)&0xffff0000))==icSigSrcMCSChannelData
) && (((icColorSpaceSignature)(((icUInt32Number)nSrcSpace
)&0xffff0000))==icSigSrcMCSChannelData)) ) && !IsNChannelCompat(m_nSrcSpace, nSrcSpace)(((((icColorSpaceSignature)(((icUInt32Number)m_nSrcSpace)&
0xffff0000))==icSigNChannelData) && (((icUInt32Number
)m_nSrcSpace)&0x0000ffff)==icGetSpaceSamples(nSrcSpace)) ||
 ((((icColorSpaceSignature)(((icUInt32Number)nSrcSpace)&0xffff0000
))==icSigNChannelData) && (((icUInt32Number)nSrcSpace
)&0x0000ffff)==icGetSpaceSamples(m_nSrcSpace)))) {
    return icCmmStatBadSpaceLink;
  }
}
else if (!IsCompatSpace(m_nLastSpace, nSrcSpace)((m_nLastSpace)==(nSrcSpace) || ((((m_nLastSpace)==icSigXYZData
 || (m_nLastSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nLastSpace
)) && (((nSrcSpace)==icSigXYZData || (nSrcSpace)==icSigLabData
) || IsSpaceSpectralPCS(nSrcSpace))) || ((((icColorSpaceSignature
)(((icUInt32Number)m_nLastSpace)&0xffff0000))==icSigSrcMCSChannelData
) && (((icColorSpaceSignature)(((icUInt32Number)nSrcSpace
)&0xffff0000))==icSigSrcMCSChannelData)) ) && !IsNChannelCompat(m_nSrcSpace, nSrcSpace)(((((icColorSpaceSignature)(((icUInt32Number)m_nSrcSpace)&
0xffff0000))==icSigNChannelData) && (((icUInt32Number
)m_nSrcSpace)&0x0000ffff)==icGetSpaceSamples(nSrcSpace)) ||
 ((((icColorSpaceSignature)(((icUInt32Number)nSrcSpace)&0xffff0000
))==icSigNChannelData) && (((icUInt32Number)nSrcSpace
)&0x0000ffff)==icGetSpaceSamples(m_nSrcSpace))))  {
    return icCmmStatBadSpaceLink;
}

//Automatic creation of intent from header/last profile
if (nIntent==icUnknownIntent((icRenderingIntent) 0x3f3f3f3f)) {
  if (bInput) {
    nIntent = (icRenderingIntent)pProfile->m_Header.renderingIntent;
  }
  else {
    nIntent = m_nLastIntent;
  }
  if (nIntent == icUnknownIntent((icRenderingIntent) 0x3f3f3f3f))
    nIntent = icPerceptual;
}

if (!Xform.ptr)
  Xform.ptr = CIccXform::Create(pProfile, bInput, nIntent, nInterp, pPcc, nUseLutType, bUseD2BxB2DxTags, pHintManager);

if (!Xform.ptr) {
  return icCmmStatBadXform;
}

m_nLastSpace = Xform.ptr->GetDstSpace();
m_nLastIntent = nIntent;

if (pProfile->m_Header.deviceClass == icSigLinkClass)
  bInput = false;
m_bLastInput = bInput;

m_Xforms->push_back(Xform);

return icCmmStatOk;
10173}

10175/**
**************************************************************************
* Name: CIccNamedColorCmm::Begin
* 
* Purpose: 
*  Does the initialization of the Xforms in the list before Apply() is called.
*  Must be called before Apply().
*
**************************************************************************
*/
icStatusCMM CIccNamedColorCmm::Begin(bool bAllocNewApply/* =true */, bool bUsePcsConversion/*=false*/)
10186{
if (m_nDestSpace==icSigUnknownData((icColorSpaceSignature) 0x3f3f3f3f)) {
  m_nDestSpace = m_nLastSpace;
}
else if (!IsCompatSpace(m_nDestSpace, m_nLastSpace)((m_nDestSpace)==(m_nLastSpace) || ((((m_nDestSpace)==icSigXYZData
 || (m_nDestSpace)==icSigLabData) || IsSpaceSpectralPCS(m_nDestSpace
)) && (((m_nLastSpace)==icSigXYZData || (m_nLastSpace
)==icSigLabData) || IsSpaceSpectralPCS(m_nLastSpace))) || (((
(icColorSpaceSignature)(((icUInt32Number)m_nDestSpace)&0xffff0000
))==icSigSrcMCSChannelData) && (((icColorSpaceSignature
)(((icUInt32Number)m_nLastSpace)&0xffff0000))==icSigSrcMCSChannelData
)) )) {
  return icCmmStatBadSpaceLink;
}

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

SetLateBindingCC();

icStatusCMM rv;
CIccXformList::iterator i;

for (i=m_Xforms->begin(); i!=m_Xforms->end(); i++) {
  rv = i->ptr->Begin();

  if (rv!= icCmmStatOk) {
    return rv;
  }
}

rv = CheckPCSConnections(bUsePcsConversion);
if (rv != icCmmStatOk && rv!=icCmmStatIdentityXform)
  return rv;

if (bAllocNewApply) {
  rv = icCmmStatOk;

  m_pApply = GetNewApplyCmm(rv);
}
else
  rv = icCmmStatOk;

return rv;
10237}

/**
**************************************************************************
* Name: CIccNamedColorCmm::GetNewApplyCmm
* 
* Purpose: 
*  Allocates a CIccApplyCmm object that allows one to call apply from
*  multiple threads.
*
**************************************************************************
*/
CIccApplyCmm *CIccNamedColorCmm::GetNewApplyCmm(icStatusCMM &status)
{
CIccApplyCmm *pApply = new CIccApplyNamedColorCmm(this);

CIccXformList::iterator i;

for (i=m_Xforms->begin(); i!=m_Xforms->end(); i++) {
  CIccApplyXform *pXform = i->ptr->GetNewApply(status);
  if (status != icCmmStatOk || !pXform) {
    delete pApply;
    return NULL__null;
  }
  pApply->AppendApplyXform(pXform);
}

m_bValid = true;

status = icCmmStatOk;
return pApply;
10268}


/**
**************************************************************************
* Name: CIccApplyNamedColorCmm::Apply
* 
* Purpose: 
*  Does the actual application of the Xforms in the list.
*  
* Args:
*  DstColorName = Destination string where the result is stored, 
*  SrcPoxel = Source pixel
**************************************************************************
*/
10283icStatusCMM CIccNamedColorCmm::Apply(icChar* DstColorName, const icFloatNumber *SrcPixel)
10284{
return ((CIccApplyNamedColorCmm*)m_pApply)->Apply(DstColorName, SrcPixel);
10286}


10289/**
10290**************************************************************************
10291* Name: CIccApplyNamedColorCmm::Apply
10292* 
10293* Purpose: 
10294*  Does the actual application of the Xforms in the list.
10295*  
10296* Args:
10297*  DestPixel = Destination pixel where the result is stored, 
10298*  SrcColorName = Source color name which is to be searched.
10299**************************************************************************
10300*/
10301icStatusCMM CIccNamedColorCmm::Apply(icFloatNumber *DstPixel, const icChar *SrcColorName, icFloatNumber tint/*=1.0*/)
10302{
return ((CIccApplyNamedColorCmm*)m_pApply)->Apply(DstPixel, SrcColorName, tint);
10304}


10307/**
10308**************************************************************************
10309* Name: CIccApplyNamedColorCmm::Apply
10310* 
10311* Purpose: 
10312*  Does the actual application of the Xforms in the list.
10313*  
10314* Args:
10315*  DstColorName = Destination string where the result is stored, 
10316*  SrcColorName = Source color name which is to be searched.
10317**************************************************************************
10318*/
10319icStatusCMM CIccNamedColorCmm::Apply(icChar* DstColorName, const icChar *SrcColorName, icFloatNumber tint/*=1.0*/)
10320{
return ((CIccApplyNamedColorCmm*)m_pApply)->Apply(DstColorName, SrcColorName, tint);
10322}


10325/**
**************************************************************************
* Name: CIccNamedColorCmm::SetLastXformDest
* 
* Purpose: 
*  Sets the destination Color space of the last Xform in the list
* 
* Args: 
*  nDestSpace = signature of the color space to be set
**************************************************************************
*/
10336icStatusCMM CIccNamedColorCmm::SetLastXformDest(icColorSpaceSignature nDestSpace)
10337{
int n = (int)m_Xforms->size();
CIccXformPtr *pLastXform;

if (!n)
  return icCmmStatBadXform;

pLastXform = &m_Xforms->back();

if (pLastXform->ptr->GetXformType()==icXformTypeNamedColor) {
  CIccXformNamedColor *pXform = (CIccXformNamedColor *)pLastXform->ptr;
  if (pXform->GetSrcSpace() == icSigNamedData &&
      nDestSpace == icSigNamedData) {
    return icCmmStatBadSpaceLink;
  }

  if (nDestSpace != icSigNamedData &&
      pXform->GetDstSpace() == icSigNamedData) {
    return icCmmStatBadSpaceLink;
  }
  
  return pXform->SetDestSpace(nDestSpace);
}

return icCmmStatBadXform;
10362}


10365/**
10366****************************************************************************
10367* Name: CIccMruCmm::CIccMruCmm
10368* 
10369* Purpose: private constructor - Use Attach to create CIccMruCmm objects
10370*****************************************************************************
10371*/
10372CIccMruCmm::CIccMruCmm()
10373{
m_pCmm = NULL__null;
m_bDeleteCmm = false;
10376}


10379/**
10380****************************************************************************
10381* Name: CIccMruCmm::~CIccMruCmm
10382* 
10383* Purpose: destructor
10384*****************************************************************************
10385*/
10386CIccMruCmm::~CIccMruCmm()
10387{
 if (m_pCmm && m_bDeleteCmm)
   delete m_pCmm;
10390}


10393/**
10394****************************************************************************
10395* Name: CIccMruCmm::Attach
10396* 
10397* Purpose: Create a Cmm decorator object that implements a cache of most
10398*  recently used pixel transformations.
10399* 
10400* Args:
10401*  pCmm - pointer to cmm object that we are attaching to.
10402*  nCacheSize - number of most recently used transformations to cache
10403*  bDeleteCmm - flag to indicate whether cmm should be deleted when
10404*    this is destroyed.
10405*
10406* Return:
10407*  A CIccMruCmm object that represents a cached form of the pCmm passed in.
10408*  The pCmm will be owned by the returned object unless.
10409*
10410*  If this function fails the pCmm object will be deleted.
10411*****************************************************************************
10412*/
10413CIccMruCmm* CIccMruCmm::Attach(CIccCmm *pCmm, icUInt8Number nCacheSize/* =4 */, bool bDeleteCmm/*=true*/)
10414{
if (!pCmm || !nCacheSize)
  return NULL__null;

if (!pCmm->Valid()) {
  if (bDeleteCmm)
    delete pCmm;
  return NULL__null;
}

CIccMruCmm *rv = new CIccMruCmm();

rv->m_pCmm = pCmm;
rv->m_nCacheSize = nCacheSize;
rv->m_bDeleteCmm = bDeleteCmm;

rv->m_nSrcSpace = pCmm->GetSourceSpace();
rv->m_nDestSpace = pCmm->GetDestSpace();
rv->m_nLastSpace = pCmm->GetLastSpace();
rv->m_nLastIntent = pCmm->GetLastIntent();

if (rv->Begin()!=icCmmStatOk) {
  delete rv;
  return NULL__null;
}

return rv;
10441}

10443CIccApplyCmm *CIccMruCmm::GetNewApplyCmm(icStatusCMM &status)
10444{
CIccApplyMruCmm *rv = new CIccApplyMruCmm(this);

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

if (!rv->Init(m_pCmm, m_nCacheSize)) {
  delete rv;
  status = icCmmStatBad;
  return NULL__null;
}

return rv;
10459}

10461/**
10462****************************************************************************
10463* Name: CIccMruCache::CIccMruCache
10464*
10465* Purpose: constructor
10466*****************************************************************************
10467*/
10468template<class T>
10469CIccMruCache<T>::CIccMruCache()
10470{
m_cache = NULL__null;

m_pixelData = NULL__null;
10474}

10476/**
10477****************************************************************************
10478* Name: CIccMruCache::~CIccMruCache
10479*
10480* Purpose: destructor
10481*****************************************************************************
10482*/
10483template<class T>
10484CIccMruCache<T>::~CIccMruCache()
10485{
if (m_cache)
  delete[] m_cache;

if (m_pixelData)
  free(m_pixelData);
10491}

10493/**
10494****************************************************************************
10495* Name: CIccMruCache::Init
10496*
10497* Purpose: Initialize the object and set up the cache
10498*
10499* Args:
10500*  pCmm - pointer to cmm object that we are attaching to.
10501*  nCacheSize - number of most recently used transformations to cache
10502*
10503* Return:
10504*  true if successful
10505*****************************************************************************
10506*/
10507template<class T>
10508bool CIccMruCache<T>::Init(icUInt16Number nSrcSamples, icUInt16Number nDstSamples, icUInt16Number nCacheSize)
10509{
m_nSrcSamples = nSrcSamples;
m_nSrcSize = nSrcSamples * sizeof(T);
m_nDstSize = nDstSamples * sizeof(T);

m_nTotalSamples = m_nSrcSamples + nDstSamples;

m_nNumPixel = 0;
m_nCacheSize = nCacheSize;

m_pFirst = NULL__null;
m_cache = new CIccMruPixel<T>[nCacheSize];

if (!m_cache)
  return false;

m_pixelData = (T*)malloc(nCacheSize * m_nTotalSamples * sizeof(T));

if (!m_pixelData)
  return false;

return true;
10531}

10533template<class T>
10534CIccMruCache<T> *CIccMruCache<T>::NewMruCache(icUInt16Number nSrcSamples, icUInt16Number nDstSamples, icUInt16Number nCacheSize /* = 4 */)
10535{
CIccMruCache<T> *rv = new CIccMruCache<T>;

if (!rv->Init(nSrcSamples, nDstSamples, nCacheSize)) {
  delete rv;
  return NULL__null;
}

return rv;
10544}

10546/**
10547****************************************************************************
10548* Name: CIccMruCache::Apply
10549*
10550* Purpose: Apply a transformation to a pixel.
10551*
10552* Args:
10553*  DstPixel - Location to store pixel results
10554*  SrcPixel - Location to get pixel values from
10555*
10556* Return:
10557*  true if SrcPixel found in cache and DstPixel initialized with value
10558*  fails if SrcPixel not found (DstPixel not touched)
10559*****************************************************************************
10560*/
10561template<class T>
10562bool CIccMruCache<T>::Apply(T *DstPixel, const T *SrcPixel)
10563{
CIccMruPixel<T> *ptr, *prev = NULL__null, *last = NULL__null;
int i;
T *pixel;

for (ptr = m_pFirst, i = 0; ptr; ptr = ptr->pNext, i++) {
  if (!memcmp(SrcPixel, ptr->pPixelData, m_nSrcSize)) {
    memcpy(DstPixel, &ptr->pPixelData[m_nSrcSamples], m_nDstSize);
    if (ptr != m_pFirst) {
      last->pNext = ptr->pNext;

      ptr->pNext = m_pFirst;
      m_pFirst = ptr;
    }
    return true;
  }
  prev = last;
  last = ptr;
}

//If we get here SrcPixel is not in the cache
if (i < m_nCacheSize) {
  pixel = &m_pixelData[i*m_nTotalSamples];

  ptr = &m_cache[i];
  ptr->pPixelData = pixel;

  if (m_pFirst) {
    ptr->pNext = m_pFirst;
  }
  m_pFirst = ptr;
}
else {  //Reuse oldest value and put it at the front of the list
  prev->pNext = NULL__null;
  last->pNext = m_pFirst;

  m_pFirst = last;
  pixel = last->pPixelData;
}
T *dest = &pixel[m_nSrcSamples];

memcpy(pixel, SrcPixel, m_nSrcSize);

return false;
10607}

10609template<class T>
10610void CIccMruCache<T>::Update(T* DstPixel)
10611{
memcpy(&m_pFirst->pPixelData[m_nSrcSamples], DstPixel, m_nDstSize);
10613}

10615//Make sure typedef classes get built
10616template class CIccMruCache<icFloatNumber>;
10617template class CIccMruCache<icUInt8Number>;
10618template class CIccMruCache<icUInt16Number>;


10621CIccApplyMruCmm::CIccApplyMruCmm(CIccMruCmm *pCmm) : CIccApplyCmm(pCmm)
10622{
m_pCachedCmm = NULL__null;
m_pCache = NULL__null;
10625}

10627/**
10628****************************************************************************
10629* Name: CIccApplyMruCmm::~CIccApplyMruCmm
10630* 
10631* Purpose: destructor
10632*****************************************************************************
10633*/
10634CIccApplyMruCmm::~CIccApplyMruCmm()
10635{
if (m_pCache)
  delete m_pCache;

10639}

10641/**
10642****************************************************************************
10643* Name: CIccApplyMruCmm::Init
10644* 
10645* Purpose: Initialize the object and set up the cache
10646* 
10647* Args:
10648*  pCmm - pointer to cmm object that we are attaching to.
10649*  nCacheSize - number of most recently used transformations to cache
10650*
10651* Return:
10652*  true if successful
10653*****************************************************************************
10654*/
10655bool CIccApplyMruCmm::Init(CIccCmm *pCachedCmm, icUInt16Number nCacheSize)
10656{
m_pCachedCmm = pCachedCmm;

m_pCache = CIccMruCacheFloat::NewMruCache(m_pCmm->GetSourceSamples(), m_pCmm->GetDestSamples(), nCacheSize);

if (!m_pCache)
  return false;

return true;
10665}

10667/**
10668****************************************************************************
10669* Name: CIccMruCmm::Apply
10670* 
10671* Purpose: Apply a transformation to a pixel.
10672* 
10673* Args:
10674*  DstPixel - Location to store pixel results
10675*  SrcPixel - Location to get pixel values from
10676*
10677* Return:
10678*  icCmmStatOk if successful
10679*****************************************************************************
10680*/
10681icStatusCMM CIccApplyMruCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel)
10682{
10683#if defined(_DEBUG)
if (!m_pCache)
  return icCmmStatInvalidLut;
10686#endif

if (!m_pCache->Apply(DstPixel, SrcPixel)) {

  m_pCachedCmm->Apply(DstPixel, SrcPixel);

  m_pCache->Update(DstPixel);
}

return icCmmStatOk;
10696}

10698/**
10699****************************************************************************
10700* Name: CIccMruCmm::Apply
10701* 
10702* Purpose: Apply a transformation to a pixel.
10703* 
10704* Args:
10705*  DstPixel - Location to store pixel results
10706*  SrcPixel - Location to get pixel values from
10707*  nPixels - number of pixels to convert
10708*
10709* Return:
10710*  icCmmStatOk if successful
10711*****************************************************************************
10712*/
10713icStatusCMM CIccApplyMruCmm::Apply(icFloatNumber *DstPixel, const icFloatNumber *SrcPixel, icUInt32Number nPixels)
10714{
icUInt32Number k;

10717#if defined(_DEBUG)
if (!m_pCache)
  return icCmmStatInvalidLut;
10720#endif

for (k=0; k<nPixels;k++) {
  if (!m_pCache->Apply(DstPixel, SrcPixel)) {
    m_pCachedCmm->Apply(DstPixel, SrcPixel);
    m_pCache->Update(DstPixel);
  }
  SrcPixel += m_pCmm->GetSourceSamples();
  DstPixel += m_pCmm->GetDestSamples();
}

return icCmmStatOk;
10732}


10735#ifdef USEREFICCMAXNAMESPACE
10736} //namespace refIccMAX
10737#endif