/***************************************************************************
* FUNCTION NAME
* SpStringToTextDesc
*
* DESCRIPTION
* This function converts stings to tags of type Sp_AT_TextDesc
* to a string. It allocates memory for the iso, unicode and mac
* strings which must be freed. SpFreeTextDesc can be called to free
* that memory.
***************************************************************************/
SpStatus_t SpStringToTextDesc(KpChar_p pString,
SpTextDesc_t *pTextDesc)
{
KpInt32_t length, index, macScriptLen = 67;
KpChar_p pSrcStr, pDestStr;
KpUInt16_t data16;
KpUInt16_p pDestStr16;
/* Allocate memory for the stings */
length = strlen (pString);
pTextDesc->IsoStr = (char *) allocBufferPtr (length+1);
pTextDesc->UniStr = (unsigned short *) allocBufferPtr((length+2)*2);
if ((NULL == pTextDesc->IsoStr) ||
(NULL == pTextDesc->UniStr)) {
SpFreeTextDesc (pTextDesc);
return SpStatMemory;
}
/* copy the string to the isoString */
pSrcStr = pString;
pDestStr = pTextDesc->IsoStr;
strcpy (pDestStr, pSrcStr);
/* convert the string to unicode */
pSrcStr = pString;
pDestStr16 = pTextDesc->UniStr;
pTextDesc->UniLangCode = 0;
for (index = 0; index < length; index++) {
data16 = *pSrcStr++;
*pDestStr16++ = data16;
}
data16 = 0;
*pDestStr16++ = data16;
/* convert the string to macintosh script */
pSrcStr = pString;
pDestStr = pTextDesc->MacStr;
pTextDesc->MacScriptCode = 0;
if (length >= macScriptLen) {
length = macScriptLen - 1;
}
pTextDesc->MacCount = (char) (length+1);
strncpy (pDestStr, pSrcStr, length+1);
pDestStr += length;
*pDestStr = 0;
return SpStatSuccess;
} /* SpStringToTextDesc */
/***************************************************************************
* FUNCTION NAME
* SpStringToMultiLang
*
* DESCRIPTION
* This function converts stings to English Unicode in a MultiLang Tag
***************************************************************************/
SpStatus_t SpStringToMultiLang(KpChar_p pString, KpInt16_t Language, KpInt16_t Country,
SpMultiLang_t *pMultiLang)
{
KpInt32_t length, index;
KpChar_p pSrcStr;
KpUInt16_t data16;
KpUInt16_p pDestStr16;
pMultiLang->StringInfo = (SpUnicodeInfo_t *)allocBufferPtr(sizeof(SpUnicodeInfo_t));
if (NULL == pMultiLang->StringInfo)
return SpStatMemory;
length = strlen (pString);
/* Set up for place holder for Profile Seq Desc Tag */
pMultiLang->Count = 0;
pMultiLang->RecSize = 12;
pMultiLang->StringInfo[0].LanguageCode = Language;
pMultiLang->StringInfo[0].CountryCode = Country;
pMultiLang->StringInfo[0].StringLength = 2 * length;
if (length > 0)
{
pMultiLang->Count = 1;
/* Allocate memory for the stings */
pMultiLang->StringInfo[0].UniString =
(unsigned short *) allocBufferPtr(2 * length);
if (NULL == pMultiLang->StringInfo[0].UniString) {
freeBufferPtr(pMultiLang->StringInfo);
return SpStatMemory;
}
/* convert the string to unicode */
pSrcStr = pString;
pDestStr16 = pMultiLang->StringInfo[0].UniString;
for (index = 0; index < length; index++) {
data16 = *pSrcStr++;
*pDestStr16++ = data16;
}
}
return SpStatSuccess;
} /* SpStringToMultiLang */
/***************************************************************************
* FUNCTION NAME
* SpProfileSetLinkSeqDesc
*
* DESCRIPTION
* This function creates the Profile Sequence Description tag for
* the device link profile pointed to by pProfile. The information
* needed to form the sequence description is contained in the
* SpDevLinkPB structure pointed to by pDevLinkDesc. A sequence record
* is created for each profile in the profile list. The sequence records
* are used to make the sequence description.
*
***************************************************************************/
SpStatus_t SpProfileSetLinkSeqDesc(SpProfile_t pProfile,
SpDevLinkPB_p pDevLinkDesc)
{
KpInt32_t index, numProfiles,numRecords;
SpProfListEntry_p pCurProfEntry;
SpProfileSeqDescRecord_t *pSeqRecords, *pCurrentRecord;
SpTagValue_t tagValue;
SpStatus_t spStatus;
/* Allocate the memory for the profile sequence records */
numProfiles = pDevLinkDesc->numProfiles;
pSeqRecords = (SpProfileSeqDescRecord_t *)
allocBufferPtr(sizeof(SpProfileSeqDescRecord_t) *
numProfiles);
if (NULL == pSeqRecords) {
return SpStatMemory;
}
/* For each profile in the profile list make a
profile sequence record */
pCurrentRecord = pSeqRecords;
pCurProfEntry = pDevLinkDesc->pProfileList;
numRecords = 0;
for (index = 0; index < pDevLinkDesc->numProfiles; index++) {
spStatus = SpProfileCreateSeqRecord(pCurProfEntry->profile,
pCurrentRecord);
if (SpStatSuccess != spStatus) {
goto getOut;
}
numRecords++;
pCurrentRecord++;
pCurProfEntry++;
}
/* Create the profile sequence description tag and
add it to the profile */
tagValue.TagId = SpTagProfileSeqDesc;
tagValue.TagType = Sp_AT_ProfileSeqDesc;
tagValue.Data.ProfileSeqDesc.Count = numRecords;
tagValue.Data.ProfileSeqDesc.Records = pSeqRecords;
spStatus = SpTagSet (pProfile, &tagValue);
/* Free all of the sequence records */
getOut:
pCurrentRecord = pSeqRecords;
for (index = 0; index < numRecords; index++) {
SpProfileFreeSeqRecord (pCurrentRecord);
pCurrentRecord++;
}
freeBufferPtr (pSeqRecords);
return spStatus;
} /* SpProfileSetLinkSeqDesc */
/*--------------------------------------------------------------------
* DESCRIPTION
* Map an entire file.
*
* AUTHOR
* lsh
*
* DATE CREATED
* November 9, 1993
*------------------------------------------------------------------*/
void FAR *KpMapFileEx (
KpChar_p FileName,
KpFileProps_t FAR *FileProps,
KpChar_p Mode,
KpMapFile_t FAR *MapFileCtl)
{
/* validate mode */
switch (*Mode) {
case 'R':
case 'r':
#if 0
case 'w':
#endif
break;
default:
return NULL;
}
/* get the size of the file */
if (!KpFileSize (FileName, FileProps, &MapFileCtl->NumBytes))
return NULL;
/* allocate buffer to hold file */
MapFileCtl->Ptr = allocBufferPtr (MapFileCtl->NumBytes);
if (NULL == MapFileCtl->Ptr)
return NULL;
/* open the file */
if (!KpFileOpen (FileName, Mode, FileProps, &MapFileCtl->Fd)) {
freeBufferPtr (MapFileCtl->Ptr);
return NULL;
}
/* read file into the buffer */
if (!KpFileRead (MapFileCtl->Fd, MapFileCtl->Ptr, &MapFileCtl->NumBytes)) {
freeBufferPtr (MapFileCtl->Ptr);
KpFileClose (MapFileCtl->Fd);
return NULL;
}
/* done with file, close it */
if ('r' == *Mode) {
KpFileClose (MapFileCtl->Fd);
MapFileCtl->Fd = -1;
}
MapFileCtl->Mode = *Mode;
return MapFileCtl->Ptr;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Return the header for the profile.
*
* AUTHOR
* doro
*
* DATE CREATED
* October 23, 1995
*------------------------------------------------------------------*/
SpStatus_t KSPAPI SpProfileLoadHeader(
char *Filename,
SpFileProps_t *Props,
SpHeader_t FAR *Header)
{
SpHugeBuffer_t BufferAddress;
SpStatus_t Status = SpStatBadProfile;
KpFileId FD;
char *name;
KpUInt32_t Read_OK;
KpInt32_t Read_Amount = HEADER_SIZE;
KpFileProps_t fileProps;
if (!SpIsICCProfile(Filename, Props))
return (SpStatBadProfile);
name = Filename;
BufferAddress = allocBufferPtr(HEADER_SIZE);
if (BufferAddress == NULL)
return (SpStatMemory);
#if defined (KPMAC)
SpCvrtSpFileProps(Props, &fileProps);
#endif
if (KpFileOpen(name, "r", &fileProps, &FD)) /* 0 = not opened */
{
/* Read HEADER_SIZE into Buffer */
Read_OK = KpFileRead(FD, BufferAddress, &Read_Amount);
/* Close File */
if (!KpFileClose(FD))
Status = SpStatBadProfile;
if (Read_OK)
{
Status = SpHeaderToPublic(BufferAddress, HEADER_SIZE, Header);
}
}
freeBufferPtr(BufferAddress);
return Status;
}
/***************************************************************************
* FUNCTION NAME
* SpProfileSetLinkDesc
*
* DESCRIPTION
* This function creates the Profile Description tag for the
* device link profile pointed to by pProfile. The information needed
* to form the description string is contained in the SpDevLinkPB
* structure pointed to by pDevLinkDesc. The description string
* is formed by taking the manufacture, model and device color space
* from the first profile in the profile list and taking the
* manufacturer, model and connection color space from the last profile
* in the list.
*
***************************************************************************/
SpStatus_t SpProfileSetLinkDesc(SpProfile_t pProfile,
SpDevLinkPB_p pDevLinkDesc)
{
KpTChar_t manufacturer1[SpMaxTextDesc], model1[SpMaxTextDesc];
KpTChar_t manufacturer2[SpMaxTextDesc], model2[SpMaxTextDesc];
KpTChar_p pDescStr;
KpInt32_t length;
SpProfListEntry_p pCurProfEntry;
SpTagValue_t tagValue;
SpStatus_t spStatus;
/* Get the manufacturer information from the first profile */
pCurProfEntry = pDevLinkDesc->pProfileList;
strcpy (manufacturer1, "Unknown");
spStatus = SpTagGetById(pCurProfEntry->profile,
SpTagDeviceMfgDesc,
&tagValue);
if (SpStatSuccess == spStatus) {
length = sizeof (manufacturer1);
SpTagGetString(&tagValue, &length, manufacturer1);
SpTagFree(&tagValue);
}
/* Get the model information from the first profile */
strcpy(model1, "Unknown");
spStatus = SpTagGetById(pCurProfEntry->profile,
SpTagDeviceModelDesc,
&tagValue);
if (SpStatSuccess == spStatus) {
length = sizeof (model1);
SpTagGetString(&tagValue, &length, model1);
SpTagFree(&tagValue);
}
/* Get the manufacturer information from the last profile */
pCurProfEntry = pDevLinkDesc->pProfileList +
(pDevLinkDesc->numProfiles - 1);
strcpy(manufacturer2, "Unknown");
spStatus = SpTagGetById(pCurProfEntry->profile,
SpTagDeviceMfgDesc,
&tagValue);
if (SpStatSuccess == spStatus) {
length = sizeof (manufacturer2);
SpTagGetString(&tagValue, &length, manufacturer2);
SpTagFree(&tagValue);
}
/* Get the model information from the last profile */
strcpy(model2, "Unknown");
spStatus = SpTagGetById(pCurProfEntry->profile,
SpTagDeviceModelDesc,
&tagValue);
if (SpStatSuccess == spStatus) {
length = sizeof (model2);
SpTagGetString(&tagValue, &length, model2);
SpTagFree(&tagValue);
}
/* Allocate memory for the description string */
length = strlen(manufacturer1) +
strlen(model1) +
strlen(manufacturer2) +
strlen(model2) + 7;
pDescStr = (KpTChar_p)allocBufferPtr(length+1);
if (NULL == pDescStr) {
return SpStatMemory;
}
/* Form the description string */
/* sprintf(pDescStr, "%s %s %s to %s %s %s",
manufacturer1, model1, colorSpace1,
manufacturer2, model2, colorSpace2); */
strcpy(pDescStr, manufacturer1);
strcat(pDescStr, " ");
strcat(pDescStr, model1);
strcat(pDescStr, " to ");
strcat(pDescStr, manufacturer2);
strcat(pDescStr, " ");
strcat(pDescStr, model2);
/* Convert the string to a text description tag and
add it to the profile */
spStatus = SpStringToTextDesc(pDescStr,
&tagValue.Data.TextDesc);
freeBufferPtr(pDescStr);
if (SpStatSuccess != spStatus) {
return spStatus;
}
tagValue.TagId = SpTagProfileDesc;
tagValue.TagType = Sp_AT_TextDesc;
spStatus = SpTagSet (pProfile, &tagValue);
SpFreeTextDesc (&tagValue.Data.TextDesc);
return spStatus;
} /* SpProfileSetLinkDesc */
/***************************************************************************
* FUNCTION NAME
* SpProfileCreateMLSeqRecord
*
* DESCRIPTION
* This function creates the Profile Sequence record for the
* profile pointed to by pProfile. The Profile Sequence record to
* build is pointed to by pSeqRecord.
*
***************************************************************************/
SpStatus_t SpProfileCreateMLSeqRecord(SpProfile_t pProfile,
SpProfileSeqDescRecord2_t *pSeqRecord)
{
SpHeader_t header;
SpTagValue_t tagValue;
SpStatus_t spStatus;
KpChar_p CString;
KpInt32_t BufSize;
/* Get the profiles header */
spStatus = SpProfileGetHeader (pProfile, &header);
if (SpStatSuccess != spStatus) {
return spStatus;
}
/* Copy the manufacturer, model, attributes and technology
fields into the sequence record */
pSeqRecord->DeviceManufacturer = header.DeviceManufacturer;
pSeqRecord->DeviceModel = header.DeviceModel;
pSeqRecord->DeviceAttributes.hi = header.DeviceAttributes.hi;
pSeqRecord->DeviceAttributes.lo = header.DeviceAttributes.lo;
/* Get the technology tag*/
spStatus = SpTagGetById(pProfile,
SpTagTechnology,
&tagValue);
if (SpStatSuccess != spStatus)
pSeqRecord->Technology = SpSigNone;
else
{
pSeqRecord->Technology = tagValue.Data.Signature;
SpTagFree(&tagValue);
}
/* Get the manufacturer description */
spStatus = SpTagGetById(pProfile,
SpTagDeviceMfgDesc,
&tagValue);
if (SpStatSuccess != spStatus) {
spStatus = SpStringToMultiLang("", SpEnglish, SpUSA, &tagValue.Data.MultiLang);
if (SpStatSuccess != spStatus) {
return spStatus;
}
} else if (tagValue.TagType == Sp_AT_TextDesc)
{
BufSize = strlen(tagValue.Data.TextDesc.IsoStr) + 1;
CString = (char *) allocBufferPtr (BufSize);
spStatus = SpTagGetString(&tagValue, &BufSize, CString);
SpTagFree(&tagValue);
spStatus = SpStringToMultiLang(CString, SpEnglish, SpUSA, &tagValue.Data.MultiLang);
freeBufferPtr(CString);
if (SpStatSuccess != spStatus)
return spStatus;
}
pSeqRecord->DeviceManufacturerDesc.TagType = SpTypeMultiLanguage;
pSeqRecord->DeviceManufacturerDesc.Reserved = 0;
pSeqRecord->DeviceManufacturerDesc.MLDesc = tagValue.Data.MultiLang;
/* Get the model description */
spStatus = SpTagGetById(pProfile,
SpTagDeviceModelDesc,
&tagValue);
if (SpStatSuccess != spStatus) {
spStatus = SpStringToMultiLang("", SpEnglish, SpUSA, &tagValue.Data.MultiLang);
if (SpStatSuccess != spStatus) {
return spStatus;
}
} else if (tagValue.TagType == Sp_AT_TextDesc)
{
BufSize = strlen(tagValue.Data.TextDesc.IsoStr) + 1;
CString = (char *) allocBufferPtr (BufSize+1);
spStatus = SpTagGetString(&tagValue, &BufSize, CString);
SpTagFree(&tagValue);
spStatus = SpStringToMultiLang(CString, SpEnglish, SpUSA, &tagValue.Data.MultiLang);
freeBufferPtr(CString);
if (SpStatSuccess != spStatus)
return spStatus;
}
pSeqRecord->DeviceModelDesc.TagType = SpTypeMultiLanguage;
pSeqRecord->DeviceModelDesc.Reserved = 0;
pSeqRecord->DeviceModelDesc.MLDesc = tagValue.Data.MultiLang;
return SpStatSuccess;
} /* SpProfileCreateMLSeqRecord */
/*--------------------------------------------------------------------
* DESCRIPTION
* Test profile with header and or tag search criteria and report status
*
* AUTHOR
* Sakey
*
* DATE CREATED
* July, 2002
*------------------------------------------------------------------*/
SpStatus_t KSPAPI SpProfileCheckEx(
SpSearch_p SearchValue,
char *Filename,
SpFileProps_t *Props)
{
SpStatus_t status;
SpHeader_t Header;
SpTagValue_t tagValue;
KpInt32_t Passed[SPSEARCH_LIST];
KpInt32_t Tested[SPSEARCH_LIST];
KpInt32_t i, j, critSize;
SpSearchCriterion_t *criterion;
#define TAGID_LIST 5
SpTagId_t TagIdsPassed[TAGID_LIST];
SpTagId_t TagIdsTested[TAGID_LIST];
SpTagId_t *pTagIdsPassed = TagIdsPassed;
SpTagId_t *pTagIdsTested = TagIdsTested;
KpInt32_t TagCount = 0;
if (NULL == SearchValue)
return SpStatIncompatibleArguments;
critSize = SearchValue->critSize;
criterion = SearchValue->criterion;
status = SpProfileLoadHeader (Filename, Props, &Header);
if (SpStatSuccess != status)
return status;
for (i = 0; i < SPSEARCH_LIST; i++)
{
/* preset all entries in PassedEvalArray to Not Tested and failed . */
Passed[i] = 0;
Tested[i] = 0;
}
/* count up the number of tag checks requested. */
for (i = 0; i < SearchValue->critCount; i++)
{
if ((SPSEARCH_ENUMTAGVALUE_EQUAL == criterion->SearchElement) ||
(SPSEARCH_ENUMTAGVALUE_NOTEQUAL == criterion->SearchElement))
TagCount++;
criterion = (SpSearchCriterion_t *)(critSize + (KpUInt8_p)criterion);
}
criterion = SearchValue->criterion;
if (TAGID_LIST < TagCount)
{
/* allocate the tested/passed arrays */
pTagIdsTested = allocBufferPtr( TagCount * sizeof(SpTagId_t));
if (NULL == pTagIdsTested)
return SpStatMemory;
pTagIdsPassed = allocBufferPtr( TagCount * sizeof(SpTagId_t));
if (NULL == pTagIdsPassed)
return SpStatMemory;
}
/* preset all entries in Tag PassedEvalArrays to Not Tested and failed . */
for (i = 0; i < TagCount; i++)
{
pTagIdsTested[i] = 0;
pTagIdsPassed[i] = 0;
}
/* Loop thru the parameters, test the value based upon the Field
* Set that it Passed if it did. Set that it was tested always
*/
for (i = 0; i < SearchValue->critCount; i++)
{
switch (criterion->SearchElement)
{
case SPSEARCH_PREFERREDCMM :
if (criterion->SearchValue.Signature ==
(KpInt32_t) Header.CMMType)
Passed[SPSEARCH_PREFERREDCMM] = 1;
Tested[SPSEARCH_PREFERREDCMM] = 1;
break;
case SPSEARCH_VERSION :
if (criterion->SearchValue.Value ==
Header.ProfileVersion)
Passed[SPSEARCH_VERSION] = 1;
Tested[SPSEARCH_VERSION] = 1;
break;
case SPSEARCH_PROFILECLASS :
if (criterion->SearchValue.Signature ==
Header.DeviceClass)
Passed[SPSEARCH_PROFILECLASS] = 1;
Tested[SPSEARCH_PROFILECLASS] = 1;
break;
case SPSEARCH_DEVICECOLORSPACE :
if (criterion->SearchValue.Signature ==
Header.DataColorSpace)
Passed[SPSEARCH_DEVICECOLORSPACE] = 1;
Tested[SPSEARCH_DEVICECOLORSPACE] = 1;
break;
case SPSEARCH_CONNECTIONSPACE :
if (criterion->SearchValue.Signature ==
Header.InterchangeColorSpace)
Passed[SPSEARCH_CONNECTIONSPACE] = 1;
Tested[SPSEARCH_CONNECTIONSPACE] = 1;
break;
/* Only use ONDATE value for all date testing since more
* than one value can be given for an attribute */
case SPSEARCH_BEFOREDATE :
if (BEFORE == TestHeaderDate(
&Header.DateTime,
&criterion->SearchValue.Date))
Passed[SPSEARCH_ONDATE] = 1;
Tested[SPSEARCH_ONDATE] = 1;
break;
case SPSEARCH_ONDATE :
if (SAME == TestHeaderDate(
&Header.DateTime,
&criterion->SearchValue.Date))
Passed[SPSEARCH_ONDATE] = 1;
Tested[SPSEARCH_ONDATE] = 1;
break;
case SPSEARCH_AFTERDATE :
if (AFTER == TestHeaderDate(
&Header.DateTime,
&criterion->SearchValue.Date))
Passed[SPSEARCH_ONDATE] = 1;
Tested[SPSEARCH_ONDATE] = 1;
break;
case SPSEARCH_PLATFORM :
if (criterion->SearchValue.Signature ==
Header.Platform)
Passed[SPSEARCH_PLATFORM] = 1;
Tested[SPSEARCH_PLATFORM] = 1;
break;
case SPSEARCH_PROFILEFLAGS :
if (criterion->SearchValue.Value ==
Header.Flags)
Passed[SPSEARCH_PROFILEFLAGS] = 1;
Tested[SPSEARCH_PROFILEFLAGS] = 1;
break;
case SPSEARCH_DEVICEMFG :
if (criterion->SearchValue.Signature ==
Header.DeviceManufacturer)
Passed[SPSEARCH_DEVICEMFG] = 1;
Tested[SPSEARCH_DEVICEMFG] = 1;
break;
case SPSEARCH_DEVICEMODEL :
if (criterion->SearchValue.Signature ==
Header.DeviceModel)
Passed[SPSEARCH_DEVICEMODEL] = 1;
Tested[SPSEARCH_DEVICEMODEL] = 1;
break;
case SPSEARCH_DEVICEATTRIBUTESHI :
if (criterion->SearchValue.Value ==
Header.DeviceAttributes.hi)
Passed[SPSEARCH_DEVICEATTRIBUTESHI] = 1;
Tested[SPSEARCH_DEVICEATTRIBUTESHI] = 1;
break;
case SPSEARCH_DEVICEATTRIBUTESLO :
if (criterion->SearchValue.Value ==
Header.DeviceAttributes.lo)
Passed[SPSEARCH_DEVICEATTRIBUTESLO] = 1;
Tested[SPSEARCH_DEVICEATTRIBUTESLO] = 1;
break;
case SPSEARCH_RENDERINGINTENT :
if (criterion->SearchValue.Signature ==
(KpInt32_t) Header.RenderingIntent)
Passed[SPSEARCH_RENDERINGINTENT] = 1;
Tested[SPSEARCH_RENDERINGINTENT] = 1;
break;
case SPSEARCH_ILLUMINANT :
if ((criterion->SearchValue.XYZ.X ==
Header.Illuminant.X) &&
(criterion->SearchValue.XYZ.Y ==
Header.Illuminant.Y) &&
(criterion->SearchValue.XYZ.Z ==
Header.Illuminant.Z))
Passed[SPSEARCH_ILLUMINANT] = 1;
Tested[SPSEARCH_ILLUMINANT] = 1;
break;
case SPSEARCH_ORIGINATOR :
if (criterion->SearchValue.Signature ==
Header.Originator)
Passed[SPSEARCH_ORIGINATOR] = 1;
Tested[SPSEARCH_ORIGINATOR] = 1;
break;
case SPSEARCH_PROFILEID :
if ((criterion->SearchValue.ProfileID.a ==
Header.ProfileID.a) &&
(criterion->SearchValue.ProfileID.b ==
Header.ProfileID.b) &&
(criterion->SearchValue.ProfileID.c ==
Header.ProfileID.c) &&
(criterion->SearchValue.ProfileID.d ==
Header.ProfileID.d))
Passed[SPSEARCH_ORIGINATOR] = 1;
Tested[SPSEARCH_ORIGINATOR] = 1;
break;
case SPSEARCH_ENUMTAGVALUE_EQUAL :
case SPSEARCH_ENUMTAGVALUE_NOTEQUAL :
/* find the matching tag ID or the first unused one */
for(j = 0; j < TagCount; j++)
{
if ((pTagIdsTested[j] == criterion->SearchValue.Tag.TagId) ||
(0 == pTagIdsTested[j]))
{
/* mark this tag as tested */
pTagIdsTested[j] = criterion->SearchValue.Tag.TagId;
break;
}
}
/* load the tag */
status = SpProfileLoadTag(Filename, Props, criterion->SearchValue.Tag.TagId, &tagValue);
if (SPSEARCH_ENUMTAGVALUE_EQUAL == criterion->SearchElement)
{
if ((SpStatSuccess == status) &&
(criterion->SearchValue.Tag.TagEnum == tagValue.Data.TagEnum))
{
pTagIdsPassed[j] = pTagIdsTested[j];
}
}
else
{
if ((SpStatSuccess != status) ||
(criterion->SearchValue.Tag.TagEnum != tagValue.Data.TagEnum))
{
pTagIdsPassed[j] = pTagIdsTested[j];
}
}
if (SpStatSuccess == status)
{
/* free allocated resources */
SpTagFree(&tagValue);
}
break;
case SPSEARCH_TIMEORDER:
default:
/* No special processing */
break;
}
criterion = (SpSearchCriterion_t *)(critSize + (KpUInt8_p)criterion);
}
/* assume success */
status = SpStatSuccess;
/* Loop thru enumeration types, Checking Passed vs Tested
* for return value
*/
for (i = 0; i < SPSEARCH_LIST; i++)
{
if (Tested[i] && !Passed[i])
status = SpStatBadProfile;
}
if (0 < TagCount)
{
for(j = 0; j < TagCount; j++)
{
if (pTagIdsTested[j] != pTagIdsPassed[j])
status = SpStatBadProfile;
}
if (TAGID_LIST < TagCount)
{
freeBufferPtr( (KpGenericPtr_t)pTagIdsTested);
freeBufferPtr( (KpGenericPtr_t)pTagIdsPassed);
}
}
return status;
}
PTErr_t
makeForwardXformMono ( ResponseRecord_p grayTRC,
fut_p theFut)
{
PTErr_t PTErr = KCP_FAILURE;
KpInt32_t futReturn, i1;
fut_otbldat_p otblDat;
double gamma;
fut_calcData_t calcData;
KpUInt16_t rrpData[2] = { 0, RRECORD_DATA_SIZE -1 };
ResponseRecord_t rrt;
KpUInt16_t *pCurveData = NULL;
/* compute new table entries */
calcData.chan = 0; /* always uses 1st input chan */
for (i1 = 0; i1 < FWD_MONO_OCHANS; i1++) {
if (( ! IS_CHAN(theFut->chan[i1])) ||
!fut_calc_gtblEx (theFut->chan[i1]->gtbl, fut_grampEx, &calcData) ||
!fut_calc_otblEx (theFut->chan[i1]->otbl, otblFunc, NULL)) {
goto ErrOut0;
}
}
/* get address of the first output table */
futReturn = fut_get_otbl (theFut, 0, &otblDat);
if ((futReturn != 1) || (otblDat == (fut_otbldat_p)NULL)) {
goto ErrOut0;
}
if (PARA_TYPE_SIG == grayTRC->TagSig)
{
pCurveData = (KpUInt16_p) allocBufferPtr (MFV_CURVE_TBL_ENT); /* get memory for curve data */
if (NULL == pCurveData) {
return KCP_NO_MEMORY;
}
makeCurveFromPara (grayTRC->ParaFunction, grayTRC->ParaParams, pCurveData, MFV_CURVE_TBL_ENT);
grayTRC->CurveCount = MFV_CURVE_TBL_ENT;
grayTRC->CurveData = pCurveData;
}
/* setup the output table */
switch (grayTRC->CurveCount)
{
case 0:
/* setup the responseRecord struct */
rrt.CurveCount = 2;
rrt.CurveData = rrpData;
/* make the output table */
PTErr = calcOtblLSN (otblDat, &rrt);
break;
case 1:
gamma = (double)grayTRC->CurveData[0] / SCALEDOT8;
if (gamma <= 0.0) {
goto ErrOut0;
}
/* make the output table */
PTErr = calcOtblLS1 (otblDat, gamma);
break;
default:
/* make the output table */
makeMonotonic (grayTRC->CurveCount, grayTRC->CurveData);
PTErr = calcOtblLSN (otblDat, grayTRC);
}
GetOut:
if (NULL != pCurveData) {
freeBufferPtr (pCurveData);
}
return PTErr;
ErrOut0:
PTErr = KCP_SYSERR_0;
goto GetOut;
}
PTErr_t
TpReadHdr ( KpFd_p fd,
KpHandle_t FAR* PTHdr,
PTType_p formatP)
{
PTErr_t errnum;
fut_hdr_p futHdr;
KpInt32_t ret, hdrSize;
hdrSize = (KpInt32_t)sizeof (fut_hdr_t);
/* get header memory */
futHdr = (fut_hdr_p) allocBufferPtr (hdrSize);
if (futHdr == NULL) {
errnum = KCP_NO_CHECKIN_MEM;
goto ErrOut;
}
ret = Kp_read (fd, (KpGenericPtr_t)&futHdr->magic, sizeof (KpInt32_t));
if (ret != 1) {
errnum = KCP_INVAL_PT_BLOCK;
goto ErrOut;
}
#if !defined KCP_ICC_ONLY
if ((futHdr->magic == FUT_CIGAM) || (futHdr->magic == FUT_MAGIC) ) {
ret = fut_read_futhdr (fd, futHdr); /* read in the header */
}
else {
#endif
#if defined (KPLSBFIRST) /* swap bytes if necessary */
Kp_swab32 ((KpGenericPtr_t)&futHdr->magic, 1);
#endif
switch (futHdr->magic) {
case PTTYPE_MFT1: /* 8 bit matrix fut */
case PTTYPE_MFT2: /* 16 bit matrix fut */
ret = fut_readMFutHdr (fd, futHdr); /* read the matrix fut header */
futHdr->idstr_len = 0;
break;
case PTTYPE_MA2B:
case PTTYPE_MB2A:
ret = fut_readMabFutHdr (fd, futHdr); /* read the matrix fut header */
futHdr->idstr_len = 0;
break;
default:
errnum = KCP_INVAL_PT_BLOCK; /* unknown type */
goto ErrOut;
}
#if !defined KCP_ICC_ONLY
}
#endif
if (ret != 1) {
errnum = KCP_INVAL_PT_BLOCK;
goto ErrOut;
}
futHdr->srcFormat = futHdr->magic; /* remember original format */
*formatP = futHdr->magic; /* return type of PT */
*PTHdr = unlockBufferPtr((KpGenericPtr_t)futHdr); /* return handle to header info */
if (*PTHdr == NULL) {
errnum = KCP_MEM_UNLOCK_ERR;
goto ErrOut;
}
return KCP_SUCCESS;
ErrOut:
if (futHdr != NULL) {
freeBufferPtr ((KpGenericPtr_t)futHdr);
}
return (errnum);
}
/* fut_copy copies an existing fut.
*/
fut_p
fut_copy (fut_p fut)
{
fut_p new_fut;
KpInt32_t i;
KpHandle_t h;
if ( ! IS_FUT(fut)) {
return (0);
}
/* allocate basic fut_structure */
new_fut = fut_alloc_fut ();
if ( new_fut == FUT_NULL ) {
return (FUT_NULL);
}
/* save handle before copying over old fut */
h = new_fut->handle;
/* copy over all data (including pointers */
*new_fut = *fut;
/* now copy back handle */
new_fut->handle = h;
/* copy id string */
new_fut->idstr = 0;
/* (void) fut_set_idstr (new_fut, fut->idstr); */
/* copy input tables */
for ( i=0; i<FUT_NICHAN; i++ ) {
new_fut->itbl[i] = (IS_SHARED (fut->itbl[i])) ?
fut_share_itbl (fut->itbl[i]) : fut_copy_itbl (fut->itbl[i]);
new_fut->itblHandle[i] = getHandleFromPtr((KpGenericPtr_t)new_fut->itbl[i]);
}
/* copy output channels */
for ( i=0; i<FUT_NOCHAN; i++ ) {
new_fut->chan[i] = fut_copy_chan (fut->chan[i]);
new_fut->chanHandle[i] = getHandleFromPtr((KpGenericPtr_t)new_fut->chan[i]);
}
/* now check that all copies were succesful */
if ( new_fut->idstr == 0 && fut->idstr != 0 ) {
goto ErrOut;
}
for ( i=0; i<FUT_NICHAN; i++ ) {
if ( new_fut->itbl[i] == 0 && fut->itbl[i] != 0) {
goto ErrOut;
}
}
for ( i=0; i<FUT_NOCHAN; i++ ) {
if ( new_fut->chan[i] == 0 && fut->chan[i] != 0) {
goto ErrOut;
}
}
for ( i=0; i<FUT_NMCHAN; i++ ) { /* free extra reference tables */
if (NULL != fut->mabInRefTblHandles[i])
{
new_fut->mabInTblEntries[i] = fut->mabInTblEntries[i];
new_fut->mabInRefTbl[i] = (mf2_tbldat_p)
allocBufferPtr (new_fut->mabInTblEntries[i] * sizeof (mf2_tbldat_t));
KpMemCpy (new_fut->mabInRefTbl[i], fut->mabInRefTbl[i],
new_fut->mabInTblEntries[i] * sizeof (mf2_tbldat_t));
new_fut->mabInRefTblHandles[i] = getHandleFromPtr ((KpGenericPtr_t)new_fut->mabInRefTbl[i]);
}
if (NULL != fut->mabOutRefTblHandles[i])
{
new_fut->mabOutTblEntries[i] = fut->mabOutTblEntries[i];
new_fut->mabOutRefTbl[i] = (mf2_tbldat_p)
allocBufferPtr (new_fut->mabOutTblEntries[i] * sizeof (mf2_tbldat_t));
KpMemCpy (new_fut->mabOutRefTbl[i], fut->mabOutRefTbl[i],
new_fut->mabOutTblEntries[i] * sizeof (mf2_tbldat_t));
new_fut->mabOutRefTblHandles[i] = getHandleFromPtr ((KpGenericPtr_t)new_fut->mabOutRefTbl[i]);
}
}
return (new_fut);
ErrOut:
fut_free (new_fut);
return (FUT_NULL);
}
/* frees source fut on error */
PTErr_t
fut2PT (fut_p *futSrc,
KpInt32_t inSpace,
KpInt32_t outSpace,
KpInt32_t srcFormat,
PTRefNum_p PTRefNumNew)
{
PTErr_t PTErr;
fut_hdr_p PTHdr = NULL;
KpHandle_t PTHdrH = NULL, PTDataH = NULL;
KpChar_t colorSpaceAttr[20];
*PTRefNumNew = 0;
if ( ! IS_FUT(*futSrc)) goto ErrOut1;
PTHdr = allocBufferPtr (sizeof(fut_hdr_t)); /* get buffer for resultant info header */
if (PTHdr == NULL) {
goto ErrOut4;
}
if (!fut_io_encode (*futSrc, PTHdr)) { /* make the info header */
goto ErrOut3;
}
PTHdr->srcFormat = srcFormat;
PTDataH = fut_unlock_fut (*futSrc);
if (PTDataH == NULL) {
goto ErrOut2;
}
*futSrc = NULL;
PTHdrH = unlockBufferPtr (PTHdr); /* unlock the header buffer */
if (PTHdrH == NULL) {
goto ErrOut2;
}
PTHdr = NULL;
PTErr = registerPT (PTHdrH, NULL, PTRefNumNew); /* enter PT into list */
if (PTErr != KCP_SUCCESS) {
goto ErrOut0;
}
makeActive (*PTRefNumNew, PTDataH); /* activate the new PT */
if (inSpace != -1) { /* set the input color space attribute */
KpItoa (inSpace, colorSpaceAttr);
PTErr = PTSetAttribute (*PTRefNumNew, KCM_IN_SPACE, colorSpaceAttr);
}
if (outSpace != -1) { /* set the output color space attribute */
KpItoa (outSpace, colorSpaceAttr);
PTErr = PTSetAttribute (*PTRefNumNew, KCM_OUT_SPACE, colorSpaceAttr);
}
if (PTErr != KCP_SUCCESS) {
goto ErrOut0;
}
getOut:
return PTErr;
ErrOut4:
PTErr = KCP_NO_CHECKIN_MEM;
goto ErrOut0;
ErrOut3:
PTErr = KCP_ENCODE_PTHDR_ERR;
goto ErrOut0;
ErrOut2:
PTErr = KCP_MEM_UNLOCK_ERR;
goto ErrOut0;
ErrOut1:
PTErr = KCP_BAD_ARG;
ErrOut0:
if (PTDataH != NULL) {
*futSrc = fut_lock_fut (PTDataH);
}
if (*futSrc != FUT_NULL) fut_free (*futSrc);
if (PTHdr != NULL) freeBufferPtr (PTHdr);
if (PTHdrH != NULL) freeBuffer (PTHdrH);
if (*PTRefNumNew != 0) PTCheckOut (*PTRefNumNew);
goto getOut;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Allocate a block of memory. The allocated block can be bigger
* than 64K.
*
* AUTHOR
* lsh
*
* DATE CREATED
* September 14, 1993
*------------------------------------------------------------------*/
void FAR *SpMalloc (KpInt32_t Size)
{
return allocBufferPtr (Size);
}
/*---------------------------------------------------------------------------
* makeInverseXformFromMatrix -- make a fut of given gridsize from given
* matrix data for inverse transform (XYZ -> RGB); return status code
*---------------------------------------------------------------------------
*/
PTErr_t
makeInverseXformFromMatrix (LPMATRIXDATA mdata,
KpUInt32_t interpMode,
KpInt32_p dim,
fut_p theFut)
{
PTErr_t PTErr = KCP_SUCCESS;
ResponseRecord_p rrp;
KpInt32_t i;
fut_chan_p theChan;
fut_gtbl_p theGtbl;
fut_otbl_p theOtbl;
mf2_tbldat_p gtblDat[3], otblDat, prevOtblDat;
KpUInt16_t prevGamma = 0, thisGamma;
double fwdgamma, one[3];
double offset[3] = {1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0};
KpUInt16_t *pCurveData = NULL;
for (i = 0; i < 3; i++) {
if (!IS_CHAN(theChan = theFut->chan[i])
|| !IS_GTBL(theGtbl = theChan->gtbl)
|| ((gtblDat[i] = theGtbl->refTbl) == NULL) /* Get grid tables */
|| !IS_OTBL(theOtbl = theChan->otbl)
|| ((otblDat = theOtbl->refTbl) == NULL)) { /* Get output table */
return KCP_INCON_PT;
}
if (theOtbl->refTblEntries != FUT_OUTTBL_ENT) return KCP_INCON_PT;
/* Get ResponseRecord: */
rrp = mdata->outResponse[i];
if (NULL == rrp) {
break; /* must only have output tables */
}
if (PARA_TYPE_SIG == rrp->TagSig)
{
pCurveData = (KpUInt16_p) allocBufferPtr (MFV_CURVE_TBL_ENT*sizeof(KpUInt16_t)); /* get memory for curve data */
if (NULL == pCurveData) {
return KCP_NO_MEMORY;
}
makeCurveFromPara (rrp->ParaFunction, rrp->ParaParams, pCurveData, MFV_CURVE_TBL_ENT);
rrp->CurveCount = MFV_CURVE_TBL_ENT;
rrp->CurveData = pCurveData;
}
if ((rrp->CurveCount > 0) && (rrp->CurveData == (KpUInt16_p)NULL)) {
PTErr = KCP_INCON_PT;
goto ErrOut;
}
/* Recompute output table: */
switch (rrp->CurveCount) {
case 0: /* linear response, with clipping */
calcOtbl0 (otblDat);
break;
case 1: /* power law */
thisGamma = rrp->CurveData[0];
if (prevGamma == thisGamma) { /* same gamma, just copy table */
memcpy (otblDat, prevOtblDat, sizeof (*otblDat) * FUT_OUTTBL_ENT);
}
else {
prevGamma = thisGamma;
prevOtblDat = otblDat;
fwdgamma = (double)thisGamma / SCALEDOT8;
if (fwdgamma <= 0.0) {
PTErr = KCP_INCON_PT;
goto ErrOut;
}
calcOtbl1 (otblDat, fwdgamma);
}
break;
default: /* look-up table of arbitrary length */
makeInverseMonotonic (rrp->CurveCount, rrp->CurveData);
if (rrp->CurveCount == theOtbl->refTblEntries) { /* ready-to-use look-up table */
memcpy (otblDat, rrp->CurveData, sizeof (*otblDat) * rrp->CurveCount);
}
else {
PTErr = calcOtblN (otblDat, rrp, interpMode);
if (PTErr != KCP_SUCCESS) {
PTErr = KCP_INCON_PT;
goto ErrOut;
}
}
break;
}
}
/* Compute inverse matrix (XYZ -> RGB): */
one[0] = one[1] = one[2] = 1.0; /* arbitrary vector */
/* replaces matrix with inverse */
if (solvemat (3, mdata->matrix, one) != 0) {
PTErr = KCP_INCON_PT;
goto ErrOut;
}
/* Rescale given matrix by factor of 3 for extended range: */
for (i = 0; i < 3; i++) {
KpInt32_t j;
for (j = 0; j < 3; j++) {
mdata->matrix[i][j] /= 3.0;
}
}
/* Replace grid tables: */
calcGtbl3 (gtblDat, dim, mdata->matrix, offset); /* with offset */
ErrOut:
if (NULL != pCurveData) {
freeBufferPtr (pCurveData);
}
return PTErr;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Return the Tag from the profile.
*
* AUTHOR
* doro
*
* DATE CREATED
* March 12, 2002
*------------------------------------------------------------------*/
SpStatus_t KSPAPI SpProfileLoadTagEx(
char *Filename,
SpFileProps_t *Props,
SpTagId_t TagId,
SpTagValue_t FAR *Value)
{
SpHeader_t Header;
SpHeader_t *HeaderPtr;
SpHugeBuffer_t BufferAddress, TagAddress;
SpStatus_t Status = SpStatSuccess;
KpFileId FD;
KpFileProps_t fileProps;
char name[MAX_PATH];
KpUInt32_t FilePosition = HEADER_SIZE;
KpInt32_t Read_Amount = sizeof(KpInt32_t);
KpInt32_t i, TagArraySize, TagBufferSize;
SpTagRecord_t *TagArray;
if (!SpIsICCProfile(Filename, Props))
return (SpStatBadProfile);
strcpy (name, Filename);
/* Need Header in case we are requesting a Named Color */
HeaderPtr = (SpHeader_t *)NULL;
if (TagId == SpTagNamedColor)
{
HeaderPtr = &Header;
Status = SpProfileLoadHeader(name, Props, HeaderPtr);
}
if (Status == SpStatSuccess)
{
/* Set up for failure - yes I know I'm negative */
Status = SpStatFileNotFound;
#if defined (KPMAC)
SpCvrtSpFileProps(Props, &fileProps);
#endif
if (KpFileOpen(Filename, "r", &fileProps, &FD)) /* 0 = not opened */
{
if (KpFilePosition(FD, FROM_START, FilePosition))
{
Status = SpStatFileReadError;
/* Read TagArraySize into Buffer */
if (KpFileRead(FD, &TagArraySize, &Read_Amount))
{
#if defined (KPLSBFIRST)
/* If we are on a little endian machine we need to do byte swap */
Kp_swab32 (&TagArraySize, 1);
#endif
TagBufferSize = TagArraySize * 3 * 4; /* each entry is 3*4 bytes */
BufferAddress = allocBufferPtr(TagBufferSize);
if (BufferAddress != NULL)
{
if (KpFileRead(FD, BufferAddress, &TagBufferSize))
{
#if defined (KPLSBFIRST)
/* If we are on a little endian machine we need to do byte swap */
Kp_swab32 (BufferAddress, TagBufferSize / sizeof (KpInt32_t));
#endif
TagArray = BufferAddress;
Status = SpStatTagNotFound;
for (i = 0; i < TagArraySize; i++)
{
if (TagId == (SpTagId_t)TagArray[i].Id)
{
Status = SpStatMemory;
TagAddress = allocBufferPtr(TagArray[i].Size);
if (TagAddress != NULL)
{
if (KpFilePosition(FD, FROM_START, TagArray[i].Offset))
{
Read_Amount = TagArray[i].Size;
if (KpFileRead(FD, TagAddress, &Read_Amount))
{
Status = SpTagToPublic(HeaderPtr, TagId,
TagArray[i].Size,
TagAddress, Value);
}
}
freeBufferPtr(TagAddress);
} else
{
Status = SpStatMemory;
break;
}
}
}
}
freeBufferPtr(BufferAddress);
} else /* Buffer Address != 0 */
Status = SpStatMemory;
}
}
/* Close File */
KpFileClose(FD);
}
}
return Status;
}
/*-------------------------------------------------------------------
* init_xfer -- initialize the transfer tables by transferring coarse
* control points from an ICC ResponseRecord
* and interpolating the fine tables from them;
* returns +1 for success, -1 for failure to
* allocate memory for coarse table
*-------------------------------------------------------------------
*/
PTErr_t
init_xfer ( xfer_p xferp,
ResponseRecord_p rrp)
{
PTErr_t PTErr = KCP_SUCCESS;
double val; /* input variables */
KpInt32_t numcoarse; /* number of input control points */
double_p coarse[2]; /* storage for control points */
KpInt32_t i; /* control-point index */
KpInt32_t hint;
KpUInt16_t *pCurveData = NULL;
/* Verify inputs: */
if (xferp == (xfer_p)NULL) return KCP_SYSERR_0;
if (rrp == (ResponseRecord_p)NULL) return KCP_SYSERR_0;
if (PARA_TYPE_SIG == rrp->TagSig)
{
pCurveData = (KpUInt16_p) allocBufferPtr (MFV_CURVE_TBL_ENT*sizeof(KpUInt16_t)); /* get memory for curve data */
if (NULL == pCurveData) {
return KCP_NO_MEMORY;
}
makeCurveFromPara (rrp->ParaFunction, rrp->ParaParams, pCurveData, MFV_CURVE_TBL_ENT);
rrp->CurveCount = MFV_CURVE_TBL_ENT;
rrp->CurveData = pCurveData;
}
if (rrp->CurveCount < 2) {
PTErr = KCP_SYSERR_0;
goto ErrOut;
}
if (rrp->CurveData == (KpUInt16_p)NULL) {
PTErr = KCP_SYSERR_0;
goto ErrOut;
}
/* Allocate space for coarse tables: */
numcoarse = rrp->CurveCount - 1; /* skip zero entry to avoid infinity in logarithm */
coarse[0] = (double_p)ALLOC (numcoarse, sizeof(double));
if (coarse[0] == NULL)
{
PTErr = KCP_NO_MEMORY;
goto ErrOut;
}
coarse[1] = (double_p)ALLOC (numcoarse, sizeof(double));
if (coarse[1] == NULL)
{
DALLOC (coarse[0]); /* release storage */
PTErr = KCP_NO_MEMORY;
goto ErrOut;
}
/* Build coarse tables from ResponseRecord: */
for (i = 0; i < numcoarse; i++)
{
val = (double)(i + 1) / (double)numcoarse; /* skip zero to avoid infinite log */
coarse[0][i] = -log10 (val);
val = (double)rrp->CurveData[i + 1] / SCALEDOT16;
val = MAX (val, 1.0e-12); /* clip to avoid infinite log */
coarse[1][i] = -log10 (val);
}
/* Build fine tables by interpolating in coarse tables: */
hint = 1;
for (i = 0; i < NUMFINE; i++) /* spaced code values */
{
double code;
code = (double)i * 2.4 / (double)(NUMFINE - 1); /* equally spaced in [0, 2.4] */
xferp->nonlinear[i] = code;
xferp->linear[i] = f4l (code, coarse[0], coarse[1], numcoarse, &hint);
}
/* Delete coarse tables: */
DALLOC (coarse[0]);
DALLOC (coarse[1]);
ErrOut:
if (NULL != pCurveData) {
freeBufferPtr (pCurveData);
}
return PTErr;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Unmap an entire file. (WIN32 Version)
*
* AUTHOR
* lsh
*
* DATE CREATED
* November 9, 1993
*------------------------------------------------------------------*/
KpInt32_t KpUnMapFile (KpMapFile_t FAR *MapFileCtl)
{
int Status;
Status = KCMS_IO_SUCCESS;
if (!UnmapViewOfFile (MapFileCtl->Ptr))
Status = KCMS_IO_ERROR;
if (!CloseHandle (MapFileCtl->hMapObject))
Status = KCMS_IO_ERROR;
#if defined(_M_IA64)
if (!CloseHandle (MapFileCtl->hFile)) {
#else /* non-64-bit case */
if (_lclose (MapFileCtl->hFile)) {
#endif /* defined(_M_IA64) */
Status = KCMS_IO_ERROR;
}
return Status;
}
#else
/*--------------------------------------------------------------------
* DESCRIPTION
* Map an entire file.
*
* AUTHOR
* lsh
*
* DATE CREATED
* November 9, 1993
*------------------------------------------------------------------*/
void FAR *KpMapFileEx (
KpChar_p FileName,
KpFileProps_t FAR *FileProps,
KpChar_p Mode,
KpMapFile_t FAR *MapFileCtl)
{
/* validate mode */
switch (*Mode) {
case 'R':
case 'r':
#if 0
case 'w':
#endif
break;
default:
return NULL;
}
/* get the size of the file */
if (!KpFileSize (FileName, FileProps, &MapFileCtl->NumBytes))
return NULL;
/* allocate buffer to hold file */
MapFileCtl->Ptr = allocBufferPtr (MapFileCtl->NumBytes);
if (NULL == MapFileCtl->Ptr)
return NULL;
/* open the file */
if (!KpFileOpen (FileName, Mode, FileProps, &MapFileCtl->Fd)) {
freeBufferPtr (MapFileCtl->Ptr);
return NULL;
}
/* read file into the buffer */
if (!KpFileRead (MapFileCtl->Fd, MapFileCtl->Ptr, &MapFileCtl->NumBytes)) {
freeBufferPtr (MapFileCtl->Ptr);
KpFileClose (MapFileCtl->Fd);
return NULL;
}
/* done with file, close it */
if ('r' == *Mode) {
KpFileClose (MapFileCtl->Fd);
MapFileCtl->Fd = -1;
}
MapFileCtl->Mode = *Mode;
return MapFileCtl->Ptr;
}
/*--------------------------------------------------------------------
* DESCRIPTION
* Map an entire file. (non-win32 version)
*
* AUTHOR
* lsh
*
* DATE CREATED
* November 9, 1993
*------------------------------------------------------------------*/
void FAR *KpMapFile (
KpChar_p FileName,
ioFileChar FAR *FileProps,
KpChar_p Mode,
KpMapFile_t FAR *MapFileCtl)
{
KpFileProps_t kpFileProps, *kpFilePropsPtr;
/* convert FileProps to KpFileProps_t and call
KpMapFileEx */
#if defined (KPMAC) || defined (KPMSMAC)
if (FileProps != NULL) {
kpFileProps.vRefNum = FileProps->vRefNum;
kpFileProps.dirID= 0;
strncpy(kpFileProps.fileType, FileProps->fileType, 5);
strncpy(kpFileProps.creatorType, FileProps->creatorType, 5);
}
else {
kpFileProps.vRefNum = 0;
kpFileProps.dirID= 0;
strncpy(kpFileProps.fileType, " ", 5);
strncpy(kpFileProps.creatorType, " ", 5);
}
kpFilePropsPtr = &kpFileProps;
#else
kpFilePropsPtr = FileProps;
#endif
return (KpMapFileEx (FileName, kpFilePropsPtr, Mode, MapFileCtl) );
}
