fragment.h File Reference

#include "Defines.h"
#include "GenLuts.h"

Go to the source code of this file.

Functions
icCurveType *	InvertLut1d (icCurveType *LookUpTable, UINT8 AdressBits)
CMError	CombiMatrix (icXYZType srcColorantData[3], icXYZType destColorantData[3], double resMatrix[3][3])
Boolean	doubMatrixInvert (double MatHin[3][3], double MatRueck[3][3])
CMError	Fill_ushort_ELUT_identical (UINT16 *usELUT, char addrBits, char usedBits, long gridPoints)
CMError	Fill_ushort_ELUT_from_CurveTag (icCurveType *pCurveTag, UINT16 *usELUT, char addrBits, char usedBits, long gridPoints)
CMError	Fill_inverse_byte_ALUT_from_CurveTag (icCurveType *pCurveTag, UINT8 *ucALUT, char addrBits)
CMError	Fill_inverse_ushort_ALUT_from_CurveTag (icCurveType *pCurveTag, unsigned short *usALUT, char addrBits)
CMError	Fill_ushort_ELUTs_from_lut8Tag (CMLutParamPtr theLutData, Ptr profileELuts, char addrBits, char usedBits, long gridPoints)
CMError	Fill_byte_ALUTs_from_lut8Tag (CMLutParamPtr theLutData, Ptr profileALuts, char addrBits)
CMError	Fill_ushort_ALUTs_from_lut8Tag (CMLutParamPtr theLutData, Ptr profileALuts, char addrBits)
CMError	Fill_ushort_ELUTs_from_lut16Tag (CMLutParamPtr theLutData, Ptr profileELuts, char addrBits, char usedBits, long gridPoints, long inputTableEntries)
CMError	Fill_byte_ALUTs_from_lut16Tag (CMLutParamPtr theLutData, Ptr profileALuts, char addrBits, long outputTableEntries)
CMError	Fill_ushort_ALUTs_from_lut16Tag (CMLutParamPtr theLutData, Ptr profileALuts, char addrBits, long outputTableEntries)
CMError	MakeGamut16or32ForMonitor (icXYZType *pRedXYZ, icXYZType *pGreenXYZ, icXYZType *pBlueXYZ, CMLutParamPtr theLutData, Boolean cube32Flag)
CMError	DoAbsoluteShiftForPCS_Cube16 (unsigned short *theCube, long count, CMProfileRef theProfile, Boolean pcsIsXYZ, Boolean afterInput)

---

Function Documentation

CMError CombiMatrix (  icXYZType  srcColorantData[3], icXYZType  destColorantData[3], double  resMatrix[3][3] )

