archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/windows/core/ntgdi/icm/mscms/profile.c

3672 lines
100 KiB
Raw Permalink Blame History

/****************************Module*Header******************************\
* Module Name: PROFILE.C
*
* Module Descripton: Profile data manipulation functions
*
* Warnings:
*
* Issues:
*
* Public Routines:
*
* Created: 11 January 1996
* Author: Srinivasan Chandrasekar [srinivac]
*
* Copyright (c) 1996, 1997 Microsoft Corporation
\***********************************************************************/
#include "mscms.h"
#define PROFILE_GROWTHCUSHION 16*1024
//
// Local functions
//
HPROFILE InternalOpenColorProfile(PPROFILE, DWORD, DWORD, DWORD);
BOOL InternalCreateProfileFromLCS(LPLOGCOLORSPACE, PBYTE*, BOOL);
BOOL FreeProfileObject(HPROFILE);
BOOL AddTagTableEntry(PPROFOBJ, TAGTYPE, DWORD, DWORD, BOOL);
BOOL AddTaggedElement(PPROFOBJ, TAGTYPE, DWORD);
BOOL DeleteTaggedElement(PPROFOBJ, PTAGDATA);
BOOL ChangeTaggedElementSize(PPROFOBJ, PTAGDATA, DWORD);
BOOL GrowProfile(PPROFOBJ, DWORD);
void MoveProfileData(PPROFOBJ, PBYTE, PBYTE, LONG, BOOL);
BOOL IsReferenceTag(PPROFOBJ, PTAGDATA);
/******************************************************************************
*
* OpenColorProfile
*
* Function:
* These are the ANSI & Unicode wrappers for InternalOpenColorProfile.
* Please see InternalOpenColorProfile for more details on this function.
*
* Returns:
* Handle to open profile on success, zero on failure.
*
******************************************************************************/
#ifdef UNICODE // Windows NT versions
HPROFILE WINAPI OpenColorProfileA(
PPROFILE pProfile,
DWORD dwDesiredAccess,
DWORD dwShareMode,
DWORD dwCreationMode
)
{
PROFILE wProfile; // Unicode version
HPROFILE rc = NULL;
//
// Validate parameters before touching them
//
if (!pProfile ||
IsBadReadPtr(pProfile, sizeof(PROFILE)) ||
(pProfile->pProfileData &&
IsBadReadPtr(pProfile->pProfileData, pProfile->cbDataSize)) ||
(!pProfile->pProfileData &&
(pProfile->cbDataSize != 0)) ||
(pProfile->dwType != PROFILE_FILENAME &&
pProfile->dwType != PROFILE_MEMBUFFER
)
)
{
WARNING((__TEXT("Invalid parameter to OpenColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
if (pProfile->dwType == PROFILE_FILENAME)
{
//
// Convert the profile name to Unicode and call the Unicode version
//
wProfile.dwType = pProfile->dwType;
if (!pProfile->pProfileData || pProfile->cbDataSize == 0)
{
WARNING((__TEXT("Invalid parameter to OpenColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
wProfile.pProfileData = (WCHAR*)MemAlloc(pProfile->cbDataSize * sizeof(WCHAR));
if (!wProfile.pProfileData)
{
WARNING((__TEXT("Error allocating memory for Unicode profile structure\n")));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
if (! MultiByteToWideChar(CP_ACP, 0, pProfile->pProfileData, pProfile->cbDataSize,
wProfile.pProfileData, pProfile->cbDataSize))
{
WARNING((__TEXT("Error converting profile structure to Unicode\n")));
goto EndOpenColorProfileA;
}
wProfile.cbDataSize = pProfile->cbDataSize * sizeof(WCHAR);
}
else
{
//
// It is a memory based profile, so no ANSI/Unicode conversion
//
wProfile = *pProfile;
}
rc = InternalOpenColorProfile(&wProfile, dwDesiredAccess,
dwShareMode, dwCreationMode);
EndOpenColorProfileA:
if (pProfile->dwType == PROFILE_FILENAME)
{
MemFree(wProfile.pProfileData);
}
return rc;
}
HPROFILE WINAPI OpenColorProfileW(
PPROFILE pProfile,
DWORD dwDesiredAccess,
DWORD dwShareMode,
DWORD dwCreationMode
)
{
//
// Internal function is Unicode in Windows NT, call it directly.
//
return InternalOpenColorProfile(pProfile, dwDesiredAccess,
dwShareMode, dwCreationMode);
}
#else // Windows 95 versions
HPROFILE WINAPI OpenColorProfileA(
PPROFILE pProfile,
DWORD dwDesiredAccess,
DWORD dwShareMode,
DWORD dwCreationMode
)
{
//
// Internal function is ANSI in Windows 95, call it directly.
//
return InternalOpenColorProfile(pProfile, dwDesiredAccess,
dwShareMode, dwCreationMode);
}
HPROFILE WINAPI OpenColorProfileW(
PPROFILE pProfile,
DWORD dwDesiredAccess,
DWORD dwShareMode,
DWORD dwCreationMode
)
{
PROFILE aProfile; // ANSI version
HPROFILE rc = NULL;
BOOL bUsedDefaultChar;
//
// Validate parameters before touching them
//
if (!pProfile ||
IsBadReadPtr(pProfile, sizeof(PROFILE)) ||
(pProfile->pProfileData &&
IsBadReadPtr(pProfile->pProfileData, pProfile->cbDataSize)) ||
(!pProfile->pProfileData &&
(pProfile->cbDataSize != 0)) ||
(pProfile->dwType != PROFILE_FILENAME &&
pProfile->dwType != PROFILE_MEMBUFFER
)
)
{
WARNING((__TEXT("Invalid parameter to OpenColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
if (pProfile->dwType == PROFILE_FILENAME)
{
//
// Convert the profile name to ANSI and call the ANSI version
//
aProfile.dwType = pProfile->dwType;
if (!pProfile->pProfileData || pProfile->cbDataSize == 0)
{
WARNING((__TEXT("Invalid parameter to OpenColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
aProfile.pProfileData = (char*)MemAlloc(pProfile->cbDataSize * sizeof(char));
if (!aProfile.pProfileData)
{
WARNING((__TEXT("Error allocating memory for ANSI profile structure\n")));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
if (! WideCharToMultiByte(CP_ACP, 0, pProfile->pProfileData, pProfile->cbDataSize/sizeof(WCHAR),
aProfile.pProfileData, pProfile->cbDataSize,
NULL, &bUsedDefaultChar) || bUsedDefaultChar)
{
WARNING((__TEXT("Error converting profile structure to ANSI\n")));
goto EndOpenColorProfileW;
}
aProfile.cbDataSize = pProfile->cbDataSize * sizeof(char);
}
else
{
//
// It is a memory based profile, so no ANSI/Unicode conversion
//
aProfile = *pProfile;
}
rc = InternalOpenColorProfile(&aProfile, dwDesiredAccess,
dwShareMode, dwCreationMode);
EndOpenColorProfileW:
if (pProfile->dwType == PROFILE_FILENAME)
{
MemFree(aProfile.pProfileData);
}
return rc;
}
#endif // ! UNICODE
/******************************************************************************
*
* CloseColorProfile
*
* Function:
* This functions closes a color profile object, and frees all memory
* associated with it.
*
* Arguments:
* hProfile - handle identifing the profile object
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI CloseColorProfile(
HPROFILE hProfile
)
{
TRACEAPI((__TEXT("CloseColorProfile\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE))
{
WARNING((__TEXT("Invalid parameter to CloseColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
return FreeProfileObject(hProfile);
}
/******************************************************************************
*
* GetColorProfileFromHandle
*
* Function:
* This functions returns a buffer filled with the profile contents.
*
* Arguments:
* hProfile - handle identifing the profile object
* pProfileData - pointer to buffer to receive the data. Can be NULL.
* pcbData - pointer to size of buffer. On return it is size
* filled/needed.
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI GetColorProfileFromHandle(
HPROFILE hProfile,
PBYTE pProfileData,
PDWORD pcbSize
)
{
PPROFOBJ pProfObj;
DWORD dwFileSize;
BOOL rc = FALSE;
//
// ValidatePrameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!pcbSize ||
IsBadWritePtr(pcbSize, sizeof(DWORD)) ||
(pProfileData &&
IsBadWritePtr(pProfileData, *pcbSize)))
{
WARNING((__TEXT("Invalid parameter to CloseColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
dwFileSize = FIX_ENDIAN(HEADER(pProfObj)->phSize);
if (pProfileData && *pcbSize >= dwFileSize)
{
CopyMemory(pProfileData, pProfObj->pView, dwFileSize);
rc = TRUE;
}
else
{
SetLastError(ERROR_INSUFFICIENT_BUFFER);
}
*pcbSize = dwFileSize;
return rc;
}
/******************************************************************************
*
* IsColorProfileValid
*
* Function:
* This functions checks if a given profile is a valid ICC profile
* that can be used for color matching
*
* Arguments:
* hProfile - handle identifing the profile object
* pbValid - Pointer to variable that receives TRUE if it is a
* valid profile, FALSE otherwise
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI IsColorProfileValid(
HPROFILE hProfile,
PBOOL pbValid
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID;
BOOL rc = FALSE;
TRACEAPI((__TEXT("IsColorProfileValid\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!pbValid ||
IsBadWritePtr(pbValid, sizeof(BOOL)))
{
WARNING((__TEXT("Invalid parameter to IsColorProfileValid\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Quick check on the integrity of the profile before calling the CMM
//
if (!ValidProfile(pProfObj))
{
*pbValid = FALSE;
return TRUE;
}
//
// Get CMM associated with profile. If it does not exist or does not
// support the CMValidate function, get default CMM.
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj || !pCMMObj->fns.pCMIsProfileValid)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj || !pCMMObj->fns.pCMIsProfileValid)
{
RIP((__TEXT("Default CMM doesn't support CMValidateProfile")));
SetLastError(ERROR_INVALID_CMM);
goto EndIsColorProfileValid;
}
}
ASSERT(pProfObj->pView != NULL);
rc = pCMMObj->fns.pCMIsProfileValid(hProfile, pbValid);
EndIsColorProfileValid:
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
return rc;
}
/******************************************************************************
*
* CreateProfileFromLogColorSpace
*
* Function:
* These are the ANSI & Unicode wrappers for InternalCreateProfileFromLCS.
* Please see InternalCreateProfileFromLCS for more details on this
* function.
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
#ifdef UNICODE // Windows NT versions
BOOL WINAPI CreateProfileFromLogColorSpaceA(
LPLOGCOLORSPACEA pLogColorSpace,
PBYTE *pBuffer
)
{
LOGCOLORSPACEW lcs;
//
// Validate Parameters
//
if (! pLogColorSpace ||
IsBadReadPtr(pLogColorSpace, sizeof(LOGCOLORSPACEA)) ||
pLogColorSpace->lcsFilename[0] != '\0')
{
WARNING((__TEXT("Invalid parameter to CreateProfileFromLogColorSpace\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*((LPLOGCOLORSPACEA)&lcs) = *pLogColorSpace;
lcs.lcsFilename[0] = '\0';
return InternalCreateProfileFromLCS(&lcs, pBuffer, FALSE);
}
BOOL WINAPI CreateProfileFromLogColorSpaceW(
LPLOGCOLORSPACEW pLogColorSpace,
PBYTE *pBuffer
)
{
//
// Internal function is Unicode in Windows NT, call it directly.
//
return InternalCreateProfileFromLCS(pLogColorSpace, pBuffer, TRUE);
}
#else // Windows 95 versions
BOOL WINAPI CreateProfileFromLogColorSpaceA(
LPLOGCOLORSPACEA pLogColorSpace,
PBYTE *pBuffer
)
{
//
// Internal function is ANSI in Windows 95, call it directly.
//
return InternalCreateProfileFromLCS(pLogColorSpace, pBuffer, TRUE);
}
BOOL WINAPI CreateProfileFromLogColorSpaceW(
LPLOGCOLORSPACEW pLogColorSpace,
PBYTE *pBuffer
)
{
LOGCOLORSPACEA lcs;
//
// Validate Parameters
//
if (! pLogColorSpace ||
IsBadReadPtr(pLogColorSpace, sizeof(LOGCOLORSPACEW)) ||
pLogColorSpace->lcsFilename[0] != '\0')
{
WARNING((__TEXT("Invalid parameter to CreateProfileFromLogColorSpace\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
lcs = *((LPLOGCOLORSPACEA)pLogColorSpace);
lcs.lcsFilename[0] = '\0';
return InternalCreateProfileFromLCS(&lcs, pBuffer, FALSE);
}
#endif // ! UNICODE
/******************************************************************************
*
* IsColorProfileTagPresent
*
* Function:
* This functions checks if a given tag is present in the profile
*
* Arguments:
* hProfile - handle identifing the profile object
* tagType - the tag to check for
* pbPrent - pointer to variable that receives TRUE if it the tag is
* present, FALSE otherwise
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI IsColorProfileTagPresent(
HPROFILE hProfile,
TAGTYPE tagType,
PBOOL pbPresent
)
{
PPROFOBJ pProfObj;
PTAGDATA pTagData;
DWORD nCount, i;
TRACEAPI((__TEXT("IsColorProfileTagPresent\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!pbPresent ||
IsBadWritePtr(pbPresent, sizeof(BOOL)))
{
WARNING((__TEXT("Invalid parameter to IsColorProfileTagPresent\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to IsColorProfileTagPresent\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
VERBOSE((__TEXT("Profile 0x%x has 0x%x(%d) tags\n"), hProfile, nCount, nCount));
//
// Tag data records follow the count.
//
pTagData = TAG_DATA(pProfObj);
//
// Check if any of these records match the tag passed in.
//
*pbPresent = FALSE;
tagType = FIX_ENDIAN(tagType); // to match tags in profile
for (i=0; i<nCount; i++)
{
if (pTagData->tagType == tagType)
{
*pbPresent = TRUE;
break;
}
pTagData++; // Next record
}
return TRUE;
}
/******************************************************************************
*
* GetCountColorProfileElements
*
* Function:
* This functions returns the number of tagged elements in the profile
*
* Arguments:
* hProfile - handle identifing the profile object
* pnCount - pointer to variable to receive number of tagged elements
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI GetCountColorProfileElements(
HPROFILE hProfile,
PDWORD pnCount
)
{
PPROFOBJ pProfObj;
TRACEAPI((__TEXT("GetCountColorProfileElements\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!pnCount ||
IsBadWritePtr(pnCount, sizeof(DWORD)))
{
WARNING((__TEXT("Invalid parameter to GetCountColorProfileElements\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetCountColorProfileElements\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Get count of tag items - it is right after the profile header
//
*pnCount = TAG_COUNT(pProfObj);
*pnCount = FIX_ENDIAN(*pnCount);
return TRUE;
}
/******************************************************************************
*
* GetColorProfileElementTag
*
* Function:
* This functions retrieves the tag name of the dwIndex'th element
* in the profile
*
* Arguments:
* hProfile - handle identifing the profile object
* dwIndex - one-based index of the tag whose name is required
* pTagType - gets the name of the tag on return
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI GetColorProfileElementTag(
HPROFILE hProfile,
DWORD dwIndex,
PTAGTYPE pTagType
)
{
PPROFOBJ pProfObj;
PTAGDATA pTagData;
DWORD nCount;
BOOL rc = FALSE;
TRACEAPI((__TEXT("GetColorProfileElementTag\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
IsBadWritePtr(pTagType, sizeof(TAGTYPE)) ||
dwIndex <= 0)
{
WARNING((__TEXT("Invalid parameter to GetColorProfileElementTag\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetColorProfileElementTag\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
if (dwIndex > nCount)
{
WARNING((__TEXT("GetColorProfileElementTag:index (%d) invalid\n"), dwIndex));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
//
// Tag data records follow the count.
//
pTagData = TAG_DATA(pProfObj);
*pTagType = FIX_ENDIAN(pTagData[dwIndex-1].tagType); // 1-based index
return TRUE;
}
/******************************************************************************
*
* GetColorProfileElement
*
* Function:
* This functions retrieves the data that a tagged element refers to
* starting from the given offset.
*
* Arguments:
* hProfile - handle identifing the profile object
* tagType - the tag name of the element whose data is required
* dwOffset - offset within the element data from which to retrieve
* pcbSize - number of bytes to get. On return it is the number of
* bytes retrieved
* pBuffer - pointer to buffer to recieve data
*
* Returns:
* TRUE if successful, FALSE otherwise
*
* Comments:
* If pBuffer is NULL, it returns size of data in *pcbSize and ignores
* dwOffset.
*
******************************************************************************/
BOOL WINAPI GetColorProfileElement(
HPROFILE hProfile,
TAGTYPE tagType,
DWORD dwOffset,
PDWORD pcbSize,
PVOID pBuffer,
PBOOL pbReference
)
{
PPROFOBJ pProfObj;
PTAGDATA pTagData;
DWORD nCount, nBytes, i;
BOOL found;
BOOL rc = FALSE; // Assume failure
TRACEAPI((__TEXT("GetColorProfileElement\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!pcbSize ||
IsBadWritePtr(pcbSize, sizeof(DWORD)) ||
!pbReference ||
IsBadWritePtr(pbReference, sizeof(BOOL))
)
{
WARNING((__TEXT("Invalid parameter to GetColorProfileElement\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetColorProfileElement\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
//
// Tag data records follow the count.
//
pTagData = TAG_DATA(pProfObj);
//
// Check if any of these records match the tag passed in.
//
found = FALSE;
tagType = FIX_ENDIAN(tagType); // to match tags in profile
for (i=0; i<nCount; i++)
{
if (pTagData->tagType == tagType)
{
found = TRUE;
break;
}
pTagData++; // next record
}
if (found)
{
//
// If pBuffer is NULL, copy size of data
//
if (!pBuffer)
{
*pcbSize = FIX_ENDIAN(pTagData->cbSize);
SetLastError(ERROR_INSUFFICIENT_BUFFER);
}
else
{
//
// pBuffer is not NULL, get number of bytes to copy
//
if (dwOffset >= FIX_ENDIAN(pTagData->cbSize))
{
WARNING((__TEXT("dwOffset too large for GetColorProfileElement\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
else if (dwOffset + *pcbSize > FIX_ENDIAN(pTagData->cbSize))
{
nBytes = FIX_ENDIAN(pTagData->cbSize) - dwOffset;
}
else
{
nBytes = *pcbSize;
}
//
// Check if output buffer is large enough
//
if (IsBadWritePtr(pBuffer, nBytes))
{
WARNING((__TEXT("Bad buffer passed to GetColorProfileElement\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
//
// Copy the data into user supplied buffer
//
CopyMemory((PVOID)pBuffer,
(PVOID)(pProfObj->pView + FIX_ENDIAN(pTagData->dwOffset)
+ dwOffset), nBytes);
*pcbSize = nBytes;
rc = TRUE; // Success!
}
//
// Check if multiple tags reference this tag's data
//
*pbReference = IsReferenceTag(pProfObj, pTagData);
}
else
{
SetLastError(ERROR_TAG_NOT_FOUND);
}
return rc;
}
/******************************************************************************
*
* SetColorProfileElementSize
*
* Function:
* This functions sets the data size of a tagged element. If the element
* is already present in the profile it's size is changed, and the data
* is truncated or extended as the case may be. If the element is not
* present, it is created and the data is filled with zeroes.
*
* Arguments:
* hProfile - handle identifing the profile object
* tagType - the tag name of the element
* cbSize - new size for the element data
*
* Returns:
* TRUE if successful, FALSE otherwise
*
* Comments:
* If cbSize is 0, and the element is present, it is deleted.
*
******************************************************************************/
BOOL WINAPI SetColorProfileElementSize(
HPROFILE hProfile,
TAGTYPE tagType,
DWORD cbSize
)
{
PTAGDATA pTagData;
PPROFOBJ pProfObj;
DWORD i, nCount, newSize;
TAGTYPE rawTag;
BOOL found, rc = FALSE;
TRACEAPI((__TEXT("SetColorProfileElementSize\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE))
{
WARNING((__TEXT("Invalid parameter to SetColorProfileElementSize\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to SetColorProfileElementSize\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if profile has write access
//
if (!(pProfObj->dwFlags & READWRITE_ACCESS))
{
WARNING((__TEXT("Writing to a profile without read/write access\n")));
SetLastError(ERROR_ACCESS_DENIED);
return FALSE;
}
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
//
// Tag data records follow the count.
//
pTagData = TAG_DATA(pProfObj);
//
// Check if any of these records match the tag passed in.
//
found = FALSE;
rawTag = FIX_ENDIAN(tagType);
for (i=0; i<nCount; i++)
{
if (pTagData->tagType == rawTag)
{
found = TRUE;
break;
}
pTagData++; // Next record
}
if (found)
{
//
// If it is a reference tag, create data area for it
//
if (IsReferenceTag(pProfObj, pTagData))
{
if (cbSize == 0)
{
PTAGDATA pTemp;
//
// Move everything after the tag table entry up
// by size of one tag table entry.
//
MoveProfileData(pProfObj, (PBYTE)(pTagData+1), (PBYTE)pTagData,
PROFILE_SIZE(pProfObj) - (LONG)((PBYTE)(pTagData+1) - VIEW(pProfObj)), TRUE);
//
// Go through the tag table and update the pointers
//
pTemp = TAG_DATA(pProfObj);
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount) - 1;
TAG_COUNT(pProfObj) = FIX_ENDIAN(nCount);
for (i=0; i<nCount; i++)
{
DWORD dwTemp = FIX_ENDIAN(pTemp->dwOffset);
dwTemp -= sizeof(TAGDATA);
pTemp->dwOffset = FIX_ENDIAN(dwTemp);
pTemp++; // Next record
}
//
// Use nCount as a placeholder to calculate file size
//
nCount = FIX_ENDIAN(HEADER(pProfObj)->phSize) - sizeof(TAGDATA);
HEADER(pProfObj)->phSize = FIX_ENDIAN(nCount);
}
else
{
DWORD dwOffset;
//
// Resize the profile if needed. For memory buffers, we have to realloc,
// and for mapped objects, we have to close and reopen the view.
//
newSize = FIX_ENDIAN(HEADER(pProfObj)->phSize);
newSize = DWORD_ALIGN(newSize) + cbSize;
//
// Check for overflow
//
if (newSize < FIX_ENDIAN(HEADER(pProfObj)->phSize) ||
newSize < cbSize)
{
WARNING((__TEXT("Overflow in setting reference element size\n")));
SetLastError(ERROR_ARITHMETIC_OVERFLOW);
return FALSE;
}
if (newSize > pProfObj->dwMapSize)
{
//Sundown: dwOffset should not be over 4gb
DWORD dwOffset = (ULONG)(ULONG_PTR)(pTagData - TAG_DATA(pProfObj));
if (! GrowProfile(pProfObj, newSize))
{
return FALSE;
}
//
// Recalculate pointers as mapping or memory pointer
// could have changed when growing profile
//
pTagData = TAG_DATA(pProfObj) + dwOffset;
}
//
// Calculate location of new data - should be DWORD aligned
//
dwOffset = DWORD_ALIGN(FIX_ENDIAN(HEADER(pProfObj)->phSize));
pTagData->dwOffset = FIX_ENDIAN(dwOffset);
//
// Set final file size
//
HEADER(pProfObj)->phSize = FIX_ENDIAN(dwOffset+cbSize);
}
rc = TRUE;
}
else
{
if (cbSize == 0)
{
rc = DeleteTaggedElement(pProfObj, pTagData);
}
else
{
DWORD cbOldSize;
//
// Get current size of element
//
cbOldSize = FIX_ENDIAN(pTagData->cbSize);
//
// Compress or expand the file as the case may be.
//
if (cbSize > cbOldSize)
{
//Sundown: dwOffset should be safe to truncate
DWORD dwOffset = (ULONG)(ULONG_PTR)(pTagData - TAG_DATA(pProfObj));
//
// Check for overflow
//
newSize = PROFILE_SIZE(pProfObj) + DWORD_ALIGN(cbSize) -
DWORD_ALIGN(cbOldSize);
if (newSize < PROFILE_SIZE(pProfObj))
{
WARNING((__TEXT("Overflow in increasing element size\n")));
SetLastError(ERROR_ARITHMETIC_OVERFLOW);
return FALSE;
}
if (!GrowProfile(pProfObj, newSize))
{
return FALSE;
}
//
// Recompute pointers
//
pTagData = TAG_DATA(pProfObj) + dwOffset;
}
rc = ChangeTaggedElementSize(pProfObj, pTagData, cbSize);
}
}
}
else
{
if (cbSize == 0)
{
WARNING((__TEXT("SetColorProfileElementSize (deleting): Tag not found\n")));
SetLastError(ERROR_TAG_NOT_FOUND);
}
else
{
rc = AddTaggedElement(pProfObj, tagType, cbSize);
}
}
return rc;
}
/******************************************************************************
*
* SetColorProfileElement
*
* Function:
* This functions sets the data for a tagged element. It does not
* change the size of the element, and only writes as much data as
* would fit within the current size, overwriting any existing data.
*
* Arguments:
* hProfile - handle identifing the profile object
* tagType - the tag name of the element
* dwOffset - offset within the element data from which to write
* pcbSize - number of bytes to write. On return it is the number of
* bytes written.
* pBuffer - pointer to buffer having data to write
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI SetColorProfileElement(
HPROFILE hProfile,
TAGTYPE tagType,
DWORD dwOffset,
PDWORD pcbSize,
PVOID pBuffer
)
{
PPROFOBJ pProfObj;
PTAGDATA pTagData;
DWORD nCount, nBytes, i;
BOOL found;
BOOL rc = FALSE; // Assume failure
TRACEAPI((__TEXT("SetColorProfileElement\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!pcbSize ||
IsBadWritePtr(pcbSize, sizeof(DWORD)) ||
!pBuffer ||
IsBadReadPtr(pBuffer, *pcbSize)
)
{
WARNING((__TEXT("Invalid parameter to SetColorProfileElement\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to SetColorProfileElement\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if profile has write access
//
if (!(pProfObj->dwFlags & READWRITE_ACCESS))
{
WARNING((__TEXT("Writing to a profile without read/write access\n")));
SetLastError(ERROR_ACCESS_DENIED);
return FALSE;
}
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
//
// Tag data records follow the count.
//
pTagData = TAG_DATA(pProfObj);
//
// Check if any of these records match the tag passed in
//
found = FALSE;
tagType = FIX_ENDIAN(tagType);
for (i=0; i<nCount; i++)
{
if (pTagData->tagType == tagType)
{
found = TRUE;
break;
}
pTagData++; // Next record
}
if (found)
{
//
// If it is a reference tag, create new space for it
//
if (IsReferenceTag(pProfObj, pTagData))
{
SetColorProfileElementSize(hProfile, tagType, FIX_ENDIAN(pTagData->cbSize));
}
//
// Get number of bytes to set
//
if (dwOffset >= FIX_ENDIAN(pTagData->cbSize))
{
WARNING((__TEXT("dwOffset too large for SetColorProfileElement\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
else if (dwOffset + *pcbSize > FIX_ENDIAN(pTagData->cbSize))
{
nBytes = FIX_ENDIAN(pTagData->cbSize) - dwOffset;
}
else
{
nBytes = *pcbSize;
}
//
// Copy the data into the profile
//
CopyMemory((PVOID)(pProfObj->pView + FIX_ENDIAN(pTagData->dwOffset)
+ dwOffset), (PVOID)pBuffer, nBytes);
*pcbSize = nBytes;
rc = TRUE;
}
else
{
WARNING((__TEXT("SetColorProfileElement: Tag not found\n")));
SetLastError(ERROR_TAG_NOT_FOUND);
}
return rc;
}
/******************************************************************************
*
* SetColorProfileElementReference
*
* Function:
* This functions creates a new tag and makes it refer to the same
* data as an existing tag.
*
* Arguments:
* hProfile - handle identifing the profile object
* newTag - new tag to create
* refTag - reference tag whose data newTag should refer to
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI SetColorProfileElementReference(
HPROFILE hProfile,
TAGTYPE newTag,
TAGTYPE refTag
)
{
PPROFOBJ pProfObj;
PTAGDATA pTagData, pOrigTag;
DWORD nCount, i;
BOOL found;
BOOL rc = FALSE; // Assume failure
TRACEAPI((__TEXT("SetColorProfileElementReference\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE))
{
WARNING((__TEXT("Invalid parameter to SetColorProfileElementReference\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to SetColorProfileElementReference\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if profile has write access
//
if (!(pProfObj->dwFlags & READWRITE_ACCESS))
{
WARNING((__TEXT("Writing to a profile without read/write access\n")));
SetLastError(ERROR_ACCESS_DENIED);
return FALSE;
}
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
//
// Tag data records follow the count.
//
pTagData = TAG_DATA(pProfObj);
//
// Check if any of these records match the tag passed in
//
found = FALSE;
refTag = FIX_ENDIAN(refTag);
for (i=0; i<nCount; i++)
{
if (pTagData->tagType == refTag)
{
pOrigTag = pTagData;
found = TRUE;
}
if (pTagData->tagType == FIX_ENDIAN(newTag))
{
WARNING((__TEXT("Duplicate tag present in SetColorProfileElementReference %x\n"), newTag));
SetLastError(ERROR_DUPLICATE_TAG);
return FALSE;
}
pTagData++; // Next record
}
if (found)
{
DWORD newSize;
//
// Grow profile if needed
//
newSize = FIX_ENDIAN(HEADER(pProfObj)->phSize);
newSize = DWORD_ALIGN(newSize) + sizeof(TAGDATA);
//
// Check for overflow
//
if (newSize < FIX_ENDIAN(HEADER(pProfObj)->phSize))
{
WARNING((__TEXT("Overflow in adding element\n")));
SetLastError(ERROR_ARITHMETIC_OVERFLOW);
return FALSE;
}
if (newSize > pProfObj->dwMapSize)
{
//Sundown: safe truncation
DWORD dwOffset = (ULONG)(ULONG_PTR)(pOrigTag - TAG_DATA(pProfObj));
if (! GrowProfile(pProfObj, newSize))
{
return FALSE;
}
//
// Recalculate pointers as mapping or memory pointer
// could have changed when growing profile
//
pOrigTag = TAG_DATA(pProfObj) + dwOffset;
}
rc = AddTagTableEntry(pProfObj, newTag, FIX_ENDIAN(pOrigTag->dwOffset),
FIX_ENDIAN(pOrigTag->cbSize), FALSE);
}
else
{
WARNING((__TEXT("SetColorProfileElementReference: Tag 0x%x not found\n"),
FIX_ENDIAN(refTag))); // Re-fix it to reflect data passed in
SetLastError(ERROR_TAG_NOT_FOUND);
}
return rc;
}
/******************************************************************************
*
* GetColorProfileHeader
*
* Function:
* This functions retrieves the header of a profile
*
* Arguments:
* hProfile - handle identifing the profile object
* pHeader - pointer to buffer to recieve the header
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI GetColorProfileHeader(
HPROFILE hProfile,
PPROFILEHEADER pHeader
)
{
PPROFOBJ pProfObj;
DWORD nCount, i, temp;
TRACEAPI((__TEXT("GetColorProfileHeader\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
IsBadWritePtr(pHeader, sizeof(PROFILEHEADER)))
{
WARNING((__TEXT("Invalid parameter to GetColorProfileHeader\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile.
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetColorProfileHeader\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
CopyMemory((PVOID)pHeader, (PVOID)pProfObj->pView,
sizeof(PROFILEHEADER));
//
// Fix up all fields to platform specific values.
// The following code assumes that the profile header is a
// multiple of DWORDs which it is!
//
ASSERT(sizeof(PROFILEHEADER) % sizeof(DWORD) == 0);
nCount = sizeof(PROFILEHEADER)/sizeof(DWORD);
for (i=0; i<nCount;i++)
{
temp = (DWORD)((PDWORD)pHeader)[i];
((PDWORD)pHeader)[i] = FIX_ENDIAN(temp);
}
return TRUE;
}
/******************************************************************************
*
* SetColorProfileHeader
*
* Function:
* This functions sets the header of a profile
*
* Arguments:
* hProfile - handle identifing the profile object
* pHeader - pointer to buffer identifing the header
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI SetColorProfileHeader(
HPROFILE hProfile,
PPROFILEHEADER pHeader
)
{
PPROFOBJ pProfObj;
DWORD nCount, i, temp;
TRACEAPI((__TEXT("SetColorProfileHeader\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
IsBadReadPtr(pHeader, sizeof(PROFILEHEADER)))
{
WARNING((__TEXT("Invalid parameter to SetColorProfileHeader\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check if profile has write access
//
if (!(pProfObj->dwFlags & READWRITE_ACCESS))
{
WARNING((__TEXT("Writing to a profile without read/write access\n")));
SetLastError(ERROR_ACCESS_DENIED);
return FALSE;
}
//
// Fix up all fields to BIG-ENDIAN.
// The following code assumes that the profile header is a
// multiple of DWORDs which it is!
//
ASSERT(sizeof(PROFILEHEADER) % sizeof(DWORD) == 0);
nCount = sizeof(PROFILEHEADER)/sizeof(DWORD);
for (i=0; i<nCount;i++)
{
temp = (DWORD)((PDWORD)pHeader)[i];
((PDWORD)pHeader)[i] = FIX_ENDIAN(temp);
}
CopyMemory((PVOID)pProfObj->pView, (PVOID)pHeader,
sizeof(PROFILEHEADER));
//
// Put back app supplied buffer the way it came in
//
for (i=0; i<nCount;i++)
{
temp = (DWORD)((PDWORD)pHeader)[i];
((PDWORD)pHeader)[i] = FIX_ENDIAN(temp);
}
return TRUE;
}
/******************************************************************************
*
* GetPS2ColorSpaceArray
*
* Function:
* This functions retrieves the PostScript Level 2 CSA from the profile
*
* Arguments:
* hProfile - handle identifing the profile object
* dwIntent - rendering intent of CSA
* dwCSAType - type of CSA
* pbuffer - pointer to receive the CSA
* pcbSize - pointer to size of buffer. If function fails because
* buffer is not big enough, it is filled with required size.
* pcbBinary - TRUE if binary data is requested. On return it is set to
* reflect the data returned
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI
GetPS2ColorSpaceArray (
HPROFILE hProfile,
DWORD dwIntent,
DWORD dwCSAType,
PBYTE pBuffer,
PDWORD pcbSize,
LPBOOL pbBinary
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID;
BOOL rc;
TRACEAPI((__TEXT("GetPS2ColorSpaceArray\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
IsBadWritePtr(pcbSize, sizeof(DWORD)) ||
(pBuffer &&
IsBadWritePtr(pBuffer, *pcbSize)
) ||
IsBadWritePtr(pbBinary, sizeof(BOOL))
)
{
WARNING((__TEXT("Invalid parameter to GetPS2ColorSpaceArray\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetPS2ColorSpaceArray\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if application specified CMM is present
//
pCMMObj = GetPreferredCMM();
if (!pCMMObj || (pCMMObj->dwFlags & CMM_DONT_USE_PS2_FNS) ||
!pCMMObj->fns.pCMGetPS2ColorSpaceArray)
{
if (pCMMObj)
{
pCMMObj->dwFlags |= CMM_DONT_USE_PS2_FNS;
ReleaseColorMatchingModule(pCMMObj);
}
//
// Get CMM associated with profile. If it does not exist or does not
// support the CMGetPS2ColorSpaceArray function, get default CMM.
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj || (pCMMObj->dwFlags & CMM_DONT_USE_PS2_FNS) ||
!pCMMObj->fns.pCMGetPS2ColorSpaceArray)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
pCMMObj->dwFlags |= CMM_DONT_USE_PS2_FNS;
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj || !pCMMObj->fns.pCMGetPS2ColorSpaceArray)
{
WARNING((__TEXT("Default CMM doesn't support CMGetPS2ColorSpaceArray\n")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
pCMMObj = NULL;
}
}
}
}
ASSERT(pProfObj->pView != NULL);
if (pCMMObj)
{
rc = pCMMObj->fns.pCMGetPS2ColorSpaceArray(hProfile, dwIntent, dwCSAType,
pBuffer, pcbSize, pbBinary);
}
else
{
rc = InternalGetPS2ColorSpaceArray(pProfObj->pView, dwIntent,
dwCSAType, pBuffer, pcbSize, pbBinary);
}
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
VERBOSE((__TEXT("GetPS2ColorSpaceArray returning %s\n"),
rc ? "TRUE" : "FALSE"));
return rc;
}
/******************************************************************************
*
* GetPS2ColorRenderingIntent
*
* Function:
* This functions retrieves the PostScript Level 2 color rendering intent
* from the profile
*
* Arguments:
* hProfile - handle identifing the profile object
* pbuffer - pointer to receive the color rendering intent
* pcbSize - pointer to size of buffer. If function fails because
* buffer is not big enough, it is filled with required size.
* pcbBinary - TRUE if binary data is requested. On return it is set to
* reflect the data returned
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI GetPS2ColorRenderingIntent(
HPROFILE hProfile,
DWORD dwIntent,
PBYTE pBuffer,
PDWORD pcbSize
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID;
BOOL rc;
TRACEAPI((__TEXT("GetPS2ColorRenderingIntent\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
IsBadWritePtr(pcbSize, sizeof(DWORD)) ||
(pBuffer &&
IsBadWritePtr(pBuffer, *pcbSize)
)
)
{
WARNING((__TEXT("Invalid parameter to GetPS2ColorRenderingIntent\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetPS2ColorRenderingIntent\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if application specified CMM is present
//
pCMMObj = GetPreferredCMM();
if (!pCMMObj || (pCMMObj->dwFlags & CMM_DONT_USE_PS2_FNS) ||
!pCMMObj->fns.pCMGetPS2ColorRenderingIntent)
{
if (pCMMObj)
{
pCMMObj->dwFlags |= CMM_DONT_USE_PS2_FNS;
ReleaseColorMatchingModule(pCMMObj);
}
//
// Get CMM associated with profile. If it does not exist or does not
// support the CMGetPS2ColorSpaceArray function, get default CMM.
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj || (pCMMObj->dwFlags & CMM_DONT_USE_PS2_FNS) ||
!pCMMObj->fns.pCMGetPS2ColorRenderingIntent)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
pCMMObj->dwFlags |= CMM_DONT_USE_PS2_FNS;
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj || !pCMMObj->fns.pCMGetPS2ColorRenderingIntent)
{
WARNING((__TEXT("Default CMM doesn't support CMGetPS2ColorRenderingIntent\n")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
pCMMObj = NULL;
}
}
}
}
ASSERT(pProfObj->pView != NULL);
if (pCMMObj)
{
rc = pCMMObj->fns.pCMGetPS2ColorRenderingIntent(hProfile,
dwIntent, pBuffer, pcbSize);
}
else
{
rc = InternalGetPS2ColorRenderingIntent(pProfObj->pView, dwIntent,
pBuffer, pcbSize);
}
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
VERBOSE((__TEXT("GetPS2ColorRenderingIntent returning %s\n"),
rc ? "TRUE" : "FALSE"));
return rc;
}
/******************************************************************************
*
* GetPS2ColorRenderingDictionary
*
* Function:
* This functions retrieves the PostScript Level 2 CRD from the profile
*
* Arguments:
* hProfile - handle identifing the profile object
* dwIntent - intent whose CRD is required
* pbuffer - pointer to receive the CSA
* pcbSize - pointer to size of buffer. If function fails because
* buffer is not big enough, it is filled with required size.
* pcbBinary - TRUE if binary data is requested. On return it is set to
* reflect the data returned
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI GetPS2ColorRenderingDictionary(
HPROFILE hProfile,
DWORD dwIntent,
PBYTE pBuffer,
PDWORD pcbSize,
PBOOL pbBinary
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID;
BOOL rc;
TRACEAPI((__TEXT("GetPS2ColorRenderingDictionary\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
IsBadWritePtr(pcbSize, sizeof(DWORD)) ||
(pBuffer &&
IsBadWritePtr(pBuffer, *pcbSize)
) ||
IsBadWritePtr(pbBinary, sizeof(BOOL))
)
{
WARNING((__TEXT("Invalid parameter to GetPS2ColorRenderingDictionary\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetPS2ColorRenderingDictionary\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if application specified CMM is present
//
pCMMObj = GetPreferredCMM();
if (!pCMMObj || (pCMMObj->dwFlags & CMM_DONT_USE_PS2_FNS) ||
!pCMMObj->fns.pCMGetPS2ColorRenderingDictionary)
{
if (pCMMObj)
{
pCMMObj->dwFlags |= CMM_DONT_USE_PS2_FNS;
ReleaseColorMatchingModule(pCMMObj);
}
//
// Get CMM associated with profile. If it does not exist or does not
// support the CMGetPS2ColorSpaceArray function, get default CMM.
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj || (pCMMObj->dwFlags & CMM_DONT_USE_PS2_FNS) ||
!pCMMObj->fns.pCMGetPS2ColorRenderingDictionary)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
pCMMObj->dwFlags |= CMM_DONT_USE_PS2_FNS;
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj || !pCMMObj->fns.pCMGetPS2ColorRenderingDictionary)
{
WARNING((__TEXT("Default CMM doesn't support CMGetPS2ColorRenderingDictionary\n")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
pCMMObj = NULL;
}
}
}
}
ASSERT(pProfObj->pView != NULL);
if (pCMMObj)
{
rc = pCMMObj->fns.pCMGetPS2ColorRenderingDictionary(hProfile, dwIntent,
pBuffer, pcbSize, pbBinary);
}
else
{
rc = InternalGetPS2ColorRenderingDictionary(pProfObj->pView, dwIntent,
pBuffer, pcbSize, pbBinary);
}
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
VERBOSE((__TEXT("GetPS2ColorRenderingDictionary returning %s\n"),
rc ? "TRUE" : "FALSE"));
return rc;
}
/******************************************************************************
*
* GetNamedProfileInfo
*
* Function:
* This functions returns information about the given named color space
* profile. If fails if the given profile is not a named color space profile.
*
* Arguments:
* hProfile - handle identifying the named color space profile object
* pNamedProfileInfo - pointer to NAMED_PROFILE_INFO structure that is
* filled on retun if successful.
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI GetNamedProfileInfo(
HPROFILE hProfile,
PNAMED_PROFILE_INFO pNamedProfileInfo
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID;
BOOL rc;
TRACEAPI((__TEXT("GetNamedProfileInfo\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!pNamedProfileInfo ||
IsBadWritePtr(pNamedProfileInfo, sizeof(NAMED_PROFILE_INFO)))
{
WARNING((__TEXT("Invalid parameter to GetNamedProfileInfo\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to GetNamedProfileInfo\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if application specified CMM is present
//
pCMMObj = GetPreferredCMM();
if (!pCMMObj ||
!pCMMObj->fns.pCMGetNamedProfileInfo)
{
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
//
// Get CMM associated with profile. If it does not exist or does not
// support the CMGetNamedProfileInfo function, get default CMM.
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj ||
!pCMMObj->fns.pCMGetNamedProfileInfo)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj || !pCMMObj->fns.pCMGetNamedProfileInfo)
{
RIP((__TEXT("Default CMM doesn't support CMValidateProfile")));
SetLastError(ERROR_INVALID_CMM);
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
return FALSE;
}
}
}
ASSERT(pProfObj->pView != NULL);
rc = pCMMObj->fns.pCMGetNamedProfileInfo(hProfile, pNamedProfileInfo);
ReleaseColorMatchingModule(pCMMObj);
return rc;
}
/******************************************************************************
*
* ConvertColorNameToIndex
*
* Function:
* This functions converts a given array of color names to color indices
* using the specified named color space profile
*
* Arguments:
* hProfile - handle identifing the named color space profile object
* paColorName - pointer to array of COLOR_NAME structures
* paIndex - pointer to array of DWORDs to receive the indices
* dwCount - number of color names to convert
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI ConvertColorNameToIndex(
HPROFILE hProfile,
PCOLOR_NAME paColorName,
PDWORD paIndex,
DWORD dwCount
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID;
BOOL rc;
TRACEAPI((__TEXT("ConvertColorNameToIndex\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!paColorName ||
dwCount == 0 ||
IsBadReadPtr(paColorName, dwCount*sizeof(COLOR_NAME)) ||
!paIndex ||
IsBadWritePtr(paIndex, dwCount*sizeof(DWORD)))
{
WARNING((__TEXT("Invalid parameter to ConvertColorNameToIndex\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to ConvertColorNameToIndex\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if application specified CMM is present
//
pCMMObj = GetPreferredCMM();
if (!pCMMObj ||
!pCMMObj->fns.pCMConvertColorNameToIndex)
{
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
//
// Get CMM associated with profile. If it does not exist or does not
// support the CMConvertColorNameToIndex function, get default CMM.
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj ||
!pCMMObj->fns.pCMConvertColorNameToIndex)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj || !pCMMObj->fns.pCMConvertColorNameToIndex)
{
RIP((__TEXT("Default CMM doesn't support CMConvertColorNameToIndex")));
SetLastError(ERROR_INVALID_CMM);
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
return FALSE;
}
}
}
ASSERT(pProfObj->pView != NULL);
rc = pCMMObj->fns.pCMConvertColorNameToIndex(
hProfile,
paColorName,
paIndex,
dwCount);
ReleaseColorMatchingModule(pCMMObj);
return rc;
}
/******************************************************************************
*
* ConvertIndexToColorName
*
* Function:
* This functions converts a given array of color indices to color names
* using the specified named color space profile
*
* Arguments:
* hProfile - handle identifing the named color space profile object
* paIndex - pointer to array of color indices
* paColorName - pointer to array of COLOR_NAME structures
* dwCount - number of color indices to convert
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI ConvertIndexToColorName(
HPROFILE hProfile,
PDWORD paIndex,
PCOLOR_NAME paColorName,
DWORD dwCount
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID;
BOOL rc;
TRACEAPI((__TEXT("ConvertIndexToColorName\n")));
//
// Validate parameters
//
if (!ValidHandle(hProfile, OBJ_PROFILE) ||
!paIndex ||
dwCount == 0 ||
IsBadWritePtr(paIndex, dwCount*sizeof(DWORD)) ||
!paColorName ||
IsBadReadPtr(paColorName, dwCount*sizeof(COLOR_NAME)))
{
WARNING((__TEXT("Invalid parameter to ConvertIndexToColorName\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Check the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to ConvertIndexToColorName\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
//
// Check if application specified CMM is present
//
pCMMObj = GetPreferredCMM();
if (!pCMMObj ||
!pCMMObj->fns.pCMConvertIndexToColorName)
{
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
//
// Get CMM associated with profile. If it does not exist or does not
// support the CMConvertIndexToColorName function, get default CMM.
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj ||
!pCMMObj->fns.pCMConvertIndexToColorName)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj || !pCMMObj->fns.pCMConvertIndexToColorName)
{
RIP((__TEXT("Default CMM doesn't support CMConvertIndexToColorName")));
SetLastError(ERROR_INVALID_CMM);
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
return FALSE;
}
}
}
ASSERT(pProfObj->pView != NULL);
rc = pCMMObj->fns.pCMConvertIndexToColorName(
hProfile,
paIndex,
paColorName,
dwCount);
ReleaseColorMatchingModule(pCMMObj);
return rc;
}
/******************************************************************************
*
* CreateDeviceLinkProfile
*
* Function:
* This functions creates a device link profile from the given set
* of profiles, using specified intents.
*
* Arguments:
* pahProfiles - pointer to array of handles of profiles
* nProfiles - number of profiles in array
* padwIntent - array of intents to use
* nIntents - size of array - can be 1 or nProfiles
* dwFlags - optimization flags
* pProfileData - pointer to pointer to buffer to receive data which
* this function allocates; caller needs to free.
* indexPreferredCMM - zero based index of profile which specifies
* preferred CMM to use.
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL WINAPI CreateDeviceLinkProfile(
PHPROFILE pahProfiles,
DWORD nProfiles,
PDWORD padwIntent,
DWORD nIntents,
DWORD dwFlags,
PBYTE *pProfileData,
DWORD indexPreferredCMM
)
{
PPROFOBJ pProfObj;
PCMMOBJ pCMMObj;
DWORD cmmID, i;
BOOL rc;
TRACEAPI((__TEXT("CreateDeviceLinkProfile\n")));
//
// Validate parameters
//
if (nProfiles <= 1 ||
indexPreferredCMM >= nProfiles ||
pahProfiles == NULL ||
IsBadReadPtr(pahProfiles, sizeof(HPROFILE) * nProfiles) ||
padwIntent == NULL ||
((nIntents != nProfiles) && (nIntents != 1)) ||
IsBadReadPtr(padwIntent, nIntents * sizeof(DWORD)))
{
WARNING((__TEXT("Invalid parameter to CreateDeviceLinkProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
for (i=0; i<nProfiles; i++)
{
if ((pahProfiles[i] == NULL) ||
! ValidHandle(pahProfiles[i], OBJ_PROFILE))
{
WARNING((__TEXT("Invalid profile passed to CreateDeviceLinkProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
pProfObj = (PPROFOBJ)HDLTOPTR(pahProfiles[i]);
ASSERT(pProfObj != NULL);
ASSERT(pProfObj->pView != NULL);
//
// Quick check on the integrity of the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to CreateDeviceLinkProfile\n")));
SetLastError(ERROR_INVALID_PROFILE);
return FALSE;
}
if (i == indexPreferredCMM)
{
//
// Get ID of preferred CMM
//
cmmID = HEADER(pProfObj)->phCMMType;
cmmID = FIX_ENDIAN(cmmID);
}
}
//
// Get CMM associated with preferred profile. If it does not exist,
// get default CMM.
//
pCMMObj = GetColorMatchingModule(cmmID);
if (!pCMMObj || !pCMMObj->fns.pCMCreateDeviceLinkProfile)
{
TERSE((__TEXT("CMM associated with profile could not be used")));
if (pCMMObj)
{
ReleaseColorMatchingModule(pCMMObj);
}
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj)
{
RIP((__TEXT("Default CMM not found\n")));
SetLastError(ERROR_INVALID_CMM);
return FALSE;
}
}
ASSERT(pCMMObj->fns.pCMCreateDeviceLinkProfile != NULL);
rc = pCMMObj->fns.pCMCreateDeviceLinkProfile(
pahProfiles,
nProfiles,
padwIntent,
nIntents,
dwFlags,
pProfileData);
ReleaseColorMatchingModule(pCMMObj);
return rc;
}
/*****************************************************************************/
/***************************** Internal Functions ****************************/
/*****************************************************************************/
/******************************************************************************
*
* InternalOpenColorProfile
*
* Function:
* This functions opens a color profile specified by the pProfile
* parameter, creates an internal profile object, and returns a handle
* to it.
*
* Arguments:
* pProfile - ptr to a profile structure that specifies the profile
* to open
* dwDesiredAccess - specifies the mode in which to open the profile.
* Any combination of these values can be used:
* PROFILE_READ: Allows the app to read the profile.
* PROFILE_READWRITE: Allows the app to read and write to the profile.
* dwShareMode - specifies the mode to share the profile with other
* processes if it is a file. Any combination of these
* values can be used.
* 0 : Prevents the file from being shared.
* FILE_SHARE_READ: Allows opening for read only by other processes.
* FILE_SHARE_WRITE: Allows opening for write by other processes.
* dwCreationMode - specifies which actions to take on the profile while
* opening it (if it is a file). Any one of the following
* values can be used.
* CREATE_NEW: Creates a new file. Fails if one exists already.
* CREATE_ALWAYS: Always create a new file. Overwriting existing.
* OPEN_EXISTING: Open exisiting file. Fail if not found.
* OPEN_ALWAYS: Open existing. If not found, create a new one.
* TRUNCATE_EXISTING: Open existing and truncate to zero bytes. Fail
* if not found.
*
* Returns:
* Handle to open profile on success, zero on failure.
*
******************************************************************************/
HPROFILE InternalOpenColorProfile(
PPROFILE pProfile,
DWORD dwDesiredAccess,
DWORD dwShareMode,
DWORD dwCreationMode
)
{
SECURITY_ATTRIBUTES sa;
PPROFOBJ pProfObj;
HPROFILE hProfile;
DWORD dwMapSize;
BOOL bNewFile = FALSE;
BOOL bError = TRUE; // Assume failure
TRACEAPI((__TEXT("OpenColorProfile\n")));
//
// Validate parameters
//
if (!pProfile ||
IsBadReadPtr(pProfile, sizeof(PROFILE)) ||
(pProfile->pProfileData &&
IsBadReadPtr(pProfile->pProfileData, pProfile->cbDataSize)) ||
(!pProfile->pProfileData &&
(pProfile->cbDataSize != 0)) ||
(pProfile->dwType != PROFILE_FILENAME &&
pProfile->dwType != PROFILE_MEMBUFFER
) ||
(dwDesiredAccess != PROFILE_READ &&
dwDesiredAccess != PROFILE_READWRITE
)
)
{
WARNING((__TEXT("Invalid parameter to OpenColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
//
// Allocate an object on the heap for the profile
//
hProfile = AllocateHeapObject(OBJ_PROFILE);
if (!hProfile)
{
WARNING((__TEXT("Could not allocate profile object\n")));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
//
// Copy profile information to our object
//
pProfObj->objHdr.dwUseCount = 1;
pProfObj->dwType = pProfile->dwType;
pProfObj->cbDataSize = pProfile->cbDataSize;
pProfObj->pProfileData = (PBYTE)MemAlloc(pProfile->cbDataSize + sizeof(TCHAR));
if (!pProfObj->pProfileData)
{
WARNING((__TEXT("Could not allocate memory for profile data\n")));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto EndOpenColorProfile;
}
CopyMemory((PVOID)pProfObj->pProfileData,
(PVOID)pProfile->pProfileData,
pProfile->cbDataSize);
if (pProfObj->dwType == PROFILE_FILENAME)
{
LPTSTR lpFilename;
if (!pProfile->pProfileData ||
pProfile->cbDataSize == 0 ||
lstrlen((LPCTSTR)pProfile->pProfileData) > MAX_PATH ||
pProfile->cbDataSize > (MAX_PATH * sizeof(TCHAR)))
{
WARNING((__TEXT("Invalid parameter to OpenColorProfile\n")));
SetLastError(ERROR_INVALID_PARAMETER);
goto EndOpenColorProfile;
}
//
// If only filename is given, it is wrt color directory
//
lpFilename = GetFilenameFromPath((LPTSTR)pProfObj->pProfileData);
if (lpFilename == pProfObj->pProfileData)
{
DWORD dwLen = MAX_PATH;
lpFilename = MemAlloc(dwLen);
if (!lpFilename)
{
WARNING((__TEXT("Could not allocate memory for file name\n")));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto EndOpenColorProfile;
}
(VOID)GetColorDirectory(NULL, lpFilename, &dwLen);
lstrcat(lpFilename, gszBackslash);
lstrcat(lpFilename, (LPTSTR)pProfObj->pProfileData);
MemFree(pProfObj->pProfileData);
pProfObj->pProfileData = (PVOID)lpFilename;
pProfObj->cbDataSize = MAX_PATH;
}
//
// File name already null terminates as we used GHND flag which
// zero initializes the allocated memory
//
// Create file mapping
//
pProfObj->dwFlags |= MEMORY_MAPPED;
if (dwCreationMode == OPEN_ALWAYS)
{
//
// If we find a zero length profile, we should error out
// saying it is a bad profile. If we create a zero length
// profile, it is fine. To distinguish these two cases, we
// check for file's existence and if present, change the
// creation mode to OPEN_EXISTING
//
if (GetFileAttributes(pProfObj->pProfileData) != (DWORD)-1)
{
dwCreationMode = OPEN_EXISTING;
}
}
//
// Set security attribute structure
//
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL; // default security
sa.bInheritHandle = FALSE;
pProfObj->hFile = CreateFile(pProfObj->pProfileData,
(dwDesiredAccess == PROFILE_READWRITE) ? GENERIC_READ | GENERIC_WRITE : GENERIC_READ,
dwShareMode, &sa, dwCreationMode, FILE_FLAG_RANDOM_ACCESS, 0);
if (pProfObj->hFile == INVALID_HANDLE_VALUE)
{
WARNING((__TEXT("Err %ld, could not open profile %s\n"),
GetLastError(), pProfObj->pProfileData));
goto EndOpenColorProfile;
}
//
// Get size of file mapping. Add a cushion so that profile can
// be grown. When closing the profile, the file size is truncated
// to the size of the actual data. If the profile size grows beyond
// the cushion, it is continually grown in chunks.
//
dwMapSize = GetFileSize(pProfObj->hFile, NULL);
if (dwMapSize == 0)
{
if (dwCreationMode == OPEN_EXISTING)
{
WARNING((__TEXT("Invalid profile - zero length\n")));
SetLastError(ERROR_INVALID_PROFILE);
goto EndOpenColorProfile;
}
else
{
dwMapSize = PROFILE_GROWTHCUSHION;
bNewFile = TRUE;
}
}
pProfObj->hMap = CreateFileMapping(pProfObj->hFile, 0,
(dwDesiredAccess == PROFILE_READWRITE) ? PAGE_READWRITE : PAGE_READONLY,
0, dwMapSize, 0);
if (!pProfObj->hMap)
{
WARNING((__TEXT("Err %ld, could not create map of profile %s\n"),
GetLastError(), pProfObj->pProfileData));
goto EndOpenColorProfile;
}
pProfObj->dwMapSize = dwMapSize;
pProfObj->pView = (PBYTE)MapViewOfFile(pProfObj->hMap,
(dwDesiredAccess == PROFILE_READWRITE) ? FILE_MAP_ALL_ACCESS : FILE_MAP_READ,
0, 0, 0);
if (!pProfObj->pView)
{
WARNING((__TEXT("Err %ld, could not create view of profile %s\n"),
GetLastError(), pProfObj->pProfileData));
goto EndOpenColorProfile;
}
//
// If a new profile has been created, initialize size
// and tag table count
//
if (bNewFile && dwDesiredAccess == PROFILE_READWRITE)
{
HEADER(pProfObj)->phSize = FIX_ENDIAN(sizeof(PROFILEHEADER) +
sizeof(DWORD));
HEADER(pProfObj)->phVersion = 0x02000000;
HEADER(pProfObj)->phSignature = PROFILE_SIGNATURE;
TAG_COUNT(pProfObj) = 0;
}
}
else
{
if (pProfile->cbDataSize == 0)
{
//
// Allocate a small buffer and create a new profile in it
//
pProfObj->cbDataSize = PROFILE_GROWTHCUSHION;
MemFree(pProfObj->pProfileData);
pProfObj->pView = pProfObj->pProfileData = MemAlloc(pProfObj->cbDataSize);
if (!pProfObj->pView)
{
WARNING((__TEXT("Could not allocate memory for profile data\n")));
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto EndOpenColorProfile;
}
HEADER(pProfObj)->phSize = FIX_ENDIAN(sizeof(PROFILEHEADER) +
sizeof(DWORD));
HEADER(pProfObj)->phVersion = 0x02000000;
HEADER(pProfObj)->phSignature = PROFILE_SIGNATURE;
TAG_COUNT(pProfObj) = 0;
pProfObj->dwMapSize = pProfObj->cbDataSize;
}
else
{
//
// Treat buffer as view of file
//
pProfObj->pView = pProfObj->pProfileData;
pProfObj->dwMapSize = pProfObj->cbDataSize;
//
// Do a sanity check on the profile
//
if (!ValidProfile(pProfObj))
{
WARNING((__TEXT("Invalid profile passed to OpenColorProfile\n")));
SetLastError(ERROR_INVALID_PROFILE);
goto EndOpenColorProfile;
}
}
}
if (dwDesiredAccess == PROFILE_READWRITE)
pProfObj->dwFlags |= READWRITE_ACCESS;
bError = FALSE; // Success!
EndOpenColorProfile:
if (bError)
{
if (hProfile)
FreeProfileObject(hProfile);
hProfile = NULL;
}
return hProfile;
}
/******************************************************************************
*
* InternalCreateProfileFromLCS
*
* Function:
* This functions takes a logical color space and creates an ICC profile
*
* Arguments:
* pLogColorSpace - Pointer to LogColorSpace structure
* pBuffer - Pointer to pointer to buffer. This function allocates and
* fills this buffer with the profile on success.
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL InternalCreateProfileFromLCS(
LPLOGCOLORSPACE pLogColorSpace,
PBYTE *pBuffer,
BOOL bValidateParams
)
{
PCMMOBJ pCMMObj = NULL;
BOOL rc;
//
// Validate parameters
//
if (bValidateParams &&
(! pLogColorSpace ||
IsBadReadPtr(pLogColorSpace, sizeof(LOGCOLORSPACE)) ||
pLogColorSpace->lcsFilename[0] != '\0'))
{
WARNING((__TEXT("Invalid parameter to CreateProfileFromLogColorSpace\n")));
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
//
// We use the default CMM for this
//
pCMMObj = GetColorMatchingModule(CMM_WINDOWS_DEFAULT);
if (!pCMMObj)
{
RIP((__TEXT("Default CMM not found\n")));
SetLastError(ERROR_INVALID_CMM);
return FALSE;
}
ASSERT(pCMMObj->fns.pCMCreateProfile != NULL);
rc = pCMMObj->fns.pCMCreateProfile(pLogColorSpace, pBuffer);
ReleaseColorMatchingModule(pCMMObj);
return rc;
}
/******************************************************************************
*
* FreeProfileObject
*
* Function:
* This functions frees a profile object and associated memory
*
* Arguments:
* hProfile - handle identifing the profile object to free
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL FreeProfileObject(
HANDLE hProfile
)
{
PPROFOBJ pProfObj;
DWORD dwFileSize = 0;
DWORD dwErr;
ASSERT(hProfile != NULL);
pProfObj = (PPROFOBJ)HDLTOPTR(hProfile);
ASSERT(pProfObj != NULL);
dwErr = GetLastError(); // remember any errors we may have set
//
// Free memory associated with profile data
//
if (pProfObj->pProfileData)
MemFree((PVOID)pProfObj->pProfileData);
//
// If it a memory mapped profile, unmap it
//
if (pProfObj->dwFlags & MEMORY_MAPPED)
{
if (pProfObj->pView)
{
dwFileSize = FIX_ENDIAN(HEADER(pProfObj)->phSize);
UnmapViewOfFile(pProfObj->pView);
}
if (pProfObj->hMap)
CloseHandle(pProfObj->hMap);
if (pProfObj->hFile)
{
//
// Set the size of the file correctly
//
SetFilePointer(pProfObj->hFile, dwFileSize, NULL, FILE_BEGIN);
SetEndOfFile(pProfObj->hFile);
CloseHandle(pProfObj->hFile);
}
}
//
// Free heap object
//
pProfObj->objHdr.dwUseCount--; // decrement before freeing
FreeHeapObject(hProfile);
if (dwErr)
{
SetLastError(dwErr); // reset our error
}
return TRUE;
}
/******************************************************************************
*
* GrowProfile
*
* Function:
* This functions grows a profile to the new size
*
* Arguments:
* pProfObj - pointer to profile object
* dwNewSize - new size for the profile
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL GrowProfile(
PPROFOBJ pProfObj,
DWORD dwNewSize
)
{
if (pProfObj->dwMapSize >= dwNewSize)
return TRUE;
//
// Add cushion for future growth
//
dwNewSize += PROFILE_GROWTHCUSHION;
if (pProfObj->dwFlags & MEMORY_MAPPED)
{
//
// Profile is a memory mapped file
//
//
// Close previous view and map
//
UnmapViewOfFile(pProfObj->pView);
CloseHandle(pProfObj->hMap);
pProfObj->hMap = CreateFileMapping(pProfObj->hFile, 0,
PAGE_READWRITE, 0, dwNewSize, 0);
if (!pProfObj->hMap)
{
WARNING((__TEXT("Err %ld, could not recreate map of profile %s\n"),
GetLastError(), pProfObj->pProfileData));
return FALSE;
}
pProfObj->pView = (PBYTE) MapViewOfFile(pProfObj->hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if (!pProfObj->pView)
{
WARNING((__TEXT("Err %ld, could not recreate view of profile %s\n"),
GetLastError(), pProfObj->pProfileData));
return FALSE;
}
//
// Set new size
//
pProfObj->dwMapSize = dwNewSize;
}
else
{
//
// Profile is an in-memory buffer
//
PVOID pTemp = MemReAlloc(pProfObj->pView, dwNewSize);
if (!pTemp)
{
WARNING((__TEXT("Error reallocating memory\n")));
return FALSE;
}
pProfObj->pView = pProfObj->pProfileData = pTemp;
pProfObj->cbDataSize = pProfObj->dwMapSize = dwNewSize;
}
return TRUE;
}
/******************************************************************************
*
* AddTagTableEntry
*
* Function:
* This functions adds a tag to the tag table
*
* Arguments:
* pProfObj - pointer to profile object
* tagType - tag to add
* dwOffset - offset of tag data from start of file
* cbSize - size of tag data
* bNewData - TRUE if new tag is not a reference to existing data
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL AddTagTableEntry(
PPROFOBJ pProfObj,
TAGTYPE tagType,
DWORD dwOffset,
DWORD cbSize,
BOOL bNewData
)
{
PTAGDATA pTagData;
PBYTE src, dest;
DWORD nCount;
DWORD cnt, i;
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
//
// Increase count of tag elements by 1, and add new tag to end of
// tag table. Move all data below tag table downwards by the size
// of one tag table entry.
//
nCount++;
dest = (PBYTE)TAG_DATA(pProfObj) + nCount * sizeof(TAGDATA);
src = (PBYTE)TAG_DATA(pProfObj) + (nCount - 1) * sizeof(TAGDATA);
//
// # bytes to move = file size - header - tag count - tag table
//
cnt = FIX_ENDIAN(HEADER(pProfObj)->phSize) - sizeof(PROFILEHEADER) -
sizeof(DWORD) - (nCount - 1) * sizeof(TAGDATA);
if (cnt > 0)
{
//
// NOTE: CopyMemory() doesn't work for overlapped memory.
// Use internal function instead.
//
MyCopyMemory((PVOID)dest, (PVOID)src, cnt);
}
TAG_COUNT(pProfObj) = FIX_ENDIAN(nCount);
pTagData = (PTAGDATA)src;
pTagData->tagType = FIX_ENDIAN(tagType);
pTagData->cbSize = FIX_ENDIAN(cbSize);
pTagData->dwOffset = FIX_ENDIAN(dwOffset);
//
// Go through the tag table and update the offsets of all elements
// by the size of one tag table entry that we inserted.
//
pTagData = TAG_DATA(pProfObj);
for (i=0; i<nCount; i++)
{
cnt = FIX_ENDIAN(pTagData->dwOffset);
cnt += sizeof(TAGDATA);
pTagData->dwOffset = FIX_ENDIAN(cnt);
pTagData++; // Next element
}
//
// Set final file size
//
cnt = DWORD_ALIGN(FIX_ENDIAN(HEADER(pProfObj)->phSize)) + sizeof(TAGDATA);
if (bNewData)
{
//
// The new tag is not a reference to an old tag. Increment
// file size of size of new data also
//
cnt += cbSize;
}
HEADER(pProfObj)->phSize = FIX_ENDIAN(cnt);
return TRUE;
}
/******************************************************************************
*
* AddTaggedElement
*
* Function:
* This functions adds a new tagged element to a profile
*
* Arguments:
* pProfObj - pointer to profile object
* tagType - tag to add
* cbSize - size of tag data
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL AddTaggedElement(
PPROFOBJ pProfObj,
TAGTYPE tagType,
DWORD cbSize
)
{
DWORD dwOffset, newSize;
ASSERT(pProfObj != NULL);
ASSERT(cbSize > 0);
//
// Resize the profile if needed. For memory buffers, we have to realloc,
// and for mapped objects, we have to close and reopen the view.
//
newSize = FIX_ENDIAN(HEADER(pProfObj)->phSize);
newSize = DWORD_ALIGN(newSize) + sizeof(TAGDATA) + cbSize;
//
// Check for overflow
//
if (newSize < FIX_ENDIAN(HEADER(pProfObj)->phSize) ||
newSize < cbSize)
{
WARNING((__TEXT("Overflow in adding element\n")));
SetLastError(ERROR_ARITHMETIC_OVERFLOW);
return FALSE;
}
if (newSize > pProfObj->dwMapSize)
{
if (! GrowProfile(pProfObj, newSize))
{
return FALSE;
}
}
//
// Calculate location of new data - should be DWORD aligned
//
dwOffset = FIX_ENDIAN(HEADER(pProfObj)->phSize);
dwOffset = DWORD_ALIGN(dwOffset);
return AddTagTableEntry(pProfObj, tagType, dwOffset, cbSize, TRUE);
}
/******************************************************************************
*
* DeleteTaggedElement
*
* Function:
* This functions deletes a tagged element from the profile
*
* Arguments:
* pProfObj - pointer to profile object
* pTagData - pointer to tagged element to delete
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL DeleteTaggedElement(
PPROFOBJ pProfObj,
PTAGDATA pTagData
)
{
PBYTE pData;
PTAGDATA pTemp;
DWORD cbSize, nCount, dwOffset, i;
//
// Remember location of data and move everything upto the data upwards
// by size of one tag table entry. Then move everything below the tag data
// upward by size of data plus size of one tage table entry.
//
pData = VIEW(pProfObj) + FIX_ENDIAN(pTagData->dwOffset);
cbSize = FIX_ENDIAN(pTagData->cbSize);
cbSize = DWORD_ALIGN(cbSize);
dwOffset = FIX_ENDIAN(pTagData->dwOffset);
MoveProfileData(pProfObj, (PBYTE)(pTagData+1), (PBYTE)pTagData,
(LONG)(pData-(PBYTE)(pTagData+1)), FALSE);
//
// Do not attempt to move data past the tag if we are deleting the last tag
//
if (pData + cbSize < VIEW(pProfObj) + PROFILE_SIZE(pProfObj))
{
MoveProfileData(pProfObj, pData+cbSize, pData-sizeof(TAGDATA),
PROFILE_SIZE(pProfObj)-(LONG)(pData - VIEW(pProfObj)) - cbSize, TRUE);
}
//
// Get count of tag items - it is right after the profile header, and
// decrement it by one.
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount) - 1;
TAG_COUNT(pProfObj) = FIX_ENDIAN(nCount);
//
// Go through the tag table and update the pointers
//
pTemp = TAG_DATA(pProfObj);
for (i=0; i<nCount; i++)
{
DWORD dwTemp = FIX_ENDIAN(pTemp->dwOffset);
if (dwTemp > dwOffset)
{
dwTemp -= cbSize; // cbSize already DWORD aligned
}
dwTemp -= sizeof(TAGDATA);
pTemp->dwOffset = FIX_ENDIAN(dwTemp);
pTemp++; // Next record
}
//
// Use nCount as a placeholder to calculate file size
//
nCount = DWORD_ALIGN(FIX_ENDIAN(HEADER(pProfObj)->phSize));
nCount -= sizeof(TAGDATA) + cbSize;
HEADER(pProfObj)->phSize = FIX_ENDIAN(nCount);
return TRUE;
}
/******************************************************************************
*
* ChangeTaggedElementSize
*
* Function:
* This functions changes the size of a tagged element in the profile
*
* Arguments:
* pProfObj - pointer to profile object
* pTagData - pointer to tagged element whose size is to be changed
* cbSize - new size for the element
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
BOOL ChangeTaggedElementSize(
PPROFOBJ pProfObj,
PTAGDATA pTagData,
DWORD cbSize
)
{
PTAGDATA pTemp;
PBYTE pData;
DWORD nCount, cbOldSize;
DWORD dwOffset, cnt, i;
ASSERT(pProfObj != NULL);
ASSERT(cbSize > 0);
//
// Get current size of element
//
cbOldSize = FIX_ENDIAN(pTagData->cbSize);
if (cbOldSize == cbSize)
{
return TRUE; // Sizes are the same - Do nothing
}
pData = VIEW(pProfObj) + FIX_ENDIAN(pTagData->dwOffset);
//
// Do not attempt to move data beyond end of file. There is no need to move
// anything if the last data item is being resized.
//
if (pData + DWORD_ALIGN(cbOldSize) < VIEW(pProfObj) + PROFILE_SIZE(pProfObj))
{
MoveProfileData(pProfObj, pData + DWORD_ALIGN(cbOldSize), pData + DWORD_ALIGN(cbSize),
PROFILE_SIZE(pProfObj) - (LONG)(pData - VIEW(pProfObj)) - DWORD_ALIGN(cbOldSize), TRUE);
}
pTagData->cbSize = FIX_ENDIAN(cbSize); // Set the new size
//
// Get count of tag items - it is right after the profile header
//
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
//
// Go through the tag table and update the pointers
//
pTemp = TAG_DATA(pProfObj);
dwOffset = FIX_ENDIAN(pTagData->dwOffset);
for (i=0; i<nCount; i++)
{
DWORD dwTemp = FIX_ENDIAN(pTemp->dwOffset);
if (dwTemp > dwOffset)
{
dwTemp += DWORD_ALIGN(cbSize) - DWORD_ALIGN(cbOldSize);
pTemp->dwOffset = FIX_ENDIAN(dwTemp);
}
pTemp++; // Next record
}
//
// Use cnt as a placeholder to calculate file size
//
cnt = FIX_ENDIAN(HEADER(pProfObj)->phSize);
cnt += DWORD_ALIGN(cbSize) - DWORD_ALIGN(cbOldSize);
HEADER(pProfObj)->phSize = FIX_ENDIAN(cnt);
return TRUE;
}
/******************************************************************************
*
* MoveProfileData
*
* Function:
* This function moves data in a profile up or down (from src to dest),
* and then zeroes out the end of the file or the extra space created.
*
* Arguments:
* pProfObj - pointer to profile object
* src - pointer to source of block to move
* dest - pointer to destination for block to move to
* cnt - number of bytes to move
*
* Returns:
* TRUE if successful, FALSE otherwise
*
******************************************************************************/
void MoveProfileData(
PPROFOBJ pProfObj,
PBYTE src,
PBYTE dest,
LONG cnt,
BOOL bZeroMemory
)
{
//
// NOTE: CopyMemory() doesn't work for overlapped memory.
// Use internal function instead.
//
MyCopyMemory((PVOID)dest, (PVOID)src, cnt);
if (bZeroMemory)
{
cnt = ABS((LONG)(dest - src));
if (dest < src)
{
//
// Size decreased, so zero out end of file
//
dest = VIEW(pProfObj) + FIX_ENDIAN(HEADER(pProfObj)->phSize) -
(src - dest);
}
else
{
//
// Size increased, so zero out the increased tagdata
//
dest = src;
}
ZeroMemory(dest, cnt);
}
return;
}
/******************************************************************************
*
* IsReferenceTag
*
* Function:
* This function checks if a given tag's data is referred to by another
* tag in the profile
*
* Arguments:
* pProfObj - pointer to profile object
* pTagData - pointer to tagdata which should be checked
*
* Returns:
* TRUE if it is a referece, FALSE otherwise
*
******************************************************************************/
BOOL IsReferenceTag(
PPROFOBJ pProfObj,
PTAGDATA pTagData
)
{
PTAGDATA pTemp;
DWORD nCount, i;
BOOL bReference = FALSE;
pTemp = TAG_DATA(pProfObj);
nCount = TAG_COUNT(pProfObj);
nCount = FIX_ENDIAN(nCount);
for (i=0; i<nCount; i++)
{
if ((pTagData->dwOffset == pTemp->dwOffset) &&
(pTagData->tagType != pTemp->tagType))
{
bReference = TRUE;
break;
}
pTemp++; // next record
}
return bReference;
}