test: runtime.c Source File

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# runtime.c

Go to the documentation of this 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 }