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

calcndim.h File Reference

Go to the source code of this file.

Functions

CMError CalcNDim_Data8To8_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError CalcNDim_Data8To16_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError CalcNDim_Data16To8_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError CalcNDim_Data16To16_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError CalcNDim_Data8To8_Lut16 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError CalcNDim_Data8To16_Lut16 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError CalcNDim_Data16To8_Lut16 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError CalcNDim_Data16To16_Lut16 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)

Function Documentation

CMError CalcNDim_Data16To16_Lut16 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 898 of file lh_core/calcndim.c. 

00900 {
00901         return CalcNDim_Data8To8_Lut16( calcParam, lutParam );
00902 }

CMError CalcNDim_Data16To16_Lut8 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 934 of file lh_core/calcndim.c. 

00936 {
00937         return CalcNDim_Data8To8_Lut16( calcParam, lutParam );
00938 }

CMError CalcNDim_Data16To8_Lut16 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 889 of file lh_core/calcndim.c. 

00891 {
00892         return CalcNDim_Data8To8_Lut16( calcParam, lutParam );
00893 }

CMError CalcNDim_Data16To8_Lut8 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 916 of file lh_core/calcndim.c. 

00918 {
00919         return CalcNDim_Data8To8_Lut16( calcParam, lutParam );
00920 }

CMError CalcNDim_Data8To16_Lut16 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 880 of file lh_core/calcndim.c. 

00882 {
00883         return CalcNDim_Data8To8_Lut16( calcParam, lutParam );
00884 }

CMError CalcNDim_Data8To16_Lut8 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 925 of file lh_core/calcndim.c. 

00927 {
00928         return CalcNDim_Data8To8_Lut16( calcParam, lutParam );
00929 }

CMError CalcNDim_Data8To8_Lut16 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 62 of file lh_core/calcndim.c. 

