test: w98/lh_core/calcndim.c File Reference

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

# calcndim.c File Reference

`#include "General.h"`
`#include "CalcEng.h"`
`#include "CalcNDim.h"`

Go to the source code of this file.

## Defines

#define | UNROLL_NDIM 1
#define | SHRINK_FACTOR 13
#define | DebugPrint(x)
#define | CLIPPWord(x, a, b) ((x)<(a)?(LH_UINT16)(a):((x)>(b)?(LH_UINT16)(b):(LH_UINT16)(x+.5)))
#define | CLIPP(x, a, b) ((x)<(a)?(a):((x)>(b)?(b):(x)))

## Functions

CMError | Calc323Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError | Calc324Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError | Calc423Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError | Calc424Dim_Data8To8_Lut16 (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)
CMError | CalcNDim_Data8To8_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError | CalcNDim_Data16To8_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError | CalcNDim_Data8To16_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)
CMError | CalcNDim_Data16To16_Lut8 (CMCalcParamPtr calcParam, CMLutParamPtr lutParam)

## Define Documentation

#define CLIPP | ( | x,
|  | a,
|  | b |  | ) | ((x)<(a)?(a):((x)>(b)?(b):(x)))

| Definition at line 58 of file w98/lh_core/calcndim.c.

#define CLIPPWord | ( | x,
|  | a,
|  | b |  | ) | ((x)<(a)?(LH_UINT16)(a):((x)>(b)?(LH_UINT16)(b):(LH_UINT16)(x+.5)))

| Definition at line 57 of file w98/lh_core/calcndim.c.

#define DebugPrint | ( | x |  | ) |

| Definition at line 54 of file w98/lh_core/calcndim.c.

#define SHRINK_FACTOR 13

| Definition at line 37 of file w98/lh_core/calcndim.c.

#define UNROLL_NDIM 1

| Definition at line 25 of file w98/lh_core/calcndim.c.

## Function Documentation

CMError Calc323Dim_Data8To8_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 41 of file w98/lh_core/calcnd3.c.

References adr_bereich_alut, adr_bereich_elut, adr_breite_alut, adr_breite_elut, aElutShift, aElutShiftNum, cm8PerChannelPacking, CMError, CMCalcParam::cmInputBytesPerLine, CMCalcParam::cmInputPixelOffset, CMCalcParam::cmLineCount, cmLong8ColorPacking, CMCalcParam::cmOutputBytesPerLine, CMCalcParam::cmOutputColorSpace, CMCalcParam::cmOutputPixelOffset, cmparamErr, CMCalcParam::cmPixelPerLine, CMLutParam::colorLut, CMLutParam::colorLutGridPoints, CMLutParam::colorLutWordSize, DebugPrint, Hold, Index, CMCalcParam::inputData, CMLutParam::inputLut, CMLutParam::inputLutWordSize, LH_END_PROC, LH_START_PROC, LH_UINT16, LH_UINT8, NDIM_IN_DIM, NDIM_OUT_DIM, noErr, CMCalcParam::outputData, CMLutParam::outputLut, CMLutParam::outputLutWordSize, and UINT32.

Referenced by CalcNDim_Data8To8_Lut16().

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

CMError Calc324Dim_Data8To8_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 964 of file w98/lh_core/calcnd3.c.

References adr_bereich_alut, adr_bereich_elut, adr_breite_alut, adr_breite_elut, aElutShift, aElutShiftNum, cm8PerChannelPacking, CMError, CMCalcParam::cmInputBytesPerLine, CMCalcParam::cmInputPixelOffset, CMCalcParam::cmLineCount, cmLong8ColorPacking, CMCalcParam::cmOutputBytesPerLine, CMCalcParam::cmOutputColorSpace, CMCalcParam::cmOutputPixelOffset, cmparamErr, CMCalcParam::cmPixelPerLine, CMLutParam::colorLut, CMLutParam::colorLutGridPoints, CMLutParam::colorLutWordSize, DebugPrint, Hold, Index, CMCalcParam::inputData, CMLutParam::inputLut, CMLutParam::inputLutWordSize, LH_END_PROC, LH_START_PROC, LH_UINT16, LH_UINT8, NDIM_IN_DIM, NDIM_OUT_DIM, noErr, CMCalcParam::outputData, CMLutParam::outputLut, CMLutParam::outputLutWordSize, and UINT32.