Definition at line 317 of file lh_core/fragment.c. { short i, j; double straightMat[3][3], invMat[3][3]; CMError err = noErr; LH_START_PROC("CombiMatrix") /* RGB -> XYZ for first profile: */ straightMat[0][0] = (double)srcColorantData[0].data.data[0].X; straightMat[1][0] = (double)srcColorantData[0].data.data[0].Y; straightMat[2][0] = (double)srcColorantData[0].data.data[0].Z; straightMat[0][1] = (double)srcColorantData[1].data.data[0].X; straightMat[1][1] = (double)srcColorantData[1].data.data[0].Y; straightMat[2][1] = (double)srcColorantData[1].data.data[0].Z; straightMat[0][2] = (double)srcColorantData[2].data.data[0].X; straightMat[1][2] = (double)srcColorantData[2].data.data[0].Y; straightMat[2][2] = (double)srcColorantData[2].data.data[0].Z; /* RGB -> XYZ for 2nd profile, store in resMatrix prelim.: */ resMatrix[0][0] = (double)destColorantData[0].data.data[0].X; resMatrix[1][0] = (double)destColorantData[0].data.data[0].Y; resMatrix[2][0] = (double)destColorantData[0].data.data[0].Z; resMatrix[0][1] = (double)destColorantData[1].data.data[0].X; resMatrix[1][1] = (double)destColorantData[1].data.data[0].Y; resMatrix[2][1] = (double)destColorantData[1].data.data[0].Z; resMatrix[0][2] = (double)destColorantData[2].data.data[0].X; resMatrix[1][2] = (double)destColorantData[2].data.data[0].Y; resMatrix[2][2] = (double)destColorantData[2].data.data[0].Z; if( !doubMatrixInvert(resMatrix, invMat) ) { #ifdef DEBUG_OUTPUT if ( DebugCheck(kThisFile, kDebugErrorInfo) ) DebugPrint("¥ CombiMatrix-Error: doubMatrixInvert failed \n"); #endif err = cmparamErr; goto CleanupAndExit; } for(i=0; i<3; i++) for(j=0; j<3; j++) resMatrix[i][j] = straightMat[i][0] * invMat[0][j] + straightMat[i][1] * invMat[1][j] + straightMat[i][2] * invMat[2][j]; CleanupAndExit: LH_END_PROC("CombiMatrix") return err; }

CMError DoAbsoluteShiftForPCS_Cube16 (  unsigned short *  theCube, long  count, CMProfileRef  theProfile, Boolean  pcsIsXYZ, Boolean  afterInput )

Definition at line 518 of file lh_core/frgmnt16.c. { unsigned long i, uLong; unsigned short *usPtr; CMError err = noErr; unsigned long elementSize; icXYZType curMediaWhite; double xFactor, yFactor, zFactor; unsigned long intFactorX, intFactorY, intFactorZ; unsigned long roundX, roundY, roundZ; unsigned long shiftX, shiftY, shiftZ; LH_START_PROC("DoAbsoluteShiftForPCS_Cube16") elementSize = sizeof(icXYZType); err = CMGetProfileElement(theProfile, icSigMediaWhitePointTag, &elementSize, &curMediaWhite); #ifdef IntelMode SwapLongOffset( &curMediaWhite.base.sig, 0, 4 ); SwapLongOffset( &curMediaWhite, (LONG)((char*)&curMediaWhite.data.data[0]-(char*)&curMediaWhite), elementSize ); #endif if(err) { if(err == cmElementTagNotFound) /* take D50 and do nothing */ return(noErr); else return(err); } /*--- preliminary matching factors: ---*/ xFactor = ((double)curMediaWhite.data.data[0].X) / 65536. / 0.9642; if(xFactor > 100.) xFactor = 100.; /* evil profile */ else if(xFactor < 0.01) xFactor = 0.01; yFactor = ((double)curMediaWhite.data.data[0].Y) / 65536.; if(yFactor > 100.) yFactor = 100.; else if(yFactor < 0.01) yFactor = 0.01; zFactor = ((double)curMediaWhite.data.data[0].Z) / 65536. / 0.8249; if(zFactor > 100.) zFactor = 100.; else if(zFactor < 0.01) zFactor = 0.01; if( ( xFactor < 1.+1.E-3 && xFactor > 1.-1.E-3 ) && ( yFactor < 1.+1.E-3 && yFactor > 1.-1.E-3 ) && ( zFactor < 1.+1.E-3 && zFactor > 1.-1.E-3 ) ) return noErr; /* do nothing if MediaWhite is D50 */ if(!afterInput) /* back to device space (for example with B2A1 table) */ { xFactor = 1. / xFactor; yFactor = 1. / yFactor; zFactor = 1. / zFactor; } /*--- integer factors for speed: ---*/ intFactorX = (unsigned long)(xFactor * 65536. * 64.); /* probably too long... */ intFactorY = (unsigned long)(yFactor * 65536. * 64.); /* ...adding 22 bits */ intFactorZ = (unsigned long)(zFactor * 65536. * 64.); roundX = roundY = roundZ = 0x1FFFFF; /* 2^21 - 1 */ shiftX = shiftY = shiftZ = 22; while(intFactorX & 0xFFFF0000) /* stay within 16 bits to prevent product overflow */ { intFactorX >>= 1; roundX >>= 1; shiftX -= 1; } while(intFactorY & 0xFFFF0000) { intFactorY >>= 1; roundY >>= 1; shiftY -= 1; } while(intFactorZ & 0xFFFF0000) { intFactorZ >>= 1; roundZ >>= 1; shiftZ -= 1; } /*--- perform matching: ---*/ if(!pcsIsXYZ) /* 16 bit linear Lab to XYZ before and afterwards */ Lab2XYZ_forCube16(theCube, count); usPtr = theCube; for(i=0; i<(unsigned long)count; i++) { uLong = ((unsigned long)(*usPtr) * intFactorX + roundX) >> shiftX; if(uLong > 0x0FFFF) uLong = 0xFFFF; /* clip to 2.0 */ *usPtr++ = (unsigned short)uLong; uLong = ((unsigned long)(*usPtr) * intFactorY + roundY) >> shiftY; if(uLong > 0x0FFFF) uLong = 0xFFFF; *usPtr++ = (unsigned short)uLong; uLong = ((unsigned long)(*usPtr) * intFactorZ + roundZ) >> shiftZ; if(uLong > 0x0FFFF) uLong = 0xFFFF; *usPtr++ = (unsigned short)uLong; } if(!pcsIsXYZ) /* back to 16 bit Lab */ XYZ2Lab_forCube16(theCube, count); LH_END_PROC("DoAbsoluteShiftForPCS_Cube16") return(noErr); }

Boolean doubMatrixInvert (  double  MatHin[3][3], double  MatRueck[3][3] )

Definition at line 389 of file lh_core/fragment.c. { double detm, hilf1, hilf2, hilf3, hilf4, hilf5, hilf6; double *a; Boolean success = TRUE; #ifdef DEBUG_OUTPUT CMError err=noErr; #endif LH_START_PROC("doubMatrixInvert") a = (double *)MatHin; hilf1 = a[0] * a[4]; hilf2 = a[1] * a[5]; hilf3 = a[2] * a[3]; hilf4 = a[2] * a[4]; hilf5 = a[1] * a[3]; hilf6 = a[0] * a[5]; detm = hilf1 * a[8] + hilf2 * a[6] + hilf3 * a[7] - hilf4 * a[6] - hilf5 * a[8] - hilf6 * a[7]; /* if(fabs(detm) < 1.E-9) */ if ( (detm < 1.E-9) && (detm > -1.E-9) ) success = FALSE; else { detm = 1. / detm; MatRueck[0][0] = (a[4] * a[8] - a[5] * a[7]) * detm; MatRueck[0][1] = (a[7] * a[2] - a[8] * a[1]) * detm; MatRueck[0][2] = (hilf2 - hilf4 ) * detm; MatRueck[1][0] = (a[5] * a[6] - a[3] * a[8]) * detm; MatRueck[1][1] = (a[8] * a[0] - a[6] * a[2]) * detm; MatRueck[1][2] = (hilf3 - hilf6 ) * detm; MatRueck[2][0] = (a[3] * a[7] - a[4] * a[6]) * detm; MatRueck[2][1] = (a[6] * a[1] - a[7] * a[0]) * detm; MatRueck[2][2] = (hilf1 - hilf5 ) * detm; } LH_END_PROC("doubMatrixInvert") return(success); }

CMError Fill_byte_ALUTs_from_lut16Tag (  CMLutParamPtr  theLutData, Ptr  profileALuts, char  addrBits, long  outputTableEntries )

Definition at line 1237 of file lh_core/fragment.c. { long i, j; UINT16 *curOutLut; UINT8 *curALUT; long count, clipIndex, outTabLen; long indFactor, fract, baseInd, lAux; UINT16 *profALUTs = (UINT16*)profileALuts; OSErr err = noErr; LUT_DATA_TYPE localAlut = nil; UINT8 *localAlutPtr; long theAlutSize; LH_START_PROC("Fill_byte_ALUTs_from_lut16Tag") count = 1 << addrBits; /* addrBits is always >= 8 */ clipIndex = (1 << addrBits) - (1 << (addrBits - 8)); /* max XLUT output with 10 bit is at 1020, not at1023 */ theAlutSize = theLutData->colorLutOutDim * count; localAlut = ALLOC_DATA(theAlutSize + 1, &err); if (err) goto CleanupAndExit; outTabLen = outputTableEntries; /* <= 4096 */ indFactor = ((outTabLen - 1) << 18) / clipIndex; /* for adjusting the indices */ LOCK_DATA(localAlut); localAlutPtr = (UINT8*)DATA_2_PTR(localAlut); for(i=0; i<theLutData->colorLutOutDim; i++) { curOutLut = profALUTs + i * outTabLen; curALUT = localAlutPtr + i * count; for(j=0; j<=clipIndex; j++) { lAux = (j * indFactor+32) >> 6; baseInd = lAux >> 12; fract = lAux & 0x0FFF; if(fract) { lAux = (long)curOutLut[baseInd + 1] - (long)curOutLut[baseInd]; lAux = (lAux * fract + 0x0800) >> 12; curALUT[j] = (UINT8)(((long)curOutLut[baseInd] + lAux) >> 8); } else curALUT[j] = curOutLut[baseInd] >> 8; } for(j=clipIndex+1; j<count; j++) /* unused indices, clip these */ curALUT[j] = curALUT[clipIndex]; } UNLOCK_DATA(localAlut); theLutData->outputLut = localAlut; localAlut = nil; CleanupAndExit: localAlut = DISPOSE_IF_DATA(localAlut); LH_END_PROC("Fill_byte_ALUTs_from_lut16Tag") return err; }

CMError Fill_byte_ALUTs_from_lut8Tag (  CMLutParamPtr  theLutData, Ptr  profileALuts, char  addrBits )

Definition at line 1028 of file lh_core/fragment.c. { long i, j; UINT8 *curOutLut; UINT8 *profAluts = (UINT8*)profileALuts; UINT8 *curALUT; long count, clipIndex; long factor, fract, baseInd, lAux; OSErr err = noErr; LUT_DATA_TYPE localAlut = nil; UINT8 *localAlutPtr; long theAlutSize; LH_START_PROC("Fill_byte_ALUTs_from_lut8Tag") count = 1 << addrBits; /* addrBits is always >= 8 */ clipIndex = (1 << addrBits) - (1 << (addrBits - 8)); /* max XLUT output with 10 bit is at 1020, not at1023 */ theAlutSize = theLutData->colorLutOutDim * count; localAlut = ALLOC_DATA(theAlutSize + 1, &err); if (err) goto CleanupAndExit; LOCK_DATA(localAlut); localAlutPtr = (UINT8*)DATA_2_PTR(localAlut); factor = (255 << 12) / clipIndex; /* for adjusting the indices */ for(i=0; i<theLutData->colorLutOutDim; i++) { curOutLut = profAluts + (i << 8); curALUT = localAlutPtr + i * count; for(j=0; j<=clipIndex; j++) { lAux = j * factor; baseInd = lAux >> 12; fract = lAux & 0x0FFF; if(fract) { lAux = (long)curOutLut[baseInd + 1] - (long)curOutLut[baseInd]; lAux = (lAux * fract + 0x0800) >> 12; curALUT[j] = (UINT8)((long)curOutLut[baseInd] + lAux); } else curALUT[j] = curOutLut[baseInd]; } for(j=clipIndex+1; j<count; j++) /* unused indices, clip these */ curALUT[j] = curALUT[clipIndex]; } UNLOCK_DATA(localAlut); theLutData->outputLut = localAlut; localAlut = nil; CleanupAndExit: localAlut = DISPOSE_IF_DATA(localAlut); LH_END_PROC("Fill_byte_ALUTs_from_lut8Tag") return err; }

CMError Fill_inverse_byte_ALUT_from_CurveTag (  icCurveType *  pCurveTag, UINT8 *  ucALUT, char  addrBits )

CMError Fill_inverse_ushort_ALUT_from_CurveTag (  icCurveType *  pCurveTag, unsigned short *  usALUT, char  addrBits )

Definition at line 70 of file lh_core/frgmnt16.c. { unsigned long i, inCount, outCount, clipIndex, ulFactor; unsigned long intpFirst, intpLast, halfStep, ulAux, target; short monot; unsigned short *inCurve, *usPtr, *stopPtr; double flFactor; #ifdef DEBUG_OUTPUT OSErr err=noErr; #endif LH_START_PROC("Fill_inverse_ushort_ALUT_from_CurveTag") if( pCurveTag->base.sig != icSigCurveType /* 'curv' */ || addrBits > 15 ) { #ifdef DEBUG_OUTPUT if ( DebugCheck(kThisFile, kDebugErrorInfo) ) DebugPrint("¥ Fill_inverse_ushort_ALUT_from_CurveTag ERROR: addrBits= %d\n",addrBits); #endif return(cmparamErr); } outCount = 1 << addrBits; clipIndex = outCount - 1; /*---special cases:---*/ if(pCurveTag->curve.count == 0) /*---identity---*/ { ulFactor = ((unsigned long)65535 << 16) / clipIndex; /* use all 32 bits */ for(i=0; i<clipIndex; i++) usALUT[i] = (unsigned short)((i * ulFactor + 32767) >> 16); for(i=clipIndex; i<outCount; i++) usALUT[i] = 0xFFFF; return(noErr); } else if(pCurveTag->curve.count == 1) /*---gamma curve---*/ { Fill_inverseGamma_ushort_ALUT(usALUT, addrBits, pCurveTag->curve.data[0]); return(noErr); } /*---ordinary case:---*/ inCount = pCurveTag->curve.count; inCurve = pCurveTag->curve.data; /* exact matching factor needed for special values: */ flFactor = (double)clipIndex / 65535.; halfStep = clipIndex >> 1; /* lessen computation incorrectness */ /* ascending or descending ? */ for(monot=0, i=1; i<inCount; i++) { if(inCurve[i-1] < inCurve[i]) monot++; else if(inCurve[i-1] > inCurve[i]) monot--; } if(monot >= 0) /* curve seems to be ascending */ { for(i=1; i<inCount; i++) if(inCurve[i-1] > inCurve[i]) inCurve[i] = inCurve[i-1]; /* correct not-invertible parts */ intpFirst = (unsigned long)(inCurve[0] * flFactor + 0.9999); intpLast = (unsigned long)(inCurve[inCount-1] * flFactor); for(i=0; i<intpFirst; i++) /* fill lacking area low */ usALUT[i] = 0; for(i=intpLast+1; i<outCount; i++) /* fill lacking area high */ usALUT[i] = 0xFFFF; /* interpolate remaining values: */ usPtr = inCurve; stopPtr = inCurve + inCount - 2; /* stops incrementation */ for(i=intpFirst; i<=intpLast; i++) { target = (0x0FFFF * i + halfStep) / clipIndex; while(*(usPtr+1) < target && usPtr < stopPtr) usPtr++; /* find interval */ ulAux = ((unsigned long)(usPtr - inCurve) << 16) / (inCount - 1); if(*(usPtr+1) != *usPtr) { ulAux += ((target - (unsigned long)*usPtr) << 16) / ( (*(usPtr+1) - *usPtr) * (inCount - 1) ); if(ulAux & 0x10000) /* *(usPtr+1) was required */ ulAux = 0xFFFF; } usALUT[i] = (unsigned short)ulAux; } } else /* curve seems to be descending */ { for(i=1; i<inCount; i++) if(inCurve[i-1] < inCurve[i]) inCurve[i] = inCurve[i-1]; /* correct not-invertible parts */ intpFirst = (unsigned long)(inCurve[inCount-1] * flFactor + 0.9999); intpLast = (unsigned long)(inCurve[0] * flFactor); for(i=0; i<intpFirst; i++) /* fill lacking area low */ usALUT[i] = 0xFFFF; for(i=intpLast+1; i<outCount; i++) /* fill lacking area high */ usALUT[i] = 0; /* interpolate remaining values: */ usPtr = inCurve + inCount - 1; stopPtr = inCurve + 1; /* stops decrementation */ for(i=intpFirst; i<=intpLast; i++) { target = (0x0FFFF * i + halfStep) / clipIndex; while(*(usPtr-1) < target && usPtr > stopPtr) usPtr--; /* find interval */ ulAux = ((unsigned long)(usPtr-1 - inCurve) << 16) / (inCount - 1); if(*(usPtr-1) != *usPtr) { ulAux += (((unsigned long)*(usPtr-1) - target) << 16) / ( (*(usPtr-1) - *usPtr) * (inCount - 1) ); if(ulAux & 0x10000) ulAux = 0xFFFF; } usALUT[i] = (unsigned short)ulAux; } } LH_END_PROC("Fill_inverse_ushort_ALUT_from_CurveTag") return(noErr); }

CMError Fill_ushort_ALUTs_from_lut16Tag (  CMLutParamPtr  theLutData, Ptr  profileALuts, char  addrBits, long  outputTableEntries )

Definition at line 414 of file lh_core/frgmnt16.c. { long i; unsigned short *curOutLut; unsigned short *curALUT; unsigned long ulIndFactor, j; long count, clipIndex, outTabLen; long fract, baseInd, lAux, leftVal, rightVal; unsigned short *profALUTs = (unsigned short *)profileALuts; OSErr err = noErr; LUT_DATA_TYPE localAlut = nil; unsigned short *localAlutPtr; long theAlutSize; LH_START_PROC("Fill_ushort_ALUTs_from_lut16Tag") count = 1 << addrBits; /* addrBits is always >= 8 */ clipIndex = count - 1; theAlutSize = theLutData->colorLutOutDim * count * sizeof(unsigned short); localAlut = ALLOC_DATA(theAlutSize + 2, &err); if (err) goto CleanupAndExit; outTabLen = outputTableEntries; /* <= 4096 acc. to the spec */ if(outTabLen > 4096) { err = cmparamErr; goto CleanupAndExit; } ulIndFactor = (((unsigned long)outTabLen - 1) << 20) / (unsigned long)clipIndex; /* for adjusting the indices */ LOCK_DATA(localAlut); localAlutPtr = (unsigned short *)DATA_2_PTR(localAlut); for(i=0; i<theLutData->colorLutOutDim; i++) { curOutLut = profALUTs + i * outTabLen; curALUT = localAlutPtr + i * count; for(j=0; j<=(unsigned long)clipIndex; j++) { lAux = (long)( (j * ulIndFactor + 16) >> 5 ); /* n.b: j is unsigned long ! */ baseInd = (unsigned long)lAux >> 15; fract = lAux & 0x7FFF; /* 15 bits for interpolation */ if(fract) { leftVal = (long)curOutLut[baseInd]; rightVal = (long)curOutLut[baseInd + 1]; lAux = rightVal - leftVal; lAux = (lAux * fract + 16383) >> 15; curALUT[j] = (unsigned short)(leftVal + lAux); } else curALUT[j] = curOutLut[baseInd]; } for(j=clipIndex+1; j<(unsigned long)count; j++) /* unused indices, clip these */ curALUT[j] = curALUT[clipIndex]; } UNLOCK_DATA(localAlut); theLutData->outputLut = localAlut; localAlut = nil; CleanupAndExit: localAlut = DISPOSE_IF_DATA(localAlut); LH_END_PROC("Fill_ushort_ALUTs_from_lut16Tag") return err; }

CMError Fill_ushort_ALUTs_from_lut8Tag (  CMLutParamPtr  theLutData, Ptr  profileALuts, char  addrBits )

Definition at line 316 of file lh_core/frgmnt16.c. { long i, j; unsigned char *curOutLut; unsigned char *profAluts = (unsigned char *)profileALuts; unsigned short *curALUT; long count, clipIndex; long factor, fract, baseInd, lAux, leftVal, rightVal; OSErr err = noErr; LUT_DATA_TYPE localAlut = nil; unsigned short *localAlutPtr; long theAlutSize; LH_START_PROC("Fill_ushort_ALUTs_from_lut8Tag") count = 1 << addrBits; /* addrBits is always >= 8 */ clipIndex = count - 1; theAlutSize = theLutData->colorLutOutDim * count * sizeof(unsigned short); localAlut = ALLOC_DATA(theAlutSize + 2, &err); if (err) goto CleanupAndExit; LOCK_DATA(localAlut); localAlutPtr = (unsigned short *)DATA_2_PTR(localAlut); factor = ((255 << 12) + clipIndex/2) / clipIndex; /* for adjusting the indices */ for(i=0; i<theLutData->colorLutOutDim; i++) { curOutLut = profAluts + (i << 8); /* these are unsigned char's */ curALUT = localAlutPtr + i * count; /* these are unsigned short's */ for(j=0; j<=clipIndex-1; j++) { lAux = j * factor; baseInd = (unsigned long)lAux >> 12; fract = lAux & 0x0FFF; leftVal = (long)curOutLut[baseInd]; leftVal = (leftVal << 8) + leftVal; /* 0xFF -> 0xFFFF */ if(fract) { rightVal = (long)curOutLut[baseInd + 1]; rightVal = (rightVal << 8) + rightVal; /* 0xFF -> 0xFFFF */ lAux = rightVal - leftVal; lAux = (lAux * fract + 0x0800) >> 12; curALUT[j] = (unsigned short)(leftVal + lAux); } else curALUT[j] = (unsigned short)leftVal; } leftVal = (long)curOutLut[255]; leftVal = (leftVal << 8) + leftVal; /* 0xFF -> 0xFFFF */ curALUT[j] = (unsigned short)leftVal; for(j=clipIndex+1; j<count; j++) /* unused indices, clip these */ curALUT[j] = curALUT[clipIndex]; } UNLOCK_DATA(localAlut); theLutData->outputLut = localAlut; localAlut = nil; CleanupAndExit: localAlut = DISPOSE_IF_DATA(localAlut); LH_END_PROC("Fill_ushort_ALUTs_from_lut8Tag") return err; }

CMError Fill_ushort_ELUT_from_CurveTag (  icCurveType *  pCurveTag, UINT16 *  usELUT, char  addrBits, char  usedBits, long  gridPoints )

CMError Fill_ushort_ELUT_identical (  UINT16 *  usELUT, char  addrBits, char  usedBits, long  gridPoints )

Definition at line 558 of file lh_core/fragment.c. { long i, count, factor, maxOut; UINT16 *myWPtr; #ifdef DEBUG_OUTPUT CMError err = noErr; #endif LH_START_PROC("Fill_ushort_ELUT_identical") count = 1 << addrBits; if(gridPoints == 0) maxOut = 65535; else maxOut = ((1L << (usedBits - 8) ) * 256 * (gridPoints - 1)) / gridPoints; factor = (maxOut << 14) / (count - 1); myWPtr = usELUT; for(i=0; i<count; i++) *myWPtr++ = (UINT16)((i * factor + 0x2000) >> 14); LH_END_PROC("Fill_ushort_ELUT_identical") return(noErr); }

CMError Fill_ushort_ELUTs_from_lut16Tag (  CMLutParamPtr  theLutData, Ptr  profileELuts, char  addrBits, char  usedBits, long  gridPoints, long  inputTableEntries )

Definition at line 1121 of file lh_core/fragment.c. { long i, j, inTabLen, maxOut; UINT16 *curInLut; UINT16 *curELUT; UINT16 *profELUT = (UINT16*)profileELuts; long count, outFactor, fract, lAux, diff; long baseInd, indFactor; long outRound, outShift, interpRound, interpShift; double dFactor; long theElutSize; LUT_DATA_TYPE localElut = nil; UINT16 *localElutPtr; OSErr err = noErr; LH_START_PROC("Fill_ushort_ELUTs_from_lut16Tag") count = 1 << addrBits; inTabLen = inputTableEntries; theElutSize = theLutData->colorLutInDim * count * sizeof (UINT16); localElut = ALLOC_DATA(theElutSize + 2, &err); if(err) goto CleanupAndExit; indFactor = ((inTabLen - 1) << 18) / (count - 1); /* for adjusting indices */ if(gridPoints == 0) maxOut = 65535; else maxOut = ((1L << (usedBits - 8) ) * 256 * (gridPoints - 1)) / gridPoints; /*-----find factor for the values that fits in 15 bits------*/ /* (product with 16 bit number must fit in 31 bit uns.long) */ /* n.b: 512 <= maxOut <= 65535 in all possible cases */ dFactor = (double)maxOut / 65535.; /* 65535 is max. curve value */ dFactor *= 4194304.; /* same as << 22, certainly too much */ outFactor = (long)dFactor; outRound = (1L << 21) - 1; outShift = 22; while(outFactor & 0xFFF8000) /* stay within 15 bits to prevent product overflow */ { outFactor >>= 1; outRound >>= 1; outShift -= 1; } interpRound = outRound >> 1; /* with interpolation we have an additional... */ interpShift = outShift - 1; /* ... >> 1 because we must add two nunmbers */ LOCK_DATA(localElut); localElutPtr = (UINT16*)DATA_2_PTR(localElut); for(i=0; i<theLutData->colorLutInDim; i++) { curInLut = profELUT + (i * inTabLen); curELUT = localElutPtr + (i * count); for(j=0; j<count; j++) { lAux = (j * indFactor+4) >> 3; baseInd = (unsigned long)lAux >> 15; fract = lAux & 0x7FFF; /* 15 bits for interpolation */ if(fract) /* interpolation necessary ? */ { lAux = (long)curInLut[baseInd] * outFactor >> 1; diff = (long)curInLut[baseInd+1] - (long)curInLut[baseInd]; diff = ((diff * outFactor >> 15) * fract) >> 1; curELUT[j] = (UINT16)( (lAux + diff + interpRound) >> interpShift ); } else curELUT[j] = (UINT16)( ((long)curInLut[baseInd] * outFactor + outRound) >> outShift ); } } UNLOCK_DATA(localElut); theLutData->inputLut = localElut; localElut = nil; CleanupAndExit: localElut = DISPOSE_IF_DATA(localElut); LH_END_PROC("Fill_ushort_ELUTs_from_lut16Tag") return err; }

CMError Fill_ushort_ELUTs_from_lut8Tag (  CMLutParamPtr  theLutData, Ptr  profileELuts, char  addrBits, char  usedBits, long  gridPoints )

Definition at line 941 of file lh_core/fragment.c. { long i, j, maxOut; UINT8 *curInLut; UINT16 *curELUT; long count, indFactor, outFactor, baseInd, fract, lAux, diff; LUT_DATA_TYPE localElut = nil; UINT16 *localElutPtr; OSErr err = noErr; long theElutSize; LH_START_PROC("Fill_ushort_ELUTs_from_lut8Tag") count = 1 << addrBits; theElutSize = theLutData->colorLutInDim * count * sizeof (UINT16); localElut = ALLOC_DATA(theElutSize + 2, &err); if (err) goto CleanupAndExit; indFactor = (255 << 12) / (count - 1); /* for adjusting indices */ if(gridPoints == 0) maxOut = 65535; else maxOut = ((1L << (usedBits - 8) ) * 256 * (gridPoints - 1)) / gridPoints; outFactor = (maxOut << 12) / 255; /* 255 is max. value from mft1 output lut */ LOCK_DATA(localElut); localElutPtr = (UINT16*)DATA_2_PTR(localElut); for(i=0; i<theLutData->colorLutInDim; i++) { curInLut = (UINT8*)profileELuts + (i << 8); curELUT = localElutPtr + i * count; for(j=0; j<count; j++) { lAux = j * indFactor; baseInd = lAux >> 12; fract = (lAux & 0x0FFF) >> 4; /* leaves 8 bits for interpolation as with distortion */ if(fract && baseInd != 255) /* interpolation necessary ? */ { lAux = (long)curInLut[baseInd] * outFactor >> 6; diff = (long)curInLut[baseInd+1] - (long)curInLut[baseInd]; diff = (diff * outFactor >> 6) * fract >> 8; curELUT[j] = (UINT16)( (lAux + diff + 32) >> 6 ); } else curELUT[j] = (UINT16)( ((long)curInLut[baseInd] * outFactor + 0x0800) >> 12 ); } } UNLOCK_DATA(localElut); theLutData->inputLut = localElut; localElut = nil; CleanupAndExit: localElut = DISPOSE_IF_DATA(localElut); LH_END_PROC("Fill_ushort_ELUTs_from_lut8Tag") return err; }

icCurveType* InvertLut1d (  icCurveType *  LookUpTable, UINT8  AdressBits )

Definition at line 70 of file lh_core/fragment.c. { unsigned long i, inCount, outCount; unsigned long intpFirst, intpLast, halfStep, ulAux, target; short monot; unsigned short *inCurve, *outCurve, *usPtr, *stopPtr; icCurveType *outCMcurve = nil; double flFactor; OSErr err = noErr; LH_START_PROC("InvertLut1d") if( LookUpTable->base.sig != icSigCurveType /* 'curv' */ || AdressBits > 15 ) goto CleanupAndExit; inCount = LookUpTable->curve.count; inCurve = LookUpTable->curve.data; outCount = 0x1 << AdressBits; outCMcurve = (icCurveType *)SmartNewPtr( sizeof(OSType) + 2 * sizeof(unsigned long) + outCount * sizeof(unsigned short), &err ); if(err) goto CleanupAndExit; outCurve = (unsigned short *)outCMcurve->curve.data; outCMcurve->base.sig = icSigCurveType; /* 'curv' */ outCMcurve->base.reserved[0] = 0x00; outCMcurve->base.reserved[1] = 0x00; outCMcurve->base.reserved[2] = 0x00; outCMcurve->base.reserved[3] = 0x00; outCMcurve->curve.count = outCount; if(inCount < 2) /* 0 or 1 point in LUT */ { InvLut1dExceptions(inCurve, inCount, outCurve, AdressBits); goto CleanupAndExit; } /* exact matching factor for special values: */ flFactor = (double)(outCount - 1) / 65535.; halfStep = outCount >> 1; /* lessen computation incorrectness */ /* ascending or descending ? */ for(monot=0, i=1; i<inCount; i++) { if(inCurve[i-1] < inCurve[i]) monot++; else if(inCurve[i-1] > inCurve[i]) monot--; } if(monot >= 0) /* curve seems to be ascending */ { for(i=1; i<inCount; i++) if(inCurve[i-1] > inCurve[i]) inCurve[i] = inCurve[i-1]; intpFirst = (unsigned long)(inCurve[0] * flFactor + 0.9999); intpLast = (unsigned long)(inCurve[inCount-1] * flFactor); for(i=0; i<intpFirst; i++) /* fill lacking area low */ outCurve[i] = 0; for(i=intpLast+1; i<outCount; i++) /* fill lacking area high */ outCurve[i] = 0xFFFF; /* interpolate remaining values: */ usPtr = inCurve; stopPtr = inCurve + inCount - 2; /* stops incrementation */ for(i=intpFirst; i<=intpLast; i++) { target = (0x0FFFF * i + halfStep) / (outCount - 1); while(*(usPtr+1) < target && usPtr < stopPtr) usPtr++; /* find interval */ ulAux = ((unsigned long)(usPtr - inCurve) << 16) / (inCount - 1); if(*(usPtr+1) != *usPtr) { ulAux += ((target - (unsigned long)*usPtr) << 16) / ( (*(usPtr+1) - *usPtr) * (inCount - 1) ); if(ulAux & 0x10000) /* *(usPtr+1) was required */ ulAux = 0xFFFF; } outCurve[i] = (unsigned short)ulAux; } } else /* curve seems to be descending */ { for(i=1; i<inCount; i++) if(inCurve[i-1] < inCurve[i]) inCurve[i] = inCurve[i-1]; intpFirst = (unsigned long)(inCurve[inCount-1] * flFactor + 0.9999); intpLast = (unsigned long)(inCurve[0] * flFactor); for(i=0; i<intpFirst; i++) /* fill lacking area low */ outCurve[i] = 0xFFFF; for(i=intpLast+1; i<outCount; i++) /* fill lacking area high */ outCurve[i] = 0; /* interpolate remaining values: */ usPtr = inCurve + inCount - 1; stopPtr = inCurve + 1; /* stops decrementation */ for(i=intpFirst; i<=intpLast; i++) { target = (0x0FFFF * i + halfStep) / (outCount - 1); while(*(usPtr-1) < target && usPtr > stopPtr) usPtr--; /* find interval */ ulAux = ((unsigned long)(usPtr-1 - inCurve) << 16) / (inCount - 1); if(*(usPtr-1) != *usPtr) { ulAux += (((unsigned long)*(usPtr-1) - target) << 16) / ( (*(usPtr-1) - *usPtr) * (inCount - 1) ); if(ulAux & 0x10000) ulAux = 0x0FFFF; } outCurve[i] = (unsigned short)ulAux; } } CleanupAndExit: LH_END_PROC("InvertLut1d") return(outCMcurve); }

CMError MakeGamut16or32ForMonitor (  icXYZType *  pRedXYZ, icXYZType *  pGreenXYZ, icXYZType *  pBlueXYZ, CMLutParamPtr  theLutData, Boolean  cube32Flag )

Definition at line 1334 of file lh_core/fragment.c. { double XYZmatrix[3][3], RGBmatrix[3][3]; double sum, dFactor; long i, j, k, gridPoints, planeCount, totalCount, longMat[9]; long longX, longY, longZ, longR, longG, longB; long *lPtr, lFactor, maxOut; unsigned short *usPtr; unsigned char *XPtr; LUT_DATA_TYPE tempXLutHdl = nil; LUT_DATA_TYPE tempELutHdl = nil; LUT_DATA_TYPE tempALutHdl = nil; unsigned char *tempXLut = nil; unsigned char *tempALut = nil; unsigned short *tempELut = nil; unsigned short Levels[32]; OSErr err = noErr; LH_START_PROC("MakeGamut16or32ForMonitor") if(theLutData->inputLut != nil || theLutData->colorLut != nil || theLutData->outputLut != nil) { err = cmparamErr; goto CleanupAndExit; } /*----------------------------------------------------------------------------------------- E */ tempELutHdl = ALLOC_DATA(adr_bereich_elut * 3 * sizeof(unsigned short) + 2, &err); /* +2 extra space for Interpolation */ if(err) goto CleanupAndExit; LOCK_DATA(tempELutHdl); tempELut = (unsigned short *)DATA_2_PTR(tempELutHdl); /*----------------------------------------------------------------------------------------- X */ if(cube32Flag) gridPoints = 32; /* for cube grid */ else gridPoints = 16; totalCount = gridPoints * gridPoints * gridPoints; totalCount += 1 + gridPoints + gridPoints * gridPoints; /* extra space for Interpolation */ #ifdef ALLOW_MMX totalCount+=3; /* +1 for MMX 4 Byte access */ #endif tempXLutHdl = ALLOC_DATA(totalCount, &err); if(err) goto CleanupAndExit; LOCK_DATA(tempXLutHdl); tempXLut = (unsigned char *)DATA_2_PTR(tempXLutHdl); /*----------------------------------------------------------------------------------------- A */ tempALutHdl = ALLOC_DATA(adr_bereich_alut + 1, &err); /* +1 extra space for Interpolation */ if(err) goto CleanupAndExit; LOCK_DATA(tempALutHdl); tempALut = (unsigned char *)DATA_2_PTR(tempALutHdl); /*---------fill 3 ELUTs for X, Y, Z (256 u.shorts each):--------------------*/ /* linear curve with clipping, slope makes white value become */ /* max * 30.5/31 or max * 14.5/15, that is half of the last XLUT interval */ if(cube32Flag) dFactor = 30.5 / 31.; else dFactor = 14.5 / 15.; maxOut = ((1L << (16 /*usedBits*/ - 8) ) * 256 * (gridPoints - 1)) / gridPoints; for(i=0; i<3; i++) /* X, Y, Z ELUTs */ { if(i == 0) lFactor = (long)( dFactor * 2. * maxOut * 256. / 255. / 0.9642 );/* X, adjust D50 */ else if(i == 1) lFactor = (long)( dFactor * 2. * maxOut * 256. / 255.); /* Y */ else lFactor = (long)( dFactor * 2. * maxOut * 256. / 255. / 0.8249);/* Z, adjust D50 */ usPtr = tempELut + 256 * i; for(j=0; j<256; j++) { k = (j * lFactor + 127) >> 8; if(k > maxOut) k = maxOut; /* max. ELUT value */ *usPtr++ = (unsigned short)k; } } /*------ RGB to XYZ matrix in the range 0.0 to 1.0 -----*/ /* floating point for accurate inversion */ XYZmatrix[0][0] = (double)pRedXYZ->data.data[0].X; XYZmatrix[1][0] = (double)pRedXYZ->data.data[0].Y; XYZmatrix[2][0] = (double)pRedXYZ->data.data[0].Z; XYZmatrix[0][1] = (double)pGreenXYZ->data.data[0].X; XYZmatrix[1][1] = (double)pGreenXYZ->data.data[0].Y; XYZmatrix[2][1] = (double)pGreenXYZ->data.data[0].Z; XYZmatrix[0][2] = (double)pBlueXYZ->data.data[0].X; XYZmatrix[1][2] = (double)pBlueXYZ->data.data[0].Y; XYZmatrix[2][2] = (double)pBlueXYZ->data.data[0].Z; /*--- grey with R = G = B (D50 adjustment is done by the ELUTs) ----*/ for(i=0; i<3; i++) { sum = XYZmatrix[i][0] + XYZmatrix[i][1] + XYZmatrix[i][2]; if(sum < 0.1) sum = 0.1; /* prevent from div. by 0 (bad profiles) */ for(j=0; j<3; j++) XYZmatrix[i][j] /= sum; } /*---XYZ to RGB matrix:---*/ if(!doubMatrixInvert(XYZmatrix, RGBmatrix)) { err = cmparamErr; goto CleanupAndExit; } for(i=0; i<3; i++) /* create integer format for speed, */ for(j=0; j<3; j++) /* 1.0 becomes 2^13, works for coeff. up to 8. */ longMat[3*i + j] = (long)(RGBmatrix[i][j] * 8192.); /*-----grid levels for cube grid in XYZ (16 bit) so ----*/ /* that white is at half of last interval, so the last */ /* value is white * 15/14.5 or white * 31/30.5 */ if(cube32Flag) dFactor = 32768. / 30.5 * 31. / (gridPoints - 1); else dFactor = 32768. / 14.5 * 15. / (gridPoints - 1); for(i=0; i<gridPoints; i++) /* n.b: 32 is max. possible gridPoints */ Levels[i] = (unsigned short)(i * dFactor + 0.5); /*----special treatment of first and last plane for speed:----*/ planeCount = gridPoints * gridPoints; XPtr = tempXLut; for(i=0; i<planeCount; i++) *XPtr++ = 255; /* out of gamut */ XPtr = tempXLut + (gridPoints - 1) * planeCount; for(i=0; i<planeCount; i++) *XPtr++ = 255; /* out of gamut */ *tempXLut = 0; /* set black (white is between last 2 planes) */ /*----second to second last plane must be computed:-----*/ /* transform points to RGB and judge in/out */ XPtr = tempXLut + planeCount; for(i=1; i<gridPoints-1; i++) for(j=0; j<gridPoints; j++) for(k=0; k<gridPoints; k++) { longX = (long)Levels[i]; /* X */ longY = (long)Levels[j]; /* Y */ longZ = (long)Levels[k]; /* Z */ /* matrix coeff: 2^13 is 1.0 , XYZ values: 1.0 or 100. is 2^15 ; */ /* -> mask for products < 0 and >= 2^28 is used for in/out checking */ longR = longX * longMat[0] + longY * longMat[1] + longZ * longMat[2]; if(longR & 0xF0000000) *XPtr++ = 255; /* out of gamut */ else { longG = longX * longMat[3] + longY * longMat[4] + longZ * longMat[5]; if(longG & 0xF0000000) *XPtr++ = 255; /* out of gamut */ else { longB = longX * longMat[6] + longY * longMat[7] + longZ * longMat[8]; if(longB & 0xF0000000) *XPtr++ = 255; /* out of gamut */ else *XPtr++ = 0; /* in gamut */ } } } /*---fill Boolean output LUT, adr_bereich_alut Bytes, 4 at one time with long:---*/ lPtr = (long *)(tempALut); j = adr_bereich_alut/4/2 + 8; /* slightly more than 50 % */ for(i=0; i<j; i++) /* slightly more than 50 % */ *(lPtr + i) = 0; /* in gamut */ k = adr_bereich_alut/4; for(i=j; i<k; i++) *(lPtr + i) = 0xFFFFFFFF; /* out of gamut */ UNLOCK_DATA(tempELutHdl); UNLOCK_DATA(tempXLutHdl); UNLOCK_DATA(tempALutHdl); theLutData->colorLut = tempXLutHdl; tempXLutHdl = nil; theLutData->inputLut = tempELutHdl; tempELutHdl = nil; theLutData->outputLut = tempALutHdl; tempALutHdl = nil; CleanupAndExit: tempELutHdl = DISPOSE_IF_DATA(tempELutHdl); tempXLutHdl = DISPOSE_IF_DATA(tempXLutHdl); tempALutHdl = DISPOSE_IF_DATA(tempALutHdl); LH_END_PROC("MakeGamut16or32ForMonitor") return (err); }

---