/* fut_free_otbl_p This function is passed a fut_otbl_t pointer and handle. If the ref count is zero, the table and the fut_otbl_t is freed. Otherwise the ref count is decremented and the lock state of the fut_otbl_t is returned to it's state on entry. */ static void fut_free_otbl_p ( fut_otbl_p otblPtr, KpHandle_t otblHdl) { fut_otbl_p otbl = otblPtr; if (otblHdl == NULL) { return; } if (otbl == NULL) { /* otbl is unlocked on entry */ otbl = lockBuffer(otblHdl); } if (IS_OTBL(otbl)) { if (otbl->ref == 0) { /* last reference being freed */ freeBuffer(otbl->tblHandle); otbl->magic = 0; freeBufferPtr ((KpGenericPtr_t)otbl); } else { if (otbl->ref > 0) { /* still other references */ otbl->ref--; /* leave in original lock state */ if (otblPtr == NULL) { unlockBuffer(otblHdl); } } } } }
/*-------------------------------------------------------------------- * DESCRIPTION * Delete a profile. If there is a file associated with the profile, * it is also deleted. * * AUTHOR * lsh & mlb * * DATE CREATED * May 4, 1995 *------------------------------------------------------------------*/ SpStatus_t KSPAPI SpProfileDelete ( SpProfile_t FAR *Profile) { KpChar_t *fileName; SpProfileData_t FAR *ProfileData; KpFileProps_t Props; /* convert profile handle to data pointer */ ProfileData = SpProfileLock (*Profile); if (NULL == ProfileData) return SpStatBadProfile; /* lock FileName handle and return ptr */ fileName = (char *) lockBuffer (ProfileData->FileName); #if defined (KPMAC) /* Convert SpIOFileChar_t to KpFileProps_t */ SpCvrtSpFileProps (&(ProfileData->Props), &Props); #endif /* delete associated file name */ if (NULL != fileName) KpFileDelete (fileName, &Props); /* unlock handles */ unlockBuffer (ProfileData->FileName); SpProfileUnlock (*Profile); return SpProfileFree (Profile); }
/* fut_free_gtbl_p This function is passed a fut_gtbl_t pointer and handle. If the ref count is zero, the table and the fut_gtbl_t is freed. Otherwise the ref count is decremented and the lock state of the fut_gtbl_t is returned to it's state on entry. */ static void fut_free_gtbl_p ( fut_gtbl_p gtblP, KpHandle_t gtblHdl) { fut_gtbl_p gtbl = gtblP; if (gtblHdl == NULL) { return; } if (gtbl == NULL) { /* gtbl is unlocked on entry */ gtbl = lockBuffer(gtblHdl); } if (IS_GTBL(gtbl)) { if (gtbl->ref == 0) { fut_free_gtbl(gtbl); /* last reference being freed */ } else { if (gtbl->ref > 0) { /* still other references, leave in original lock state */ gtbl->ref--; if (gtblP == NULL) { unlockBuffer(gtblHdl); } } } } }
/* fut_free_itbl_list_p This function is passed a list of fut_itbl_t pointers and handles. If the ref count is zero, the table and the fut_itbl_t is freed. Otherwise the ref count is decremented and the lock state of the fut_itbl_t is returned to it's state on entry. */ static void fut_free_itbl_list_p ( fut_itbl_p FAR * itbl_list, KpHandle_t FAR * itblHdl_list) { KpInt32_t i; fut_itbl_p itbl; if ((itbl_list == NULL) || (itblHdl_list == NULL)) { return; } for (i = 0; i < FUT_NICHAN; i++) { itbl = itbl_list[i]; if (itbl == NULL) { itbl = lockBuffer (itblHdl_list[i]); } if (IS_ITBL(itbl)) { if (itbl->ref == 0) { fut_free_itbl (itbl); /* last reference being freed */ itbl_list[i] = NULL; itblHdl_list[i] = NULL; } else { if ( itbl->ref > 0 ) { /* still other references */ itbl->ref--; if (itbl_list[i] == NULL) { /* leave in original lock state */ unlockBuffer(itblHdl_list[i]); } } } } } }
/*-------------------------------------------------------------------- * DESCRIPTION (Public) * Return the name of the currently associated file. * * AUTHOR * lsh * * DATE CREATED * September 20, 1993 *------------------------------------------------------------------*/ SpStatus_t KSPAPI SpProfileGetDiskName ( SpProfile_t Profile, size_t BufferSize, KpChar_t *Buffer, SpIOFileChar_t *Props) { char FAR *fileName; SpProfileData_t FAR *ProfileData; /* convert profile handle to data pointer */ ProfileData = SpProfileLock (Profile); if (NULL == ProfileData) return SpStatBadProfile; /* lock FileName handle and return ptr */ fileName = (char *) lockBuffer (ProfileData->FileName); /* check for case of no file name */ if (NULL == fileName) { *Buffer = '\0'; SpProfileUnlock (Profile); return SpStatNoFileName; } /* check for buffer large enough */ if (BufferSize < strlen (fileName) + 1) { unlockBuffer (ProfileData->FileName); SpProfileUnlock (Profile); return SpStatBufferTooSmall; } strcpy (Buffer, fileName); /* Get file properties */ #if defined (KPMAC) SpProfSetSpFileData (&(ProfileData->Props), Props); #endif /* unlock handles */ unlockBuffer (ProfileData->FileName); SpProfileUnlock (Profile); return SpStatSuccess; }
void DepthBuffer32::Clear( boost::uint32_t value ) { boost::uint32_t* bufferPtr = NULL; if( lockBuffer( bufferPtr ) ) { // Loop unrolling via Duff's device // http://en.wikipedia.org/wiki/Duff's_device duff_copy8( value, bufferPtr, getSize() ); unlockBuffer(); } }
/*-------------------------------------------------------------------- * DESCRIPTION (Private -- phase out 5/4/95) * Return the name of the currently associated file. * * AUTHOR * lsh * * DATE CREATED * September 20, 1993 *------------------------------------------------------------------*/ SpStatus_t KSPAPI SpProfileGetFileName ( SpProfile_t Profile, size_t BufferSize, char FAR *Buffer) { char FAR *fileName; SpProfileData_t FAR *ProfileData; /* convert profile handle to data pointer */ ProfileData = SpProfileLock (Profile); if (NULL == ProfileData) return SpStatBadProfile; /* lock FileName handle and return ptr */ fileName = (char *) lockBuffer (ProfileData->FileName); /* check for case of no file name */ if (NULL == fileName) { *Buffer = '\0'; SpProfileUnlock (Profile); return SpStatNoFileName; } /* check for buffer large enough */ if (BufferSize < strlen (fileName) + 1) { unlockBuffer (ProfileData->FileName); SpProfileUnlock (Profile); return SpStatBufferTooSmall; } strcpy (Buffer, fileName); /* unlock handles */ unlockBuffer (ProfileData->FileName); SpProfileUnlock (Profile); return SpStatSuccess; }
void String8::setPathName(const char* name, size_t len) { char* buf = lockBuffer(len); memcpy(buf, name, len); // remove trailing path separator, if present if (len > 0 && buf[len - 1] == OS_PATH_SEPARATOR) len--; buf[len] = '\0'; unlockBuffer(len); }
/* TpWriteHdr writes the header of a fut to an external memory block. */ PTErr_t TpWriteHdr( KpFd_p fd, PTType_t format, KpHandle_t PTHdr, KpInt32_t attrSize) { PTErr_t errnum = KCP_SUCCESS; fut_hdr_p futHdr; switch (format) { case PTTYPE_FUTF: /* get buffer pointer */ futHdr = (fut_hdr_p)lockBuffer (PTHdr); if (futHdr == NULL) { errnum = KCP_MEM_LOCK_ERR; return errnum; } futHdr->idstr_len = attrSize; /* insert size of attributes */ if (fut_write_hdr (fd, futHdr) == 0) { /* and write out the header */ errnum = KCP_PT_HDR_WRITE_ERR; } if ( ! unlockBuffer (PTHdr)) { errnum = KCP_MEM_UNLOCK_ERR; } break; case PTTYPE_MFT1: case PTTYPE_MFT2: case PTTYPE_MFT2_VER_0: errnum = KCP_SUCCESS; break; case PTTYPE_MAB1: case PTTYPE_MAB2: case PTTYPE_MBA1: case PTTYPE_MBA2: errnum = KCP_SUCCESS; break; default: errnum = KCP_INVAL_PTTYPE; break; } return errnum; }
String8& String8::convertToResPath() { #if OS_PATH_SEPARATOR != RES_PATH_SEPARATOR size_t len = length(); if (len > 0) { char * buf = lockBuffer(len); for (char * end = buf + len; buf < end; ++buf) { if (*buf == OS_PATH_SEPARATOR) *buf = RES_PATH_SEPARATOR; } unlockBuffer(len); } #endif return *this; }
// *************************************************************************** void CVegetableVBAllocator::deleteVertexBufferHard() { // must unlock VBhard before. unlockBuffer(); // test (refptr) if the object still exist in memory. if(_VBHard.getNumVertices()!=0) { // A vbufferhard should still exist only if driver still exist. nlassert(_Driver!=NULL); // delete it from driver. _VBHard.deleteAllVertices (); } }
// *************************************************************************** void CVegetableVBAllocator::lockBuffer() { // force unlock unlockBuffer(); // need to lock only if the VBHard is created if(_VBHardOk) { // lock the VBHard for writing _VBHard.lock(_VBAHard); _AGPBufferPtr=(uint8*)_VBAHard.getVertexCoordPointer(); // lock the Input VertexBuffer for reading _VBSoft.lock(_VBASoft); _RAMBufferPtr=(const uint8*)_VBASoft.getVertexCoordPointer(); } }
/*-------------------------------------------------------------------- * DESCRIPTION (Public) * Set the name of the file to associate with the profile. * If the Name is NULL no file will be associated with the profile. * * AUTHOR * lsh & mlb * * DATE Copied * November 15, 1995 *------------------------------------------------------------------*/ SpStatus_t KSPAPI SpProfileSetName ( SpProfile_t Profile, KpChar_t *FileName, SpFileProps_t *Props) { char FAR *fileName; SpProfileData_t FAR *ProfileData; SpStatus_t status; /* convert profile handle to data pointer */ ProfileData = SpProfileLock (Profile); if (NULL == ProfileData) return SpStatBadProfile; /* Free current FileName if one is there */ if (ProfileData->FileName != NULL) { if (ProfileData->TagArray == NULL) status = SpProfilePopTagArray(ProfileData); freeBuffer(ProfileData->FileName); } /* create the FileName handle */ ProfileData->FileName = allocBufferHandle (strlen (FileName) + 1); if (ProfileData->FileName == NULL) return SpStatMemory; /* lock FileName handle and return ptr */ fileName = (char *) lockBuffer (ProfileData->FileName); if (fileName == NULL) return SpStatMemory; /* copy text data into the newly allocated space */ strcpy (fileName, FileName); /* Copy props information into internal profile data structure */ #if defined (KPMAC) SpProfSetSpFileProps (Props, &(ProfileData->Props)); #endif /* unlock handles */ unlockBuffer (ProfileData->FileName); SpProfileUnlock (Profile); return SpStatSuccess; }
/* unlock header and data of a PT */ PTErr_t unlockPT ( KpHandle_t PTHdr, fut_p fut) { PTErr_t errnum = KCP_SUCCESS; if (fut_unlock_fut (fut) == NULL) { errnum = KCP_PTERR_1; } else { if ( ! unlockBuffer (PTHdr)) { errnum = KCP_MEM_UNLOCK_ERR; } } return errnum; }
/*-------------------------------------------------------------------- * DESCRIPTION * Iterate over all the tags in a profile. Call user supplied * function with the Id of each tag. * * AUTHOR * lsh * * DATE CREATED * July 7, 1994 *------------------------------------------------------------------*/ SpStatus_t KSPAPI SpTagIter ( SpProfile_t Profile, SpTagIter_t TagIterFunc, void FAR *Data) { KpInt32_t index; SpProfileData_t FAR *ProfileData; SpTagDirEntry_t FAR *tagArray; SpStatus_t Status; /* convert profile handle to pointer to locked memory */ ProfileData = SpProfileLock (Profile); if (NULL == ProfileData) return SpStatBadProfile; Status = SpDoIter ( TagIterFunc, SpIterInit, NULL, 0, Data); /* Check if Profile found via Search function */ if (ProfileData->TagArray == NULL) /* If so, it needs the Tag Array Loaded */ SpProfilePopTagArray(ProfileData); for (index = 0; (index < ProfileData->TotalCount) && (Status == SpStatSuccess); index++) { /* User Callback Function could unlock since the Profile is available, so lock before calling */ /* lock TagArray handle and return ptr */ tagArray = (SpTagDirEntry_t FAR *) lockBuffer (ProfileData->TagArray); /* call users function ONLY IF VALID ENTRY */ if (tagArray[index].TagDataSize != -1) Status = SpDoIter(TagIterFunc, SpIterProcessing, Profile, tagArray[index].TagId, Data); } unlockBuffer (ProfileData->TagArray); SpDoIter ( TagIterFunc, SpIterTerm, NULL, 0, Data); SpProfileUnlock (Profile); return Status; }
/*-------------------------------------------------------------------- * DESCRIPTION * Convert Profile handle to pointer to locked profile data. * * AUTHOR * lsh * * DATE CREATED * September 20, 1993 *------------------------------------------------------------------*/ SpProfileData_t FAR *SpProfileLock (SpProfile_t Profile) { SpProfileData_t FAR *ProfileData; ProfileData = lockBuffer ((KcmHandle) Profile); if (NULL != ProfileData) { #if defined(KPMAC) /* increment the lock counter */ ProfileData->LockCount++; #endif if (SpProfileDataSig != ProfileData->Signature) { unlockBuffer ((KcmHandle) Profile); return NULL; } } return ProfileData; }
/*-------------------------------------------------------------------- * DESCRIPTION * This function inverts the input tables of a PT * * AUTHOR * PGT * * DATE CREATED * May 11, 1994 *--------------------------------------------------------------------*/ static PTErr_t InvertInputTables ( PTRefNum_t refNum, KpInt32_t numOutChan, KpInt32_t FAR *numInVar) { KpInt32_t in, out, k; PTErr_t cpStatus; KcmHandle refTblHandle; mf2_tbldat_p refTbl; mf2_tbldat_t refTblTemp; KcmHandle tblList[FUT_NOCHAN * FUT_NICHAN]; KpInt32_t numTbls, refTblEntries; /* Get each table, invert if not already inverted */ cpStatus = KCP_SUCCESS; for (out = 0, numTbls = 0; (out < numOutChan) && (cpStatus == KCP_SUCCESS); ++out) { for (in = 0; (in < numInVar [out]) && (cpStatus == KCP_SUCCESS); ++in) { cpStatus = getRefTbl (FUT_IMAGIC, refNum, in, out, &refTblHandle, &refTblEntries); if (cpStatus == KCP_NO_INTABLE) { /* no input tbl, ignore */ cpStatus = KCP_SUCCESS; } else { if ((cpStatus == KCP_SUCCESS) && (UniqueTable (refTblHandle, tblList, numTbls))) { refTbl = lockBuffer (refTblHandle); if (refTbl != NULL) { tblList [numTbls++] = refTblHandle; /* save address to avoid multiple inversion */ for (k = 0; k < refTblEntries/2; ++k) { /* invert the table */ refTblTemp = refTbl [k]; /* by reversing the order of the entries */ refTbl [k] = refTbl [refTblEntries-1-k]; refTbl [refTblEntries-1-k] = refTblTemp; } unlockBuffer (refTblHandle); } else { cpStatus = KCP_MEM_LOCK_ERR; } } } } } return cpStatus; }
void GraphicsDeviceGL_1_3::drawVirtualScreen() { glViewport( m_virtualViewport[0], m_virtualViewport[1], m_virtualViewport[2], m_virtualViewport[3] ); //update the video memory framebuffer. lockBuffer(); if (m_writeFrame > m_renderFrame) { m_videoFrameBuffer->update( m_frameWidth, m_frameHeight, m_frameBuffer_32bpp[m_writeBufferIndex] ); } m_renderFrame = m_writeFrame; unlockBuffer(); enableBlending(false); drawFullscreenQuad(m_videoFrameBuffer); glViewport( m_fullViewport[0], m_fullViewport[1], m_fullViewport[2], m_fullViewport[3] ); }
void String8::toUpper(size_t start, size_t length) { const size_t len = size(); if (start >= len) { return; } if (start + length > len) { length = len - start; } char* buf = lockBuffer(len); buf += start; while (length > 0) { *buf = toupper(*buf); buf++; length--; } unlockBuffer(len); }
void GraphicsDeviceOGL::convertFrameBufferTo32bpp(u8* source, u32* pal) { lockBuffer(); const s32 curIndex = m_bufferIndex; u32 *dest = m_frameBuffer_32bpp[curIndex]; u32 pixelCount = m_frameWidth*m_frameHeight; for (u32 p=0; p<pixelCount; p++) { *dest = pal[ *source ]; dest++; source++; } m_writeBufferIndex = m_bufferIndex; m_bufferIndex = (m_bufferIndex+1)&1; m_writeFrame++; unlockBuffer(); }
// *************************************************************************** void CVegetableVBAllocator::clear() { // clear list. _VertexFreeMemory.clear(); _NumVerticesAllocated= 0; // must unlock for vbhard and vbsoft unlockBuffer(); // delete the VB. deleteVertexBufferHard(); // really delete the VB soft too _VBSoft.deleteAllVertices(); // clear other states. _Driver= NULL; _VBHardOk= false; }
/*-------------------------------------------------------------------- * DESCRIPTION * Unlock profile data. * * AUTHOR * lsh * * DATE CREATED * September 20, 1993 *------------------------------------------------------------------*/ void SpProfileUnlock (SpProfile_t Profile) { #if defined(KPMAC) SpProfileData_t FAR *ProfileData; if (NULL == Profile) return; ProfileData = *((SpProfileData_t FAR **) Profile); ProfileData->LockCount--; /* lockCount == 0 means that we need to fully unlock the handle */ if(ProfileData->LockCount == 0) #endif unlockBuffer ((KcmHandle) Profile); }
/*-------------------------------------------------------------------- * DESCRIPTION * This function inverts the output tables of a PT * * AUTHOR * PGT * * DATE CREATED * May 11, 1994 *--------------------------------------------------------------------*/ static PTErr_t InvertOutputTables ( PTRefNum_t refNum, KpInt32_t numOutChan) { KpInt32_t i, k; PTErr_t cpStatus; KcmHandle refTblHandle; KcmHandle tblList[FUT_NOCHAN]; mf2_tbldat_p refTbl; KpInt32_t numTbls, refTblEntries, dummy = 0; /* Get each table, invert if not already inverted */ cpStatus = KCP_SUCCESS; numTbls = 0; for (i = 0; (i < numOutChan) && (cpStatus == KCP_SUCCESS); ++i) { cpStatus = getRefTbl (FUT_OMAGIC, refNum, dummy, i, &refTblHandle, &refTblEntries); if (cpStatus == KCP_NO_OUTTABLE) { cpStatus = KCP_SUCCESS; } else { if ((cpStatus == KCP_SUCCESS) && (UniqueTable (refTblHandle, tblList, numTbls))) { refTbl = lockBuffer (refTblHandle); if (refTbl != NULL) { tblList [numTbls++] = refTblHandle; /* save address to avoid multiple inversion */ for (k = 0; k < refTblEntries; ++k ) { /* invert the table */ refTbl[k] = (mf2_tbldat_t)(MF2_TBL_MAXVAL - refTbl[k]); /* by negating the contents of each entry */ } unlockBuffer (refTblHandle); } else { cpStatus = KCP_MEM_LOCK_ERR; } } } } return cpStatus; }
/*-------------------------------------------------------------------- * DESCRIPTION (Private -- phase out 5/4/95) * Set the name of the file to associate with the profile. * If the Name is NULL no file will be associated with the profile. * * AUTHOR * lsh * * DATE CREATED * Octorber 22, 1993 *------------------------------------------------------------------*/ SpStatus_t KSPAPI SpProfileSetFileName ( SpProfile_t Profile, char FAR *FileName) { char FAR *fileName; SpProfileData_t FAR *ProfileData; /* convert profile handle to data pointer */ ProfileData = SpProfileLock (Profile); if (NULL == ProfileData) return SpStatBadProfile; /* Free current FileName if one is there */ if (ProfileData->FileName != NULL) freeBuffer(ProfileData->FileName); /* create the FileName handle */ ProfileData->FileName = allocBufferHandle (strlen (FileName) + 1); if (ProfileData->FileName == NULL) return (SpStatMemory); /* lock FileName handle and return ptr */ fileName = (char *) lockBuffer (ProfileData->FileName); if (fileName == NULL) return (SpStatMemory); /* copy text data into the newly allocated space */ strcpy (fileName, FileName); #if defined (KPMAC) SpProfileClearProps(&(ProfileData->Props)); #endif /* unlock handles */ unlockBuffer (ProfileData->FileName); SpProfileUnlock (Profile); return SpStatSuccess; }
bool String8::removeAll(const char* other) { ssize_t index = find(other); if (index < 0) return false; char* buf = lockBuffer(size()); if (!buf) return false; // out of memory size_t skip = strlen(other); size_t len = size(); size_t tail = index; while (size_t(index) < len) { ssize_t next = find(other, index + skip); if (next < 0) { next = len; } memmove(buf + tail, buf + index + skip, next - index - skip); tail += next - index - skip; index = next; } unlockBuffer(tail); return true; }
String8& String8::appendPath(const char* name) { // TODO: The test below will fail for Win32 paths. Fix later or ignore. if (name[0] != OS_PATH_SEPARATOR) { if (*name == '\0') { // nothing to do return *this; } size_t len = length(); if (len == 0) { // no existing filename, just use the new one setPathName(name); return *this; } // make room for oldPath + '/' + newPath int newlen = strlen(name); char* buf = lockBuffer(len + 1 + newlen); // insert a '/' if needed if (buf[len - 1] != OS_PATH_SEPARATOR) buf[len++] = OS_PATH_SEPARATOR; memcpy(buf + len, name, newlen + 1); len += newlen; unlockBuffer(len); return *this; } else { setPathName(name); return *this; } }
void String8::unlockBuffer() { unlockBuffer(strlen(mString)); }
/* verify that two header info blocks are the same */ PTErr_t TpCompareHdr ( KpHandle_t PTHdr1, KpHandle_t PTHdr2) { PTErr_t errnum = KCP_SUCCESS; KpInt32_t i1, i2; chan_hdr_p chanf, chani; fut_hdr_p futHdr1, futHdr2; if (PTHdr1 == PTHdr2) { return (KCP_SUCCESS); } futHdr1 = (fut_hdr_p)lockBuffer (PTHdr1); /* get header pointer 1 */ if (futHdr1 == NULL) { errnum = KCP_MEM_LOCK_ERR; goto GetOut; } futHdr2 = (fut_hdr_p)lockBuffer (PTHdr2); /* get header pointer 2 */ if (futHdr2 == NULL) { errnum = KCP_MEM_LOCK_ERR; goto GetOut; } if ( (futHdr1->magic != futHdr2->magic) || (futHdr1->version != futHdr2->version) || (futHdr1->order != futHdr2->order)) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } switch (futHdr1->magic) { case FUT_CIGAM: /* fut with bytes reversed */ case FUT_MAGIC: /* fut with bytes in correct order */ for (i1 = 0; i1 < FUT_NCHAN; i1++) { if (futHdr1->icode[i1] != futHdr2->icode[i1]) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } } for (i1=0, chanf=futHdr1->chan, chani=futHdr2->chan; i1<FUT_NCHAN; ++i1, chanf++, chani++) { if (chanf->gcode != chani->gcode) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } if (chanf->gcode != 0) { /* if the channel is defined */ for (i2 = 0; i2 < FUT_NCHAN; i2++) { if (chanf->icode[i2] != chani->icode[i2]) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } /* if this input is defined */ if (chanf->icode[i2] != FUTIO_NULL) { if (chanf->size[i2] != chani->size[i2]) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } } } if (chanf->ocode != chani->ocode) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } } } if (futHdr1->more != futHdr2->more) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } break; case PTTYPE_MFT1: /* 8 bit matrix fut */ case PTTYPE_MFT2: /* 16 bit matrix fut */ case PTTYPE_MA2B: case PTTYPE_MB2A: for (i1 = 0; i1 < 2; i1++) { if (futHdr1->icode[i1] != futHdr2->icode[i1]) { errnum = KCP_INCON_PT; /* no match */ goto GetOut; } } break; default: return (KCP_INVAL_PT_BLOCK); /* unknown type */ } GetOut: if ( ! unlockBuffer (PTHdr1)) { errnum = KCP_MEM_UNLOCK_ERR; } if ( ! unlockBuffer (PTHdr2)) { errnum = KCP_MEM_UNLOCK_ERR; } return errnum; }
/* TpReadData reads a fut from a memory block and returns a handle to a newly allocated fut */ PTErr_t TpReadData( KpFd_p fd, PTType_t format, PTRefNum_t PTRefNum, KpHandle_t PTHdr, KpHandle_t FAR* PTData) { PTErr_t errnum; fut_p fut = NULL, theFutFromMatrix = NULL, newFut = NULL, lab2xyzFut = NULL, finalFut = NULL; fut_hdr_p futHdr; Fixed_t matrix[MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM]; KpInt32_t ret, iomask; KpChar_t ENUM_String[20]; KpInt32_t inCS, i, i1; ResponseRecord_t inRedTRC, inGreenTRC, inBlueTRC; ResponseRecord_t outRedTRC, outGreenTRC, outBlueTRC; PTRefNum_t matrixPTRefNum; PTDataClass_t iClass, oClass; futHdr = (fut_hdr_p) lockBuffer (PTHdr); /* get buffer pointer */ if (futHdr == NULL) { errnum = KCP_MEM_LOCK_ERR; goto GetOut; } futHdr->profileType = getIntAttrDef (PTRefNum, KCM_ICC_PROFILE_TYPE); futHdr->spaceIn = getIntAttrDef (PTRefNum, KCM_SPACE_IN); futHdr->spaceOut = getIntAttrDef (PTRefNum, KCM_SPACE_OUT); futHdr->iDataClass = getDataClass (futHdr->spaceIn); futHdr->oDataClass = getDataClass (futHdr->spaceOut); switch (format) { case FUT_CIGAM: /* fut with bytes reversed */ case FUT_MAGIC: /* fut with bytes in correct order */ if ((fut = fut_alloc_fut ()) == NULL) { /* allocate a new fut structure */ errnum = KCP_NO_ACTIVATE_MEM; } else { if (fut_read_tbls (fd, fut, futHdr) != 1) { /* read fut tables */ errnum = KCP_PT_DATA_READ_ERR; } else { if (fut_io_decode (fut, futHdr) == 0) { errnum = KCP_PTERR_0; } else { errnum = KCP_SUCCESS; } } } break; case PTTYPE_MFT1: case PTTYPE_MFT2: fut = fut_readMFutTbls (fd, futHdr, matrix); /* read matrix fut tables */ if (fut == NULL) { errnum = KCP_NO_ACTIVATE_MEM; } else { inCS = getIntAttrDef (PTRefNum, KCM_SPACE_IN); if ((inCS == KCM_CIE_XYZ) && (isIdentityMatrix (matrix, MF_MATRIX_DIM) != 1)) { ret = makeOutputMatrixXform ((Fixed_p)&matrix, 8, &theFutFromMatrix); if (ret != 1) { errnum = KCP_INCON_PT; goto GetOut; } else { iomask = FUT_PASS(FUT_XYZ); /* get the Lab to XYZ fut */ lab2xyzFut = get_lab2xyz (KCP_GRID_DIM_SIXTEEN); newFut = fut_comp (theFutFromMatrix, lab2xyzFut, iomask); if (newFut != NULL) { finalFut = fut_comp (fut, newFut, iomask); } fut_free (theFutFromMatrix); /* free intermediate futs */ fut_free (lab2xyzFut); fut_free (fut); fut_free (newFut); fut = finalFut; /* set the input color space attribute to Lab */ KpItoa (KCM_CIE_LAB, ENUM_String); errnum = PTSetAttribute (PTRefNum, KCM_SPACE_IN, ENUM_String); if (errnum != KCP_SUCCESS) { goto GetOut; } /* set the input composition attribute to Lab */ errnum = PTSetAttribute (PTRefNum, KCM_IN_CHAIN_CLASS_2, "6"); if (errnum != KCP_SUCCESS) { goto GetOut; } } } if ((fut == NULL) || !fut_io_encode (fut, futHdr)) { /* make the info header */ errnum = KCP_INCON_PT; goto GetOut; } errnum = KCP_SUCCESS; } break; case PTTYPE_MA2B: case PTTYPE_MB2A: matrix[0] = matrix[4] = matrix[8] = KpF15d16FromDouble(1.0); matrix[1] = matrix[2] = matrix[3] = matrix[5] = matrix[6] = matrix[7] = matrix[9] = matrix[10] = matrix[11] = KpF15d16FromDouble(0.0); fut = fut_readMabFutTbls (fd, futHdr, matrix); /* read matrix fut tables */ if (fut == NULL) { errnum = KCP_NO_ACTIVATE_MEM; } else { if (fut->lutConfig & HAS_MATRIX_DATA) { i = MF_MATRIX_DIM * MF_MATRIX_DIM + MF_MATRIX_DIM; for (i1 = 0; i1 < i; i1++) { fut->matrix[i1] = matrix[i1]; } switch (fut->lutConfig) { case MAB_M_MATRIX_B_COMBO: case MBA_B_MATRIX_M_COMBO: inRedTRC.CurveCount = fut->mabInTblEntries[0]; inGreenTRC.CurveCount = fut->mabInTblEntries[1]; inBlueTRC.CurveCount = fut->mabInTblEntries[2]; inRedTRC.CurveData = fut->mabInRefTbl[0]; inGreenTRC.CurveData = fut->mabInRefTbl[1]; inBlueTRC.CurveData = fut->mabInRefTbl[2]; outRedTRC.CurveCount = fut->mabOutTblEntries[0]; outGreenTRC.CurveCount = fut->mabOutTblEntries[1]; outBlueTRC.CurveCount = fut->mabOutTblEntries[2]; outRedTRC.CurveData = fut->mabOutRefTbl[0]; outGreenTRC.CurveData = fut->mabOutRefTbl[1]; outBlueTRC.CurveData = fut->mabOutRefTbl[2]; iClass = getDataClass(futHdr->spaceIn); oClass = getDataClass(futHdr->spaceOut); ret = makeFutFromMatrix ((Fixed_p)&matrix, &inRedTRC, &inGreenTRC, &inBlueTRC, &outRedTRC, &outGreenTRC, &outBlueTRC, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix); break; case MBA_B_MATRIX_M_CLUT_A_COMBO: inRedTRC.CurveCount = fut->mabInTblEntries[0]; inGreenTRC.CurveCount = fut->mabInTblEntries[1]; inBlueTRC.CurveCount = fut->mabInTblEntries[2]; inRedTRC.CurveData = fut->mabInRefTbl[0]; inGreenTRC.CurveData = fut->mabInRefTbl[1]; inBlueTRC.CurveData = fut->mabInRefTbl[2]; iClass = getDataClass(futHdr->spaceIn); oClass = KCP_UNKNOWN; ret = makeFutFromMatrix ((Fixed_p)&matrix, &inRedTRC, &inGreenTRC, &inBlueTRC, NULL, NULL, NULL, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix); break; case MAB_A_CLUT_M_MATRIX_B_COMBO: outRedTRC.CurveCount = fut->mabOutTblEntries[0]; outGreenTRC.CurveCount = fut->mabOutTblEntries[1]; outBlueTRC.CurveCount = fut->mabOutTblEntries[2]; outRedTRC.CurveData = fut->mabOutRefTbl[0]; outGreenTRC.CurveData = fut->mabOutRefTbl[1]; outBlueTRC.CurveData = fut->mabOutRefTbl[2]; iClass = KCP_UNKNOWN; oClass = getDataClass(futHdr->spaceOut); ret = makeFutFromMatrix ((Fixed_p)&matrix, NULL, NULL, NULL, &outRedTRC, &outGreenTRC, &outBlueTRC, MATRIX_GRID_SIZE, iClass, oClass, (fut_p *)&theFutFromMatrix); break; default: break; } if (NULL != theFutFromMatrix) { /* Create a PT from the fut */ errnum = fut2PT (&theFutFromMatrix, KCM_UNKNOWN, KCM_UNKNOWN, PTTYPE_CALCULATED, &matrixPTRefNum); if (errnum != KCP_SUCCESS) { goto GetOut; } errnum = setMatrixPTRefNum (PTRefNum, matrixPTRefNum, fut->lutConfig); if (errnum != KCP_SUCCESS) { goto GetOut; } } if (ret != 1) { errnum = KCP_INCON_PT; goto GetOut; } } if ((fut == NULL) || !fut_io_encode (fut, futHdr)) { /* make the info header */ errnum = KCP_INCON_PT; goto GetOut; } errnum = KCP_SUCCESS; } break; default: break; } GetOut: if ((errnum != KCP_SUCCESS) || (fut == NULL)) { fut_free (fut); } else { /* return handle to fut to caller */ /* make sure the futs are in the reference state */ if (fut_to_mft (fut) == 1) { *PTData = (KpHandle_t)fut_unlock_fut (fut); } } if ( ! unlockBuffer (PTHdr)) { errnum = KCP_MEM_UNLOCK_ERR; } return errnum; }
KpInt32_t unlockSysBuffer (KpHandle_t handle) { return (unlockBuffer (handle)); }