Referenced by CalcNDim_Data8To8_Lut16().

    00967 {
    00968         LH_UINT8 * inputData[8], *outputData[8];
    00969         UINT32 OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount;
    00970         register unsigned long adr0;
    00971     register unsigned long ko0;
    00972     unsigned long accu[8];
    00973     register long i;
    00974     /*long Offsets[8];*/
    00975
    00976     register long aAlutShift,aElutOffset,aAlutOffset;
    00977     register long aElutWordSize;
    00978     register long aAlutWordSize;
    00979     register long aXlutAdrSize;
    00980     register long aXlutAdrShift;
    00981     register unsigned long aXlutWordSize;
    00982         register unsigned long ii,jj;
    00983     register long aOutputPackMode8Bit;
    00984         long ein_Cache[8];
    00985
    00986         LH_UINT16 * aus_lut     = (LH_UINT16*)lutParam->outputLut;
    00987         LH_UINT16 * ein_lut     = (LH_UINT16*)lutParam->inputLut;
    00988         LH_UINT16 * Xlut        = (LH_UINT16*)lutParam->colorLut;
    00989
    00990         #ifdef DEBUG_OUTPUT
    00991         long err = noErr;
    00992         #endif
    00993         LH_START_PROC("Calc324Dim_Data8To8_Lut16")
    00994
    00995         inputData[0] = (LH_UINT8 *)calcParam->inputData[0];
    00996         inputData[1] = (LH_UINT8 *)calcParam->inputData[1];
    00997         inputData[2] = (LH_UINT8 *)calcParam->inputData[2];
    00998 #if NDIM_IN_DIM == 4
    00999         inputData[3] = (LH_UINT8 *)calcParam->inputData[3];
    01000 #endif
    01001         outputData[0] = (LH_UINT8 *)calcParam->outputData[0];
    01002         outputData[1] = (LH_UINT8 *)calcParam->outputData[1];
    01003         outputData[2] = (LH_UINT8 *)calcParam->outputData[2];
    01004 #if NDIM_OUT_DIM == 4
    01005         outputData[3] = (LH_UINT8 *)calcParam->outputData[3];
    01006 #endif
    01007
    01008         OutputIncrement = calcParam->cmOutputPixelOffset;
    01009         inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + (NDIM_IN_DIM * 2);
    01010         outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement;
    01011
    01012         Pixelcount = calcParam->cmPixelPerLine;
    01013         LineCount = calcParam->cmLineCount;
    01014
    01015         aElutWordSize = lutParam->inputLutWordSize;
    01016         aAlutWordSize = lutParam->outputLutWordSize;
    01017         aXlutAdrSize = lutParam->colorLutGridPoints;
    01018         for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++)
    01019                 aXlutAdrShift = i;
    01020         aXlutWordSize = lutParam->colorLutWordSize;
    01021
    01022         aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking;
    01023    /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/
    01024         #if FARBR_FILES
    01025         WriteLuts(      "DoNDim",1,adr_bereich_elut,aElutWordSize,ein_lut,
    01026                                 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,adr_bereich_alut,aAlutWordSize,(LH_UINT16 *)aus_lut);
    01027     #endif
    01028
    01029         i=0;
    01030
    01031         {
    01032                 if( aElutShift < 0 )
    01033                 {
    01034                         #ifdef DEBUG_OUTPUT
    01035                         DebugPrint("¥ DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift);
    01036                         #endif
    01037                         return cmparamErr;
    01038                 }
    01039         }
    01040
    01041         if( aOutputPackMode8Bit ){
    01042                 aAlutShift = (aAlutWordSize-8);
    01043         }
    01044         else{
    01045                 aAlutShift = (16 - aAlutWordSize);
    01046         }
    01047
    01048         #ifdef DEBUG_OUTPUT
    01049                 if ( DebugCheck(kThisFile, kDebugReserved1) ){
    01050                     DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n",
    01051                                                 adr_bereich_elut,adr_breite_elut,aElutWordSize,ein_lut);
    01052                         DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n",
    01053                                                 adr_bereich_alut,adr_breite_alut,aAlutWordSize,aus_lut);
    01054                         DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n",
    01055                                                 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut);
    01056                 }
    01057     #endif
    01058
    01059     /*if( 1 )*/
    01060     if( aXlutAdrSize != (1<<aXlutAdrShift )){
    01061     register long aXlutOffset;
    01062     long theXlutOffsets[8];
    01063     register unsigned long aAlutInShift;
    01064     register long aAlutInShiftRemainder;
    01065     register unsigned long aAlutInShiftNum;
    01066     register long aElutWordSizeMask = (1<<aElutWordSize) - 1;
    01067     register unsigned long aAlutRound;
    01068    aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;
    01069     aAlutInShiftRemainder = 0;
    01070     if( aAlutInShift > 16 ){
    01071         aAlutInShiftRemainder = aAlutInShift - 16;
    01072         aAlutInShift = 16;
    01073     }
    01074     aAlutInShiftNum = (1<<aAlutInShift);
    01075
    01076 #ifdef DEBUG_OUTPUT
    01077         if ( DebugCheck(kThisFile, kDebugMiscInfo) )
    01078             DebugPrint("  DoNDim gripoints = %ld\n",aXlutAdrSize);
    01079 #endif
    01080     if( aElutWordSize <= 0 ){
    01081 #ifdef DEBUG_OUTPUT
    01082         DebugPrint("¥ DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize);
    01083 #endif
    01084         return cmparamErr;
    01085     }
    01086     if( aAlutInShift <= 0 ){
    01087 #ifdef DEBUG_OUTPUT
    01088         DebugPrint("¥ DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift);
    01089 #endif
    01090         return cmparamErr;
    01091     }
    01092     aXlutOffset =NDIM_OUT_DIM;
    01093     for( i=0; i<(long)NDIM_IN_DIM; i++){
    01094         theXlutOffsets[ NDIM_IN_DIM-1-i] = aXlutOffset;
    01095         aXlutOffset *=aXlutAdrSize;
    01096     }
    01097         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
    01098
    01099 #ifdef DEBUG_OUTPUT
    01100         if ( DebugCheck(kThisFile, kDebugReserved1) )
    01101             DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(adr_bereich_alut/2))/adr_bereich_alut = %ld\n",aElutWordSize,aAlutInShift);
    01102 #endif
    01103
    01104         while (LineCount){
    01105                 i = Pixelcount;
    01106
    01107                 while (i){
    01108
    01109                 long adr[8],Index[8];
    01110                 LH_UINT16 ein_reg[8];
    01111                 register unsigned long  adrAdr,ko,adrOffset;
    01112
    01113                 adr0=0;
    01114                         aElutOffset = 0;
    01115                         jj=0;
    01116
    01117                                 ein_Cache[0]=jj=(*(LH_UINT16 *)inputData[0]);
    01118                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01119                                         ko = ko0 & ( aElutShiftNum - 1 );
    01120                                         ko0 = ko0 >> aElutShift;
    01121                                         ko0 += aElutOffset;
    01122                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01123
    01124                                 jj *= aXlutAdrSize;
    01125                                 aElutOffset += adr_bereich_elut;
    01126                                 adr[0] = jj & aElutWordSizeMask;
    01127                                 jj = jj >> aElutWordSize;
    01128                                 adr0 += (jj)*theXlutOffsets[0];
    01129                                 ein_reg[0] = (LH_UINT16)jj;
    01130
    01131                                 ein_Cache[1]=jj=(*(LH_UINT16 *)inputData[1]);
    01132                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01133                                         ko = ko0 & ( aElutShiftNum - 1 );
    01134                                         ko0 = ko0 >> aElutShift;
    01135                                         ko0 += aElutOffset;
    01136                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01137
    01138                                 jj *= aXlutAdrSize;
    01139                                 aElutOffset += adr_bereich_elut;
    01140                                 adr[1] = jj & aElutWordSizeMask;
    01141                                 jj = jj >> aElutWordSize;
    01142                                 adr0 += (jj)*theXlutOffsets[1];
    01143                                 ein_reg[1] = (LH_UINT16)jj;
    01144
    01145                                         ein_Cache[2]=jj=(*(LH_UINT16 *)inputData[2]);
    01146                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01147                                         ko = ko0 & ( aElutShiftNum - 1 );
    01148                                         ko0 = ko0 >> aElutShift;
    01149                                         ko0 += aElutOffset;
    01150                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01151
    01152                                 jj *= aXlutAdrSize;
    01153                                 aElutOffset += adr_bereich_elut;
    01154                                 adr[2] = jj & aElutWordSizeMask;
    01155                                 jj = jj >> aElutWordSize;
    01156                                 adr0 += (jj)*theXlutOffsets[2];
    01157                                 ein_reg[2] = (LH_UINT16)jj;
    01158
    01159 #if NDIM_IN_DIM == 4
    01160                                         ein_Cache[3]=jj=(*(LH_UINT16 *)inputData[3]);
    01161                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01162                                         ko = ko0 & ( aElutShiftNum - 1 );
    01163                                         ko0 = ko0 >> aElutShift;
    01164                                         ko0 += aElutOffset;
    01165                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01166
    01167                                 jj *= aXlutAdrSize;
    01168                                 aElutOffset += adr_bereich_elut;
    01169                                 adr[3] = jj & aElutWordSizeMask;
    01170                                 jj = jj >> aElutWordSize;
    01171                                 adr0 += (jj)*theXlutOffsets[3];
    01172                                 ein_reg[3] = (LH_UINT16)jj;
    01173 #endif
    01174
    01175
    01176
    01177                 {                                                               /* a kind of */
    01178                     register long Hold;
    01179
    01180
    01181                                 Index[0] = 0;
    01182                                 Index[1] = 1;
    01183                                 Index[2] = 2;
    01184 #if NDIM_IN_DIM == 4
    01185                                 Index[3] = 3;
    01186 #endif
    01187                                         if( adr[0] < adr[1] ){
    01188                                                 Hold = Index[0];
    01189                                                 Index[0] = Index[1];
    01190                                                 Index[1] = Hold;
    01191                                         }
    01192
    01193                                         if( adr[Index[1]] < adr[2] ){
    01194                                                 Hold = Index[1];
    01195                                                 Index[1] = Index[2];
    01196                                                 Index[2] = Hold;
    01197                                                 if( adr[Index[0]] < adr[Index[1]] ){
    01198                                                         Hold = Index[0];
    01199                                                         Index[0] = Index[1];
    01200                                                         Index[1] = Hold;
    01201                                                 }
    01202                                         }
    01203
    01204 #if NDIM_IN_DIM == 4
    01205                                         if( adr[Index[2]] < adr[3] ){
    01206                                                 Hold = Index[2];
    01207                                                 Index[2] = Index[3];
    01208                                                 Index[3] = Hold;
    01209                                                 if( adr[Index[1]] < adr[Index[2]] ){
    01210                                                         Hold = Index[1];
    01211                                                         Index[1] = Index[2];
    01212                                                         Index[2] = Hold;
    01213                                                         if( adr[Index[0]] < adr[Index[1]] ){
    01214                                                                 Hold = Index[0];
    01215                                                                 Index[0] = Index[1];
    01216                                                                 Index[1] = Hold;
    01217                                                         }
    01218                                                 }
    01219                                         }
    01220 #endif
    01221                 }
    01222
    01223         accu[0]=0;
    01224         accu[1]=0;
    01225         accu[2]=0;
    01226 #if NDIM_OUT_DIM == 4
    01227         accu[3]=0;
    01228 #endif
    01229         ko0 = (1<<aElutWordSize);
    01230         adrAdr=adr0;
    01231         adrOffset=0;
    01232         if( aXlutWordSize  == 16 ){
    01233                 jj = Index[0];
    01234                 ko = ko0 - adr[jj];
    01235                 ko0 = adr[jj];
    01236
    01237                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01238                     adrOffset += theXlutOffsets[jj];
    01239
    01240                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    01241                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    01242                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    01243 #if NDIM_OUT_DIM == 4
    01244                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    01245 #endif
    01246
    01247                 adrAdr = (adr0 + adrOffset);
    01248
    01249                 jj = Index[1];
    01250                 ko = ko0 - adr[jj];
    01251                 ko0 = adr[jj];
    01252
    01253                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01254                     adrOffset += theXlutOffsets[jj];
    01255
    01256                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    01257                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    01258                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    01259 #if NDIM_OUT_DIM == 4
    01260                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    01261 #endif
    01262
    01263                 adrAdr = (adr0 + adrOffset);
    01264
    01265                 jj = Index[2];
    01266                 ko = ko0 - adr[jj];
    01267                 ko0 = adr[jj];
    01268
    01269                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01270                     adrOffset += theXlutOffsets[jj];
    01271
    01272                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    01273                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    01274                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    01275 #if NDIM_OUT_DIM == 4
    01276                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    01277 #endif
    01278
    01279                 adrAdr = (adr0 + adrOffset);
    01280
    01281 #if NDIM_IN_DIM == 4
    01282                 jj = Index[3];
    01283                 ko = ko0 - adr[jj];
    01284                 ko0 = adr[jj];
    01285
    01286                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01287                     adrOffset += theXlutOffsets[jj];
    01288
    01289                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    01290                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    01291                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    01292 #if NDIM_OUT_DIM == 4
    01293                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    01294 #endif
    01295
    01296                 adrAdr = (adr0 + adrOffset);
    01297 #endif
    01298
    01299                 accu[0]+=Xlut[adrAdr+0]*ko0;
    01300                 accu[1]+=Xlut[adrAdr+1]*ko0;
    01301                 accu[2]+=Xlut[adrAdr+2]*ko0;
    01302  #if NDIM_OUT_DIM == 4
    01303                accu[3]+=Xlut[adrAdr+3]*ko0;
    01304  #endif
    01305        }
    01306        else{
    01307
    01308                 jj = Index[0];
    01309                 ko = ko0 - adr[jj];
    01310                 ko0 = adr[jj];
    01311
    01312                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01313                     adrOffset += theXlutOffsets[jj];
    01314
    01315                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01316                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01317                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01318 #if NDIM_OUT_DIM == 4
    01319                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01320 #endif
    01321                 adrAdr = (adr0 + adrOffset);
    01322
    01323                 jj = Index[1];
    01324                 ko = ko0 - adr[jj];
    01325                 ko0 = adr[jj];
    01326
    01327                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01328                     adrOffset += theXlutOffsets[jj];
    01329
    01330                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01331                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01332                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01333 #if NDIM_OUT_DIM == 4
    01334                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01335 #endif
    01336                 adrAdr = (adr0 + adrOffset);
    01337
    01338                 jj = Index[2];
    01339                 ko = ko0 - adr[jj];
    01340                 ko0 = adr[jj];
    01341
    01342                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01343                     adrOffset += theXlutOffsets[jj];
    01344
    01345                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01346                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01347                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01348 #if NDIM_OUT_DIM == 4
    01349                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01350 #endif
    01351                 adrAdr = (adr0 + adrOffset);
    01352
    01353 #if NDIM_IN_DIM == 4
    01354                 jj = Index[3];
    01355                 ko = ko0 - adr[jj];
    01356                 ko0 = adr[jj];
    01357
    01358                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    01359                     adrOffset += theXlutOffsets[jj];
    01360
    01361                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01362                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01363                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01364 #if NDIM_OUT_DIM == 4
    01365                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01366 #endif
    01367                 adrAdr = (adr0 + adrOffset);
    01368 #endif
    01369                 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0;
    01370                 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0;
    01371                 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0;
    01372 #if NDIM_OUT_DIM == 4
    01373                accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0;
    01374 #endif
    01375         }
    01376
    01377                 aAlutOffset = 0;
    01378
    01379                 if( aOutputPackMode8Bit ){
    01380                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    01381                                         jj = accu[ii];
    01382                                         jj = jj + ( jj >> aXlutWordSize );
    01383
    01384                                         ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder;     /*      aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    01385
    01386                                         ko = ko0 & (aAlutInShiftNum - 1 );
    01387                                         ko0 = ko0 >> aAlutInShift;
    01388                                         ko0 += aAlutOffset;
    01389                                         if( aAlutWordSize <= 8)
    01390                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
    01391                                         else{
    01392                                         jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
    01393                                                 jj = jj - ( jj >> aAlutShift );
    01394                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
    01395                                         }
    01396                                         *outputData[ii] = (LH_UINT8)jj;
    01397                         aAlutOffset += adr_bereich_alut;
    01398                     }
    01399                         }
    01400                         else{
    01401                                 if( aXlutWordSize >= 16 ){
    01402                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    01403                                                 jj = accu[ii];
    01404                                                 jj = jj + ( jj >> aXlutWordSize );
    01405                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    01406
    01407                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    01408                                                 ko0 = ko0 >> aAlutInShift;
    01409                                                 ko0 += aAlutOffset;
    01410                                                 if( aAlutWordSize <= 8)
    01411                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    01412                                                 else
    01413                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    01414                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    01415                                                 aAlutOffset += adr_bereich_alut;
    01416                                         }
    01417                                 }
    01418                                 else{
    01419                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    01420                                                 jj = accu[ii];
    01421                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
    01422                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) ; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    01423
    01424                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    01425                                                 ko0 = ko0 >> aAlutInShift;
    01426                                                 ko0 += aAlutOffset;
    01427                                                 if( aAlutWordSize <= 8)
    01428                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    01429                                                 else
    01430                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    01431                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    01432                                                 aAlutOffset += adr_bereich_alut;
    01433                                         }
    01434                                 }
    01435                         }
    01436                         while (--i){
    01437                                 for( jj=0; jj<NDIM_IN_DIM; ++jj){
    01438                                         inputData[jj] += (NDIM_IN_DIM * 2);
    01439                                 }
    01440                                 for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01441                                         outputData[jj] += OutputIncrement;
    01442                                 }
    01443
    01444                                 {
    01445                                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    01446                                                 if( *((LH_UINT16 *)inputData[jj]) ^ *(LH_UINT16 *)(&ein_Cache[jj]) )break;
    01447                                         }
    01448                                 }
    01449                                 if( jj<NDIM_IN_DIM ) break;
    01450                                 if( aOutputPackMode8Bit ){
    01451                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01452                                                 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )];
    01453                                         }
    01454                                 }
    01455                                 else{
    01456                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01457                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]);
    01458                                         }
    01459                                 }
    01460                         }
    01461                 }
    01462
    01463                 if( --LineCount ){
    01464                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    01465                                 inputData[jj] += inputDataRowOffset;
    01466                         }
    01467                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01468                                 outputData[jj] += outputDataRowOffset;
    01469                         }
    01470                 }
    01471     }
    01472     }
    01473     else{
    01474
    01475     register unsigned long  bit_breit_selektor;
    01476     register unsigned long  bit_maske_selektor;
    01477     register unsigned long  bit_breit_adr;
    01478     register unsigned long  bit_maske_adr;
    01479     register unsigned long  aAlutInShiftNum;
    01480     register long aAlutInShift;
    01481     register long aAlutInShiftRemainder;
    01482     register unsigned long aAlutRound;
    01483     /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/
    01484     bit_breit_selektor=aElutWordSize-aXlutAdrShift;
    01485     if( aElutWordSize-aXlutAdrShift < 0 )
    01486     {
    01487 #ifdef DEBUG_OUTPUT
    01488         DebugPrint("¥ DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor);
    01489 #endif
    01490         return cmparamErr;
    01491     }
    01492     bit_maske_selektor=(1<<bit_breit_selektor)-1;
    01493     bit_breit_adr=aXlutAdrShift;
    01494     bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor;
    01495     aAlutInShift = (aXlutWordSize+bit_breit_selektor-adr_breite_alut);
    01496     /*aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    01497     aAlutInShiftRemainder = 0;
    01498     if( aAlutInShift > 16 ){
    01499         aAlutInShiftRemainder = aAlutInShift - 16;
    01500         aAlutInShift = 16;
    01501     }
    01502
    01503     aAlutInShiftNum = (1<<aAlutInShift);
    01504
    01505         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
    01506         while (LineCount){
    01507                 i = Pixelcount;
    01508
    01509                 while (i){
    01510
    01511                 long adr[8],Index[8];
    01512                 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/
    01513                 LH_UINT16 ein_reg[8];
    01514                    register unsigned long  adrAdr,ko,adrOffset;
    01515                 /*register unsigned long aIndex;*/
    01516
    01517                 adr0=0;
    01518                 aElutOffset = 0;
    01519                 jj=0;
    01520                         ein_Cache[0]=jj=(*(LH_UINT16 *)inputData[0]);
    01521                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01522                         ko = ko0 & ( aElutShiftNum - 1 );
    01523                         ko0 = ko0 >> aElutShift;
    01524                         ko0 += aElutOffset;
    01525                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01526
    01527                         aElutOffset += adr_bereich_elut;
    01528                         adr[0] = (jj & bit_maske_selektor);
    01529                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-0-1)*bit_breit_adr);
    01530                         ein_reg[0] = (LH_UINT16)jj;
    01531
    01532                         ein_Cache[1]=jj=(*(LH_UINT16 *)inputData[1]);
    01533                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01534                         ko = ko0 & ( aElutShiftNum - 1 );
    01535                         ko0 = ko0 >> aElutShift;
    01536                         ko0 += aElutOffset;
    01537                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01538
    01539                         aElutOffset += adr_bereich_elut;
    01540                         adr[1] = (jj & bit_maske_selektor);
    01541                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-1-1)*bit_breit_adr);
    01542                         ein_reg[1] = (LH_UINT16)jj;
    01543
    01544                         ein_Cache[2]=jj=(*(LH_UINT16 *)inputData[2]);
    01545                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01546                         ko = ko0 & ( aElutShiftNum - 1 );
    01547                         ko0 = ko0 >> aElutShift;
    01548                         ko0 += aElutOffset;
    01549                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01550
    01551                         aElutOffset += adr_bereich_elut;
    01552                         adr[2] = (jj & bit_maske_selektor);
    01553                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-2-1)*bit_breit_adr);
    01554                         ein_reg[2] = (LH_UINT16)jj;
    01555
    01556 #if NDIM_IN_DIM == 4
    01557                         ein_Cache[3]=jj=(*(LH_UINT16 *)inputData[3]);
    01558                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    01559                         ko = ko0 & ( aElutShiftNum - 1 );
    01560                         ko0 = ko0 >> aElutShift;
    01561                         ko0 += aElutOffset;
    01562                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    01563
    01564                         aElutOffset += adr_bereich_elut;
    01565                         adr[3] = (jj & bit_maske_selektor);
    01566                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-3-1)*bit_breit_adr);
    01567                         ein_reg[3] = (LH_UINT16)jj;
    01568 #endif
    01569                 adr0 *= NDIM_OUT_DIM;
    01570
    01571                 {                                                               /* a kind of */
    01572                     register long Hold;
    01573
    01574
    01575                                 Index[0] = 0;
    01576                                 Index[1] = 1;
    01577                                 Index[2] = 2;
    01578 #if NDIM_IN_DIM == 4
    01579                                 Index[3] = 3;
    01580 #endif
    01581                                         if( adr[0] < adr[1] ){
    01582                                                 Hold = Index[0];
    01583                                                 Index[0] = Index[1];
    01584                                                 Index[1] = Hold;
    01585                                         }
    01586
    01587                                         if( adr[Index[1]] < adr[2] ){
    01588                                                 Hold = Index[1];
    01589                                                 Index[1] = Index[2];
    01590                                                 Index[2] = Hold;
    01591                                                 if( adr[Index[0]] < adr[Index[1]] ){
    01592                                                         Hold = Index[0];
    01593                                                         Index[0] = Index[1];
    01594                                                         Index[1] = Hold;
    01595                                                 }
    01596                                         }
    01597
    01598 #if NDIM_IN_DIM == 4
    01599                                         if( adr[Index[2]] < adr[3] ){
    01600                                                 Hold = Index[2];
    01601                                                 Index[2] = Index[3];
    01602                                                 Index[3] = Hold;
    01603                                                 if( adr[Index[1]] < adr[Index[2]] ){
    01604                                                         Hold = Index[1];
    01605                                                         Index[1] = Index[2];
    01606                                                         Index[2] = Hold;
    01607                                                         if( adr[Index[0]] < adr[Index[1]] ){
    01608                                                                 Hold = Index[0];
    01609                                                                 Index[0] = Index[1];
    01610                                                                 Index[1] = Hold;
    01611                                                         }
    01612                                                 }
    01613                                         }
    01614 #endif
    01615                 }
    01616
    01617                         accu[0]=0;
    01618                         accu[1]=0;
    01619                         accu[2]=0;
    01620 #if NDIM_OUT_DIM == 4
    01621                         accu[3]=0;
    01622 #endif
    01623
    01624                 ko0 = bit_maske_selektor+1;
    01625                 adrAdr=adr0;
    01626                 adrOffset=0;
    01627
    01628                 if( aXlutWordSize  == 16 ){
    01629                         jj = Index[0];
    01630                         ko = ko0 - adr[jj];
    01631                         ko0 = adr[jj];
    01632
    01633                         if( ein_reg[jj] < bit_maske_adr )
    01634                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01635
    01636                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    01637                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    01638                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    01639 #if NDIM_OUT_DIM == 4
    01640                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    01641 #endif
    01642                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01643
    01644                         jj = Index[1];
    01645                         ko = ko0 - adr[jj];
    01646                         ko0 = adr[jj];
    01647
    01648                         if( ein_reg[jj] < bit_maske_adr )
    01649                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01650
    01651                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    01652                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    01653                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    01654 #if NDIM_OUT_DIM == 4
    01655                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    01656 #endif
    01657                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01658
    01659                         jj = Index[2];
    01660                         ko = ko0 - adr[jj];
    01661                         ko0 = adr[jj];
    01662
    01663                         if( ein_reg[jj] < bit_maske_adr )
    01664                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01665
    01666                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    01667                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    01668                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    01669 #if NDIM_OUT_DIM == 4
    01670                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    01671 #endif
    01672                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01673
    01674 #if NDIM_IN_DIM == 4
    01675                         jj = Index[3];
    01676                         ko = ko0 - adr[jj];
    01677                         ko0 = adr[jj];
    01678
    01679                         if( ein_reg[jj] < bit_maske_adr )
    01680                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01681
    01682                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    01683                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    01684                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    01685 #if NDIM_OUT_DIM == 4
    01686                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    01687 #endif
    01688                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01689 #endif
    01690                 accu[0]+=Xlut[adrAdr+0]*ko0;
    01691                 accu[1]+=Xlut[adrAdr+1]*ko0;
    01692                 accu[2]+=Xlut[adrAdr+2]*ko0;
    01693 #if NDIM_OUT_DIM == 4
    01694                                 accu[3]+=Xlut[adrAdr+3]*ko0;
    01695 #endif
    01696                 }
    01697                 else{
    01698                         jj = Index[0];
    01699                         ko = ko0 - adr[jj];
    01700                         ko0 = adr[jj];
    01701
    01702                         if( ein_reg[jj] < bit_maske_adr )
    01703                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01704
    01705                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01706                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01707                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01708 #if NDIM_OUT_DIM == 4
    01709                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01710 #endif
    01711
    01712                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01713
    01714                         jj = Index[1];
    01715                         ko = ko0 - adr[jj];
    01716                         ko0 = adr[jj];
    01717
    01718                         if( ein_reg[jj] < bit_maske_adr )
    01719                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01720
    01721                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01722                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01723                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01724 #if NDIM_OUT_DIM == 4
    01725                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01726 #endif
    01727
    01728                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01729
    01730                         jj = Index[2];
    01731                         ko = ko0 - adr[jj];
    01732                         ko0 = adr[jj];
    01733
    01734                         if( ein_reg[jj] < bit_maske_adr )
    01735                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01736
    01737                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01738                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01739                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01740 #if NDIM_OUT_DIM == 4
    01741                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01742 #endif
    01743
    01744                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01745
    01746 #if NDIM_IN_DIM == 4
    01747                         jj = Index[3];
    01748                         ko = ko0 - adr[jj];
    01749                         ko0 = adr[jj];
    01750
    01751                         if( ein_reg[jj] < bit_maske_adr )
    01752                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    01753
    01754                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    01755                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    01756                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    01757 #if NDIM_OUT_DIM == 4
    01758                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    01759 #endif
    01760
    01761                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    01762 #endif
    01763                                 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0;
    01764                 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0;
    01765                 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0;
    01766 #if NDIM_OUT_DIM == 4
    01767                                 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0;
    01768 #endif
    01769                 }
    01770
    01771                 aAlutOffset = 0;
    01772
    01773                 if( aOutputPackMode8Bit ){
    01774                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    01775                                         jj = accu[ii];
    01776                                         jj = jj + ( jj >> aXlutWordSize );
    01777
    01778                                         ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder;     /*      aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    01779
    01780                                         ko = ko0 & (aAlutInShiftNum - 1 );
    01781                                         ko0 = ko0 >> aAlutInShift;
    01782                                         ko0 += aAlutOffset;
    01783                                         if( aAlutWordSize <= 8)
    01784                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
    01785                                         else{
    01786                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
    01787                                                 jj = jj - ( jj >> aAlutShift );
    01788                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
    01789                                         }
    01790
    01791                                         *outputData[ii] = (LH_UINT8)jj;
    01792                         aAlutOffset += adr_bereich_alut;
    01793                     }
    01794                 }
    01795                 else{
    01796                                 if( aXlutWordSize >= 16 ){
    01797                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    01798                                                 jj = accu[ii];
    01799                                                 jj = jj + ( jj >> aXlutWordSize );
    01800                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    01801
    01802                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    01803                                                 ko0 = ko0 >> aAlutInShift;
    01804                                                 ko0 += aAlutOffset;
    01805                                                 if( aAlutWordSize <= 8)
    01806                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    01807                                                 else
    01808                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    01809                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    01810                                                 aAlutOffset += adr_bereich_alut;
    01811                                         }
    01812                                 }
    01813                                 else{
    01814                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    01815                                                 jj = accu[ii];
    01816                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
    01817                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))); /*   aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    01818
    01819                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    01820                                                 ko0 = ko0 >> aAlutInShift;
    01821                                                 ko0 += aAlutOffset;
    01822                                                 if( aAlutWordSize <= 8)
    01823                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    01824                                                 else
    01825                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    01826                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    01827                                                 aAlutOffset += adr_bereich_alut;
    01828                                         }
    01829                                 }
    01830                 }
    01831
    01832                         while (--i){
    01833                                 for( jj=0; jj<NDIM_IN_DIM; ++jj){
    01834                                         inputData[jj] += (NDIM_IN_DIM * 2);
    01835                                 }
    01836                                 for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01837                                         outputData[jj] += OutputIncrement;
    01838                                 }
    01839
    01840                                 {
    01841                                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    01842                                                 if( *((LH_UINT16 *)inputData[jj]) ^ *(LH_UINT16 *)(&ein_Cache[jj]) )break;
    01843                                         }
    01844                                 }
    01845                                 if( jj<NDIM_IN_DIM ) break;
    01846                                 if( aOutputPackMode8Bit ){
    01847                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01848                                                 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )];
    01849                                         }
    01850                                 }
    01851                                 else{
    01852                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01853                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]);
    01854                                         }
    01855                                 }
    01856                         }
    01857                 }
    01858
    01859                 if( --LineCount ){
    01860                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    01861                                 inputData[jj] += inputDataRowOffset;
    01862                         }
    01863                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    01864                                 outputData[jj] += outputDataRowOffset;
    01865                         }
    01866                 }
    01867     }
    01868     }
    01869
    01870         /* UNLOCK_DATA( aElutHdle ); */
    01871         /* UNLOCK_DATA( aAlutHdle ); */
    01872         /* UNLOCK_DATA( aXlutHdle ); */
    01873
    01874         LH_END_PROC("Calc324Dim_Data8To8_Lut16")
    01875         return noErr;
    01876 }

