test: calcnd3.c Source File

00001 /* 00002 File: LHCalcND3_Lut16.c 00003 00004 Contains: 00005 00006 Written by: U. J. Krabbenhoeft 00007 00008 Copyright: � 1993-1997 by Heidelberger Druckmaschinen AG, all rights reserved. 00009 00010 Version: 00011 */ 00012 00013 #ifndef LHGeneralIncs_h 00014 #include "General.h" 00015 #endif 00016 00017 #ifndef LHCalcEngine_h 00018 #include "CalcEng.h" 00019 #endif 00020 00021 #ifndef LHCalcNDim_h 00022 #include "CalcNDim.h" 00023 #endif 00024 00025 #ifdef DEBUG_OUTPUT 00026 #define kThisFile kLHCalcNDim_Lut16ID 00027 #else 00028 #define DebugPrint(x) 00029 #endif 00030 00031 #define CLIPPWord(x,a,b) ((x)<(a)?(LH_UINT16)(a):((x)>(b)?(LH_UINT16)(b):(LH_UINT16)(x+.5))) 00032 #define CLIPP(x,a,b) ((x)<(a)?(a):((x)>(b)?(b):(x))) 00033 00034 #define UNROLL_NDIM 1 00035 #if UNROLL_NDIM 00036 CMError Calc323Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 00037 CMLutParamPtr lutParam); 00038 CMError Calc324Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 00039 CMLutParamPtr lutParam); 00040 CMError Calc423Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 00041 CMLutParamPtr lutParam); 00042 CMError Calc424Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 00043 CMLutParamPtr lutParam); 00044 #define NDIM_IN_DIM 3 00045 #define NDIM_OUT_DIM 3 00046 #define aElutShift (16-adr_breite_elut) 00047 #define aElutShiftNum (1<<aElutShift) 00048 00049 CMError Calc323Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 00050 CMLutParamPtr lutParam) 00051 00052 { 00053 LH_UINT8 * inputData[8], *outputData[8]; 00054 UINT32 OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount; 00055 register unsigned long adr0; 00056 register unsigned long ko0; 00057 unsigned long accu[8]; 00058 register long i; 00059 /*long Offsets[8];*/ 00060 00061 register long aAlutShift,aElutOffset,aAlutOffset; 00062 register long aElutWordSize; 00063 register long aAlutWordSize; 00064 register long aXlutAdrSize; 00065 register long aXlutAdrShift; 00066 register unsigned long aXlutWordSize; 00067 register unsigned long ii,jj; 00068 register long aOutputPackMode8Bit; 00069 LH_UINT16 ein_Cache[8]; 00070 00071 LH_UINT16 * aus_lut = (LH_UINT16*)lutParam->outputLut; 00072 LH_UINT16 * ein_lut = (LH_UINT16*)lutParam->inputLut; 00073 LH_UINT16 * Xlut = (LH_UINT16*)lutParam->colorLut; 00074 00075 #ifdef DEBUG_OUTPUT 00076 long err = noErr; 00077 #endif 00078 LH_START_PROC("Calc323Dim_Data8To8_Lut16") 00079 00080 inputData[0] = (LH_UINT8 *)calcParam->inputData[0]; 00081 inputData[1] = (LH_UINT8 *)calcParam->inputData[1]; 00082 inputData[2] = (LH_UINT8 *)calcParam->inputData[2]; 00083 #if NDIM_IN_DIM == 4 00084 inputData[3] = (LH_UINT8 *)calcParam->inputData[3]; 00085 #endif 00086 outputData[0] = (LH_UINT8 *)calcParam->outputData[0]; 00087 outputData[1] = (LH_UINT8 *)calcParam->outputData[1]; 00088 outputData[2] = (LH_UINT8 *)calcParam->outputData[2]; 00089 #if NDIM_OUT_DIM == 4 00090 outputData[3] = (LH_UINT8 *)calcParam->outputData[3]; 00091 #endif 00092 00093 OutputIncrement = calcParam->cmOutputPixelOffset; 00094 inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + (NDIM_IN_DIM * 2); 00095 outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement; 00096 00097 Pixelcount = calcParam->cmPixelPerLine; 00098 LineCount = calcParam->cmLineCount; 00099 00100 aElutWordSize = lutParam->inputLutWordSize; 00101 aAlutWordSize = lutParam->outputLutWordSize; 00102 aXlutAdrSize = lutParam->colorLutGridPoints; 00103 for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++) 00104 aXlutAdrShift = i; 00105 aXlutWordSize = lutParam->colorLutWordSize; 00106 00107 aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking; 00108 /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/ 00109 #if FARBR_FILES 00110 WriteLuts( "DoNDim",1,adr_bereich_elut,aElutWordSize,ein_lut, 00111 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,adr_bereich_alut,aAlutWordSize,(LH_UINT16 *)aus_lut); 00112 #endif 00113 00114 i=0; 00115 00116 { 00117 if( aElutShift < 0 ) 00118 { 00119 #ifdef DEBUG_OUTPUT 00120 DebugPrint("� DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift); 00121 #endif 00122 return cmparamErr; 00123 } 00124 } 00125 00126 if( aOutputPackMode8Bit ){ 00127 aAlutShift = (aAlutWordSize-8); 00128 } 00129 else{ 00130 aAlutShift = (16 - aAlutWordSize); 00131 } 00132 00133 #ifdef DEBUG_OUTPUT 00134 if ( DebugCheck(kThisFile, kDebugReserved1) ){ 00135 DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n", 00136 adr_bereich_elut,adr_breite_elut,aElutWordSize,ein_lut); 00137 DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n", 00138 adr_bereich_alut,adr_breite_alut,aAlutWordSize,aus_lut); 00139 DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n", 00140 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut); 00141 } 00142 #endif 00143 00144 /*if( 1 )*/ 00145 if( aXlutAdrSize != (1<<aXlutAdrShift )){ 00146 register long aXlutOffset; 00147 long theXlutOffsets[8]; 00148 register unsigned long aAlutInShift; 00149 register long aAlutInShiftRemainder; 00150 register unsigned long aAlutInShiftNum; 00151 register long aElutWordSizeMask = (1<<aElutWordSize) - 1; 00152 register unsigned long aAlutRound; 00153 aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut; 00154 aAlutInShiftRemainder = 0; 00155 if( aAlutInShift > 16 ){ 00156 aAlutInShiftRemainder = aAlutInShift - 16; 00157 aAlutInShift = 16; 00158 } 00159 aAlutInShiftNum = (1<<aAlutInShift); 00160 00161 #ifdef DEBUG_OUTPUT 00162 if ( DebugCheck(kThisFile, kDebugMiscInfo) ) 00163 DebugPrint(" DoNDim gripoints = %ld\n",aXlutAdrSize); 00164 #endif 00165 if( aElutWordSize <= 0 ){ 00166 #ifdef DEBUG_OUTPUT 00167 DebugPrint("� DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize); 00168 #endif 00169 return cmparamErr; 00170 } 00171 if( aAlutInShift <= 0 ){ 00172 #ifdef DEBUG_OUTPUT 00173 DebugPrint("� DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift); 00174 #endif 00175 return cmparamErr; 00176 } 00177 aXlutOffset =NDIM_OUT_DIM; 00178 for( i=0; i<(long)NDIM_IN_DIM; i++){ 00179 theXlutOffsets[ NDIM_IN_DIM-1-i] = aXlutOffset; 00180 aXlutOffset *=aXlutAdrSize; 00181 } 00182 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 00183 00184 #ifdef DEBUG_OUTPUT 00185 if ( DebugCheck(kThisFile, kDebugReserved1) ) 00186 DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(adr_bereich_alut/2))/adr_bereich_alut = %ld\n",aElutWordSize,aAlutInShift); 00187 #endif 00188 00189 while (LineCount){ 00190 i = Pixelcount; 00191 00192 while (i){ 00193 00194 long adr[8],Index[8]; 00195 LH_UINT16 ein_reg[8]; 00196 register unsigned long adrAdr,ko,adrOffset; 00197 00198 adr0=0; 00199 aElutOffset = 0; 00200 jj=0; 00201 00202 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 00203 ko0 = jj - ( jj >> ( adr_breite_elut )); 00204 ko = ko0 & ( aElutShiftNum - 1 ); 00205 ko0 = ko0 >> aElutShift; 00206 ko0 += aElutOffset; 00207 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 00208 00209 jj *= aXlutAdrSize; 00210 aElutOffset += adr_bereich_elut; 00211 adr[0] = jj & aElutWordSizeMask; 00212 jj = jj >> aElutWordSize; 00213 adr0 += (jj)*theXlutOffsets[0]; 00214 ein_reg[0] = (LH_UINT16)jj; 00215 00216 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 00217 ko0 = jj - ( jj >> ( adr_breite_elut )); 00218 ko = ko0 & ( aElutShiftNum - 1 ); 00219 ko0 = ko0 >> aElutShift; 00220 ko0 += aElutOffset; 00221 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 00222 00223 jj *= aXlutAdrSize; 00224 aElutOffset += adr_bereich_elut; 00225 adr[1] = jj & aElutWordSizeMask; 00226 jj = jj >> aElutWordSize; 00227 adr0 += (jj)*theXlutOffsets[1]; 00228 ein_reg[1] = (LH_UINT16)jj; 00229 00230 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 00231 ko0 = jj - ( jj >> ( adr_breite_elut )); 00232 ko = ko0 & ( aElutShiftNum - 1 ); 00233 ko0 = ko0 >> aElutShift; 00234 ko0 += aElutOffset; 00235 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 00236 00237 jj *= aXlutAdrSize; 00238 aElutOffset += adr_bereich_elut; 00239 adr[2] = jj & aElutWordSizeMask; 00240 jj = jj >> aElutWordSize; 00241 adr0 += (jj)*theXlutOffsets[2]; 00242 ein_reg[2] = (LH_UINT16)jj; 00243 00244 #if NDIM_IN_DIM == 4 00245 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 00246 ko0 = jj - ( jj >> ( adr_breite_elut )); 00247 ko = ko0 & ( aElutShiftNum - 1 ); 00248 ko0 = ko0 >> aElutShift; 00249 ko0 += aElutOffset; 00250 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 00251 00252 jj *= aXlutAdrSize; 00253 aElutOffset += adr_bereich_elut; 00254 adr[3] = jj & aElutWordSizeMask; 00255 jj = jj >> aElutWordSize; 00256 adr0 += (jj)*theXlutOffsets[3]; 00257 ein_reg[3] = (LH_UINT16)jj; 00258 #endif 00259 00260 00261 00262 { /* a kind of */ 00263 register long Hold; 00264 00265 00266 Index[0] = 0; 00267 Index[1] = 1; 00268 Index[2] = 2; 00269 #if NDIM_IN_DIM == 4 00270 Index[3] = 3; 00271 #endif 00272 if( adr[0] < adr[1] ){ 00273 Hold = Index[0]; 00274 Index[0] = Index[1]; 00275 Index[1] = Hold; 00276 } 00277 00278 if( adr[Index[1]] < adr[2] ){ 00279 Hold = Index[1]; 00280 Index[1] = Index[2]; 00281 Index[2] = Hold; 00282 if( adr[Index[0]] < adr[Index[1]] ){ 00283 Hold = Index[0]; 00284 Index[0] = Index[1]; 00285 Index[1] = Hold; 00286 } 00287 } 00288 00289 #if NDIM_IN_DIM == 4 00290 if( adr[Index[2]] < adr[3] ){ 00291 Hold = Index[2]; 00292 Index[2] = Index[3]; 00293 Index[3] = Hold; 00294 if( adr[Index[1]] < adr[Index[2]] ){ 00295 Hold = Index[1]; 00296 Index[1] = Index[2]; 00297 Index[2] = Hold; 00298 if( adr[Index[0]] < adr[Index[1]] ){ 00299 Hold = Index[0]; 00300 Index[0] = Index[1]; 00301 Index[1] = Hold; 00302 } 00303 } 00304 } 00305 #endif 00306 } 00307 00308 accu[0]=0; 00309 accu[1]=0; 00310 accu[2]=0; 00311 #if NDIM_OUT_DIM == 4 00312 accu[3]=0; 00313 #endif 00314 ko0 = (1<<aElutWordSize); 00315 adrAdr=adr0; 00316 adrOffset=0; 00317 if( aXlutWordSize == 16 ){ 00318 jj = Index[0]; 00319 ko = ko0 - adr[jj]; 00320 ko0 = adr[jj]; 00321 00322 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00323 adrOffset += theXlutOffsets[jj]; 00324 00325 accu[0]+=Xlut[adrAdr+(0)]*ko; 00326 accu[1]+=Xlut[adrAdr+(1)]*ko; 00327 accu[2]+=Xlut[adrAdr+(2)]*ko; 00328 #if NDIM_OUT_DIM == 4 00329 accu[3]+=Xlut[adrAdr+(3)]*ko; 00330 #endif 00331 00332 adrAdr = (adr0 + adrOffset); 00333 00334 jj = Index[1]; 00335 ko = ko0 - adr[jj]; 00336 ko0 = adr[jj]; 00337 00338 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00339 adrOffset += theXlutOffsets[jj]; 00340 00341 accu[0]+=Xlut[adrAdr+(0)]*ko; 00342 accu[1]+=Xlut[adrAdr+(1)]*ko; 00343 accu[2]+=Xlut[adrAdr+(2)]*ko; 00344 #if NDIM_OUT_DIM == 4 00345 accu[3]+=Xlut[adrAdr+(3)]*ko; 00346 #endif 00347 00348 adrAdr = (adr0 + adrOffset); 00349 00350 jj = Index[2]; 00351 ko = ko0 - adr[jj]; 00352 ko0 = adr[jj]; 00353 00354 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00355 adrOffset += theXlutOffsets[jj]; 00356 00357 accu[0]+=Xlut[adrAdr+(0)]*ko; 00358 accu[1]+=Xlut[adrAdr+(1)]*ko; 00359 accu[2]+=Xlut[adrAdr+(2)]*ko; 00360 #if NDIM_OUT_DIM == 4 00361 accu[3]+=Xlut[adrAdr+(3)]*ko; 00362 #endif 00363 00364 adrAdr = (adr0 + adrOffset); 00365 00366 #if NDIM_IN_DIM == 4 00367 jj = Index[3]; 00368 ko = ko0 - adr[jj]; 00369 ko0 = adr[jj]; 00370 00371 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00372 adrOffset += theXlutOffsets[jj]; 00373 00374 accu[0]+=Xlut[adrAdr+(0)]*ko; 00375 accu[1]+=Xlut[adrAdr+(1)]*ko; 00376 accu[2]+=Xlut[adrAdr+(2)]*ko; 00377 #if NDIM_OUT_DIM == 4 00378 accu[3]+=Xlut[adrAdr+(3)]*ko; 00379 #endif 00380 00381 adrAdr = (adr0 + adrOffset); 00382 #endif 00383 00384 accu[0]+=Xlut[adrAdr+0]*ko0; 00385 accu[1]+=Xlut[adrAdr+1]*ko0; 00386 accu[2]+=Xlut[adrAdr+2]*ko0; 00387 #if NDIM_OUT_DIM == 4 00388 accu[3]+=Xlut[adrAdr+3]*ko0; 00389 #endif 00390 } 00391 else{ 00392 00393 jj = Index[0]; 00394 ko = ko0 - adr[jj]; 00395 ko0 = adr[jj]; 00396 00397 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00398 adrOffset += theXlutOffsets[jj]; 00399 00400 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00401 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00402 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00403 #if NDIM_OUT_DIM == 4 00404 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00405 #endif 00406 adrAdr = (adr0 + adrOffset); 00407 00408 jj = Index[1]; 00409 ko = ko0 - adr[jj]; 00410 ko0 = adr[jj]; 00411 00412 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00413 adrOffset += theXlutOffsets[jj]; 00414 00415 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00416 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00417 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00418 #if NDIM_OUT_DIM == 4 00419 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00420 #endif 00421 adrAdr = (adr0 + adrOffset); 00422 00423 jj = Index[2]; 00424 ko = ko0 - adr[jj]; 00425 ko0 = adr[jj]; 00426 00427 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00428 adrOffset += theXlutOffsets[jj]; 00429 00430 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00431 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00432 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00433 #if NDIM_OUT_DIM == 4 00434 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00435 #endif 00436 adrAdr = (adr0 + adrOffset); 00437 00438 #if NDIM_IN_DIM == 4 00439 jj = Index[3]; 00440 ko = ko0 - adr[jj]; 00441 ko0 = adr[jj]; 00442 00443 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 00444 adrOffset += theXlutOffsets[jj]; 00445 00446 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00447 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00448 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00449 #if NDIM_OUT_DIM == 4 00450 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00451 #endif 00452 adrAdr = (adr0 + adrOffset); 00453 #endif 00454 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 00455 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 00456 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 00457 #if NDIM_OUT_DIM == 4 00458 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 00459 #endif 00460 } 00461 00462 aAlutOffset = 0; 00463 00464 if( aOutputPackMode8Bit ){ 00465 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 00466 jj = accu[ii]; 00467 jj = jj + ( jj >> aXlutWordSize ); 00468 00469 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 00470 00471 ko = ko0 & (aAlutInShiftNum - 1 ); 00472 ko0 = ko0 >> aAlutInShift; 00473 ko0 += aAlutOffset; 00474 if( aAlutWordSize <= 8) 00475 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 00476 else{ 00477 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 00478 jj = jj - ( jj >> aAlutShift ); 00479 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 00480 } 00481 *outputData[ii] = (LH_UINT8)jj; 00482 aAlutOffset += adr_bereich_alut; 00483 } 00484 } 00485 else{ 00486 if( aXlutWordSize >= 16 ){ 00487 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 00488 jj = accu[ii]; 00489 jj = jj + ( jj >> aXlutWordSize ); 00490 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 00491 00492 ko = ko0 & (aAlutInShiftNum - 1 ); 00493 ko0 = ko0 >> aAlutInShift; 00494 ko0 += aAlutOffset; 00495 if( aAlutWordSize <= 8) 00496 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 00497 else 00498 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 00499 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 00500 aAlutOffset += adr_bereich_alut; 00501 } 00502 } 00503 else{ 00504 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 00505 jj = accu[ii]; 00506 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 00507 ko0 = (jj - ( jj >> ( adr_breite_alut ))) ; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 00508 00509 ko = ko0 & (aAlutInShiftNum - 1 ); 00510 ko0 = ko0 >> aAlutInShift; 00511 ko0 += aAlutOffset; 00512 if( aAlutWordSize <= 8) 00513 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 00514 else 00515 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 00516 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 00517 aAlutOffset += adr_bereich_alut; 00518 } 00519 } 00520 } 00521 while (--i){ 00522 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 00523 inputData[jj] += (NDIM_IN_DIM * 2); 00524 } 00525 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00526 outputData[jj] += OutputIncrement; 00527 } 00528 00529 { 00530 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 00531 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 00532 } 00533 } 00534 if( jj<NDIM_IN_DIM ) break; 00535 if( aOutputPackMode8Bit ){ 00536 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00537 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 00538 } 00539 } 00540 else{ 00541 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00542 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 00543 } 00544 } 00545 } 00546 } 00547 00548 if( --LineCount ){ 00549 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 00550 inputData[jj] += inputDataRowOffset; 00551 } 00552 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00553 outputData[jj] += outputDataRowOffset; 00554 } 00555 } 00556 } 00557 } 00558 else{ 00559 00560 register unsigned long bit_breit_selektor; 00561 register unsigned long bit_maske_selektor; 00562 register unsigned long bit_breit_adr; 00563 register unsigned long bit_maske_adr; 00564 register unsigned long aAlutInShiftNum; 00565 register long aAlutInShift; 00566 register long aAlutInShiftRemainder; 00567 register unsigned long aAlutRound; 00568 /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/ 00569 bit_breit_selektor=aElutWordSize-aXlutAdrShift; 00570 if( aElutWordSize-aXlutAdrShift < 0 ) 00571 { 00572 #ifdef DEBUG_OUTPUT 00573 DebugPrint("� DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor); 00574 #endif 00575 return cmparamErr; 00576 } 00577 bit_maske_selektor=(1<<bit_breit_selektor)-1; 00578 bit_breit_adr=aXlutAdrShift; 00579 bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor; 00580 aAlutInShift = (aXlutWordSize+bit_breit_selektor-adr_breite_alut); 00581 /*aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 00582 aAlutInShiftRemainder = 0; 00583 if( aAlutInShift > 16 ){ 00584 aAlutInShiftRemainder = aAlutInShift - 16; 00585 aAlutInShift = 16; 00586 } 00587 00588 aAlutInShiftNum = (1<<aAlutInShift); 00589 00590 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 00591 while (LineCount){ 00592 i = Pixelcount; 00593 00594 while (i){ 00595 00596 long adr[8],Index[8]; 00597 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/ 00598 LH_UINT16 ein_reg[8]; 00599 register unsigned long adrAdr,ko,adrOffset; 00600 /*register unsigned long aIndex;*/ 00601 00602 adr0=0; 00603 aElutOffset = 0; 00604 jj=0; 00605 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 00606 ko0 = jj - ( jj >> ( adr_breite_elut )); 00607 ko = ko0 & ( aElutShiftNum - 1 ); 00608 ko0 = ko0 >> aElutShift; 00609 ko0 += aElutOffset; 00610 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 00611 00612 aElutOffset += adr_bereich_elut; 00613 adr[0] = (jj & bit_maske_selektor); 00614 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-0-1)*bit_breit_adr); 00615 ein_reg[0] = (LH_UINT16)jj; 00616 00617 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 00618 ko0 = jj - ( jj >> ( adr_breite_elut )); 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 += adr_bereich_elut; 00625 adr[1] = (jj & bit_maske_selektor); 00626 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-1-1)*bit_breit_adr); 00627 ein_reg[1] = (LH_UINT16)jj; 00628 00629 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 00630 ko0 = jj - ( jj >> ( adr_breite_elut )); 00631 ko = ko0 & ( aElutShiftNum - 1 ); 00632 ko0 = ko0 >> aElutShift; 00633 ko0 += aElutOffset; 00634 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 00635 00636 aElutOffset += adr_bereich_elut; 00637 adr[2] = (jj & bit_maske_selektor); 00638 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-2-1)*bit_breit_adr); 00639 ein_reg[2] = (LH_UINT16)jj; 00640 00641 #if NDIM_IN_DIM == 4 00642 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 00643 ko0 = jj - ( jj >> ( adr_breite_elut )); 00644 ko = ko0 & ( aElutShiftNum - 1 ); 00645 ko0 = ko0 >> aElutShift; 00646 ko0 += aElutOffset; 00647 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 00648 00649 aElutOffset += adr_bereich_elut; 00650 adr[3] = (jj & bit_maske_selektor); 00651 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-3-1)*bit_breit_adr); 00652 ein_reg[3] = (LH_UINT16)jj; 00653 #endif 00654 adr0 *= NDIM_OUT_DIM; 00655 00656 { /* a kind of */ 00657 register long Hold; 00658 00659 00660 Index[0] = 0; 00661 Index[1] = 1; 00662 Index[2] = 2; 00663 #if NDIM_IN_DIM == 4 00664 Index[3] = 3; 00665 #endif 00666 if( adr[0] < adr[1] ){ 00667 Hold = Index[0]; 00668 Index[0] = Index[1]; 00669 Index[1] = Hold; 00670 } 00671 00672 if( adr[Index[1]] < adr[2] ){ 00673 Hold = Index[1]; 00674 Index[1] = Index[2]; 00675 Index[2] = Hold; 00676 if( adr[Index[0]] < adr[Index[1]] ){ 00677 Hold = Index[0]; 00678 Index[0] = Index[1]; 00679 Index[1] = Hold; 00680 } 00681 } 00682 00683 #if NDIM_IN_DIM == 4 00684 if( adr[Index[2]] < adr[3] ){ 00685 Hold = Index[2]; 00686 Index[2] = Index[3]; 00687 Index[3] = Hold; 00688 if( adr[Index[1]] < adr[Index[2]] ){ 00689 Hold = Index[1]; 00690 Index[1] = Index[2]; 00691 Index[2] = Hold; 00692 if( adr[Index[0]] < adr[Index[1]] ){ 00693 Hold = Index[0]; 00694 Index[0] = Index[1]; 00695 Index[1] = Hold; 00696 } 00697 } 00698 } 00699 #endif 00700 } 00701 00702 accu[0]=0; 00703 accu[1]=0; 00704 accu[2]=0; 00705 #if NDIM_OUT_DIM == 4 00706 accu[3]=0; 00707 #endif 00708 00709 ko0 = bit_maske_selektor+1; 00710 adrAdr=adr0; 00711 adrOffset=0; 00712 00713 if( aXlutWordSize == 16 ){ 00714 jj = Index[0]; 00715 ko = ko0 - adr[jj]; 00716 ko0 = adr[jj]; 00717 00718 if( ein_reg[jj] < bit_maske_adr ) 00719 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00720 00721 accu[0]+=Xlut[adrAdr+(0)]*ko; 00722 accu[1]+=Xlut[adrAdr+(1)]*ko; 00723 accu[2]+=Xlut[adrAdr+(2)]*ko; 00724 #if NDIM_OUT_DIM == 4 00725 accu[3]+=Xlut[adrAdr+(3)]*ko; 00726 #endif 00727 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00728 00729 jj = Index[1]; 00730 ko = ko0 - adr[jj]; 00731 ko0 = adr[jj]; 00732 00733 if( ein_reg[jj] < bit_maske_adr ) 00734 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00735 00736 accu[0]+=Xlut[adrAdr+(0)]*ko; 00737 accu[1]+=Xlut[adrAdr+(1)]*ko; 00738 accu[2]+=Xlut[adrAdr+(2)]*ko; 00739 #if NDIM_OUT_DIM == 4 00740 accu[3]+=Xlut[adrAdr+(3)]*ko; 00741 #endif 00742 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00743 00744 jj = Index[2]; 00745 ko = ko0 - adr[jj]; 00746 ko0 = adr[jj]; 00747 00748 if( ein_reg[jj] < bit_maske_adr ) 00749 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00750 00751 accu[0]+=Xlut[adrAdr+(0)]*ko; 00752 accu[1]+=Xlut[adrAdr+(1)]*ko; 00753 accu[2]+=Xlut[adrAdr+(2)]*ko; 00754 #if NDIM_OUT_DIM == 4 00755 accu[3]+=Xlut[adrAdr+(3)]*ko; 00756 #endif 00757 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00758 00759 #if NDIM_IN_DIM == 4 00760 jj = Index[3]; 00761 ko = ko0 - adr[jj]; 00762 ko0 = adr[jj]; 00763 00764 if( ein_reg[jj] < bit_maske_adr ) 00765 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00766 00767 accu[0]+=Xlut[adrAdr+(0)]*ko; 00768 accu[1]+=Xlut[adrAdr+(1)]*ko; 00769 accu[2]+=Xlut[adrAdr+(2)]*ko; 00770 #if NDIM_OUT_DIM == 4 00771 accu[3]+=Xlut[adrAdr+(3)]*ko; 00772 #endif 00773 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00774 #endif 00775 accu[0]+=Xlut[adrAdr+0]*ko0; 00776 accu[1]+=Xlut[adrAdr+1]*ko0; 00777 accu[2]+=Xlut[adrAdr+2]*ko0; 00778 #if NDIM_OUT_DIM == 4 00779 accu[3]+=Xlut[adrAdr+3]*ko0; 00780 #endif 00781 } 00782 else{ 00783 jj = Index[0]; 00784 ko = ko0 - adr[jj]; 00785 ko0 = adr[jj]; 00786 00787 if( ein_reg[jj] < bit_maske_adr ) 00788 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00789 00790 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00791 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00792 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00793 #if NDIM_OUT_DIM == 4 00794 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00795 #endif 00796 00797 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00798 00799 jj = Index[1]; 00800 ko = ko0 - adr[jj]; 00801 ko0 = adr[jj]; 00802 00803 if( ein_reg[jj] < bit_maske_adr ) 00804 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00805 00806 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00807 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00808 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00809 #if NDIM_OUT_DIM == 4 00810 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00811 #endif 00812 00813 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00814 00815 jj = Index[2]; 00816 ko = ko0 - adr[jj]; 00817 ko0 = adr[jj]; 00818 00819 if( ein_reg[jj] < bit_maske_adr ) 00820 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00821 00822 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00823 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00824 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00825 #if NDIM_OUT_DIM == 4 00826 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00827 #endif 00828 00829 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00830 00831 #if NDIM_IN_DIM == 4 00832 jj = Index[3]; 00833 ko = ko0 - adr[jj]; 00834 ko0 = adr[jj]; 00835 00836 if( ein_reg[jj] < bit_maske_adr ) 00837 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 00838 00839 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 00840 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 00841 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 00842 #if NDIM_OUT_DIM == 4 00843 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 00844 #endif 00845 00846 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 00847 #endif 00848 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 00849 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 00850 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 00851 #if NDIM_OUT_DIM == 4 00852 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 00853 #endif 00854 } 00855 00856 aAlutOffset = 0; 00857 00858 if( aOutputPackMode8Bit ){ 00859 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 00860 jj = accu[ii]; 00861 jj = jj + ( jj >> aXlutWordSize ); 00862 00863 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 00864 00865 ko = ko0 & (aAlutInShiftNum - 1 ); 00866 ko0 = ko0 >> aAlutInShift; 00867 ko0 += aAlutOffset; 00868 if( aAlutWordSize <= 8) 00869 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 00870 else{ 00871 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 00872 jj = jj - ( jj >> aAlutShift ); 00873 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 00874 } 00875 00876 *outputData[ii] = (LH_UINT8)jj; 00877 aAlutOffset += adr_bereich_alut; 00878 } 00879 } 00880 else{ 00881 if( aXlutWordSize >= 16 ){ 00882 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 00883 jj = accu[ii]; 00884 jj = jj + ( jj >> aXlutWordSize ); 00885 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 00886 00887 ko = ko0 & (aAlutInShiftNum - 1 ); 00888 ko0 = ko0 >> aAlutInShift; 00889 ko0 += aAlutOffset; 00890 if( aAlutWordSize <= 8) 00891 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 00892 else 00893 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 00894 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 00895 aAlutOffset += adr_bereich_alut; 00896 } 00897 } 00898 else{ 00899 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 00900 jj = accu[ii]; 00901 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 00902 ko0 = (jj - ( jj >> ( adr_breite_alut ))); /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 00903 00904 ko = ko0 & (aAlutInShiftNum - 1 ); 00905 ko0 = ko0 >> aAlutInShift; 00906 ko0 += aAlutOffset; 00907 if( aAlutWordSize <= 8) 00908 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 00909 else 00910 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 00911 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 00912 aAlutOffset += adr_bereich_alut; 00913 } 00914 } 00915 } 00916 00917 while (--i){ 00918 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 00919 inputData[jj] += (NDIM_IN_DIM * 2); 00920 } 00921 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00922 outputData[jj] += OutputIncrement; 00923 } 00924 00925 { 00926 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 00927 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 00928 } 00929 } 00930 if( jj<NDIM_IN_DIM ) break; 00931 if( aOutputPackMode8Bit ){ 00932 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00933 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 00934 } 00935 } 00936 else{ 00937 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00938 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 00939 } 00940 } 00941 } 00942 } 00943 00944 if( --LineCount ){ 00945 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 00946 inputData[jj] += inputDataRowOffset; 00947 } 00948 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 00949 outputData[jj] += outputDataRowOffset; 00950 } 00951 } 00952 } 00953 } 00954 00955 /* UNLOCK_DATA( aElutHdle ); */ 00956 /* UNLOCK_DATA( aAlutHdle ); */ 00957 /* UNLOCK_DATA( aXlutHdle ); */ 00958 00959 LH_END_PROC("Calc323Dim_Data8To8_Lut16") 00960 return noErr; 00961 } 00962 00963 #undef NDIM_IN_DIM 00964 #undef NDIM_OUT_DIM 00965 #undef aElutShift 00966 #undef aElutShiftNum 00967 #define NDIM_IN_DIM 3 00968 #define NDIM_OUT_DIM 4 00969 #define aElutShift (16-adr_breite_elut) 00970 #define aElutShiftNum (1<<aElutShift) 00971 00972 CMError Calc324Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 00973 CMLutParamPtr lutParam) 00974 00975 { 00976 LH_UINT8 * inputData[8], *outputData[8]; 00977 UINT32 OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount; 00978 register unsigned long adr0; 00979 register unsigned long ko0; 00980 unsigned long accu[8]; 00981 register long i; 00982 /*long Offsets[8];*/ 00983 00984 register long aAlutShift,aElutOffset,aAlutOffset; 00985 register long aElutWordSize; 00986 register long aAlutWordSize; 00987 register long aXlutAdrSize; 00988 register long aXlutAdrShift; 00989 register unsigned long aXlutWordSize; 00990 register unsigned long ii,jj; 00991 register long aOutputPackMode8Bit; 00992 LH_UINT16 ein_Cache[8]; 00993 00994 LH_UINT16 * aus_lut = (LH_UINT16*)lutParam->outputLut; 00995 LH_UINT16 * ein_lut = (LH_UINT16*)lutParam->inputLut; 00996 LH_UINT16 * Xlut = (LH_UINT16*)lutParam->colorLut; 00997 00998 #ifdef DEBUG_OUTPUT 00999 long err = noErr; 01000 #endif 01001 LH_START_PROC("Calc324Dim_Data8To8_Lut16") 01002 01003 inputData[0] = (LH_UINT8 *)calcParam->inputData[0]; 01004 inputData[1] = (LH_UINT8 *)calcParam->inputData[1]; 01005 inputData[2] = (LH_UINT8 *)calcParam->inputData[2]; 01006 #if NDIM_IN_DIM == 4 01007 inputData[3] = (LH_UINT8 *)calcParam->inputData[3]; 01008 #endif 01009 outputData[0] = (LH_UINT8 *)calcParam->outputData[0]; 01010 outputData[1] = (LH_UINT8 *)calcParam->outputData[1]; 01011 outputData[2] = (LH_UINT8 *)calcParam->outputData[2]; 01012 #if NDIM_OUT_DIM == 4 01013 outputData[3] = (LH_UINT8 *)calcParam->outputData[3]; 01014 #endif 01015 01016 OutputIncrement = calcParam->cmOutputPixelOffset; 01017 inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + (NDIM_IN_DIM * 2); 01018 outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement; 01019 01020 Pixelcount = calcParam->cmPixelPerLine; 01021 LineCount = calcParam->cmLineCount; 01022 01023 aElutWordSize = lutParam->inputLutWordSize; 01024 aAlutWordSize = lutParam->outputLutWordSize; 01025 aXlutAdrSize = lutParam->colorLutGridPoints; 01026 for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++) 01027 aXlutAdrShift = i; 01028 aXlutWordSize = lutParam->colorLutWordSize; 01029 01030 aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking; 01031 /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/ 01032 #if FARBR_FILES 01033 WriteLuts( "DoNDim",1,adr_bereich_elut,aElutWordSize,ein_lut, 01034 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,adr_bereich_alut,aAlutWordSize,(LH_UINT16 *)aus_lut); 01035 #endif 01036 01037 i=0; 01038 01039 { 01040 if( aElutShift < 0 ) 01041 { 01042 #ifdef DEBUG_OUTPUT 01043 DebugPrint("� DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift); 01044 #endif 01045 return cmparamErr; 01046 } 01047 } 01048 01049 if( aOutputPackMode8Bit ){ 01050 aAlutShift = (aAlutWordSize-8); 01051 } 01052 else{ 01053 aAlutShift = (16 - aAlutWordSize); 01054 } 01055 01056 #ifdef DEBUG_OUTPUT 01057 if ( DebugCheck(kThisFile, kDebugReserved1) ){ 01058 DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n", 01059 adr_bereich_elut,adr_breite_elut,aElutWordSize,ein_lut); 01060 DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n", 01061 adr_bereich_alut,adr_breite_alut,aAlutWordSize,aus_lut); 01062 DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n", 01063 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut); 01064 } 01065 #endif 01066 01067 /*if( 1 )*/ 01068 if( aXlutAdrSize != (1<<aXlutAdrShift )){ 01069 register long aXlutOffset; 01070 long theXlutOffsets[8]; 01071 register unsigned long aAlutInShift; 01072 register long aAlutInShiftRemainder; 01073 register unsigned long aAlutInShiftNum; 01074 register long aElutWordSizeMask = (1<<aElutWordSize) - 1; 01075 register unsigned long aAlutRound; 01076 aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut; 01077 aAlutInShiftRemainder = 0; 01078 if( aAlutInShift > 16 ){ 01079 aAlutInShiftRemainder = aAlutInShift - 16; 01080 aAlutInShift = 16; 01081 } 01082 aAlutInShiftNum = (1<<aAlutInShift); 01083 01084 #ifdef DEBUG_OUTPUT 01085 if ( DebugCheck(kThisFile, kDebugMiscInfo) ) 01086 DebugPrint(" DoNDim gripoints = %ld\n",aXlutAdrSize); 01087 #endif 01088 if( aElutWordSize <= 0 ){ 01089 #ifdef DEBUG_OUTPUT 01090 DebugPrint("� DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize); 01091 #endif 01092 return cmparamErr; 01093 } 01094 if( aAlutInShift <= 0 ){ 01095 #ifdef DEBUG_OUTPUT 01096 DebugPrint("� DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift); 01097 #endif 01098 return cmparamErr; 01099 } 01100 aXlutOffset =NDIM_OUT_DIM; 01101 for( i=0; i<(long)NDIM_IN_DIM; i++){ 01102 theXlutOffsets[ NDIM_IN_DIM-1-i] = aXlutOffset; 01103 aXlutOffset *=aXlutAdrSize; 01104 } 01105 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 01106 01107 #ifdef DEBUG_OUTPUT 01108 if ( DebugCheck(kThisFile, kDebugReserved1) ) 01109 DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(adr_bereich_alut/2))/adr_bereich_alut = %ld\n",aElutWordSize,aAlutInShift); 01110 #endif 01111 01112 while (LineCount){ 01113 i = Pixelcount; 01114 01115 while (i){ 01116 01117 long adr[8],Index[8]; 01118 LH_UINT16 ein_reg[8]; 01119 register unsigned long adrAdr,ko,adrOffset; 01120 01121 adr0=0; 01122 aElutOffset = 0; 01123 jj=0; 01124 01125 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 01126 ko0 = jj - ( jj >> ( adr_breite_elut )); 01127 ko = ko0 & ( aElutShiftNum - 1 ); 01128 ko0 = ko0 >> aElutShift; 01129 ko0 += aElutOffset; 01130 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01131 01132 jj *= aXlutAdrSize; 01133 aElutOffset += adr_bereich_elut; 01134 adr[0] = jj & aElutWordSizeMask; 01135 jj = jj >> aElutWordSize; 01136 adr0 += (jj)*theXlutOffsets[0]; 01137 ein_reg[0] = (LH_UINT16)jj; 01138 01139 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 01140 ko0 = jj - ( jj >> ( adr_breite_elut )); 01141 ko = ko0 & ( aElutShiftNum - 1 ); 01142 ko0 = ko0 >> aElutShift; 01143 ko0 += aElutOffset; 01144 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01145 01146 jj *= aXlutAdrSize; 01147 aElutOffset += adr_bereich_elut; 01148 adr[1] = jj & aElutWordSizeMask; 01149 jj = jj >> aElutWordSize; 01150 adr0 += (jj)*theXlutOffsets[1]; 01151 ein_reg[1] = (LH_UINT16)jj; 01152 01153 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 01154 ko0 = jj - ( jj >> ( adr_breite_elut )); 01155 ko = ko0 & ( aElutShiftNum - 1 ); 01156 ko0 = ko0 >> aElutShift; 01157 ko0 += aElutOffset; 01158 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01159 01160 jj *= aXlutAdrSize; 01161 aElutOffset += adr_bereich_elut; 01162 adr[2] = jj & aElutWordSizeMask; 01163 jj = jj >> aElutWordSize; 01164 adr0 += (jj)*theXlutOffsets[2]; 01165 ein_reg[2] = (LH_UINT16)jj; 01166 01167 #if NDIM_IN_DIM == 4 01168 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 01169 ko0 = jj - ( jj >> ( adr_breite_elut )); 01170 ko = ko0 & ( aElutShiftNum - 1 ); 01171 ko0 = ko0 >> aElutShift; 01172 ko0 += aElutOffset; 01173 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01174 01175 jj *= aXlutAdrSize; 01176 aElutOffset += adr_bereich_elut; 01177 adr[3] = jj & aElutWordSizeMask; 01178 jj = jj >> aElutWordSize; 01179 adr0 += (jj)*theXlutOffsets[3]; 01180 ein_reg[3] = (LH_UINT16)jj; 01181 #endif 01182 01183 01184 01185 { /* a kind of */ 01186 register long Hold; 01187 01188 01189 Index[0] = 0; 01190 Index[1] = 1; 01191 Index[2] = 2; 01192 #if NDIM_IN_DIM == 4 01193 Index[3] = 3; 01194 #endif 01195 if( adr[0] < adr[1] ){ 01196 Hold = Index[0]; 01197 Index[0] = Index[1]; 01198 Index[1] = Hold; 01199 } 01200 01201 if( adr[Index[1]] < adr[2] ){ 01202 Hold = Index[1]; 01203 Index[1] = Index[2]; 01204 Index[2] = Hold; 01205 if( adr[Index[0]] < adr[Index[1]] ){ 01206 Hold = Index[0]; 01207 Index[0] = Index[1]; 01208 Index[1] = Hold; 01209 } 01210 } 01211 01212 #if NDIM_IN_DIM == 4 01213 if( adr[Index[2]] < adr[3] ){ 01214 Hold = Index[2]; 01215 Index[2] = Index[3]; 01216 Index[3] = Hold; 01217 if( adr[Index[1]] < adr[Index[2]] ){ 01218 Hold = Index[1]; 01219 Index[1] = Index[2]; 01220 Index[2] = Hold; 01221 if( adr[Index[0]] < adr[Index[1]] ){ 01222 Hold = Index[0]; 01223 Index[0] = Index[1]; 01224 Index[1] = Hold; 01225 } 01226 } 01227 } 01228 #endif 01229 } 01230 01231 accu[0]=0; 01232 accu[1]=0; 01233 accu[2]=0; 01234 #if NDIM_OUT_DIM == 4 01235 accu[3]=0; 01236 #endif 01237 ko0 = (1<<aElutWordSize); 01238 adrAdr=adr0; 01239 adrOffset=0; 01240 if( aXlutWordSize == 16 ){ 01241 jj = Index[0]; 01242 ko = ko0 - adr[jj]; 01243 ko0 = adr[jj]; 01244 01245 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01246 adrOffset += theXlutOffsets[jj]; 01247 01248 accu[0]+=Xlut[adrAdr+(0)]*ko; 01249 accu[1]+=Xlut[adrAdr+(1)]*ko; 01250 accu[2]+=Xlut[adrAdr+(2)]*ko; 01251 #if NDIM_OUT_DIM == 4 01252 accu[3]+=Xlut[adrAdr+(3)]*ko; 01253 #endif 01254 01255 adrAdr = (adr0 + adrOffset); 01256 01257 jj = Index[1]; 01258 ko = ko0 - adr[jj]; 01259 ko0 = adr[jj]; 01260 01261 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01262 adrOffset += theXlutOffsets[jj]; 01263 01264 accu[0]+=Xlut[adrAdr+(0)]*ko; 01265 accu[1]+=Xlut[adrAdr+(1)]*ko; 01266 accu[2]+=Xlut[adrAdr+(2)]*ko; 01267 #if NDIM_OUT_DIM == 4 01268 accu[3]+=Xlut[adrAdr+(3)]*ko; 01269 #endif 01270 01271 adrAdr = (adr0 + adrOffset); 01272 01273 jj = Index[2]; 01274 ko = ko0 - adr[jj]; 01275 ko0 = adr[jj]; 01276 01277 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01278 adrOffset += theXlutOffsets[jj]; 01279 01280 accu[0]+=Xlut[adrAdr+(0)]*ko; 01281 accu[1]+=Xlut[adrAdr+(1)]*ko; 01282 accu[2]+=Xlut[adrAdr+(2)]*ko; 01283 #if NDIM_OUT_DIM == 4 01284 accu[3]+=Xlut[adrAdr+(3)]*ko; 01285 #endif 01286 01287 adrAdr = (adr0 + adrOffset); 01288 01289 #if NDIM_IN_DIM == 4 01290 jj = Index[3]; 01291 ko = ko0 - adr[jj]; 01292 ko0 = adr[jj]; 01293 01294 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01295 adrOffset += theXlutOffsets[jj]; 01296 01297 accu[0]+=Xlut[adrAdr+(0)]*ko; 01298 accu[1]+=Xlut[adrAdr+(1)]*ko; 01299 accu[2]+=Xlut[adrAdr+(2)]*ko; 01300 #if NDIM_OUT_DIM == 4 01301 accu[3]+=Xlut[adrAdr+(3)]*ko; 01302 #endif 01303 01304 adrAdr = (adr0 + adrOffset); 01305 #endif 01306 01307 accu[0]+=Xlut[adrAdr+0]*ko0; 01308 accu[1]+=Xlut[adrAdr+1]*ko0; 01309 accu[2]+=Xlut[adrAdr+2]*ko0; 01310 #if NDIM_OUT_DIM == 4 01311 accu[3]+=Xlut[adrAdr+3]*ko0; 01312 #endif 01313 } 01314 else{ 01315 01316 jj = Index[0]; 01317 ko = ko0 - adr[jj]; 01318 ko0 = adr[jj]; 01319 01320 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01321 adrOffset += theXlutOffsets[jj]; 01322 01323 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01324 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01325 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01326 #if NDIM_OUT_DIM == 4 01327 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01328 #endif 01329 adrAdr = (adr0 + adrOffset); 01330 01331 jj = Index[1]; 01332 ko = ko0 - adr[jj]; 01333 ko0 = adr[jj]; 01334 01335 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01336 adrOffset += theXlutOffsets[jj]; 01337 01338 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01339 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01340 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01341 #if NDIM_OUT_DIM == 4 01342 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01343 #endif 01344 adrAdr = (adr0 + adrOffset); 01345 01346 jj = Index[2]; 01347 ko = ko0 - adr[jj]; 01348 ko0 = adr[jj]; 01349 01350 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01351 adrOffset += theXlutOffsets[jj]; 01352 01353 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01354 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01355 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01356 #if NDIM_OUT_DIM == 4 01357 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01358 #endif 01359 adrAdr = (adr0 + adrOffset); 01360 01361 #if NDIM_IN_DIM == 4 01362 jj = Index[3]; 01363 ko = ko0 - adr[jj]; 01364 ko0 = adr[jj]; 01365 01366 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 01367 adrOffset += theXlutOffsets[jj]; 01368 01369 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01370 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01371 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01372 #if NDIM_OUT_DIM == 4 01373 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01374 #endif 01375 adrAdr = (adr0 + adrOffset); 01376 #endif 01377 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 01378 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 01379 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 01380 #if NDIM_OUT_DIM == 4 01381 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 01382 #endif 01383 } 01384 01385 aAlutOffset = 0; 01386 01387 if( aOutputPackMode8Bit ){ 01388 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 01389 jj = accu[ii]; 01390 jj = jj + ( jj >> aXlutWordSize ); 01391 01392 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 01393 01394 ko = ko0 & (aAlutInShiftNum - 1 ); 01395 ko0 = ko0 >> aAlutInShift; 01396 ko0 += aAlutOffset; 01397 if( aAlutWordSize <= 8) 01398 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 01399 else{ 01400 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 01401 jj = jj - ( jj >> aAlutShift ); 01402 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 01403 } 01404 *outputData[ii] = (LH_UINT8)jj; 01405 aAlutOffset += adr_bereich_alut; 01406 } 01407 } 01408 else{ 01409 if( aXlutWordSize >= 16 ){ 01410 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 01411 jj = accu[ii]; 01412 jj = jj + ( jj >> aXlutWordSize ); 01413 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 01414 01415 ko = ko0 & (aAlutInShiftNum - 1 ); 01416 ko0 = ko0 >> aAlutInShift; 01417 ko0 += aAlutOffset; 01418 if( aAlutWordSize <= 8) 01419 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 01420 else 01421 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 01422 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 01423 aAlutOffset += adr_bereich_alut; 01424 } 01425 } 01426 else{ 01427 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 01428 jj = accu[ii]; 01429 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 01430 ko0 = (jj - ( jj >> ( adr_breite_alut ))) ; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 01431 01432 ko = ko0 & (aAlutInShiftNum - 1 ); 01433 ko0 = ko0 >> aAlutInShift; 01434 ko0 += aAlutOffset; 01435 if( aAlutWordSize <= 8) 01436 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 01437 else 01438 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 01439 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 01440 aAlutOffset += adr_bereich_alut; 01441 } 01442 } 01443 } 01444 while (--i){ 01445 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 01446 inputData[jj] += (NDIM_IN_DIM * 2); 01447 } 01448 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01449 outputData[jj] += OutputIncrement; 01450 } 01451 01452 { 01453 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 01454 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 01455 } 01456 } 01457 if( jj<NDIM_IN_DIM ) break; 01458 if( aOutputPackMode8Bit ){ 01459 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01460 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 01461 } 01462 } 01463 else{ 01464 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01465 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 01466 } 01467 } 01468 } 01469 } 01470 01471 if( --LineCount ){ 01472 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 01473 inputData[jj] += inputDataRowOffset; 01474 } 01475 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01476 outputData[jj] += outputDataRowOffset; 01477 } 01478 } 01479 } 01480 } 01481 else{ 01482 01483 register unsigned long bit_breit_selektor; 01484 register unsigned long bit_maske_selektor; 01485 register unsigned long bit_breit_adr; 01486 register unsigned long bit_maske_adr; 01487 register unsigned long aAlutInShiftNum; 01488 register long aAlutInShift; 01489 register long aAlutInShiftRemainder; 01490 register unsigned long aAlutRound; 01491 /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/ 01492 bit_breit_selektor=aElutWordSize-aXlutAdrShift; 01493 if( aElutWordSize-aXlutAdrShift < 0 ) 01494 { 01495 #ifdef DEBUG_OUTPUT 01496 DebugPrint("� DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor); 01497 #endif 01498 return cmparamErr; 01499 } 01500 bit_maske_selektor=(1<<bit_breit_selektor)-1; 01501 bit_breit_adr=aXlutAdrShift; 01502 bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor; 01503 aAlutInShift = (aXlutWordSize+bit_breit_selektor-adr_breite_alut); 01504 /*aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 01505 aAlutInShiftRemainder = 0; 01506 if( aAlutInShift > 16 ){ 01507 aAlutInShiftRemainder = aAlutInShift - 16; 01508 aAlutInShift = 16; 01509 } 01510 01511 aAlutInShiftNum = (1<<aAlutInShift); 01512 01513 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 01514 while (LineCount){ 01515 i = Pixelcount; 01516 01517 while (i){ 01518 01519 long adr[8],Index[8]; 01520 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/ 01521 LH_UINT16 ein_reg[8]; 01522 register unsigned long adrAdr,ko,adrOffset; 01523 /*register unsigned long aIndex;*/ 01524 01525 adr0=0; 01526 aElutOffset = 0; 01527 jj=0; 01528 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 01529 ko0 = jj - ( jj >> ( adr_breite_elut )); 01530 ko = ko0 & ( aElutShiftNum - 1 ); 01531 ko0 = ko0 >> aElutShift; 01532 ko0 += aElutOffset; 01533 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01534 01535 aElutOffset += adr_bereich_elut; 01536 adr[0] = (jj & bit_maske_selektor); 01537 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-0-1)*bit_breit_adr); 01538 ein_reg[0] = (LH_UINT16)jj; 01539 01540 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 01541 ko0 = jj - ( jj >> ( adr_breite_elut )); 01542 ko = ko0 & ( aElutShiftNum - 1 ); 01543 ko0 = ko0 >> aElutShift; 01544 ko0 += aElutOffset; 01545 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01546 01547 aElutOffset += adr_bereich_elut; 01548 adr[1] = (jj & bit_maske_selektor); 01549 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-1-1)*bit_breit_adr); 01550 ein_reg[1] = (LH_UINT16)jj; 01551 01552 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 01553 ko0 = jj - ( jj >> ( adr_breite_elut )); 01554 ko = ko0 & ( aElutShiftNum - 1 ); 01555 ko0 = ko0 >> aElutShift; 01556 ko0 += aElutOffset; 01557 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01558 01559 aElutOffset += adr_bereich_elut; 01560 adr[2] = (jj & bit_maske_selektor); 01561 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-2-1)*bit_breit_adr); 01562 ein_reg[2] = (LH_UINT16)jj; 01563 01564 #if NDIM_IN_DIM == 4 01565 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 01566 ko0 = jj - ( jj >> ( adr_breite_elut )); 01567 ko = ko0 & ( aElutShiftNum - 1 ); 01568 ko0 = ko0 >> aElutShift; 01569 ko0 += aElutOffset; 01570 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 01571 01572 aElutOffset += adr_bereich_elut; 01573 adr[3] = (jj & bit_maske_selektor); 01574 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-3-1)*bit_breit_adr); 01575 ein_reg[3] = (LH_UINT16)jj; 01576 #endif 01577 adr0 *= NDIM_OUT_DIM; 01578 01579 { /* a kind of */ 01580 register long Hold; 01581 01582 01583 Index[0] = 0; 01584 Index[1] = 1; 01585 Index[2] = 2; 01586 #if NDIM_IN_DIM == 4 01587 Index[3] = 3; 01588 #endif 01589 if( adr[0] < adr[1] ){ 01590 Hold = Index[0]; 01591 Index[0] = Index[1]; 01592 Index[1] = Hold; 01593 } 01594 01595 if( adr[Index[1]] < adr[2] ){ 01596 Hold = Index[1]; 01597 Index[1] = Index[2]; 01598 Index[2] = Hold; 01599 if( adr[Index[0]] < adr[Index[1]] ){ 01600 Hold = Index[0]; 01601 Index[0] = Index[1]; 01602 Index[1] = Hold; 01603 } 01604 } 01605 01606 #if NDIM_IN_DIM == 4 01607 if( adr[Index[2]] < adr[3] ){ 01608 Hold = Index[2]; 01609 Index[2] = Index[3]; 01610 Index[3] = Hold; 01611 if( adr[Index[1]] < adr[Index[2]] ){ 01612 Hold = Index[1]; 01613 Index[1] = Index[2]; 01614 Index[2] = Hold; 01615 if( adr[Index[0]] < adr[Index[1]] ){ 01616 Hold = Index[0]; 01617 Index[0] = Index[1]; 01618 Index[1] = Hold; 01619 } 01620 } 01621 } 01622 #endif 01623 } 01624 01625 accu[0]=0; 01626 accu[1]=0; 01627 accu[2]=0; 01628 #if NDIM_OUT_DIM == 4 01629 accu[3]=0; 01630 #endif 01631 01632 ko0 = bit_maske_selektor+1; 01633 adrAdr=adr0; 01634 adrOffset=0; 01635 01636 if( aXlutWordSize == 16 ){ 01637 jj = Index[0]; 01638 ko = ko0 - adr[jj]; 01639 ko0 = adr[jj]; 01640 01641 if( ein_reg[jj] < bit_maske_adr ) 01642 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01643 01644 accu[0]+=Xlut[adrAdr+(0)]*ko; 01645 accu[1]+=Xlut[adrAdr+(1)]*ko; 01646 accu[2]+=Xlut[adrAdr+(2)]*ko; 01647 #if NDIM_OUT_DIM == 4 01648 accu[3]+=Xlut[adrAdr+(3)]*ko; 01649 #endif 01650 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01651 01652 jj = Index[1]; 01653 ko = ko0 - adr[jj]; 01654 ko0 = adr[jj]; 01655 01656 if( ein_reg[jj] < bit_maske_adr ) 01657 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01658 01659 accu[0]+=Xlut[adrAdr+(0)]*ko; 01660 accu[1]+=Xlut[adrAdr+(1)]*ko; 01661 accu[2]+=Xlut[adrAdr+(2)]*ko; 01662 #if NDIM_OUT_DIM == 4 01663 accu[3]+=Xlut[adrAdr+(3)]*ko; 01664 #endif 01665 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01666 01667 jj = Index[2]; 01668 ko = ko0 - adr[jj]; 01669 ko0 = adr[jj]; 01670 01671 if( ein_reg[jj] < bit_maske_adr ) 01672 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01673 01674 accu[0]+=Xlut[adrAdr+(0)]*ko; 01675 accu[1]+=Xlut[adrAdr+(1)]*ko; 01676 accu[2]+=Xlut[adrAdr+(2)]*ko; 01677 #if NDIM_OUT_DIM == 4 01678 accu[3]+=Xlut[adrAdr+(3)]*ko; 01679 #endif 01680 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01681 01682 #if NDIM_IN_DIM == 4 01683 jj = Index[3]; 01684 ko = ko0 - adr[jj]; 01685 ko0 = adr[jj]; 01686 01687 if( ein_reg[jj] < bit_maske_adr ) 01688 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01689 01690 accu[0]+=Xlut[adrAdr+(0)]*ko; 01691 accu[1]+=Xlut[adrAdr+(1)]*ko; 01692 accu[2]+=Xlut[adrAdr+(2)]*ko; 01693 #if NDIM_OUT_DIM == 4 01694 accu[3]+=Xlut[adrAdr+(3)]*ko; 01695 #endif 01696 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01697 #endif 01698 accu[0]+=Xlut[adrAdr+0]*ko0; 01699 accu[1]+=Xlut[adrAdr+1]*ko0; 01700 accu[2]+=Xlut[adrAdr+2]*ko0; 01701 #if NDIM_OUT_DIM == 4 01702 accu[3]+=Xlut[adrAdr+3]*ko0; 01703 #endif 01704 } 01705 else{ 01706 jj = Index[0]; 01707 ko = ko0 - adr[jj]; 01708 ko0 = adr[jj]; 01709 01710 if( ein_reg[jj] < bit_maske_adr ) 01711 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01712 01713 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01714 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01715 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01716 #if NDIM_OUT_DIM == 4 01717 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01718 #endif 01719 01720 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01721 01722 jj = Index[1]; 01723 ko = ko0 - adr[jj]; 01724 ko0 = adr[jj]; 01725 01726 if( ein_reg[jj] < bit_maske_adr ) 01727 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01728 01729 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01730 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01731 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01732 #if NDIM_OUT_DIM == 4 01733 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01734 #endif 01735 01736 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01737 01738 jj = Index[2]; 01739 ko = ko0 - adr[jj]; 01740 ko0 = adr[jj]; 01741 01742 if( ein_reg[jj] < bit_maske_adr ) 01743 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01744 01745 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01746 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01747 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01748 #if NDIM_OUT_DIM == 4 01749 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01750 #endif 01751 01752 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01753 01754 #if NDIM_IN_DIM == 4 01755 jj = Index[3]; 01756 ko = ko0 - adr[jj]; 01757 ko0 = adr[jj]; 01758 01759 if( ein_reg[jj] < bit_maske_adr ) 01760 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 01761 01762 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 01763 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 01764 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 01765 #if NDIM_OUT_DIM == 4 01766 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 01767 #endif 01768 01769 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 01770 #endif 01771 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 01772 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 01773 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 01774 #if NDIM_OUT_DIM == 4 01775 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 01776 #endif 01777 } 01778 01779 aAlutOffset = 0; 01780 01781 if( aOutputPackMode8Bit ){ 01782 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 01783 jj = accu[ii]; 01784 jj = jj + ( jj >> aXlutWordSize ); 01785 01786 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 01787 01788 ko = ko0 & (aAlutInShiftNum - 1 ); 01789 ko0 = ko0 >> aAlutInShift; 01790 ko0 += aAlutOffset; 01791 if( aAlutWordSize <= 8) 01792 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 01793 else{ 01794 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 01795 jj = jj - ( jj >> aAlutShift ); 01796 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 01797 } 01798 01799 *outputData[ii] = (LH_UINT8)jj; 01800 aAlutOffset += adr_bereich_alut; 01801 } 01802 } 01803 else{ 01804 if( aXlutWordSize >= 16 ){ 01805 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 01806 jj = accu[ii]; 01807 jj = jj + ( jj >> aXlutWordSize ); 01808 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 01809 01810 ko = ko0 & (aAlutInShiftNum - 1 ); 01811 ko0 = ko0 >> aAlutInShift; 01812 ko0 += aAlutOffset; 01813 if( aAlutWordSize <= 8) 01814 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 01815 else 01816 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 01817 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 01818 aAlutOffset += adr_bereich_alut; 01819 } 01820 } 01821 else{ 01822 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 01823 jj = accu[ii]; 01824 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 01825 ko0 = (jj - ( jj >> ( adr_breite_alut ))); /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 01826 01827 ko = ko0 & (aAlutInShiftNum - 1 ); 01828 ko0 = ko0 >> aAlutInShift; 01829 ko0 += aAlutOffset; 01830 if( aAlutWordSize <= 8) 01831 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 01832 else 01833 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 01834 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 01835 aAlutOffset += adr_bereich_alut; 01836 } 01837 } 01838 } 01839 01840 while (--i){ 01841 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 01842 inputData[jj] += (NDIM_IN_DIM * 2); 01843 } 01844 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01845 outputData[jj] += OutputIncrement; 01846 } 01847 01848 { 01849 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 01850 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 01851 } 01852 } 01853 if( jj<NDIM_IN_DIM ) break; 01854 if( aOutputPackMode8Bit ){ 01855 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01856 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 01857 } 01858 } 01859 else{ 01860 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01861 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 01862 } 01863 } 01864 } 01865 } 01866 01867 if( --LineCount ){ 01868 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 01869 inputData[jj] += inputDataRowOffset; 01870 } 01871 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 01872 outputData[jj] += outputDataRowOffset; 01873 } 01874 } 01875 } 01876 } 01877 01878 /* UNLOCK_DATA( aElutHdle ); */ 01879 /* UNLOCK_DATA( aAlutHdle ); */ 01880 /* UNLOCK_DATA( aXlutHdle ); */ 01881 01882 LH_END_PROC("Calc324Dim_Data8To8_Lut16") 01883 return noErr; 01884 } 01885 01886 #undef NDIM_IN_DIM 01887 #undef NDIM_OUT_DIM 01888 #undef aElutShift 01889 #undef aElutShiftNum 01890 #define NDIM_IN_DIM 4 01891 #define NDIM_OUT_DIM 3 01892 #define aElutShift (16-adr_breite_elut) 01893 #define aElutShiftNum (1<<aElutShift) 01894 01895 CMError Calc423Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 01896 CMLutParamPtr lutParam) 01897 01898 { 01899 LH_UINT8 * inputData[8], *outputData[8]; 01900 UINT32 OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount; 01901 register unsigned long adr0; 01902 register unsigned long ko0; 01903 unsigned long accu[8]; 01904 register long i; 01905 /*long Offsets[8];*/ 01906 01907 register long aAlutShift,aElutOffset,aAlutOffset; 01908 register long aElutWordSize; 01909 register long aAlutWordSize; 01910 register long aXlutAdrSize; 01911 register long aXlutAdrShift; 01912 register unsigned long aXlutWordSize; 01913 register unsigned long ii,jj; 01914 register long aOutputPackMode8Bit; 01915 LH_UINT16 ein_Cache[8]; 01916 01917 LH_UINT16 * aus_lut = (LH_UINT16*)lutParam->outputLut; 01918 LH_UINT16 * ein_lut = (LH_UINT16*)lutParam->inputLut; 01919 LH_UINT16 * Xlut = (LH_UINT16*)lutParam->colorLut; 01920 01921 #ifdef DEBUG_OUTPUT 01922 long err = noErr; 01923 #endif 01924 LH_START_PROC("Calc423Dim_Data8To8_Lut16") 01925 01926 inputData[0] = (LH_UINT8 *)calcParam->inputData[0]; 01927 inputData[1] = (LH_UINT8 *)calcParam->inputData[1]; 01928 inputData[2] = (LH_UINT8 *)calcParam->inputData[2]; 01929 #if NDIM_IN_DIM == 4 01930 inputData[3] = (LH_UINT8 *)calcParam->inputData[3]; 01931 #endif 01932 outputData[0] = (LH_UINT8 *)calcParam->outputData[0]; 01933 outputData[1] = (LH_UINT8 *)calcParam->outputData[1]; 01934 outputData[2] = (LH_UINT8 *)calcParam->outputData[2]; 01935 #if NDIM_OUT_DIM == 4 01936 outputData[3] = (LH_UINT8 *)calcParam->outputData[3]; 01937 #endif 01938 01939 OutputIncrement = calcParam->cmOutputPixelOffset; 01940 inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + (NDIM_IN_DIM * 2); 01941 outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement; 01942 01943 Pixelcount = calcParam->cmPixelPerLine; 01944 LineCount = calcParam->cmLineCount; 01945 01946 aElutWordSize = lutParam->inputLutWordSize; 01947 aAlutWordSize = lutParam->outputLutWordSize; 01948 aXlutAdrSize = lutParam->colorLutGridPoints; 01949 for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++) 01950 aXlutAdrShift = i; 01951 aXlutWordSize = lutParam->colorLutWordSize; 01952 01953 aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking; 01954 /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/ 01955 #if FARBR_FILES 01956 WriteLuts( "DoNDim",1,adr_bereich_elut,aElutWordSize,ein_lut, 01957 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,adr_bereich_alut,aAlutWordSize,(LH_UINT16 *)aus_lut); 01958 #endif 01959 01960 i=0; 01961 01962 { 01963 if( aElutShift < 0 ) 01964 { 01965 #ifdef DEBUG_OUTPUT 01966 DebugPrint("� DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift); 01967 #endif 01968 return cmparamErr; 01969 } 01970 } 01971 01972 if( aOutputPackMode8Bit ){ 01973 aAlutShift = (aAlutWordSize-8); 01974 } 01975 else{ 01976 aAlutShift = (16 - aAlutWordSize); 01977 } 01978 01979 #ifdef DEBUG_OUTPUT 01980 if ( DebugCheck(kThisFile, kDebugReserved1) ){ 01981 DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n", 01982 adr_bereich_elut,adr_breite_elut,aElutWordSize,ein_lut); 01983 DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n", 01984 adr_bereich_alut,adr_breite_alut,aAlutWordSize,aus_lut); 01985 DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n", 01986 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut); 01987 } 01988 #endif 01989 01990 /*if( 1 )*/ 01991 if( aXlutAdrSize != (1<<aXlutAdrShift )){ 01992 register long aXlutOffset; 01993 long theXlutOffsets[8]; 01994 register unsigned long aAlutInShift; 01995 register long aAlutInShiftRemainder; 01996 register unsigned long aAlutInShiftNum; 01997 register long aElutWordSizeMask = (1<<aElutWordSize) - 1; 01998 register unsigned long aAlutRound; 01999 aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut; 02000 aAlutInShiftRemainder = 0; 02001 if( aAlutInShift > 16 ){ 02002 aAlutInShiftRemainder = aAlutInShift - 16; 02003 aAlutInShift = 16; 02004 } 02005 aAlutInShiftNum = (1<<aAlutInShift); 02006 02007 #ifdef DEBUG_OUTPUT 02008 if ( DebugCheck(kThisFile, kDebugMiscInfo) ) 02009 DebugPrint(" DoNDim gripoints = %ld\n",aXlutAdrSize); 02010 #endif 02011 if( aElutWordSize <= 0 ){ 02012 #ifdef DEBUG_OUTPUT 02013 DebugPrint("� DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize); 02014 #endif 02015 return cmparamErr; 02016 } 02017 if( aAlutInShift <= 0 ){ 02018 #ifdef DEBUG_OUTPUT 02019 DebugPrint("� DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift); 02020 #endif 02021 return cmparamErr; 02022 } 02023 aXlutOffset =NDIM_OUT_DIM; 02024 for( i=0; i<(long)NDIM_IN_DIM; i++){ 02025 theXlutOffsets[ NDIM_IN_DIM-1-i] = aXlutOffset; 02026 aXlutOffset *=aXlutAdrSize; 02027 } 02028 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 02029 02030 #ifdef DEBUG_OUTPUT 02031 if ( DebugCheck(kThisFile, kDebugReserved1) ) 02032 DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(adr_bereich_alut/2))/adr_bereich_alut = %ld\n",aElutWordSize,aAlutInShift); 02033 #endif 02034 02035 while (LineCount){ 02036 i = Pixelcount; 02037 02038 while (i){ 02039 02040 long adr[8],Index[8]; 02041 LH_UINT16 ein_reg[8]; 02042 register unsigned long adrAdr,ko,adrOffset; 02043 02044 adr0=0; 02045 aElutOffset = 0; 02046 jj=0; 02047 02048 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 02049 ko0 = jj - ( jj >> ( adr_breite_elut )); 02050 ko = ko0 & ( aElutShiftNum - 1 ); 02051 ko0 = ko0 >> aElutShift; 02052 ko0 += aElutOffset; 02053 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02054 02055 jj *= aXlutAdrSize; 02056 aElutOffset += adr_bereich_elut; 02057 adr[0] = jj & aElutWordSizeMask; 02058 jj = jj >> aElutWordSize; 02059 adr0 += (jj)*theXlutOffsets[0]; 02060 ein_reg[0] = (LH_UINT16)jj; 02061 02062 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 02063 ko0 = jj - ( jj >> ( adr_breite_elut )); 02064 ko = ko0 & ( aElutShiftNum - 1 ); 02065 ko0 = ko0 >> aElutShift; 02066 ko0 += aElutOffset; 02067 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02068 02069 jj *= aXlutAdrSize; 02070 aElutOffset += adr_bereich_elut; 02071 adr[1] = jj & aElutWordSizeMask; 02072 jj = jj >> aElutWordSize; 02073 adr0 += (jj)*theXlutOffsets[1]; 02074 ein_reg[1] = (LH_UINT16)jj; 02075 02076 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 02077 ko0 = jj - ( jj >> ( adr_breite_elut )); 02078 ko = ko0 & ( aElutShiftNum - 1 ); 02079 ko0 = ko0 >> aElutShift; 02080 ko0 += aElutOffset; 02081 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02082 02083 jj *= aXlutAdrSize; 02084 aElutOffset += adr_bereich_elut; 02085 adr[2] = jj & aElutWordSizeMask; 02086 jj = jj >> aElutWordSize; 02087 adr0 += (jj)*theXlutOffsets[2]; 02088 ein_reg[2] = (LH_UINT16)jj; 02089 02090 #if NDIM_IN_DIM == 4 02091 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 02092 ko0 = jj - ( jj >> ( adr_breite_elut )); 02093 ko = ko0 & ( aElutShiftNum - 1 ); 02094 ko0 = ko0 >> aElutShift; 02095 ko0 += aElutOffset; 02096 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02097 02098 jj *= aXlutAdrSize; 02099 aElutOffset += adr_bereich_elut; 02100 adr[3] = jj & aElutWordSizeMask; 02101 jj = jj >> aElutWordSize; 02102 adr0 += (jj)*theXlutOffsets[3]; 02103 ein_reg[3] = (LH_UINT16)jj; 02104 #endif 02105 02106 02107 02108 { /* a kind of */ 02109 register long Hold; 02110 02111 02112 Index[0] = 0; 02113 Index[1] = 1; 02114 Index[2] = 2; 02115 #if NDIM_IN_DIM == 4 02116 Index[3] = 3; 02117 #endif 02118 if( adr[0] < adr[1] ){ 02119 Hold = Index[0]; 02120 Index[0] = Index[1]; 02121 Index[1] = Hold; 02122 } 02123 02124 if( adr[Index[1]] < adr[2] ){ 02125 Hold = Index[1]; 02126 Index[1] = Index[2]; 02127 Index[2] = Hold; 02128 if( adr[Index[0]] < adr[Index[1]] ){ 02129 Hold = Index[0]; 02130 Index[0] = Index[1]; 02131 Index[1] = Hold; 02132 } 02133 } 02134 02135 #if NDIM_IN_DIM == 4 02136 if( adr[Index[2]] < adr[3] ){ 02137 Hold = Index[2]; 02138 Index[2] = Index[3]; 02139 Index[3] = Hold; 02140 if( adr[Index[1]] < adr[Index[2]] ){ 02141 Hold = Index[1]; 02142 Index[1] = Index[2]; 02143 Index[2] = Hold; 02144 if( adr[Index[0]] < adr[Index[1]] ){ 02145 Hold = Index[0]; 02146 Index[0] = Index[1]; 02147 Index[1] = Hold; 02148 } 02149 } 02150 } 02151 #endif 02152 } 02153 02154 accu[0]=0; 02155 accu[1]=0; 02156 accu[2]=0; 02157 #if NDIM_OUT_DIM == 4 02158 accu[3]=0; 02159 #endif 02160 ko0 = (1<<aElutWordSize); 02161 adrAdr=adr0; 02162 adrOffset=0; 02163 if( aXlutWordSize == 16 ){ 02164 jj = Index[0]; 02165 ko = ko0 - adr[jj]; 02166 ko0 = adr[jj]; 02167 02168 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02169 adrOffset += theXlutOffsets[jj]; 02170 02171 accu[0]+=Xlut[adrAdr+(0)]*ko; 02172 accu[1]+=Xlut[adrAdr+(1)]*ko; 02173 accu[2]+=Xlut[adrAdr+(2)]*ko; 02174 #if NDIM_OUT_DIM == 4 02175 accu[3]+=Xlut[adrAdr+(3)]*ko; 02176 #endif 02177 02178 adrAdr = (adr0 + adrOffset); 02179 02180 jj = Index[1]; 02181 ko = ko0 - adr[jj]; 02182 ko0 = adr[jj]; 02183 02184 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02185 adrOffset += theXlutOffsets[jj]; 02186 02187 accu[0]+=Xlut[adrAdr+(0)]*ko; 02188 accu[1]+=Xlut[adrAdr+(1)]*ko; 02189 accu[2]+=Xlut[adrAdr+(2)]*ko; 02190 #if NDIM_OUT_DIM == 4 02191 accu[3]+=Xlut[adrAdr+(3)]*ko; 02192 #endif 02193 02194 adrAdr = (adr0 + adrOffset); 02195 02196 jj = Index[2]; 02197 ko = ko0 - adr[jj]; 02198 ko0 = adr[jj]; 02199 02200 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02201 adrOffset += theXlutOffsets[jj]; 02202 02203 accu[0]+=Xlut[adrAdr+(0)]*ko; 02204 accu[1]+=Xlut[adrAdr+(1)]*ko; 02205 accu[2]+=Xlut[adrAdr+(2)]*ko; 02206 #if NDIM_OUT_DIM == 4 02207 accu[3]+=Xlut[adrAdr+(3)]*ko; 02208 #endif 02209 02210 adrAdr = (adr0 + adrOffset); 02211 02212 #if NDIM_IN_DIM == 4 02213 jj = Index[3]; 02214 ko = ko0 - adr[jj]; 02215 ko0 = adr[jj]; 02216 02217 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02218 adrOffset += theXlutOffsets[jj]; 02219 02220 accu[0]+=Xlut[adrAdr+(0)]*ko; 02221 accu[1]+=Xlut[adrAdr+(1)]*ko; 02222 accu[2]+=Xlut[adrAdr+(2)]*ko; 02223 #if NDIM_OUT_DIM == 4 02224 accu[3]+=Xlut[adrAdr+(3)]*ko; 02225 #endif 02226 02227 adrAdr = (adr0 + adrOffset); 02228 #endif 02229 02230 accu[0]+=Xlut[adrAdr+0]*ko0; 02231 accu[1]+=Xlut[adrAdr+1]*ko0; 02232 accu[2]+=Xlut[adrAdr+2]*ko0; 02233 #if NDIM_OUT_DIM == 4 02234 accu[3]+=Xlut[adrAdr+3]*ko0; 02235 #endif 02236 } 02237 else{ 02238 02239 jj = Index[0]; 02240 ko = ko0 - adr[jj]; 02241 ko0 = adr[jj]; 02242 02243 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02244 adrOffset += theXlutOffsets[jj]; 02245 02246 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02247 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02248 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02249 #if NDIM_OUT_DIM == 4 02250 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02251 #endif 02252 adrAdr = (adr0 + adrOffset); 02253 02254 jj = Index[1]; 02255 ko = ko0 - adr[jj]; 02256 ko0 = adr[jj]; 02257 02258 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02259 adrOffset += theXlutOffsets[jj]; 02260 02261 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02262 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02263 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02264 #if NDIM_OUT_DIM == 4 02265 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02266 #endif 02267 adrAdr = (adr0 + adrOffset); 02268 02269 jj = Index[2]; 02270 ko = ko0 - adr[jj]; 02271 ko0 = adr[jj]; 02272 02273 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02274 adrOffset += theXlutOffsets[jj]; 02275 02276 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02277 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02278 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02279 #if NDIM_OUT_DIM == 4 02280 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02281 #endif 02282 adrAdr = (adr0 + adrOffset); 02283 02284 #if NDIM_IN_DIM == 4 02285 jj = Index[3]; 02286 ko = ko0 - adr[jj]; 02287 ko0 = adr[jj]; 02288 02289 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 02290 adrOffset += theXlutOffsets[jj]; 02291 02292 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02293 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02294 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02295 #if NDIM_OUT_DIM == 4 02296 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02297 #endif 02298 adrAdr = (adr0 + adrOffset); 02299 #endif 02300 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 02301 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 02302 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 02303 #if NDIM_OUT_DIM == 4 02304 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 02305 #endif 02306 } 02307 02308 aAlutOffset = 0; 02309 02310 if( aOutputPackMode8Bit ){ 02311 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 02312 jj = accu[ii]; 02313 jj = jj + ( jj >> aXlutWordSize ); 02314 02315 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 02316 02317 ko = ko0 & (aAlutInShiftNum - 1 ); 02318 ko0 = ko0 >> aAlutInShift; 02319 ko0 += aAlutOffset; 02320 if( aAlutWordSize <= 8) 02321 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 02322 else{ 02323 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 02324 jj = jj - ( jj >> aAlutShift ); 02325 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 02326 } 02327 *outputData[ii] = (LH_UINT8)jj; 02328 aAlutOffset += adr_bereich_alut; 02329 } 02330 } 02331 else{ 02332 if( aXlutWordSize >= 16 ){ 02333 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 02334 jj = accu[ii]; 02335 jj = jj + ( jj >> aXlutWordSize ); 02336 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 02337 02338 ko = ko0 & (aAlutInShiftNum - 1 ); 02339 ko0 = ko0 >> aAlutInShift; 02340 ko0 += aAlutOffset; 02341 if( aAlutWordSize <= 8) 02342 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 02343 else 02344 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 02345 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 02346 aAlutOffset += adr_bereich_alut; 02347 } 02348 } 02349 else{ 02350 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 02351 jj = accu[ii]; 02352 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 02353 ko0 = (jj - ( jj >> ( adr_breite_alut ))) ; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 02354 02355 ko = ko0 & (aAlutInShiftNum - 1 ); 02356 ko0 = ko0 >> aAlutInShift; 02357 ko0 += aAlutOffset; 02358 if( aAlutWordSize <= 8) 02359 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 02360 else 02361 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 02362 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 02363 aAlutOffset += adr_bereich_alut; 02364 } 02365 } 02366 } 02367 while (--i){ 02368 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 02369 inputData[jj] += (NDIM_IN_DIM * 2); 02370 } 02371 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02372 outputData[jj] += OutputIncrement; 02373 } 02374 02375 { 02376 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 02377 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 02378 } 02379 } 02380 if( jj<NDIM_IN_DIM ) break; 02381 if( aOutputPackMode8Bit ){ 02382 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02383 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 02384 } 02385 } 02386 else{ 02387 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02388 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 02389 } 02390 } 02391 } 02392 } 02393 02394 if( --LineCount ){ 02395 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 02396 inputData[jj] += inputDataRowOffset; 02397 } 02398 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02399 outputData[jj] += outputDataRowOffset; 02400 } 02401 } 02402 } 02403 } 02404 else{ 02405 02406 register unsigned long bit_breit_selektor; 02407 register unsigned long bit_maske_selektor; 02408 register unsigned long bit_breit_adr; 02409 register unsigned long bit_maske_adr; 02410 register unsigned long aAlutInShiftNum; 02411 register long aAlutInShift; 02412 register long aAlutInShiftRemainder; 02413 register unsigned long aAlutRound; 02414 /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/ 02415 bit_breit_selektor=aElutWordSize-aXlutAdrShift; 02416 if( aElutWordSize-aXlutAdrShift < 0 ) 02417 { 02418 #ifdef DEBUG_OUTPUT 02419 DebugPrint("� DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor); 02420 #endif 02421 return cmparamErr; 02422 } 02423 bit_maske_selektor=(1<<bit_breit_selektor)-1; 02424 bit_breit_adr=aXlutAdrShift; 02425 bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor; 02426 aAlutInShift = (aXlutWordSize+bit_breit_selektor-adr_breite_alut); 02427 /*aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 02428 aAlutInShiftRemainder = 0; 02429 if( aAlutInShift > 16 ){ 02430 aAlutInShiftRemainder = aAlutInShift - 16; 02431 aAlutInShift = 16; 02432 } 02433 02434 aAlutInShiftNum = (1<<aAlutInShift); 02435 02436 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 02437 while (LineCount){ 02438 i = Pixelcount; 02439 02440 while (i){ 02441 02442 long adr[8],Index[8]; 02443 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/ 02444 LH_UINT16 ein_reg[8]; 02445 register unsigned long adrAdr,ko,adrOffset; 02446 /*register unsigned long aIndex;*/ 02447 02448 adr0=0; 02449 aElutOffset = 0; 02450 jj=0; 02451 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 02452 ko0 = jj - ( jj >> ( adr_breite_elut )); 02453 ko = ko0 & ( aElutShiftNum - 1 ); 02454 ko0 = ko0 >> aElutShift; 02455 ko0 += aElutOffset; 02456 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02457 02458 aElutOffset += adr_bereich_elut; 02459 adr[0] = (jj & bit_maske_selektor); 02460 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-0-1)*bit_breit_adr); 02461 ein_reg[0] = (LH_UINT16)jj; 02462 02463 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 02464 ko0 = jj - ( jj >> ( adr_breite_elut )); 02465 ko = ko0 & ( aElutShiftNum - 1 ); 02466 ko0 = ko0 >> aElutShift; 02467 ko0 += aElutOffset; 02468 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02469 02470 aElutOffset += adr_bereich_elut; 02471 adr[1] = (jj & bit_maske_selektor); 02472 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-1-1)*bit_breit_adr); 02473 ein_reg[1] = (LH_UINT16)jj; 02474 02475 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 02476 ko0 = jj - ( jj >> ( adr_breite_elut )); 02477 ko = ko0 & ( aElutShiftNum - 1 ); 02478 ko0 = ko0 >> aElutShift; 02479 ko0 += aElutOffset; 02480 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02481 02482 aElutOffset += adr_bereich_elut; 02483 adr[2] = (jj & bit_maske_selektor); 02484 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-2-1)*bit_breit_adr); 02485 ein_reg[2] = (LH_UINT16)jj; 02486 02487 #if NDIM_IN_DIM == 4 02488 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 02489 ko0 = jj - ( jj >> ( adr_breite_elut )); 02490 ko = ko0 & ( aElutShiftNum - 1 ); 02491 ko0 = ko0 >> aElutShift; 02492 ko0 += aElutOffset; 02493 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02494 02495 aElutOffset += adr_bereich_elut; 02496 adr[3] = (jj & bit_maske_selektor); 02497 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-3-1)*bit_breit_adr); 02498 ein_reg[3] = (LH_UINT16)jj; 02499 #endif 02500 adr0 *= NDIM_OUT_DIM; 02501 02502 { /* a kind of */ 02503 register long Hold; 02504 02505 02506 Index[0] = 0; 02507 Index[1] = 1; 02508 Index[2] = 2; 02509 #if NDIM_IN_DIM == 4 02510 Index[3] = 3; 02511 #endif 02512 if( adr[0] < adr[1] ){ 02513 Hold = Index[0]; 02514 Index[0] = Index[1]; 02515 Index[1] = Hold; 02516 } 02517 02518 if( adr[Index[1]] < adr[2] ){ 02519 Hold = Index[1]; 02520 Index[1] = Index[2]; 02521 Index[2] = Hold; 02522 if( adr[Index[0]] < adr[Index[1]] ){ 02523 Hold = Index[0]; 02524 Index[0] = Index[1]; 02525 Index[1] = Hold; 02526 } 02527 } 02528 02529 #if NDIM_IN_DIM == 4 02530 if( adr[Index[2]] < adr[3] ){ 02531 Hold = Index[2]; 02532 Index[2] = Index[3]; 02533 Index[3] = Hold; 02534 if( adr[Index[1]] < adr[Index[2]] ){ 02535 Hold = Index[1]; 02536 Index[1] = Index[2]; 02537 Index[2] = Hold; 02538 if( adr[Index[0]] < adr[Index[1]] ){ 02539 Hold = Index[0]; 02540 Index[0] = Index[1]; 02541 Index[1] = Hold; 02542 } 02543 } 02544 } 02545 #endif 02546 } 02547 02548 accu[0]=0; 02549 accu[1]=0; 02550 accu[2]=0; 02551 #if NDIM_OUT_DIM == 4 02552 accu[3]=0; 02553 #endif 02554 02555 ko0 = bit_maske_selektor+1; 02556 adrAdr=adr0; 02557 adrOffset=0; 02558 02559 if( aXlutWordSize == 16 ){ 02560 jj = Index[0]; 02561 ko = ko0 - adr[jj]; 02562 ko0 = adr[jj]; 02563 02564 if( ein_reg[jj] < bit_maske_adr ) 02565 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02566 02567 accu[0]+=Xlut[adrAdr+(0)]*ko; 02568 accu[1]+=Xlut[adrAdr+(1)]*ko; 02569 accu[2]+=Xlut[adrAdr+(2)]*ko; 02570 #if NDIM_OUT_DIM == 4 02571 accu[3]+=Xlut[adrAdr+(3)]*ko; 02572 #endif 02573 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02574 02575 jj = Index[1]; 02576 ko = ko0 - adr[jj]; 02577 ko0 = adr[jj]; 02578 02579 if( ein_reg[jj] < bit_maske_adr ) 02580 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02581 02582 accu[0]+=Xlut[adrAdr+(0)]*ko; 02583 accu[1]+=Xlut[adrAdr+(1)]*ko; 02584 accu[2]+=Xlut[adrAdr+(2)]*ko; 02585 #if NDIM_OUT_DIM == 4 02586 accu[3]+=Xlut[adrAdr+(3)]*ko; 02587 #endif 02588 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02589 02590 jj = Index[2]; 02591 ko = ko0 - adr[jj]; 02592 ko0 = adr[jj]; 02593 02594 if( ein_reg[jj] < bit_maske_adr ) 02595 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02596 02597 accu[0]+=Xlut[adrAdr+(0)]*ko; 02598 accu[1]+=Xlut[adrAdr+(1)]*ko; 02599 accu[2]+=Xlut[adrAdr+(2)]*ko; 02600 #if NDIM_OUT_DIM == 4 02601 accu[3]+=Xlut[adrAdr+(3)]*ko; 02602 #endif 02603 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02604 02605 #if NDIM_IN_DIM == 4 02606 jj = Index[3]; 02607 ko = ko0 - adr[jj]; 02608 ko0 = adr[jj]; 02609 02610 if( ein_reg[jj] < bit_maske_adr ) 02611 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02612 02613 accu[0]+=Xlut[adrAdr+(0)]*ko; 02614 accu[1]+=Xlut[adrAdr+(1)]*ko; 02615 accu[2]+=Xlut[adrAdr+(2)]*ko; 02616 #if NDIM_OUT_DIM == 4 02617 accu[3]+=Xlut[adrAdr+(3)]*ko; 02618 #endif 02619 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02620 #endif 02621 accu[0]+=Xlut[adrAdr+0]*ko0; 02622 accu[1]+=Xlut[adrAdr+1]*ko0; 02623 accu[2]+=Xlut[adrAdr+2]*ko0; 02624 #if NDIM_OUT_DIM == 4 02625 accu[3]+=Xlut[adrAdr+3]*ko0; 02626 #endif 02627 } 02628 else{ 02629 jj = Index[0]; 02630 ko = ko0 - adr[jj]; 02631 ko0 = adr[jj]; 02632 02633 if( ein_reg[jj] < bit_maske_adr ) 02634 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02635 02636 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02637 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02638 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02639 #if NDIM_OUT_DIM == 4 02640 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02641 #endif 02642 02643 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02644 02645 jj = Index[1]; 02646 ko = ko0 - adr[jj]; 02647 ko0 = adr[jj]; 02648 02649 if( ein_reg[jj] < bit_maske_adr ) 02650 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02651 02652 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02653 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02654 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02655 #if NDIM_OUT_DIM == 4 02656 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02657 #endif 02658 02659 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02660 02661 jj = Index[2]; 02662 ko = ko0 - adr[jj]; 02663 ko0 = adr[jj]; 02664 02665 if( ein_reg[jj] < bit_maske_adr ) 02666 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02667 02668 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02669 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02670 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02671 #if NDIM_OUT_DIM == 4 02672 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02673 #endif 02674 02675 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02676 02677 #if NDIM_IN_DIM == 4 02678 jj = Index[3]; 02679 ko = ko0 - adr[jj]; 02680 ko0 = adr[jj]; 02681 02682 if( ein_reg[jj] < bit_maske_adr ) 02683 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 02684 02685 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 02686 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 02687 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 02688 #if NDIM_OUT_DIM == 4 02689 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 02690 #endif 02691 02692 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 02693 #endif 02694 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 02695 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 02696 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 02697 #if NDIM_OUT_DIM == 4 02698 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 02699 #endif 02700 } 02701 02702 aAlutOffset = 0; 02703 02704 if( aOutputPackMode8Bit ){ 02705 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 02706 jj = accu[ii]; 02707 jj = jj + ( jj >> aXlutWordSize ); 02708 02709 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 02710 02711 ko = ko0 & (aAlutInShiftNum - 1 ); 02712 ko0 = ko0 >> aAlutInShift; 02713 ko0 += aAlutOffset; 02714 if( aAlutWordSize <= 8) 02715 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 02716 else{ 02717 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 02718 jj = jj - ( jj >> aAlutShift ); 02719 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 02720 } 02721 02722 *outputData[ii] = (LH_UINT8)jj; 02723 aAlutOffset += adr_bereich_alut; 02724 } 02725 } 02726 else{ 02727 if( aXlutWordSize >= 16 ){ 02728 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 02729 jj = accu[ii]; 02730 jj = jj + ( jj >> aXlutWordSize ); 02731 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 02732 02733 ko = ko0 & (aAlutInShiftNum - 1 ); 02734 ko0 = ko0 >> aAlutInShift; 02735 ko0 += aAlutOffset; 02736 if( aAlutWordSize <= 8) 02737 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 02738 else 02739 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 02740 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 02741 aAlutOffset += adr_bereich_alut; 02742 } 02743 } 02744 else{ 02745 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 02746 jj = accu[ii]; 02747 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 02748 ko0 = (jj - ( jj >> ( adr_breite_alut ))); /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 02749 02750 ko = ko0 & (aAlutInShiftNum - 1 ); 02751 ko0 = ko0 >> aAlutInShift; 02752 ko0 += aAlutOffset; 02753 if( aAlutWordSize <= 8) 02754 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 02755 else 02756 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 02757 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 02758 aAlutOffset += adr_bereich_alut; 02759 } 02760 } 02761 } 02762 02763 while (--i){ 02764 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 02765 inputData[jj] += (NDIM_IN_DIM * 2); 02766 } 02767 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02768 outputData[jj] += OutputIncrement; 02769 } 02770 02771 { 02772 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 02773 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 02774 } 02775 } 02776 if( jj<NDIM_IN_DIM ) break; 02777 if( aOutputPackMode8Bit ){ 02778 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02779 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 02780 } 02781 } 02782 else{ 02783 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02784 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 02785 } 02786 } 02787 } 02788 } 02789 02790 if( --LineCount ){ 02791 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 02792 inputData[jj] += inputDataRowOffset; 02793 } 02794 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 02795 outputData[jj] += outputDataRowOffset; 02796 } 02797 } 02798 } 02799 } 02800 02801 /* UNLOCK_DATA( aElutHdle ); */ 02802 /* UNLOCK_DATA( aAlutHdle ); */ 02803 /* UNLOCK_DATA( aXlutHdle ); */ 02804 02805 LH_END_PROC("Calc423Dim_Data8To8_Lut16") 02806 return noErr; 02807 } 02808 02809 #undef NDIM_IN_DIM 02810 #undef NDIM_OUT_DIM 02811 #undef aElutShift 02812 #undef aElutShiftNum 02813 #define NDIM_IN_DIM 4 02814 #define NDIM_OUT_DIM 4 02815 #define aElutShift (16-adr_breite_elut) 02816 #define aElutShiftNum (1<<aElutShift) 02817 02818 CMError Calc424Dim_Data8To8_Lut16 (CMCalcParamPtr calcParam, 02819 CMLutParamPtr lutParam) 02820 02821 { 02822 LH_UINT8 * inputData[8], *outputData[8]; 02823 UINT32 OutputIncrement, inputDataRowOffset, outputDataRowOffset, Pixelcount, LineCount; 02824 register unsigned long adr0; 02825 register unsigned long ko0; 02826 unsigned long accu[8]; 02827 register long i; 02828 /*long Offsets[8];*/ 02829 02830 register long aAlutShift,aElutOffset,aAlutOffset; 02831 register long aElutWordSize; 02832 register long aAlutWordSize; 02833 register long aXlutAdrSize; 02834 register long aXlutAdrShift; 02835 register unsigned long aXlutWordSize; 02836 register unsigned long ii,jj; 02837 register long aOutputPackMode8Bit; 02838 LH_UINT16 ein_Cache[8]; 02839 02840 LH_UINT16 * aus_lut = (LH_UINT16*)lutParam->outputLut; 02841 LH_UINT16 * ein_lut = (LH_UINT16*)lutParam->inputLut; 02842 LH_UINT16 * Xlut = (LH_UINT16*)lutParam->colorLut; 02843 02844 #ifdef DEBUG_OUTPUT 02845 long err = noErr; 02846 #endif 02847 LH_START_PROC("Calc424Dim_Data8To8_Lut16") 02848 02849 inputData[0] = (LH_UINT8 *)calcParam->inputData[0]; 02850 inputData[1] = (LH_UINT8 *)calcParam->inputData[1]; 02851 inputData[2] = (LH_UINT8 *)calcParam->inputData[2]; 02852 #if NDIM_IN_DIM == 4 02853 inputData[3] = (LH_UINT8 *)calcParam->inputData[3]; 02854 #endif 02855 outputData[0] = (LH_UINT8 *)calcParam->outputData[0]; 02856 outputData[1] = (LH_UINT8 *)calcParam->outputData[1]; 02857 outputData[2] = (LH_UINT8 *)calcParam->outputData[2]; 02858 #if NDIM_OUT_DIM == 4 02859 outputData[3] = (LH_UINT8 *)calcParam->outputData[3]; 02860 #endif 02861 02862 OutputIncrement = calcParam->cmOutputPixelOffset; 02863 inputDataRowOffset = calcParam->cmInputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmInputPixelOffset + (NDIM_IN_DIM * 2); 02864 outputDataRowOffset = calcParam->cmOutputBytesPerLine - calcParam->cmPixelPerLine * calcParam->cmOutputPixelOffset + OutputIncrement; 02865 02866 Pixelcount = calcParam->cmPixelPerLine; 02867 LineCount = calcParam->cmLineCount; 02868 02869 aElutWordSize = lutParam->inputLutWordSize; 02870 aAlutWordSize = lutParam->outputLutWordSize; 02871 aXlutAdrSize = lutParam->colorLutGridPoints; 02872 for ( i = 1; (i < 32) && (aXlutAdrSize >> i); i++) 02873 aXlutAdrShift = i; 02874 aXlutWordSize = lutParam->colorLutWordSize; 02875 02876 aOutputPackMode8Bit = calcParam->cmOutputColorSpace & cm8PerChannelPacking || calcParam->cmOutputColorSpace & cmLong8ColorPacking; 02877 /*DebugPrint("DoNDim with %d input elements\n",aByteCount);*/ 02878 #if FARBR_FILES 02879 WriteLuts( "DoNDim",1,adr_bereich_elut,aElutWordSize,ein_lut, 02880 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutWordSize,(LH_UINT16 *)Xlut,adr_bereich_alut,aAlutWordSize,(LH_UINT16 *)aus_lut); 02881 #endif 02882 02883 i=0; 02884 02885 { 02886 if( aElutShift < 0 ) 02887 { 02888 #ifdef DEBUG_OUTPUT 02889 DebugPrint("� DoNDim-Error: aElutShift < 0 (aElutShift = %d)\n",aElutShift); 02890 #endif 02891 return cmparamErr; 02892 } 02893 } 02894 02895 if( aOutputPackMode8Bit ){ 02896 aAlutShift = (aAlutWordSize-8); 02897 } 02898 else{ 02899 aAlutShift = (16 - aAlutWordSize); 02900 } 02901 02902 #ifdef DEBUG_OUTPUT 02903 if ( DebugCheck(kThisFile, kDebugReserved1) ){ 02904 DebugPrint("aElutAdrSize=%lx,aElutAdrShift=%lx,aElutWordSize=%lx,ein_lut=%lx,\n", 02905 adr_bereich_elut,adr_breite_elut,aElutWordSize,ein_lut); 02906 DebugPrint("aAlutAdrSize=%lx,aAlutAdrShift=%lx,aAlutWordSize=%lx,aus_lut=%lx,\n", 02907 adr_bereich_alut,adr_breite_alut,aAlutWordSize,aus_lut); 02908 DebugPrint("aXlutInDim=%lx,aXlutOutDim=%lx,aXlutAdrSize=%lx,aXlutAdrShift=%lx,aXlutWordSize=%lx,Xlut=%lx,\n", 02909 NDIM_IN_DIM,NDIM_OUT_DIM,aXlutAdrSize,aXlutAdrShift,aXlutWordSize,Xlut); 02910 } 02911 #endif 02912 02913 /*if( 1 )*/ 02914 if( aXlutAdrSize != (1<<aXlutAdrShift )){ 02915 register long aXlutOffset; 02916 long theXlutOffsets[8]; 02917 register unsigned long aAlutInShift; 02918 register long aAlutInShiftRemainder; 02919 register unsigned long aAlutInShiftNum; 02920 register long aElutWordSizeMask = (1<<aElutWordSize) - 1; 02921 register unsigned long aAlutRound; 02922 aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut; 02923 aAlutInShiftRemainder = 0; 02924 if( aAlutInShift > 16 ){ 02925 aAlutInShiftRemainder = aAlutInShift - 16; 02926 aAlutInShift = 16; 02927 } 02928 aAlutInShiftNum = (1<<aAlutInShift); 02929 02930 #ifdef DEBUG_OUTPUT 02931 if ( DebugCheck(kThisFile, kDebugMiscInfo) ) 02932 DebugPrint(" DoNDim gripoints = %ld\n",aXlutAdrSize); 02933 #endif 02934 if( aElutWordSize <= 0 ){ 02935 #ifdef DEBUG_OUTPUT 02936 DebugPrint("� DoNDim-Error: (1<<aElutWordSize)/aXlutAdrSize <= 0 %d\n",(1<<aElutWordSize)/aXlutAdrSize); 02937 #endif 02938 return cmparamErr; 02939 } 02940 if( aAlutInShift <= 0 ){ 02941 #ifdef DEBUG_OUTPUT 02942 DebugPrint("� DoNDim-Error: aAlutInShift <= 0 %d\n",aAlutInShift); 02943 #endif 02944 return cmparamErr; 02945 } 02946 aXlutOffset =NDIM_OUT_DIM; 02947 for( i=0; i<(long)NDIM_IN_DIM; i++){ 02948 theXlutOffsets[ NDIM_IN_DIM-1-i] = aXlutOffset; 02949 aXlutOffset *=aXlutAdrSize; 02950 } 02951 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 02952 02953 #ifdef DEBUG_OUTPUT 02954 if ( DebugCheck(kThisFile, kDebugReserved1) ) 02955 DebugPrint(" aElutWordSize((1<<aElutWordSize)-0) = %ld\n aAlutInShift:((1<<aXlutWordSize)*aElutWordSize+(adr_bereich_alut/2))/adr_bereich_alut = %ld\n",aElutWordSize,aAlutInShift); 02956 #endif 02957 02958 while (LineCount){ 02959 i = Pixelcount; 02960 02961 while (i){ 02962 02963 long adr[8],Index[8]; 02964 LH_UINT16 ein_reg[8]; 02965 register unsigned long adrAdr,ko,adrOffset; 02966 02967 adr0=0; 02968 aElutOffset = 0; 02969 jj=0; 02970 02971 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 02972 ko0 = jj - ( jj >> ( adr_breite_elut )); 02973 ko = ko0 & ( aElutShiftNum - 1 ); 02974 ko0 = ko0 >> aElutShift; 02975 ko0 += aElutOffset; 02976 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02977 02978 jj *= aXlutAdrSize; 02979 aElutOffset += adr_bereich_elut; 02980 adr[0] = jj & aElutWordSizeMask; 02981 jj = jj >> aElutWordSize; 02982 adr0 += (jj)*theXlutOffsets[0]; 02983 ein_reg[0] = (LH_UINT16)jj; 02984 02985 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 02986 ko0 = jj - ( jj >> ( adr_breite_elut )); 02987 ko = ko0 & ( aElutShiftNum - 1 ); 02988 ko0 = ko0 >> aElutShift; 02989 ko0 += aElutOffset; 02990 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 02991 02992 jj *= aXlutAdrSize; 02993 aElutOffset += adr_bereich_elut; 02994 adr[1] = jj & aElutWordSizeMask; 02995 jj = jj >> aElutWordSize; 02996 adr0 += (jj)*theXlutOffsets[1]; 02997 ein_reg[1] = (LH_UINT16)jj; 02998 02999 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 03000 ko0 = jj - ( jj >> ( adr_breite_elut )); 03001 ko = ko0 & ( aElutShiftNum - 1 ); 03002 ko0 = ko0 >> aElutShift; 03003 ko0 += aElutOffset; 03004 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 03005 03006 jj *= aXlutAdrSize; 03007 aElutOffset += adr_bereich_elut; 03008 adr[2] = jj & aElutWordSizeMask; 03009 jj = jj >> aElutWordSize; 03010 adr0 += (jj)*theXlutOffsets[2]; 03011 ein_reg[2] = (LH_UINT16)jj; 03012 03013 #if NDIM_IN_DIM == 4 03014 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 03015 ko0 = jj - ( jj >> ( adr_breite_elut )); 03016 ko = ko0 & ( aElutShiftNum - 1 ); 03017 ko0 = ko0 >> aElutShift; 03018 ko0 += aElutOffset; 03019 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 03020 03021 jj *= aXlutAdrSize; 03022 aElutOffset += adr_bereich_elut; 03023 adr[3] = jj & aElutWordSizeMask; 03024 jj = jj >> aElutWordSize; 03025 adr0 += (jj)*theXlutOffsets[3]; 03026 ein_reg[3] = (LH_UINT16)jj; 03027 #endif 03028 03029 03030 03031 { /* a kind of */ 03032 register long Hold; 03033 03034 03035 Index[0] = 0; 03036 Index[1] = 1; 03037 Index[2] = 2; 03038 #if NDIM_IN_DIM == 4 03039 Index[3] = 3; 03040 #endif 03041 if( adr[0] < adr[1] ){ 03042 Hold = Index[0]; 03043 Index[0] = Index[1]; 03044 Index[1] = Hold; 03045 } 03046 03047 if( adr[Index[1]] < adr[2] ){ 03048 Hold = Index[1]; 03049 Index[1] = Index[2]; 03050 Index[2] = Hold; 03051 if( adr[Index[0]] < adr[Index[1]] ){ 03052 Hold = Index[0]; 03053 Index[0] = Index[1]; 03054 Index[1] = Hold; 03055 } 03056 } 03057 03058 #if NDIM_IN_DIM == 4 03059 if( adr[Index[2]] < adr[3] ){ 03060 Hold = Index[2]; 03061 Index[2] = Index[3]; 03062 Index[3] = Hold; 03063 if( adr[Index[1]] < adr[Index[2]] ){ 03064 Hold = Index[1]; 03065 Index[1] = Index[2]; 03066 Index[2] = Hold; 03067 if( adr[Index[0]] < adr[Index[1]] ){ 03068 Hold = Index[0]; 03069 Index[0] = Index[1]; 03070 Index[1] = Hold; 03071 } 03072 } 03073 } 03074 #endif 03075 } 03076 03077 accu[0]=0; 03078 accu[1]=0; 03079 accu[2]=0; 03080 #if NDIM_OUT_DIM == 4 03081 accu[3]=0; 03082 #endif 03083 ko0 = (1<<aElutWordSize); 03084 adrAdr=adr0; 03085 adrOffset=0; 03086 if( aXlutWordSize == 16 ){ 03087 jj = Index[0]; 03088 ko = ko0 - adr[jj]; 03089 ko0 = adr[jj]; 03090 03091 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03092 adrOffset += theXlutOffsets[jj]; 03093 03094 accu[0]+=Xlut[adrAdr+(0)]*ko; 03095 accu[1]+=Xlut[adrAdr+(1)]*ko; 03096 accu[2]+=Xlut[adrAdr+(2)]*ko; 03097 #if NDIM_OUT_DIM == 4 03098 accu[3]+=Xlut[adrAdr+(3)]*ko; 03099 #endif 03100 03101 adrAdr = (adr0 + adrOffset); 03102 03103 jj = Index[1]; 03104 ko = ko0 - adr[jj]; 03105 ko0 = adr[jj]; 03106 03107 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03108 adrOffset += theXlutOffsets[jj]; 03109 03110 accu[0]+=Xlut[adrAdr+(0)]*ko; 03111 accu[1]+=Xlut[adrAdr+(1)]*ko; 03112 accu[2]+=Xlut[adrAdr+(2)]*ko; 03113 #if NDIM_OUT_DIM == 4 03114 accu[3]+=Xlut[adrAdr+(3)]*ko; 03115 #endif 03116 03117 adrAdr = (adr0 + adrOffset); 03118 03119 jj = Index[2]; 03120 ko = ko0 - adr[jj]; 03121 ko0 = adr[jj]; 03122 03123 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03124 adrOffset += theXlutOffsets[jj]; 03125 03126 accu[0]+=Xlut[adrAdr+(0)]*ko; 03127 accu[1]+=Xlut[adrAdr+(1)]*ko; 03128 accu[2]+=Xlut[adrAdr+(2)]*ko; 03129 #if NDIM_OUT_DIM == 4 03130 accu[3]+=Xlut[adrAdr+(3)]*ko; 03131 #endif 03132 03133 adrAdr = (adr0 + adrOffset); 03134 03135 #if NDIM_IN_DIM == 4 03136 jj = Index[3]; 03137 ko = ko0 - adr[jj]; 03138 ko0 = adr[jj]; 03139 03140 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03141 adrOffset += theXlutOffsets[jj]; 03142 03143 accu[0]+=Xlut[adrAdr+(0)]*ko; 03144 accu[1]+=Xlut[adrAdr+(1)]*ko; 03145 accu[2]+=Xlut[adrAdr+(2)]*ko; 03146 #if NDIM_OUT_DIM == 4 03147 accu[3]+=Xlut[adrAdr+(3)]*ko; 03148 #endif 03149 03150 adrAdr = (adr0 + adrOffset); 03151 #endif 03152 03153 accu[0]+=Xlut[adrAdr+0]*ko0; 03154 accu[1]+=Xlut[adrAdr+1]*ko0; 03155 accu[2]+=Xlut[adrAdr+2]*ko0; 03156 #if NDIM_OUT_DIM == 4 03157 accu[3]+=Xlut[adrAdr+3]*ko0; 03158 #endif 03159 } 03160 else{ 03161 03162 jj = Index[0]; 03163 ko = ko0 - adr[jj]; 03164 ko0 = adr[jj]; 03165 03166 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03167 adrOffset += theXlutOffsets[jj]; 03168 03169 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03170 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03171 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03172 #if NDIM_OUT_DIM == 4 03173 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03174 #endif 03175 adrAdr = (adr0 + adrOffset); 03176 03177 jj = Index[1]; 03178 ko = ko0 - adr[jj]; 03179 ko0 = adr[jj]; 03180 03181 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03182 adrOffset += theXlutOffsets[jj]; 03183 03184 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03185 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03186 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03187 #if NDIM_OUT_DIM == 4 03188 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03189 #endif 03190 adrAdr = (adr0 + adrOffset); 03191 03192 jj = Index[2]; 03193 ko = ko0 - adr[jj]; 03194 ko0 = adr[jj]; 03195 03196 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03197 adrOffset += theXlutOffsets[jj]; 03198 03199 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03200 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03201 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03202 #if NDIM_OUT_DIM == 4 03203 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03204 #endif 03205 adrAdr = (adr0 + adrOffset); 03206 03207 #if NDIM_IN_DIM == 4 03208 jj = Index[3]; 03209 ko = ko0 - adr[jj]; 03210 ko0 = adr[jj]; 03211 03212 if( ein_reg[jj] < (LH_UINT16)(aXlutAdrSize-1) ) 03213 adrOffset += theXlutOffsets[jj]; 03214 03215 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03216 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03217 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03218 #if NDIM_OUT_DIM == 4 03219 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03220 #endif 03221 adrAdr = (adr0 + adrOffset); 03222 #endif 03223 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 03224 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 03225 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 03226 #if NDIM_OUT_DIM == 4 03227 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 03228 #endif 03229 } 03230 03231 aAlutOffset = 0; 03232 03233 if( aOutputPackMode8Bit ){ 03234 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 03235 jj = accu[ii]; 03236 jj = jj + ( jj >> aXlutWordSize ); 03237 03238 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 03239 03240 ko = ko0 & (aAlutInShiftNum - 1 ); 03241 ko0 = ko0 >> aAlutInShift; 03242 ko0 += aAlutOffset; 03243 if( aAlutWordSize <= 8) 03244 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 03245 else{ 03246 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 03247 jj = jj - ( jj >> aAlutShift ); 03248 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 03249 } 03250 *outputData[ii] = (LH_UINT8)jj; 03251 aAlutOffset += adr_bereich_alut; 03252 } 03253 } 03254 else{ 03255 if( aXlutWordSize >= 16 ){ 03256 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 03257 jj = accu[ii]; 03258 jj = jj + ( jj >> aXlutWordSize ); 03259 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 03260 03261 ko = ko0 & (aAlutInShiftNum - 1 ); 03262 ko0 = ko0 >> aAlutInShift; 03263 ko0 += aAlutOffset; 03264 if( aAlutWordSize <= 8) 03265 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 03266 else 03267 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 03268 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 03269 aAlutOffset += adr_bereich_alut; 03270 } 03271 } 03272 else{ 03273 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 03274 jj = accu[ii]; 03275 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 03276 ko0 = (jj - ( jj >> ( adr_breite_alut ))) ; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 03277 03278 ko = ko0 & (aAlutInShiftNum - 1 ); 03279 ko0 = ko0 >> aAlutInShift; 03280 ko0 += aAlutOffset; 03281 if( aAlutWordSize <= 8) 03282 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 03283 else 03284 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 03285 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 03286 aAlutOffset += adr_bereich_alut; 03287 } 03288 } 03289 } 03290 while (--i){ 03291 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 03292 inputData[jj] += (NDIM_IN_DIM * 2); 03293 } 03294 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03295 outputData[jj] += OutputIncrement; 03296 } 03297 03298 { 03299 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 03300 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 03301 } 03302 } 03303 if( jj<NDIM_IN_DIM ) break; 03304 if( aOutputPackMode8Bit ){ 03305 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03306 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 03307 } 03308 } 03309 else{ 03310 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03311 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 03312 } 03313 } 03314 } 03315 } 03316 03317 if( --LineCount ){ 03318 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 03319 inputData[jj] += inputDataRowOffset; 03320 } 03321 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03322 outputData[jj] += outputDataRowOffset; 03323 } 03324 } 03325 } 03326 } 03327 else{ 03328 03329 register unsigned long bit_breit_selektor; 03330 register unsigned long bit_maske_selektor; 03331 register unsigned long bit_breit_adr; 03332 register unsigned long bit_maske_adr; 03333 register unsigned long aAlutInShiftNum; 03334 register long aAlutInShift; 03335 register long aAlutInShiftRemainder; 03336 register unsigned long aAlutRound; 03337 /*register long aXlutPlaneShift = aXlutAdrShift*aXlutInDim;*/ 03338 bit_breit_selektor=aElutWordSize-aXlutAdrShift; 03339 if( aElutWordSize-aXlutAdrShift < 0 ) 03340 { 03341 #ifdef DEBUG_OUTPUT 03342 DebugPrint("� DoNDim-Error: bit_breit_selektor < 0 (bit_breit_selektor = %d)\n",bit_breit_selektor); 03343 #endif 03344 return cmparamErr; 03345 } 03346 bit_maske_selektor=(1<<bit_breit_selektor)-1; 03347 bit_breit_adr=aXlutAdrShift; 03348 bit_maske_adr=((1<<bit_breit_adr)-1)<<bit_breit_selektor; 03349 aAlutInShift = (aXlutWordSize+bit_breit_selektor-adr_breite_alut); 03350 /*aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 03351 aAlutInShiftRemainder = 0; 03352 if( aAlutInShift > 16 ){ 03353 aAlutInShiftRemainder = aAlutInShift - 16; 03354 aAlutInShift = 16; 03355 } 03356 03357 aAlutInShiftNum = (1<<aAlutInShift); 03358 03359 aAlutRound = 1<<( aAlutInShift + aAlutShift - 1 ); 03360 while (LineCount){ 03361 i = Pixelcount; 03362 03363 while (i){ 03364 03365 long adr[8],Index[8]; 03366 /*LH_UINT16 *ein_lut = (LH_UINT16 *)ein_lut;*/ 03367 LH_UINT16 ein_reg[8]; 03368 register unsigned long adrAdr,ko,adrOffset; 03369 /*register unsigned long aIndex;*/ 03370 03371 adr0=0; 03372 aElutOffset = 0; 03373 jj=0; 03374 jj=ein_Cache[0]=(*(LH_UINT16 *)inputData[0]); 03375 ko0 = jj - ( jj >> ( adr_breite_elut )); 03376 ko = ko0 & ( aElutShiftNum - 1 ); 03377 ko0 = ko0 >> aElutShift; 03378 ko0 += aElutOffset; 03379 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 03380 03381 aElutOffset += adr_bereich_elut; 03382 adr[0] = (jj & bit_maske_selektor); 03383 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-0-1)*bit_breit_adr); 03384 ein_reg[0] = (LH_UINT16)jj; 03385 03386 jj=ein_Cache[1]=(*(LH_UINT16 *)inputData[1]); 03387 ko0 = jj - ( jj >> ( adr_breite_elut )); 03388 ko = ko0 & ( aElutShiftNum - 1 ); 03389 ko0 = ko0 >> aElutShift; 03390 ko0 += aElutOffset; 03391 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 03392 03393 aElutOffset += adr_bereich_elut; 03394 adr[1] = (jj & bit_maske_selektor); 03395 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-1-1)*bit_breit_adr); 03396 ein_reg[1] = (LH_UINT16)jj; 03397 03398 jj=ein_Cache[2]=(*(LH_UINT16 *)inputData[2]); 03399 ko0 = jj - ( jj >> ( adr_breite_elut )); 03400 ko = ko0 & ( aElutShiftNum - 1 ); 03401 ko0 = ko0 >> aElutShift; 03402 ko0 += aElutOffset; 03403 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 03404 03405 aElutOffset += adr_bereich_elut; 03406 adr[2] = (jj & bit_maske_selektor); 03407 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-2-1)*bit_breit_adr); 03408 ein_reg[2] = (LH_UINT16)jj; 03409 03410 #if NDIM_IN_DIM == 4 03411 jj=ein_Cache[3]=(*(LH_UINT16 *)inputData[3]); 03412 ko0 = jj - ( jj >> ( adr_breite_elut )); 03413 ko = ko0 & ( aElutShiftNum - 1 ); 03414 ko0 = ko0 >> aElutShift; 03415 ko0 += aElutOffset; 03416 jj = ( ein_lut[ ko0 ] * ( aElutShiftNum - ko ) + ein_lut[ ko0 +1 ] * ko ) >> aElutShift; 03417 03418 aElutOffset += adr_bereich_elut; 03419 adr[3] = (jj & bit_maske_selektor); 03420 adr0 |= ((jj & bit_maske_adr)>>bit_breit_selektor)<<((NDIM_IN_DIM-3-1)*bit_breit_adr); 03421 ein_reg[3] = (LH_UINT16)jj; 03422 #endif 03423 adr0 *= NDIM_OUT_DIM; 03424 03425 { /* a kind of */ 03426 register long Hold; 03427 03428 03429 Index[0] = 0; 03430 Index[1] = 1; 03431 Index[2] = 2; 03432 #if NDIM_IN_DIM == 4 03433 Index[3] = 3; 03434 #endif 03435 if( adr[0] < adr[1] ){ 03436 Hold = Index[0]; 03437 Index[0] = Index[1]; 03438 Index[1] = Hold; 03439 } 03440 03441 if( adr[Index[1]] < adr[2] ){ 03442 Hold = Index[1]; 03443 Index[1] = Index[2]; 03444 Index[2] = Hold; 03445 if( adr[Index[0]] < adr[Index[1]] ){ 03446 Hold = Index[0]; 03447 Index[0] = Index[1]; 03448 Index[1] = Hold; 03449 } 03450 } 03451 03452 #if NDIM_IN_DIM == 4 03453 if( adr[Index[2]] < adr[3] ){ 03454 Hold = Index[2]; 03455 Index[2] = Index[3]; 03456 Index[3] = Hold; 03457 if( adr[Index[1]] < adr[Index[2]] ){ 03458 Hold = Index[1]; 03459 Index[1] = Index[2]; 03460 Index[2] = Hold; 03461 if( adr[Index[0]] < adr[Index[1]] ){ 03462 Hold = Index[0]; 03463 Index[0] = Index[1]; 03464 Index[1] = Hold; 03465 } 03466 } 03467 } 03468 #endif 03469 } 03470 03471 accu[0]=0; 03472 accu[1]=0; 03473 accu[2]=0; 03474 #if NDIM_OUT_DIM == 4 03475 accu[3]=0; 03476 #endif 03477 03478 ko0 = bit_maske_selektor+1; 03479 adrAdr=adr0; 03480 adrOffset=0; 03481 03482 if( aXlutWordSize == 16 ){ 03483 jj = Index[0]; 03484 ko = ko0 - adr[jj]; 03485 ko0 = adr[jj]; 03486 03487 if( ein_reg[jj] < bit_maske_adr ) 03488 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03489 03490 accu[0]+=Xlut[adrAdr+(0)]*ko; 03491 accu[1]+=Xlut[adrAdr+(1)]*ko; 03492 accu[2]+=Xlut[adrAdr+(2)]*ko; 03493 #if NDIM_OUT_DIM == 4 03494 accu[3]+=Xlut[adrAdr+(3)]*ko; 03495 #endif 03496 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03497 03498 jj = Index[1]; 03499 ko = ko0 - adr[jj]; 03500 ko0 = adr[jj]; 03501 03502 if( ein_reg[jj] < bit_maske_adr ) 03503 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03504 03505 accu[0]+=Xlut[adrAdr+(0)]*ko; 03506 accu[1]+=Xlut[adrAdr+(1)]*ko; 03507 accu[2]+=Xlut[adrAdr+(2)]*ko; 03508 #if NDIM_OUT_DIM == 4 03509 accu[3]+=Xlut[adrAdr+(3)]*ko; 03510 #endif 03511 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03512 03513 jj = Index[2]; 03514 ko = ko0 - adr[jj]; 03515 ko0 = adr[jj]; 03516 03517 if( ein_reg[jj] < bit_maske_adr ) 03518 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03519 03520 accu[0]+=Xlut[adrAdr+(0)]*ko; 03521 accu[1]+=Xlut[adrAdr+(1)]*ko; 03522 accu[2]+=Xlut[adrAdr+(2)]*ko; 03523 #if NDIM_OUT_DIM == 4 03524 accu[3]+=Xlut[adrAdr+(3)]*ko; 03525 #endif 03526 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03527 03528 #if NDIM_IN_DIM == 4 03529 jj = Index[3]; 03530 ko = ko0 - adr[jj]; 03531 ko0 = adr[jj]; 03532 03533 if( ein_reg[jj] < bit_maske_adr ) 03534 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03535 03536 accu[0]+=Xlut[adrAdr+(0)]*ko; 03537 accu[1]+=Xlut[adrAdr+(1)]*ko; 03538 accu[2]+=Xlut[adrAdr+(2)]*ko; 03539 #if NDIM_OUT_DIM == 4 03540 accu[3]+=Xlut[adrAdr+(3)]*ko; 03541 #endif 03542 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03543 #endif 03544 accu[0]+=Xlut[adrAdr+0]*ko0; 03545 accu[1]+=Xlut[adrAdr+1]*ko0; 03546 accu[2]+=Xlut[adrAdr+2]*ko0; 03547 #if NDIM_OUT_DIM == 4 03548 accu[3]+=Xlut[adrAdr+3]*ko0; 03549 #endif 03550 } 03551 else{ 03552 jj = Index[0]; 03553 ko = ko0 - adr[jj]; 03554 ko0 = adr[jj]; 03555 03556 if( ein_reg[jj] < bit_maske_adr ) 03557 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03558 03559 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03560 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03561 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03562 #if NDIM_OUT_DIM == 4 03563 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03564 #endif 03565 03566 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03567 03568 jj = Index[1]; 03569 ko = ko0 - adr[jj]; 03570 ko0 = adr[jj]; 03571 03572 if( ein_reg[jj] < bit_maske_adr ) 03573 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03574 03575 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03576 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03577 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03578 #if NDIM_OUT_DIM == 4 03579 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03580 #endif 03581 03582 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03583 03584 jj = Index[2]; 03585 ko = ko0 - adr[jj]; 03586 ko0 = adr[jj]; 03587 03588 if( ein_reg[jj] < bit_maske_adr ) 03589 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03590 03591 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03592 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03593 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03594 #if NDIM_OUT_DIM == 4 03595 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03596 #endif 03597 03598 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03599 03600 #if NDIM_IN_DIM == 4 03601 jj = Index[3]; 03602 ko = ko0 - adr[jj]; 03603 ko0 = adr[jj]; 03604 03605 if( ein_reg[jj] < bit_maske_adr ) 03606 adrOffset |= (1<<(NDIM_IN_DIM-1-jj)*bit_breit_adr); 03607 03608 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+(0)]*ko; 03609 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+(1)]*ko; 03610 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+(2)]*ko; 03611 #if NDIM_OUT_DIM == 4 03612 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+(3)]*ko; 03613 #endif 03614 03615 adrAdr = (adr0 + NDIM_OUT_DIM*adrOffset); 03616 #endif 03617 accu[0]+=((LH_UINT8 *)Xlut)[adrAdr+0]*ko0; 03618 accu[1]+=((LH_UINT8 *)Xlut)[adrAdr+1]*ko0; 03619 accu[2]+=((LH_UINT8 *)Xlut)[adrAdr+2]*ko0; 03620 #if NDIM_OUT_DIM == 4 03621 accu[3]+=((LH_UINT8 *)Xlut)[adrAdr+3]*ko0; 03622 #endif 03623 } 03624 03625 aAlutOffset = 0; 03626 03627 if( aOutputPackMode8Bit ){ 03628 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 03629 jj = accu[ii]; 03630 jj = jj + ( jj >> aXlutWordSize ); 03631 03632 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 03633 03634 ko = ko0 & (aAlutInShiftNum - 1 ); 03635 ko0 = ko0 >> aAlutInShift; 03636 ko0 += aAlutOffset; 03637 if( aAlutWordSize <= 8) 03638 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) >> ( aAlutInShift ); 03639 else{ 03640 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ); 03641 jj = jj - ( jj >> aAlutShift ); 03642 jj = ( jj + aAlutRound ) >> (aAlutInShift + aAlutShift); 03643 } 03644 03645 *outputData[ii] = (LH_UINT8)jj; 03646 aAlutOffset += adr_bereich_alut; 03647 } 03648 } 03649 else{ 03650 if( aXlutWordSize >= 16 ){ 03651 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 03652 jj = accu[ii]; 03653 jj = jj + ( jj >> aXlutWordSize ); 03654 ko0 = (jj - ( jj >> ( adr_breite_alut ))) >> aAlutInShiftRemainder; /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 03655 03656 ko = ko0 & (aAlutInShiftNum - 1 ); 03657 ko0 = ko0 >> aAlutInShift; 03658 ko0 += aAlutOffset; 03659 if( aAlutWordSize <= 8) 03660 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 03661 else 03662 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 03663 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 03664 aAlutOffset += adr_bereich_alut; 03665 } 03666 } 03667 else{ 03668 for( ii=0; ii<NDIM_OUT_DIM; ++ii){ 03669 jj = accu[ii]; 03670 jj = jj + ( jj >> aXlutWordSize ) + ( jj >> 2*aXlutWordSize ); 03671 ko0 = (jj - ( jj >> ( adr_breite_alut ))); /* aAlutInShift = aXlutWordSize + aElutWordSize - adr_breite_alut;*/ 03672 03673 ko = ko0 & (aAlutInShiftNum - 1 ); 03674 ko0 = ko0 >> aAlutInShift; 03675 ko0 += aAlutOffset; 03676 if( aAlutWordSize <= 8) 03677 jj = ( ((LH_UINT8*)aus_lut)[ ko0 ] * ( aAlutInShiftNum - ko ) + ((LH_UINT8*)aus_lut)[ ko0 +1 ] * ko ) << ( aAlutShift - aAlutInShift ); 03678 else 03679 jj = ( aus_lut[ ko0 ] * ( aAlutInShiftNum - ko ) + aus_lut[ ko0 +1 ] * ko ) >> (aAlutInShift- aAlutShift); 03680 *((LH_UINT16 *)outputData[ii]) = (LH_UINT16)jj; 03681 aAlutOffset += adr_bereich_alut; 03682 } 03683 } 03684 } 03685 03686 while (--i){ 03687 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 03688 inputData[jj] += (NDIM_IN_DIM * 2); 03689 } 03690 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03691 outputData[jj] += OutputIncrement; 03692 } 03693 03694 { 03695 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 03696 if( *((LH_UINT16 *)inputData[jj]) ^ ein_Cache[jj] )break; 03697 } 03698 } 03699 if( jj<NDIM_IN_DIM ) break; 03700 if( aOutputPackMode8Bit ){ 03701 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03702 *outputData[jj] = outputData[jj][-(long)(NDIM_OUT_DIM )]; 03703 } 03704 } 03705 else{ 03706 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03707 *((LH_UINT16 *)outputData[jj]) = *(LH_UINT16 *)(&outputData[jj][-(long)(NDIM_OUT_DIM * 2)]); 03708 } 03709 } 03710 } 03711 } 03712 03713 if( --LineCount ){ 03714 for( jj=0; jj<NDIM_IN_DIM; ++jj){ 03715 inputData[jj] += inputDataRowOffset; 03716 } 03717 for( jj=0; jj<NDIM_OUT_DIM; ++jj){ 03718 outputData[jj] += outputDataRowOffset; 03719 } 03720 } 03721 } 03722 } 03723 03724 /* UNLOCK_DATA( aElutHdle ); */ 03725 /* UNLOCK_DATA( aAlutHdle ); */ 03726 /* UNLOCK_DATA( aXlutHdle ); */ 03727 03728 LH_END_PROC("Calc424Dim_Data8To8_Lut16") 03729 return noErr; 03730 } 03731 #endif