test: runtime.c Source File

00001 /* 00002 File: LHCMRuntime.c 00003 00004 Contains: 00005 00006 Written by: U. J. Krabbenhoeft 00007 00008 Copyright: � 1993-1997 by Heidelberger Druckmaschinen AG, all rights reserved. 00009 00010 Version: 00011 */ 00012 00013 #ifndef LHGeneralIncs_h 00014 #include "General.h" 00015 #endif 00016 00017 #ifndef LHCalcEngine_h 00018 #include "CalcEng.h" 00019 #endif 00020 00021 #ifndef LHCalcEngine1Dim_h 00022 #include "CalcEng1.h" 00023 #endif 00024 00025 #ifdef ALLOW_MMX 00026 #ifndef LHCalcEngineFas_h 00027 #include "CalcEnF.h" 00028 #endif 00029 #endif 00030 00031 #ifndef LHCalcNDim_h 00032 #include "CalcNDim.h" 00033 #endif 00034 00035 #ifndef LHCMRuntime_h 00036 #include "Runtime.h" 00037 #endif 00038 00039 #if ! realThing 00040 #ifdef DEBUG_OUTPUT 00041 #define kThisFile kCMMRuntimeID 00042 extern Boolean gUSE_NDIM_FOR_BITMAP; 00043 #endif 00044 #endif 00045 00046 typedef struct ColorSpaceInfo 00047 { 00048 SINT32 origSizeIn; 00049 SINT32 origSizeOut; 00050 SINT32 usedSizeIn; 00051 SINT32 usedSizeOut; 00052 void* tempInBuffer; 00053 void* tempOutBuffer; 00054 SINT32 processedLinesIn; 00055 SINT32 processedLinesOut; 00056 SINT32 inputPixelSize; 00057 SINT32 outputPixelSize; 00058 Boolean inPlace; 00059 } ColorSpaceInfo; 00060 00061 /* -------------------------------------------------------------------------------------------------------------- */ 00062 #define kProgressTicks 30 /* .5secs -> min. time between calls of progressproc */ 00063 #define kMaxTempBlock 300 * 1024 /* allow max. 300 kByte temp buffer */ 00064 00065 /* -------------------------------------------------------------------------------------------------------------- */ 00066 typedef CMError (*CalcProcPtr)(CMCalcParamPtr calcParamPtr, 00067 CMLutParamPtr lutParamPtr ); 00068 00069 typedef CalcProcPtr CalcProcUPP; 00070 typedef CMError (*CalcProc1DimPtr)(CMCalcParamPtr calcParamPtr, 00071 CMLutParamPtr lutParamPtr, char OutDim ); 00072 00073 typedef CalcProc1DimPtr CalcProc1DimUPP; 00074 #define NewCalcProc(userRoutine) \ 00075 ((CalcProcUPP) (userRoutine)) 00076 #define NewCalcProc1Dim(userRoutine) \ 00077 ((CalcProc1DimUPP) (userRoutine)) 00078 #define CallCalcProc(userRoutine, calcParamPtr, lutParamPtr) \ 00079 (*(userRoutine))( (calcParamPtr), (lutParamPtr) ) 00080 00081 /*-------------------------------------------------------------------------------------------------------------- 00082 local prototypes 00083 --------------------------------------------------------------------------------------------------------------*/ 00084 00085 OSErr Convert5To8 ( Ptr dataPtr5, 00086 Ptr dataPtr8, 00087 SINT32 startLine, 00088 SINT32 height, 00089 SINT32 width, 00090 SINT32 rowBytes5 ); 00091 OSErr Convert8To5 ( Ptr dataPtr8, 00092 Ptr dataPtr5, 00093 SINT32 startLine, 00094 SINT32 height, 00095 SINT32 width, 00096 SINT32 rowBytes5 ); 00097 OSErr Convert8To1 ( Ptr dataPtr8, 00098 Ptr dataPtr5, 00099 SINT32 startLine, 00100 SINT32 height, 00101 SINT32 width, 00102 SINT32 rowBytes5 ); 00103 OSErr Convert16To10 ( Ptr dataPtr16, 00104 Ptr dataPtr10, 00105 SINT32 startLine, 00106 SINT32 height, 00107 SINT32 width, 00108 SINT32 rowBytes10 ); 00109 OSErr Convert10To16 ( Ptr dataPtr10, 00110 Ptr dataPtr16, 00111 SINT32 startLine, 00112 SINT32 height, 00113 SINT32 width, 00114 SINT32 rowBytes10 ); 00115 00116 CMError FillLutParam ( CMLutParamPtr lutParam, 00117 CMMModelPtr modelingData ); 00118 CMError FillLutParamChk ( CMLutParamPtr lutParam, 00119 CMMModelPtr modelingData ); 00120 00121 CMError FillCalcParam ( CMCalcParamPtr calcParam, 00122 const CMBitmap * bitMap, 00123 const CMBitmap * matchedBitMap ); 00124 00125 CMError FillCalcParamCM ( CMCalcParamPtr calcParam, 00126 CMLutParamPtr lutParam, 00127 CMColor* myColors, 00128 SINT32 count ); 00129 CMError CheckInputColorSpace ( const CMBitmap* bitMap, 00130 CMCalcParamPtr calcParam, 00131 ColorSpaceInfo* info, 00132 OSType inColorSpace, 00133 long colorLutInDim ); 00134 CMError CheckOutputColorSpace ( const CMBitmap* bitMap, 00135 CMCalcParamPtr calcParam, 00136 ColorSpaceInfo* info, 00137 OSType outColorSpace, 00138 long colorLutOutDim ); 00139 CMError SetOutputColorSpaceInplace ( CMCalcParamPtr calcParam, 00140 ColorSpaceInfo* info, 00141 OSType outColorSpace ); 00142 CMError CheckOutputColorSpaceChk( const CMBitmap* bitMap, 00143 CMCalcParamPtr calcParam, 00144 ColorSpaceInfo* info ); 00145 00146 CMError AllocBufferCheckCM ( CMCalcParamPtr calcParam, 00147 ColorSpaceInfo* info ); 00148 00149 CalcProcPtr FindLookupRoutine ( const CMLutParam* lutParam, 00150 const ColorSpaceInfo* info ); 00151 00152 CalcProcPtr FindCalcRoutine ( const CMCalcParam* calcParam, 00153 const CMLutParam* lutParam, 00154 const ColorSpaceInfo* info, 00155 const Boolean lookupOnly ); 00156 00157 00158 #ifdef __MWERKS__ 00159 #pragma mark ================ packing/unpacking ================ 00160 #endif 00161 00162 /*-------------------------------------------------------------------------------------------------------------- 00163 Convert5To8 convert cmRGB16Space to cmRGB24Space 00164 --------------------------------------------------------------------------------------------------------------*/ 00165 OSErr 00166 Convert5To8 ( Ptr dataPtr5, 00167 Ptr dataPtr8, 00168 SINT32 startLine, 00169 SINT32 height, 00170 SINT32 width, 00171 SINT32 rowBytes5 ) 00172 { 00173 UINT16* srcPtr16; 00174 UINT8* destPtr8 = (UINT8*)dataPtr8; 00175 UINT8 data8; 00176 UINT16 three5Bits; 00177 SINT32 lineLoop; 00178 SINT32 pixelLoop; 00179 OSErr err = noErr; 00180 00181 LH_START_PROC("Convert5To8") 00182 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++) 00183 { 00184 srcPtr16 = (UINT16*)(dataPtr5 + (lineLoop*rowBytes5)); 00185 for (pixelLoop = 0; pixelLoop < width; pixelLoop++) 00186 { 00187 three5Bits = *srcPtr16++; 00188 00189 data8 = (three5Bits >> 10) & 0x001F; 00190 *destPtr8++ = (data8 << 3) | (data8 >>2); 00191 00192 data8 = (three5Bits >> 5) & 0x001F; 00193 *destPtr8++ = (data8 << 3) | (data8 >>2); 00194 00195 data8 = three5Bits & 0x001F; 00196 *destPtr8++ = (data8 << 3) | (data8 >>2); 00197 } 00198 } 00199 LH_END_PROC("Convert5To8") 00200 return err; 00201 } 00202 00203 /*-------------------------------------------------------------------------------------------------------------- 00204 Convert8To5 convert cmRGB24Space to cmRGB16Space 00205 --------------------------------------------------------------------------------------------------------------*/ 00206 OSErr 00207 Convert8To5 ( Ptr dataPtr8, 00208 Ptr dataPtr5, 00209 SINT32 startLine, 00210 SINT32 height, 00211 SINT32 width, 00212 SINT32 rowBytes5 ) 00213 { 00214 UINT16* destPtr16; 00215 UINT8* srcPtr8 = (UINT8*)dataPtr8; 00216 UINT16 three5Bits; 00217 SINT32 lineLoop; 00218 SINT32 pixelLoop; 00219 OSErr err = noErr; 00220 00221 LH_START_PROC("Convert8To5") 00222 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++) 00223 { 00224 destPtr16 = (UINT16*)(dataPtr5 + (lineLoop*rowBytes5)); 00225 for (pixelLoop = 0; pixelLoop < width; pixelLoop++) 00226 { 00227 three5Bits = (((UINT16)*srcPtr8 & 0x00F8) << 7); 00228 srcPtr8++; 00229 three5Bits |= (((UINT16)*srcPtr8 & 0x00F8) << 2); 00230 srcPtr8++; 00231 three5Bits |= (((UINT16)*srcPtr8 & 0x00F8) >> 3); 00232 srcPtr8++; 00233 00234 *destPtr16++ = three5Bits; 00235 } 00236 } 00237 LH_END_PROC("Convert8To5") 00238 return err; 00239 } 00240 #ifdef PI_Application_h 00241 OSErr Convert565To8 ( Ptr dataPtr5, 00242 Ptr dataPtr8, 00243 SINT32 startLine, 00244 SINT32 height, 00245 SINT32 width, 00246 SINT32 rowBytes5 ); 00247 OSErr Convert8To565 ( Ptr dataPtr8, 00248 Ptr dataPtr5, 00249 SINT32 startLine, 00250 SINT32 height, 00251 SINT32 width, 00252 SINT32 rowBytes5 ); 00253 /*-------------------------------------------------------------------------------------------------------------- 00254 Convert565To8 convert cmRGB16_565Space to cmRGB24Space 00255 --------------------------------------------------------------------------------------------------------------*/ 00256 OSErr 00257 Convert565To8( Ptr dataPtr5, 00258 Ptr dataPtr8, 00259 SINT32 startLine, 00260 SINT32 height, 00261 SINT32 width, 00262 SINT32 rowBytes5 ) 00263 { 00264 UINT16* srcPtr16; 00265 UINT8* destPtr8 = (UINT8*)dataPtr8; 00266 UINT8 data8; 00267 UINT16 three5Bits; 00268 SINT32 lineLoop; 00269 SINT32 pixelLoop; 00270 OSErr err = noErr; 00271 00272 LH_START_PROC("Convert565To8") 00273 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++) 00274 { 00275 srcPtr16 = (UINT16*)(dataPtr5 + (lineLoop*rowBytes5)); 00276 for (pixelLoop = 0; pixelLoop < width; pixelLoop++) 00277 { 00278 three5Bits = *srcPtr16++; 00279 00280 data8 = (three5Bits >> 11) & 0x001F; 00281 *destPtr8++ = (data8 << 3) | (data8 >>2); 00282 00283 data8 = (three5Bits >> 5) & 0x003F; 00284 *destPtr8++ = (data8 << 2) | (data8 >>4); 00285 00286 data8 = three5Bits & 0x001F; 00287 *destPtr8++ = (data8 << 3) | (data8 >>2); 00288 } 00289 } 00290 LH_END_PROC("Convert565To8") 00291 return err; 00292 } 00293 00294 /*-------------------------------------------------------------------------------------------------------------- 00295 Convert8To565 convert cmRGB24Space to cmRGB16_565Space 00296 --------------------------------------------------------------------------------------------------------------*/ 00297 OSErr 00298 Convert8To565( Ptr dataPtr8, 00299 Ptr dataPtr5, 00300 SINT32 startLine, 00301 SINT32 height, 00302 SINT32 width, 00303 SINT32 rowBytes5 ) 00304 { 00305 UINT16* destPtr16; 00306 UINT8* srcPtr8 = (UINT8*)dataPtr8; 00307 UINT16 three5Bits; 00308 SINT32 lineLoop; 00309 SINT32 pixelLoop; 00310 OSErr err = noErr; 00311 00312 LH_START_PROC("Convert8To565") 00313 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++) 00314 { 00315 destPtr16 = (UINT16*)(dataPtr5 + (lineLoop*rowBytes5)); 00316 for (pixelLoop = 0; pixelLoop < width; pixelLoop++) 00317 { 00318 three5Bits = (((UINT16)*srcPtr8 & 0x00F8) << 8); 00319 srcPtr8++; 00320 three5Bits |= (((UINT16)*srcPtr8 & 0x00FC) << 3); 00321 srcPtr8++; 00322 three5Bits |= (((UINT16)*srcPtr8 & 0x00F8) >> 3); 00323 srcPtr8++; 00324 00325 *destPtr16++ = three5Bits; 00326 } 00327 } 00328 LH_END_PROC("Convert8To565") 00329 return err; 00330 } 00331 #endif 00332 /*-------------------------------------------------------------------------------------------------------------- 00333 Convert8To1 convert 8-bit to 1-bit (gamut result) 00334 --------------------------------------------------------------------------------------------------------------*/ 00335 OSErr 00336 Convert8To1 ( Ptr dataPtr8, 00337 Ptr dataPtr1, 00338 SINT32 startLine, 00339 SINT32 height, 00340 SINT32 width, 00341 SINT32 rowBytes1 ) 00342 { 00343 UINT8* destPtr8; 00344 UINT8* srcPtr8 = (UINT8*)dataPtr8; 00345 UINT8 theWord = 0; 00346 SINT32 lineLoop; 00347 SINT32 pixelLoop; 00348 OSErr err = noErr; 00349 00350 LH_START_PROC("Convert8To1") 00351 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++) 00352 { 00353 destPtr8 = (UINT8*)(dataPtr1 + (lineLoop*rowBytes1)); 00354 for ( pixelLoop = 0; pixelLoop < width; pixelLoop++ ) 00355 { 00356 if (*srcPtr8) 00357 theWord |= (1<< (7- ( pixelLoop & 7))); 00358 if ( (pixelLoop & 7) == 7) 00359 { 00360 *destPtr8++ = theWord; 00361 theWord = 0; 00362 } 00363 srcPtr8 ++; 00364 } 00365 if (width % 8) 00366 { 00367 *destPtr8 = theWord | ( ((unsigned char)255 >> (width % 8))); 00368 theWord = 0; 00369 } 00370 } 00371 LH_END_PROC("Convert8To1") 00372 return err; 00373 } 00374 00375 /* ----------------------------------------------------------------------- 00376 Convert16To10 00377 ----------------------------------------------------------------------- */ 00378 OSErr 00379 Convert16To10 ( Ptr dataPtr16, 00380 Ptr dataPtr10, 00381 SINT32 startLine, 00382 SINT32 height, 00383 SINT32 width, 00384 SINT32 rowBytes10 ) 00385 { 00386 UINT32 data16_1; 00387 UINT32 data16_2; 00388 UINT32 data16_3; 00389 UINT16* srcPtr16 = (UINT16*)dataPtr16; 00390 UINT32* destPtr32; 00391 SINT32 lineLoop; 00392 SINT32 pixelLoop; 00393 OSErr err = noErr; 00394 00395 LH_START_PROC("Convert16To10") 00396 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++) 00397 { 00398 destPtr32 = (UINT32*)( dataPtr10 + (lineLoop * rowBytes10)); 00399 for (pixelLoop = 0; pixelLoop < width; pixelLoop++) 00400 { 00401 data16_1 = ((UINT32)*srcPtr16++ & 0x0000FFC0) << 14; 00402 data16_2 = ((UINT32)*srcPtr16++ & 0x0000FFC0) << 4; 00403 data16_3 = ((UINT32)*srcPtr16++ & 0x0000FFC0) >> 6; 00404 *destPtr32++ = data16_1 | data16_2 | data16_3; 00405 } 00406 } 00407 LH_END_PROC("Convert16To10") 00408 return err; 00409 } 00410 00411 /* ----------------------------------------------------------------------- 00412 Convert10To16 00413 ----------------------------------------------------------------------- */ 00414 OSErr 00415 Convert10To16 ( Ptr dataPtr10, 00416 Ptr dataPtr16, 00417 SINT32 startLine, 00418 SINT32 height, 00419 SINT32 width, 00420 SINT32 rowBytes10 ) 00421 { 00422 UINT16 data16; 00423 UINT32 data32; 00424 UINT32* srcPtr32; 00425 UINT16* destPtr16 = (UINT16*)dataPtr16; 00426 SINT32 lineLoop; 00427 SINT32 pixelLoop; 00428 OSErr err = noErr; 00429 00430 LH_START_PROC("Convert10To16") 00431 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++) 00432 { 00433 srcPtr32 = (UINT32*)( dataPtr10 + (lineLoop * rowBytes10)); 00434 for (pixelLoop = 0; pixelLoop < width; pixelLoop++) 00435 { 00436 data32 = *srcPtr32++; 00437 data16 = (UINT16)(data32>>14) & 0x0FFC0; 00438 *destPtr16++ = data16 | data16>>10; 00439 data16 = (UINT16)(data32>>4) & 0x0FFC0; 00440 *destPtr16++ = data16 | data16>>10; 00441 data16 = (UINT16)(data32<<6); 00442 *destPtr16++ = data16 | data16>>10; 00443 } 00444 } 00445 LH_END_PROC("Convert10To16") 00446 return err; 00447 } 00448 00449 #ifdef __MWERKS__ 00450 #pragma mark ================ setup & checking ================ 00451 #endif 00452 00453 /*-------------------------------------------------------------------------------------------------------------- 00454 FillLutParam 00455 --------------------------------------------------------------------------------------------------------------*/ 00456 CMError 00457 FillLutParam ( CMLutParamPtr lutParam, 00458 CMMModelPtr modelingData ) 00459 { 00460 CMError err = noErr; 00461 00462 LH_START_PROC("FillLutParam") 00463 *lutParam = (modelingData)->lutParam; 00464 #if ! LUTS_ARE_PTR_BASED 00465 lutParam->inputLut = DATA_2_PTR(modelingData)->lutParam.inputLut; 00466 lutParam->outputLut = DATA_2_PTR(modelingData)->lutParam.outputLut; 00467 lutParam->colorLut = DATA_2_PTR(modelingData)->lutParam.colorLut; 00468 #endif 00469 LH_END_PROC("FillLutParam") 00470 return err; 00471 } 00472 00473 /*-------------------------------------------------------------------------------------------------------------- 00474 FillLutParamChk 00475 --------------------------------------------------------------------------------------------------------------*/ 00476 CMError 00477 FillLutParamChk ( CMLutParamPtr lutParam, 00478 CMMModelPtr modelingData ) 00479 { 00480 CMError err = noErr; 00481 00482 LH_START_PROC("FillLutParamChk") 00483 *lutParam = (modelingData)->gamutLutParam; 00484 #if ! LUTS_ARE_PTR_BASED 00485 lutParam->inputLut = DATA_2_PTR(modelingData)->gamutLutParam.inputLut; 00486 lutParam->outputLut = DATA_2_PTR(modelingData)->gamutLutParam.outputLut; 00487 lutParam->colorLut = DATA_2_PTR(modelingData)->gamutLutParam.colorLut; 00488 #endif 00489 LH_END_PROC("FillLutParamChk") 00490 return err; 00491 } 00492 00493 /*-------------------------------------------------------------------------------------------------------------- 00494 FillCalcParam 00495 --------------------------------------------------------------------------------------------------------------*/ 00496 CMError 00497 FillCalcParam ( CMCalcParamPtr calcParam, 00498 const CMBitmap * bitMap, 00499 const CMBitmap * matchedBitMap ) 00500 { 00501 CMError err = noErr; 00502 00503 LH_START_PROC("FillCalcParam") 00504 00505 calcParam->cmInputColorSpace = bitMap->space; 00506 calcParam->cmOutputColorSpace = matchedBitMap->space; 00507 calcParam->cmPixelPerLine = bitMap->width; 00508 calcParam->cmInputBytesPerLine = bitMap->rowBytes; 00509 calcParam->cmOutputBytesPerLine = matchedBitMap->rowBytes; 00510 calcParam->cmLineCount = bitMap->height; 00511 00512 LH_END_PROC("FillCalcParam") 00513 return err; 00514 } 00515 00516 /*-------------------------------------------------------------------------------------------------------------- 00517 FillCalcParamCM 00518 --------------------------------------------------------------------------------------------------------------*/ 00519 CMError 00520 FillCalcParamCM ( CMCalcParamPtr calcParam, 00521 CMLutParamPtr lutParam, 00522 CMColor* myColors, 00523 SINT32 count ) 00524 { 00525 SINT32 loop; 00526 CMError err = noErr; 00527 00528 LH_START_PROC("FillCalcParamCM") 00529 00530 calcParam->cmInputPixelOffset = sizeof(CMColor); 00531 calcParam->cmOutputPixelOffset = sizeof(CMColor); 00532 00533 /* ---------------------------------------------------------- handle input */ 00534 switch (lutParam->colorLutInDim) 00535 { 00536 case 1: 00537 calcParam->cmInputColorSpace = cmGraySpace; /* cmGraySpace is 16 bit */ 00538 calcParam->inputData[0] = (Ptr)myColors; 00539 break; 00540 case 3: 00541 calcParam->cmInputColorSpace = cmRGBSpace|cm16PerChannelPacking; 00542 calcParam->inputData[0] = ((Ptr)myColors); 00543 calcParam->inputData[1] = ((Ptr)myColors) + 2; 00544 calcParam->inputData[2] = ((Ptr)myColors) + 4; 00545 break; 00546 case 4: 00547 calcParam->cmInputColorSpace = cmCMYKSpace|cm16PerChannelPacking; 00548 calcParam->inputData[0] = ((Ptr)myColors); 00549 calcParam->inputData[1] = ((Ptr)myColors) + 2; 00550 calcParam->inputData[2] = ((Ptr)myColors) + 4; 00551 calcParam->inputData[3] = ((Ptr)myColors) + 6; 00552 break; 00553 case 5: 00554 case 6: 00555 case 7: 00556 case 8: 00557 #if ( CM_MAX_COLOR_CHANNELS == 15 ) 00558 case 2: 00559 case 9: 00560 case 10: 00561 case 11: 00562 case 12: 00563 case 13: 00564 case 14: 00565 case 15: 00566 #endif 00567 calcParam->cmInputColorSpace = cmMCFiveSpace + lutParam->colorLutInDim-5; 00568 calcParam->cmInputColorSpace |= cm8PerChannelPacking; 00569 for (loop = 0; loop<lutParam->colorLutInDim; loop++) 00570 calcParam->inputData[loop] = ((Ptr)myColors) + loop; 00571 break; 00572 } 00573 00574 /* ---------------------------------------------------------- handle output */ 00575 switch (lutParam->colorLutOutDim) 00576 { 00577 case 1: 00578 calcParam->cmOutputColorSpace = cmGraySpace; /* cmGraySpace is 16 bit */ 00579 calcParam->outputData[0] = (Ptr)myColors; 00580 break; 00581 case 3: 00582 calcParam->cmOutputColorSpace = cmRGBSpace|cm16PerChannelPacking; 00583 calcParam->outputData[0] = ((Ptr)myColors); 00584 calcParam->outputData[1] = ((Ptr)myColors) + 2; 00585 calcParam->outputData[2] = ((Ptr)myColors) + 4; 00586 break; 00587 case 4: 00588 calcParam->cmOutputColorSpace = cmCMYKSpace|cm16PerChannelPacking; 00589 calcParam->outputData[0] = ((Ptr)myColors); 00590 calcParam->outputData[1] = ((Ptr)myColors) + 2; 00591 calcParam->outputData[2] = ((Ptr)myColors) + 4; 00592 calcParam->outputData[3] = ((Ptr)myColors) + 6; 00593 break; 00594 case 5: 00595 case 6: 00596 case 7: 00597 case 8: 00598 #if ( CM_MAX_COLOR_CHANNELS == 15 ) 00599 case 2: 00600 case 9: 00601 case 10: 00602 case 11: 00603 case 12: 00604 case 13: 00605 case 14: 00606 case 15: 00607 #endif 00608 calcParam->cmOutputColorSpace = cmMCFiveSpace + lutParam->colorLutOutDim - 5; 00609 calcParam->cmOutputColorSpace |= cm8PerChannelPacking; 00610 for (loop = 0; loop<lutParam->colorLutOutDim; loop++) 00611 calcParam->outputData[loop] = ((Ptr)myColors) + loop; 00612 break; 00613 } 00614 calcParam->cmPixelPerLine = count; 00615 calcParam->cmInputBytesPerLine = count*sizeof(CMColor); 00616 calcParam->cmOutputBytesPerLine = count*sizeof(CMColor); 00617 calcParam->cmLineCount = 1; 00618 LH_END_PROC("FillCalcParamCM") 00619 return err; 00620 } 00621 00622 #ifdef PI_Application_h 00623 #define ALLOW_16BIT_DATA 00624 #else 00625 #define Byte_Factor 1 00626 #endif 00627 00628 CMError Do8To555Setup( CMCalcParamPtr calcParam, ColorSpaceInfo *info, SINT32 *theLinesAtOnce, long reverseOrder ); 00629 CMError Do8To555Setup( CMCalcParamPtr calcParam, ColorSpaceInfo *info, SINT32 *theLinesAtOnce, long reverseOrder ) 00630 { 00631 SINT32 newRowBytes,linesAtOnce,bufferSize; 00632 SINT16 iErr = noErr; 00633 00634 *theLinesAtOnce = 0; 00635 newRowBytes = calcParam->cmPixelPerLine * 3; /* TempBuffer -> cmRGB24Space */ 00636 linesAtOnce = (kMaxTempBlock) / newRowBytes; 00637 if (linesAtOnce == 0) 00638 linesAtOnce = 1; 00639 else if (linesAtOnce > calcParam->cmLineCount) 00640 linesAtOnce = calcParam->cmLineCount; 00641 00642 bufferSize = newRowBytes * linesAtOnce; 00643 info->processedLinesOut = 0; 00644 info->origSizeOut = 5; 00645 info->usedSizeOut = 8; 00646 info->tempOutBuffer = (void*)SmartNewPtr(bufferSize, &iErr); 00647 info->outputPixelSize = 16; 00648 if (iErr != noErr) 00649 { 00650 return iErr; 00651 } 00652 00653 calcParam->cmLineCount = linesAtOnce; 00654 calcParam->cmOutputColorSpace = cmRGB24Space; 00655 calcParam->cmOutputBytesPerLine = newRowBytes; 00656 if( reverseOrder ){ 00657 calcParam->outputData[2] = (Ptr)info->tempOutBuffer; 00658 calcParam->outputData[1] = ((Ptr)info->tempOutBuffer)+1; 00659 calcParam->outputData[0] = ((Ptr)info->tempOutBuffer)+2; 00660 } 00661 else{ 00662 calcParam->outputData[0] = (Ptr)info->tempOutBuffer; 00663 calcParam->outputData[1] = ((Ptr)info->tempOutBuffer)+1; 00664 calcParam->outputData[2] = ((Ptr)info->tempOutBuffer)+2; 00665 } 00666 calcParam->cmOutputPixelOffset = 3; 00667 *theLinesAtOnce = linesAtOnce; 00668 return 0; 00669 } 00670 00671 CMError Do555To8Setup( CMCalcParamPtr calcParam, ColorSpaceInfo *info, SINT32 *theLinesAtOnce, long reverseOrder ); 00672 CMError Do555To8Setup( CMCalcParamPtr calcParam, ColorSpaceInfo *info, SINT32 *theLinesAtOnce, long reverseOrder ) 00673 { 00674 SINT32 newRowBytes,linesAtOnce,bufferSize; 00675 SINT16 iErr = noErr; 00676 00677 *theLinesAtOnce = 0; 00678 newRowBytes = calcParam->cmPixelPerLine * 3; /* TempBuffer -> cmRGB24Space */ 00679 linesAtOnce = (kMaxTempBlock) / newRowBytes; 00680 if (linesAtOnce == 0) 00681 linesAtOnce = 1; 00682 else if (linesAtOnce > calcParam->cmLineCount) 00683 linesAtOnce = calcParam->cmLineCount; 00684 00685 bufferSize = newRowBytes * linesAtOnce; 00686 info->processedLinesIn = 0; 00687 info->origSizeIn = 5; 00688 info->usedSizeIn = 8; 00689 info->tempInBuffer = (void*)SmartNewPtr(bufferSize, &iErr); 00690 info->inputPixelSize = 16; 00691 if (iErr != noErr) 00692 { 00693 return iErr; 00694 } 00695 calcParam->cmLineCount = linesAtOnce; 00696 calcParam->cmInputColorSpace = cmRGB24Space; 00697 calcParam->cmInputBytesPerLine = newRowBytes; 00698 if( reverseOrder ){ 00699 calcParam->inputData[2] = (Ptr)info->tempInBuffer; 00700 calcParam->inputData[1] = ((Ptr)info->tempInBuffer)+1; 00701 calcParam->inputData[0] = ((Ptr)info->tempInBuffer)+2; 00702 } 00703 else{ 00704 calcParam->inputData[0] = (Ptr)info->tempInBuffer; 00705 calcParam->inputData[1] = ((Ptr)info->tempInBuffer)+1; 00706 calcParam->inputData[2] = ((Ptr)info->tempInBuffer)+2; 00707 } 00708 calcParam->cmInputPixelOffset = 3; 00709 *theLinesAtOnce = linesAtOnce; 00710 return noErr; 00711 } 00712 /*-------------------------------------------------------------------------------------------------------------- 00713 CheckInputColorSpace 00714 --------------------------------------------------------------------------------------------------------------*/ 00715 CMError 00716 CheckInputColorSpace (const CMBitmap* bitMap, 00717 CMCalcParamPtr calcParam, 00718 ColorSpaceInfo* info, 00719 OSType inColorSpace, 00720 long colorLutInDim ) 00721 { 00722 CMError err = noErr; 00723 SINT32 newRowBytes; 00724 SINT32 bufferSize; 00725 SINT32 linesAtOnce; 00726 SINT32 loop; 00727 SINT16 iErr = noErr; 00728 CMBitmapColorSpace inputBitMapColorSpace = calcParam->cmInputColorSpace; 00729 #ifdef ALLOW_16BIT_DATA 00730 UINT8 Byte_Factor=1; 00731 #endif 00732 00733 LH_START_PROC("CheckInputColorSpace") 00734 colorLutInDim=colorLutInDim; 00735 00736 #ifdef ALLOW_16BIT_DATA 00737 if( inputBitMapColorSpace & cm16PerChannelPacking && (inputBitMapColorSpace & 31) != cmGraySpace){ 00738 Byte_Factor = 2; 00739 inputBitMapColorSpace &= ~cm16PerChannelPacking; 00740 inputBitMapColorSpace |= cm8PerChannelPacking; 00741 } 00742 #endif 00743 info->origSizeIn = Byte_Factor*8; 00744 info->usedSizeIn = Byte_Factor*8; 00745 switch ( inputBitMapColorSpace ) 00746 { 00747 case cmNoSpace: 00748 case cmRGBSpace: /* "... bitmap never uses this constant alone..." */ 00749 case cmHSVSpace: /* "... bitmap never uses this constant alone..." */ 00750 case cmHLSSpace: /* "... bitmap never uses this constant alone..." */ 00751 case cmYXYSpace: /* "... bitmap never uses this constant alone..." */ 00752 case cmXYZSpace: /* "... bitmap never uses this constant alone..." */ 00753 case cmLUVSpace: /* "... bitmap never uses this constant alone..." */ 00754 case cmLABSpace: /* "... bitmap never uses this constant alone..." */ 00755 case cmMCFiveSpace: /* "... bitmap never uses this constant alone..." */ 00756 case cmMCSixSpace: /* "... bitmap never uses this constant alone..." */ 00757 case cmMCSevenSpace: /* "... bitmap never uses this constant alone..." */ 00758 case cmMCEightSpace: /* "... bitmap never uses this constant alone..." */ 00759 case cmGamutResultSpace: /* "... bitmap never uses this constant alone..." */ 00760 case cmGamutResult1Space: /* not as colorspace for CMMatchBitmap */ 00761 #ifdef PI_Application_h 00762 case cmYCCSpace: /* "... bitmap never uses this constant alone..." */ 00763 case cmBGRSpace: /* "... bitmap never uses this constant alone..." */ 00764 #endif 00765 err = cmInvalidSrcMap; 00766 break; 00767 case cmCMYKSpace: /* "... bitmap never uses this constant alone..." */ 00768 case cmKYMCSpace: /* "... bitmap never uses this constant alone..." */ 00769 err = cmInvalidSrcMap; 00770 #if ! realThing 00771 if ( (inColorSpace != icSigCmykData) && (inColorSpace != icSigCmyData) ) 00772 err = cmInvalidColorSpace; 00773 else 00774 { 00775 err = noErr; 00776 calcParam->inputData[0] = &bitMap->image[0]; 00777 calcParam->inputData[1] = &bitMap->image[2]; 00778 calcParam->inputData[2] = &bitMap->image[4]; 00779 calcParam->inputData[3] = &bitMap->image[6]; 00780 calcParam->cmInputPixelOffset = 8; 00781 info->origSizeIn = 16; 00782 info->usedSizeIn = 16; 00783 } 00784 #endif 00785 break; 00786 case cmGraySpace: 00787 if (inColorSpace != icSigGrayData) 00788 err = cmInvalidColorSpace; 00789 else 00790 { 00791 calcParam->inputData[0] = &bitMap->image[0]; 00792 calcParam->cmInputPixelOffset = 2; 00793 info->origSizeIn = 16; 00794 info->usedSizeIn = 16; 00795 info->inputPixelSize = 16; 00796 } 00797 break; 00798 case cmGrayASpace: 00799 if (inColorSpace != icSigGrayData) 00800 err = cmInvalidColorSpace; 00801 else 00802 { 00803 calcParam->inputData[0] = &bitMap->image[0]; 00804 calcParam->inputData[1] = &bitMap->image[2]; 00805 calcParam->cmInputPixelOffset = 4; 00806 info->origSizeIn = 16; 00807 info->usedSizeIn = 16; 00808 info->inputPixelSize = 32; 00809 } 00810 break; 00811 case cmLAB24Space: 00812 if (inColorSpace != icSigLabData) 00813 err = cmInvalidColorSpace; 00814 else 00815 { 00816 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 00817 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00818 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 00819 calcParam->cmInputPixelOffset = Byte_Factor*3; 00820 info->inputPixelSize = Byte_Factor*24; 00821 } 00822 break; 00823 00824 /* separated cmRGB24Space and cmRGB32Space to reflect the bitmap format definition changes. */ 00825 case cmRGB24Space: 00826 if (inColorSpace != icSigRgbData) 00827 err = cmInvalidColorSpace; 00828 else 00829 { 00830 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 00831 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00832 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 00833 calcParam->cmInputPixelOffset = Byte_Factor*3; 00834 info->inputPixelSize = Byte_Factor*24; 00835 } 00836 break; 00837 case cmRGB32Space: 00838 if (inColorSpace != icSigRgbData) 00839 err = cmInvalidColorSpace; 00840 else 00841 { 00842 calcParam->inputData[0] = &bitMap->image[Byte_Factor*1]; 00843 calcParam->inputData[1] = &bitMap->image[Byte_Factor*2]; 00844 calcParam->inputData[2] = &bitMap->image[Byte_Factor*3]; 00845 calcParam->inputData[3] = &bitMap->image[Byte_Factor*0]; 00846 calcParam->cmInputPixelOffset = Byte_Factor*4; 00847 info->inputPixelSize = Byte_Factor*32; 00848 } 00849 break; 00850 00851 case cmRGBASpace: 00852 case cmRGBA32Space: 00853 if (inColorSpace != icSigRgbData) 00854 err = cmInvalidColorSpace; 00855 else 00856 { 00857 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 00858 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00859 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 00860 calcParam->inputData[3] = &bitMap->image[Byte_Factor*3]; 00861 calcParam->cmInputPixelOffset = Byte_Factor*4; 00862 info->inputPixelSize = Byte_Factor*32; 00863 } 00864 break; 00865 00866 #ifdef PI_Application_h 00867 00868 case cmGraySpace|cm8PerChannelPacking: 00869 if (inColorSpace != icSigGrayData) 00870 err = cmInvalidColorSpace; 00871 else 00872 { 00873 calcParam->inputData[0] = &bitMap->image[0]; 00874 calcParam->cmInputPixelOffset = 1; 00875 info->origSizeIn = 8; 00876 info->usedSizeIn = 8; 00877 info->inputPixelSize = 8; 00878 } 00879 break; 00880 case cmGrayASpace|cm8PerChannelPacking: 00881 if (inColorSpace != icSigGrayData) 00882 err = cmInvalidColorSpace; 00883 else 00884 { 00885 calcParam->inputData[0] = &bitMap->image[0]; 00886 calcParam->inputData[1] = &bitMap->image[1]; 00887 calcParam->cmInputPixelOffset = 2; 00888 info->origSizeIn = 8; 00889 info->usedSizeIn = 8; 00890 info->inputPixelSize = 16; 00891 } 00892 break; 00893 00894 00895 case cmBGR24Space: 00896 if (inColorSpace != icSigRgbData) 00897 err = cmInvalidColorSpace; 00898 else 00899 { 00900 calcParam->inputData[0] = &bitMap->image[Byte_Factor*2]; 00901 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00902 calcParam->inputData[2] = &bitMap->image[Byte_Factor*0]; 00903 calcParam->cmInputPixelOffset = Byte_Factor*3; 00904 info->inputPixelSize = Byte_Factor*24; 00905 } 00906 break; 00907 case cmBGR32Space: 00908 if (inColorSpace != icSigRgbData) 00909 err = cmInvalidColorSpace; 00910 else 00911 { 00912 calcParam->inputData[0] = &bitMap->image[Byte_Factor*2]; 00913 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00914 calcParam->inputData[2] = &bitMap->image[Byte_Factor*0]; 00915 calcParam->inputData[3] = &bitMap->image[Byte_Factor*3]; 00916 calcParam->cmInputPixelOffset = Byte_Factor*4; 00917 info->inputPixelSize = Byte_Factor*32; 00918 } 00919 break; 00920 00921 case cmYCC32Space: 00922 if (inColorSpace != icSigYCbCrData) 00923 err = cmInvalidColorSpace; 00924 else 00925 { 00926 calcParam->inputData[0] = &bitMap->image[Byte_Factor*1]; 00927 calcParam->inputData[1] = &bitMap->image[Byte_Factor*2]; 00928 calcParam->inputData[2] = &bitMap->image[Byte_Factor*3]; 00929 calcParam->inputData[3] = &bitMap->image[Byte_Factor*0]; 00930 calcParam->cmInputPixelOffset = Byte_Factor*4; 00931 info->inputPixelSize = Byte_Factor*32; 00932 } 00933 break; 00934 case cmYCC24Space: 00935 if (inColorSpace != icSigYCbCrData) 00936 err = cmInvalidColorSpace; 00937 else 00938 { 00939 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 00940 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00941 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 00942 calcParam->cmInputPixelOffset = Byte_Factor*3; 00943 info->inputPixelSize = Byte_Factor*24; 00944 } 00945 break; 00946 00947 case cmYCCASpace: 00948 case cmYCCA32Space: 00949 if (inColorSpace != icSigYCbCrData) 00950 err = cmInvalidColorSpace; 00951 else 00952 { 00953 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 00954 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00955 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 00956 calcParam->inputData[3] = &bitMap->image[Byte_Factor*3]; 00957 calcParam->cmInputPixelOffset = Byte_Factor*4; 00958 info->inputPixelSize = Byte_Factor*32; 00959 } 00960 break; 00961 case cmAYCC32Space: 00962 if (inColorSpace != icSigYCbCrData) 00963 err = cmInvalidColorSpace; 00964 else 00965 { 00966 calcParam->inputData[0] = &bitMap->image[Byte_Factor*1]; 00967 calcParam->inputData[1] = &bitMap->image[Byte_Factor*2]; 00968 calcParam->inputData[2] = &bitMap->image[Byte_Factor*3]; 00969 calcParam->inputData[3] = &bitMap->image[Byte_Factor*0]; 00970 calcParam->cmInputPixelOffset = Byte_Factor*4; 00971 info->inputPixelSize = Byte_Factor*32; 00972 } 00973 break; 00974 case cmLong8ColorPacking + cmLABSpace: 00975 if (inColorSpace != icSigLabData) 00976 err = cmInvalidColorSpace; 00977 else 00978 { 00979 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 00980 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00981 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 00982 calcParam->inputData[3] = &bitMap->image[Byte_Factor*3]; 00983 calcParam->cmInputPixelOffset = Byte_Factor*4; 00984 info->inputPixelSize = Byte_Factor*32; 00985 } 00986 break; 00987 case cmLong8ColorPacking + cmXYZSpace: 00988 if (inColorSpace != icSigXYZData) 00989 err = cmInvalidColorSpace; 00990 else 00991 { 00992 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 00993 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 00994 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 00995 calcParam->inputData[3] = &bitMap->image[Byte_Factor*3]; 00996 calcParam->cmInputPixelOffset = Byte_Factor*4; 00997 info->inputPixelSize = Byte_Factor*32; 00998 } 00999 break; 01000 case cmLong8ColorPacking + cmYXYSpace: 01001 if (inColorSpace != icSigYxyData) 01002 err = cmInvalidColorSpace; 01003 else 01004 { 01005 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 01006 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 01007 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 01008 calcParam->inputData[3] = &bitMap->image[Byte_Factor*3]; 01009 calcParam->cmInputPixelOffset = Byte_Factor*4; 01010 info->inputPixelSize = Byte_Factor*32; 01011 } 01012 break; 01013 case cmGenericSpace + cm8PerChannelPacking: 01014 { 01015 for (loop = 0; loop< colorLutInDim; loop++) 01016 calcParam->inputData[loop] = &bitMap->image[Byte_Factor*loop]; 01017 calcParam->cmInputPixelOffset = Byte_Factor*colorLutInDim; 01018 info->inputPixelSize = Byte_Factor*colorLutInDim*8; 01019 } 01020 break; 01021 case cmGenericSpace + cmLong8ColorPacking: 01022 { 01023 for (loop = 0; loop< (colorLutInDim+1); loop++) 01024 calcParam->inputData[loop] = &bitMap->image[Byte_Factor*loop]; 01025 calcParam->cmInputPixelOffset = Byte_Factor*(colorLutInDim+1); 01026 info->inputPixelSize = Byte_Factor*(colorLutInDim+1)*8; 01027 } 01028 break; 01029 case cmCMY24Space: 01030 if ( inColorSpace != icSigCmyData ) 01031 err = cmInvalidColorSpace; 01032 else 01033 { 01034 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 01035 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 01036 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 01037 calcParam->cmInputPixelOffset = Byte_Factor*3; 01038 info->inputPixelSize = Byte_Factor*24; 01039 } 01040 break; 01041 #endif 01042 01043 case cmCMYK32Space: 01044 if ( (inColorSpace != icSigCmykData) && (inColorSpace != icSigCmyData) ) 01045 err = cmInvalidColorSpace; 01046 else 01047 { 01048 calcParam->inputData[0] = &bitMap->image[Byte_Factor*0]; 01049 calcParam->inputData[1] = &bitMap->image[Byte_Factor*1]; 01050 calcParam->inputData[2] = &bitMap->image[Byte_Factor*2]; 01051 calcParam->inputData[3] = &bitMap->image[Byte_Factor*3]; 01052 calcParam->cmInputPixelOffset = Byte_Factor*4; 01053 info->inputPixelSize = Byte_Factor*32; 01054 } 01055 break; 01056 case cmKYMC32Space: 01057 if ( (inColorSpace != icSigCmykData) && (inColorSpace != icSigCmyData) ) 01058 err = cmInvalidColorSpace; 01059 else 01060 { 01061 calcParam->inputData[3] = &bitMap->image[Byte_Factor*0]; 01062 calcParam->inputData[2] = &bitMap->image[Byte_Factor*1]; 01063 calcParam->inputData[1] = &bitMap->image[Byte_Factor*2]; 01064 calcParam->inputData[0] = &bitMap->image[Byte_Factor*3]; 01065 calcParam->cmInputPixelOffset = Byte_Factor*4; 01066 info->inputPixelSize = Byte_Factor*32; 01067 } 01068 break; 01069 case cmARGB32Space: 01070 if (inColorSpace != icSigRgbData) 01071 err = cmInvalidColorSpace; 01072 else 01073 { 01074 calcParam->inputData[0] = &bitMap->image[Byte_Factor*1]; 01075 calcParam->inputData[1] = &bitMap->image[Byte_Factor*2]; 01076 calcParam->inputData[2] = &bitMap->image[Byte_Factor*3]; 01077 calcParam->inputData[3] = &bitMap->image[Byte_Factor*0]; 01078 calcParam->cmInputPixelOffset = Byte_Factor*4; 01079 info->inputPixelSize = Byte_Factor*32; 01080 } 01081 break; 01082 case cmMCFive8Space: 01083 if (inColorSpace != icSigMCH5Data) 01084 err = cmInvalidColorSpace; 01085 else 01086 { 01087 for (loop = 0; loop< 5; loop++) 01088 calcParam->inputData[loop] = &bitMap->image[Byte_Factor*loop]; 01089 calcParam->cmInputPixelOffset = Byte_Factor*5; 01090 info->inputPixelSize = Byte_Factor*40; 01091 } 01092 break; 01093 case cmMCSix8Space: 01094 if (inColorSpace != icSigMCH6Data) 01095 err = cmInvalidColorSpace; 01096 else 01097 { 01098 for (loop = 0; loop< 6; loop++) 01099 calcParam->inputData[loop] = &bitMap->image[Byte_Factor*loop]; 01100 calcParam->cmInputPixelOffset = Byte_Factor*6; 01101 info->inputPixelSize = Byte_Factor*48; 01102 } 01103 break; 01104 case cmMCSeven8Space: 01105 if (inColorSpace != icSigMCH7Data) 01106 err = cmInvalidColorSpace; 01107 else 01108 { 01109 for (loop = 0; loop< 7; loop++) 01110 calcParam->inputData[loop] = &bitMap->image[Byte_Factor*loop]; 01111 calcParam->cmInputPixelOffset = Byte_Factor*7; 01112 info->inputPixelSize = Byte_Factor*56; 01113 } 01114 break; 01115 case cmMCEight8Space: 01116 if (inColorSpace != icSigMCH8Data) 01117 err = cmInvalidColorSpace; 01118 else 01119 { 01120 for (loop = 0; loop< 8; loop++) 01121 calcParam->inputData[loop] = &bitMap->image[Byte_Factor*loop]; 01122 calcParam->cmInputPixelOffset = Byte_Factor*8; 01123 info->inputPixelSize = Byte_Factor*64; 01124 } 01125 break; 01126 #if ( CM_MAX_COLOR_CHANNELS == 15 ) 01127 case cmMC98Space: 01128 case cmMCa8Space: 01129 case cmMCb8Space: 01130 case cmMCc8Space: 01131 case cmMCd8Space: 01132 case cmMCe8Space: 01133 case cmMCf8Space: 01134 case cmMC28Space: 01135 if (inColorSpace != icSigMCH8Data) 01136 err = cmInvalidColorSpace; 01137 else 01138 { 01139 for (loop = 0; loop< 8; loop++) 01140 calcParam->inputData[loop] = &bitMap->image[Byte_Factor*loop]; 01141 calcParam->cmInputPixelOffset = Byte_Factor*8; 01142 info->inputPixelSize = Byte_Factor*64; 01143 } 01144 break; 01145 #endif 01146 #ifdef PI_Application_h 01147 case cmWord5ColorPacking + cmLABSpace: 01148 if (inColorSpace != icSigLabData) 01149 err = cmInvalidColorSpace; 01150 else{ 01151 newRowBytes = calcParam->cmInputBytesPerLine; 01152 err = Do555To8Setup( calcParam, info, &linesAtOnce, 0 ); 01153 if( err ) goto CleanupAndExit; 01154 } 01155 break; 01156 case cmWord5ColorPacking + cmXYZSpace: 01157 if (inColorSpace != icSigXYZData) 01158 err = cmInvalidColorSpace; 01159 else{ 01160 newRowBytes = calcParam->cmInputBytesPerLine; 01161 err = Do555To8Setup( calcParam, info, &linesAtOnce, 0 ); 01162 if( err ) goto CleanupAndExit; 01163 } 01164 break; 01165 case cmWord5ColorPacking + cmYXYSpace: 01166 if (inColorSpace != icSigYxyData) 01167 err = cmInvalidColorSpace; 01168 else{ 01169 newRowBytes = calcParam->cmInputBytesPerLine; 01170 err = Do555To8Setup( calcParam, info, &linesAtOnce, 0 ); 01171 if( err ) goto CleanupAndExit; 01172 } 01173 break; 01174 case cmWord5ColorPacking + cmGenericSpace: 01175 { 01176 newRowBytes = calcParam->cmInputBytesPerLine; 01177 err = Do555To8Setup( calcParam, info, &linesAtOnce, 0 ); 01178 if( err ) goto CleanupAndExit; 01179 } 01180 break; 01181 case cmWord565ColorPacking + cmGenericSpace: 01182 { 01183 newRowBytes = calcParam->cmInputBytesPerLine; 01184 err = Do555To8Setup( calcParam, info, &linesAtOnce, 0 ); 01185 if( err ) goto CleanupAndExit; 01186 info->origSizeIn = 6; 01187 } 01188 break; 01189 case cmWord5ColorPacking + cmBGRSpace: 01190 if (inColorSpace != icSigRgbData) 01191 err = cmInvalidColorSpace; 01192 else{ 01193 newRowBytes = calcParam->cmInputBytesPerLine; 01194 err = Do555To8Setup( calcParam, info, &linesAtOnce, 1 ); 01195 if( err ) goto CleanupAndExit; 01196 } 01197 break; 01198 case cmWord565ColorPacking + cmBGRSpace: 01199 if (inColorSpace != icSigRgbData) 01200 err = cmInvalidColorSpace; 01201 else{ 01202 newRowBytes = calcParam->cmInputBytesPerLine; 01203 err = Do555To8Setup( calcParam, info, &linesAtOnce, 1 ); 01204 if( err ) goto CleanupAndExit; 01205 info->origSizeIn = 6; 01206 } 01207 break; 01208 case cmRGB16_565Space: 01209 #endif 01210 case cmRGB16Space: 01211 if (inColorSpace != icSigRgbData) 01212 err = cmInvalidColorSpace; 01213 else{ 01214 newRowBytes = calcParam->cmInputBytesPerLine; 01215 err = Do555To8Setup( calcParam, info, &linesAtOnce, 0 ); 01216 if( err ) goto CleanupAndExit; 01217 #ifdef PI_Application_h 01218 if( inputBitMapColorSpace == cmRGB16_565Space ){ 01219 info->origSizeIn = 6; 01220 } 01221 #endif 01222 } 01223 break; 01224 case cmNamedIndexed32Space: 01225 if( (inputBitMapColorSpace == cmNamedIndexed32Space) && (inColorSpace != icSigNamedData)){ 01226 err = cmInvalidColorSpace; 01227 } 01228 else{ 01229 newRowBytes = calcParam->cmPixelPerLine * 3; /* TempBuffer -> 32 BIT */ 01230 linesAtOnce = (kMaxTempBlock) / newRowBytes; 01231 if (linesAtOnce == 0) 01232 linesAtOnce = 1; 01233 else if (linesAtOnce > calcParam->cmLineCount) 01234 linesAtOnce = calcParam->cmLineCount; 01235 01236 bufferSize = newRowBytes * linesAtOnce; 01237 info->processedLinesIn = 0; 01238 info->origSizeIn = 8; 01239 info->usedSizeIn = 8; 01240 info->tempInBuffer = (void*)SmartNewPtr(bufferSize, &iErr); 01241 info->inputPixelSize = 32; 01242 if (iErr != noErr) 01243 { 01244 err = iErr; 01245 goto CleanupAndExit; 01246 } 01247 01248 calcParam->cmLineCount = linesAtOnce; 01249 calcParam->cmInputColorSpace = cmLAB24Space; 01250 calcParam->inputData[0] = ((Ptr)info->tempInBuffer)+0; 01251 calcParam->inputData[1] = ((Ptr)info->tempInBuffer)+1; 01252 calcParam->inputData[2] = ((Ptr)info->tempInBuffer)+2; 01253 01254 calcParam->cmInputBytesPerLine = newRowBytes; 01255 calcParam->cmInputPixelOffset = 3; 01256 } 01257 break; 01258 case cmHSV32Space: 01259 case cmHLS32Space: 01260 case cmYXY32Space: 01261 case cmXYZ32Space: 01262 case cmLUV32Space: 01263 case cmLAB32Space: 01264 #ifdef PI_Application_h 01265 case cmBGRSpace + cmLong10ColorPacking: 01266 case cmRGBSpace + cmLong10ColorPacking: 01267 case cmGenericSpace + cmLong10ColorPacking: 01268 #endif 01269 if( ( ((inputBitMapColorSpace == cmHSV32Space) && (inColorSpace != icSigHsvData)) || 01270 ((inputBitMapColorSpace == cmHLS32Space) && (inColorSpace != icSigHlsData)) || 01271 ((inputBitMapColorSpace == cmYXY32Space) && (inColorSpace != icSigYxyData)) || 01272 ((inputBitMapColorSpace == cmXYZ32Space) && (inColorSpace != icSigXYZData)) || 01273 ((inputBitMapColorSpace == cmLUV32Space) && (inColorSpace != icSigLuvData)) || 01274 ((inputBitMapColorSpace == cmLAB32Space) && (inColorSpace != icSigLabData)) 01275 #ifdef PI_Application_h 01276 || ((inputBitMapColorSpace == cmBGRSpace + cmLong10ColorPacking) && (inColorSpace != icSigRgbData)) 01277 || ((inputBitMapColorSpace == cmRGBSpace + cmLong10ColorPacking) && (inColorSpace != icSigRgbData)) 01278 || ((inputBitMapColorSpace == cmGenericSpace + cmLong10ColorPacking) && (inColorSpace != icSigMCH3Data)) 01279 #endif 01280 ) 01281 #if ! realThing 01282 && FALSE 01283 #endif 01284 ) 01285 err = cmInvalidColorSpace; 01286 else{ 01287 newRowBytes = calcParam->cmPixelPerLine * 3 * sizeof(SINT16); /* TempBuffer -> cm16PerChannelPacking */ 01288 linesAtOnce = (kMaxTempBlock) / newRowBytes; 01289 if (linesAtOnce == 0) 01290 linesAtOnce = 1; 01291 else if (linesAtOnce > calcParam->cmLineCount) 01292 linesAtOnce = calcParam->cmLineCount; 01293 01294 bufferSize = newRowBytes * linesAtOnce; 01295 info->processedLinesIn = 0; 01296 info->origSizeIn = 10; 01297 info->usedSizeIn = 16; 01298 info->tempInBuffer = (void*)SmartNewPtr(bufferSize, &iErr); 01299 info->inputPixelSize = 32; 01300 if (iErr != noErr) 01301 { 01302 err = iErr; 01303 goto CleanupAndExit; 01304 } 01305 01306 calcParam->cmLineCount = linesAtOnce; 01307 if( inputBitMapColorSpace == cmBGRSpace + cmLong10ColorPacking ){ 01308 calcParam->cmInputColorSpace = cmBGRSpace; 01309 calcParam->inputData[0] = ((Ptr)info->tempInBuffer)+4; 01310 calcParam->inputData[1] = ((Ptr)info->tempInBuffer)+2; 01311 calcParam->inputData[2] = ((Ptr)info->tempInBuffer)+0; 01312 } 01313 else{ 01314 calcParam->cmInputColorSpace = cmRGBSpace; 01315 calcParam->inputData[0] = ((Ptr)info->tempInBuffer)+0; 01316 calcParam->inputData[1] = ((Ptr)info->tempInBuffer)+2; 01317 calcParam->inputData[2] = ((Ptr)info->tempInBuffer)+4; 01318 } 01319 calcParam->cmInputBytesPerLine = newRowBytes; 01320 calcParam->cmInputPixelOffset = 6; 01321 } 01322 break; 01323 default: 01324 err = cmInvalidSrcMap; 01325 break; 01326 } 01327 01328 CleanupAndExit: 01329 LH_END_PROC("CheckInputColorSpace") 01330 return err; 01331 } 01332 01333 /*-------------------------------------------------------------------------------------------------------------- 01334 CheckOutputColorSpace 01335 --------------------------------------------------------------------------------------------------------------*/ 01336 CMError 01337 CheckOutputColorSpace (const CMBitmap* bitMap, 01338 CMCalcParamPtr calcParam, 01339 ColorSpaceInfo* info, 01340 OSType outColorSpace, 01341 long colorLutOutDim ) 01342 { 01343 CMError err = noErr; 01344 SINT32 newRowBytes; 01345 SINT32 bufferSize; 01346 SINT32 linesAtOnce; 01347 SINT32 loop; 01348 SINT16 iErr = noErr; 01349 CMBitmapColorSpace outputBitMapColorSpace = calcParam->cmOutputColorSpace; 01350 #ifdef ALLOW_16BIT_DATA 01351 UINT8 Byte_Factor=1; 01352 #endif 01353 01354 LH_START_PROC("CheckOutputColorSpace") 01355 colorLutOutDim = colorLutOutDim; 01356 01357 #ifdef ALLOW_16BIT_DATA 01358 if( outputBitMapColorSpace & cm16PerChannelPacking && (outputBitMapColorSpace & 31) != cmGraySpace){ 01359 Byte_Factor = 2; 01360 outputBitMapColorSpace &= ~cm16PerChannelPacking; 01361 outputBitMapColorSpace |= cm8PerChannelPacking; 01362 } 01363 #endif 01364 info->origSizeOut = Byte_Factor*8; 01365 info->usedSizeOut = Byte_Factor*8; 01366 switch ( outputBitMapColorSpace ) 01367 { 01368 case cmNoSpace: 01369 case cmRGBSpace: /* "... bitmap never uses this constant alone..." */ 01370 case cmHSVSpace: /* "... bitmap never uses this constant alone..." */ 01371 case cmHLSSpace: /* "... bitmap never uses this constant alone..." */ 01372 case cmYXYSpace: /* "... bitmap never uses this constant alone..." */ 01373 case cmXYZSpace: /* "... bitmap never uses this constant alone..." */ 01374 case cmLUVSpace: /* "... bitmap never uses this constant alone..." */ 01375 case cmLABSpace: /* "... bitmap never uses this constant alone..." */ 01376 case cmMCFiveSpace: /* "... bitmap never uses this constant alone..." */ 01377 case cmMCSixSpace: /* "... bitmap never uses this constant alone..." */ 01378 case cmMCSevenSpace: /* "... bitmap never uses this constant alone..." */ 01379 case cmMCEightSpace: /* "... bitmap never uses this constant alone..." */ 01380 case cmGamutResultSpace: /* "... bitmap never uses this constant alone..." */ 01381 case cmGamutResult1Space: /* not as colorspace for CMMatchBitmap */ 01382 #ifdef PI_Application_h 01383 case cmYCCSpace: /* "... bitmap never uses this constant alone..." */ 01384 case cmBGRSpace: /* "... bitmap never uses this constant alone..." */ 01385 #endif 01386 err = cmInvalidDstMap; 01387 break; 01388 case cmCMYKSpace: /* "... bitmap never uses this constant alone..." */ 01389 case cmKYMCSpace: /* "... bitmap never uses this constant alone..." */ 01390 err = cmInvalidDstMap; 01391 #if ! realThing 01392 if ( (outColorSpace != icSigCmykData) && (outColorSpace != icSigCmyData) ) 01393 err = cmInvalidColorSpace; 01394 else 01395 { 01396 calcParam->outputData[0] = &bitMap->image[0]; 01397 calcParam->outputData[1] = &bitMap->image[2]; 01398 calcParam->outputData[2] = &bitMap->image[4]; 01399 calcParam->outputData[3] = &bitMap->image[6]; 01400 calcParam->cmOutputPixelOffset = 8; 01401 info->usedSizeOut = 16; 01402 } 01403 #endif 01404 break; 01405 case cmGraySpace: 01406 if (outColorSpace != icSigGrayData) 01407 err = cmInvalidColorSpace; 01408 else 01409 { 01410 calcParam->outputData[0] = &bitMap->image[0]; 01411 calcParam->cmOutputPixelOffset = 2; 01412 info->usedSizeOut = 16; 01413 info->outputPixelSize = 16; 01414 } 01415 break; 01416 case cmGrayASpace: 01417 if (outColorSpace != icSigGrayData) 01418 err = cmInvalidColorSpace; 01419 else 01420 { 01421 calcParam->outputData[0] = &bitMap->image[0]; 01422 calcParam->outputData[1] = &bitMap->image[2]; 01423 calcParam->cmOutputPixelOffset = 4; 01424 info->usedSizeOut = 16; 01425 info->outputPixelSize = 32; 01426 } 01427 break; 01428 case cmLAB24Space: 01429 if (outColorSpace != icSigLabData) 01430 err = cmInvalidColorSpace; 01431 else 01432 { 01433 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01434 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01435 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01436 calcParam->cmOutputPixelOffset = Byte_Factor*3; 01437 info->outputPixelSize = Byte_Factor*24; 01438 } 01439 break; 01440 01441 /* separated cmRGB24Space and cmRGB32Space to reflect the bitmap format definition changes. */ 01442 case cmRGB24Space: 01443 if (outColorSpace != icSigRgbData) 01444 err = cmInvalidColorSpace; 01445 else 01446 { 01447 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01448 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01449 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01450 calcParam->cmOutputPixelOffset = Byte_Factor*3; 01451 info->outputPixelSize = Byte_Factor*24; 01452 } 01453 break; 01454 case cmRGB32Space: 01455 if (outColorSpace != icSigRgbData) 01456 err = cmInvalidColorSpace; 01457 else 01458 { 01459 calcParam->outputData[0] = &bitMap->image[Byte_Factor*1]; 01460 calcParam->outputData[1] = &bitMap->image[Byte_Factor*2]; 01461 calcParam->outputData[2] = &bitMap->image[Byte_Factor*3]; 01462 calcParam->outputData[3] = &bitMap->image[Byte_Factor*0]; 01463 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01464 calcParam->clearMask = TRUE; 01465 info->outputPixelSize = Byte_Factor*32; 01466 } 01467 break; 01468 01469 case cmRGBASpace: 01470 case cmRGBA32Space: 01471 if (outColorSpace != icSigRgbData) 01472 err = cmInvalidColorSpace; 01473 else 01474 { 01475 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01476 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01477 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01478 calcParam->outputData[3] = &bitMap->image[Byte_Factor*3]; 01479 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01480 info->outputPixelSize = Byte_Factor*32; 01481 } 01482 break; 01483 01484 #ifdef PI_Application_h 01485 case cmGraySpace|cm8PerChannelPacking: 01486 if (outColorSpace != icSigGrayData) 01487 err = cmInvalidColorSpace; 01488 else 01489 { 01490 calcParam->outputData[0] = &bitMap->image[0]; 01491 calcParam->cmOutputPixelOffset = 1; 01492 info->usedSizeOut = 8; 01493 info->outputPixelSize = 8; 01494 } 01495 break; 01496 case cmGrayASpace|cm8PerChannelPacking: 01497 if (outColorSpace != icSigGrayData) 01498 err = cmInvalidColorSpace; 01499 else 01500 { 01501 calcParam->outputData[0] = &bitMap->image[0]; 01502 calcParam->outputData[1] = &bitMap->image[1]; 01503 calcParam->cmOutputPixelOffset = 2; 01504 info->usedSizeOut = 8; 01505 info->outputPixelSize = 16; 01506 } 01507 break; 01508 01509 case cmBGR24Space: 01510 if (outColorSpace != icSigRgbData) 01511 err = cmInvalidColorSpace; 01512 else 01513 { 01514 calcParam->outputData[0] = &bitMap->image[Byte_Factor*2]; 01515 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01516 calcParam->outputData[2] = &bitMap->image[Byte_Factor*0]; 01517 calcParam->cmOutputPixelOffset = Byte_Factor*3; 01518 info->outputPixelSize = Byte_Factor*24; 01519 } 01520 break; 01521 case cmBGR32Space: 01522 if (outColorSpace != icSigRgbData) 01523 err = cmInvalidColorSpace; 01524 else 01525 { 01526 calcParam->outputData[0] = &bitMap->image[Byte_Factor*2]; 01527 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01528 calcParam->outputData[2] = &bitMap->image[Byte_Factor*0]; 01529 calcParam->outputData[3] = &bitMap->image[Byte_Factor*3]; 01530 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01531 calcParam->clearMask = FALSE; 01532 calcParam->copyAlpha = TRUE; 01533 info->outputPixelSize = Byte_Factor*32; 01534 } 01535 break; 01536 01537 case cmYCC24Space: /* cmYCC24Space and cmYCC32Space have the same value !!! */ 01538 if (outColorSpace != icSigYCbCrData) 01539 err = cmInvalidColorSpace; 01540 else 01541 { 01542 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01543 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01544 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01545 calcParam->cmOutputPixelOffset = Byte_Factor*3; 01546 info->outputPixelSize = Byte_Factor*24; 01547 } 01548 break; 01549 case cmYCC32Space: 01550 if (outColorSpace != icSigYCbCrData) 01551 err = cmInvalidColorSpace; 01552 else 01553 { 01554 calcParam->outputData[0] = &bitMap->image[Byte_Factor*1]; 01555 calcParam->outputData[1] = &bitMap->image[Byte_Factor*2]; 01556 calcParam->outputData[2] = &bitMap->image[Byte_Factor*3]; 01557 calcParam->outputData[3] = &bitMap->image[Byte_Factor*0]; 01558 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01559 calcParam->clearMask = TRUE; 01560 info->outputPixelSize = Byte_Factor*32; 01561 } 01562 break; 01563 01564 case cmYCCASpace: 01565 case cmYCCA32Space: 01566 if (outColorSpace != icSigYCbCrData) 01567 err = cmInvalidColorSpace; 01568 else 01569 { 01570 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01571 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01572 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01573 calcParam->outputData[3] = &bitMap->image[Byte_Factor*3]; 01574 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01575 info->outputPixelSize = Byte_Factor*32; 01576 } 01577 break; 01578 case cmAYCC32Space: 01579 if (outColorSpace != icSigYCbCrData) 01580 err = cmInvalidColorSpace; 01581 else 01582 { 01583 calcParam->outputData[0] = &bitMap->image[Byte_Factor*1]; 01584 calcParam->outputData[1] = &bitMap->image[Byte_Factor*2]; 01585 calcParam->outputData[2] = &bitMap->image[Byte_Factor*3]; 01586 calcParam->outputData[3] = &bitMap->image[Byte_Factor*0]; 01587 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01588 info->outputPixelSize = Byte_Factor*32; 01589 } 01590 break; 01591 case cmLong8ColorPacking + cmLABSpace: 01592 if (outColorSpace != icSigLabData) 01593 err = cmInvalidColorSpace; 01594 else 01595 { 01596 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01597 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01598 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01599 calcParam->outputData[3] = &bitMap->image[Byte_Factor*3]; 01600 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01601 info->outputPixelSize = Byte_Factor*32; 01602 } 01603 break; 01604 case cmLong8ColorPacking + cmXYZSpace: 01605 if (outColorSpace != icSigXYZData) 01606 err = cmInvalidColorSpace; 01607 else 01608 { 01609 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01610 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01611 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01612 calcParam->outputData[3] = &bitMap->image[Byte_Factor*3]; 01613 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01614 info->outputPixelSize = Byte_Factor*32; 01615 } 01616 break; 01617 case cmLong8ColorPacking + cmYXYSpace: 01618 if (outColorSpace != icSigYxyData) 01619 err = cmInvalidColorSpace; 01620 else 01621 { 01622 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01623 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01624 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01625 calcParam->outputData[3] = &bitMap->image[Byte_Factor*3]; 01626 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01627 info->outputPixelSize = Byte_Factor*32; 01628 } 01629 break; 01630 case cmGenericSpace + cm8PerChannelPacking: 01631 { 01632 for (loop = 0; loop< colorLutOutDim; loop++) 01633 calcParam->outputData[loop] = &bitMap->image[Byte_Factor*loop]; 01634 calcParam->cmOutputPixelOffset = Byte_Factor*colorLutOutDim; 01635 info->outputPixelSize = Byte_Factor*colorLutOutDim*8; 01636 } 01637 break; 01638 case cmGenericSpace + cmLong8ColorPacking: 01639 { 01640 for (loop = 0; loop< (colorLutOutDim+1); loop++) 01641 calcParam->outputData[loop] = &bitMap->image[Byte_Factor*loop]; 01642 calcParam->cmOutputPixelOffset = Byte_Factor*(colorLutOutDim+1); 01643 info->outputPixelSize = Byte_Factor*(colorLutOutDim+1)*8; 01644 } 01645 break; 01646 case cmCMY24Space: 01647 if ( outColorSpace != icSigCmyData ) 01648 err = cmInvalidColorSpace; 01649 else 01650 { 01651 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01652 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01653 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01654 calcParam->cmOutputPixelOffset = Byte_Factor*3; 01655 info->outputPixelSize = Byte_Factor*24; 01656 } 01657 break; 01658 #endif 01659 01660 case cmCMYK32Space: 01661 if ( (outColorSpace != icSigCmykData) && (outColorSpace != icSigCmyData) ) 01662 err = cmInvalidColorSpace; 01663 else 01664 { 01665 calcParam->outputData[0] = &bitMap->image[Byte_Factor*0]; 01666 calcParam->outputData[1] = &bitMap->image[Byte_Factor*1]; 01667 calcParam->outputData[2] = &bitMap->image[Byte_Factor*2]; 01668 calcParam->outputData[3] = &bitMap->image[Byte_Factor*3]; 01669 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01670 if (outColorSpace == icSigCmyData) /* if we have CMY-Data - clear the k */ 01671 calcParam->clearMask = TRUE; 01672 info->outputPixelSize = Byte_Factor*32; 01673 } 01674 break; 01675 case cmKYMC32Space: 01676 if ( (outColorSpace != icSigCmykData) && (outColorSpace != icSigCmyData) ) 01677 err = cmInvalidColorSpace; 01678 else 01679 { 01680 calcParam->outputData[3] = &bitMap->image[Byte_Factor*0]; 01681 calcParam->outputData[2] = &bitMap->image[Byte_Factor*1]; 01682 calcParam->outputData[1] = &bitMap->image[Byte_Factor*2]; 01683 calcParam->outputData[0] = &bitMap->image[Byte_Factor*3]; 01684 calcParam->cmOutputPixelOffset = Byte_Factor*4; 01685 if (outColorSpace == icSigCmyData) /* if we have CMY-Data - clear the k */ 01686 calcParam->clearMask = TRUE; 01687 info->outputPixelSize = Byte_Factor*32; 01688 } 01689 break; 01690 case cmARGB32Space: 01691 if (outColorSpace != icSigRgbData) 01692 err = cmInvalidColorSpace; 01693 else 01694 { 01695 calcParam->outputData[0] = &bitMap->image[Byte_Factor*1]; 01696 calcParam->outputData[1] = &bitMap->image[Byte_Factor*2]; 01697 calcParam->outputData[2] = &bitMap->image[Byte_Factor*3]; 01698 calcParam->outputData[3] = &bitMap->image[Byte_Factor*0]; 01699 calcParam->cmOutputPixelOffset =Byte_Factor*4; 01700 info->outputPixelSize = Byte_Factor*32; 01701 } 01702 break; 01703 case cmMCFive8Space: 01704 if (outColorSpace != icSigMCH5Data) 01705 err = cmInvalidColorSpace; 01706 else 01707 { 01708 for (loop = 0; loop< 5; loop++) 01709 calcParam->outputData[loop] = &bitMap->image[Byte_Factor*loop]; 01710 calcParam->cmOutputPixelOffset = Byte_Factor*5; 01711 info->outputPixelSize = Byte_Factor*40; 01712 } 01713 break; 01714 case cmMCSix8Space: 01715 if (outColorSpace != icSigMCH6Data) 01716 err = cmInvalidColorSpace; 01717 else 01718 { 01719 for (loop = 0; loop< 6; loop++) 01720 calcParam->outputData[loop] = &bitMap->image[Byte_Factor*loop]; 01721 calcParam->cmOutputPixelOffset = Byte_Factor*6; 01722 info->outputPixelSize = Byte_Factor*48; 01723 } 01724 break; 01725 case cmMCSeven8Space: 01726 if (outColorSpace != icSigMCH7Data) 01727 err = cmInvalidColorSpace; 01728 else 01729 { 01730 for (loop = 0; loop< 7; loop++) 01731 calcParam->outputData[loop] = &bitMap->image[Byte_Factor*loop]; 01732 calcParam->cmOutputPixelOffset = Byte_Factor*7; 01733 info->outputPixelSize = Byte_Factor*56; 01734 } 01735 break; 01736 case cmMCEight8Space: 01737 if (outColorSpace != icSigMCH8Data) 01738 err = cmInvalidColorSpace; 01739 else 01740 { 01741 for (loop = 0; loop< 8; loop++) 01742 calcParam->outputData[loop] = &bitMap->image[Byte_Factor*loop]; 01743 calcParam->cmOutputPixelOffset = Byte_Factor*8; 01744 info->outputPixelSize = Byte_Factor*64; 01745 } 01746 break; 01747 #ifdef PI_Application_h 01748 case cmWord5ColorPacking + cmLABSpace: 01749 if (outColorSpace != icSigLabData) 01750 err = cmInvalidColorSpace; 01751 else{ 01752 err = Do8To555Setup( calcParam, info, &linesAtOnce, 0 ); 01753 if( err ) goto CleanupAndExit; 01754 } 01755 break; 01756 case cmWord5ColorPacking + cmXYZSpace: 01757 if (outColorSpace != icSigXYZData) 01758 err = cmInvalidColorSpace; 01759 else{ 01760 err = Do8To555Setup( calcParam, info, &linesAtOnce, 0 ); 01761 if( err ) goto CleanupAndExit; 01762 } 01763 break; 01764 case cmWord5ColorPacking + cmYXYSpace: 01765 if (outColorSpace != icSigYxyData) 01766 err = cmInvalidColorSpace; 01767 else{ 01768 err = Do8To555Setup( calcParam, info, &linesAtOnce, 0 ); 01769 if( err ) goto CleanupAndExit; 01770 } 01771 break; 01772 case cmWord5ColorPacking + cmGenericSpace: 01773 { 01774 err = Do8To555Setup( calcParam, info, &linesAtOnce, 0 ); 01775 if( err ) goto CleanupAndExit; 01776 } 01777 break; 01778 case cmWord565ColorPacking + cmGenericSpace: 01779 { 01780 err = Do8To555Setup( calcParam, info, &linesAtOnce, 0 ); 01781 if( err ) goto CleanupAndExit; 01782 info->origSizeOut = 6; 01783 } 01784 break; 01785 case cmWord5ColorPacking + cmBGRSpace: 01786 if (outColorSpace != icSigRgbData) 01787 err = cmInvalidColorSpace; 01788 else{ 01789 err = Do8To555Setup( calcParam, info, &linesAtOnce, 1 ); 01790 if( err ) goto CleanupAndExit; 01791 } 01792 break; 01793 case cmWord565ColorPacking + cmBGRSpace: 01794 if (outColorSpace != icSigRgbData) 01795 err = cmInvalidColorSpace; 01796 else{ 01797 err = Do8To555Setup( calcParam, info, &linesAtOnce, 1 ); 01798 if( err ) goto CleanupAndExit; 01799 info->origSizeOut = 6; 01800 } 01801 break; 01802 case cmRGB16_565Space: 01803 #endif 01804 case cmRGB16Space: 01805 if (outColorSpace != icSigRgbData) 01806 err = cmInvalidColorSpace; 01807 else{ 01808 err = Do8To555Setup( calcParam, info, &linesAtOnce, 0 ); 01809 if( err ) goto CleanupAndExit; 01810 #ifdef PI_Application_h 01811 if( outputBitMapColorSpace == cmRGB16_565Space ){ 01812 info->origSizeOut = 6; 01813 } 01814 #endif 01815 } 01816 break; 01817 case cmNamedIndexed32Space: 01818 if( (outColorSpace == cmNamedIndexed32Space) && (outColorSpace != icSigNamedData)){ 01819 err = cmInvalidColorSpace; 01820 } 01821 else{ 01822 calcParam->outputData[0] = &bitMap->image[0]; 01823 calcParam->outputData[1] = &bitMap->image[1]; 01824 calcParam->outputData[2] = &bitMap->image[2]; 01825 calcParam->outputData[3] = &bitMap->image[3]; 01826 calcParam->cmOutputPixelOffset = 4; 01827 info->outputPixelSize = 32; 01828 } 01829 break; 01830 case cmHSV32Space: 01831 case cmHLS32Space: 01832 case cmYXY32Space: 01833 case cmXYZ32Space: 01834 case cmLUV32Space: 01835 case cmLAB32Space: 01836 #ifdef PI_Application_h 01837 case cmBGRSpace + cmLong10ColorPacking: 01838 case cmRGBSpace + cmLong10ColorPacking: 01839 case cmGenericSpace + cmLong10ColorPacking: 01840 #endif 01841 if ( ( ((outputBitMapColorSpace == cmHSV32Space) && (outColorSpace != icSigHsvData)) || 01842 ((outputBitMapColorSpace == cmHLS32Space) && (outColorSpace != icSigHlsData)) || 01843 ((outputBitMapColorSpace == cmYXY32Space) && (outColorSpace != icSigYxyData)) || 01844 ((outputBitMapColorSpace == cmXYZ32Space) && (outColorSpace != icSigXYZData)) || 01845 ((outputBitMapColorSpace == cmLUV32Space) && (outColorSpace != icSigLuvData)) || 01846 ((outputBitMapColorSpace == cmLAB32Space) && (outColorSpace != icSigLabData)) 01847 #ifdef PI_Application_h 01848 || ((outputBitMapColorSpace == cmBGRSpace + cmLong10ColorPacking) && (outColorSpace != icSigRgbData)) 01849 || ((outputBitMapColorSpace == cmRGBSpace + cmLong10ColorPacking) && (outColorSpace != icSigRgbData)) 01850 || ((outputBitMapColorSpace == cmGenericSpace + cmLong10ColorPacking) && (outColorSpace != icSigMCH3Data)) 01851 #endif 01852 ) 01853 #if ! realThing 01854 && FALSE 01855 #endif 01856 ) 01857 err = cmInvalidColorSpace; 01858 else{ 01859 newRowBytes = calcParam->cmPixelPerLine * 3 * sizeof(SINT16); /* TempBuffer -> cm16PerChannelPacking */ 01860 linesAtOnce = (kMaxTempBlock) / newRowBytes; 01861 if (linesAtOnce == 0) 01862 linesAtOnce = 1; 01863 else if (linesAtOnce > calcParam->cmLineCount) 01864 linesAtOnce = calcParam->cmLineCount; 01865 01866 bufferSize = newRowBytes * linesAtOnce; 01867 info->processedLinesOut = 0; 01868 info->origSizeOut = 10; 01869 info->usedSizeOut = 16; 01870 info->tempOutBuffer = (void*)SmartNewPtr(bufferSize, &iErr); 01871 info->outputPixelSize = 32; 01872 if (iErr != noErr) 01873 { 01874 err = iErr; 01875 goto CleanupAndExit; 01876 } 01877 01878 calcParam->cmLineCount = linesAtOnce; 01879 calcParam->cmOutputBytesPerLine = newRowBytes; 01880 if( outputBitMapColorSpace == cmBGRSpace + cmLong10ColorPacking ){ 01881 calcParam->cmOutputColorSpace = cmBGRSpace; 01882 calcParam->outputData[0] = ((Ptr)info->tempOutBuffer)+4; 01883 calcParam->outputData[1] = ((Ptr)info->tempOutBuffer)+2; 01884 calcParam->outputData[2] = ((Ptr)info->tempOutBuffer)+0; 01885 } 01886 else{ 01887 calcParam->cmOutputColorSpace = cmRGBSpace; 01888 calcParam->outputData[0] = ((Ptr)info->tempOutBuffer)+0; 01889 calcParam->outputData[1] = ((Ptr)info->tempOutBuffer)+2; 01890 calcParam->outputData[2] = ((Ptr)info->tempOutBuffer)+4; 01891 } 01892 calcParam->cmOutputPixelOffset = 6; 01893 } 01894 break; 01895 default: 01896 err = cmInvalidDstMap; 01897 break; 01898 } 01899 01900 CleanupAndExit: 01901 LH_END_PROC("CheckOutputColorSpace") 01902 return err; 01903 } 01904 01905 01906 /*-------------------------------------------------------------------------------------------------------------- 01907 SetOutputColorSpaceInplace 01908 --------------------------------------------------------------------------------------------------------------*/ 01909 CMError 01910 SetOutputColorSpaceInplace ( CMCalcParamPtr calcParam, 01911 ColorSpaceInfo* info, 01912 OSType outColorSpace ) 01913 { 01914 CMError err = noErr; 01915 01916 LH_START_PROC("SetOutputColorSpaceInplace") 01917 01918 switch ( outColorSpace ) 01919 { 01920 case icSigXYZData: 01921 calcParam->cmOutputColorSpace = cmXYZ32Space; 01922 break; 01923 case icSigLuvData: 01924 calcParam->cmOutputColorSpace = cmLUV32Space; 01925 break; 01926 case icSigYxyData: 01927 calcParam->cmOutputColorSpace = cmYXY32Space; 01928 break; 01929 case icSigHsvData: 01930 calcParam->cmOutputColorSpace = cmHSV32Space; 01931 break; 01932 case icSigHlsData: 01933 calcParam->cmOutputColorSpace = cmHLS32Space; 01934 break; 01935 case icSigGrayData: 01936 if (calcParam->cmInputPixelOffset == 1) 01937 calcParam->cmOutputColorSpace = cmGraySpace|cm8PerChannelPacking; 01938 else if (calcParam->cmInputPixelOffset == 2) 01939 calcParam->cmOutputColorSpace = cmGraySpace; 01940 else 01941 calcParam->cmOutputColorSpace = cmGrayASpace; 01942 break; 01943 01944 case icSigRgbData: 01945 /* based on the size of the input bitmap, select the right rgb packing format */ 01946 #ifdef PI_Application_h 01947 if( (calcParam->cmInputColorSpace & 0x1f) == cmBGRSpace ){ 01948 if (info->inputPixelSize < 24){ 01949 if (info->origSizeIn == 6){ 01950 calcParam->cmOutputColorSpace = cmBGRSpace|cmWord565ColorPacking; 01951 } 01952 else{ /* output is 5 bit */ 01953 calcParam->cmOutputColorSpace = cmBGRSpace|cmWord5ColorPacking; 01954 } 01955 } 01956 if (info->inputPixelSize < 32) 01957 calcParam->cmOutputColorSpace = cmBGR24Space; 01958 else if (info->inputPixelSize == 32) 01959 calcParam->cmOutputColorSpace = cmBGR32Space; 01960 else if (info->inputPixelSize == 48) 01961 calcParam->cmOutputColorSpace = cmBGRSpace | cm16PerChannelPacking; 01962 else if (info->inputPixelSize == 64) 01963 calcParam->cmOutputColorSpace = cmBGR32Space | cm16PerChannelPacking; 01964 break; 01965 } 01966 #endif 01967 if (info->inputPixelSize < 24) 01968 #ifdef PI_Application_h 01969 if (info->origSizeIn == 6){ 01970 calcParam->cmOutputColorSpace = cmRGB16_565Space; 01971 } 01972 else /* output is 5 bit */ 01973 #endif 01974 calcParam->cmOutputColorSpace = cmRGB16Space; 01975 else if (info->inputPixelSize < 32) 01976 calcParam->cmOutputColorSpace = cmRGB24Space; 01977 else if (info->inputPixelSize == 32) 01978 calcParam->cmOutputColorSpace = cmRGB32Space; 01979 else if (info->inputPixelSize == 48) 01980 calcParam->cmOutputColorSpace = cmRGBSpace | cm16PerChannelPacking; 01981 else if (info->inputPixelSize == 64) 01982 calcParam->cmOutputColorSpace = cmRGB32Space | cm16PerChannelPacking; 01983 break; 01984 01985 case icSigLabData: 01986 /* based on the size of the input bitmap, select the right lab packing format */ 01987 if (info->inputPixelSize < 32) 01988 calcParam->cmOutputColorSpace = cmLAB24Space; 01989 else 01990 calcParam->cmOutputColorSpace = cmLAB32Space; 01991 break; 01992 01993 case icSigCmyData: 01994 calcParam->cmOutputColorSpace = cmCMY24Space; 01995 break; 01996 case icSigCmykData: 01997 #ifdef PI_Application_h 01998 if( (calcParam->cmInputColorSpace & 0x1f) == cmKYMCSpace ){ 01999 calcParam->cmOutputColorSpace = cmKYMC32Space; 02000 break; 02001 } 02002 #endif 02003 calcParam->cmOutputColorSpace = cmCMYK32Space; 02004 break; 02005 02006 case icSigMCH5Data: 02007 calcParam->cmOutputColorSpace = cmMCFive8Space; 02008 break; 02009 case icSigMCH6Data: 02010 calcParam->cmOutputColorSpace = cmMCSix8Space; 02011 break; 02012 case icSigMCH7Data: 02013 calcParam->cmOutputColorSpace = cmMCSeven8Space; 02014 break; 02015 case icSigMCH8Data: 02016 calcParam->cmOutputColorSpace = cmMCEight8Space; 02017 break; 02018 default: 02019 break; 02020 } 02021 02022 LH_END_PROC("SetOutputColorSpaceInplace") 02023 return err; 02024 } 02025 02026 /*-------------------------------------------------------------------------------------------------------------- 02027 CheckOutputColorSpaceChk 02028 --------------------------------------------------------------------------------------------------------------*/ 02029 CMError 02030 CheckOutputColorSpaceChk ( const CMBitmap* bitMap, 02031 CMCalcParamPtr calcParam, 02032 ColorSpaceInfo* info ) 02033 { 02034 CMError err = noErr; 02035 SINT32 newRowBytes; 02036 SINT32 bufferSize; 02037 SINT32 linesAtOnce; 02038 SINT16 iErr = noErr; 02039 02040 LH_START_PROC("CheckOutputColorSpaceChk") 02041 switch ( bitMap->space) 02042 { 02043 case cmGamutResult1Space: 02044 newRowBytes = calcParam->cmPixelPerLine; /* TempBuffer -> 1 byte per pixel */ 02045 linesAtOnce = (kMaxTempBlock) / newRowBytes; 02046 if (linesAtOnce == 0) 02047 linesAtOnce = 1; 02048 else if (linesAtOnce > calcParam->cmLineCount) 02049 linesAtOnce = calcParam->cmLineCount; 02050 02051 bufferSize = newRowBytes * linesAtOnce; 02052 info->processedLinesOut = 0; 02053 info->origSizeOut = 1; 02054 info->usedSizeOut = 8; /* ACHTUNG !!!!! bufferSize*info->usedSizeOut */ 02055 info->tempOutBuffer = (void*)SmartNewPtr(bufferSize*info->usedSizeOut, &iErr); 02056 if (iErr != noErr) 02057 { 02058 err = iErr; 02059 goto CleanupAndExit; 02060 } 02061 02062 calcParam->cmLineCount = linesAtOnce; 02063 calcParam->cmOutputColorSpace = cmGraySpace|cm8PerChannelPacking; 02064 calcParam->cmOutputBytesPerLine = newRowBytes; 02065 calcParam->outputData[0] = (Ptr)info->tempOutBuffer; 02066 calcParam->cmOutputPixelOffset = 1; 02067 break; 02068 case cmGamutResultSpace: 02069 newRowBytes = calcParam->cmPixelPerLine; /* TempBuffer -> 1 byte per pixel */ 02070 linesAtOnce = (kMaxTempBlock) / newRowBytes; 02071 if (linesAtOnce == 0) 02072 linesAtOnce = 1; 02073 else if (linesAtOnce > calcParam->cmLineCount) 02074 linesAtOnce = calcParam->cmLineCount; 02075 02076 bufferSize = newRowBytes * linesAtOnce; 02077 info->processedLinesOut = 0; 02078 info->origSizeOut = 8; 02079 info->usedSizeOut = 8; 02080 info->tempOutBuffer = 0; 02081 02082 calcParam->cmLineCount = linesAtOnce; 02083 calcParam->cmOutputColorSpace = cmGraySpace|cm8PerChannelPacking; 02084 calcParam->cmOutputBytesPerLine = newRowBytes; 02085 calcParam->cmOutputPixelOffset = 1; 02086 calcParam->outputData[0] = &bitMap->image[0]; 02087 break; 02088 default: 02089 err = cmInvalidDstMap; 02090 break; 02091 } 02092 CleanupAndExit: 02093 LH_END_PROC("CheckOutputColorSpaceChk") 02094 return err; 02095 } 02096 02097 /*-------------------------------------------------------------------------------------------------------------- 02098 AllocBufferCheckCM 02099 --------------------------------------------------------------------------------------------------------------*/ 02100 CMError 02101 AllocBufferCheckCM ( CMCalcParamPtr calcParam, 02102 ColorSpaceInfo* info ) 02103 { 02104 CMError err = noErr; 02105 SINT32 newRowBytes; 02106 SINT32 bufferSize; 02107 SINT32 linesAtOnce; 02108 SINT16 iErr = noErr; 02109 02110 LH_START_PROC("AllocBufferCheckCM") 02111 newRowBytes = calcParam->cmPixelPerLine; /* TempBuffer -> 1 byte per pixel */ 02112 linesAtOnce = (kMaxTempBlock) / newRowBytes; 02113 if (linesAtOnce == 0) 02114 linesAtOnce = 1; 02115 else if (linesAtOnce > calcParam->cmLineCount) 02116 linesAtOnce = calcParam->cmLineCount; 02117 02118 bufferSize = newRowBytes * linesAtOnce; 02119 info->processedLinesOut = 0; 02120 info->origSizeOut = 1; 02121 info->usedSizeOut = 8; 02122 info->tempOutBuffer = (void*)SmartNewPtr(bufferSize, &iErr); 02123 if (iErr != noErr) 02124 { 02125 err = iErr; 02126 goto CleanupAndExit; 02127 } 02128 02129 calcParam->cmLineCount = linesAtOnce; 02130 calcParam->cmOutputColorSpace = cmGraySpace|cm8PerChannelPacking; 02131 calcParam->cmOutputBytesPerLine = newRowBytes; 02132 calcParam->outputData[0] = (Ptr)info->tempOutBuffer; 02133 calcParam->cmOutputPixelOffset = 1; 02134 02135 CleanupAndExit: 02136 LH_END_PROC("AllocBufferCheckCM") 02137 return err; 02138 } 02139 02140 /*-------------------------------------------------------------------------------------------------------------- 02141 FindLookupRoutine 02142 --------------------------------------------------------------------------------------------------------------*/ 02143 CalcProcPtr 02144 FindLookupRoutine ( const CMLutParam* lutParam, 02145 const ColorSpaceInfo* info ) 02146 { 02147 CalcProcPtr proc2call = nil; 02148 #ifdef DEBUG_OUTPUT 02149 CMError err = noErr; 02150 #endif 02151 LH_START_PROC("FindLookupRoutine") 02152 02153 switch ( lutParam->colorLutInDim ) 02154 { 02155 case 3: /* 3 -> */ 02156 switch ( lutParam->colorLutOutDim ) 02157 { 02158 case 3: /* 3 -> 3 */ 02159 switch (info->usedSizeIn) 02160 { 02161 case 8: /* 3 -> 3 Di 8 */ 02162 switch (info->usedSizeOut) 02163 { 02164 case 8: /* 3 -> 3 Di 8 Do 8 */ 02165 switch (lutParam->colorLutWordSize) 02166 { 02167 case 8: /* 3 -> 3 Di 8 Do 8 Lut 8 */ 02168 switch (lutParam->colorLutGridPoints) 02169 { 02170 #if LH_CALC_ENGINE_ALL_FORMATS_LO 02171 case 16: /* 3 -> 3 Di 8 Do 8 Lut 8 Grid 16 */ 02172 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16_LO); 02173 break; 02174 #endif 02175 case 32: /* 3 -> 3 Di 8 Do 8 Lut 8 Grid 32 */ 02176 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32_LO); 02177 break; 02178 } 02179 break; 02180 #if LH_CALC_ENGINE_ALL_FORMATS_LO 02181 case 16: /* 3 -> 3 Di 8 Do 8 Lut 16 */ 02182 switch (lutParam->colorLutGridPoints) 02183 { 02184 case 16: /* 3 -> 3 Di 8 Do 8 Lut 16 Grid 16 */ 02185 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G16_LO); 02186 break; 02187 case 32: /* 3 -> 3 Di 8 Do 8 Lut 16 Grid 32 */ 02188 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G32_LO); 02189 break; 02190 } 02191 break; 02192 #endif 02193 } 02194 break; 02195 #if LH_CALC_ENGINE_ALL_FORMATS_LO 02196 case 16: /* 3 -> 3 Di 8 Do 16 */ 02197 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02198 switch (lutParam->colorLutWordSize) 02199 { 02200 case 8: /* 3 -> 3 Di 8 Do 16 Lut 8 */ 02201 switch (lutParam->colorLutGridPoints) 02202 { 02203 case 16: /* 3 -> 3 Di 8 Do 16 Lut 8 Grid 16 */ 02204 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G16_LO); 02205 break; 02206 case 32: /* 3 -> 3 Di 8 Do 16 Lut 8 Grid 32 */ 02207 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G32_LO); 02208 break; 02209 } 02210 break; 02211 case 16: /* 3 -> 3 Di 8 Do 16 Lut 16 */ 02212 switch (lutParam->colorLutGridPoints) 02213 { 02214 case 16: /* 3 -> 3 Di 8 Do 16 Lut 16 Grid 16 */ 02215 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G16_LO); 02216 break; 02217 case 32: /* 3 -> 3 Di 8 Do 16 Lut 16 Grid 32 */ 02218 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G32_LO); 02219 break; 02220 } 02221 break; 02222 } 02223 #endif 02224 break; 02225 #endif 02226 } 02227 02228 break; 02229 #if LH_CALC_ENGINE_ALL_FORMATS_LO 02230 case 16: /* 3 -> 3 Di 16 */ 02231 switch (info->usedSizeOut) 02232 { 02233 case 8: /* 3 -> 3 Di 16 Do 8 */ 02234 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02235 switch (lutParam->colorLutWordSize) 02236 { 02237 case 8: /* 3 -> 3 Di 16 Do 8 Lut 8 */ 02238 switch (lutParam->colorLutGridPoints) 02239 { 02240 case 16: /* 3 -> 3 Di 16 Do 8 Lut 8 Grid 16 */ 02241 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G16_LO); 02242 break; 02243 case 32: /* 3 -> 3 Di 16 Do 8 Lut 8 Grid 32 */ 02244 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G32_LO); 02245 break; 02246 } 02247 break; 02248 case 16: /* 3 -> 3 Di 16 Do 8 Lut 16 */ 02249 switch (lutParam->colorLutGridPoints) 02250 { 02251 case 16: /* 3 -> 3 Di 16 Do 8 Lut 16 Grid 16 */ 02252 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G16_LO); 02253 break; 02254 case 32: /* 3 -> 3 Di 16 Do 8 Lut 16 Grid 32 */ 02255 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G32_LO); 02256 break; 02257 } 02258 break; 02259 } 02260 #endif 02261 break; 02262 case 16: /* 3 -> 3 Di 16 Do 16 */ 02263 #if LH_CALC_ENGINE_16_BIT_LO 02264 switch (lutParam->colorLutWordSize) 02265 { 02266 case 8: /* 3 -> 3 Di 16 Do 16 Lut 8 */ 02267 switch (lutParam->colorLutGridPoints) 02268 { 02269 case 16: /* 3 -> 3 Di 16 Do 16 Lut 8 Grid 16 */ 02270 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G16_LO); 02271 break; 02272 case 32: /* 3 -> 3 Di 16 Do 16 Lut 8 Grid 32 */ 02273 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G32_LO); 02274 break; 02275 } 02276 break; 02277 case 16: /* 3 -> 3 Di 16 Do 16 Lut 16 */ 02278 switch (lutParam->colorLutGridPoints) 02279 { 02280 case 16: /* 3 -> 3 Di 16 Do 16 Lut 16 Grid 16 */ 02281 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G16_LO); 02282 break; 02283 case 32: /* 3 -> 3 Di 16 Do 16 Lut 16 Grid 32 */ 02284 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G32_LO); 02285 break; 02286 } 02287 break; 02288 } 02289 #endif 02290 break; 02291 } 02292 break; 02293 #endif 02294 } 02295 break; 02296 #if LH_CALC_ENGINE_ALL_FORMATS_LO 02297 case 4: /* 3 -> 4 */ 02298 switch (info->usedSizeIn) 02299 { 02300 case 8: /* 3 -> 4 Di 8 */ 02301 switch (info->usedSizeOut) 02302 { 02303 case 8: /* 3 -> 4 Di 8 Do 8 */ 02304 switch (lutParam->colorLutWordSize) 02305 { 02306 case 8: /* 3 -> 4 Di 8 Do 8 Lut 8 */ 02307 switch (lutParam->colorLutGridPoints) 02308 { 02309 case 16: /* 3 -> 4 Di 8 Do 8 Lut 8 Grid 16 */ 02310 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16_LO); 02311 break; 02312 case 32: /* 3 -> 4 Di 8 Do 8 Lut 8 Grid 32 */ 02313 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32_LO); 02314 break; 02315 } 02316 break; 02317 case 16: /* 3 -> 4 Di 8 Do 8 Lut 16 */ 02318 switch (lutParam->colorLutGridPoints) 02319 { 02320 case 16: /* 3 -> 4 Di 8 Do 8 Lut 16 Grid 16 */ 02321 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G16_LO); 02322 break; 02323 case 32: /* 3 -> 4 Di 8 Do 8 Lut 16 Grid 32 */ 02324 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G32_LO); 02325 break; 02326 } 02327 break; 02328 } 02329 break; 02330 case 16: /* 3 -> 4 Di 8 Do 16 */ 02331 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02332 switch (lutParam->colorLutWordSize) 02333 { 02334 case 8: /* 3 -> 4 Di 8 Do 16 Lut 8 */ 02335 switch (lutParam->colorLutGridPoints) 02336 { 02337 case 16: /* 3 -> 4 Di 8 Do 16 Lut 8 Grid 16 */ 02338 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G16_LO); 02339 break; 02340 case 32: /* 3 -> 4 Di 8 Do 16 Lut 8 Grid 32 */ 02341 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G32_LO); 02342 break; 02343 } 02344 break; 02345 case 16: /* 3 -> 4 Di 8 Do 16 Lut 16 */ 02346 switch (lutParam->colorLutGridPoints) 02347 { 02348 case 16: /* 3 -> 4 Di 8 Do 16 Lut 16 Grid 16 */ 02349 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G16_LO); 02350 break; 02351 case 32: /* 3 -> 4 Di 8 Do 16 Lut 16 Grid 32 */ 02352 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G32_LO); 02353 break; 02354 } 02355 break; 02356 } 02357 #endif 02358 break; 02359 } 02360 break; 02361 case 16: /* 3 -> 4 Di 16 */ 02362 switch (info->usedSizeOut) 02363 { 02364 case 8: /* 3 -> 4 Di 16 Do 8 */ 02365 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02366 switch (lutParam->colorLutWordSize) 02367 { 02368 case 8: /* 3 -> 4 Di 16 Do 8 Lut 8 */ 02369 switch (lutParam->colorLutGridPoints) 02370 { 02371 case 16: /* 3 -> 4 Di 16 Do 8 Lut 8 Grid 16 */ 02372 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G16_LO); 02373 break; 02374 case 32: /* 3 -> 4 Di 16 Do 8 Lut 8 Grid 32 */ 02375 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G32_LO); 02376 break; 02377 } 02378 break; 02379 case 16: /* 3 -> 4 Di 16 Do 8 Lut 16 */ 02380 switch (lutParam->colorLutGridPoints) 02381 { 02382 case 16: /* 3 -> 4 Di 16 Do 8 Lut 16 Grid 16 */ 02383 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G16_LO); 02384 break; 02385 case 32: /* 3 -> 4 Di 16 Do 8 Lut 16 Grid 32 */ 02386 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G32_LO); 02387 break; 02388 } 02389 break; 02390 } 02391 #endif 02392 break; 02393 case 16: /* 3 -> 4 Di 16 Do 16 */ 02394 #if LH_CALC_ENGINE_16_BIT_LO 02395 switch (lutParam->colorLutWordSize) 02396 { 02397 case 8: /* 3 -> 4 Di 16 Do 16 Lut 8 */ 02398 switch (lutParam->colorLutGridPoints) 02399 { 02400 case 16: /* 3 -> 4 Di 16 Do 16 Lut 8 Grid 16 */ 02401 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G16_LO); 02402 break; 02403 case 32: /* 3 -> 4 Di 16 Do 16 Lut 8 Grid 32 */ 02404 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G32_LO); 02405 break; 02406 } 02407 break; 02408 case 16: /* 3 -> 4 Di 16 Do 16 Lut 16 */ 02409 switch (lutParam->colorLutGridPoints) 02410 { 02411 case 16: /* 3 -> 4 Di 16 Do 16 Lut 16 Grid 16 */ 02412 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G16_LO); 02413 break; 02414 case 32: /* 3 -> 4 Di 16 Do 16 Lut 16 Grid 32 */ 02415 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G32_LO); 02416 break; 02417 } 02418 break; 02419 } 02420 #endif 02421 break; 02422 } 02423 break; 02424 } 02425 break; 02426 #endif 02427 } 02428 break; 02429 #if LH_CALC_ENGINE_ALL_FORMATS_LO 02430 case 4: /* 4 -> */ 02431 switch ( lutParam->colorLutOutDim ) 02432 { 02433 case 3: /* 4 -> 3 */ 02434 switch (info->usedSizeIn) 02435 { 02436 case 8: /* 4 -> 3 Di 8 */ 02437 switch (info->usedSizeOut) 02438 { 02439 case 8: /* 4 -> 3 Di 8 Do 8 */ 02440 switch (lutParam->colorLutWordSize) 02441 { 02442 case 8: /* 4 -> 3 Di 8 Do 8 Lut 8 */ 02443 switch (lutParam->colorLutGridPoints) 02444 { 02445 case 8: /* 4 -> 3 Di 8 Do 8 Lut 8 Grid 8 */ 02446 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8_LO); 02447 break; 02448 case 16: /* 4 -> 3 Di 8 Do 8 Lut 8 Grid 16 */ 02449 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16_LO); 02450 break; 02451 } 02452 break; 02453 case 16: /* 4 -> 3 Di 8 Do 8 Lut 16 */ 02454 switch (lutParam->colorLutGridPoints) 02455 { 02456 case 8: /* 4 -> 3 Di 8 Do 8 Lut 16 Grid 8 */ 02457 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G8_LO); 02458 break; 02459 case 16: /* 4 -> 3 Di 8 Do 8 Lut 16 Grid 16 */ 02460 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G16_LO); 02461 break; 02462 } 02463 break; 02464 } 02465 break; 02466 case 16: /* 4 -> 3 Di 8 Do 16 */ 02467 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02468 switch (lutParam->colorLutWordSize) 02469 { 02470 case 8: /* 4 -> 3 Di 8 Do 16 Lut 8 */ 02471 switch (lutParam->colorLutGridPoints) 02472 { 02473 case 8: /* 4 -> 3 Di 8 Do 16 Lut 8 Grid 8 */ 02474 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G8_LO); 02475 break; 02476 case 16: /* 4 -> 3 Di 8 Do 16 Lut 8 Grid 16 */ 02477 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G16_LO); 02478 break; 02479 } 02480 break; 02481 case 16: /* 4 -> 3 Di 8 Do 16 Lut 16 */ 02482 switch (lutParam->colorLutGridPoints) 02483 { 02484 case 8: /* 4 -> 3 Di 8 Do 16 Lut 16 Grid 8 */ 02485 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G8_LO); 02486 break; 02487 case 16: /* 4 -> 3 Di 8 Do 16 Lut 16 Grid 16 */ 02488 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G16_LO); 02489 break; 02490 } 02491 break; 02492 } 02493 #endif 02494 break; 02495 } 02496 break; 02497 case 16: /* 4 -> 3 Di 16 */ 02498 switch (info->usedSizeOut) 02499 { 02500 case 8: /* 4 -> 3 Di 16 Do 8 */ 02501 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02502 switch (lutParam->colorLutWordSize) 02503 { 02504 case 8: /* 4 -> 3 Di 16 Do 8 Lut 8 */ 02505 switch (lutParam->colorLutGridPoints) 02506 { 02507 case 8: /* 4 -> 3 Di 16 Do 8 Lut 8 Grid 8 */ 02508 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G8_LO); 02509 break; 02510 case 16: /* 4 -> 3 Di 16 Do 8 Lut 8 Grid 16 */ 02511 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G16_LO); 02512 break; 02513 } 02514 break; 02515 case 16: /* 4 -> 3 Di 16 Do 8 Lut 16 */ 02516 switch (lutParam->colorLutGridPoints) 02517 { 02518 case 8: /* 4 -> 3 Di 16 Do 8 Lut 16 Grid 8 */ 02519 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G8_LO); 02520 break; 02521 case 16: /* 4 -> 3 Di 16 Do 8 Lut 16 Grid 16 */ 02522 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G16_LO); 02523 break; 02524 } 02525 break; 02526 } 02527 #endif 02528 break; 02529 case 16: /* 4 -> 3 Di 16 Do 16 */ 02530 #if LH_CALC_ENGINE_16_BIT_LO 02531 switch (lutParam->colorLutWordSize) 02532 { 02533 case 8: /* 4 -> 3 Di 16 Do 16 Lut 8 */ 02534 switch (lutParam->colorLutGridPoints) 02535 { 02536 case 8: /* 4 -> 3 Di 16 Do 16 Lut 8 Grid 8 */ 02537 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G8_LO); 02538 break; 02539 case 16: /* 4 -> 3 Di 16 Do 16 Lut 8 Grid 16 */ 02540 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G16_LO); 02541 break; 02542 } 02543 break; 02544 case 16: /* 4 -> 3 Di 16 Do 16 Lut 16 */ 02545 switch (lutParam->colorLutGridPoints) 02546 { 02547 case 8: /* 4 -> 3 Di 16 Do 16 Lut 16 Grid 8 */ 02548 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G8_LO); 02549 break; 02550 case 16: /* 4 -> 3 Di 16 Do 16 Lut 16 Grid 16 */ 02551 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G16_LO); 02552 break; 02553 } 02554 break; 02555 } 02556 #endif 02557 break; 02558 } 02559 break; 02560 } 02561 break; 02562 case 4: /* 4 -> 4 */ 02563 switch (info->usedSizeIn) 02564 { 02565 case 8: /* 4 -> 4 Di 8 */ 02566 switch (info->usedSizeOut) 02567 { 02568 case 8: /* 4 -> 4 Di 8 Do 8 */ 02569 switch (lutParam->colorLutWordSize) 02570 { 02571 case 8: /* 4 -> 4 Di 8 Do 8 Lut 8 */ 02572 switch (lutParam->colorLutGridPoints) 02573 { 02574 case 8: /* 4 -> 4 Di 8 Do 8 Lut 8 Grid 8 */ 02575 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8_LO); 02576 break; 02577 case 16: /* 4 -> 4 Di 8 Do 8 Lut 8 Grid 16 */ 02578 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16_LO); 02579 break; 02580 } 02581 break; 02582 case 16: /* 4 -> 4 Di 8 Do 8 Lut 16 */ 02583 switch (lutParam->colorLutGridPoints) 02584 { 02585 case 8: /* 4 -> 4 Di 8 Do 8 Lut 16 Grid 8 */ 02586 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G8_LO); 02587 break; 02588 case 16: /* 4 -> 4 Di 8 Do 8 Lut 16 Grid 16 */ 02589 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G16_LO); 02590 break; 02591 } 02592 break; 02593 } 02594 break; 02595 case 16: /* 4 -> 4 Di 8 Do 16 */ 02596 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02597 switch (lutParam->colorLutWordSize) 02598 { 02599 case 8: /* 4 -> 4 Di 8 Do 16 Lut 8 */ 02600 switch (lutParam->colorLutGridPoints) 02601 { 02602 case 8: /* 4 -> 4 Di 8 Do 16 Lut 8 Grid 8 */ 02603 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G8_LO); 02604 break; 02605 case 16: /* 4 -> 4 Di 8 Do 16 Lut 8 Grid 16 */ 02606 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G16_LO); 02607 break; 02608 } 02609 break; 02610 case 16: /* 4 -> 4 Di 8 Do 16 Lut 16 */ 02611 switch (lutParam->colorLutGridPoints) 02612 { 02613 case 8: /* 4 -> 4 Di 8 Do 16 Lut 16 Grid 8 */ 02614 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G8_LO); 02615 break; 02616 case 16: /* 4 -> 4 Di 8 Do 16 Lut 16 Grid 16 */ 02617 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G16_LO); 02618 break; 02619 } 02620 break; 02621 } 02622 #endif 02623 break; 02624 } 02625 break; 02626 case 16: /* 4 -> 4 Di 16 */ 02627 switch (info->usedSizeOut) 02628 { 02629 case 8: /* 4 -> 4 Di 16 Do 8 */ 02630 #if LH_CALC_ENGINE_MIXED_DATAFORMAT 02631 switch (lutParam->colorLutWordSize) 02632 { 02633 case 8: /* 4 -> 4 Di 16 Do 8 Lut 8 */ 02634 switch (lutParam->colorLutGridPoints) 02635 { 02636 case 8: /* 4 -> 4 Di 16 Do 8 Lut 8 Grid 8 */ 02637 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G8_LO); 02638 break; 02639 case 16: /* 4 -> 4 Di 16 Do 8 Lut 8 Grid 16 */ 02640 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G16_LO); 02641 break; 02642 } 02643 break; 02644 case 16: /* 4 -> 4 Di 16 Do 8 Lut 16 */ 02645 switch (lutParam->colorLutGridPoints) 02646 { 02647 case 8: /* 4 -> 4 Di 16 Do 8 Lut 16 Grid 8 */ 02648 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G8_LO); 02649 break; 02650 case 16: /* 4 -> 4 Di 16 Do 8 Lut 16 Grid 16 */ 02651 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G16_LO); 02652 break; 02653 } 02654 break; 02655 } 02656 #endif 02657 break; 02658 case 16: /* 4 -> 4 Di 16 Do 16 */ 02659 #if LH_CALC_ENGINE_16_BIT_LO 02660 switch (lutParam->colorLutWordSize) 02661 { 02662 case 8: /* 4 -> 4 Di 16 Do 16 Lut 8 */ 02663 switch (lutParam->colorLutGridPoints) 02664 { 02665 case 8: /* 4 -> 4 Di 16 Do 16 Lut 8 Grid 8 */ 02666 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G8_LO); 02667 break; 02668 case 16: /* 4 -> 4 Di 16 Do 16 Lut 8 Grid 16 */ 02669 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G16_LO); 02670 break; 02671 } 02672 break; 02673 case 16: /* 4 -> 4 Di 16 Do 16 Lut 16 */ 02674 switch (lutParam->colorLutGridPoints) 02675 { 02676 case 8: /* 4 -> 4 Di 16 Do 16 Lut 16 Grid 8 */ 02677 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G8_LO); 02678 break; 02679 case 16: /* 4 -> 4 Di 16 Do 16 Lut 16 Grid 16 */ 02680 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G16_LO); 02681 break; 02682 } 02683 break; 02684 } 02685 #endif 02686 break; 02687 } 02688 break; 02689 } 02690 break; 02691 } 02692 break; 02693 #endif 02694 } 02695 02696 LH_END_PROC("FindLookupRoutine") 02697 return proc2call; 02698 } 02699 02700 #ifdef ALLOW_MMX 02701 #define cpuid __asm _emit 0x0F __asm _emit 0xA2 02702 02703 #define CPUID_FLAG 0x00200000 02704 #define MMX_FLAG 0x00800000 02705 #define FAMILY_5_FLAG 0x00000500 /* Pentium, not Pentium II */ 02706 #define FAMILY_MASK 0x00000F00 02707 02708 /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* 02709 * * 02710 * * 02711 * DetectMMX * 02712 * * 02713 * Inputs : none * 02714 * * 02715 * Outputs : TRUE - CPU has MMX * 02716 * * 02717 * Abstract : This function detects existance of MMX-Technology. * 02718 * * 02719 * * 02720 *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ 02721 02722 static LH_UINT32 DetectMMX (void) 02723 { 02724 LH_UINT32 fMMX = FALSE; 02725 02726 __asm { 02727 02728 push edx ; 02729 push ebx ; 02730 push eax ; 02731 pushfd ; Push flags on stack 02732 pop eax ; and get flags into eax 02733 xor eax, CPUID_FLAG ; Toggle CPUID flag 02734 push eax ; Move flags back into 02735 popfd ; flags reg 02736 pushfd ; Get flags into ebx 02737 pop ebx 02738 and ebx, CPUID_FLAG ; Mask CPUID flag 02739 and eax, CPUID_FLAG 02740 cmp eax, ebx ; Test toggled bit 02741 jnz Done ; CPU does not support CPUID 02742 02743 mov eax, 1 ; Set CPUID mode 02744 cpuid 02745 test edx, MMX_FLAG ; Check MMX-Technology bit 02746 jz Done ; CPU has no MMX-Technology 02747 and eax, FAMILY_MASK ; mask out family bits 02748 cmp eax, FAMILY_5_FLAG ; Check Family 5 bits 02749 jnz Done ; CPU has no MMX-Technology 02750 02751 mov fMMX, TRUE ; CPU has MMX-Technology 02752 Done: 02753 ;pushfd ; dummy 02754 pop eax ; 02755 pop ebx ; 02756 pop edx ; 02757 } 02758 02759 return (fMMX); 02760 } 02761 02762 #endif 02763 /*-------------------------------------------------------------------------------------------------------------- 02764 FindCalcRoutine 02765 --------------------------------------------------------------------------------------------------------------*/ 02766 CalcProcPtr 02767 FindCalcRoutine( const CMCalcParam* calcParam, 02768 const CMLutParam* lutParam, 02769 const ColorSpaceInfo* info, 02770 const Boolean lookupOnly ) 02771 { 02772 SINT32 index = 0; 02773 CalcProcPtr proc2call = nil; 02774 #ifdef DEBUG_OUTPUT 02775 CMError err = noErr; 02776 #endif 02777 02778 LH_START_PROC("FindCalcRoutine") 02779 02780 calcParam = calcParam; 02781 /* to reduce the code size change the next line to 0 - this will call DoNDim instead of the optimized functions */ 02782 #if 1 02783 if (lookupOnly) 02784 proc2call = FindLookupRoutine(lutParam, info); 02785 if (proc2call == nil) 02786 { 02787 switch ( lutParam->colorLutInDim ) 02788 { 02789 case 1: /* 1 -> */ 02790 switch ( lutParam->colorLutOutDim ) 02791 { 02792 case 1: /* 1 -> 1,3,4 */ 02793 case 3: /* 1 -> 1,3,4 */ 02794 case 4: /* 1 -> 1,3,4 */ 02795 switch (info->usedSizeIn) 02796 { 02797 case 8: /* 1 -> 1,3,4 Di 8 */ 02798 switch (info->usedSizeOut) 02799 { 02800 case 8: /* 1 -> 1,3,4 Di 8 Do 8 */ 02801 switch (lutParam->colorLutWordSize) 02802 { 02803 case 8: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 */ 02804 switch (lutParam->colorLutGridPoints) 02805 { 02806 #if LH_Calc1toX_Di8_Do8_Lut8_G128 != LH_CALC_USE_DO_N_DIM 02807 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 Grid 16 */ 02808 proc2call = NewCalcProc(LHCalc1toX_Di8_Do8_Lut8_G128); 02809 break; 02810 #endif 02811 } 02812 break; 02813 case 16: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 */ 02814 switch (lutParam->colorLutGridPoints) 02815 { 02816 #if LH_Calc1toX_Di8_Do8_Lut16_G128 != LH_CALC_USE_DO_N_DIM 02817 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 Grid 16 */ 02818 proc2call = NewCalcProc(LHCalc1toX_Di8_Do8_Lut16_G128); 02819 break; 02820 #endif 02821 } 02822 break; 02823 } 02824 break; 02825 case 16: /* 1 -> 1,3,4 Di 8 Do 16 */ 02826 switch (lutParam->colorLutWordSize) 02827 { 02828 case 8: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 */ 02829 switch (lutParam->colorLutGridPoints) 02830 { 02831 #if LH_Calc1toX_Di8_Do16_Lut8_G128 != LH_CALC_USE_DO_N_DIM 02832 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 Grid 16 */ 02833 proc2call = NewCalcProc(LHCalc1toX_Di8_Do16_Lut8_G128); 02834 break; 02835 #endif 02836 } 02837 break; 02838 case 16: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 */ 02839 switch (lutParam->colorLutGridPoints) 02840 { 02841 #if LH_Calc1toX_Di8_Do16_Lut16_G128 != LH_CALC_USE_DO_N_DIM 02842 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 Grid 16 */ 02843 proc2call = NewCalcProc(LHCalc1toX_Di8_Do16_Lut16_G128); 02844 break; 02845 #endif 02846 } 02847 break; 02848 } 02849 break; 02850 } 02851 break; 02852 case 16: /* 1 -> 1,3,4 Di 16 */ 02853 switch (info->usedSizeOut) 02854 { 02855 case 8: /* 1 -> 1,3,4 Di 8 Do 8 */ 02856 switch (lutParam->colorLutWordSize) 02857 { 02858 case 8: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 */ 02859 switch (lutParam->colorLutGridPoints) 02860 { 02861 #if LH_Calc1toX_Di16_Do8_Lut8_G128 != LH_CALC_USE_DO_N_DIM 02862 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 Grid 16 */ 02863 proc2call = NewCalcProc(LHCalc1toX_Di16_Do8_Lut8_G128); 02864 break; 02865 #endif 02866 } 02867 break; 02868 case 16: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 */ 02869 switch (lutParam->colorLutGridPoints) 02870 { 02871 #if LH_Calc1toX_Di16_Do8_Lut16_G128 != LH_CALC_USE_DO_N_DIM 02872 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 Grid 16 */ 02873 proc2call = NewCalcProc(LHCalc1toX_Di16_Do8_Lut16_G128); 02874 break; 02875 #endif 02876 } 02877 break; 02878 } 02879 break; 02880 case 16: /* 1 -> 1,3,4 Di 8 Do 16 */ 02881 switch (lutParam->colorLutWordSize) 02882 { 02883 case 8: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 */ 02884 switch (lutParam->colorLutGridPoints) 02885 { 02886 #if LH_Calc1toX_Di16_Do16_Lut8_G128 != LH_CALC_USE_DO_N_DIM 02887 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 8 Grid 16 */ 02888 proc2call = NewCalcProc(LHCalc1toX_Di16_Do16_Lut8_G128); 02889 break; 02890 #endif 02891 } 02892 break; 02893 case 16: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 */ 02894 switch (lutParam->colorLutGridPoints) 02895 { 02896 #if LH_Calc1toX_Di16_Do16_Lut16_G128 != LH_CALC_USE_DO_N_DIM 02897 case 128: /* 1 -> 1,3,4 Di 8 Do 8 Lut 16 Grid 16 */ 02898 proc2call = NewCalcProc(LHCalc1toX_Di16_Do16_Lut16_G128); 02899 break; 02900 #endif 02901 } 02902 break; 02903 } 02904 break; 02905 } 02906 break; 02907 } 02908 break; 02909 } 02910 break; 02911 case 3: /* 3 -> */ 02912 switch ( lutParam->colorLutOutDim ) 02913 { 02914 case 3: /* 3 -> 3 */ 02915 switch (info->usedSizeIn) 02916 { 02917 case 8: /* 3 -> 3 Di 8 */ 02918 switch (info->usedSizeOut) 02919 { 02920 case 8: /* 3 -> 3 Di 8 Do 8 */ 02921 switch (lutParam->colorLutWordSize) 02922 { 02923 case 8: /* 3 -> 3 Di 8 Do 8 Lut 8 */ 02924 switch (lutParam->colorLutGridPoints) 02925 { 02926 #if LH_Calc3to3_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 02927 case 16: /* 3 -> 3 Di 8 Do 8 Lut 8 Grid 16 */ 02928 #ifdef ALLOW_MMX 02929 if (DetectMMX()) { 02930 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16_F); 02931 } 02932 else 02933 #endif 02934 #if LH_CALC_USE_ADDITIONAL_OLD_CODE 02935 if( !info->inPlace ){ 02936 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16_Old); 02937 } 02938 else 02939 #endif 02940 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16); 02941 break; 02942 #endif 02943 #if LH_Calc3to3_Di8_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM 02944 case 32: /* 3 -> 3 Di 8 Do 8 Lut 8 Grid 32 */ 02945 #ifdef ALLOW_MMX 02946 if (DetectMMX()) { 02947 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32_F); 02948 } 02949 else 02950 #endif 02951 #if LH_CALC_USE_ADDITIONAL_OLD_CODE 02952 if( !info->inPlace ){ 02953 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32_Old); 02954 } 02955 else 02956 #endif 02957 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32); 02958 break; 02959 #endif 02960 } 02961 break; 02962 case 16: /* 3 -> 3 Di 8 Do 8 Lut 16 */ 02963 switch (lutParam->colorLutGridPoints) 02964 { 02965 #if LH_Calc3to3_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 02966 case 16: /* 3 -> 3 Di 8 Do 8 Lut 16 Grid 16 */ 02967 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G16); 02968 break; 02969 #endif 02970 #if LH_Calc3to3_Di8_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM 02971 case 32: /* 3 -> 3 Di 8 Do 8 Lut 16 Grid 32 */ 02972 proc2call = NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G32); 02973 break; 02974 #endif 02975 } 02976 break; 02977 } 02978 break; 02979 case 16: /* 3 -> 3 Di 8 Do 16 */ 02980 switch (lutParam->colorLutWordSize) 02981 { 02982 case 8: /* 3 -> 3 Di 8 Do 16 Lut 8 */ 02983 switch (lutParam->colorLutGridPoints) 02984 { 02985 #if LH_Calc3to3_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 02986 case 16: /* 3 -> 3 Di 8 Do 16 Lut 8 Grid 16 */ 02987 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G16); 02988 break; 02989 #endif 02990 #if LH_Calc3to3_Di8_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM 02991 case 32: /* 3 -> 3 Di 8 Do 16 Lut 8 Grid 32 */ 02992 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G32); 02993 break; 02994 #endif 02995 } 02996 break; 02997 case 16: /* 3 -> 3 Di 8 Do 16 Lut 16 */ 02998 switch (lutParam->colorLutGridPoints) 02999 { 03000 #if LH_Calc3to3_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03001 case 16: /* 3 -> 3 Di 8 Do 16 Lut 16 Grid 16 */ 03002 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G16); 03003 break; 03004 #endif 03005 #if LH_Calc3to3_Di8_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM 03006 case 32: /* 3 -> 3 Di 8 Do 16 Lut 16 Grid 32 */ 03007 proc2call = NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G32); 03008 break; 03009 #endif 03010 } 03011 break; 03012 } 03013 break; 03014 } 03015 break; 03016 case 16: /* 3 -> 3 Di 16 */ 03017 switch (info->usedSizeOut) 03018 { 03019 case 8: /* 3 -> 3 Di 16 Do 8 */ 03020 switch (lutParam->colorLutWordSize) 03021 { 03022 case 8: /* 3 -> 3 Di 16 Do 8 Lut 8 */ 03023 switch (lutParam->colorLutGridPoints) 03024 { 03025 #if LH_Calc3to3_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03026 case 16: /* 3 -> 3 Di 16 Do 8 Lut 8 Grid 16 */ 03027 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G16); 03028 break; 03029 #endif 03030 #if LH_Calc3to3_Di16_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM 03031 case 32: /* 3 -> 3 Di 16 Do 8 Lut 8 Grid 32 */ 03032 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G32); 03033 break; 03034 #endif 03035 } 03036 break; 03037 case 16: /* 3 -> 3 Di 16 Do 8 Lut 16 */ 03038 switch (lutParam->colorLutGridPoints) 03039 { 03040 #if LH_Calc3to3_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03041 case 16: /* 3 -> 3 Di 16 Do 8 Lut 16 Grid 16 */ 03042 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G16); 03043 break; 03044 #endif 03045 #if LH_Calc3to3_Di16_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM 03046 case 32: /* 3 -> 3 Di 16 Do 8 Lut 16 Grid 32 */ 03047 proc2call = NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G32); 03048 break; 03049 #endif 03050 } 03051 break; 03052 } 03053 break; 03054 case 16: /* 3 -> 3 Di 16 Do 16 */ 03055 switch (lutParam->colorLutWordSize) 03056 { 03057 case 8: /* 3 -> 3 Di 16 Do 16 Lut 8 */ 03058 switch (lutParam->colorLutGridPoints) 03059 { 03060 #if LH_Calc3to3_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03061 case 16: /* 3 -> 3 Di 16 Do 16 Lut 8 Grid 16 */ 03062 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G16); 03063 break; 03064 #endif 03065 #if LH_Calc3to3_Di16_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM 03066 case 32: /* 3 -> 3 Di 16 Do 16 Lut 8 Grid 32 */ 03067 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G32); 03068 break; 03069 #endif 03070 } 03071 break; 03072 case 16: /* 3 -> 3 Di 16 Do 16 Lut 16 */ 03073 switch (lutParam->colorLutGridPoints) 03074 { 03075 #if LH_Calc3to3_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03076 case 16: /* 3 -> 3 Di 16 Do 16 Lut 16 Grid 16 */ 03077 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G16); 03078 break; 03079 #endif 03080 #if LH_Calc3to3_Di16_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM 03081 case 32: /* 3 -> 3 Di 16 Do 16 Lut 16 Grid 32 */ 03082 proc2call = NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G32); 03083 break; 03084 #endif 03085 } 03086 break; 03087 } 03088 break; 03089 } 03090 break; 03091 } 03092 break; 03093 case 4: /* 3 -> 4 */ 03094 switch (info->usedSizeIn) 03095 { 03096 case 8: /* 3 -> 4 Di 8 */ 03097 switch (info->usedSizeOut) 03098 { 03099 case 8: /* 3 -> 4 Di 8 Do 8 */ 03100 switch (lutParam->colorLutWordSize) 03101 { 03102 case 8: /* 3 -> 4 Di 8 Do 8 Lut 8 */ 03103 switch (lutParam->colorLutGridPoints) 03104 { 03105 #if LH_Calc3to4_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03106 case 16: /* 3 -> 4 Di 8 Do 8 Lut 8 Grid 16 */ 03107 #ifdef ALLOW_MMX 03108 if (DetectMMX()) { 03109 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16_F); 03110 } 03111 else 03112 #endif 03113 #if LH_CALC_USE_ADDITIONAL_OLD_CODE 03114 if( !info->inPlace ){ 03115 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16_Old); 03116 } 03117 else 03118 #endif 03119 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16); 03120 break; 03121 #endif 03122 #if LH_Calc3to4_Di8_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM 03123 case 32: /* 3 -> 4 Di 8 Do 8 Lut 8 Grid 32 */ 03124 #ifdef ALLOW_MMX 03125 if (DetectMMX()) { 03126 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32_F); 03127 } 03128 else 03129 #endif 03130 #if LH_CALC_USE_ADDITIONAL_OLD_CODE 03131 if( !info->inPlace ){ 03132 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32_Old); 03133 } 03134 else 03135 #endif 03136 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32); 03137 break; 03138 #endif 03139 } 03140 break; 03141 case 16: /* 3 -> 4 Di 8 Do 8 Lut 16 */ 03142 switch (lutParam->colorLutGridPoints) 03143 { 03144 #if LH_Calc3to4_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03145 case 16: /* 3 -> 4 Di 8 Do 8 Lut 16 Grid 16 */ 03146 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G16); 03147 break; 03148 #endif 03149 #if LH_Calc3to4_Di8_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM 03150 case 32: /* 3 -> 4 Di 8 Do 8 Lut 16 Grid 32 */ 03151 proc2call = NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G32); 03152 break; 03153 #endif 03154 } 03155 break; 03156 } 03157 break; 03158 case 16: /* 3 -> 4 Di 8 Do 16 */ 03159 switch (lutParam->colorLutWordSize) 03160 { 03161 case 8: /* 3 -> 4 Di 8 Do 16 Lut 8 */ 03162 switch (lutParam->colorLutGridPoints) 03163 { 03164 #if LH_Calc3to4_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03165 case 16: /* 3 -> 4 Di 8 Do 16 Lut 8 Grid 16 */ 03166 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G16); 03167 break; 03168 #endif 03169 #if LH_Calc3to4_Di8_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM 03170 case 32: /* 3 -> 4 Di 8 Do 16 Lut 8 Grid 32 */ 03171 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G32); 03172 break; 03173 #endif 03174 } 03175 break; 03176 case 16: /* 3 -> 4 Di 8 Do 16 Lut 16 */ 03177 switch (lutParam->colorLutGridPoints) 03178 { 03179 #if LH_Calc3to4_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03180 case 16: /* 3 -> 4 Di 8 Do 16 Lut 16 Grid 16 */ 03181 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G16); 03182 break; 03183 #endif 03184 #if LH_Calc3to4_Di8_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM 03185 case 32: /* 3 -> 4 Di 8 Do 16 Lut 16 Grid 32 */ 03186 proc2call = NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G32); 03187 break; 03188 #endif 03189 } 03190 break; 03191 } 03192 break; 03193 } 03194 break; 03195 case 16: /* 3 -> 4 Di 16 */ 03196 switch (info->usedSizeOut) 03197 { 03198 case 8: /* 3 -> 4 Di 16 Do 8 */ 03199 switch (lutParam->colorLutWordSize) 03200 { 03201 case 8: /* 3 -> 4 Di 16 Do 8 Lut 8 */ 03202 switch (lutParam->colorLutGridPoints) 03203 { 03204 #if LH_Calc3to4_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03205 case 16: /* 3 -> 4 Di 16 Do 8 Lut 8 Grid 16 */ 03206 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G16); 03207 break; 03208 #endif 03209 #if LH_Calc3to4_Di16_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM 03210 case 32: /* 3 -> 4 Di 16 Do 8 Lut 8 Grid 32 */ 03211 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G32); 03212 break; 03213 #endif 03214 } 03215 break; 03216 case 16: /* 3 -> 4 Di 16 Do 8 Lut 16 */ 03217 switch (lutParam->colorLutGridPoints) 03218 { 03219 #if LH_Calc3to4_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03220 case 16: /* 3 -> 4 Di 16 Do 8 Lut 16 Grid 16 */ 03221 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G16); 03222 break; 03223 #endif 03224 #if LH_Calc3to4_Di16_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM 03225 case 32: /* 3 -> 4 Di 16 Do 8 Lut 16 Grid 32 */ 03226 proc2call = NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G32); 03227 break; 03228 #endif 03229 } 03230 break; 03231 } 03232 break; 03233 case 16: /* 3 -> 4 Di 16 Do 16 */ 03234 switch (lutParam->colorLutWordSize) 03235 { 03236 case 8: /* 3 -> 4 Di 16 Do 16 Lut 8 */ 03237 switch (lutParam->colorLutGridPoints) 03238 { 03239 #if LH_Calc3to4_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03240 case 16: /* 3 -> 4 Di 16 Do 16 Lut 8 Grid 16 */ 03241 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G16); 03242 break; 03243 #endif 03244 #if LH_Calc3to4_Di16_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM 03245 case 32: /* 3 -> 4 Di 16 Do 16 Lut 8 Grid 32 */ 03246 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G32); 03247 break; 03248 #endif 03249 } 03250 break; 03251 case 16: /* 3 -> 4 Di 16 Do 16 Lut 16 */ 03252 switch (lutParam->colorLutGridPoints) 03253 { 03254 #if LH_Calc3to4_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03255 case 16: /* 3 -> 4 Di 16 Do 16 Lut 16 Grid 16 */ 03256 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G16); 03257 break; 03258 #endif 03259 #if LH_Calc3to4_Di16_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM 03260 case 32: /* 3 -> 4 Di 16 Do 16 Lut 16 Grid 32 */ 03261 proc2call = NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G32); 03262 break; 03263 #endif 03264 } 03265 break; 03266 } 03267 break; 03268 } 03269 break; 03270 } 03271 break; 03272 } 03273 break; 03274 case 4: /* 4 -> */ 03275 switch ( lutParam->colorLutOutDim ) 03276 { 03277 case 3: /* 4 -> 3 */ 03278 switch (info->usedSizeIn) 03279 { 03280 case 8: /* 4 -> 3 Di 8 */ 03281 switch (info->usedSizeOut) 03282 { 03283 case 8: /* 4 -> 3 Di 8 Do 8 */ 03284 switch (lutParam->colorLutWordSize) 03285 { 03286 case 8: /* 4 -> 3 Di 8 Do 8 Lut 8 */ 03287 switch (lutParam->colorLutGridPoints) 03288 { 03289 #if LH_Calc4to3_Di8_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03290 case 8: /* 4 -> 3 Di 8 Do 8 Lut 8 Grid 8 */ 03291 #ifdef ALLOW_MMX 03292 if (DetectMMX()) { 03293 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8_F); 03294 } 03295 else 03296 #endif 03297 #if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM 03298 if( !info->inPlace ){ 03299 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8_Old); 03300 } 03301 else 03302 #endif 03303 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8); 03304 break; 03305 #endif 03306 #if LH_Calc4to3_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03307 case 16: /* 4 -> 3 Di 8 Do 8 Lut 8 Grid 16 */ 03308 #ifdef ALLOW_MMX 03309 if (DetectMMX()) { 03310 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16_F); 03311 } 03312 else 03313 #endif 03314 #if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM 03315 if( !info->inPlace ){ 03316 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16_Old); 03317 } 03318 else 03319 #endif 03320 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16); 03321 break; 03322 #endif 03323 } 03324 break; 03325 case 16: /* 4 -> 3 Di 8 Do 8 Lut 16 */ 03326 switch (lutParam->colorLutGridPoints) 03327 { 03328 #if LH_Calc4to3_Di8_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03329 case 8: /* 4 -> 3 Di 8 Do 8 Lut 16 Grid 8 */ 03330 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G8); 03331 break; 03332 #endif 03333 #if LH_Calc4to3_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03334 case 16: /* 4 -> 3 Di 8 Do 8 Lut 16 Grid 16 */ 03335 proc2call = NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G16); 03336 break; 03337 #endif 03338 } 03339 break; 03340 } 03341 break; 03342 case 16: /* 4 -> 3 Di 8 Do 16 */ 03343 switch (lutParam->colorLutWordSize) 03344 { 03345 case 8: /* 4 -> 3 Di 8 Do 16 Lut 8 */ 03346 switch (lutParam->colorLutGridPoints) 03347 { 03348 #if LH_Calc4to3_Di8_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03349 case 8: /* 4 -> 3 Di 8 Do 16 Lut 8 Grid 8 */ 03350 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G8); 03351 break; 03352 #endif 03353 #if LH_Calc4to3_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03354 case 16: /* 4 -> 3 Di 8 Do 16 Lut 8 Grid 16 */ 03355 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G16); 03356 break; 03357 #endif 03358 } 03359 break; 03360 case 16: /* 4 -> 3 Di 8 Do 16 Lut 16 */ 03361 switch (lutParam->colorLutGridPoints) 03362 { 03363 #if LH_Calc4to3_Di8_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03364 case 8: /* 4 -> 3 Di 8 Do 16 Lut 16 Grid 8 */ 03365 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G8); 03366 break; 03367 #endif 03368 #if LH_Calc4to3_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03369 case 16: /* 4 -> 3 Di 8 Do 16 Lut 16 Grid 16 */ 03370 proc2call = NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G16); 03371 break; 03372 #endif 03373 } 03374 break; 03375 } 03376 break; 03377 } 03378 break; 03379 case 16: /* 4 -> 3 Di 16 */ 03380 switch (info->usedSizeOut) 03381 { 03382 case 8: /* 4 -> 3 Di 16 Do 8 */ 03383 switch (lutParam->colorLutWordSize) 03384 { 03385 case 8: /* 4 -> 3 Di 16 Do 8 Lut 8 */ 03386 switch (lutParam->colorLutGridPoints) 03387 { 03388 #if LH_Calc4to3_Di16_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03389 case 8: /* 4 -> 3 Di 16 Do 8 Lut 8 Grid 8 */ 03390 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G8); 03391 break; 03392 #endif 03393 #if LH_Calc4to3_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03394 case 16: /* 4 -> 3 Di 16 Do 8 Lut 8 Grid 16 */ 03395 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G16); 03396 break; 03397 #endif 03398 } 03399 break; 03400 case 16: /* 4 -> 3 Di 16 Do 8 Lut 16 */ 03401 switch (lutParam->colorLutGridPoints) 03402 { 03403 #if LH_Calc4to3_Di16_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03404 case 8: /* 4 -> 3 Di 16 Do 8 Lut 16 Grid 8 */ 03405 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G8); 03406 break; 03407 #endif 03408 #if LH_Calc4to3_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03409 case 16: /* 4 -> 3 Di 16 Do 8 Lut 16 Grid 16 */ 03410 proc2call = NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G16); 03411 break; 03412 #endif 03413 } 03414 break; 03415 } 03416 break; 03417 case 16: /* 4 -> 3 Di 16 Do 16 */ 03418 switch (lutParam->colorLutWordSize) 03419 { 03420 case 8: /* 4 -> 3 Di 16 Do 16 Lut 8 */ 03421 switch (lutParam->colorLutGridPoints) 03422 { 03423 #if LH_Calc4to3_Di16_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03424 case 8: /* 4 -> 3 Di 16 Do 16 Lut 8 Grid 8 */ 03425 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G8); 03426 break; 03427 #endif 03428 #if LH_Calc4to3_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03429 case 16: /* 4 -> 3 Di 16 Do 16 Lut 8 Grid 16 */ 03430 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G16); 03431 break; 03432 #endif 03433 } 03434 break; 03435 case 16: /* 4 -> 3 Di 16 Do 16 Lut 16 */ 03436 switch (lutParam->colorLutGridPoints) 03437 { 03438 #if LH_Calc4to3_Di16_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03439 case 8: /* 4 -> 3 Di 16 Do 16 Lut 16 Grid 8 */ 03440 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G8); 03441 break; 03442 #endif 03443 #if LH_Calc4to3_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03444 case 16: /* 4 -> 3 Di 16 Do 16 Lut 16 Grid 16 */ 03445 proc2call = NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G16); 03446 break; 03447 #endif 03448 } 03449 break; 03450 } 03451 break; 03452 } 03453 break; 03454 } 03455 break; 03456 case 4: /* 4 -> 4 */ 03457 switch (info->usedSizeIn) 03458 { 03459 case 8: /* 4 -> 4 Di 8 */ 03460 switch (info->usedSizeOut) 03461 { 03462 case 8: /* 4 -> 4 Di 8 Do 8 */ 03463 switch (lutParam->colorLutWordSize) 03464 { 03465 case 8: /* 4 -> 4 Di 8 Do 8 Lut 8 */ 03466 switch (lutParam->colorLutGridPoints) 03467 { 03468 #if LH_Calc4to4_Di8_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03469 case 8: /* 4 -> 4 Di 8 Do 8 Lut 8 Grid 8 */ 03470 #ifdef ALLOW_MMX 03471 if (DetectMMX()) { 03472 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8_F); 03473 } 03474 else 03475 #endif 03476 #if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM 03477 if( !info->inPlace ){ 03478 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8_Old); 03479 } 03480 else 03481 #endif 03482 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8); 03483 break; 03484 #endif 03485 #if LH_Calc4to4_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03486 case 16: /* 4 -> 4 Di 8 Do 8 Lut 8 Grid 16 */ 03487 #ifdef ALLOW_MMX 03488 if (DetectMMX()) { 03489 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16_F); 03490 } 03491 else 03492 #endif 03493 #if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM 03494 if( !info->inPlace ){ 03495 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16_Old); 03496 } 03497 else 03498 #endif 03499 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16); 03500 break; 03501 #endif 03502 } 03503 break; 03504 case 16: /* 4 -> 4 Di 8 Do 8 Lut 16 */ 03505 switch (lutParam->colorLutGridPoints) 03506 { 03507 #if LH_Calc4to4_Di8_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03508 case 8: /* 4 -> 4 Di 8 Do 8 Lut 16 Grid 8 */ 03509 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G8); 03510 break; 03511 #endif 03512 #if LH_Calc4to4_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03513 case 16: /* 4 -> 4 Di 8 Do 8 Lut 16 Grid 16 */ 03514 proc2call = NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G16); 03515 break; 03516 #endif 03517 } 03518 break; 03519 } 03520 break; 03521 case 16: /* 4 -> 4 Di 8 Do 16 */ 03522 switch (lutParam->colorLutWordSize) 03523 { 03524 case 8: /* 4 -> 4 Di 8 Do 16 Lut 8 */ 03525 switch (lutParam->colorLutGridPoints) 03526 { 03527 #if LH_Calc4to4_Di8_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03528 case 8: /* 4 -> 4 Di 8 Do 16 Lut 8 Grid 8 */ 03529 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G8); 03530 break; 03531 #endif 03532 #if LH_Calc4to4_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03533 case 16: /* 4 -> 4 Di 8 Do 16 Lut 8 Grid 16 */ 03534 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G16); 03535 break; 03536 #endif 03537 } 03538 break; 03539 case 16: /* 4 -> 4 Di 8 Do 16 Lut 16 */ 03540 switch (lutParam->colorLutGridPoints) 03541 { 03542 #if LH_Calc4to4_Di8_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03543 case 8: /* 4 -> 4 Di 8 Do 16 Lut 16 Grid 8 */ 03544 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G8); 03545 break; 03546 #endif 03547 #if LH_Calc4to4_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03548 case 16: /* 4 -> 4 Di 8 Do 16 Lut 16 Grid 16 */ 03549 proc2call = NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G16); 03550 break; 03551 #endif 03552 } 03553 break; 03554 } 03555 break; 03556 } 03557 break; 03558 case 16: /* 4 -> 4 Di 16 */ 03559 switch (info->usedSizeOut) 03560 { 03561 case 8: /* 4 -> 4 Di 16 Do 8 */ 03562 switch (lutParam->colorLutWordSize) 03563 { 03564 case 8: /* 4 -> 4 Di 16 Do 8 Lut 8 */ 03565 switch (lutParam->colorLutGridPoints) 03566 { 03567 #if LH_Calc4to4_Di16_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03568 case 8: /* 4 -> 4 Di 16 Do 8 Lut 8 Grid 8 */ 03569 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G8); 03570 break; 03571 #endif 03572 #if LH_Calc4to4_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03573 case 16: /* 4 -> 4 Di 16 Do 8 Lut 8 Grid 16 */ 03574 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G16); 03575 break; 03576 #endif 03577 } 03578 break; 03579 case 16: /* 4 -> 4 Di 16 Do 8 Lut 16 */ 03580 switch (lutParam->colorLutGridPoints) 03581 { 03582 #if LH_Calc4to4_Di16_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03583 case 8: /* 4 -> 4 Di 16 Do 8 Lut 16 Grid 8 */ 03584 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G8); 03585 break; 03586 #endif 03587 #if LH_Calc4to4_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03588 case 16: /* 4 -> 4 Di 16 Do 8 Lut 16 Grid 16 */ 03589 proc2call = NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G16); 03590 break; 03591 #endif 03592 } 03593 break; 03594 } 03595 break; 03596 case 16: /* 4 -> 4 Di 16 Do 16 */ 03597 switch (lutParam->colorLutWordSize) 03598 { 03599 case 8: /* 4 -> 4 Di 16 Do 16 Lut 8 */ 03600 switch (lutParam->colorLutGridPoints) 03601 { 03602 #if LH_Calc4to4_Di16_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM 03603 case 8: /* 4 -> 4 Di 16 Do 16 Lut 8 Grid 8 */ 03604 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G8); 03605 break; 03606 #endif 03607 #if LH_Calc4to4_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM 03608 case 16: /* 4 -> 4 Di 16 Do 16 Lut 8 Grid 16 */ 03609 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G16); 03610 break; 03611 #endif 03612 } 03613 break; 03614 case 16: /* 4 -> 4 Di 16 Do 16 Lut 16 */ 03615 switch (lutParam->colorLutGridPoints) 03616 { 03617 #if LH_Calc4to4_Di16_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM 03618 case 8: /* 4 -> 4 Di 16 Do 16 Lut 16 Grid 8 */ 03619 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G8); 03620 break; 03621 #endif 03622 #if LH_Calc4to4_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM 03623 case 16: /* 4 -> 4 Di 16 Do 16 Lut 16 Grid 16 */ 03624 proc2call = NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G16); 03625 break; 03626 #endif 03627 } 03628 break; 03629 } 03630 break; 03631 } 03632 break; 03633 } 03634 break; 03635 } 03636 break; 03637 } 03638 } 03639 #endif 03640 03641 if ( ( proc2call == nil ) 03642 #ifdef DEBUG_OUTPUT 03643 || ( gUSE_NDIM_FOR_BITMAP ) 03644 #endif 03645 ) 03646 { 03647 switch (info->usedSizeIn) 03648 { 03649 case 8: /* Di 8 */ 03650 switch (info->usedSizeOut) 03651 { 03652 case 8: /* Di 8 Do 8 */ 03653 switch (lutParam->colorLutWordSize) 03654 { 03655 case 8: /* Di 8 Do 8 Lut 8 */ 03656 proc2call = NewCalcProc(CalcNDim_Data8To8_Lut8); 03657 break; 03658 case 16: /* Di 8 Do 8 Lut 16 */ 03659 proc2call = NewCalcProc(CalcNDim_Data8To8_Lut16); 03660 break; 03661 } 03662 break; 03663 case 16: /* Di 8 Do 16 */ 03664 switch (lutParam->colorLutWordSize) 03665 { 03666 case 8: /* Di 8 Do 16 Lut 8 */ 03667 proc2call = NewCalcProc(CalcNDim_Data8To16_Lut8); 03668 break; 03669 case 16: /* Di 8 Do 16 Lut 16 */ 03670 proc2call = NewCalcProc(CalcNDim_Data8To16_Lut16); 03671 break; 03672 } 03673 break; 03674 } 03675 break; 03676 case 16: /* Di 16 */ 03677 switch (info->usedSizeOut) 03678 { 03679 case 8: /* Di 16 Do 8 */ 03680 switch (lutParam->colorLutWordSize) 03681 { 03682 case 8: /* Di 16 Do 8 Lut 8 */ 03683 proc2call = NewCalcProc(CalcNDim_Data16To8_Lut8); 03684 break; 03685 case 16: /* Di 16 Do 8 Lut 16 */ 03686 proc2call = NewCalcProc(CalcNDim_Data16To8_Lut16); 03687 break; 03688 } 03689 break; 03690 case 16: /* Di 16 Do 16 */ 03691 switch (lutParam->colorLutWordSize) 03692 { 03693 case 8: /* Di 16 Do 16 Lut 8 */ 03694 proc2call = NewCalcProc(CalcNDim_Data16To16_Lut8); 03695 break; 03696 case 16: /* Di 16 Do 16 Lut 16 */ 03697 proc2call = NewCalcProc(CalcNDim_Data16To16_Lut16); 03698 break; 03699 } 03700 break; 03701 } 03702 break; 03703 } 03704 } 03705 03706 #ifdef DEBUG_OUTPUT 03707 if ( DebugCheck(kThisFile, kDebugMiscInfo) ) 03708 { 03709 if ( gUSE_NDIM_FOR_BITMAP ) 03710 DebugPrint("DoNDIM: %1d->%1d Di %2d Do %2d Grid %2d Lut %2d\n", lutParam->colorLutInDim, lutParam->colorLutOutDim, 03711 info->usedSizeIn, info->usedSizeOut, 03712 lutParam->colorLutGridPoints, lutParam->colorLutWordSize); 03713 else 03714 DebugPrint("OPTIMIZED: %1d->%1d Di %2d Do %2d Grid %2d Lut %2d\n", lutParam->colorLutInDim, lutParam->colorLutOutDim, 03715 info->usedSizeIn, info->usedSizeOut, 03716 lutParam->colorLutGridPoints, lutParam->colorLutWordSize); 03717 } 03718 if (proc2call == nil) 03719 DebugPrint("� ERROR: FindCalcRoutine is nil !!!\n"); 03720 #endif 03721 LH_END_PROC("FindCalcRoutine") 03722 return proc2call; 03723 } 03724 03725 #ifdef __MWERKS__ 03726 #pragma mark ================ Match/Check CMColors ================ 03727 #endif 03728 03729 /*-------------------------------------------------------------------------------------------------------------- 03730 LHMatchColorsPrivate 03731 --------------------------------------------------------------------------------------------------------------*/ 03732 CMError 03733 LHMatchColorsPrivate (CMMModelPtr modelingData, 03734 CMColor* myColors, 03735 SINT32 count) 03736 { 03737 CMCalcParam calcParam; 03738 CMLutParam lutParam; 03739 CMError err = -1; 03740 ColorSpaceInfo info; 03741 CalcProcPtr calcRoutine = nil; 03742 03743 LH_START_PROC("LHMatchColorsPrivate") 03744 03745 LOCK_DATA((modelingData)->lutParam.inputLut); 03746 LOCK_DATA((modelingData)->lutParam.colorLut); 03747 LOCK_DATA((modelingData)->lutParam.outputLut); 03748 03749 /* preprocess for NamedColor stuff */ 03750 if (modelingData->hasNamedColorProf == NamedColorProfileOnly){ 03751 err = ConvertNamedIndexToColors(modelingData,myColors,count); 03752 goto CleanupAndExit; 03753 } 03754 else if (modelingData->hasNamedColorProf==NamedColorProfileAtBegin){ 03755 err = ConvertNamedIndexToPCS(modelingData,myColors,count); 03756 if (err) goto CleanupAndExit; 03757 } 03758 03759 SetMem(&info, sizeof(ColorSpaceInfo), 0); 03760 SetMem(&calcParam, sizeof(CMCalcParam), 0); 03761 03762 info.origSizeIn = 16; 03763 info.origSizeOut = 16; 03764 info.usedSizeIn = 16; 03765 info.usedSizeOut = 16; 03766 03767 FillLutParam(&lutParam, modelingData); 03768 FillCalcParamCM(&calcParam, &lutParam, myColors, count ); 03769 03770 info.inPlace = TRUE; 03771 calcRoutine = FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup ); 03772 if (calcRoutine == nil) 03773 { 03774 err = cmMethodError; 03775 goto CleanupAndExit; 03776 } 03777 03778 err = CallCalcProc(calcRoutine,&calcParam, &lutParam); 03779 if (err) 03780 goto CleanupAndExit; 03781 03782 /* postprocess for NamedColor stuff */ 03783 err = ConvertPCSToNamedIndex(modelingData,myColors,count); 03784 03785 CleanupAndExit: 03786 UNLOCK_DATA((modelingData)->lutParam.inputLut); 03787 UNLOCK_DATA((modelingData)->lutParam.colorLut); 03788 UNLOCK_DATA((modelingData)->lutParam.outputLut); 03789 03790 LH_END_PROC("LHMatchColorsPrivate") 03791 return err; 03792 } 03793 03794 /*-------------------------------------------------------------------------------------------------------------- 03795 LHCheckColorsPrivateMS 03796 --------------------------------------------------------------------------------------------------------------*/ 03797 CMError LHCheckColorsPrivateMS( CMMModelPtr modelingData, 03798 CMColor* myColors, 03799 UINT32 count, 03800 UINT8 *result ) 03801 { 03802 CMCalcParam calcParam; 03803 CMLutParam lutParam; 03804 CMError err = -1; 03805 ColorSpaceInfo info; 03806 CalcProcPtr calcRoutine = nil; 03807 03808 LH_START_PROC("LHCheckColorsPrivateMS") 03809 03810 if( (modelingData)->gamutLutParam.colorLut == 0 )return cmMethodError; 03811 LOCK_DATA((modelingData)->gamutLutParam.inputLut); 03812 LOCK_DATA((modelingData)->gamutLutParam.colorLut); 03813 LOCK_DATA((modelingData)->gamutLutParam.outputLut); 03814 03815 /* preprocess for NamedColor stuff */ 03816 if (modelingData->hasNamedColorProf == NamedColorProfileOnly){ 03817 err = unimpErr; 03818 goto CleanupAndExit; 03819 } 03820 else if (modelingData->hasNamedColorProf==NamedColorProfileAtBegin){ 03821 err = ConvertNamedIndexToPCS(modelingData,myColors,count); 03822 if (err) goto CleanupAndExit; 03823 } 03824 03825 SetMem(&info, sizeof(ColorSpaceInfo), 0); 03826 SetMem(&calcParam, sizeof(CMCalcParam), 0); 03827 03828 info.origSizeIn = 16; 03829 info.origSizeOut = 8; 03830 info.usedSizeIn = 16; 03831 info.usedSizeOut = 8; 03832 03833 FillLutParamChk(&lutParam, modelingData); 03834 FillCalcParamCM(&calcParam, &lutParam, myColors, count ); 03835 calcParam.outputData[0] = (Ptr)result; 03836 calcParam.cmOutputBytesPerLine = count*sizeof(UINT8); 03837 calcParam.cmOutputPixelOffset = 1; 03838 calcParam.cmOutputColorSpace = cmGraySpace8Bit; /* cmGraySpace is 16 bit */ 03839 03840 03841 info.inPlace = (UINT8 *)myColors == result; 03842 calcRoutine = FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup ); 03843 if (calcRoutine == nil) 03844 { 03845 err = cmMethodError; 03846 goto CleanupAndExit; 03847 } 03848 03849 err = CallCalcProc(calcRoutine,&calcParam, &lutParam); 03850 if (err) 03851 goto CleanupAndExit; 03852 03853 /* postprocess for NamedColor stuff */ 03854 if( modelingData->hasNamedColorProf == NamedColorProfileAtEnd ){ 03855 err = unimpErr; 03856 goto CleanupAndExit; 03857 } 03858 CleanupAndExit: 03859 UNLOCK_DATA((modelingData)->gamutLutParam.inputLut); 03860 UNLOCK_DATA((modelingData)->gamutLutParam.colorLut); 03861 UNLOCK_DATA((modelingData)->gamutLutParam.outputLut); 03862 03863 LH_END_PROC("LHCheckColorsPrivateMS") 03864 return err; 03865 } 03866 03867 /*-------------------------------------------------------------------------------------------------------------- 03868 LHCheckColorsPrivate 03869 --------------------------------------------------------------------------------------------------------------*/ 03870 CMError 03871 LHCheckColorsPrivate ( CMMModelPtr modelingData, 03872 CMColor* myColors, 03873 UINT32 count, 03874 UINT8 *result ) 03875 { 03876 CMCalcParam calcParam; 03877 CMLutParam lutParam; 03878 CMError err = -1; 03879 ColorSpaceInfo info; 03880 CalcProcPtr calcRoutine = nil; 03881 03882 LH_START_PROC("LHCheckColorsPrivate") 03883 03884 SetMem(&info, sizeof(ColorSpaceInfo), 0); 03885 SetMem(&calcParam, sizeof(CMCalcParam), 0); 03886 03887 /* disabling check colors with Named Color Profile */ 03888 if ( modelingData->hasNamedColorProf == NamedColorProfileOnly || 03889 modelingData->hasNamedColorProf == NamedColorProfileAtEnd ){ 03890 err = unimpErr; 03891 goto CleanupAndExit; 03892 } 03893 03894 info.origSizeIn = 16; 03895 info.origSizeOut = 16; 03896 info.usedSizeIn = 16; 03897 info.usedSizeOut = 16; 03898 03899 if( (modelingData)->gamutLutParam.colorLut == 0 )return cmMethodError; 03900 LOCK_DATA((modelingData)->gamutLutParam.inputLut); 03901 LOCK_DATA((modelingData)->gamutLutParam.colorLut); 03902 LOCK_DATA((modelingData)->gamutLutParam.outputLut); 03903 03904 FillLutParamChk(&lutParam, modelingData); 03905 FillCalcParamCM(&calcParam, &lutParam, myColors, count ); 03906 03907 AllocBufferCheckCM(&calcParam, &info); 03908 03909 info.inPlace = info.tempOutBuffer == nil; 03910 calcRoutine = FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup ); 03911 if (calcRoutine == nil) 03912 { 03913 err = cmMethodError; 03914 goto CleanupAndExit; 03915 } 03916 03917 err = CallCalcProc(calcRoutine, &calcParam, &lutParam); 03918 03919 Convert8To1( (Ptr)info.tempOutBuffer, (Ptr)result, info.processedLinesIn, calcParam.cmLineCount, count, count*sizeof(CMColor)); 03920 03921 DisposeIfPtr((Ptr)info.tempOutBuffer); 03922 03923 CleanupAndExit: 03924 UNLOCK_DATA((modelingData)->gamutLutParam.inputLut); 03925 UNLOCK_DATA((modelingData)->gamutLutParam.colorLut); 03926 UNLOCK_DATA((modelingData)->gamutLutParam.outputLut); 03927 03928 LH_END_PROC("LHCheckColorsPrivate") 03929 return err; 03930 } 03931 03932 void CopyIndexData( CMBitmap *bitMapIn, CMBitmap *bitMapOut, ColorSpaceInfo *info ); 03933 void CopyIndexData( CMBitmap *bitMapIn, CMBitmap *bitMapOut, ColorSpaceInfo *info ) 03934 { 03935 Ptr imgIn=NULL; 03936 Ptr imgOut=NULL; 03937 SINT32 i,j; 03938 #ifdef DEBUG_OUTPUT 03939 CMError err = -1; 03940 #endif 03941 LH_START_PROC("CopyIndexData") 03942 03943 for( i=0; i<bitMapIn->height; i++ ){ 03944 imgIn = bitMapIn->image + i * bitMapIn->rowBytes; 03945 imgOut = bitMapOut->image + i * bitMapOut->rowBytes; 03946 if( info->inputPixelSize == 24 ){ 03947 if( info->outputPixelSize == 24 ){ 03948 for (j=0;j<bitMapIn->width;j++) { 03949 *imgOut++ = *imgIn++; 03950 *imgOut++ = *imgIn++; 03951 *imgOut++ = *imgIn++; 03952 } 03953 } 03954 else if( info->outputPixelSize == 32 ){ 03955 for (j=0;j<bitMapIn->width;j++) { 03956 *imgOut++ = *imgIn++; 03957 *imgOut++ = *imgIn++; 03958 *imgOut++ = *imgIn++; 03959 imgOut++; 03960 } 03961 } 03962 } 03963 else if( info->inputPixelSize == 32 ){ 03964 if( info->outputPixelSize == 24 ){ 03965 for (j=0;j<bitMapIn->width;j++) { 03966 *imgOut++ = *imgIn++; 03967 *imgOut++ = *imgIn++; 03968 *imgOut++ = *imgIn++; 03969 imgIn++; 03970 } 03971 } 03972 else if( info->outputPixelSize == 32 ){ 03973 for (j=0;j<bitMapIn->width;j++) { 03974 *imgOut++ = *imgIn++; 03975 *imgOut++ = *imgIn++; 03976 *imgOut++ = *imgIn++; 03977 imgOut++; 03978 imgIn++; 03979 } 03980 } 03981 } 03982 } 03983 LH_END_PROC("CopyIndexData") 03984 return; 03985 } 03986 03987 #ifdef __MWERKS__ 03988 #pragma mark ================ Match/Check CMBitmaps ================ 03989 #endif 03990 03991 /*-------------------------------------------------------------------------------------------------------------- 03992 LHMatchBitMapPrivate 03993 --------------------------------------------------------------------------------------------------------------*/ 03994 CMError 03995 LHMatchBitMapPrivate ( CMMModelPtr modelingData, 03996 const CMBitmap * inBitMap, 03997 CMBitmapCallBackUPP progressProc, 03998 void * refCon, 03999 CMBitmap * outBitMap ) 04000 { 04001 CMCalcParam calcParam; 04002 CMLutParam lutParam; 04003 CMError err = -1; 04004 ColorSpaceInfo info; 04005 CalcProcPtr calcRoutine = nil; 04006 CMBitmap bitMapOut; 04007 CMBitmap bitMapIn = *inBitMap; 04008 OSType inColorSpace = modelingData->firstColorSpace; 04009 OSType outColorSpace = modelingData->lastColorSpace; 04010 Boolean progressProcWasCalled = FALSE; 04011 SINT32 offset; 04012 SINT32 progressTimer; 04013 SINT32 dimLoop; 04014 Boolean matchInPlace = FALSE; 04015 long progressProcCount = 0; 04016 SINT32 inLineCount; 04017 Ptr aBuffer; 04018 04019 LH_START_PROC("LHMatchBitMapPrivate") 04020 04021 LOCK_DATA((modelingData)->lutParam.inputLut); 04022 LOCK_DATA((modelingData)->lutParam.colorLut); 04023 LOCK_DATA((modelingData)->lutParam.outputLut); 04024 04025 if( outBitMap == nil ){ 04026 bitMapOut = *inBitMap; 04027 matchInPlace = TRUE; 04028 } 04029 else{ 04030 bitMapOut = *outBitMap; 04031 } 04032 04033 SetMem(&info, sizeof(ColorSpaceInfo), 0); 04034 SetMem(&calcParam, sizeof(CMCalcParam), 0); 04035 04036 FillLutParam(&lutParam, modelingData); 04037 FillCalcParam(&calcParam, &bitMapIn, &bitMapOut); 04038 04039 err = CheckInputColorSpace( &bitMapIn, &calcParam, &info, inColorSpace, lutParam.colorLutInDim ); 04040 inLineCount = calcParam.cmLineCount; 04041 if (err) 04042 goto CleanupAndExit; 04043 04044 if (matchInPlace){ 04045 err = SetOutputColorSpaceInplace( &calcParam, &info, outColorSpace); 04046 if (err) 04047 goto CleanupAndExit; 04048 } 04049 err = CheckOutputColorSpace( &bitMapOut, &calcParam, &info, outColorSpace, lutParam.colorLutOutDim ); 04050 if (err) 04051 goto CleanupAndExit; 04052 04053 if (matchInPlace) /* matching in place - check if pixel sizes are ok */ 04054 { 04055 if (info.inputPixelSize < info.outputPixelSize) 04056 { 04057 err = cmInvalidDstMap; 04058 goto CleanupAndExit; 04059 } 04060 /* set the color space field to the output color space */ 04061 bitMapIn.space = calcParam.cmOutputColorSpace; 04062 } else 04063 { 04064 calcParam.copyAlpha = (calcParam.cmInputColorSpace & cmAlphaSpace) && (calcParam.cmOutputColorSpace & cmAlphaSpace); 04065 } 04066 04067 info.inPlace = bitMapOut.image == bitMapIn.image && info.tempInBuffer == nil && info.tempOutBuffer == nil; 04068 calcRoutine = FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup ); 04069 if (calcRoutine == nil) 04070 { 04071 err = cmMethodError; 04072 goto CleanupAndExit; 04073 } 04074 04075 if( info.inPlace && calcParam.cmInputPixelOffset < calcParam.cmOutputPixelOffset ){ 04076 for( dimLoop=0; dimLoop<8; dimLoop++){ /* now work backwards */ 04077 calcParam.inputData[dimLoop] = (Ptr)calcParam.inputData[dimLoop] + (calcParam.cmLineCount-1) * calcParam.cmInputBytesPerLine + (calcParam.cmPixelPerLine-1) * calcParam.cmInputPixelOffset; 04078 calcParam.outputData[dimLoop] = (Ptr)calcParam.outputData[dimLoop] + (calcParam.cmLineCount-1) * calcParam.cmOutputBytesPerLine + (calcParam.cmPixelPerLine-1) * calcParam.cmOutputPixelOffset; 04079 } 04080 calcParam.cmInputPixelOffset = -calcParam.cmInputPixelOffset; 04081 calcParam.cmOutputPixelOffset = -calcParam.cmOutputPixelOffset; 04082 calcParam.cmInputBytesPerLine = -calcParam.cmInputBytesPerLine; 04083 calcParam.cmOutputBytesPerLine = -calcParam.cmOutputBytesPerLine; 04084 } 04085 /* ------------------------------------------------- 8 or 16 bit data --------------------------------------------------------- */ 04086 if ((info.tempInBuffer == nil) && (info.tempOutBuffer == nil)&& modelingData->hasNamedColorProf == NoNamedColorProfile) 04087 { 04088 if (progressProc == nil) 04089 err = CallCalcProc(calcRoutine,&calcParam, &lutParam); /* no callback proc - do it all in one step */ 04090 else 04091 { 04092 calcParam.cmLineCount = kMaxTempBlock / calcParam.cmInputBytesPerLine; 04093 if (calcParam.cmLineCount < 1) 04094 calcParam.cmLineCount = 1; 04095 else if (calcParam.cmLineCount > bitMapIn.height) 04096 calcParam.cmLineCount = bitMapIn.height; 04097 04098 progressTimer = TickCount(); 04099 while ( info.processedLinesIn < bitMapIn.height ) 04100 { 04101 err = CallCalcProc(calcRoutine,&calcParam, &lutParam); 04102 04103 for (dimLoop = 0; dimLoop< lutParam.colorLutInDim; dimLoop++) 04104 calcParam.inputData[dimLoop] = (Ptr)calcParam.inputData[dimLoop] + calcParam.cmLineCount * calcParam.cmInputBytesPerLine; 04105 04106 for (dimLoop = 0; dimLoop< lutParam.colorLutOutDim; dimLoop++) 04107 calcParam.outputData[dimLoop] = (Ptr)calcParam.outputData[dimLoop] + calcParam.cmLineCount * calcParam.cmOutputBytesPerLine; 04108 04109 info.processedLinesIn += calcParam.cmLineCount; 04110 if ( info.processedLinesIn + calcParam.cmLineCount > bitMapIn.height ) 04111 calcParam.cmLineCount = bitMapIn.height-info.processedLinesIn; 04112 04113 /* - - - - - handle CMBitmapCallBackProc - - - - - */ 04114 if ( progressProc && ( progressTimer + kProgressTicks < (SINT32)TickCount()) ) 04115 { 04116 progressProcWasCalled = TRUE; 04117 if (CallCMBitmapCallBackProc ( progressProc, bitMapIn.height, info.processedLinesIn, (void *)refCon )) 04118 { 04119 info.processedLinesIn = bitMapIn.height; 04120 err = userCanceledErr; 04121 } else 04122 progressTimer = TickCount(); 04123 progressProcCount = info.processedLinesIn; 04124 } 04125 } 04126 } 04127 } 04128 else if (modelingData->hasNamedColorProf != NamedColorProfileOnly ){ 04129 info.processedLinesIn = 0; 04130 progressTimer = TickCount(); 04131 if( info.tempInBuffer && info.tempOutBuffer ){ 04132 if( inLineCount > calcParam.cmLineCount )inLineCount = calcParam.cmLineCount; 04133 } 04134 else if( info.tempInBuffer ){ 04135 if( progressProc && modelingData->hasNamedColorProf == NamedColorProfileAtEnd ){ 04136 inLineCount /= 32; 04137 if( inLineCount < 1 ) inLineCount = 1; 04138 } 04139 } 04140 else if( info.tempOutBuffer ){ 04141 inLineCount = calcParam.cmLineCount; 04142 } 04143 else if( progressProc ){ 04144 inLineCount = kMaxTempBlock / calcParam.cmInputBytesPerLine; 04145 if (inLineCount < 1) 04146 inLineCount = 1; 04147 else if (inLineCount > bitMapIn.height) 04148 inLineCount = bitMapIn.height; 04149 if( modelingData->hasNamedColorProf == NamedColorProfileAtEnd ){ 04150 inLineCount /= 32; 04151 if( inLineCount < 1 ) inLineCount = 1; 04152 } 04153 } 04154 while ( info.processedLinesIn < bitMapIn.height ) 04155 { 04156 if ( info.processedLinesIn + inLineCount > bitMapIn.height ) 04157 inLineCount = bitMapIn.height-info.processedLinesIn; 04158 04159 if (info.origSizeIn == 5 ) /* input is 5 bit */ 04160 Convert5To8 ( bitMapIn.image, (Ptr)info.tempInBuffer, info.processedLinesIn, inLineCount, bitMapIn.width, bitMapIn.rowBytes ); 04161 #ifdef PI_Application_h 04162 else if (info.origSizeIn == 6 ) /* output is 5 bit */ 04163 Convert565To8 ( bitMapIn.image, (Ptr)info.tempInBuffer, info.processedLinesIn, inLineCount, bitMapIn.width, bitMapIn.rowBytes ); 04164 #endif 04165 else if (info.origSizeIn == 10 ) 04166 Convert10To16 ( bitMapIn.image, (Ptr)info.tempInBuffer, info.processedLinesIn, inLineCount, bitMapIn.width, bitMapIn.rowBytes ); 04167 04168 if (modelingData->hasNamedColorProf == NamedColorProfileAtBegin ){ 04169 err = ConvertIndexToLabBitmap( modelingData, bitMapIn.image, 04170 (Ptr)info.tempInBuffer, info.processedLinesIn, 04171 inLineCount, bitMapIn.width, 04172 bitMapIn.rowBytes, 04173 calcParam.cmInputBytesPerLine, 04174 calcParam.cmInputPixelOffset*8 ); 04175 if (err) 04176 goto CleanupAndExit; 04177 } 04178 calcParam.cmLineCount = inLineCount; 04179 err = CallCalcProc( calcRoutine, &calcParam, &lutParam ); 04180 if (err) 04181 goto CleanupAndExit; 04182 04183 if (modelingData->hasNamedColorProf == NamedColorProfileAtEnd ){ 04184 if( info.tempOutBuffer )aBuffer = (Ptr)info.tempOutBuffer; 04185 else aBuffer = bitMapOut.image; 04186 err = ConvertLabToIndexBitmap( modelingData, aBuffer, 04187 info.processedLinesIn, 04188 calcParam.cmLineCount, 04189 bitMapOut.width, bitMapOut.rowBytes ); 04190 if (err) 04191 goto CleanupAndExit; 04192 } 04193 04194 if( info.origSizeOut == 5 ) /* output is 5 bit */ 04195 Convert8To5 ( (Ptr)info.tempOutBuffer, bitMapOut.image, info.processedLinesIn, calcParam.cmLineCount, bitMapOut.width, bitMapOut.rowBytes); 04196 #ifdef PI_Application_h 04197 else if( info.origSizeOut == 6 ) /* output is 5 bit */ 04198 Convert8To565 ( (Ptr)info.tempOutBuffer, bitMapOut.image, info.processedLinesIn, calcParam.cmLineCount, bitMapOut.width, bitMapOut.rowBytes); 04199 #endif 04200 else if( info.origSizeOut == 10 ) /* output is 10 bit */ 04201 Convert16To10 ( (Ptr)info.tempOutBuffer, bitMapOut.image, info.processedLinesIn, calcParam.cmLineCount, bitMapOut.width, bitMapOut.rowBytes); 04202 04203 info.processedLinesIn += inLineCount; 04204 /* - - - - - handle CMBitmapCallBackProc - - - - - */ 04205 if ( progressProc && ( progressTimer + kProgressTicks < (SINT32)TickCount()) ) 04206 { 04207 progressProcWasCalled = TRUE; 04208 if (CallCMBitmapCallBackProc ( progressProc, bitMapIn.height, info.processedLinesIn, (void *)refCon )) 04209 { 04210 info.processedLinesIn = bitMapIn.height; 04211 err = userCanceledErr; 04212 } else 04213 progressTimer = TickCount(); 04214 progressProcCount = info.processedLinesIn; 04215 } 04216 if( !info.tempInBuffer ){ 04217 offset = calcParam.cmLineCount * calcParam.cmInputBytesPerLine; 04218 for (dimLoop = 0; dimLoop< lutParam.colorLutInDim; dimLoop++) 04219 calcParam.inputData[dimLoop] = (Ptr)calcParam.inputData[dimLoop] + offset; 04220 } 04221 if( !info.tempOutBuffer ){ 04222 offset = calcParam.cmLineCount * calcParam.cmOutputBytesPerLine; 04223 for (dimLoop = 0; dimLoop< lutParam.colorLutOutDim; dimLoop++) 04224 calcParam.outputData[dimLoop] = (Ptr)calcParam.outputData[dimLoop] + offset; 04225 } 04226 } 04227 } 04228 else{ 04229 CopyIndexData( &bitMapIn, &bitMapOut, &info ); 04230 } 04231 if (err) 04232 goto CleanupAndExit; 04233 04234 if( progressProcWasCalled && progressProcCount != bitMapIn.height ) 04235 CallCMBitmapCallBackProc ( progressProc, bitMapIn.height, bitMapIn.height, (void *)refCon ); 04236 CleanupAndExit: 04237 04238 /* Clean up temporary storage */ 04239 DisposeIfPtr((Ptr)info.tempInBuffer); 04240 DisposeIfPtr((Ptr)info.tempOutBuffer); 04241 04242 UNLOCK_DATA((modelingData)->lutParam.inputLut); 04243 UNLOCK_DATA((modelingData)->lutParam.colorLut); 04244 UNLOCK_DATA((modelingData)->lutParam.outputLut); 04245 04246 LH_END_PROC("LHMatchBitMapPrivate") 04247 04248 return err; 04249 } 04250 04251 /*-------------------------------------------------------------------------------------------------------------- 04252 LHCheckBitMapPrivate 04253 --------------------------------------------------------------------------------------------------------------*/ 04254 CMError 04255 LHCheckBitMapPrivate ( CMMModelPtr modelingData, 04256 const CMBitmap *inBitMap, 04257 CMBitmapCallBackUPP progressProc, 04258 void * refCon, 04259 CMBitmap *outBitMap ) 04260 { 04261 CMCalcParam calcParam; 04262 CMLutParam lutParam; 04263 CMError err = -1; 04264 ColorSpaceInfo info; 04265 CalcProcPtr calcRoutine = nil; 04266 CMBitmap bitMapIn = *inBitMap; 04267 CMBitmap bitMapOut; 04268 OSType inColorSpace = modelingData->firstColorSpace; 04269 Boolean progressProcWasCalled = FALSE; 04270 SINT32 offset; 04271 SINT32 progressTimer; 04272 SINT32 dimLoop; 04273 Boolean matchInPlace = FALSE; 04274 long progressProcCount = 0; 04275 SINT32 inLineCount; 04276 04277 LH_START_PROC("LHCheckBitMapPrivate") 04278 04279 if( (modelingData)->gamutLutParam.colorLut == 0 )return cmMethodError; 04280 LOCK_DATA((modelingData)->gamutLutParam.inputLut); 04281 LOCK_DATA((modelingData)->gamutLutParam.colorLut); 04282 LOCK_DATA((modelingData)->gamutLutParam.outputLut); 04283 04284 SetMem(&info, sizeof(ColorSpaceInfo), 0); 04285 SetMem(&calcParam, sizeof(CMCalcParam), 0); 04286 04287 if ( (outBitMap == nil ) || (modelingData->gamutLutParam.colorLut == nil) ) 04288 { 04289 err = cmInvalidDstMap; 04290 goto CleanupAndExit; 04291 } 04292 bitMapOut = *outBitMap; 04293 FillLutParamChk(&lutParam, modelingData); 04294 FillCalcParam(&calcParam, &bitMapIn, &bitMapOut); 04295 04296 err = CheckInputColorSpace( &bitMapIn, &calcParam, &info, inColorSpace, lutParam.colorLutInDim ); 04297 inLineCount = calcParam.cmLineCount; 04298 if (err) 04299 goto CleanupAndExit; 04300 04301 err = CheckOutputColorSpaceChk( &bitMapOut, &calcParam, &info ); 04302 if (err) 04303 goto CleanupAndExit; 04304 04305 info.inPlace = bitMapOut.image == bitMapIn.image && info.tempInBuffer == nil && info.tempOutBuffer == nil; 04306 calcRoutine = FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup ); 04307 if (calcRoutine == nil) 04308 { 04309 err = cmMethodError; 04310 goto CleanupAndExit; 04311 } 04312 04313 /* ------------------------------------------------- 8 or 16 bit data --------------------------------------------------------- */ 04314 if ((info.tempInBuffer == nil) && (info.tempOutBuffer == nil) && modelingData->hasNamedColorProf == NoNamedColorProfile) 04315 { 04316 if (progressProc == nil) 04317 err = CallCalcProc(calcRoutine,&calcParam, &lutParam); /* no callback proc - do it all in one step */ 04318 else 04319 { 04320 calcParam.cmLineCount = kMaxTempBlock / calcParam.cmInputBytesPerLine; 04321 if (calcParam.cmLineCount < 1) 04322 calcParam.cmLineCount = 1; 04323 else if (calcParam.cmLineCount > bitMapIn.height) 04324 calcParam.cmLineCount = bitMapIn.height; 04325 04326 progressTimer = TickCount(); 04327 while ( info.processedLinesIn < bitMapIn.height ) 04328 { 04329 err = CallCalcProc(calcRoutine,&calcParam, &lutParam); 04330 04331 for (dimLoop = 0; dimLoop< lutParam.colorLutInDim; dimLoop++) 04332 calcParam.inputData[dimLoop] = (Ptr)calcParam.inputData[dimLoop] + calcParam.cmLineCount * calcParam.cmInputBytesPerLine; 04333 04334 for (dimLoop = 0; dimLoop< lutParam.colorLutOutDim; dimLoop++) 04335 calcParam.outputData[dimLoop] = (Ptr)calcParam.outputData[dimLoop] + calcParam.cmLineCount * calcParam.cmOutputBytesPerLine; 04336 04337 info.processedLinesIn += calcParam.cmLineCount; 04338 if ( info.processedLinesIn + calcParam.cmLineCount > bitMapIn.height ) 04339 calcParam.cmLineCount = bitMapIn.height-info.processedLinesIn; 04340 04341 /* - - - - - handle CMBitmapCallBackProc - - - - - */ 04342 if ( progressProc && ( progressTimer + kProgressTicks < (SINT32)TickCount()) ) 04343 { 04344 progressProcWasCalled = TRUE; 04345 if (CallCMBitmapCallBackProc ( progressProc, bitMapIn.height, info.processedLinesIn, (void *)refCon )) 04346 { 04347 info.processedLinesIn = bitMapIn.height; 04348 err = userCanceledErr; 04349 } else 04350 progressTimer = TickCount(); 04351 progressProcCount = info.processedLinesIn; 04352 } 04353 } 04354 } 04355 } 04356 else if (modelingData->hasNamedColorProf != NamedColorProfileOnly ){ 04357 info.processedLinesIn = 0; 04358 progressTimer = TickCount(); 04359 if( info.tempInBuffer && info.tempOutBuffer ){ 04360 if( inLineCount > calcParam.cmLineCount )inLineCount = calcParam.cmLineCount; 04361 } 04362 else if( info.tempInBuffer ){ 04363 } 04364 else if( info.tempOutBuffer ){ 04365 inLineCount = calcParam.cmLineCount; 04366 } 04367 else if( progressProc ){ 04368 inLineCount = kMaxTempBlock / calcParam.cmInputBytesPerLine; 04369 if (inLineCount < 1) 04370 inLineCount = 1; 04371 else if (inLineCount > bitMapIn.height) 04372 inLineCount = bitMapIn.height; 04373 } 04374 while ( info.processedLinesIn < bitMapIn.height ) 04375 { 04376 if ( info.processedLinesIn + inLineCount > bitMapIn.height ) 04377 inLineCount = bitMapIn.height-info.processedLinesIn; 04378 04379 if (info.origSizeIn == 5 ) /* input is 5 bit */ 04380 Convert5To8 ( bitMapIn.image, (Ptr)info.tempInBuffer, info.processedLinesIn, inLineCount, bitMapIn.width, bitMapIn.rowBytes ); 04381 #ifdef PI_Application_h 04382 else if (info.origSizeIn == 6 ) /* output is 5 bit */ 04383 Convert565To8 ( bitMapIn.image, (Ptr)info.tempInBuffer, info.processedLinesIn, inLineCount, bitMapIn.width, bitMapIn.rowBytes ); 04384 #endif 04385 else if (info.origSizeIn == 10 ) 04386 Convert10To16 ( bitMapIn.image, (Ptr)info.tempInBuffer, info.processedLinesIn, inLineCount, bitMapIn.width, bitMapIn.rowBytes ); 04387 04388 if (modelingData->hasNamedColorProf == NamedColorProfileAtBegin ){ 04389 err = ConvertIndexToLabBitmap( modelingData, bitMapIn.image, 04390 (Ptr)info.tempInBuffer, info.processedLinesIn, 04391 inLineCount, bitMapIn.width, 04392 bitMapIn.rowBytes, 04393 calcParam.cmInputBytesPerLine, 04394 calcParam.cmInputPixelOffset*8 ); 04395 if (err) 04396 goto CleanupAndExit; 04397 } 04398 calcParam.cmLineCount = inLineCount; 04399 err = CallCalcProc( calcRoutine, &calcParam, &lutParam ); 04400 if (err) 04401 goto CleanupAndExit; 04402 04403 if( info.origSizeOut == 1 ) /* output is 5 bit */ 04404 Convert8To1 ( (Ptr)info.tempOutBuffer, bitMapOut.image, info.processedLinesIn, calcParam.cmLineCount, bitMapOut.width, bitMapOut.rowBytes); 04405 04406 info.processedLinesIn += inLineCount; 04407 /* - - - - - handle CMBitmapCallBackProc - - - - - */ 04408 if ( progressProc && ( progressTimer + kProgressTicks < (SINT32)TickCount()) ) 04409 { 04410 progressProcWasCalled = TRUE; 04411 if (CallCMBitmapCallBackProc ( progressProc, bitMapIn.height, info.processedLinesIn, (void *)refCon )) 04412 { 04413 info.processedLinesIn = bitMapIn.height; 04414 err = userCanceledErr; 04415 } else 04416 progressTimer = TickCount(); 04417 progressProcCount = info.processedLinesIn; 04418 } 04419 if( !info.tempInBuffer ){ 04420 offset = calcParam.cmLineCount * calcParam.cmInputBytesPerLine; 04421 for (dimLoop = 0; dimLoop< lutParam.colorLutInDim; dimLoop++) 04422 calcParam.inputData[dimLoop] = (Ptr)calcParam.inputData[dimLoop] + offset; 04423 } 04424 if( !info.tempOutBuffer ){ 04425 offset = calcParam.cmLineCount * calcParam.cmOutputBytesPerLine; 04426 for (dimLoop = 0; dimLoop< lutParam.colorLutOutDim; dimLoop++) 04427 calcParam.outputData[dimLoop] = (Ptr)calcParam.outputData[dimLoop] + offset; 04428 } 04429 } 04430 DisposeIfPtr((Ptr)info.tempInBuffer); 04431 DisposeIfPtr((Ptr)info.tempOutBuffer); 04432 } 04433 else{ 04434 DisposeIfPtr((Ptr)info.tempInBuffer); 04435 err = cmMethodError; 04436 goto CleanupAndExit; 04437 } 04438 if (err) 04439 goto CleanupAndExit; 04440 04441 if( progressProcWasCalled && progressProcCount != bitMapIn.height ) 04442 CallCMBitmapCallBackProc ( progressProc, bitMapIn.height, bitMapIn.height, (void *)refCon ); 04443 CleanupAndExit: 04444 UNLOCK_DATA((modelingData)->gamutLutParam.inputLut); 04445 UNLOCK_DATA((modelingData)->gamutLutParam.colorLut); 04446 UNLOCK_DATA((modelingData)->gamutLutParam.outputLut); 04447 04448 LH_END_PROC("LHCheckBitMapPrivate") 04449 04450 return err; 04451 } 04452 04453 #ifdef __MWERKS__ 04454 #pragma mark ================ Match/Check CMBitmaps Plane ================ 04455 #endif 04456 04457 /*-------------------------------------------------------------------------------------------------------------- 04458 CMError 04459 LHMatchBitMapPlanePrivate ( CMMModelPtr modelingData, 04460 const LH_CMBitmapPlane * bitMapLH, 04461 CMBitmapCallBackUPP progressProc, 04462 void * refCon, 04463 LH_CMBitmapPlane * matchedBitMapLH ) 04464 --------------------------------------------------------------------------------------------------------------*/ 04465 CMError 04466 LHMatchBitMapPlanePrivate ( CMMModelPtr modelingData, 04467 const LH_CMBitmapPlane * bitMapLH, 04468 CMBitmapCallBackUPP progressProc, 04469 void * refCon, 04470 LH_CMBitmapPlane * matchedBitMapLH ) 04471 { 04472 CMCalcParam calcParam; 04473 CMLutParam lutParam; 04474 CMError err = -1; 04475 ColorSpaceInfo info; 04476 CalcProcPtr calcRoutine = nil; 04477 LH_CMBitmapPlane * secondBitmapLH = matchedBitMapLH; 04478 OSType inColorSpace = (modelingData)->firstColorSpace; 04479 OSType outColorSpace = (modelingData)->lastColorSpace; 04480 Boolean progressProcWasCalled = FALSE; 04481 Boolean matchInPlace = FALSE; 04482 SINT32 dimLoop; 04483 04484 LH_START_PROC("LHMatchBitMapPlanePrivate") 04485 04486 SetMem(&info, sizeof(ColorSpaceInfo), 0); 04487 SetMem(&calcParam, sizeof(CMCalcParam), 0); 04488 04489 if (secondBitmapLH == nil) 04490 { 04491 secondBitmapLH = (LH_CMBitmapPlane *)bitMapLH; 04492 matchInPlace = TRUE; 04493 } 04494 04495 LOCK_DATA((modelingData)->lutParam.inputLut); 04496 LOCK_DATA((modelingData)->lutParam.colorLut); 04497 LOCK_DATA((modelingData)->lutParam.outputLut); 04498 04499 /* create CMBitmap based on the LH_CMBitmapPlane - so we can use the 'standard' setup functions */ 04500 { 04501 CMBitmap bitMap; 04502 CMBitmap secondBitmap; 04503 04504 bitMap.image = bitMapLH->image[0]; 04505 bitMap.width = bitMapLH->width; 04506 bitMap.height = bitMapLH->height; 04507 bitMap.rowBytes = bitMapLH->rowBytes; 04508 bitMap.pixelSize = bitMapLH->pixelSize; 04509 bitMap.space = bitMapLH->space; 04510 04511 secondBitmap.image = secondBitmapLH->image[0]; 04512 secondBitmap.width = secondBitmapLH->width; 04513 secondBitmap.height = secondBitmapLH->height; 04514 secondBitmap.rowBytes = secondBitmapLH->rowBytes; 04515 secondBitmap.pixelSize = secondBitmapLH->pixelSize; 04516 secondBitmap.space = secondBitmapLH->space; 04517 04518 FillLutParam(&lutParam, modelingData); 04519 FillCalcParam(&calcParam, &bitMap, &secondBitmap); 04520 04521 err = CheckInputColorSpace(&bitMap,&calcParam, &info, inColorSpace, lutParam.colorLutInDim ); 04522 if (err) 04523 goto CleanupAndExit; 04524 err = CheckOutputColorSpace(&secondBitmap,&calcParam, &info, outColorSpace, lutParam.colorLutOutDim ); 04525 if (err) 04526 goto CleanupAndExit; 04527 } 04528 04529 /* now update the input/output data pointers */ 04530 for (dimLoop = 0; dimLoop < 8; dimLoop++) 04531 { 04532 calcParam.inputData[dimLoop] = bitMapLH->image[dimLoop]; 04533 calcParam.outputData[dimLoop] = secondBitmapLH->image[dimLoop]; 04534 } 04535 04536 calcParam.cmInputPixelOffset = bitMapLH->elementOffset; 04537 calcParam.cmOutputPixelOffset = secondBitmapLH->elementOffset; 04538 if (bitMapLH == secondBitmapLH) /* matching in place - check if pixeloffsets are ok */ 04539 { 04540 if (calcParam.cmInputPixelOffset < calcParam.cmOutputPixelOffset) 04541 { 04542 err = cmInvalidDstMap; 04543 goto CleanupAndExit; 04544 } 04545 if (info.origSizeIn * lutParam.colorLutInDim < info.origSizeOut * lutParam.colorLutOutDim) 04546 { 04547 err = cmInvalidDstMap; 04548 goto CleanupAndExit; 04549 } 04550 } else 04551 { 04552 calcParam.copyAlpha = (calcParam.cmInputColorSpace & cmAlphaSpace) && (calcParam.cmOutputColorSpace & cmAlphaSpace); 04553 } 04554 04555 info.inPlace = info.tempInBuffer == nil && info.tempOutBuffer == nil; 04556 calcRoutine = FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup ); 04557 if (calcRoutine == nil) 04558 { 04559 err = cmMethodError; 04560 goto CleanupAndExit; 04561 } 04562 04563 /* ------------------------------------------------- 8 or 16 bit data --------------------------------------------------------- */ 04564 if ((info.tempInBuffer == nil) && (info.tempOutBuffer == nil)) 04565 { 04566 err = CallCalcProc(calcRoutine,&calcParam, &lutParam); 04567 } 04568 /* ----------------------------------------------- input is 5 or 10 bit ------------------------------------------------------- */ 04569 else if ((info.tempInBuffer != nil) && (info.tempOutBuffer == nil)) 04570 { 04571 DisposeIfPtr((Ptr)info.tempInBuffer); 04572 } 04573 /* ----------------------------------------------- output is 5 or 10 bit ------------------------------------------------------- */ 04574 else if ((info.tempInBuffer == nil) && (info.tempOutBuffer != nil)) 04575 { 04576 DisposeIfPtr((Ptr)info.tempOutBuffer); 04577 } 04578 /* ------------------------------------------ input and output are 5 or 10 bit ------------------------------------------------- */ 04579 else 04580 { 04581 DisposeIfPtr((Ptr)info.tempInBuffer); 04582 DisposeIfPtr((Ptr)info.tempOutBuffer); 04583 } 04584 04585 if (progressProcWasCalled) 04586 CallCMBitmapCallBackProc ( progressProc, 0, 0, (void *)refCon ); 04587 CleanupAndExit: 04588 UNLOCK_DATA((modelingData)->lutParam.inputLut); 04589 UNLOCK_DATA((modelingData)->lutParam.colorLut); 04590 UNLOCK_DATA((modelingData)->lutParam.outputLut); 04591 04592 LH_END_PROC("LHMatchBitMapPlanePrivate") 04593 return err; 04594 } 04595 04596 #ifdef __MWERKS__ 04597 #pragma mark ================ Utilities for NamedColor ================ 04598 #endif 04599 04600 /*-------------------------------------------------------------------------------------------------------------- 04601 OSErr ConvertNamedIndexToColors( CMMModelPtr modelingData, 04602 CMColor *theData, 04603 SINT32 pixCnt ) 04604 --------------------------------------------------------------------------------------------------------------*/ 04605 OSErr ConvertNamedIndexToColors( CMMModelPtr modelingData, 04606 CMColor *theData, 04607 SINT32 pixCnt ) 04608 { 04609 UINT16 *tagTbl = NULL; 04610 LUT_DATA_TYPE tagH = NULL; 04611 OSErr err = noErr; 04612 UINT32 i,index; 04613 UINT16 *colorPtr=NULL; 04614 int elemSz,deviceChannelCount,count; 04615 04616 LH_START_PROC("ConvertNamedIndexToColors") 04617 04618 if ( modelingData->hasNamedColorProf!=NoNamedColorProfile) 04619 { 04620 /* prepare the tag table */ 04621 tagH = modelingData->theNamedColorTagData; 04622 if (tagH==NULL) 04623 { 04624 err = cmparamErr; 04625 goto CleanUp; 04626 } 04627 LOCK_DATA(tagH); 04628 04629 /* tagTbl should now point to beginning of first device data */ 04630 /* = CMNamedColor2Type_header(84) + firstName(32) + PCSSize(3*2) */ 04631 tagTbl = (UINT16 *)DATA_2_PTR(tagH) + 61; 04632 04633 /* find out how many bytes to skip per element. div'ed 2 for indexing purpose */ 04634 count = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.count; 04635 deviceChannelCount = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.nDeviceCoords; 04636 if (deviceChannelCount==3) 04637 { 04638 elemSz = 32+(3+3)*sizeof(SINT16); 04639 } else if (deviceChannelCount == 4) 04640 { 04641 elemSz = 32+(3+4)*sizeof(SINT16); 04642 } else if (deviceChannelCount == 0) 04643 { 04644 elemSz = 32+(3+0)*sizeof(SINT16); 04645 } else 04646 { 04647 err = cmparamErr; 04648 goto CleanUp; 04649 } 04650 elemSz/=2; 04651 04652 /* doing the actual */ 04653 for (i=0; i<(UINT32)pixCnt; i++) 04654 { 04655 /* go to the index'th element*/ 04656 index = theData->namedColor.namedColorIndex; 04657 if (index > (UINT32)count || index == 0 ) 04658 { 04659 err = cmNamedColorNotFound; 04660 goto CleanUp; 04661 } 04662 colorPtr = tagTbl + (index-1)*elemSz; 04663 /* put in all the info */ 04664 if (deviceChannelCount==3) 04665 { 04666 theData->rgb.red = *colorPtr++; 04667 theData->rgb.green = *colorPtr++; 04668 theData->rgb.blue = *colorPtr++; 04669 } else if (deviceChannelCount==4) 04670 { 04671 theData->cmyk.cyan = *colorPtr++; 04672 theData->cmyk.magenta = *colorPtr++; 04673 theData->cmyk.yellow = *colorPtr++; 04674 theData->cmyk.black = *colorPtr++; 04675 } 04676 theData++; 04677 } 04678 UNLOCK_DATA(tagH); 04679 } 04680 CleanUp: 04681 LH_END_PROC("ConvertNamedIndexToColors") 04682 return err; 04683 } 04684 04685 /*-------------------------------------------------------------------------------------------------------------- 04686 OSErr ConvertNamedIndexToPCS( CMMModelPtr cw, 04687 CMColor *theData, 04688 SINT32 pixCnt ) 04689 --------------------------------------------------------------------------------------------------------------*/ 04690 OSErr ConvertNamedIndexToPCS( CMMModelPtr cw, 04691 CMColor *theData, 04692 SINT32 pixCnt ) 04693 { 04694 UINT16 *tagTbl = NULL; 04695 LUT_DATA_TYPE tagH = NULL; 04696 OSErr err = noErr; 04697 UINT32 i,index; 04698 UINT16 *colorPtr=NULL; 04699 int elemSz,deviceChannelCount,count; 04700 CMMModelPtr modelingData = (CMMModelPtr)cw; 04701 04702 04703 LH_START_PROC("ConvertNamedIndexToPCS") 04704 if( cw == 0 )return cmparamErr; 04705 { 04706 /* prepare the tag table */ 04707 tagH = modelingData->theNamedColorTagData; 04708 if (tagH == NULL) 04709 { 04710 err = cmparamErr; 04711 goto CleanUp; 04712 } 04713 LOCK_DATA(tagH); 04714 04715 /* tagTbl should now point to beginning of first PCS data */ 04716 /* = CMNamedColor2Type_header(84) + firstName(32) */ 04717 tagTbl = (UINT16 *)DATA_2_PTR(tagH) + 58; 04718 04719 /* find out how many bytes to skip per element. div'ed 2 for indexing purpose */ 04720 count = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.count; 04721 deviceChannelCount = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.nDeviceCoords; 04722 if (deviceChannelCount == 3) 04723 { 04724 elemSz = 32+(3+3)*sizeof(SINT16); 04725 } else if (deviceChannelCount == 4) 04726 { 04727 elemSz = 32+(3+4)*sizeof(SINT16); 04728 } else if (deviceChannelCount == 0) 04729 { 04730 elemSz = 32+(3+0)*sizeof(SINT16); 04731 } else 04732 { 04733 err = cmparamErr; 04734 goto CleanUp; 04735 } 04736 elemSz /= 2; 04737 04738 /* doing the actual */ 04739 for (i=0; i<(UINT32)pixCnt; i++) 04740 { 04741 /* go to the index'th element*/ 04742 index = theData->namedColor.namedColorIndex; 04743 if (index > (UINT32)count || index == 0 ) 04744 { 04745 err = cmNamedColorNotFound; 04746 goto CleanUp; 04747 } 04748 colorPtr = tagTbl + (index-1)*elemSz; 04749 /* put in all the info */ 04750 theData->Lab.L = *colorPtr++; 04751 theData->Lab.a = *colorPtr++; 04752 theData->Lab.b = *colorPtr++; 04753 theData++; 04754 } 04755 UNLOCK_DATA(tagH); 04756 } 04757 CleanUp: 04758 LH_END_PROC("ConvertNamedIndexToPCS") 04759 return err; 04760 } 04761 04762 04763 04764 #define POS(x) ((x) > (0) ? (UINT32)(x) : (UINT32)(-(x))) 04765 /*-------------------------------------------------------------------------------------------------------------- 04766 OSErr ConvertPCSToNamedIndex( CMMModelPtr modelingData, 04767 CMColor *theData, 04768 SINT32 pixCnt ) 04769 --------------------------------------------------------------------------------------------------------------*/ 04770 OSErr ConvertPCSToNamedIndex( CMMModelPtr modelingData, 04771 CMColor *theData, 04772 SINT32 pixCnt ) 04773 { 04774 UINT16 *tagTbl = NULL; 04775 LUT_DATA_TYPE tagH = NULL; 04776 OSErr err = noErr; 04777 UINT32 i,j,index,dE,dEnow; 04778 UINT16 *colorPtr=NULL; 04779 int elemSz,deviceChannelCount,count; 04780 04781 LH_START_PROC("ConvertPCSToNamedIndex") 04782 if (modelingData->hasNamedColorProf == NamedColorProfileAtEnd) 04783 { 04784 /* prepare the tag table */ 04785 tagH = modelingData->theNamedColorTagData; 04786 if (tagH==NULL) 04787 { 04788 err = cmparamErr; 04789 goto CleanUp; 04790 } 04791 LOCK_DATA(tagH); 04792 04793 /* tagTbl should now point to beginning of first PCS data */ 04794 /* = CMNamedColor2Type_header(84) + firstName(32) */ 04795 tagTbl = (UINT16 *)DATA_2_PTR(tagH) + 58; 04796 04797 /* find out how many bytes to skip per element. div'ed 2 for indexing purpose */ 04798 count = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.count; 04799 deviceChannelCount = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.nDeviceCoords; 04800 if (deviceChannelCount == 3) 04801 { 04802 elemSz = 32+(3+3)*sizeof(SINT16); 04803 } else if (deviceChannelCount == 4) 04804 { 04805 elemSz = 32+(3+4)*sizeof(SINT16); 04806 } else if (deviceChannelCount == 0) 04807 { 04808 elemSz = 32+(3+0)*sizeof(SINT16); 04809 } else 04810 { 04811 err = cmparamErr; 04812 goto CleanUp; 04813 } 04814 elemSz/=2; 04815 04816 /* doing the actual */ 04817 for (i=0; i < (UINT32)pixCnt; i++) 04818 { 04819 /* go through the whole table to find the closest one*/ 04820 dEnow = 0x40000; /* just arbitrarily high = 256*256*4 */ 04821 index = (UINT32)-1; 04822 colorPtr = tagTbl; 04823 for (j=0; j < (UINT32)count; j++) 04824 { 04825 dE = POS((long)theData->Lab.a - *(colorPtr+1)); 04826 dE = dE + POS((long)theData->Lab.b - *(colorPtr+2)); 04827 dE = 2*dE + (dE>>1) + POS((long)theData->Lab.L - *(colorPtr)); 04828 if (dE < dEnow) 04829 { 04830 index = j; 04831 dEnow = dE; 04832 } 04833 colorPtr += elemSz; 04834 } 04835 theData->namedColor.namedColorIndex = index+1; 04836 theData++; 04837 } 04838 UNLOCK_DATA(tagH); 04839 } 04840 CleanUp: 04841 LH_END_PROC("ConvertPCSToNamedIndex") 04842 return err; 04843 } 04844 04845 /*-------------------------------------------------------------------------------------------------------------- 04846 CMError CMConvertNamedIndexToColors( CMWorldRef cw, 04847 CMColor *theData, 04848 unsigned long pixCnt ) 04849 --------------------------------------------------------------------------------------------------------------*/ 04850 CMError CMConvertNamedIndexToColors( CMWorldRef cw, CMColor *theData, unsigned long pixCnt ); 04851 CMError CMConvertNamedIndexToColors( CMWorldRef cw, CMColor *theData, unsigned long pixCnt ) 04852 { 04853 return ConvertNamedIndexToColors( (CMMModelPtr)cw, theData, (SINT32)pixCnt ); 04854 } 04855 /*-------------------------------------------------------------------------------------------------------------- 04856 CMError CMConvertNamedIndexToPCS( CMWorldRef cw, 04857 CMColor *theData, 04858 unsigned long pixCnt ) 04859 --------------------------------------------------------------------------------------------------------------*/ 04860 CMError CMConvertNamedIndexToPCS( CMWorldRef cw, CMColor *theData, unsigned long pixCnt ); 04861 CMError CMConvertNamedIndexToPCS( CMWorldRef cw, CMColor *theData, unsigned long pixCnt ) 04862 { 04863 return ConvertNamedIndexToPCS( (CMMModelPtr)cw, theData, (SINT32)pixCnt ); 04864 } 04865 CMError ConvertLabToIndexBitmap( CMMModelPtr modelingData, 04866 Ptr InBuffer, 04867 UINT32 processedLinesIn, 04868 UINT32 inLineCount, 04869 UINT32 width, 04870 UINT32 rowBytes ) 04871 { 04872 OSErr err = noErr; 04873 LUT_DATA_TYPE tagH=NULL; 04874 UINT16 *tagTbl = NULL,*colorPtr = NULL; 04875 int deviceChannelCount,elemSz,count; 04876 UINT32 i,j,k,index,dE,dEnow; 04877 UINT16 LL,aa,bb; 04878 UINT8 *imgIn=NULL,*imgOut=NULL; 04879 UINT32 *imgInPtr=NULL; 04880 UINT8 *imgInPtr8=NULL; 04881 UINT8 *imgOutPtr8=NULL; 04882 04883 LH_START_PROC("ConvertLabToIndexBitmap") 04884 /* prepare the tag table */ 04885 tagH = modelingData->theNamedColorTagData; 04886 if (tagH==NULL){ 04887 err = cmparamErr; 04888 goto CleanUp; 04889 } 04890 LOCK_DATA(tagH); 04891 tagTbl = (UINT16 *)DATA_2_PTR(tagH) + 58; 04892 count = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.count; 04893 deviceChannelCount = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.nDeviceCoords; 04894 if (deviceChannelCount == 3){ 04895 elemSz = 32+(3+3)*sizeof(SINT16); 04896 } 04897 else if (deviceChannelCount == 4){ 04898 elemSz = 32+(3+4)*sizeof(SINT16); 04899 } 04900 else if (deviceChannelCount == 0){ 04901 elemSz = 32+(3+0)*sizeof(SINT16); 04902 } 04903 else{ 04904 err = cmparamErr; 04905 goto CleanUp; 04906 } 04907 elemSz /= 2; 04908 04909 /* search for index */ 04910 imgIn = (UINT8*)InBuffer + processedLinesIn * rowBytes; 04911 imgInPtr8=((UINT8 *)imgIn); 04912 LL = *(imgInPtr8+0)+1; /* do not use cache for first pixel */ 04913 for (i = 0; i < inLineCount; i++){ 04914 for (j = 0; j < width; j++){ 04915 imgInPtr8=((UINT8 *)imgIn+j*4); 04916 if( LL == *(imgInPtr8+0) ){ 04917 if( aa == *(imgInPtr8+1) && bb == *(imgInPtr8+2) ){ 04918 *((UINT32 *)imgIn+j) = index+1; 04919 continue; 04920 } 04921 } 04922 LL = *(imgInPtr8+0); 04923 aa = *(imgInPtr8+1); 04924 bb = *(imgInPtr8+2); 04925 /* go through the whole table to find the closest one*/ 04926 dEnow = 0x40000; /* just arbitrarily high = 256*256*4 */ 04927 index =(UINT32)-1; 04928 colorPtr = tagTbl; 04929 for (k = 0; k < (UINT32)count; k++){ 04930 dE = POS((long)aa - (*(colorPtr+1)>>8)); 04931 dE = dE + POS((long)bb - (*(colorPtr+2)>>8)); 04932 dE = 2*dE + (dE>>1) + POS((long)LL - (*(colorPtr)>>8)); /* Quantization L = 2.55 * (a|b) */ 04933 if (dE < dEnow){ 04934 index = k; 04935 dEnow = dE; 04936 } 04937 colorPtr += elemSz; 04938 } 04939 *((UINT32 *)imgIn+j) = index+1; 04940 } 04941 imgIn+=rowBytes; 04942 } 04943 CleanUp: 04944 UNLOCK_DATA(tagH); 04945 LH_END_PROC("ConvertLabToIndexBitmap") 04946 return err; 04947 } 04948 CMError ConvertIndexToLabBitmap( CMMModelPtr modelingData, 04949 Ptr InBuffer, 04950 Ptr OutBuffer, 04951 UINT32 processedLinesIn, 04952 UINT32 lineCount, 04953 UINT32 inWidth, 04954 UINT32 inRowBytes, 04955 UINT32 outRowBytes, 04956 UINT32 outputSize ) 04957 { 04958 OSErr err = noErr; 04959 LUT_DATA_TYPE tagH=NULL; 04960 UINT16 *tagTbl = NULL,*ColorPtr = NULL; 04961 UINT32 *imgIn=NULL; 04962 UINT8 *imgOut=NULL; 04963 int deviceChannelCount,elemSz; 04964 UINT32 i,j,index,countNamesInProfile; 04965 04966 LH_START_PROC("ConvertIndexToLabBitmap") 04967 /* set up the table for indexing */ 04968 tagH = modelingData->theNamedColorTagData; 04969 if (tagH==NULL) { 04970 err = cmparamErr; 04971 goto CleanUp; 04972 } 04973 04974 LOCK_DATA(tagH); 04975 tagTbl = (UINT16 *)DATA_2_PTR(tagH) + 58; /* points to PCS */ 04976 deviceChannelCount = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.nDeviceCoords; 04977 countNamesInProfile = ((icNamedColor2Type *)DATA_2_PTR(tagH))->ncolor.count; 04978 if (deviceChannelCount==3) { 04979 elemSz = 32+(3+3)*sizeof(UINT16); 04980 } else if (deviceChannelCount==4) { 04981 elemSz = 32+(3+4)*sizeof(UINT16); 04982 } else if (deviceChannelCount==0) { 04983 elemSz = 32+(3+0)*sizeof(UINT16); 04984 } else { 04985 err = cmparamErr; 04986 goto CleanUp; 04987 } 04988 elemSz/=2; 04989 04990 /* ...and convert the data from index to PCS values */ 04991 for( i=processedLinesIn; i<processedLinesIn+lineCount; i++ ){ 04992 imgIn = (UINT32 *)(InBuffer + i * inRowBytes); 04993 imgOut = (UINT8*)OutBuffer + (i-processedLinesIn) * outRowBytes; 04994 if( outputSize == 24 ){ 04995 for (j=0;j<inWidth;j++) { 04996 index = *imgIn++; 04997 if( index == 0 || index > countNamesInProfile ){ 04998 err = cmNamedColorNotFound; 04999 goto CleanUp; 05000 } 05001 05002 ColorPtr = tagTbl + (index-1)*elemSz; 05003 *imgOut++ = (*ColorPtr++)>>8; 05004 *imgOut++ = (*ColorPtr++)>>8; 05005 *imgOut++ = (*ColorPtr++)>>8; 05006 } 05007 } 05008 else if( outputSize == 32 ){ 05009 for (j=0;j<inWidth;j++) { 05010 index = *imgIn++; 05011 if( index == 0 || index > countNamesInProfile ){ 05012 err = cmNamedColorNotFound; 05013 goto CleanUp; 05014 } 05015 05016 ColorPtr = tagTbl + (index-1)*elemSz; 05017 *imgOut++ = (*ColorPtr++)>>8; 05018 *imgOut++ = (*ColorPtr++)>>8; 05019 *imgOut = (*ColorPtr++)>>8; 05020 imgOut += 2; 05021 } 05022 } 05023 } 05024 CleanUp: 05025 UNLOCK_DATA(tagH); 05026 LH_END_PROC("ConvertIndexToLabBitmap") 05027 return err; 05028 } 05029 05030 #include <string.h> 05031 CMError CMConvNameToIndex( icNamedColor2Type *Data, pcCMColorName Ptr2Name, unsigned long *Arr2Indices, unsigned long count ); 05032 CMError CMConvNameToIndex( icNamedColor2Type *Data, pcCMColorName Ptr2Name, unsigned long *Arr2Indices, unsigned long count ) 05033 { 05034 OSErr err = noErr; 05035 UINT32 i,index,l,len; 05036 char *colorPtr=NULL; 05037 long elemSz,deviceChannelCount,countNamesInProfile; 05038 const char *aPtr; 05039 Ptr tagTbl; 05040 05041 LH_START_PROC("CMConvNameToIndex") 05042 05043 if( Data == 0 || count == 0 )return cmparamErr; 05044 05045 tagTbl = &Data->ncolor.data[0]; 05046 /* find out how many bytes to skip per element. div'ed 2 for indexing purpose */ 05047 countNamesInProfile = Data->ncolor.count; 05048 deviceChannelCount = Data->ncolor.nDeviceCoords; 05049 if (deviceChannelCount==3){ 05050 elemSz = 32+(3+3)*sizeof(SINT16); 05051 } 05052 else if (deviceChannelCount == 4){ 05053 elemSz = 32+(3+4)*sizeof(SINT16); 05054 } 05055 else if (deviceChannelCount == 0){ 05056 elemSz = 32+(3+0)*sizeof(SINT16); 05057 } 05058 else{ 05059 err = cmparamErr; 05060 goto CleanUp; 05061 } 05062 05063 for (i=0; i<(UINT32)count; i++){ 05064 colorPtr = tagTbl; 05065 len = strlen( Ptr2Name[i] ); 05066 aPtr = Ptr2Name[i]; 05067 for( index = 0; index < (UINT32)countNamesInProfile; index++ ){ 05068 for( l = 0; l<len; l++ ){ 05069 if( colorPtr[l] != aPtr[l] )break; 05070 if( colorPtr[l] == 0 )break; 05071 } 05072 if( l >= len )break; 05073 colorPtr += elemSz; 05074 } 05075 if( l < len )index = 0; /* not found */ 05076 else index++; /* Indices are 1 based */ 05077 05078 /* put in all the info */ 05079 if( index == 0 ){ 05080 err = cmNamedColorNotFound; 05081 goto CleanUp; 05082 } 05083 Arr2Indices[i] = index; 05084 } 05085 CleanUp: 05086 LH_END_PROC("CMConvNameToIndex") 05087 return err; 05088 } 05089 05090 CMError CMConvNameToIndexCW( CMWorldRef *Storage, pcCMColorName Ptr2Name, unsigned long *Arr2Indices, unsigned long count); 05091 CMError CMConvNameToIndexCW( CMWorldRef *Storage, pcCMColorName Ptr2Name, unsigned long *Arr2Indices, unsigned long count) 05092 { 05093 Ptr tagTbl = NULL; 05094 LUT_DATA_TYPE tagH = NULL; 05095 CMError err = noErr; 05096 char *colorPtr=NULL; 05097 CMMModelPtr modelingData; 05098 icNamedColor2Type *namedData; 05099 05100 LH_START_PROC("CMConvNameToIndexCW") 05101 05102 if( Storage == 0 )return cmparamErr; 05103 LOCK_DATA( Storage ); 05104 modelingData = (CMMModelPtr)(DATA_2_PTR( Storage )); 05105 if ( modelingData->hasNamedColorProf!=NoNamedColorProfile) 05106 { 05107 /* prepare the tag table */ 05108 tagH = modelingData->theNamedColorTagData; 05109 if (tagH==NULL){ 05110 err = cmparamErr; 05111 goto CleanUp; 05112 } 05113 LOCK_DATA(tagH); 05114 05115 namedData = (icNamedColor2Type *)DATA_2_PTR(tagH); 05116 err = CMConvNameToIndex( namedData, Ptr2Name, Arr2Indices, count ); 05117 UNLOCK_DATA(tagH); 05118 } 05119 CleanUp: 05120 UNLOCK_DATA( Storage ); 05121 LH_END_PROC("CMConvNameToIndexCW") 05122 return err; 05123 } 05124 CMError CMConvNameToIndexProfile( CMProfileRef aProf, pcCMColorName Ptr2Name, unsigned long *Arr2Indices, unsigned long count); 05125 CMError CMConvNameToIndexProfile( CMProfileRef aProf, pcCMColorName Ptr2Name, unsigned long *Arr2Indices, unsigned long count) 05126 { 05127 CMError err; 05128 short aOSerr; 05129 icNamedColor2Type *aName = 0; 05130 unsigned long byteCount; 05131 05132 LH_START_PROC("CMConvNameToIndexProfile") 05133 05134 if( aProf == 0 )return cmparamErr; 05135 err = CMGetPartialProfileElement( aProf, 05136 icSigNamedColor2Tag, 05137 0, 05138 &byteCount, 05139 0 ); 05140 if (err) 05141 goto CleanupAndExit; 05142 aName = (icNamedColor2Type *)SmartNewPtr( byteCount, &aOSerr ); 05143 err = aOSerr; 05144 if (err) 05145 goto CleanupAndExit; 05146 err = CMGetPartialProfileElement( aProf, 05147 icSigNamedColor2Tag, 05148 0, 05149 &byteCount, 05150 (Ptr)aName ); 05151 if (err){ 05152 goto CleanupAndExit; 05153 } 05154 05155 #ifdef IntelMode 05156 SwapLongOffset( &aName->ncolor.count, 0, 4 ); 05157 SwapLongOffset( &aName->ncolor.nDeviceCoords, 0, 4 ); 05158 #endif 05159 err = CMConvNameToIndex( aName, Ptr2Name, Arr2Indices, count ); 05160 05161 CleanupAndExit: 05162 DisposeIfPtr( (Ptr)aName ); 05163 LH_END_PROC("CMConvNameToIndexProfile") 05164 return err; 05165 } 05166 05167 CMError CMConvIndexToName( icNamedColor2Type *Data, unsigned long *Arr2Indices, pCMColorName Ptr2Name, unsigned long count); 05168 CMError CMConvIndexToName( icNamedColor2Type *Data, unsigned long *Arr2Indices, pCMColorName Ptr2Name, unsigned long count) 05169 { 05170 Ptr tagTbl = NULL; 05171 OSErr err = noErr; 05172 UINT32 i,index; 05173 char *colorPtr=NULL; 05174 long elemSz,deviceChannelCount,countNamesInProfile; 05175 05176 LH_START_PROC("CMConvIndexToName") 05177 05178 if( Data == 0 || count == 0 )return cmparamErr; 05179 tagTbl = &Data->ncolor.data[0]; 05180 05181 /* find out how many bytes to skip per element. div'ed 2 for indexing purpose */ 05182 countNamesInProfile = Data->ncolor.count; 05183 deviceChannelCount = Data->ncolor.nDeviceCoords; 05184 if (deviceChannelCount==3){ 05185 elemSz = 32+(3+3)*sizeof(SINT16); 05186 } 05187 else if (deviceChannelCount == 4){ 05188 elemSz = 32+(3+4)*sizeof(SINT16); 05189 } 05190 else if (deviceChannelCount == 0){ 05191 elemSz = 32+(3+0)*sizeof(SINT16); 05192 } 05193 else{ 05194 err = cmparamErr; 05195 goto CleanUp; 05196 } 05197 05198 /* doing the actual */ 05199 for (i=0; i<(UINT32)count; i++){ 05200 /* go to the index'th element*/ 05201 index = Arr2Indices[i]; 05202 if (index > (UINT32)countNamesInProfile || index == 0 ) 05203 { 05204 err = cmNamedColorNotFound; 05205 goto CleanUp; 05206 } 05207 colorPtr = tagTbl + (index-1)*elemSz; 05208 /* put in all the info */ 05209 strcpy( Ptr2Name[i], colorPtr ); 05210 } 05211 05212 CleanUp: 05213 LH_END_PROC("CMConvIndexToName") 05214 return err; 05215 } 05216 05217 CMError CMConvIndexToNameCW( CMWorldRef *Storage, unsigned long *Arr2Indices, pCMColorName Ptr2Name, unsigned long count); 05218 CMError CMConvIndexToNameCW( CMWorldRef *Storage, unsigned long *Arr2Indices, pCMColorName Ptr2Name, unsigned long count) 05219 { 05220 Ptr tagTbl = NULL; 05221 LUT_DATA_TYPE tagH = NULL; 05222 CMError err = noErr; 05223 char *colorPtr=NULL; 05224 CMMModelPtr modelingData; 05225 icNamedColor2Type *namedData; 05226 05227 LH_START_PROC("CMConvIndexToNameCW") 05228 05229 if( Storage == 0 )return cmparamErr; 05230 LOCK_DATA( Storage ); 05231 modelingData = (CMMModelPtr)(DATA_2_PTR( Storage )); 05232 if ( modelingData->hasNamedColorProf!=NoNamedColorProfile) 05233 { 05234 /* prepare the tag table */ 05235 tagH = modelingData->theNamedColorTagData ; 05236 if (tagH==NULL){ 05237 err = cmparamErr; 05238 goto CleanUp; 05239 } 05240 LOCK_DATA(tagH); 05241 05242 namedData = (icNamedColor2Type *)DATA_2_PTR(tagH); 05243 err = CMConvIndexToName( namedData, Arr2Indices, Ptr2Name, count ); 05244 UNLOCK_DATA(tagH); 05245 } 05246 CleanUp: 05247 UNLOCK_DATA( Storage ); 05248 LH_END_PROC("CMConvIndexToNameCW") 05249 return err; 05250 } 05251 CMError CMConvIndexToNameProfile( CMProfileRef aProf, unsigned long *Arr2Indices, pCMColorName Ptr2Name, unsigned long count); 05252 CMError CMConvIndexToNameProfile( CMProfileRef aProf, unsigned long *Arr2Indices, pCMColorName Ptr2Name, unsigned long count) 05253 { 05254 CMError err; 05255 short aOSerr; 05256 icNamedColor2Type *aName = 0; 05257 unsigned long byteCount; 05258 05259 LH_START_PROC("CMConvIndexToNameProfile") 05260 05261 if( aProf == 0 )return cmparamErr; 05262 err = CMGetPartialProfileElement( aProf, 05263 icSigNamedColor2Tag, 05264 0, 05265 &byteCount, 05266 0 ); 05267 if (err) 05268 goto CleanupAndExit; 05269 aName = (icNamedColor2Type *)SmartNewPtr( byteCount, &aOSerr ); 05270 err = aOSerr; 05271 if (err) 05272 goto CleanupAndExit; 05273 err = CMGetPartialProfileElement( aProf, 05274 icSigNamedColor2Tag, 05275 0, 05276 &byteCount, 05277 (Ptr)aName ); 05278 if (err){ 05279 goto CleanupAndExit; 05280 } 05281 05282 #ifdef IntelMode 05283 SwapLongOffset( &aName->ncolor.count, 0, 4 ); 05284 SwapLongOffset( &aName->ncolor.nDeviceCoords, 0, 4 ); 05285 #endif 05286 err = CMConvIndexToName( aName, Arr2Indices, Ptr2Name, count ); 05287 05288 CleanupAndExit: 05289 DisposeIfPtr( (Ptr)aName ); 05290 LH_END_PROC("CMConvIndexToNameProfile") 05291 return err; 05292 } 05293 05294 CMError CMGetNamedProfileInfoProfile( CMProfileRef aProf, pCMNamedProfileInfo Info ); 05295 CMError CMGetNamedProfileInfoProfile( CMProfileRef aProf, pCMNamedProfileInfo Info ) 05296 { 05297 CMError err = noErr; 05298 Ptr tagTbl; 05299 short aOSerr; 05300 icNamedColor2Type *aName = 0; 05301 unsigned long byteCount; 05302 05303 LH_START_PROC("CMGetNamedProfileInfoProfile") 05304 05305 if( aProf == 0 )return cmparamErr; 05306 err = CMGetPartialProfileElement( aProf, 05307 icSigNamedColor2Tag, 05308 0, 05309 &byteCount, 05310 0 ); 05311 if (err) 05312 goto CleanupAndExit; 05313 aName = (icNamedColor2Type *)SmartNewPtr( byteCount, &aOSerr ); 05314 err = aOSerr; 05315 if (err) 05316 goto CleanupAndExit; 05317 err = CMGetPartialProfileElement( aProf, 05318 icSigNamedColor2Tag, 05319 0, 05320 &byteCount, 05321 (Ptr)aName ); 05322 if (err){ 05323 goto CleanupAndExit; 05324 } 05325 05326 05327 /* = CMNamedColor2Type_header(84) + firstName(32) + PCSSize(3*2) */ 05328 tagTbl = (Ptr)aName + 8; 05329 05330 #ifdef IntelMode 05331 SwapLongOffset( &aName->ncolor.count, 0, 4 ); 05332 SwapLongOffset( &aName->ncolor.nDeviceCoords, 0, 4 ); 05333 SwapLongOffset( &aName->ncolor.vendorFlag, 0, 4 ); 05334 #endif 05335 memcpy( Info, tagTbl, sizeof( CMNamedProfileInfo )); 05336 CleanupAndExit: 05337 05338 /* Clean up allocated storage */ 05339 DisposeIfPtr((Ptr) aName); 05340 LH_END_PROC("CMGetNamedProfileInfoProfile") 05341 return err; 05342 } 05343 CMError CMGetNamedProfileInfoCW( CMWorldRef *Storage, pCMNamedProfileInfo Info ); 05344 CMError CMGetNamedProfileInfoCW( CMWorldRef *Storage, pCMNamedProfileInfo Info ) 05345 { 05346 LUT_DATA_TYPE tagH = NULL; 05347 OSErr err = noErr; 05348 CMMModelPtr modelingData; 05349 Ptr tagTbl; 05350 05351 LH_START_PROC("CMGetNamedProfileInfoCW") 05352 05353 if( Storage == 0 )return cmparamErr; 05354 LOCK_DATA( Storage ); 05355 modelingData = (CMMModelPtr)(DATA_2_PTR( Storage )); 05356 if( modelingData->hasNamedColorProf != NoNamedColorProfile ){ 05357 /* prepare the tag table */ 05358 tagH = modelingData->theNamedColorTagData; 05359 if (tagH==NULL){ 05360 err = cmparamErr; 05361 goto CleanUp; 05362 } 05363 LOCK_DATA(tagH); 05364 05365 /* tagTbl should now point to beginning of first device data */ 05366 /* = CMNamedColor2Type_header(84) + firstName(32) + PCSSize(3*2) */ 05367 tagTbl = (Ptr)DATA_2_PTR(tagH) + 8; 05368 05369 memcpy( Info, tagTbl, sizeof( CMNamedProfileInfo )); 05370 UNLOCK_DATA(tagH); 05371 } 05372 CleanUp: 05373 UNLOCK_DATA( Storage ); 05374 LH_END_PROC("CMGetNamedProfileInfoCW") 05375 return err; 05376 }