CMError Calc423Dim_Data8To8_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 1887 of file w98/lh_core/calcnd3.c.

References adr_bereich_alut, adr_bereich_elut, adr_breite_alut, adr_breite_elut, aElutShift, aElutShiftNum, cm8PerChannelPacking, CMError, CMCalcParam::cmInputBytesPerLine, CMCalcParam::cmInputPixelOffset, CMCalcParam::cmLineCount, cmLong8ColorPacking, CMCalcParam::cmOutputBytesPerLine, CMCalcParam::cmOutputColorSpace, CMCalcParam::cmOutputPixelOffset, cmparamErr, CMCalcParam::cmPixelPerLine, CMLutParam::colorLut, CMLutParam::colorLutGridPoints, CMLutParam::colorLutWordSize, DebugPrint, Hold, Index, CMCalcParam::inputData, CMLutParam::inputLut, CMLutParam::inputLutWordSize, LH_END_PROC, LH_START_PROC, LH_UINT16, LH_UINT8, NDIM_IN_DIM, NDIM_OUT_DIM, noErr, CMCalcParam::outputData, CMLutParam::outputLut, CMLutParam::outputLutWordSize, and UINT32.

Referenced by CalcNDim_Data8To8_Lut16().

    01890 {
    01891         LH_UINT8 * inputData[8], *outputData[8];
    01892         UINT32 OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount;
    01893         register unsigned long adr0;
    01894     register unsigned long ko0;
    01895     unsigned long accu[8];
    01896     register long i;
    01897     /*long Offsets[8];*/
    01898
    01899     register long aAlutShift,aElutOffset,aAlutOffset;
    01900     register long aElutWordSize;
    01901     register long aAlutWordSize;
    01902     register long aXlutAdrSize;
    01903     register long aXlutAdrShift;
    01904     register unsigned long aXlutWordSize;
    01905         register unsigned long ii,jj;
    01906     register long aOutputPackMode8Bit;
    01907         long ein_Cache[8];
    01908
    01909         LH_UINT16 * aus_lut     = (LH_UINT16*)lutParam->outputLut;
    01910         LH_UINT16 * ein_lut     = (LH_UINT16*)lutParam->inputLut;
    01911         LH_UINT16 * Xlut        = (LH_UINT16*)lutParam->colorLut;
    01912
    01913         #ifdef DEBUG_OUTPUT
    01914         long err = noErr;
    01915         #endif
    01916         LH_START_PROC("Calc423Dim_Data8To8_Lut16")
    01917
    01918         inputData[0] = (LH_UINT8 *)calcParam->inputData[0];
    01919         inputData[1] = (LH_UINT8 *)calcParam->inputData[1];
    01920         inputData[2] = (LH_UINT8 *)calcParam->inputData[2];
    01921 #if NDIM_IN_DIM == 4
    01922         inputData[3] = (LH_UINT8 *)calcParam->inputData[3];
    01923 #endif
    01924         outputData[0] = (LH_UINT8 *)calcParam->outputData[0];
    01925         outputData[1] = (LH_UINT8 *)calcParam->outputData[1];
    01926         outputData[2] = (LH_UINT8 *)calcParam->outputData[2];
    01927 #if NDIM_OUT_DIM == 4
    01928         outputData[3] = (LH_UINT8 *)calcParam->outputData[3];
    01929 #endif
    01930
    01931         OutputIncrement = calcParam->cmOutputPixelOffset;
    01932         inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + (NDIM_IN_DIM * 2);
    01933         outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement;
    01934
    01935         Pixelcount = calcParam->cmPixelPerLine;
    01936         LineCount = calcParam->cmLineCount;
    01937
    01938         aElutWordSize = lutParam->inputLutWordSize;
    01939         aAlutWordSize = lutParam->outputLutWordSize;
    01940         aXlutAdrSize = lutParam->colorLutGridPoints;
    01941         for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++)
    01942                 aXlutAdrShift = i;
    01943         aXlutWordSize = lutParam->colorLutWordSize;
    01944
    01945         aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking;
    01946    /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/
    01947         #if FARBR_FILES
    01948         WriteLuts(      "DoNDim",1,adr_bereich_elut,aElutWordSize,ein_lut,
    01949                                 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,adr_bereich_alut,aAlutWordSize,(LH_UINT16 *)aus_lut);
    01950     #endif
    01951
    01952         i=0;
    01953
    01954         {
    01955                 if( aElutShift < 0 )
    01956                 {
    01957                         #ifdef DEBUG_OUTPUT
    01958                         DebugPrint("¥ DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift);
    01959                         #endif
    01960                         return cmparamErr;
    01961                 }
    01962         }
    01963
    01964         if( aOutputPackMode8Bit ){
    01965                 aAlutShift = (aAlutWordSize-8);
    01966         }
    01967         else{
    01968                 aAlutShift = (16 - aAlutWordSize);
    01969         }
    01970
    01971         #ifdef DEBUG_OUTPUT
    01972                 if ( DebugCheck(kThisFile, kDebugReserved1) ){
    01973                     DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n",
    01974                                                 adr_bereich_elut,adr_breite_elut,aElutWordSize,ein_lut);
    01975                         DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n",
    01976                                                 adr_bereich_alut,adr_breite_alut,aAlutWordSize,aus_lut);
    01977                         DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n",
    01978                                                 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut);
    01979                 }
    01980     #endif
    01981
    01982     /*if( 1 )*/
    01983     if( aXlutAdrSize != (1<<aXlutAdrShift )){
    01984     register long aXlutOffset;
    01985     long theXlutOffsets[8];
    01986     register unsigned long aAlutInShift;
    01987     register long aAlutInShiftRemainder;
    01988     register unsigned long aAlutInShiftNum;
    01989     register long aElutWordSizeMask = (1<<aElutWordSize) - 1;
    01990     register unsigned long aAlutRound;
    01991    aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;
    01992     aAlutInShiftRemainder = 0;
    01993     if( aAlutInShift > 16 ){
    01994         aAlutInShiftRemainder = aAlutInShift - 16;
    01995         aAlutInShift = 16;
    01996     }
    01997     aAlutInShiftNum = (1<<aAlutInShift);
    01998
    01999 #ifdef DEBUG_OUTPUT
    02000         if ( DebugCheck(kThisFile, kDebugMiscInfo) )
    02001             DebugPrint("  DoNDim gripoints = %ld\n",aXlutAdrSize);
    02002 #endif
    02003     if( aElutWordSize <= 0 ){
    02004 #ifdef DEBUG_OUTPUT
    02005         DebugPrint("¥ DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize);
    02006 #endif
    02007         return cmparamErr;
    02008     }
    02009     if( aAlutInShift <= 0 ){
    02010 #ifdef DEBUG_OUTPUT
    02011         DebugPrint("¥ DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift);
    02012 #endif
    02013         return cmparamErr;
    02014     }
    02015     aXlutOffset =NDIM_OUT_DIM;
    02016     for( i=0; i<(long)NDIM_IN_DIM; i++){
    02017         theXlutOffsets[ NDIM_IN_DIM-1-i] = aXlutOffset;
    02018         aXlutOffset *=aXlutAdrSize;
    02019     }
    02020         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
    02021
    02022 #ifdef DEBUG_OUTPUT
    02023         if ( DebugCheck(kThisFile, kDebugReserved1) )
    02024             DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(adr_bereich_alut/2))/adr_bereich_alut = %ld\n",aElutWordSize,aAlutInShift);
    02025 #endif
    02026
    02027         while (LineCount){
    02028                 i = Pixelcount;
    02029
    02030                 while (i){
    02031
    02032                 long adr[8],Index[8];
    02033                 LH_UINT16 ein_reg[8];
    02034                 register unsigned long  adrAdr,ko,adrOffset;
    02035
    02036                 adr0=0;
    02037                         aElutOffset = 0;
    02038                         jj=0;
    02039
    02040                                 ein_Cache[0]=jj=(*(LH_UINT16 *)inputData[0]);
    02041                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02042                                         ko = ko0 & ( aElutShiftNum - 1 );
    02043                                         ko0 = ko0 >> aElutShift;
    02044                                         ko0 += aElutOffset;
    02045                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02046
    02047                                 jj *= aXlutAdrSize;
    02048                                 aElutOffset += adr_bereich_elut;
    02049                                 adr[0] = jj & aElutWordSizeMask;
    02050                                 jj = jj >> aElutWordSize;
    02051                                 adr0 += (jj)*theXlutOffsets[0];
    02052                                 ein_reg[0] = (LH_UINT16)jj;
    02053
    02054                                 ein_Cache[1]=jj=(*(LH_UINT16 *)inputData[1]);
    02055                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02056                                         ko = ko0 & ( aElutShiftNum - 1 );
    02057                                         ko0 = ko0 >> aElutShift;
    02058                                         ko0 += aElutOffset;
    02059                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02060
    02061                                 jj *= aXlutAdrSize;
    02062                                 aElutOffset += adr_bereich_elut;
    02063                                 adr[1] = jj & aElutWordSizeMask;
    02064                                 jj = jj >> aElutWordSize;
    02065                                 adr0 += (jj)*theXlutOffsets[1];
    02066                                 ein_reg[1] = (LH_UINT16)jj;
    02067
    02068                                         ein_Cache[2]=jj=(*(LH_UINT16 *)inputData[2]);
    02069                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02070                                         ko = ko0 & ( aElutShiftNum - 1 );
    02071                                         ko0 = ko0 >> aElutShift;
    02072                                         ko0 += aElutOffset;
    02073                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02074
    02075                                 jj *= aXlutAdrSize;
    02076                                 aElutOffset += adr_bereich_elut;
    02077                                 adr[2] = jj & aElutWordSizeMask;
    02078                                 jj = jj >> aElutWordSize;
    02079                                 adr0 += (jj)*theXlutOffsets[2];
    02080                                 ein_reg[2] = (LH_UINT16)jj;
    02081
    02082 #if NDIM_IN_DIM == 4
    02083                                         ein_Cache[3]=jj=(*(LH_UINT16 *)inputData[3]);
    02084                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02085                                         ko = ko0 & ( aElutShiftNum - 1 );
    02086                                         ko0 = ko0 >> aElutShift;
    02087                                         ko0 += aElutOffset;
    02088                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02089
    02090                                 jj *= aXlutAdrSize;
    02091                                 aElutOffset += adr_bereich_elut;
    02092                                 adr[3] = jj & aElutWordSizeMask;
    02093                                 jj = jj >> aElutWordSize;
    02094                                 adr0 += (jj)*theXlutOffsets[3];
    02095                                 ein_reg[3] = (LH_UINT16)jj;
    02096 #endif
    02097
    02098
    02099
    02100                 {                                                               /* a kind of */
    02101                     register long Hold;
    02102
    02103
    02104                                 Index[0] = 0;
    02105                                 Index[1] = 1;
    02106                                 Index[2] = 2;
    02107 #if NDIM_IN_DIM == 4
    02108                                 Index[3] = 3;
    02109 #endif
    02110                                         if( adr[0] < adr[1] ){
    02111                                                 Hold = Index[0];
    02112                                                 Index[0] = Index[1];
    02113                                                 Index[1] = Hold;
    02114                                         }
    02115
    02116                                         if( adr[Index[1]] < adr[2] ){
    02117                                                 Hold = Index[1];
    02118                                                 Index[1] = Index[2];
    02119                                                 Index[2] = Hold;
    02120                                                 if( adr[Index[0]] < adr[Index[1]] ){
    02121                                                         Hold = Index[0];
    02122                                                         Index[0] = Index[1];
    02123                                                         Index[1] = Hold;
    02124                                                 }
    02125                                         }
    02126
    02127 #if NDIM_IN_DIM == 4
    02128                                         if( adr[Index[2]] < adr[3] ){
    02129                                                 Hold = Index[2];
    02130                                                 Index[2] = Index[3];
    02131                                                 Index[3] = Hold;
    02132                                                 if( adr[Index[1]] < adr[Index[2]] ){
    02133                                                         Hold = Index[1];
    02134                                                         Index[1] = Index[2];
    02135                                                         Index[2] = Hold;
    02136                                                         if( adr[Index[0]] < adr[Index[1]] ){
    02137                                                                 Hold = Index[0];
    02138                                                                 Index[0] = Index[1];
    02139                                                                 Index[1] = Hold;
    02140                                                         }
    02141                                                 }
    02142                                         }
    02143 #endif
    02144                 }
    02145
    02146         accu[0]=0;
    02147         accu[1]=0;
    02148         accu[2]=0;
    02149 #if NDIM_OUT_DIM == 4
    02150         accu[3]=0;
    02151 #endif
    02152         ko0 = (1<<aElutWordSize);
    02153         adrAdr=adr0;
    02154         adrOffset=0;
    02155         if( aXlutWordSize  == 16 ){
    02156                 jj = Index[0];
    02157                 ko = ko0 - adr[jj];
    02158                 ko0 = adr[jj];
    02159
    02160                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02161                     adrOffset += theXlutOffsets[jj];
    02162
    02163                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    02164                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    02165                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    02166 #if NDIM_OUT_DIM == 4
    02167                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    02168 #endif
    02169
    02170                 adrAdr = (adr0 + adrOffset);
    02171
    02172                 jj = Index[1];
    02173                 ko = ko0 - adr[jj];
    02174                 ko0 = adr[jj];
    02175
    02176                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02177                     adrOffset += theXlutOffsets[jj];
    02178
    02179                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    02180                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    02181                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    02182 #if NDIM_OUT_DIM == 4
    02183                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    02184 #endif
    02185
    02186                 adrAdr = (adr0 + adrOffset);
    02187
    02188                 jj = Index[2];
    02189                 ko = ko0 - adr[jj];
    02190                 ko0 = adr[jj];
    02191
    02192                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02193                     adrOffset += theXlutOffsets[jj];
    02194
    02195                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    02196                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    02197                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    02198 #if NDIM_OUT_DIM == 4
    02199                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    02200 #endif
    02201
    02202                 adrAdr = (adr0 + adrOffset);
    02203
    02204 #if NDIM_IN_DIM == 4
    02205                 jj = Index[3];
    02206                 ko = ko0 - adr[jj];
    02207                 ko0 = adr[jj];
    02208
    02209                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02210                     adrOffset += theXlutOffsets[jj];
    02211
    02212                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    02213                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    02214                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    02215 #if NDIM_OUT_DIM == 4
    02216                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    02217 #endif
    02218
    02219                 adrAdr = (adr0 + adrOffset);
    02220 #endif
    02221
    02222                 accu[0]+=Xlut[adrAdr+0]*ko0;
    02223                 accu[1]+=Xlut[adrAdr+1]*ko0;
    02224                 accu[2]+=Xlut[adrAdr+2]*ko0;
    02225  #if NDIM_OUT_DIM == 4
    02226                accu[3]+=Xlut[adrAdr+3]*ko0;
    02227  #endif
    02228        }
    02229        else{
    02230
    02231                 jj = Index[0];
    02232                 ko = ko0 - adr[jj];
    02233                 ko0 = adr[jj];
    02234
    02235                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02236                     adrOffset += theXlutOffsets[jj];
    02237
    02238                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02239                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02240                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02241 #if NDIM_OUT_DIM == 4
    02242                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02243 #endif
    02244                 adrAdr = (adr0 + adrOffset);
    02245
    02246                 jj = Index[1];
    02247                 ko = ko0 - adr[jj];
    02248                 ko0 = adr[jj];
    02249
    02250                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02251                     adrOffset += theXlutOffsets[jj];
    02252
    02253                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02254                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02255                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02256 #if NDIM_OUT_DIM == 4
    02257                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02258 #endif
    02259                 adrAdr = (adr0 + adrOffset);
    02260
    02261                 jj = Index[2];
    02262                 ko = ko0 - adr[jj];
    02263                 ko0 = adr[jj];
    02264
    02265                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02266                     adrOffset += theXlutOffsets[jj];
    02267
    02268                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02269                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02270                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02271 #if NDIM_OUT_DIM == 4
    02272                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02273 #endif
    02274                 adrAdr = (adr0 + adrOffset);
    02275
    02276 #if NDIM_IN_DIM == 4
    02277                 jj = Index[3];
    02278                 ko = ko0 - adr[jj];
    02279                 ko0 = adr[jj];
    02280
    02281                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    02282                     adrOffset += theXlutOffsets[jj];
    02283
    02284                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02285                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02286                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02287 #if NDIM_OUT_DIM == 4
    02288                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02289 #endif
    02290                 adrAdr = (adr0 + adrOffset);
    02291 #endif
    02292                 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0;
    02293                 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0;
    02294                 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0;
    02295 #if NDIM_OUT_DIM == 4
    02296                accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0;
    02297 #endif
    02298         }
    02299
    02300                 aAlutOffset = 0;
    02301
    02302                 if( aOutputPackMode8Bit ){
    02303                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    02304                                         jj = accu[ii];
    02305                                         jj = jj + ( jj >> aXlutWordSize );
    02306
    02307                                         ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder;     /*      aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    02308
    02309                                         ko = ko0 & (aAlutInShiftNum - 1 );
    02310                                         ko0 = ko0 >> aAlutInShift;
    02311                                         ko0 += aAlutOffset;
    02312                                         if( aAlutWordSize <= 8)
    02313                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
    02314                                         else{
    02315                                         jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
    02316                                                 jj = jj - ( jj >> aAlutShift );
    02317                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
    02318                                         }
    02319                                         *outputData[ii] = (LH_UINT8)jj;
    02320                         aAlutOffset += adr_bereich_alut;
    02321                     }
    02322                         }
    02323                         else{
    02324                                 if( aXlutWordSize >= 16 ){
    02325                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    02326                                                 jj = accu[ii];
    02327                                                 jj = jj + ( jj >> aXlutWordSize );
    02328                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    02329
    02330                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    02331                                                 ko0 = ko0 >> aAlutInShift;
    02332                                                 ko0 += aAlutOffset;
    02333                                                 if( aAlutWordSize <= 8)
    02334                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    02335                                                 else
    02336                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    02337                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    02338                                                 aAlutOffset += adr_bereich_alut;
    02339                                         }
    02340                                 }
    02341                                 else{
    02342                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    02343                                                 jj = accu[ii];
    02344                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
    02345                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) ; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    02346
    02347                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    02348                                                 ko0 = ko0 >> aAlutInShift;
    02349                                                 ko0 += aAlutOffset;
    02350                                                 if( aAlutWordSize <= 8)
    02351                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    02352                                                 else
    02353                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    02354                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    02355                                                 aAlutOffset += adr_bereich_alut;
    02356                                         }
    02357                                 }
    02358                         }
    02359                         while (--i){
    02360                                 for( jj=0; jj<NDIM_IN_DIM; ++jj){
    02361                                         inputData[jj] += (NDIM_IN_DIM * 2);
    02362                                 }
    02363                                 for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02364                                         outputData[jj] += OutputIncrement;
    02365                                 }
    02366
    02367                                 {
    02368                                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    02369                                                 if( *((LH_UINT16 *)inputData[jj]) ^ *(LH_UINT16 *)(&ein_Cache[jj]) )break;
    02370                                         }
    02371                                 }
    02372                                 if( jj<NDIM_IN_DIM ) break;
    02373                                 if( aOutputPackMode8Bit ){
    02374                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02375                                                 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )];
    02376                                         }
    02377                                 }
    02378                                 else{
    02379                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02380                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]);
    02381                                         }
    02382                                 }
    02383                         }
    02384                 }
    02385
    02386                 if( --LineCount ){
    02387                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    02388                                 inputData[jj] += inputDataRowOffset;
    02389                         }
    02390                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02391                                 outputData[jj] += outputDataRowOffset;
    02392                         }
    02393                 }
    02394     }
    02395     }
    02396     else{
    02397
    02398     register unsigned long  bit_breit_selektor;
    02399     register unsigned long  bit_maske_selektor;
    02400     register unsigned long  bit_breit_adr;
    02401     register unsigned long  bit_maske_adr;
    02402     register unsigned long  aAlutInShiftNum;
    02403     register long aAlutInShift;
    02404     register long aAlutInShiftRemainder;
    02405     register unsigned long aAlutRound;
    02406     /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/
    02407     bit_breit_selektor=aElutWordSize-aXlutAdrShift;
    02408     if( aElutWordSize-aXlutAdrShift < 0 )
    02409     {
    02410 #ifdef DEBUG_OUTPUT
    02411         DebugPrint("¥ DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor);
    02412 #endif
    02413         return cmparamErr;
    02414     }
    02415     bit_maske_selektor=(1<<bit_breit_selektor)-1;
    02416     bit_breit_adr=aXlutAdrShift;
    02417     bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor;
    02418     aAlutInShift = (aXlutWordSize+bit_breit_selektor-adr_breite_alut);
    02419     /*aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    02420     aAlutInShiftRemainder = 0;
    02421     if( aAlutInShift > 16 ){
    02422         aAlutInShiftRemainder = aAlutInShift - 16;
    02423         aAlutInShift = 16;
    02424     }
    02425
    02426     aAlutInShiftNum = (1<<aAlutInShift);
    02427
    02428         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
    02429         while (LineCount){
    02430                 i = Pixelcount;
    02431
    02432                 while (i){
    02433
    02434                 long adr[8],Index[8];
    02435                 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/
    02436                 LH_UINT16 ein_reg[8];
    02437                    register unsigned long  adrAdr,ko,adrOffset;
    02438                 /*register unsigned long aIndex;*/
    02439
    02440                 adr0=0;
    02441                 aElutOffset = 0;
    02442                 jj=0;
    02443                         ein_Cache[0]=jj=(*(LH_UINT16 *)inputData[0]);
    02444                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02445                         ko = ko0 & ( aElutShiftNum - 1 );
    02446                         ko0 = ko0 >> aElutShift;
    02447                         ko0 += aElutOffset;
    02448                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02449
    02450                         aElutOffset += adr_bereich_elut;
    02451                         adr[0] = (jj & bit_maske_selektor);
    02452                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-0-1)*bit_breit_adr);
    02453                         ein_reg[0] = (LH_UINT16)jj;
    02454
    02455                         ein_Cache[1]=jj=(*(LH_UINT16 *)inputData[1]);
    02456                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02457                         ko = ko0 & ( aElutShiftNum - 1 );
    02458                         ko0 = ko0 >> aElutShift;
    02459                         ko0 += aElutOffset;
    02460                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02461
    02462                         aElutOffset += adr_bereich_elut;
    02463                         adr[1] = (jj & bit_maske_selektor);
    02464                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-1-1)*bit_breit_adr);
    02465                         ein_reg[1] = (LH_UINT16)jj;
    02466
    02467                         ein_Cache[2]=jj=(*(LH_UINT16 *)inputData[2]);
    02468                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02469                         ko = ko0 & ( aElutShiftNum - 1 );
    02470                         ko0 = ko0 >> aElutShift;
    02471                         ko0 += aElutOffset;
    02472                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02473
    02474                         aElutOffset += adr_bereich_elut;
    02475                         adr[2] = (jj & bit_maske_selektor);
    02476                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-2-1)*bit_breit_adr);
    02477                         ein_reg[2] = (LH_UINT16)jj;
    02478
    02479 #if NDIM_IN_DIM == 4
    02480                         ein_Cache[3]=jj=(*(LH_UINT16 *)inputData[3]);
    02481                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02482                         ko = ko0 & ( aElutShiftNum - 1 );
    02483                         ko0 = ko0 >> aElutShift;
    02484                         ko0 += aElutOffset;
    02485                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02486
    02487                         aElutOffset += adr_bereich_elut;
    02488                         adr[3] = (jj & bit_maske_selektor);
    02489                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-3-1)*bit_breit_adr);
    02490                         ein_reg[3] = (LH_UINT16)jj;
    02491 #endif
    02492                 adr0 *= NDIM_OUT_DIM;
    02493
    02494                 {                                                               /* a kind of */
    02495                     register long Hold;
    02496
    02497
    02498                                 Index[0] = 0;
    02499                                 Index[1] = 1;
    02500                                 Index[2] = 2;
    02501 #if NDIM_IN_DIM == 4
    02502                                 Index[3] = 3;
    02503 #endif
    02504                                         if( adr[0] < adr[1] ){
    02505                                                 Hold = Index[0];
    02506                                                 Index[0] = Index[1];
    02507                                                 Index[1] = Hold;
    02508                                         }
    02509
    02510                                         if( adr[Index[1]] < adr[2] ){
    02511                                                 Hold = Index[1];
    02512                                                 Index[1] = Index[2];
    02513                                                 Index[2] = Hold;
    02514                                                 if( adr[Index[0]] < adr[Index[1]] ){
    02515                                                         Hold = Index[0];
    02516                                                         Index[0] = Index[1];
    02517                                                         Index[1] = Hold;
    02518                                                 }
    02519                                         }
    02520
    02521 #if NDIM_IN_DIM == 4
    02522                                         if( adr[Index[2]] < adr[3] ){
    02523                                                 Hold = Index[2];
    02524                                                 Index[2] = Index[3];
    02525                                                 Index[3] = Hold;
    02526                                                 if( adr[Index[1]] < adr[Index[2]] ){
    02527                                                         Hold = Index[1];
    02528                                                         Index[1] = Index[2];
    02529                                                         Index[2] = Hold;
    02530                                                         if( adr[Index[0]] < adr[Index[1]] ){
    02531                                                                 Hold = Index[0];
    02532                                                                 Index[0] = Index[1];
    02533                                                                 Index[1] = Hold;
    02534                                                         }
    02535                                                 }
    02536                                         }
    02537 #endif
    02538                 }
    02539
    02540                         accu[0]=0;
    02541                         accu[1]=0;
    02542                         accu[2]=0;
    02543 #if NDIM_OUT_DIM == 4
    02544                         accu[3]=0;
    02545 #endif
    02546
    02547                 ko0 = bit_maske_selektor+1;
    02548                 adrAdr=adr0;
    02549                 adrOffset=0;
    02550
    02551                 if( aXlutWordSize  == 16 ){
    02552                         jj = Index[0];
    02553                         ko = ko0 - adr[jj];
    02554                         ko0 = adr[jj];
    02555
    02556                         if( ein_reg[jj] < bit_maske_adr )
    02557                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02558
    02559                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    02560                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    02561                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    02562 #if NDIM_OUT_DIM == 4
    02563                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    02564 #endif
    02565                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02566
    02567                         jj = Index[1];
    02568                         ko = ko0 - adr[jj];
    02569                         ko0 = adr[jj];
    02570
    02571                         if( ein_reg[jj] < bit_maske_adr )
    02572                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02573
    02574                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    02575                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    02576                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    02577 #if NDIM_OUT_DIM == 4
    02578                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    02579 #endif
    02580                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02581
    02582                         jj = Index[2];
    02583                         ko = ko0 - adr[jj];
    02584                         ko0 = adr[jj];
    02585
    02586                         if( ein_reg[jj] < bit_maske_adr )
    02587                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02588
    02589                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    02590                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    02591                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    02592 #if NDIM_OUT_DIM == 4
    02593                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    02594 #endif
    02595                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02596
    02597 #if NDIM_IN_DIM == 4
    02598                         jj = Index[3];
    02599                         ko = ko0 - adr[jj];
    02600                         ko0 = adr[jj];
    02601
    02602                         if( ein_reg[jj] < bit_maske_adr )
    02603                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02604
    02605                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    02606                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    02607                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    02608 #if NDIM_OUT_DIM == 4
    02609                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    02610 #endif
    02611                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02612 #endif
    02613                 accu[0]+=Xlut[adrAdr+0]*ko0;
    02614                 accu[1]+=Xlut[adrAdr+1]*ko0;
    02615                 accu[2]+=Xlut[adrAdr+2]*ko0;
    02616 #if NDIM_OUT_DIM == 4
    02617                                 accu[3]+=Xlut[adrAdr+3]*ko0;
    02618 #endif
    02619                 }
    02620                 else{
    02621                         jj = Index[0];
    02622                         ko = ko0 - adr[jj];
    02623                         ko0 = adr[jj];
    02624
    02625                         if( ein_reg[jj] < bit_maske_adr )
    02626                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02627
    02628                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02629                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02630                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02631 #if NDIM_OUT_DIM == 4
    02632                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02633 #endif
    02634
    02635                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02636
    02637                         jj = Index[1];
    02638                         ko = ko0 - adr[jj];
    02639                         ko0 = adr[jj];
    02640
    02641                         if( ein_reg[jj] < bit_maske_adr )
    02642                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02643
    02644                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02645                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02646                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02647 #if NDIM_OUT_DIM == 4
    02648                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02649 #endif
    02650
    02651                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02652
    02653                         jj = Index[2];
    02654                         ko = ko0 - adr[jj];
    02655                         ko0 = adr[jj];
    02656
    02657                         if( ein_reg[jj] < bit_maske_adr )
    02658                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02659
    02660                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02661                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02662                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02663 #if NDIM_OUT_DIM == 4
    02664                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02665 #endif
    02666
    02667                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02668
    02669 #if NDIM_IN_DIM == 4
    02670                         jj = Index[3];
    02671                         ko = ko0 - adr[jj];
    02672                         ko0 = adr[jj];
    02673
    02674                         if( ein_reg[jj] < bit_maske_adr )
    02675                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    02676
    02677                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    02678                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    02679                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    02680 #if NDIM_OUT_DIM == 4
    02681                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    02682 #endif
    02683
    02684                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    02685 #endif
    02686                                 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0;
    02687                 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0;
    02688                 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0;
    02689 #if NDIM_OUT_DIM == 4
    02690                                 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0;
    02691 #endif
    02692                 }
    02693
    02694                 aAlutOffset = 0;
    02695
    02696                 if( aOutputPackMode8Bit ){
    02697                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    02698                                         jj = accu[ii];
    02699                                         jj = jj + ( jj >> aXlutWordSize );
    02700
    02701                                         ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder;     /*      aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    02702
    02703                                         ko = ko0 & (aAlutInShiftNum - 1 );
    02704                                         ko0 = ko0 >> aAlutInShift;
    02705                                         ko0 += aAlutOffset;
    02706                                         if( aAlutWordSize <= 8)
    02707                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
    02708                                         else{
    02709                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
    02710                                                 jj = jj - ( jj >> aAlutShift );
    02711                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
    02712                                         }
    02713
    02714                                         *outputData[ii] = (LH_UINT8)jj;
    02715                         aAlutOffset += adr_bereich_alut;
    02716                     }
    02717                 }
    02718                 else{
    02719                                 if( aXlutWordSize >= 16 ){
    02720                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    02721                                                 jj = accu[ii];
    02722                                                 jj = jj + ( jj >> aXlutWordSize );
    02723                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    02724
    02725                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    02726                                                 ko0 = ko0 >> aAlutInShift;
    02727                                                 ko0 += aAlutOffset;
    02728                                                 if( aAlutWordSize <= 8)
    02729                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    02730                                                 else
    02731                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    02732                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    02733                                                 aAlutOffset += adr_bereich_alut;
    02734                                         }
    02735                                 }
    02736                                 else{
    02737                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    02738                                                 jj = accu[ii];
    02739                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
    02740                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))); /*   aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    02741
    02742                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    02743                                                 ko0 = ko0 >> aAlutInShift;
    02744                                                 ko0 += aAlutOffset;
    02745                                                 if( aAlutWordSize <= 8)
    02746                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    02747                                                 else
    02748                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    02749                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    02750                                                 aAlutOffset += adr_bereich_alut;
    02751                                         }
    02752                                 }
    02753                 }
    02754
    02755                         while (--i){
    02756                                 for( jj=0; jj<NDIM_IN_DIM; ++jj){
    02757                                         inputData[jj] += (NDIM_IN_DIM * 2);
    02758                                 }
    02759                                 for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02760                                         outputData[jj] += OutputIncrement;
    02761                                 }
    02762
    02763                                 {
    02764                                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    02765                                                 if( *((LH_UINT16 *)inputData[jj]) ^ *(LH_UINT16 *)(&ein_Cache[jj]) )break;
    02766                                         }
    02767                                 }
    02768                                 if( jj<NDIM_IN_DIM ) break;
    02769                                 if( aOutputPackMode8Bit ){
    02770                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02771                                                 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )];
    02772                                         }
    02773                                 }
    02774                                 else{
    02775                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02776                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]);
    02777                                         }
    02778                                 }
    02779                         }
    02780                 }
    02781
    02782                 if( --LineCount ){
    02783                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    02784                                 inputData[jj] += inputDataRowOffset;
    02785                         }
    02786                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    02787                                 outputData[jj] += outputDataRowOffset;
    02788                         }
    02789                 }
    02790     }
    02791     }
    02792
    02793         /* UNLOCK_DATA( aElutHdle ); */
    02794         /* UNLOCK_DATA( aAlutHdle ); */
    02795         /* UNLOCK_DATA( aXlutHdle ); */
    02796
    02797         LH_END_PROC("Calc423Dim_Data8To8_Lut16")
    02798         return noErr;
    02799 }

