test: calcndim.c Source File

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