00065 {
00066         LH_UINT8 * inputData[8], *outputData[8];
00067         UINT32 InputIncrement, OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount;
00068         register unsigned long adr0;
00069     register unsigned long ko0;
00070     unsigned long accu[8];
00071     register long i;
00072     /*long Offsets[8];*/
00073     
00074     register unsigned long nDim;
00075     register long aElutShift,aAlutShift,aElutOffset,aAlutOffset;
00076     register unsigned long aElutAdrSize;
00077     register long aElutAdrShift;
00078     register long aElutWordSize;
00079     register long aAlutAdrSize;
00080     register long aAlutAdrShift;
00081     register long aAlutWordSize;
00082     register unsigned long aXlutInDim;
00083     register unsigned long aXlutOutDim;
00084     register long aXlutAdrSize;
00085     register long aXlutAdrShift;
00086     register unsigned long aXlutWordSize;
00087     register long aInputPackMode8Bit;
00088     register long aOutputPackMode8Bit;
00089     register long aElutShiftNum;
00090         register unsigned long ii,jj;
00091         LH_UINT16 ein_Cache[8];
00092         
00093         
00094         LH_UINT16 * aus_lut     = (LH_UINT16*)lutParam->outputLut;
00095         LH_UINT16 * ein_lut     = (LH_UINT16*)lutParam->inputLut;
00096         LH_UINT16 * Xlut        = (LH_UINT16*)lutParam->colorLut;
00097         
00098         Boolean aCopyAlpha;
00099    
00100         #ifdef DEBUG_OUTPUT
00101         long err = noErr;
00102         #endif
00103         LH_START_PROC("CalcNDim_Data8To8_Lut16")
00104 #if UNROLL_NDIM
00105         if( lutParam->colorLutInDim == 3 &&
00106                 calcParam->cmInputPixelOffset == 6 ){
00107                 if(     lutParam->colorLutOutDim == 3 &&
00108                         (       calcParam->cmOutputPixelOffset == 3 ||
00109                                 calcParam->cmOutputPixelOffset == 6)){
00110                         return Calc323Dim_Data8To8_Lut16( calcParam, lutParam );
00111                 }
00112                 if(     lutParam->colorLutOutDim == 4 &&
00113                         (       calcParam->cmOutputPixelOffset == 4 ||
00114                                 calcParam->cmOutputPixelOffset == 8) ){
00115                         return Calc324Dim_Data8To8_Lut16( calcParam, lutParam );
00116                 }
00117         }
00118         if( lutParam->colorLutInDim == 4 &&
00119                 calcParam->cmInputPixelOffset == 8 ){
00120                 if(     lutParam->colorLutOutDim == 3 &&
00121                         (       calcParam->cmOutputPixelOffset == 3 ||
00122                                 calcParam->cmOutputPixelOffset == 6) ){
00123                         return Calc423Dim_Data8To8_Lut16( calcParam, lutParam );
00124                 }
00125                 if(     lutParam->colorLutOutDim == 4 &&
00126                         (       calcParam->cmOutputPixelOffset == 4 ||
00127                                 calcParam->cmOutputPixelOffset == 8) ){
00128                         return Calc424Dim_Data8To8_Lut16( calcParam, lutParam );
00129                 }
00130         }
00131 #endif
00132         
00133         inputData[0] = (LH_UINT8 *)calcParam->inputData[0];
00134         inputData[1] = (LH_UINT8 *)calcParam->inputData[1];
00135         inputData[2] = (LH_UINT8 *)calcParam->inputData[2];
00136         inputData[3] = (LH_UINT8 *)calcParam->inputData[3];
00137         inputData[4] = (LH_UINT8 *)calcParam->inputData[4];
00138         inputData[5] = (LH_UINT8 *)calcParam->inputData[5];
00139         inputData[6] = (LH_UINT8 *)calcParam->inputData[6];
00140         inputData[7] = (LH_UINT8 *)calcParam->inputData[7];
00141 
00142         outputData[0] = (LH_UINT8 *)calcParam->outputData[0];
00143         outputData[1] = (LH_UINT8 *)calcParam->outputData[1];
00144         outputData[2] = (LH_UINT8 *)calcParam->outputData[2];
00145         outputData[3] = (LH_UINT8 *)calcParam->outputData[3];
00146         outputData[4] = (LH_UINT8 *)calcParam->outputData[4];
00147         outputData[5] = (LH_UINT8 *)calcParam->outputData[5];
00148         outputData[6] = (LH_UINT8 *)calcParam->outputData[6];
00149         outputData[7] = (LH_UINT8 *)calcParam->outputData[7];
00150         InputIncrement = calcParam->cmInputPixelOffset;
00151         OutputIncrement = calcParam->cmOutputPixelOffset;
00152         inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + InputIncrement;
00153         outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement;
00154 
00155         Pixelcount = calcParam->cmPixelPerLine;
00156         LineCount = calcParam->cmLineCount;
00157 
00158         aElutAdrSize = lutParam->inputLutEntryCount;
00159         for ( i = 1; (i < 32) && (aElutAdrSize >> i); i++)
00160                 aElutAdrShift = i;
00161         aElutWordSize = lutParam->inputLutWordSize;
00162         aAlutAdrSize = lutParam->outputLutEntryCount;
00163         for ( i = 1; (i < 32) && (aAlutAdrSize >> i); i++)
00164                 aAlutAdrShift = i;
00165         aAlutWordSize = lutParam->outputLutWordSize;
00166         aXlutInDim = lutParam->colorLutInDim;
00167         aXlutOutDim = lutParam->colorLutOutDim;
00168         aXlutAdrSize = lutParam->colorLutGridPoints;
00169         for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++)
00170                 aXlutAdrShift = i;
00171         aXlutWordSize = lutParam->colorLutWordSize;
00172 
00173         aInputPackMode8Bit = calcParam->cmInputColorSpace & cm8PerChannelPacking || calcParam->cmInputColorSpace & cmLong8ColorPacking;
00174         aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking;
00175         
00176     /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/
00177         #if FARBR_FILES
00178         WriteLuts(      "DoNDim",1,aElutAdrSize,aElutWordSize,ein_lut,
00179                                 aXlutInDim,aXlutOutDim,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,aAlutAdrSize,aAlutWordSize,(LH_UINT16 *)aus_lut);
00180     #endif
00181 
00182         i=0;
00183                         
00184         
00185         if( calcParam->copyAlpha )aCopyAlpha = 1;
00186         else aCopyAlpha = 0;
00187         if( aXlutInDim > 7 || aXlutOutDim > 7 )aCopyAlpha = 0;
00188         if( aInputPackMode8Bit != aOutputPackMode8Bit )aCopyAlpha = 0;
00189         
00190         nDim=aXlutInDim;
00191         
00192         if( aInputPackMode8Bit ){
00193                 aElutShift = aElutAdrShift-8;
00194                 if( aElutShift < 0 )
00195                 {
00196                         #ifdef DEBUG_OUTPUT
00197                         DebugPrint("¥ DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift);
00198                         #endif
00199                         return cmparamErr;
00200                 }
00201         }
00202         else{
00203                 aElutShift = 16-aElutAdrShift;
00204                 if( aElutShift < 0 )
00205                 {
00206                         #ifdef DEBUG_OUTPUT
00207                         DebugPrint("¥ DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift);
00208                         #endif
00209                         return cmparamErr;
00210                 }
00211         }
00212         
00213         if( aOutputPackMode8Bit ){
00214                 aAlutShift = (aAlutWordSize-8);         
00215         }
00216         else{
00217                 aAlutShift = (16 - aAlutWordSize);              
00218         }
00219         
00220         #ifdef DEBUG_OUTPUT
00221                 if ( DebugCheck(kThisFile, kDebugReserved1) ){
00222                     DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n",
00223                                                 aElutAdrSize,aElutAdrShift,aElutWordSize,ein_lut);
00224                         DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n",
00225                                                 aAlutAdrSize,aAlutAdrShift,aAlutWordSize,aus_lut);
00226                         DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n",
00227                                                 aXlutInDim,aXlutOutDim,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut);
00228                         DebugPrint("aInputPackMode8Bit=%lx,aOutputPackMode8Bit=%lx\n",
00229                                                 aInputPackMode8Bit,aOutputPackMode8Bit );
00230                 }
00231     #endif
00232     aElutShiftNum = 1<<aElutShift;
00233     
00234     /*if( 1 )*/
00235     if( aXlutAdrSize != (1<<aXlutAdrShift )){
00236     register long aXlutOffset;
00237 #if FARBR_DEBUG
00238     register long aXlutPlaneOffset;
00239 #endif
00240     long theXlutOffsets[8]; 
00241     register unsigned long aAlutInShift;
00242     register long aAlutInShiftRemainder;
00243     register unsigned long aAlutInShiftNum;
00244     register long aElutWordSizeMask = (1<<aElutWordSize) - 1;
00245     register unsigned long aAlutRound;
00246    aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;
00247     aAlutInShiftRemainder = 0;
00248     if( aAlutInShift > 16 ){
00249         aAlutInShiftRemainder = aAlutInShift - 16;
00250         aAlutInShift = 16;
00251     }
00252     aAlutInShiftNum = (1<<aAlutInShift);
00253 
00254 #ifdef DEBUG_OUTPUT
00255         if ( DebugCheck(kThisFile, kDebugMiscInfo) )
00256             DebugPrint("  DoNDim gripoints = %ld\n",aXlutAdrSize);
00257 #endif
00258     if( aElutWordSize <= 0 ){
00259 #ifdef DEBUG_OUTPUT
00260         DebugPrint("¥ DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize);
00261 #endif
00262         return cmparamErr;
00263     }
00264     if( aAlutInShift <= 0 ){
00265 #ifdef DEBUG_OUTPUT
00266         DebugPrint("¥ DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift);
00267 #endif
00268         return cmparamErr;
00269     }
00270     aXlutOffset =aXlutOutDim;
00271     for( i=0; i<(long)nDim; i++){
00272         theXlutOffsets[ nDim-1-i] = aXlutOffset;
00273         aXlutOffset *=aXlutAdrSize;
00274     }
00275         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
00276 
00277 #ifdef DEBUG_OUTPUT
00278         if ( DebugCheck(kThisFile, kDebugReserved1) )
00279             DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(aAlutAdrSize/2))/aAlutAdrSize = %ld\n",aElutWordSize,aAlutInShift);
00280 #endif
00281     
00282         while (LineCount){
00283                 i = Pixelcount;
00284                 
00285                 while (i){
00286         
00287                 long adr[8],Index[8];
00288                 LH_UINT16 ein_reg[8];
00289                 register unsigned long  adrAdr,ko,adrOffset;
00290         
00291                 adr0=0;
00292                         aElutOffset = 0;
00293                         jj=0;
00294                         if( aInputPackMode8Bit ){
00295                                 for( ii=0; ii<nDim; ii++){ 
00296                                 jj=ein_lut[((*(LH_UINT8 *)&ein_Cache[ii]=*inputData[ii])<<aElutShift)+aElutOffset];
00297                                 jj *= aXlutAdrSize;
00298                                 aElutOffset += aElutAdrSize;
00299                                 adr[ii] = jj & aElutWordSizeMask;
00300                                 jj = jj >> aElutWordSize;
00301                                 adr0 += (jj)*theXlutOffsets[ii];
00302                                 ein_reg[ii] = (LH_UINT16)jj;
00303                                 }
00304                         }
00305                         else{
00306                                 for( ii=0; ii<nDim; ii++){ 
00307                                 jj=ein_Cache[ii]=(*(LH_UINT16 *)inputData[ii]);
00308                                         ko0 = jj - ( jj >> ( aElutAdrShift ));
00309                                         ko = ko0 & ( aElutShiftNum - 1 );
00310                                         ko0 = ko0 >> aElutShift;
00311                                         ko0 += aElutOffset;
00312                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
00313         
00314                                 jj *= aXlutAdrSize;
00315                                 aElutOffset += aElutAdrSize;
00316                                 adr[ii] = jj & aElutWordSizeMask;
00317                                 jj = jj >> aElutWordSize;
00318                                 adr0 += (jj)*theXlutOffsets[ii];
00319                                 ein_reg[ii] = (LH_UINT16)jj;
00320                                 }
00321                         }
00322         
00323         #if FARBR_DEBUG
00324                 aXlutPlaneOffset = nDim;
00325         DebugPrint("i=%ld o=%ld\n",i,o);
00326         if( aInputPackMode < k3ShortsUnpacked ){ DebugPrint("ein_arr=(d)");for(ii=0; ii<nDim; ++ii) DebugPrint("%ld ",ein_arr[i+ii]); DebugPrint("\n");}
00327         else{ DebugPrint("ein_arr=(d)");for(ii=0; ii<nDim; ++ii) DebugPrint("%ld ",aEinArr[i+ii]); DebugPrint("\n");}
00328         DebugPrint("ein_reg=(d)");for(ii=0; ii<nDim; ++ii) DebugPrint("%ld ",ein_reg[ii]/aXlutAdrSize); DebugPrint("\n");
00329             DebugPrint("adr=(d)");for( ii=0; ii<nDim; ++ii) DebugPrint("%ld ",adr[ii] ); DebugPrint("\n");
00330         #endif
00331 
00332         {                                                               /* a kind of*/
00333                         register unsigned long Top, Gap;
00334                         register long Hold,Switches;
00335                         
00336                         Gap = nDim;
00337                         
00338                         for( ii=0; ii<nDim; ++ii){
00339                                 Index[ii] = ii;
00340                         }
00341                         do{
00342                                 /*Gap = (Gap * 10 ) / SHRINK_FACTOR;*/
00343                                 Gap = (Gap * ((10*16)/SHRINK_FACTOR) ) >>4;
00344                                 if( Gap == 0 ) Gap = 1;
00345                                 Switches = 0;
00346                                 Top = nDim - Gap;
00347                                 for( ii=0; ii<Top; ++ii){
00348                                         jj = ii + Gap;
00349                                         if( adr[Index[ii]] < adr[Index[jj]] ){
00350                                                 Hold = Index[ii];
00351                                                 Index[ii] = Index[jj];
00352                                                 Index[jj] = Hold;
00353                                                 Switches = 1;
00354                                         }
00355                                 }
00356                         }while( Switches || Gap > 1 );
00357                 }
00358                 #if FARBR_DEBUG
00359             DebugPrint("Index=");
00360             for( ii=0; ii<nDim; ++ii){
00361                 DebugPrint("%3ld ",Index[ii] );
00362             }
00363             DebugPrint("\n");
00364         #endif
00365 
00366         for( jj=0; jj<aXlutOutDim; ++jj)accu[jj]=0;
00367 
00368         ko0 = (1<<aElutWordSize);
00369         adrAdr=adr0;
00370         adrOffset=0;
00371         if( aXlutWordSize  == 16 ){
00372             for( ii=0; ii<nDim; ++ii){
00373                 jj = Index[ii];
00374                 ko = ko0 - adr[jj];
00375                 ko0 = adr[jj];
00376 
00377                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
00378                     adrOffset += theXlutOffsets[jj];
00379 
00380                    for( jj=0; jj<aXlutOutDim; ++jj){                            
00381 #if FARBR_DEBUG
00382                     DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj*aXlutPlaneOffset),Xlut[adrAdr+(jj*aXlutPlaneOffset)],ko);
00383 #endif
00384                     accu[jj]+=Xlut[adrAdr+(jj)]*ko;
00385                 }
00386 
00387                 adrAdr = (adr0 + adrOffset);
00388             }
00389                for( jj=0; jj<aXlutOutDim; ++jj){                                
00390 #if FARBR_DEBUG
00391                     DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj*aXlutPlaneOffset),Xlut[adrAdr+(jj*aXlutPlaneOffset)],ko0);
00392 #endif
00393                 accu[jj]+=Xlut[adrAdr+jj]*ko0;
00394             }
00395         }
00396         else{
00397 
00398             for( ii=0; ii<nDim; ++ii){
00399                 jj = Index[ii];
00400                 ko = ko0 - adr[jj];
00401                 ko0 = adr[jj];
00402 
00403                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
00404                     adrOffset += theXlutOffsets[jj];
00405 
00406                    for( jj=0; jj<aXlutOutDim; ++jj){                            
00407 #if FARBR_DEBUG
00408                     DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj*aXlutPlaneOffset),Xlut[adrAdr+(jj*aXlutPlaneOffset)],ko);
00409 #endif
00410                     accu[jj]+=((LH_UINT8 *)Xlut)[adrAdr+(jj)]*ko;
00411                 }
00412 
00413                 adrAdr = (adr0 + adrOffset);
00414             }
00415                for( jj=0; jj<aXlutOutDim; ++jj){                                
00416 #if FARBR_DEBUG
00417                     DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj*aXlutPlaneOffset),Xlut[adrAdr+(jj*aXlutPlaneOffset)],ko0);
00418 #endif
00419                 accu[jj]+=((LH_UINT8 *)Xlut)[adrAdr+jj]*ko0;
00420                 /*ii = accu[jj]+((LH_UINT8 *)Xlut)[adrAdr+jj]*ko0;
00421                 accu[jj] = ii +( ii >> 8 );*/
00422             }
00423         }
00424 
00425 #if FARBR_DEBUG
00426         DebugPrint("accu=(d)");for( ii=0; ii<aXlutOutDim; ++ii) DebugPrint("%3ld ",accu[ii] ); DebugPrint("\n");
00427 #endif
00428                 aAlutOffset = 0;
00429 
00430                 if( aOutputPackMode8Bit ){
00431                         for( ii=0; ii<aXlutOutDim; ++ii){
00432         #if FARBR_DEBUG
00433                         ii = ((accu[ii]) >> aAlutInShift)+aAlutOffset;
00434                         DebugPrint("adr:((accu[ii]) >> aAlutInShift)+aAlutOffset = %ld\n",ii);
00435                         DebugPrint("aus_lut[%ld]=%ld aus_lut[%ld]=%ld aus_lut[%ld]=%ld \n",ii-1,aus_lut[ii-1],ii,aus_lut[ii],ii+1,aus_lut[ii+1]);
00436         #endif
00437                                         jj = accu[ii];
00438                                         jj = jj + ( jj >> aXlutWordSize );
00439 
00440                                         ko0 = (jj - ( jj >> ( aAlutAdrShift ))) >> aAlutInShiftRemainder;       /*      aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;*/
00441 
00442                                         ko = ko0 & (aAlutInShiftNum - 1 );
00443                                         ko0 = ko0 >> aAlutInShift;
00444                                         ko0 += aAlutOffset;
00445                                         if( aAlutWordSize <= 8)
00446                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
00447                                         else{
00448                                         jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
00449                                                 jj = jj - ( jj >> aAlutShift );
00450                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
00451                                         }
00452                                         *outputData[ii] = (LH_UINT8)jj;
00453                         aAlutOffset += aAlutAdrSize;
00454                     }
00455                 }
00456                 else{
00457                                 if( aXlutWordSize >= 16 ){
00458                                         for( ii=0; ii<aXlutOutDim; ++ii){
00459                                                 jj = accu[ii];
00460                                                 jj = jj + ( jj >> aXlutWordSize );
00461                                 ko0 = (jj - ( jj >> ( aAlutAdrShift ))) >> aAlutInShiftRemainder; /*    aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;*/
00462                 
00463                                                 ko = ko0 & (aAlutInShiftNum - 1 );
00464                                                 ko0 = ko0 >> aAlutInShift;
00465                                                 ko0 += aAlutOffset;
00466                                                 if( aAlutWordSize <= 8)
00467                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
00468                                                 else
00469                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
00470                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
00471                                                 aAlutOffset += aAlutAdrSize;
00472                                         }
00473                                 }
00474                                 else{
00475                                         for( ii=0; ii<aXlutOutDim; ++ii){
00476                                                 jj = accu[ii];
00477                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
00478                                 ko0 = (jj - ( jj >> ( aAlutAdrShift ))) ; /*    aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;*/
00479                 
00480                                                 ko = ko0 & (aAlutInShiftNum - 1 );
00481                                                 ko0 = ko0 >> aAlutInShift;
00482                                                 ko0 += aAlutOffset;
00483                                                 if( aAlutWordSize <= 8)
00484                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
00485                                                 else
00486                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
00487                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
00488                                                 aAlutOffset += aAlutAdrSize;
00489                                         }
00490                                 }
00491                 }
00492                 #if FARBR_DEBUG
00493                     if( aOutputPackMode8Bit ){DebugPrint("outputData=(d)");for( ii=0; ii<aXlutOutDim; ++ii) DebugPrint("%3ld ",outputData[ii+o] ); DebugPrint("\n");}
00494                     else{DebugPrint("outputData=(d)");for( ii=0; ii<aXlutOutDim; ++ii) DebugPrint("%3ld ",aAusArr[ii+o] ); DebugPrint("\n");}
00495                         #endif
00496                         if( aCopyAlpha ){
00497                                 if( aOutputPackMode8Bit )
00498                                         *outputData[aXlutOutDim] = *inputData[aXlutInDim];
00499                                 else
00500                                         *((LH_UINT16 *)outputData[aXlutOutDim]) = *((LH_UINT16 *)inputData[aXlutInDim]);
00501                         }
00502                         while (--i){
00503                                 for( jj=0; jj<aXlutInDim; ++jj){
00504                                         inputData[jj] += InputIncrement;
00505                                 }
00506                                 for( jj=0; jj<aXlutOutDim; ++jj){
00507                                         outputData[jj] += OutputIncrement;
00508                                 }
00509                                 if( aCopyAlpha ){
00510                                         inputData[aXlutInDim] += InputIncrement;
00511                                         outputData[aXlutOutDim] += OutputIncrement;
00512                                 }
00513         
00514                                 if( aInputPackMode8Bit ){
00515                                         for( jj=0; jj<aXlutInDim; ++jj){
00516                                                 if( *inputData[jj] ^ *(LH_UINT8 *)(&ein_Cache[jj]) )break;
00517                                         }
00518                                 }
00519                                 else{
00520                                         for( jj=0; jj<aXlutInDim; ++jj){
00521                                                 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break;
00522                                         }
00523                                 }
00524                                 if( jj<aXlutInDim ) break;
00525                                 if( aOutputPackMode8Bit ){
00526                                         for( jj=0; jj<aXlutOutDim; ++jj){
00527                                                 *outputData[jj] = outputData[jj][-(long)OutputIncrement];
00528                                         }
00529                                         if( aCopyAlpha ){
00530                                                 *outputData[aXlutOutDim] = *inputData[aXlutInDim];
00531                                         }
00532                                 }
00533                                 else{
00534                                         for( jj=0; jj<aXlutOutDim; ++jj){
00535                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)OutputIncrement]);
00536                                         }
00537                                         if( aCopyAlpha ){
00538                                                 *((LH_UINT16 *)outputData[aXlutOutDim]) = *((LH_UINT16 *)inputData[aXlutInDim]);
00539                                         }
00540                                 }
00541                         }
00542                 }
00543                 
00544                 if( --LineCount ){
00545                         for( jj=0; jj<aXlutInDim; ++jj){
00546                                 inputData[jj] += inputDataRowOffset;
00547                         }
00548                         for( jj=0; jj<aXlutOutDim; ++jj){
00549                                 outputData[jj] += outputDataRowOffset;
00550                         }
00551                         if( aCopyAlpha ){
00552                                 inputData[aXlutInDim] += inputDataRowOffset;
00553                                 outputData[aXlutOutDim] += outputDataRowOffset;
00554                         }
00555                 }
00556     }
00557     }
00558     else{
00559 
00560     register unsigned long  bit_breit_selektor;
00561     register unsigned long  bit_maske_selektor;
00562     register unsigned long  bit_breit_adr;
00563     register unsigned long  bit_maske_adr;
00564     register unsigned long  aAlutInShiftNum;
00565     register long aAlutInShift;
00566     register long aAlutInShiftRemainder;
00567     register unsigned long aAlutRound;
00568     /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/
00569     bit_breit_selektor=aElutWordSize-aXlutAdrShift;
00570     if( aElutWordSize-aXlutAdrShift < 0 )
00571     {
00572 #ifdef DEBUG_OUTPUT
00573         DebugPrint("¥ DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor);
00574 #endif
00575         return cmparamErr;
00576     }
00577     bit_maske_selektor=(1<<bit_breit_selektor)-1;
00578     bit_breit_adr=aXlutAdrShift;
00579     bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor;
00580     aAlutInShift = (aXlutWordSize+bit_breit_selektor-aAlutAdrShift);
00581     /*aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;*/
00582     aAlutInShiftRemainder = 0;
00583     if( aAlutInShift > 16 ){
00584         aAlutInShiftRemainder = aAlutInShift - 16;
00585         aAlutInShift = 16;
00586     }
00587         
00588     aAlutInShiftNum = (1<<aAlutInShift);
00589     
00590         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
00591         while (LineCount){
00592                 i = Pixelcount;
00593                 
00594                 while (i){
00595         
00596                 long adr[8],Index[8];
00597                 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/
00598                 LH_UINT16 ein_reg[8];
00599                    register unsigned long  adrAdr,ko,adrOffset;
00600                 /*register unsigned long aIndex;*/
00601         
00602                 adr0=0;
00603                 aElutOffset = 0;
00604                 jj=0;
00605                         if( aInputPackMode8Bit ){
00606                     for( ii=0; ii<nDim; ii++){ 
00607                         jj=ein_lut[((*(LH_UINT8 *)&ein_Cache[ii]=*inputData[ii])<<aElutShift)+aElutOffset];
00608                         aElutOffset += aElutAdrSize;
00609                         adr[ii] = (jj & bit_maske_selektor);
00610                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((nDim-ii-1)*bit_breit_adr);
00611                         ein_reg[ii] = (LH_UINT16)jj;
00612                     }
00613                 }
00614                 else{
00615                     for( ii=0; ii<nDim; ii++){ 
00616                         jj=ein_Cache[ii]=(*(LH_UINT16 *)inputData[ii]);
00617                         ko0 = jj - ( jj >> ( aElutAdrShift ));
00618                         ko = ko0 & ( aElutShiftNum - 1 );
00619                         ko0 = ko0 >> aElutShift;
00620                         ko0 += aElutOffset;
00621                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
00622         
00623                         aElutOffset += aElutAdrSize;
00624                         adr[ii] = (jj & bit_maske_selektor);
00625                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((nDim-ii-1)*bit_breit_adr);
00626                         ein_reg[ii] = (LH_UINT16)jj;
00627                     }
00628                 }
00629         
00630                 adr0 *= aXlutOutDim;
00631         #if FARBR_DEBUG
00632                 DebugPrint("i=%ld o=%ld\n",i,o);
00633                 DebugPrint("adr0=%ld\n",adr0);
00634                 if( aInputPackMode < k3ShortsUnpacked ){ DebugPrint("ein_arr=(d)");for(ii=0; ii<nDim; ++ii) DebugPrint("%ld ",ein_arr[i+ii]); DebugPrint("\n");}
00635                 else{ DebugPrint("ein_arr=(d)");for(ii=0; ii<nDim; ++ii) DebugPrint("%ld ",aEinArr[i+ii]); DebugPrint("\n");}
00636                 DebugPrint("ein_reg=(d)");for(ii=0; ii<nDim; ++ii) DebugPrint("%ld ",ein_reg[ii]); DebugPrint("\n");
00637                 DebugPrint("adr=(d)");for( ii=0; ii<nDim; ++ii) DebugPrint("%ld ",adr[ii] ); DebugPrint("\n");
00638         #endif
00639         
00640                    {                                                            /* a kind of */
00641                     register unsigned long Top, Gap;
00642                     register long Hold,Switches;
00643                     
00644                     Gap = nDim;
00645                     
00646                     for( ii=0; ii<nDim; ++ii){
00647                         Index[ii] = ii;
00648                     }
00649                     do{
00650                         /*Gap = (Gap * 10 ) / SHRINK_FACTOR;*/
00651                         Gap = (Gap * ((10*16)/SHRINK_FACTOR) ) >>4;
00652                         if( Gap == 0 ) Gap = 1;
00653                         Switches = 0;
00654                         Top = nDim - Gap;
00655                         for( ii=0; ii<Top; ++ii){
00656                             jj = ii + Gap;
00657                             if( adr[Index[ii]] < adr[Index[jj]] ){
00658                                 Hold = Index[ii];
00659                                 Index[ii] = Index[jj];
00660                                 Index[jj] = Hold;
00661                                 Switches = 1;
00662                             }
00663                         }
00664                     }while( Switches || Gap > 1 );
00665                 }
00666         #if FARBR_DEBUG
00667                 DebugPrint("Index=");
00668                 for( ii=0; ii<nDim; ++ii){
00669                     DebugPrint("%3ld ",Index[ii] );
00670                 }
00671                 DebugPrint("\n");
00672         #endif
00673         
00674                    for( jj=0; jj<aXlutOutDim; ++jj)accu[jj]=0;
00675         
00676                 ko0 = bit_maske_selektor+1;
00677                 adrAdr=adr0;
00678                 adrOffset=0;
00679         
00680                 if( aXlutWordSize  == 16 ){
00681                     for( ii=0; ii<nDim; ++ii){
00682                         jj = Index[ii];
00683                         ko = ko0 - adr[jj];
00684                         ko0 = adr[jj];
00685         
00686                         if( ein_reg[jj] < bit_maske_adr )
00687                             adrOffset |= (1<<(nDim-1-jj)*bit_breit_adr);
00688         
00689                            for( jj=0; jj<aXlutOutDim; ++jj){                            
00690         #if FARBR_DEBUG
00691                             DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj),Xlut[adrAdr+(jj)],ko);
00692         #endif
00693                             accu[jj]+=Xlut[adrAdr+(jj)]*ko;
00694                         }
00695         
00696                         adrAdr = (adr0 + aXlutOutDim*adrOffset);
00697                     }
00698                        for( jj=0; jj<aXlutOutDim; ++jj){                                
00699         #if FARBR_DEBUG
00700                             DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj),Xlut[adrAdr+(jj)],ko0);
00701         #endif
00702                         accu[jj]+=Xlut[adrAdr+(jj)]*ko0;
00703                     }
00704                 }
00705                 else{
00706         
00707                     for( ii=0; ii<nDim; ++ii){
00708                         jj = Index[ii];
00709                         ko = ko0 - adr[jj];
00710                         ko0 = adr[jj];
00711         
00712                         if( ein_reg[jj] < bit_maske_adr )
00713                             adrOffset |= (1<<(nDim-1-jj)*bit_breit_adr);
00714         
00715                            for( jj=0; jj<aXlutOutDim; ++jj){                            
00716         #if FARBR_DEBUG
00717                             DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj),Xlut[adrAdr+(jj)],ko);
00718         #endif
00719                             accu[jj]+=((LH_UINT8 *)Xlut)[adrAdr+(jj)]*ko;
00720                         }
00721         
00722                         adrAdr = (adr0 + aXlutOutDim*adrOffset);
00723                     }
00724                        for( jj=0; jj<aXlutOutDim; ++jj){                                
00725         #if FARBR_DEBUG
00726                             DebugPrint("jj=(d)%ld adrAdr=%lx Address=%lx Xlut[Address]=(d)%ld ko=(d)%ld\n",jj,adrAdr,adrAdr+(jj),Xlut[adrAdr+(jj)],ko0);
00727         #endif
00728                         accu[jj]+=((LH_UINT8 *)Xlut)[adrAdr+(jj)]*ko0;
00729                     }
00730                 }
00731         
00732         #if FARBR_DEBUG
00733                 DebugPrint("accu=(d)");for( ii=0; ii<aXlutOutDim; ++ii) DebugPrint("%3ld ",accu[ii] ); DebugPrint("\n");
00734         #endif
00735                 aAlutOffset = 0;
00736         
00737                 if( aOutputPackMode8Bit ){
00738                         for( ii=0; ii<aXlutOutDim; ++ii){
00739         #if FARBR_DEBUG
00740                         ii = ((accu[ii]) >> aAlutInShift)+aAlutOffset;
00741                         DebugPrint("adr:((accu[ii]) >> aAlutInShift)+aAlutOffset = %ld\n",ii);
00742                         DebugPrint("aus_lut[%ld]=%ld aus_lut[%ld]=%ld aus_lut[%ld]=%ld \n",ii-1,aus_lut[ii-1],ii,aus_lut[ii],ii+1,aus_lut[ii+1]);
00743         #endif
00744                                         jj = accu[ii];
00745                                         jj = jj + ( jj >> aXlutWordSize );
00746 
00747                                         ko0 = (jj - ( jj >> ( aAlutAdrShift ))) >> aAlutInShiftRemainder;       /*      aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;*/
00748 
00749                                         ko = ko0 & (aAlutInShiftNum - 1 );
00750                                         ko0 = ko0 >> aAlutInShift;
00751                                         ko0 += aAlutOffset;
00752                                         if( aAlutWordSize <= 8)
00753                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
00754                                         else{
00755                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
00756                                                 jj = jj - ( jj >> aAlutShift );
00757                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
00758                                         }
00759 
00760                                         *outputData[ii] = (LH_UINT8)jj;
00761                         aAlutOffset += aAlutAdrSize;
00762                     }
00763                 }
00764                 else{
00765                                 if( aXlutWordSize >= 16 ){
00766                                         for( ii=0; ii<aXlutOutDim; ++ii){
00767                                                 jj = accu[ii];
00768                                                 jj = jj + ( jj >> aXlutWordSize );
00769                                 ko0 = (jj - ( jj >> ( aAlutAdrShift ))) >> aAlutInShiftRemainder; /*    aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;*/
00770                 
00771                                                 ko = ko0 & (aAlutInShiftNum - 1 );
00772                                                 ko0 = ko0 >> aAlutInShift;
00773                                                 ko0 += aAlutOffset;
00774                                                 if( aAlutWordSize <= 8)
00775                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
00776                                                 else
00777                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
00778                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
00779                                                 aAlutOffset += aAlutAdrSize;
00780                                         }
00781                                 }
00782                                 else{
00783                                         for( ii=0; ii<aXlutOutDim; ++ii){
00784                                                 jj = accu[ii];
00785                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
00786                                 ko0 = (jj - ( jj >> ( aAlutAdrShift ))); /*     aAlutInShift = aXlutWordSize + aElutWordSize - aAlutAdrShift;*/
00787                 
00788                                                 ko = ko0 & (aAlutInShiftNum - 1 );
00789                                                 ko0 = ko0 >> aAlutInShift;
00790                                                 ko0 += aAlutOffset;
00791                                                 if( aAlutWordSize <= 8)
00792                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
00793                                                 else
00794                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
00795                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
00796                                                 aAlutOffset += aAlutAdrSize;
00797                                         }
00798                                 }
00799                 }
00800         
00801         #if FARBR_DEBUG
00802                 if( aOutputPackMode < k3ShortsUnpacked ){DebugPrint("aus_arr=(d)");for( ii=0; ii<aXlutOutDim; ++ii) DebugPrint("%3ld ",aus_arr[ii+o] ); DebugPrint("\n");}
00803                 else{DebugPrint("aus_arr=(d)");for( ii=0; ii<aXlutOutDim; ++ii) DebugPrint("%3ld ",aAusArr[ii+o] ); DebugPrint("\n");}
00804         #endif
00805                         if( aCopyAlpha ){
00806                                 if( aOutputPackMode8Bit )
00807                                         *outputData[aXlutOutDim] = *inputData[aXlutInDim];
00808                                 else
00809                                         *((LH_UINT16 *)outputData[aXlutOutDim]) = *((LH_UINT16 *)inputData[aXlutInDim]);
00810                         }
00811                         while (--i){
00812                                 for( jj=0; jj<aXlutInDim; ++jj){
00813                                         inputData[jj] += InputIncrement;
00814                                 }
00815                                 for( jj=0; jj<aXlutOutDim; ++jj){
00816                                         outputData[jj] += OutputIncrement;
00817                                 }
00818                                 if( aCopyAlpha ){
00819                                         inputData[aXlutInDim] += InputIncrement;
00820                                         outputData[aXlutOutDim] += OutputIncrement;
00821                                 }
00822         
00823                                 if( aInputPackMode8Bit ){
00824                                         for( jj=0; jj<aXlutInDim; ++jj){
00825                                                 if( *inputData[jj] ^ *(LH_UINT8 *)(&ein_Cache[jj]) )break;
00826                                         }
00827                                 }
00828                                 else{
00829                                         for( jj=0; jj<aXlutInDim; ++jj){
00830                                                 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break;
00831                                         }
00832                                 }
00833                                 if( jj<aXlutInDim ) break;
00834                                 if( aOutputPackMode8Bit ){
00835                                         for( jj=0; jj<aXlutOutDim; ++jj){
00836                                                 *outputData[jj] = outputData[jj][-(long)OutputIncrement];
00837                                         }
00838                                         if( aCopyAlpha ){
00839                                                 *outputData[aXlutOutDim] = *inputData[aXlutInDim];
00840                                         }
00841                                 }
00842                                 else{
00843                                         for( jj=0; jj<aXlutOutDim; ++jj){
00844                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)OutputIncrement]);
00845                                         }
00846                                         if( aCopyAlpha ){
00847                                                 *((LH_UINT16 *)outputData[aXlutOutDim]) = *((LH_UINT16 *)inputData[aXlutInDim]);
00848                                         }
00849                                 }
00850                         }
00851                 }
00852                 
00853                 if( --LineCount ){
00854                         for( jj=0; jj<aXlutInDim; ++jj){
00855                                 inputData[jj] += inputDataRowOffset;
00856                         }
00857                         for( jj=0; jj<aXlutOutDim; ++jj){
00858                                 outputData[jj] += outputDataRowOffset;
00859                         }
00860                         if( aCopyAlpha ){
00861                                 inputData[aXlutInDim] += inputDataRowOffset;
00862                                 outputData[aXlutOutDim] += outputDataRowOffset;
00863                         }
00864                 }
00865     }
00866     }
00867 
00868         /* UNLOCK_DATA( aElutHdle ); */
00869         /* UNLOCK_DATA( aAlutHdle ); */
00870         /* UNLOCK_DATA( aXlutHdle ); */
00871 
00872         LH_END_PROC("CalcNDim_Data8To8_Lut16")
00873         return noErr;
00874 }

CMError CalcNDim_Data8To8_Lut8 (  CMCalcParamPtr  calcParam,
CMLutParamPtr  lutParam
) 
 

Definition at line 907 of file lh_core/calcndim.c. 

00909 {
00910         return CalcNDim_Data8To8_Lut16( calcParam, lutParam );
00911 }

Generated on Sat May 15 19:43:02 2004 for test by doxygen 1.3.7