CMError Calc424Dim_Data8To8_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 2810 of file w98/lh_core/calcnd3.c.

References adr_bereich_alut, adr_bereich_elut, adr_breite_alut, adr_breite_elut, aElutShift, aElutShiftNum, cm8PerChannelPacking, CMError, CMCalcParam::cmInputBytesPerLine, CMCalcParam::cmInputPixelOffset, CMCalcParam::cmLineCount, cmLong8ColorPacking, CMCalcParam::cmOutputBytesPerLine, CMCalcParam::cmOutputColorSpace, CMCalcParam::cmOutputPixelOffset, cmparamErr, CMCalcParam::cmPixelPerLine, CMLutParam::colorLut, CMLutParam::colorLutGridPoints, CMLutParam::colorLutWordSize, DebugPrint, Hold, Index, CMCalcParam::inputData, CMLutParam::inputLut, CMLutParam::inputLutWordSize, LH_END_PROC, LH_START_PROC, LH_UINT16, LH_UINT8, NDIM_IN_DIM, NDIM_OUT_DIM, noErr, CMCalcParam::outputData, CMLutParam::outputLut, CMLutParam::outputLutWordSize, and UINT32.

Referenced by CalcNDim_Data8To8_Lut16().

    02813 {
    02814         LH_UINT8 * inputData[8], *outputData[8];
    02815         UINT32 OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount;
    02816         register unsigned long adr0;
    02817     register unsigned long ko0;
    02818     unsigned long accu[8];
    02819     register long i;
    02820     /*long Offsets[8];*/
    02821
    02822     register long aAlutShift,aElutOffset,aAlutOffset;
    02823     register long aElutWordSize;
    02824     register long aAlutWordSize;
    02825     register long aXlutAdrSize;
    02826     register long aXlutAdrShift;
    02827     register unsigned long aXlutWordSize;
    02828         register unsigned long ii,jj;
    02829     register long aOutputPackMode8Bit;
    02830         long ein_Cache[8];
    02831
    02832         LH_UINT16 * aus_lut     = (LH_UINT16*)lutParam->outputLut;
    02833         LH_UINT16 * ein_lut     = (LH_UINT16*)lutParam->inputLut;
    02834         LH_UINT16 * Xlut        = (LH_UINT16*)lutParam->colorLut;
    02835
    02836         #ifdef DEBUG_OUTPUT
    02837         long err = noErr;
    02838         #endif
    02839         LH_START_PROC("Calc424Dim_Data8To8_Lut16")
    02840
    02841         inputData[0] = (LH_UINT8 *)calcParam->inputData[0];
    02842         inputData[1] = (LH_UINT8 *)calcParam->inputData[1];
    02843         inputData[2] = (LH_UINT8 *)calcParam->inputData[2];
    02844 #if NDIM_IN_DIM == 4
    02845         inputData[3] = (LH_UINT8 *)calcParam->inputData[3];
    02846 #endif
    02847         outputData[0] = (LH_UINT8 *)calcParam->outputData[0];
    02848         outputData[1] = (LH_UINT8 *)calcParam->outputData[1];
    02849         outputData[2] = (LH_UINT8 *)calcParam->outputData[2];
    02850 #if NDIM_OUT_DIM == 4
    02851         outputData[3] = (LH_UINT8 *)calcParam->outputData[3];
    02852 #endif
    02853
    02854         OutputIncrement = calcParam->cmOutputPixelOffset;
    02855         inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + (NDIM_IN_DIM * 2);
    02856         outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement;
    02857
    02858         Pixelcount = calcParam->cmPixelPerLine;
    02859         LineCount = calcParam->cmLineCount;
    02860
    02861         aElutWordSize = lutParam->inputLutWordSize;
    02862         aAlutWordSize = lutParam->outputLutWordSize;
    02863         aXlutAdrSize = lutParam->colorLutGridPoints;
    02864         for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++)
    02865                 aXlutAdrShift = i;
    02866         aXlutWordSize = lutParam->colorLutWordSize;
    02867
    02868         aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking;
    02869    /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/
    02870         #if FARBR_FILES
    02871         WriteLuts(      "DoNDim",1,adr_bereich_elut,aElutWordSize,ein_lut,
    02872                                 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,adr_bereich_alut,aAlutWordSize,(LH_UINT16 *)aus_lut);
    02873     #endif
    02874
    02875         i=0;
    02876
    02877         {
    02878                 if( aElutShift < 0 )
    02879                 {
    02880                         #ifdef DEBUG_OUTPUT
    02881                         DebugPrint("¥ DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift);
    02882                         #endif
    02883                         return cmparamErr;
    02884                 }
    02885         }
    02886
    02887         if( aOutputPackMode8Bit ){
    02888                 aAlutShift = (aAlutWordSize-8);
    02889         }
    02890         else{
    02891                 aAlutShift = (16 - aAlutWordSize);
    02892         }
    02893
    02894         #ifdef DEBUG_OUTPUT
    02895                 if ( DebugCheck(kThisFile, kDebugReserved1) ){
    02896                     DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n",
    02897                                                 adr_bereich_elut,adr_breite_elut,aElutWordSize,ein_lut);
    02898                         DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n",
    02899                                                 adr_bereich_alut,adr_breite_alut,aAlutWordSize,aus_lut);
    02900                         DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n",
    02901                                                 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut);
    02902                 }
    02903     #endif
    02904
    02905     /*if( 1 )*/
    02906     if( aXlutAdrSize != (1<<aXlutAdrShift )){
    02907     register long aXlutOffset;
    02908     long theXlutOffsets[8];
    02909     register unsigned long aAlutInShift;
    02910     register long aAlutInShiftRemainder;
    02911     register unsigned long aAlutInShiftNum;
    02912     register long aElutWordSizeMask = (1<<aElutWordSize) - 1;
    02913     register unsigned long aAlutRound;
    02914    aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;
    02915     aAlutInShiftRemainder = 0;
    02916     if( aAlutInShift > 16 ){
    02917         aAlutInShiftRemainder = aAlutInShift - 16;
    02918         aAlutInShift = 16;
    02919     }
    02920     aAlutInShiftNum = (1<<aAlutInShift);
    02921
    02922 #ifdef DEBUG_OUTPUT
    02923         if ( DebugCheck(kThisFile, kDebugMiscInfo) )
    02924             DebugPrint("  DoNDim gripoints = %ld\n",aXlutAdrSize);
    02925 #endif
    02926     if( aElutWordSize <= 0 ){
    02927 #ifdef DEBUG_OUTPUT
    02928         DebugPrint("¥ DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize);
    02929 #endif
    02930         return cmparamErr;
    02931     }
    02932     if( aAlutInShift <= 0 ){
    02933 #ifdef DEBUG_OUTPUT
    02934         DebugPrint("¥ DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift);
    02935 #endif
    02936         return cmparamErr;
    02937     }
    02938     aXlutOffset =NDIM_OUT_DIM;
    02939     for( i=0; i<(long)NDIM_IN_DIM; i++){
    02940         theXlutOffsets[ NDIM_IN_DIM-1-i] = aXlutOffset;
    02941         aXlutOffset *=aXlutAdrSize;
    02942     }
    02943         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
    02944
    02945 #ifdef DEBUG_OUTPUT
    02946         if ( DebugCheck(kThisFile, kDebugReserved1) )
    02947             DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(adr_bereich_alut/2))/adr_bereich_alut = %ld\n",aElutWordSize,aAlutInShift);
    02948 #endif
    02949
    02950         while (LineCount){
    02951                 i = Pixelcount;
    02952
    02953                 while (i){
    02954
    02955                 long adr[8],Index[8];
    02956                 LH_UINT16 ein_reg[8];
    02957                 register unsigned long  adrAdr,ko,adrOffset;
    02958
    02959                 adr0=0;
    02960                         aElutOffset = 0;
    02961                         jj=0;
    02962
    02963                                 ein_Cache[0]=jj=(*(LH_UINT16 *)inputData[0]);
    02964                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02965                                         ko = ko0 & ( aElutShiftNum - 1 );
    02966                                         ko0 = ko0 >> aElutShift;
    02967                                         ko0 += aElutOffset;
    02968                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02969
    02970                                 jj *= aXlutAdrSize;
    02971                                 aElutOffset += adr_bereich_elut;
    02972                                 adr[0] = jj & aElutWordSizeMask;
    02973                                 jj = jj >> aElutWordSize;
    02974                                 adr0 += (jj)*theXlutOffsets[0];
    02975                                 ein_reg[0] = (LH_UINT16)jj;
    02976
    02977                                 ein_Cache[1]=jj=(*(LH_UINT16 *)inputData[1]);
    02978                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02979                                         ko = ko0 & ( aElutShiftNum - 1 );
    02980                                         ko0 = ko0 >> aElutShift;
    02981                                         ko0 += aElutOffset;
    02982                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02983
    02984                                 jj *= aXlutAdrSize;
    02985                                 aElutOffset += adr_bereich_elut;
    02986                                 adr[1] = jj & aElutWordSizeMask;
    02987                                 jj = jj >> aElutWordSize;
    02988                                 adr0 += (jj)*theXlutOffsets[1];
    02989                                 ein_reg[1] = (LH_UINT16)jj;
    02990
    02991                                         ein_Cache[2]=jj=(*(LH_UINT16 *)inputData[2]);
    02992                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    02993                                         ko = ko0 & ( aElutShiftNum - 1 );
    02994                                         ko0 = ko0 >> aElutShift;
    02995                                         ko0 += aElutOffset;
    02996                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    02997
    02998                                 jj *= aXlutAdrSize;
    02999                                 aElutOffset += adr_bereich_elut;
    03000                                 adr[2] = jj & aElutWordSizeMask;
    03001                                 jj = jj >> aElutWordSize;
    03002                                 adr0 += (jj)*theXlutOffsets[2];
    03003                                 ein_reg[2] = (LH_UINT16)jj;
    03004
    03005 #if NDIM_IN_DIM == 4
    03006                                         ein_Cache[3]=jj=(*(LH_UINT16 *)inputData[3]);
    03007                                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    03008                                         ko = ko0 & ( aElutShiftNum - 1 );
    03009                                         ko0 = ko0 >> aElutShift;
    03010                                         ko0 += aElutOffset;
    03011                                 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    03012
    03013                                 jj *= aXlutAdrSize;
    03014                                 aElutOffset += adr_bereich_elut;
    03015                                 adr[3] = jj & aElutWordSizeMask;
    03016                                 jj = jj >> aElutWordSize;
    03017                                 adr0 += (jj)*theXlutOffsets[3];
    03018                                 ein_reg[3] = (LH_UINT16)jj;
    03019 #endif
    03020
    03021
    03022
    03023                 {                                                               /* a kind of */
    03024                     register long Hold;
    03025
    03026
    03027                                 Index[0] = 0;
    03028                                 Index[1] = 1;
    03029                                 Index[2] = 2;
    03030 #if NDIM_IN_DIM == 4
    03031                                 Index[3] = 3;
    03032 #endif
    03033                                         if( adr[0] < adr[1] ){
    03034                                                 Hold = Index[0];
    03035                                                 Index[0] = Index[1];
    03036                                                 Index[1] = Hold;
    03037                                         }
    03038
    03039                                         if( adr[Index[1]] < adr[2] ){
    03040                                                 Hold = Index[1];
    03041                                                 Index[1] = Index[2];
    03042                                                 Index[2] = Hold;
    03043                                                 if( adr[Index[0]] < adr[Index[1]] ){
    03044                                                         Hold = Index[0];
    03045                                                         Index[0] = Index[1];
    03046                                                         Index[1] = Hold;
    03047                                                 }
    03048                                         }
    03049
    03050 #if NDIM_IN_DIM == 4
    03051                                         if( adr[Index[2]] < adr[3] ){
    03052                                                 Hold = Index[2];
    03053                                                 Index[2] = Index[3];
    03054                                                 Index[3] = Hold;
    03055                                                 if( adr[Index[1]] < adr[Index[2]] ){
    03056                                                         Hold = Index[1];
    03057                                                         Index[1] = Index[2];
    03058                                                         Index[2] = Hold;
    03059                                                         if( adr[Index[0]] < adr[Index[1]] ){
    03060                                                                 Hold = Index[0];
    03061                                                                 Index[0] = Index[1];
    03062                                                                 Index[1] = Hold;
    03063                                                         }
    03064                                                 }
    03065                                         }
    03066 #endif
    03067                 }
    03068
    03069         accu[0]=0;
    03070         accu[1]=0;
    03071         accu[2]=0;
    03072 #if NDIM_OUT_DIM == 4
    03073         accu[3]=0;
    03074 #endif
    03075         ko0 = (1<<aElutWordSize);
    03076         adrAdr=adr0;
    03077         adrOffset=0;
    03078         if( aXlutWordSize  == 16 ){
    03079                 jj = Index[0];
    03080                 ko = ko0 - adr[jj];
    03081                 ko0 = adr[jj];
    03082
    03083                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03084                     adrOffset += theXlutOffsets[jj];
    03085
    03086                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    03087                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    03088                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    03089 #if NDIM_OUT_DIM == 4
    03090                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    03091 #endif
    03092
    03093                 adrAdr = (adr0 + adrOffset);
    03094
    03095                 jj = Index[1];
    03096                 ko = ko0 - adr[jj];
    03097                 ko0 = adr[jj];
    03098
    03099                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03100                     adrOffset += theXlutOffsets[jj];
    03101
    03102                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    03103                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    03104                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    03105 #if NDIM_OUT_DIM == 4
    03106                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    03107 #endif
    03108
    03109                 adrAdr = (adr0 + adrOffset);
    03110
    03111                 jj = Index[2];
    03112                 ko = ko0 - adr[jj];
    03113                 ko0 = adr[jj];
    03114
    03115                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03116                     adrOffset += theXlutOffsets[jj];
    03117
    03118                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    03119                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    03120                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    03121 #if NDIM_OUT_DIM == 4
    03122                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    03123 #endif
    03124
    03125                 adrAdr = (adr0 + adrOffset);
    03126
    03127 #if NDIM_IN_DIM == 4
    03128                 jj = Index[3];
    03129                 ko = ko0 - adr[jj];
    03130                 ko0 = adr[jj];
    03131
    03132                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03133                     adrOffset += theXlutOffsets[jj];
    03134
    03135                     accu[0]+=Xlut[adrAdr+(0)]*ko;
    03136                     accu[1]+=Xlut[adrAdr+(1)]*ko;
    03137                     accu[2]+=Xlut[adrAdr+(2)]*ko;
    03138 #if NDIM_OUT_DIM == 4
    03139                     accu[3]+=Xlut[adrAdr+(3)]*ko;
    03140 #endif
    03141
    03142                 adrAdr = (adr0 + adrOffset);
    03143 #endif
    03144
    03145                 accu[0]+=Xlut[adrAdr+0]*ko0;
    03146                 accu[1]+=Xlut[adrAdr+1]*ko0;
    03147                 accu[2]+=Xlut[adrAdr+2]*ko0;
    03148  #if NDIM_OUT_DIM == 4
    03149                accu[3]+=Xlut[adrAdr+3]*ko0;
    03150  #endif
    03151        }
    03152        else{
    03153
    03154                 jj = Index[0];
    03155                 ko = ko0 - adr[jj];
    03156                 ko0 = adr[jj];
    03157
    03158                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03159                     adrOffset += theXlutOffsets[jj];
    03160
    03161                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03162                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03163                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03164 #if NDIM_OUT_DIM == 4
    03165                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03166 #endif
    03167                 adrAdr = (adr0 + adrOffset);
    03168
    03169                 jj = Index[1];
    03170                 ko = ko0 - adr[jj];
    03171                 ko0 = adr[jj];
    03172
    03173                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03174                     adrOffset += theXlutOffsets[jj];
    03175
    03176                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03177                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03178                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03179 #if NDIM_OUT_DIM == 4
    03180                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03181 #endif
    03182                 adrAdr = (adr0 + adrOffset);
    03183
    03184                 jj = Index[2];
    03185                 ko = ko0 - adr[jj];
    03186                 ko0 = adr[jj];
    03187
    03188                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03189                     adrOffset += theXlutOffsets[jj];
    03190
    03191                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03192                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03193                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03194 #if NDIM_OUT_DIM == 4
    03195                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03196 #endif
    03197                 adrAdr = (adr0 + adrOffset);
    03198
    03199 #if NDIM_IN_DIM == 4
    03200                 jj = Index[3];
    03201                 ko = ko0 - adr[jj];
    03202                 ko0 = adr[jj];
    03203
    03204                 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) )
    03205                     adrOffset += theXlutOffsets[jj];
    03206
    03207                     accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03208                     accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03209                     accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03210 #if NDIM_OUT_DIM == 4
    03211                     accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03212 #endif
    03213                 adrAdr = (adr0 + adrOffset);
    03214 #endif
    03215                 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0;
    03216                 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0;
    03217                 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0;
    03218 #if NDIM_OUT_DIM == 4
    03219                accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0;
    03220 #endif
    03221         }
    03222
    03223                 aAlutOffset = 0;
    03224
    03225                 if( aOutputPackMode8Bit ){
    03226                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    03227                                         jj = accu[ii];
    03228                                         jj = jj + ( jj >> aXlutWordSize );
    03229
    03230                                         ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder;     /*      aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    03231
    03232                                         ko = ko0 & (aAlutInShiftNum - 1 );
    03233                                         ko0 = ko0 >> aAlutInShift;
    03234                                         ko0 += aAlutOffset;
    03235                                         if( aAlutWordSize <= 8)
    03236                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
    03237                                         else{
    03238                                         jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
    03239                                                 jj = jj - ( jj >> aAlutShift );
    03240                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
    03241                                         }
    03242                                         *outputData[ii] = (LH_UINT8)jj;
    03243                         aAlutOffset += adr_bereich_alut;
    03244                     }
    03245                         }
    03246                         else{
    03247                                 if( aXlutWordSize >= 16 ){
    03248                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    03249                                                 jj = accu[ii];
    03250                                                 jj = jj + ( jj >> aXlutWordSize );
    03251                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    03252
    03253                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    03254                                                 ko0 = ko0 >> aAlutInShift;
    03255                                                 ko0 += aAlutOffset;
    03256                                                 if( aAlutWordSize <= 8)
    03257                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    03258                                                 else
    03259                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    03260                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    03261                                                 aAlutOffset += adr_bereich_alut;
    03262                                         }
    03263                                 }
    03264                                 else{
    03265                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    03266                                                 jj = accu[ii];
    03267                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
    03268                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) ; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    03269
    03270                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    03271                                                 ko0 = ko0 >> aAlutInShift;
    03272                                                 ko0 += aAlutOffset;
    03273                                                 if( aAlutWordSize <= 8)
    03274                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    03275                                                 else
    03276                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    03277                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    03278                                                 aAlutOffset += adr_bereich_alut;
    03279                                         }
    03280                                 }
    03281                         }
    03282                         while (--i){
    03283                                 for( jj=0; jj<NDIM_IN_DIM; ++jj){
    03284                                         inputData[jj] += (NDIM_IN_DIM * 2);
    03285                                 }
    03286                                 for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03287                                         outputData[jj] += OutputIncrement;
    03288                                 }
    03289
    03290                                 {
    03291                                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    03292                                                 if( *((LH_UINT16 *)inputData[jj]) ^ *(LH_UINT16 *)(&ein_Cache[jj]) )break;
    03293                                         }
    03294                                 }
    03295                                 if( jj<NDIM_IN_DIM ) break;
    03296                                 if( aOutputPackMode8Bit ){
    03297                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03298                                                 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )];
    03299                                         }
    03300                                 }
    03301                                 else{
    03302                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03303                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]);
    03304                                         }
    03305                                 }
    03306                         }
    03307                 }
    03308
    03309                 if( --LineCount ){
    03310                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    03311                                 inputData[jj] += inputDataRowOffset;
    03312                         }
    03313                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03314                                 outputData[jj] += outputDataRowOffset;
    03315                         }
    03316                 }
    03317     }
    03318     }
    03319     else{
    03320
    03321     register unsigned long  bit_breit_selektor;
    03322     register unsigned long  bit_maske_selektor;
    03323     register unsigned long  bit_breit_adr;
    03324     register unsigned long  bit_maske_adr;
    03325     register unsigned long  aAlutInShiftNum;
    03326     register long aAlutInShift;
    03327     register long aAlutInShiftRemainder;
    03328     register unsigned long aAlutRound;
    03329     /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/
    03330     bit_breit_selektor=aElutWordSize-aXlutAdrShift;
    03331     if( aElutWordSize-aXlutAdrShift < 0 )
    03332     {
    03333 #ifdef DEBUG_OUTPUT
    03334         DebugPrint("¥ DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor);
    03335 #endif
    03336         return cmparamErr;
    03337     }
    03338     bit_maske_selektor=(1<<bit_breit_selektor)-1;
    03339     bit_breit_adr=aXlutAdrShift;
    03340     bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor;
    03341     aAlutInShift = (aXlutWordSize+bit_breit_selektor-adr_breite_alut);
    03342     /*aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    03343     aAlutInShiftRemainder = 0;
    03344     if( aAlutInShift > 16 ){
    03345         aAlutInShiftRemainder = aAlutInShift - 16;
    03346         aAlutInShift = 16;
    03347     }
    03348
    03349     aAlutInShiftNum = (1<<aAlutInShift);
    03350
    03351         aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 );
    03352         while (LineCount){
    03353                 i = Pixelcount;
    03354
    03355                 while (i){
    03356
    03357                 long adr[8],Index[8];
    03358                 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/
    03359                 LH_UINT16 ein_reg[8];
    03360                    register unsigned long  adrAdr,ko,adrOffset;
    03361                 /*register unsigned long aIndex;*/
    03362
    03363                 adr0=0;
    03364                 aElutOffset = 0;
    03365                 jj=0;
    03366                         ein_Cache[0]=jj=(*(LH_UINT16 *)inputData[0]);
    03367                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    03368                         ko = ko0 & ( aElutShiftNum - 1 );
    03369                         ko0 = ko0 >> aElutShift;
    03370                         ko0 += aElutOffset;
    03371                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    03372
    03373                         aElutOffset += adr_bereich_elut;
    03374                         adr[0] = (jj & bit_maske_selektor);
    03375                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-0-1)*bit_breit_adr);
    03376                         ein_reg[0] = (LH_UINT16)jj;
    03377
    03378                         ein_Cache[1]=jj=(*(LH_UINT16 *)inputData[1]);
    03379                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    03380                         ko = ko0 & ( aElutShiftNum - 1 );
    03381                         ko0 = ko0 >> aElutShift;
    03382                         ko0 += aElutOffset;
    03383                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    03384
    03385                         aElutOffset += adr_bereich_elut;
    03386                         adr[1] = (jj & bit_maske_selektor);
    03387                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-1-1)*bit_breit_adr);
    03388                         ein_reg[1] = (LH_UINT16)jj;
    03389
    03390                         ein_Cache[2]=jj=(*(LH_UINT16 *)inputData[2]);
    03391                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    03392                         ko = ko0 & ( aElutShiftNum - 1 );
    03393                         ko0 = ko0 >> aElutShift;
    03394                         ko0 += aElutOffset;
    03395                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    03396
    03397                         aElutOffset += adr_bereich_elut;
    03398                         adr[2] = (jj & bit_maske_selektor);
    03399                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-2-1)*bit_breit_adr);
    03400                         ein_reg[2] = (LH_UINT16)jj;
    03401
    03402 #if NDIM_IN_DIM == 4
    03403                         ein_Cache[3]=jj=(*(LH_UINT16 *)inputData[3]);
    03404                         ko0 = jj - ( jj >> ( adr_breite_elut ));
    03405                         ko = ko0 & ( aElutShiftNum - 1 );
    03406                         ko0 = ko0 >> aElutShift;
    03407                         ko0 += aElutOffset;
    03408                            jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift;
    03409
    03410                         aElutOffset += adr_bereich_elut;
    03411                         adr[3] = (jj & bit_maske_selektor);
    03412                         adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-3-1)*bit_breit_adr);
    03413                         ein_reg[3] = (LH_UINT16)jj;
    03414 #endif
    03415                 adr0 *= NDIM_OUT_DIM;
    03416
    03417                 {                                                               /* a kind of */
    03418                     register long Hold;
    03419
    03420
    03421                                 Index[0] = 0;
    03422                                 Index[1] = 1;
    03423                                 Index[2] = 2;
    03424 #if NDIM_IN_DIM == 4
    03425                                 Index[3] = 3;
    03426 #endif
    03427                                         if( adr[0] < adr[1] ){
    03428                                                 Hold = Index[0];
    03429                                                 Index[0] = Index[1];
    03430                                                 Index[1] = Hold;
    03431                                         }
    03432
    03433                                         if( adr[Index[1]] < adr[2] ){
    03434                                                 Hold = Index[1];
    03435                                                 Index[1] = Index[2];
    03436                                                 Index[2] = Hold;
    03437                                                 if( adr[Index[0]] < adr[Index[1]] ){
    03438                                                         Hold = Index[0];
    03439                                                         Index[0] = Index[1];
    03440                                                         Index[1] = Hold;
    03441                                                 }
    03442                                         }
    03443
    03444 #if NDIM_IN_DIM == 4
    03445                                         if( adr[Index[2]] < adr[3] ){
    03446                                                 Hold = Index[2];
    03447                                                 Index[2] = Index[3];
    03448                                                 Index[3] = Hold;
    03449                                                 if( adr[Index[1]] < adr[Index[2]] ){
    03450                                                         Hold = Index[1];
    03451                                                         Index[1] = Index[2];
    03452                                                         Index[2] = Hold;
    03453                                                         if( adr[Index[0]] < adr[Index[1]] ){
    03454                                                                 Hold = Index[0];
    03455                                                                 Index[0] = Index[1];
    03456                                                                 Index[1] = Hold;
    03457                                                         }
    03458                                                 }
    03459                                         }
    03460 #endif
    03461                 }
    03462
    03463                         accu[0]=0;
    03464                         accu[1]=0;
    03465                         accu[2]=0;
    03466 #if NDIM_OUT_DIM == 4
    03467                         accu[3]=0;
    03468 #endif
    03469
    03470                 ko0 = bit_maske_selektor+1;
    03471                 adrAdr=adr0;
    03472                 adrOffset=0;
    03473
    03474                 if( aXlutWordSize  == 16 ){
    03475                         jj = Index[0];
    03476                         ko = ko0 - adr[jj];
    03477                         ko0 = adr[jj];
    03478
    03479                         if( ein_reg[jj] < bit_maske_adr )
    03480                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03481
    03482                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    03483                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    03484                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    03485 #if NDIM_OUT_DIM == 4
    03486                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    03487 #endif
    03488                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03489
    03490                         jj = Index[1];
    03491                         ko = ko0 - adr[jj];
    03492                         ko0 = adr[jj];
    03493
    03494                         if( ein_reg[jj] < bit_maske_adr )
    03495                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03496
    03497                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    03498                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    03499                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    03500 #if NDIM_OUT_DIM == 4
    03501                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    03502 #endif
    03503                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03504
    03505                         jj = Index[2];
    03506                         ko = ko0 - adr[jj];
    03507                         ko0 = adr[jj];
    03508
    03509                         if( ein_reg[jj] < bit_maske_adr )
    03510                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03511
    03512                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    03513                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    03514                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    03515 #if NDIM_OUT_DIM == 4
    03516                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    03517 #endif
    03518                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03519
    03520 #if NDIM_IN_DIM == 4
    03521                         jj = Index[3];
    03522                         ko = ko0 - adr[jj];
    03523                         ko0 = adr[jj];
    03524
    03525                         if( ein_reg[jj] < bit_maske_adr )
    03526                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03527
    03528                                                 accu[0]+=Xlut[adrAdr+(0)]*ko;
    03529                                                 accu[1]+=Xlut[adrAdr+(1)]*ko;
    03530                                                 accu[2]+=Xlut[adrAdr+(2)]*ko;
    03531 #if NDIM_OUT_DIM == 4
    03532                                                 accu[3]+=Xlut[adrAdr+(3)]*ko;
    03533 #endif
    03534                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03535 #endif
    03536                 accu[0]+=Xlut[adrAdr+0]*ko0;
    03537                 accu[1]+=Xlut[adrAdr+1]*ko0;
    03538                 accu[2]+=Xlut[adrAdr+2]*ko0;
    03539 #if NDIM_OUT_DIM == 4
    03540                                 accu[3]+=Xlut[adrAdr+3]*ko0;
    03541 #endif
    03542                 }
    03543                 else{
    03544                         jj = Index[0];
    03545                         ko = ko0 - adr[jj];
    03546                         ko0 = adr[jj];
    03547
    03548                         if( ein_reg[jj] < bit_maske_adr )
    03549                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03550
    03551                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03552                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03553                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03554 #if NDIM_OUT_DIM == 4
    03555                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03556 #endif
    03557
    03558                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03559
    03560                         jj = Index[1];
    03561                         ko = ko0 - adr[jj];
    03562                         ko0 = adr[jj];
    03563
    03564                         if( ein_reg[jj] < bit_maske_adr )
    03565                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03566
    03567                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03568                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03569                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03570 #if NDIM_OUT_DIM == 4
    03571                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03572 #endif
    03573
    03574                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03575
    03576                         jj = Index[2];
    03577                         ko = ko0 - adr[jj];
    03578                         ko0 = adr[jj];
    03579
    03580                         if( ein_reg[jj] < bit_maske_adr )
    03581                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03582
    03583                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03584                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03585                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03586 #if NDIM_OUT_DIM == 4
    03587                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03588 #endif
    03589
    03590                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03591
    03592 #if NDIM_IN_DIM == 4
    03593                         jj = Index[3];
    03594                         ko = ko0 - adr[jj];
    03595                         ko0 = adr[jj];
    03596
    03597                         if( ein_reg[jj] < bit_maske_adr )
    03598                             adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr);
    03599
    03600                             accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko;
    03601                             accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko;
    03602                             accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko;
    03603 #if NDIM_OUT_DIM == 4
    03604                             accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko;
    03605 #endif
    03606
    03607                         adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset);
    03608 #endif
    03609                                 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0;
    03610                 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0;
    03611                 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0;
    03612 #if NDIM_OUT_DIM == 4
    03613                                 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0;
    03614 #endif
    03615                 }
    03616
    03617                 aAlutOffset = 0;
    03618
    03619                 if( aOutputPackMode8Bit ){
    03620                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    03621                                         jj = accu[ii];
    03622                                         jj = jj + ( jj >> aXlutWordSize );
    03623
    03624                                         ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder;     /*      aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    03625
    03626                                         ko = ko0 & (aAlutInShiftNum - 1 );
    03627                                         ko0 = ko0 >> aAlutInShift;
    03628                                         ko0 += aAlutOffset;
    03629                                         if( aAlutWordSize <= 8)
    03630                                         jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift );
    03631                                         else{
    03632                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko );
    03633                                                 jj = jj - ( jj >> aAlutShift );
    03634                                                 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift);
    03635                                         }
    03636
    03637                                         *outputData[ii] = (LH_UINT8)jj;
    03638                         aAlutOffset += adr_bereich_alut;
    03639                     }
    03640                 }
    03641                 else{
    03642                                 if( aXlutWordSize >= 16 ){
    03643                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    03644                                                 jj = accu[ii];
    03645                                                 jj = jj + ( jj >> aXlutWordSize );
    03646                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /*  aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    03647
    03648                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    03649                                                 ko0 = ko0 >> aAlutInShift;
    03650                                                 ko0 += aAlutOffset;
    03651                                                 if( aAlutWordSize <= 8)
    03652                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    03653                                                 else
    03654                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    03655                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    03656                                                 aAlutOffset += adr_bereich_alut;
    03657                                         }
    03658                                 }
    03659                                 else{
    03660                                         for( ii=0; ii<NDIM_OUT_DIM; ++ii){
    03661                                                 jj = accu[ii];
    03662                                                 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize );
    03663                                 ko0 = (jj - ( jj >> ( adr_breite_alut ))); /*   aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/
    03664
    03665                                                 ko = ko0 & (aAlutInShiftNum - 1 );
    03666                                                 ko0 = ko0 >> aAlutInShift;
    03667                                                 ko0 += aAlutOffset;
    03668                                                 if( aAlutWordSize <= 8)
    03669                                                 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift );
    03670                                                 else
    03671                                                 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift);
    03672                                                 *((LH_UINT16 *)outputData[ii]) =  (LH_UINT16)jj;
    03673                                                 aAlutOffset += adr_bereich_alut;
    03674                                         }
    03675                                 }
    03676                 }
    03677
    03678                         while (--i){
    03679                                 for( jj=0; jj<NDIM_IN_DIM; ++jj){
    03680                                         inputData[jj] += (NDIM_IN_DIM * 2);
    03681                                 }
    03682                                 for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03683                                         outputData[jj] += OutputIncrement;
    03684                                 }
    03685
    03686                                 {
    03687                                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    03688                                                 if( *((LH_UINT16 *)inputData[jj]) ^ *(LH_UINT16 *)(&ein_Cache[jj]) )break;
    03689                                         }
    03690                                 }
    03691                                 if( jj<NDIM_IN_DIM ) break;
    03692                                 if( aOutputPackMode8Bit ){
    03693                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03694                                                 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )];
    03695                                         }
    03696                                 }
    03697                                 else{
    03698                                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03699                                                 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]);
    03700                                         }
    03701                                 }
    03702                         }
    03703                 }
    03704
    03705                 if( --LineCount ){
    03706                         for( jj=0; jj<NDIM_IN_DIM; ++jj){
    03707                                 inputData[jj] += inputDataRowOffset;
    03708                         }
    03709                         for( jj=0; jj<NDIM_OUT_DIM; ++jj){
    03710                                 outputData[jj] += outputDataRowOffset;
    03711                         }
    03712                 }
    03713     }
    03714     }
    03715
    03716         /* UNLOCK_DATA( aElutHdle ); */
    03717         /* UNLOCK_DATA( aAlutHdle ); */
    03718         /* UNLOCK_DATA( aXlutHdle ); */
    03719
    03720         LH_END_PROC("Calc424Dim_Data8To8_Lut16")
    03721         return noErr;
    03722 }

CMError CalcNDim_Data16To16_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 899 of file w98/lh_core/calcndim.c.

References CalcNDim_Data8To8_Lut16(), and CMError.

Referenced by CreateCombi().

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

CMError CalcNDim_Data16To16_Lut8 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 935 of file w98/lh_core/calcndim.c.

References CalcNDim_Data8To8_Lut16(), and CMError.

Referenced by CreateCombi().

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

CMError CalcNDim_Data16To8_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 890 of file w98/lh_core/calcndim.c.

References CalcNDim_Data8To8_Lut16(), and CMError.

Referenced by CreateCombi().

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

CMError CalcNDim_Data16To8_Lut8 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 917 of file w98/lh_core/calcndim.c.

References CalcNDim_Data8To8_Lut16(), and CMError.

Referenced by CreateCombi().

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

CMError CalcNDim_Data8To16_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 881 of file w98/lh_core/calcndim.c.

References CalcNDim_Data8To8_Lut16(), and CMError.

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

CMError CalcNDim_Data8To16_Lut8 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 926 of file w98/lh_core/calcndim.c.

References CalcNDim_Data8To8_Lut16(), and CMError.

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

CMError CalcNDim_Data8To8_Lut16 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

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

References aElutShift, aElutShiftNum, Boolean, Calc323Dim_Data8To8_Lut16(), Calc324Dim_Data8To8_Lut16(), Calc423Dim_Data8To8_Lut16(), Calc424Dim_Data8To8_Lut16(), cm8PerChannelPacking, CMError, CMCalcParam::cmInputBytesPerLine, CMCalcParam::cmInputColorSpace, CMCalcParam::cmInputPixelOffset, CMCalcParam::cmLineCount, cmLong8ColorPacking, CMCalcParam::cmOutputBytesPerLine, CMCalcParam::cmOutputColorSpace, CMCalcParam::cmOutputPixelOffset, cmparamErr, CMCalcParam::cmPixelPerLine, CMLutParam::colorLut, CMLutParam::colorLutGridPoints, CMLutParam::colorLutInDim, CMLutParam::colorLutOutDim, CMLutParam::colorLutWordSize, CMCalcParam::copyAlpha, DebugPrint, Hold, Index, CMCalcParam::inputData, CMLutParam::inputLut, CMLutParam::inputLutEntryCount, CMLutParam::inputLutWordSize, LH_END_PROC, LH_START_PROC, LH_UINT16, LH_UINT8, noErr, CMCalcParam::outputData, CMLutParam::outputLut, CMLutParam::outputLutEntryCount, CMLutParam::outputLutWordSize, SHRINK_FACTOR, UINT32, and UNROLL_NDIM.

Referenced by CalcNDim_Data16To16_Lut16(), CalcNDim_Data16To16_Lut8(), CalcNDim_Data16To8_Lut16(), CalcNDim_Data16To8_Lut8(), CalcNDim_Data8To16_Lut16(), CalcNDim_Data8To16_Lut8(), and CalcNDim_Data8To8_Lut8().

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

CMError CalcNDim_Data8To8_Lut8 | ( | CMCalcParamPtr | calcParam,
|  | CMLutParamPtr | lutParam
| ) |

Definition at line 908 of file w98/lh_core/calcndim.c.

References CalcNDim_Data8To8_Lut16(), and CMError.

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