00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
#ifndef LHGeneralIncs_h
00014
#include "General.h"
00015
#endif
00016
00017
#ifndef LHCalcEngine_h
00018
#include "CalcEng.h"
00019
#endif
00020
00021
#ifndef LHCalcEngine1Dim_h
00022
#include "CalcEng1.h"
00023
#endif
00024
00025
#ifdef ALLOW_MMX
00026
#ifndef LHCalcEngineFas_h
00027
#include "CalcEnF.h"
00028
#endif
00029
#endif
00030
00031
#ifndef LHCalcNDim_h
00032
#include "CalcNDim.h"
00033
#endif
00034
00035
#ifndef LHCMRuntime_h
00036
#include "Runtime.h"
00037
#endif
00038
00039
#if ! realThing
00040
#ifdef DEBUG_OUTPUT
00041
#define kThisFile kCMMRuntimeID
00042
extern Boolean gUSE_NDIM_FOR_BITMAP;
00043
#endif
00044
#endif
00045
00046
typedef struct ColorSpaceInfo
00047 {
00048 SINT32 origSizeIn;
00049 SINT32 origSizeOut;
00050 SINT32 usedSizeIn;
00051 SINT32 usedSizeOut;
00052 void*
tempInBuffer;
00053 void*
tempOutBuffer;
00054 SINT32 processedLinesIn;
00055 SINT32 processedLinesOut;
00056 SINT32 inputPixelSize;
00057 SINT32 outputPixelSize;
00058 Boolean inPlace;
00059 }
ColorSpaceInfo;
00060
00061
00062 #define kProgressTicks 30
00063 #define kMaxTempBlock 300 * 1024
00064
00065
00066 typedef CMError (*CalcProcPtr)(
CMCalcParamPtr calcParamPtr,
00067
CMLutParamPtr lutParamPtr );
00068
00069 typedef CalcProcPtr CalcProcUPP;
00070 typedef CMError (*CalcProc1DimPtr)(
CMCalcParamPtr calcParamPtr,
00071
CMLutParamPtr lutParamPtr,
char OutDim );
00072
00073 typedef CalcProc1DimPtr CalcProc1DimUPP;
00074 #define NewCalcProc(userRoutine) \
00075
((CalcProcUPP) (userRoutine))
00076 #define NewCalcProc1Dim(userRoutine) \
00077
((CalcProc1DimUPP) (userRoutine))
00078 #define CallCalcProc(userRoutine, calcParamPtr, lutParamPtr) \
00079
(*(userRoutine))( (calcParamPtr), (lutParamPtr) )
00080
00081
00082
00083
00084
00085
OSErr Convert5To8 ( Ptr dataPtr5,
00086 Ptr dataPtr8,
00087 SINT32 startLine,
00088 SINT32 height,
00089 SINT32 width,
00090 SINT32 rowBytes5 );
00091
OSErr Convert8To5 ( Ptr dataPtr8,
00092 Ptr dataPtr5,
00093 SINT32 startLine,
00094 SINT32 height,
00095 SINT32 width,
00096 SINT32 rowBytes5 );
00097
OSErr Convert8To1 ( Ptr dataPtr8,
00098 Ptr dataPtr5,
00099 SINT32 startLine,
00100 SINT32 height,
00101 SINT32 width,
00102 SINT32 rowBytes5 );
00103
OSErr Convert16To10 ( Ptr dataPtr16,
00104 Ptr dataPtr10,
00105 SINT32 startLine,
00106 SINT32 height,
00107 SINT32 width,
00108 SINT32 rowBytes10 );
00109
OSErr Convert10To16 ( Ptr dataPtr10,
00110 Ptr dataPtr16,
00111 SINT32 startLine,
00112 SINT32 height,
00113 SINT32 width,
00114 SINT32 rowBytes10 );
00115
00116
CMError FillLutParam (
CMLutParamPtr lutParam,
00117 CMMModelPtr modelingData );
00118
CMError FillLutParamChk (
CMLutParamPtr lutParam,
00119 CMMModelPtr modelingData );
00120
00121
CMError FillCalcParam (
CMCalcParamPtr calcParam,
00122
const CMBitmap * bitMap,
00123
const CMBitmap * matchedBitMap );
00124
00125
CMError FillCalcParamCM (
CMCalcParamPtr calcParam,
00126
CMLutParamPtr lutParam,
00127
CMColor* myColors,
00128 SINT32 count );
00129
CMError CheckInputColorSpace (
const CMBitmap* bitMap,
00130
CMCalcParamPtr calcParam,
00131
ColorSpaceInfo* info,
00132 OSType inColorSpace,
00133
long colorLutInDim );
00134
CMError CheckOutputColorSpace (
const CMBitmap* bitMap,
00135
CMCalcParamPtr calcParam,
00136
ColorSpaceInfo* info,
00137 OSType outColorSpace,
00138
long colorLutOutDim );
00139
CMError SetOutputColorSpaceInplace (
CMCalcParamPtr calcParam,
00140
ColorSpaceInfo* info,
00141 OSType outColorSpace );
00142
CMError CheckOutputColorSpaceChk(
const CMBitmap* bitMap,
00143
CMCalcParamPtr calcParam,
00144
ColorSpaceInfo* info );
00145
00146
CMError AllocBufferCheckCM (
CMCalcParamPtr calcParam,
00147
ColorSpaceInfo* info );
00148
00149
CalcProcPtr FindLookupRoutine (
const CMLutParam* lutParam,
00150
const ColorSpaceInfo* info );
00151
00152
CalcProcPtr FindCalcRoutine (
const CMCalcParam* calcParam,
00153
const CMLutParam* lutParam,
00154
const ColorSpaceInfo* info,
00155
const Boolean lookupOnly );
00156
00157
00158
#ifdef __MWERKS__
00159
#pragma mark ================ packing/unpacking ================
00160
#endif
00161
00162
00163
00164
00165
OSErr
00166
Convert5To8 ( Ptr dataPtr5,
00167 Ptr dataPtr8,
00168 SINT32 startLine,
00169 SINT32 height,
00170 SINT32 width,
00171 SINT32 rowBytes5 )
00172 {
00173
UINT16* srcPtr16;
00174
UINT8* destPtr8 = (
UINT8*)dataPtr8;
00175
UINT8 data8;
00176
UINT16 three5Bits;
00177
SINT32 lineLoop;
00178
SINT32 pixelLoop;
00179
OSErr err =
noErr;
00180
00181
LH_START_PROC(
"Convert5To8")
00182 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++)
00183 {
00184 srcPtr16 = (
UINT16*)(dataPtr5 + (lineLoop*rowBytes5));
00185
for (pixelLoop = 0; pixelLoop < width; pixelLoop++)
00186 {
00187 three5Bits = *srcPtr16++;
00188
00189 data8 = (three5Bits >> 10) & 0x001F;
00190 *destPtr8++ = (data8 << 3) | (data8 >>2);
00191
00192 data8 = (three5Bits >> 5) & 0x001F;
00193 *destPtr8++ = (data8 << 3) | (data8 >>2);
00194
00195 data8 = three5Bits & 0x001F;
00196 *destPtr8++ = (data8 << 3) | (data8 >>2);
00197 }
00198 }
00199
LH_END_PROC(
"Convert5To8")
00200 return err;
00201 }
00202
00203
00204
00205
00206 OSErr
00207 Convert8To5 ( Ptr dataPtr8,
00208 Ptr dataPtr5,
00209 SINT32 startLine,
00210 SINT32 height,
00211 SINT32 width,
00212 SINT32 rowBytes5 )
00213 {
00214
UINT16* destPtr16;
00215
UINT8* srcPtr8 = (
UINT8*)dataPtr8;
00216
UINT16 three5Bits;
00217
SINT32 lineLoop;
00218
SINT32 pixelLoop;
00219
OSErr err =
noErr;
00220
00221
LH_START_PROC(
"Convert8To5")
00222 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++)
00223 {
00224 destPtr16 = (
UINT16*)(dataPtr5 + (lineLoop*rowBytes5));
00225
for (pixelLoop = 0; pixelLoop < width; pixelLoop++)
00226 {
00227 three5Bits = (((
UINT16)*srcPtr8 & 0x00F8) << 7);
00228 srcPtr8++;
00229 three5Bits |= (((
UINT16)*srcPtr8 & 0x00F8) << 2);
00230 srcPtr8++;
00231 three5Bits |= (((
UINT16)*srcPtr8 & 0x00F8) >> 3);
00232 srcPtr8++;
00233
00234 *destPtr16++ = three5Bits;
00235 }
00236 }
00237
LH_END_PROC(
"Convert8To5")
00238 return err;
00239 }
00240 #ifdef PI_Application_h
00241 OSErr Convert565To8 ( Ptr dataPtr5,
00242 Ptr dataPtr8,
00243 SINT32 startLine,
00244 SINT32 height,
00245 SINT32 width,
00246 SINT32 rowBytes5 );
00247 OSErr Convert8To565 ( Ptr dataPtr8,
00248 Ptr dataPtr5,
00249 SINT32 startLine,
00250 SINT32 height,
00251 SINT32 width,
00252 SINT32 rowBytes5 );
00253
00254
00255
00256 OSErr
00257 Convert565To8( Ptr dataPtr5,
00258 Ptr dataPtr8,
00259 SINT32 startLine,
00260 SINT32 height,
00261 SINT32 width,
00262 SINT32 rowBytes5 )
00263 {
00264
UINT16* srcPtr16;
00265
UINT8* destPtr8 = (
UINT8*)dataPtr8;
00266
UINT8 data8;
00267
UINT16 three5Bits;
00268
SINT32 lineLoop;
00269
SINT32 pixelLoop;
00270
OSErr err =
noErr;
00271
00272
LH_START_PROC(
"Convert565To8")
00273 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++)
00274 {
00275 srcPtr16 = (
UINT16*)(dataPtr5 + (lineLoop*rowBytes5));
00276
for (pixelLoop = 0; pixelLoop < width; pixelLoop++)
00277 {
00278 three5Bits = *srcPtr16++;
00279
00280 data8 = (three5Bits >> 11) & 0x001F;
00281 *destPtr8++ = (data8 << 3) | (data8 >>2);
00282
00283 data8 = (three5Bits >> 5) & 0x003F;
00284 *destPtr8++ = (data8 << 2) | (data8 >>4);
00285
00286 data8 = three5Bits & 0x001F;
00287 *destPtr8++ = (data8 << 3) | (data8 >>2);
00288 }
00289 }
00290
LH_END_PROC(
"Convert565To8")
00291 return err;
00292 }
00293
00294
00295
00296
00297 OSErr
00298 Convert8To565( Ptr dataPtr8,
00299 Ptr dataPtr5,
00300 SINT32 startLine,
00301 SINT32 height,
00302 SINT32 width,
00303 SINT32 rowBytes5 )
00304 {
00305
UINT16* destPtr16;
00306
UINT8* srcPtr8 = (
UINT8*)dataPtr8;
00307
UINT16 three5Bits;
00308
SINT32 lineLoop;
00309
SINT32 pixelLoop;
00310
OSErr err =
noErr;
00311
00312
LH_START_PROC(
"Convert8To565")
00313 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++)
00314 {
00315 destPtr16 = (
UINT16*)(dataPtr5 + (lineLoop*rowBytes5));
00316
for (pixelLoop = 0; pixelLoop < width; pixelLoop++)
00317 {
00318 three5Bits = (((
UINT16)*srcPtr8 & 0x00F8) << 8);
00319 srcPtr8++;
00320 three5Bits |= (((
UINT16)*srcPtr8 & 0x00FC) << 3);
00321 srcPtr8++;
00322 three5Bits |= (((
UINT16)*srcPtr8 & 0x00F8) >> 3);
00323 srcPtr8++;
00324
00325 *destPtr16++ = three5Bits;
00326 }
00327 }
00328
LH_END_PROC(
"Convert8To565")
00329 return err;
00330 }
00331 #endif
00332
00333
00334
00335 OSErr
00336 Convert8To1 ( Ptr dataPtr8,
00337 Ptr dataPtr1,
00338 SINT32 startLine,
00339 SINT32 height,
00340 SINT32 width,
00341 SINT32 rowBytes1 )
00342 {
00343
UINT8* destPtr8;
00344
UINT8* srcPtr8 = (
UINT8*)dataPtr8;
00345
UINT8 theWord = 0;
00346
SINT32 lineLoop;
00347
SINT32 pixelLoop;
00348
OSErr err =
noErr;
00349
00350
LH_START_PROC(
"Convert8To1")
00351 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++)
00352 {
00353 destPtr8 = (
UINT8*)(dataPtr1 + (lineLoop*rowBytes1));
00354
for ( pixelLoop = 0; pixelLoop < width; pixelLoop++ )
00355 {
00356
if (*srcPtr8)
00357 theWord |= (1<< (7- ( pixelLoop & 7)));
00358
if ( (pixelLoop & 7) == 7)
00359 {
00360 *destPtr8++ = theWord;
00361 theWord = 0;
00362 }
00363 srcPtr8 ++;
00364 }
00365
if (width % 8)
00366 {
00367 *destPtr8 = theWord | ( ((
unsigned char)255 >> (width % 8)));
00368 theWord = 0;
00369 }
00370 }
00371
LH_END_PROC(
"Convert8To1")
00372 return err;
00373 }
00374
00375
00376
00377
00378 OSErr
00379 Convert16To10 ( Ptr dataPtr16,
00380 Ptr dataPtr10,
00381 SINT32 startLine,
00382 SINT32 height,
00383 SINT32 width,
00384 SINT32 rowBytes10 )
00385 {
00386
UINT32 data16_1;
00387
UINT32 data16_2;
00388
UINT32 data16_3;
00389
UINT16* srcPtr16 = (
UINT16*)dataPtr16;
00390
UINT32* destPtr32;
00391
SINT32 lineLoop;
00392
SINT32 pixelLoop;
00393
OSErr err =
noErr;
00394
00395
LH_START_PROC(
"Convert16To10")
00396 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++)
00397 {
00398 destPtr32 = (
UINT32*)( dataPtr10 + (lineLoop * rowBytes10));
00399
for (pixelLoop = 0; pixelLoop < width; pixelLoop++)
00400 {
00401 data16_1 = ((
UINT32)*srcPtr16++ & 0x0000FFC0) << 14;
00402 data16_2 = ((
UINT32)*srcPtr16++ & 0x0000FFC0) << 4;
00403 data16_3 = ((
UINT32)*srcPtr16++ & 0x0000FFC0) >> 6;
00404 *destPtr32++ = data16_1 | data16_2 | data16_3;
00405 }
00406 }
00407
LH_END_PROC(
"Convert16To10")
00408 return err;
00409 }
00410
00411
00412
00413
00414 OSErr
00415 Convert10To16 ( Ptr dataPtr10,
00416 Ptr dataPtr16,
00417 SINT32 startLine,
00418 SINT32 height,
00419 SINT32 width,
00420 SINT32 rowBytes10 )
00421 {
00422
UINT16 data16;
00423
UINT32 data32;
00424
UINT32* srcPtr32;
00425
UINT16* destPtr16 = (
UINT16*)dataPtr16;
00426
SINT32 lineLoop;
00427
SINT32 pixelLoop;
00428
OSErr err =
noErr;
00429
00430
LH_START_PROC(
"Convert10To16")
00431 for (lineLoop = startLine; lineLoop < startLine + height; lineLoop++)
00432 {
00433 srcPtr32 = (
UINT32*)( dataPtr10 + (lineLoop * rowBytes10));
00434
for (pixelLoop = 0; pixelLoop < width; pixelLoop++)
00435 {
00436 data32 = *srcPtr32++;
00437 data16 = (
UINT16)(data32>>14) & 0x0FFC0;
00438 *destPtr16++ = data16 | data16>>10;
00439 data16 = (
UINT16)(data32>>4) & 0x0FFC0;
00440 *destPtr16++ = data16 | data16>>10;
00441 data16 = (
UINT16)(data32<<6);
00442 *destPtr16++ = data16 | data16>>10;
00443 }
00444 }
00445
LH_END_PROC(
"Convert10To16")
00446 return err;
00447 }
00448
00449 #ifdef __MWERKS__
00450 #pragma mark ================ setup & checking ================
00451 #endif
00452
00453
00454
00455
00456 CMError
00457 FillLutParam (
CMLutParamPtr lutParam,
00458 CMMModelPtr modelingData )
00459 {
00460
CMError err =
noErr;
00461
00462
LH_START_PROC(
"FillLutParam")
00463 *lutParam = (modelingData)->lutParam;
00464
#if ! LUTS_ARE_PTR_BASED
00465
lutParam->inputLut =
DATA_2_PTR(modelingData)->lutParam.inputLut;
00466 lutParam->outputLut =
DATA_2_PTR(modelingData)->lutParam.outputLut;
00467 lutParam->colorLut =
DATA_2_PTR(modelingData)->lutParam.colorLut;
00468
#endif
00469
LH_END_PROC(
"FillLutParam")
00470 return err;
00471 }
00472
00473
00474
00475
00476 CMError
00477 FillLutParamChk (
CMLutParamPtr lutParam,
00478 CMMModelPtr modelingData )
00479 {
00480
CMError err =
noErr;
00481
00482
LH_START_PROC(
"FillLutParamChk")
00483 *lutParam = (modelingData)->gamutLutParam;
00484
#if ! LUTS_ARE_PTR_BASED
00485
lutParam->inputLut =
DATA_2_PTR(modelingData)->gamutLutParam.inputLut;
00486 lutParam->outputLut =
DATA_2_PTR(modelingData)->gamutLutParam.outputLut;
00487 lutParam->colorLut =
DATA_2_PTR(modelingData)->gamutLutParam.colorLut;
00488
#endif
00489
LH_END_PROC(
"FillLutParamChk")
00490 return err;
00491 }
00492
00493
00494
00495
00496 CMError
00497 FillCalcParam (
CMCalcParamPtr calcParam,
00498 const
CMBitmap * bitMap,
00499 const
CMBitmap * matchedBitMap )
00500 {
00501
CMError err =
noErr;
00502
00503
LH_START_PROC(
"FillCalcParam")
00504
00505 calcParam->cmInputColorSpace = bitMap->space;
00506 calcParam->cmOutputColorSpace = matchedBitMap->space;
00507 calcParam->cmPixelPerLine = bitMap->width;
00508 calcParam->cmInputBytesPerLine = bitMap->rowBytes;
00509 calcParam->cmOutputBytesPerLine = matchedBitMap->rowBytes;
00510 calcParam->cmLineCount = bitMap->height;
00511
00512 LH_END_PROC("FillCalcParam")
00513 return err;
00514 }
00515
00516
00517
00518
00519 CMError
00520 FillCalcParamCM (
CMCalcParamPtr calcParam,
00521
CMLutParamPtr lutParam,
00522
CMColor* myColors,
00523 SINT32 count )
00524 {
00525
SINT32 loop;
00526
CMError err =
noErr;
00527
00528
LH_START_PROC(
"FillCalcParamCM")
00529
00530 calcParam->cmInputPixelOffset = sizeof(
CMColor);
00531 calcParam->cmOutputPixelOffset = sizeof(CMColor);
00532
00533
00534 switch (lutParam->colorLutInDim)
00535 {
00536
case 1:
00537 calcParam->cmInputColorSpace =
cmGraySpace;
00538 calcParam->inputData[0] = (
Ptr)myColors;
00539
break;
00540
case 3:
00541 calcParam->cmInputColorSpace =
cmRGBSpace|
cm16PerChannelPacking;
00542 calcParam->inputData[0] = ((
Ptr)myColors);
00543 calcParam->inputData[1] = ((
Ptr)myColors) + 2;
00544 calcParam->inputData[2] = ((
Ptr)myColors) + 4;
00545
break;
00546
case 4:
00547 calcParam->cmInputColorSpace =
cmCMYKSpace|
cm16PerChannelPacking;
00548 calcParam->inputData[0] = ((
Ptr)myColors);
00549 calcParam->inputData[1] = ((
Ptr)myColors) + 2;
00550 calcParam->inputData[2] = ((
Ptr)myColors) + 4;
00551 calcParam->inputData[3] = ((
Ptr)myColors) + 6;
00552
break;
00553
case 5:
00554
case 6:
00555
case 7:
00556
case 8:
00557
#if ( CM_MAX_COLOR_CHANNELS == 15 )
00558
case 2:
00559
case 9:
00560
case 10:
00561
case 11:
00562
case 12:
00563
case 13:
00564
case 14:
00565
case 15:
00566
#endif
00567
calcParam->cmInputColorSpace =
cmMCFiveSpace + lutParam->colorLutInDim-5;
00568 calcParam->cmInputColorSpace |=
cm8PerChannelPacking;
00569
for (loop = 0; loop<lutParam->colorLutInDim; loop++)
00570 calcParam->inputData[loop] = ((
Ptr)myColors) + loop;
00571
break;
00572 }
00573
00574
00575
switch (lutParam->colorLutOutDim)
00576 {
00577
case 1:
00578 calcParam->cmOutputColorSpace =
cmGraySpace;
00579 calcParam->outputData[0] = (
Ptr)myColors;
00580
break;
00581
case 3:
00582 calcParam->cmOutputColorSpace =
cmRGBSpace|
cm16PerChannelPacking;
00583 calcParam->outputData[0] = ((
Ptr)myColors);
00584 calcParam->outputData[1] = ((
Ptr)myColors) + 2;
00585 calcParam->outputData[2] = ((
Ptr)myColors) + 4;
00586
break;
00587
case 4:
00588 calcParam->cmOutputColorSpace =
cmCMYKSpace|
cm16PerChannelPacking;
00589 calcParam->outputData[0] = ((
Ptr)myColors);
00590 calcParam->outputData[1] = ((
Ptr)myColors) + 2;
00591 calcParam->outputData[2] = ((
Ptr)myColors) + 4;
00592 calcParam->outputData[3] = ((
Ptr)myColors) + 6;
00593
break;
00594
case 5:
00595
case 6:
00596
case 7:
00597
case 8:
00598
#if ( CM_MAX_COLOR_CHANNELS == 15 )
00599
case 2:
00600
case 9:
00601
case 10:
00602
case 11:
00603
case 12:
00604
case 13:
00605
case 14:
00606
case 15:
00607
#endif
00608
calcParam->cmOutputColorSpace =
cmMCFiveSpace + lutParam->colorLutOutDim - 5;
00609 calcParam->cmOutputColorSpace |=
cm8PerChannelPacking;
00610
for (loop = 0; loop<lutParam->colorLutOutDim; loop++)
00611 calcParam->outputData[loop] = ((
Ptr)myColors) + loop;
00612
break;
00613 }
00614 calcParam->cmPixelPerLine = count;
00615 calcParam->cmInputBytesPerLine = count*
sizeof(
CMColor);
00616 calcParam->cmOutputBytesPerLine = count*
sizeof(
CMColor);
00617 calcParam->cmLineCount = 1;
00618
LH_END_PROC(
"FillCalcParamCM")
00619 return err;
00620 }
00621
00622 #ifdef PI_Application_h
00623 #define ALLOW_16BIT_DATA
00624 #else
00625 #define Byte_Factor 1
00626 #endif
00627
00628 CMError Do8To555Setup(
CMCalcParamPtr calcParam,
ColorSpaceInfo *info, SINT32 *theLinesAtOnce,
long reverseOrder );
00629 CMError Do8To555Setup(
CMCalcParamPtr calcParam,
ColorSpaceInfo *info, SINT32 *theLinesAtOnce,
long reverseOrder )
00630 {
00631
SINT32 newRowBytes,linesAtOnce,bufferSize;
00632
SINT16 iErr =
noErr;
00633
00634 *theLinesAtOnce = 0;
00635 newRowBytes = calcParam->cmPixelPerLine * 3;
00636 linesAtOnce = (
kMaxTempBlock) / newRowBytes;
00637
if (linesAtOnce == 0)
00638 linesAtOnce = 1;
00639
else if (linesAtOnce > calcParam->cmLineCount)
00640 linesAtOnce = calcParam->cmLineCount;
00641
00642 bufferSize = newRowBytes * linesAtOnce;
00643 info->processedLinesOut = 0;
00644 info->origSizeOut = 5;
00645 info->usedSizeOut = 8;
00646 info->tempOutBuffer = (
void*)
SmartNewPtr(bufferSize, &iErr);
00647 info->outputPixelSize = 16;
00648
if (iErr !=
noErr)
00649 {
00650
return iErr;
00651 }
00652
00653 calcParam->cmLineCount = linesAtOnce;
00654 calcParam->cmOutputColorSpace =
cmRGB24Space;
00655 calcParam->cmOutputBytesPerLine = newRowBytes;
00656
if( reverseOrder ){
00657 calcParam->outputData[2] = (
Ptr)info->tempOutBuffer;
00658 calcParam->outputData[1] = ((
Ptr)info->tempOutBuffer)+1;
00659 calcParam->outputData[0] = ((
Ptr)info->tempOutBuffer)+2;
00660 }
00661
else{
00662 calcParam->outputData[0] = (
Ptr)info->tempOutBuffer;
00663 calcParam->outputData[1] = ((
Ptr)info->tempOutBuffer)+1;
00664 calcParam->outputData[2] = ((
Ptr)info->tempOutBuffer)+2;
00665 }
00666 calcParam->cmOutputPixelOffset = 3;
00667 *theLinesAtOnce = linesAtOnce;
00668
return 0;
00669 }
00670
00671
CMError Do555To8Setup(
CMCalcParamPtr calcParam,
ColorSpaceInfo *info, SINT32 *theLinesAtOnce,
long reverseOrder );
00672
CMError Do555To8Setup(
CMCalcParamPtr calcParam,
ColorSpaceInfo *info, SINT32 *theLinesAtOnce,
long reverseOrder )
00673 {
00674
SINT32 newRowBytes,linesAtOnce,bufferSize;
00675
SINT16 iErr =
noErr;
00676
00677 *theLinesAtOnce = 0;
00678 newRowBytes = calcParam->
cmPixelPerLine * 3;
00679 linesAtOnce = (
kMaxTempBlock) / newRowBytes;
00680
if (linesAtOnce == 0)
00681 linesAtOnce = 1;
00682
else if (linesAtOnce > calcParam->
cmLineCount)
00683 linesAtOnce = calcParam->
cmLineCount;
00684
00685 bufferSize = newRowBytes * linesAtOnce;
00686 info->
processedLinesIn = 0;
00687 info->
origSizeIn = 5;
00688 info->
usedSizeIn = 8;
00689 info->
tempInBuffer = (
void*)
SmartNewPtr(bufferSize, &iErr);
00690 info->
inputPixelSize = 16;
00691
if (iErr !=
noErr)
00692 {
00693
return iErr;
00694 }
00695 calcParam->
cmLineCount = linesAtOnce;
00696 calcParam->
cmInputColorSpace =
cmRGB24Space;
00697 calcParam->
cmInputBytesPerLine = newRowBytes;
00698
if( reverseOrder ){
00699 calcParam->
inputData[2] = (
Ptr)info->
tempInBuffer;
00700 calcParam->
inputData[1] = ((
Ptr)info->
tempInBuffer)+1;
00701 calcParam->
inputData[0] = ((
Ptr)info->
tempInBuffer)+2;
00702 }
00703
else{
00704 calcParam->
inputData[0] = (
Ptr)info->
tempInBuffer;
00705 calcParam->
inputData[1] = ((
Ptr)info->
tempInBuffer)+1;
00706 calcParam->
inputData[2] = ((
Ptr)info->
tempInBuffer)+2;
00707 }
00708 calcParam->
cmInputPixelOffset = 3;
00709 *theLinesAtOnce = linesAtOnce;
00710
return noErr;
00711 }
00712
00713
00714
00715
CMError
00716
CheckInputColorSpace (
const CMBitmap* bitMap,
00717
CMCalcParamPtr calcParam,
00718
ColorSpaceInfo* info,
00719 OSType inColorSpace,
00720
long colorLutInDim )
00721 {
00722
CMError err =
noErr;
00723
SINT32 newRowBytes;
00724
SINT32 bufferSize;
00725
SINT32 linesAtOnce;
00726
SINT32 loop;
00727
SINT16 iErr =
noErr;
00728
CMBitmapColorSpace inputBitMapColorSpace = calcParam->
cmInputColorSpace;
00729
#ifdef ALLOW_16BIT_DATA
00730
UINT8 Byte_Factor=1;
00731
#endif
00732
00733
LH_START_PROC(
"CheckInputColorSpace")
00734 colorLutInDim=colorLutInDim;
00735
00736 #ifdef ALLOW_16BIT_DATA
00737 if( inputBitMapColorSpace & cm16PerChannelPacking && (inputBitMapColorSpace & 31) != cmGraySpace){
00738
Byte_Factor = 2;
00739 inputBitMapColorSpace &= ~
cm16PerChannelPacking;
00740 inputBitMapColorSpace |=
cm8PerChannelPacking;
00741 }
00742
#endif
00743
info->
origSizeIn =
Byte_Factor*8;
00744 info->
usedSizeIn =
Byte_Factor*8;
00745
switch ( inputBitMapColorSpace )
00746 {
00747
case cmNoSpace:
00748
case cmRGBSpace:
00749
case cmHSVSpace:
00750
case cmHLSSpace:
00751
case cmYXYSpace:
00752
case cmXYZSpace:
00753
case cmLUVSpace:
00754
case cmLABSpace:
00755
case cmMCFiveSpace:
00756
case cmMCSixSpace:
00757
case cmMCSevenSpace:
00758
case cmMCEightSpace:
00759
case cmGamutResultSpace:
00760
case cmGamutResult1Space:
00761
#ifdef PI_Application_h
00762
case cmYCCSpace:
00763
case cmBGRSpace:
00764
#endif
00765
err =
cmInvalidSrcMap;
00766
break;
00767
case cmCMYKSpace:
00768
case cmKYMCSpace:
00769 err =
cmInvalidSrcMap;
00770
#if ! realThing
00771
if ( (inColorSpace !=
icSigCmykData) && (inColorSpace !=
icSigCmyData) )
00772 err =
cmInvalidColorSpace;
00773
else
00774 {
00775 err =
noErr;
00776 calcParam->
inputData[0] = &bitMap->
image[0];
00777 calcParam->
inputData[1] = &bitMap->
image[2];
00778 calcParam->
inputData[2] = &bitMap->
image[4];
00779 calcParam->
inputData[3] = &bitMap->
image[6];
00780 calcParam->
cmInputPixelOffset = 8;
00781 info->
origSizeIn = 16;
00782 info->
usedSizeIn = 16;
00783 }
00784
#endif
00785
break;
00786
case cmGraySpace:
00787
if (inColorSpace !=
icSigGrayData)
00788 err =
cmInvalidColorSpace;
00789
else
00790 {
00791 calcParam->
inputData[0] = &bitMap->
image[0];
00792 calcParam->
cmInputPixelOffset = 2;
00793 info->
origSizeIn = 16;
00794 info->
usedSizeIn = 16;
00795 info->
inputPixelSize = 16;
00796 }
00797
break;
00798
case cmGrayASpace:
00799
if (inColorSpace !=
icSigGrayData)
00800 err =
cmInvalidColorSpace;
00801
else
00802 {
00803 calcParam->
inputData[0] = &bitMap->
image[0];
00804 calcParam->
inputData[1] = &bitMap->
image[2];
00805 calcParam->
cmInputPixelOffset = 4;
00806 info->
origSizeIn = 16;
00807 info->
usedSizeIn = 16;
00808 info->
inputPixelSize = 32;
00809 }
00810
break;
00811
case cmLAB24Space:
00812
if (inColorSpace !=
icSigLabData)
00813 err =
cmInvalidColorSpace;
00814
else
00815 {
00816 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
00817 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00818 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
00819 calcParam->
cmInputPixelOffset =
Byte_Factor*3;
00820 info->
inputPixelSize =
Byte_Factor*24;
00821 }
00822
break;
00823
00824
00825
case cmRGB24Space:
00826
if (inColorSpace !=
icSigRgbData)
00827 err =
cmInvalidColorSpace;
00828
else
00829 {
00830 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
00831 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00832 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
00833 calcParam->
cmInputPixelOffset =
Byte_Factor*3;
00834 info->
inputPixelSize =
Byte_Factor*24;
00835 }
00836
break;
00837
case cmRGB32Space:
00838
if (inColorSpace !=
icSigRgbData)
00839 err =
cmInvalidColorSpace;
00840
else
00841 {
00842 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*1];
00843 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*2];
00844 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*3];
00845 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*0];
00846 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00847 info->
inputPixelSize =
Byte_Factor*32;
00848 }
00849
break;
00850
00851
case cmRGBASpace:
00852
case cmRGBA32Space:
00853
if (inColorSpace !=
icSigRgbData)
00854 err =
cmInvalidColorSpace;
00855
else
00856 {
00857 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
00858 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00859 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
00860 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*3];
00861 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00862 info->
inputPixelSize =
Byte_Factor*32;
00863 }
00864
break;
00865
00866
#ifdef PI_Application_h
00867
00868
case cmGraySpace|
cm8PerChannelPacking:
00869
if (inColorSpace !=
icSigGrayData)
00870 err =
cmInvalidColorSpace;
00871
else
00872 {
00873 calcParam->
inputData[0] = &bitMap->
image[0];
00874 calcParam->
cmInputPixelOffset = 1;
00875 info->
origSizeIn = 8;
00876 info->
usedSizeIn = 8;
00877 info->
inputPixelSize = 8;
00878 }
00879
break;
00880
case cmGrayASpace|
cm8PerChannelPacking:
00881
if (inColorSpace !=
icSigGrayData)
00882 err =
cmInvalidColorSpace;
00883
else
00884 {
00885 calcParam->
inputData[0] = &bitMap->
image[0];
00886 calcParam->
inputData[1] = &bitMap->
image[1];
00887 calcParam->
cmInputPixelOffset = 2;
00888 info->
origSizeIn = 8;
00889 info->
usedSizeIn = 8;
00890 info->
inputPixelSize = 16;
00891 }
00892
break;
00893
00894
00895
case cmBGR24Space:
00896
if (inColorSpace !=
icSigRgbData)
00897 err =
cmInvalidColorSpace;
00898
else
00899 {
00900 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*2];
00901 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00902 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*0];
00903 calcParam->
cmInputPixelOffset =
Byte_Factor*3;
00904 info->
inputPixelSize =
Byte_Factor*24;
00905 }
00906
break;
00907
case cmBGR32Space:
00908
if (inColorSpace !=
icSigRgbData)
00909 err =
cmInvalidColorSpace;
00910
else
00911 {
00912 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*2];
00913 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00914 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*0];
00915 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*3];
00916 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00917 info->
inputPixelSize =
Byte_Factor*32;
00918 }
00919
break;
00920
00921
case cmYCC32Space:
00922
if (inColorSpace !=
icSigYCbCrData)
00923 err =
cmInvalidColorSpace;
00924
else
00925 {
00926 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*1];
00927 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*2];
00928 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*3];
00929 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*0];
00930 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00931 info->
inputPixelSize =
Byte_Factor*32;
00932 }
00933
break;
00934
case cmYCC24Space:
00935
if (inColorSpace !=
icSigYCbCrData)
00936 err =
cmInvalidColorSpace;
00937
else
00938 {
00939 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
00940 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00941 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
00942 calcParam->
cmInputPixelOffset =
Byte_Factor*3;
00943 info->
inputPixelSize =
Byte_Factor*24;
00944 }
00945
break;
00946
00947
case cmYCCASpace:
00948
case cmYCCA32Space:
00949
if (inColorSpace !=
icSigYCbCrData)
00950 err =
cmInvalidColorSpace;
00951
else
00952 {
00953 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
00954 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00955 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
00956 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*3];
00957 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00958 info->
inputPixelSize =
Byte_Factor*32;
00959 }
00960
break;
00961
case cmAYCC32Space:
00962
if (inColorSpace !=
icSigYCbCrData)
00963 err =
cmInvalidColorSpace;
00964
else
00965 {
00966 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*1];
00967 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*2];
00968 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*3];
00969 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*0];
00970 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00971 info->
inputPixelSize =
Byte_Factor*32;
00972 }
00973
break;
00974
case cmLong8ColorPacking +
cmLABSpace:
00975
if (inColorSpace !=
icSigLabData)
00976 err =
cmInvalidColorSpace;
00977
else
00978 {
00979 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
00980 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00981 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
00982 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*3];
00983 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00984 info->
inputPixelSize =
Byte_Factor*32;
00985 }
00986
break;
00987
case cmLong8ColorPacking +
cmXYZSpace:
00988
if (inColorSpace !=
icSigXYZData)
00989 err =
cmInvalidColorSpace;
00990
else
00991 {
00992 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
00993 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
00994 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
00995 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*3];
00996 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
00997 info->
inputPixelSize =
Byte_Factor*32;
00998 }
00999
break;
01000
case cmLong8ColorPacking +
cmYXYSpace:
01001
if (inColorSpace !=
icSigYxyData)
01002 err =
cmInvalidColorSpace;
01003
else
01004 {
01005 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
01006 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
01007 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
01008 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*3];
01009 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
01010 info->
inputPixelSize =
Byte_Factor*32;
01011 }
01012
break;
01013
case cmGenericSpace +
cm8PerChannelPacking:
01014 {
01015
for (loop = 0; loop< colorLutInDim; loop++)
01016 calcParam->
inputData[loop] = &bitMap->
image[
Byte_Factor*loop];
01017 calcParam->
cmInputPixelOffset =
Byte_Factor*colorLutInDim;
01018 info->
inputPixelSize =
Byte_Factor*colorLutInDim*8;
01019 }
01020
break;
01021
case cmGenericSpace +
cmLong8ColorPacking:
01022 {
01023
for (loop = 0; loop< (colorLutInDim+1); loop++)
01024 calcParam->
inputData[loop] = &bitMap->
image[
Byte_Factor*loop];
01025 calcParam->
cmInputPixelOffset =
Byte_Factor*(colorLutInDim+1);
01026 info->
inputPixelSize =
Byte_Factor*(colorLutInDim+1)*8;
01027 }
01028
break;
01029
case cmCMY24Space:
01030
if ( inColorSpace !=
icSigCmyData )
01031 err =
cmInvalidColorSpace;
01032
else
01033 {
01034 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
01035 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
01036 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
01037 calcParam->
cmInputPixelOffset =
Byte_Factor*3;
01038 info->
inputPixelSize =
Byte_Factor*24;
01039 }
01040
break;
01041
#endif
01042
01043
case cmCMYK32Space:
01044
if ( (inColorSpace !=
icSigCmykData) && (inColorSpace !=
icSigCmyData) )
01045 err =
cmInvalidColorSpace;
01046
else
01047 {
01048 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*0];
01049 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*1];
01050 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*2];
01051 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*3];
01052 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
01053 info->
inputPixelSize =
Byte_Factor*32;
01054 }
01055
break;
01056
case cmKYMC32Space:
01057
if ( (inColorSpace !=
icSigCmykData) && (inColorSpace !=
icSigCmyData) )
01058 err =
cmInvalidColorSpace;
01059
else
01060 {
01061 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*0];
01062 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*1];
01063 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*2];
01064 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*3];
01065 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
01066 info->
inputPixelSize =
Byte_Factor*32;
01067 }
01068
break;
01069
case cmARGB32Space:
01070
if (inColorSpace !=
icSigRgbData)
01071 err =
cmInvalidColorSpace;
01072
else
01073 {
01074 calcParam->
inputData[0] = &bitMap->
image[
Byte_Factor*1];
01075 calcParam->
inputData[1] = &bitMap->
image[
Byte_Factor*2];
01076 calcParam->
inputData[2] = &bitMap->
image[
Byte_Factor*3];
01077 calcParam->
inputData[3] = &bitMap->
image[
Byte_Factor*0];
01078 calcParam->
cmInputPixelOffset =
Byte_Factor*4;
01079 info->
inputPixelSize =
Byte_Factor*32;
01080 }
01081
break;
01082
case cmMCFive8Space:
01083
if (inColorSpace !=
icSigMCH5Data)
01084 err =
cmInvalidColorSpace;
01085
else
01086 {
01087
for (loop = 0; loop< 5; loop++)
01088 calcParam->
inputData[loop] = &bitMap->
image[
Byte_Factor*loop];
01089 calcParam->
cmInputPixelOffset =
Byte_Factor*5;
01090 info->
inputPixelSize =
Byte_Factor*40;
01091 }
01092
break;
01093
case cmMCSix8Space:
01094
if (inColorSpace !=
icSigMCH6Data)
01095 err =
cmInvalidColorSpace;
01096
else
01097 {
01098
for (loop = 0; loop< 6; loop++)
01099 calcParam->
inputData[loop] = &bitMap->
image[
Byte_Factor*loop];
01100 calcParam->
cmInputPixelOffset =
Byte_Factor*6;
01101 info->
inputPixelSize =
Byte_Factor*48;
01102 }
01103
break;
01104
case cmMCSeven8Space:
01105
if (inColorSpace !=
icSigMCH7Data)
01106 err =
cmInvalidColorSpace;
01107
else
01108 {
01109
for (loop = 0; loop< 7; loop++)
01110 calcParam->
inputData[loop] = &bitMap->
image[
Byte_Factor*loop];
01111 calcParam->
cmInputPixelOffset =
Byte_Factor*7;
01112 info->
inputPixelSize =
Byte_Factor*56;
01113 }
01114
break;
01115
case cmMCEight8Space:
01116
if (inColorSpace !=
icSigMCH8Data)
01117 err =
cmInvalidColorSpace;
01118
else
01119 {
01120
for (loop = 0; loop< 8; loop++)
01121 calcParam->
inputData[loop] = &bitMap->
image[
Byte_Factor*loop];
01122 calcParam->
cmInputPixelOffset =
Byte_Factor*8;
01123 info->
inputPixelSize =
Byte_Factor*64;
01124 }
01125
break;
01126
#if ( CM_MAX_COLOR_CHANNELS == 15 )
01127
case cmMC98Space:
01128
case cmMCa8Space:
01129
case cmMCb8Space:
01130
case cmMCc8Space:
01131
case cmMCd8Space:
01132
case cmMCe8Space:
01133
case cmMCf8Space:
01134
case cmMC28Space:
01135
if (inColorSpace !=
icSigMCH8Data)
01136 err =
cmInvalidColorSpace;
01137
else
01138 {
01139
for (loop = 0; loop< 8; loop++)
01140 calcParam->
inputData[loop] = &bitMap->
image[
Byte_Factor*loop];
01141 calcParam->
cmInputPixelOffset =
Byte_Factor*8;
01142 info->
inputPixelSize =
Byte_Factor*64;
01143 }
01144
break;
01145
#endif
01146
#ifdef PI_Application_h
01147
case cmWord5ColorPacking +
cmLABSpace:
01148
if (inColorSpace !=
icSigLabData)
01149 err =
cmInvalidColorSpace;
01150
else{
01151 newRowBytes = calcParam->
cmInputBytesPerLine;
01152 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 0 );
01153
if( err )
goto CleanupAndExit;
01154 }
01155
break;
01156
case cmWord5ColorPacking +
cmXYZSpace:
01157
if (inColorSpace !=
icSigXYZData)
01158 err =
cmInvalidColorSpace;
01159
else{
01160 newRowBytes = calcParam->
cmInputBytesPerLine;
01161 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 0 );
01162
if( err )
goto CleanupAndExit;
01163 }
01164
break;
01165
case cmWord5ColorPacking +
cmYXYSpace:
01166
if (inColorSpace !=
icSigYxyData)
01167 err =
cmInvalidColorSpace;
01168
else{
01169 newRowBytes = calcParam->
cmInputBytesPerLine;
01170 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 0 );
01171
if( err )
goto CleanupAndExit;
01172 }
01173
break;
01174
case cmWord5ColorPacking +
cmGenericSpace:
01175 {
01176 newRowBytes = calcParam->
cmInputBytesPerLine;
01177 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 0 );
01178
if( err )
goto CleanupAndExit;
01179 }
01180
break;
01181
case cmWord565ColorPacking +
cmGenericSpace:
01182 {
01183 newRowBytes = calcParam->
cmInputBytesPerLine;
01184 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 0 );
01185
if( err )
goto CleanupAndExit;
01186 info->
origSizeIn = 6;
01187 }
01188
break;
01189
case cmWord5ColorPacking +
cmBGRSpace:
01190
if (inColorSpace !=
icSigRgbData)
01191 err =
cmInvalidColorSpace;
01192
else{
01193 newRowBytes = calcParam->
cmInputBytesPerLine;
01194 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 1 );
01195
if( err )
goto CleanupAndExit;
01196 }
01197
break;
01198
case cmWord565ColorPacking +
cmBGRSpace:
01199
if (inColorSpace !=
icSigRgbData)
01200 err =
cmInvalidColorSpace;
01201
else{
01202 newRowBytes = calcParam->
cmInputBytesPerLine;
01203 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 1 );
01204
if( err )
goto CleanupAndExit;
01205 info->
origSizeIn = 6;
01206 }
01207
break;
01208
case cmRGB16_565Space:
01209
#endif
01210
case cmRGB16Space:
01211
if (inColorSpace !=
icSigRgbData)
01212 err =
cmInvalidColorSpace;
01213
else{
01214 newRowBytes = calcParam->
cmInputBytesPerLine;
01215 err =
Do555To8Setup( calcParam, info, &linesAtOnce, 0 );
01216
if( err )
goto CleanupAndExit;
01217
#ifdef PI_Application_h
01218
if( inputBitMapColorSpace ==
cmRGB16_565Space ){
01219 info->
origSizeIn = 6;
01220 }
01221
#endif
01222
}
01223
break;
01224
case cmNamedIndexed32Space:
01225
if( (inputBitMapColorSpace ==
cmNamedIndexed32Space) && (inColorSpace !=
icSigNamedData)){
01226 err =
cmInvalidColorSpace;
01227 }
01228
else{
01229 newRowBytes = calcParam->
cmPixelPerLine * 3;
01230 linesAtOnce = (
kMaxTempBlock) / newRowBytes;
01231
if (linesAtOnce == 0)
01232 linesAtOnce = 1;
01233
else if (linesAtOnce > calcParam->
cmLineCount)
01234 linesAtOnce = calcParam->
cmLineCount;
01235
01236 bufferSize = newRowBytes * linesAtOnce;
01237 info->
processedLinesIn = 0;
01238 info->
origSizeIn = 8;
01239 info->
usedSizeIn = 8;
01240 info->
tempInBuffer = (
void*)
SmartNewPtr(bufferSize, &iErr);
01241 info->
inputPixelSize = 32;
01242
if (iErr !=
noErr)
01243 {
01244 err = iErr;
01245
goto CleanupAndExit;
01246 }
01247
01248 calcParam->
cmLineCount = linesAtOnce;
01249 calcParam->
cmInputColorSpace =
cmLAB24Space;
01250 calcParam->
inputData[0] = ((
Ptr)info->
tempInBuffer)+0;
01251 calcParam->
inputData[1] = ((
Ptr)info->
tempInBuffer)+1;
01252 calcParam->
inputData[2] = ((
Ptr)info->
tempInBuffer)+2;
01253
01254 calcParam->
cmInputBytesPerLine = newRowBytes;
01255 calcParam->
cmInputPixelOffset = 3;
01256 }
01257
break;
01258
case cmHSV32Space:
01259
case cmHLS32Space:
01260
case cmYXY32Space:
01261
case cmXYZ32Space:
01262
case cmLUV32Space:
01263
case cmLAB32Space:
01264
#ifdef PI_Application_h
01265
case cmBGRSpace +
cmLong10ColorPacking:
01266
case cmRGBSpace +
cmLong10ColorPacking:
01267
case cmGenericSpace +
cmLong10ColorPacking:
01268
#endif
01269
if( ( ((inputBitMapColorSpace ==
cmHSV32Space) && (inColorSpace !=
icSigHsvData)) ||
01270 ((inputBitMapColorSpace ==
cmHLS32Space) && (inColorSpace !=
icSigHlsData)) ||
01271 ((inputBitMapColorSpace ==
cmYXY32Space) && (inColorSpace !=
icSigYxyData)) ||
01272 ((inputBitMapColorSpace ==
cmXYZ32Space) && (inColorSpace !=
icSigXYZData)) ||
01273 ((inputBitMapColorSpace ==
cmLUV32Space) && (inColorSpace !=
icSigLuvData)) ||
01274 ((inputBitMapColorSpace ==
cmLAB32Space) && (inColorSpace !=
icSigLabData))
01275
#ifdef PI_Application_h
01276
|| ((inputBitMapColorSpace ==
cmBGRSpace +
cmLong10ColorPacking) && (inColorSpace !=
icSigRgbData))
01277 || ((inputBitMapColorSpace ==
cmRGBSpace +
cmLong10ColorPacking) && (inColorSpace !=
icSigRgbData))
01278 || ((inputBitMapColorSpace ==
cmGenericSpace +
cmLong10ColorPacking) && (inColorSpace !=
icSigMCH3Data))
01279
#endif
01280
)
01281
#if ! realThing
01282
&&
FALSE
01283
#endif
01284
)
01285 err =
cmInvalidColorSpace;
01286
else{
01287 newRowBytes = calcParam->
cmPixelPerLine * 3 *
sizeof(
SINT16);
01288 linesAtOnce = (
kMaxTempBlock) / newRowBytes;
01289
if (linesAtOnce == 0)
01290 linesAtOnce = 1;
01291
else if (linesAtOnce > calcParam->
cmLineCount)
01292 linesAtOnce = calcParam->
cmLineCount;
01293
01294 bufferSize = newRowBytes * linesAtOnce;
01295 info->
processedLinesIn = 0;
01296 info->
origSizeIn = 10;
01297 info->
usedSizeIn = 16;
01298 info->
tempInBuffer = (
void*)
SmartNewPtr(bufferSize, &iErr);
01299 info->
inputPixelSize = 32;
01300
if (iErr !=
noErr)
01301 {
01302 err = iErr;
01303
goto CleanupAndExit;
01304 }
01305
01306 calcParam->
cmLineCount = linesAtOnce;
01307
if( inputBitMapColorSpace ==
cmBGRSpace +
cmLong10ColorPacking ){
01308 calcParam->
cmInputColorSpace =
cmBGRSpace;
01309 calcParam->
inputData[0] = ((
Ptr)info->
tempInBuffer)+4;
01310 calcParam->
inputData[1] = ((
Ptr)info->
tempInBuffer)+2;
01311 calcParam->
inputData[2] = ((
Ptr)info->
tempInBuffer)+0;
01312 }
01313
else{
01314 calcParam->
cmInputColorSpace =
cmRGBSpace;
01315 calcParam->
inputData[0] = ((
Ptr)info->
tempInBuffer)+0;
01316 calcParam->
inputData[1] = ((
Ptr)info->
tempInBuffer)+2;
01317 calcParam->
inputData[2] = ((
Ptr)info->
tempInBuffer)+4;
01318 }
01319 calcParam->
cmInputBytesPerLine = newRowBytes;
01320 calcParam->
cmInputPixelOffset = 6;
01321 }
01322
break;
01323
default:
01324 err =
cmInvalidSrcMap;
01325
break;
01326 }
01327
01328 CleanupAndExit:
01329
LH_END_PROC(
"CheckInputColorSpace")
01330 return err;
01331 }
01332
01333
01334
01335
01336 CMError
01337 CheckOutputColorSpace (const
CMBitmap* bitMap,
01338
CMCalcParamPtr calcParam,
01339
ColorSpaceInfo* info,
01340 OSType outColorSpace,
01341
long colorLutOutDim )
01342 {
01343
CMError err =
noErr;
01344
SINT32 newRowBytes;
01345
SINT32 bufferSize;
01346
SINT32 linesAtOnce;
01347
SINT32 loop;
01348
SINT16 iErr =
noErr;
01349
CMBitmapColorSpace outputBitMapColorSpace = calcParam->cmOutputColorSpace;
01350
#ifdef ALLOW_16BIT_DATA
01351
UINT8 Byte_Factor=1;
01352
#endif
01353
01354
LH_START_PROC(
"CheckOutputColorSpace")
01355 colorLutOutDim = colorLutOutDim;
01356
01357 #ifdef ALLOW_16BIT_DATA
01358 if( outputBitMapColorSpace & cm16PerChannelPacking && (outputBitMapColorSpace & 31) != cmGraySpace){
01359
Byte_Factor = 2;
01360 outputBitMapColorSpace &= ~
cm16PerChannelPacking;
01361 outputBitMapColorSpace |=
cm8PerChannelPacking;
01362 }
01363
#endif
01364
info->origSizeOut =
Byte_Factor*8;
01365 info->usedSizeOut =
Byte_Factor*8;
01366
switch ( outputBitMapColorSpace )
01367 {
01368
case cmNoSpace:
01369
case cmRGBSpace:
01370
case cmHSVSpace:
01371
case cmHLSSpace:
01372
case cmYXYSpace:
01373
case cmXYZSpace:
01374
case cmLUVSpace:
01375
case cmLABSpace:
01376
case cmMCFiveSpace:
01377
case cmMCSixSpace:
01378
case cmMCSevenSpace:
01379
case cmMCEightSpace:
01380
case cmGamutResultSpace:
01381
case cmGamutResult1Space:
01382
#ifdef PI_Application_h
01383
case cmYCCSpace:
01384
case cmBGRSpace:
01385
#endif
01386
err =
cmInvalidDstMap;
01387
break;
01388
case cmCMYKSpace:
01389
case cmKYMCSpace:
01390 err =
cmInvalidDstMap;
01391
#if ! realThing
01392
if ( (outColorSpace !=
icSigCmykData) && (outColorSpace !=
icSigCmyData) )
01393 err =
cmInvalidColorSpace;
01394
else
01395 {
01396 calcParam->outputData[0] = &bitMap->image[0];
01397 calcParam->outputData[1] = &bitMap->image[2];
01398 calcParam->outputData[2] = &bitMap->image[4];
01399 calcParam->outputData[3] = &bitMap->image[6];
01400 calcParam->cmOutputPixelOffset = 8;
01401 info->usedSizeOut = 16;
01402 }
01403
#endif
01404
break;
01405
case cmGraySpace:
01406
if (outColorSpace !=
icSigGrayData)
01407 err =
cmInvalidColorSpace;
01408
else
01409 {
01410 calcParam->outputData[0] = &bitMap->image[0];
01411 calcParam->cmOutputPixelOffset = 2;
01412 info->usedSizeOut = 16;
01413 info->outputPixelSize = 16;
01414 }
01415
break;
01416
case cmGrayASpace:
01417
if (outColorSpace !=
icSigGrayData)
01418 err =
cmInvalidColorSpace;
01419
else
01420 {
01421 calcParam->outputData[0] = &bitMap->image[0];
01422 calcParam->outputData[1] = &bitMap->image[2];
01423 calcParam->cmOutputPixelOffset = 4;
01424 info->usedSizeOut = 16;
01425 info->outputPixelSize = 32;
01426 }
01427
break;
01428
case cmLAB24Space:
01429
if (outColorSpace !=
icSigLabData)
01430 err =
cmInvalidColorSpace;
01431
else
01432 {
01433 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01434 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01435 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01436 calcParam->cmOutputPixelOffset =
Byte_Factor*3;
01437 info->outputPixelSize =
Byte_Factor*24;
01438 }
01439
break;
01440
01441
01442
case cmRGB24Space:
01443
if (outColorSpace !=
icSigRgbData)
01444 err =
cmInvalidColorSpace;
01445
else
01446 {
01447 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01448 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01449 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01450 calcParam->cmOutputPixelOffset =
Byte_Factor*3;
01451 info->outputPixelSize =
Byte_Factor*24;
01452 }
01453
break;
01454
case cmRGB32Space:
01455
if (outColorSpace !=
icSigRgbData)
01456 err =
cmInvalidColorSpace;
01457
else
01458 {
01459 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*1];
01460 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*2];
01461 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*3];
01462 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*0];
01463 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01464 calcParam->clearMask =
TRUE;
01465 info->outputPixelSize =
Byte_Factor*32;
01466 }
01467
break;
01468
01469
case cmRGBASpace:
01470
case cmRGBA32Space:
01471
if (outColorSpace !=
icSigRgbData)
01472 err =
cmInvalidColorSpace;
01473
else
01474 {
01475 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01476 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01477 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01478 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*3];
01479 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01480 info->outputPixelSize =
Byte_Factor*32;
01481 }
01482
break;
01483
01484
#ifdef PI_Application_h
01485
case cmGraySpace|
cm8PerChannelPacking:
01486
if (outColorSpace !=
icSigGrayData)
01487 err =
cmInvalidColorSpace;
01488
else
01489 {
01490 calcParam->outputData[0] = &bitMap->image[0];
01491 calcParam->cmOutputPixelOffset = 1;
01492 info->usedSizeOut = 8;
01493 info->outputPixelSize = 8;
01494 }
01495
break;
01496
case cmGrayASpace|
cm8PerChannelPacking:
01497
if (outColorSpace !=
icSigGrayData)
01498 err =
cmInvalidColorSpace;
01499
else
01500 {
01501 calcParam->outputData[0] = &bitMap->image[0];
01502 calcParam->outputData[1] = &bitMap->image[1];
01503 calcParam->cmOutputPixelOffset = 2;
01504 info->usedSizeOut = 8;
01505 info->outputPixelSize = 16;
01506 }
01507
break;
01508
01509
case cmBGR24Space:
01510
if (outColorSpace !=
icSigRgbData)
01511 err =
cmInvalidColorSpace;
01512
else
01513 {
01514 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*2];
01515 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01516 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*0];
01517 calcParam->cmOutputPixelOffset =
Byte_Factor*3;
01518 info->outputPixelSize =
Byte_Factor*24;
01519 }
01520
break;
01521
case cmBGR32Space:
01522
if (outColorSpace !=
icSigRgbData)
01523 err =
cmInvalidColorSpace;
01524
else
01525 {
01526 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*2];
01527 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01528 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*0];
01529 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*3];
01530 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01531 calcParam->clearMask =
FALSE;
01532 calcParam->copyAlpha =
TRUE;
01533 info->outputPixelSize =
Byte_Factor*32;
01534 }
01535
break;
01536
01537
case cmYCC24Space:
01538
if (outColorSpace !=
icSigYCbCrData)
01539 err =
cmInvalidColorSpace;
01540
else
01541 {
01542 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01543 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01544 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01545 calcParam->cmOutputPixelOffset =
Byte_Factor*3;
01546 info->outputPixelSize =
Byte_Factor*24;
01547 }
01548
break;
01549
case cmYCC32Space:
01550
if (outColorSpace !=
icSigYCbCrData)
01551 err =
cmInvalidColorSpace;
01552
else
01553 {
01554 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*1];
01555 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*2];
01556 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*3];
01557 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*0];
01558 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01559 calcParam->clearMask =
TRUE;
01560 info->outputPixelSize =
Byte_Factor*32;
01561 }
01562
break;
01563
01564
case cmYCCASpace:
01565
case cmYCCA32Space:
01566
if (outColorSpace !=
icSigYCbCrData)
01567 err =
cmInvalidColorSpace;
01568
else
01569 {
01570 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01571 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01572 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01573 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*3];
01574 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01575 info->outputPixelSize =
Byte_Factor*32;
01576 }
01577
break;
01578
case cmAYCC32Space:
01579
if (outColorSpace !=
icSigYCbCrData)
01580 err =
cmInvalidColorSpace;
01581
else
01582 {
01583 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*1];
01584 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*2];
01585 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*3];
01586 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*0];
01587 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01588 info->outputPixelSize =
Byte_Factor*32;
01589 }
01590
break;
01591
case cmLong8ColorPacking +
cmLABSpace:
01592
if (outColorSpace !=
icSigLabData)
01593 err =
cmInvalidColorSpace;
01594
else
01595 {
01596 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01597 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01598 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01599 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*3];
01600 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01601 info->outputPixelSize =
Byte_Factor*32;
01602 }
01603
break;
01604
case cmLong8ColorPacking +
cmXYZSpace:
01605
if (outColorSpace !=
icSigXYZData)
01606 err =
cmInvalidColorSpace;
01607
else
01608 {
01609 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01610 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01611 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01612 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*3];
01613 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01614 info->outputPixelSize =
Byte_Factor*32;
01615 }
01616
break;
01617
case cmLong8ColorPacking +
cmYXYSpace:
01618
if (outColorSpace !=
icSigYxyData)
01619 err =
cmInvalidColorSpace;
01620
else
01621 {
01622 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01623 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01624 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01625 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*3];
01626 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01627 info->outputPixelSize =
Byte_Factor*32;
01628 }
01629
break;
01630
case cmGenericSpace +
cm8PerChannelPacking:
01631 {
01632
for (loop = 0; loop< colorLutOutDim; loop++)
01633 calcParam->outputData[loop] = &bitMap->image[
Byte_Factor*loop];
01634 calcParam->cmOutputPixelOffset =
Byte_Factor*colorLutOutDim;
01635 info->outputPixelSize =
Byte_Factor*colorLutOutDim*8;
01636 }
01637
break;
01638
case cmGenericSpace +
cmLong8ColorPacking:
01639 {
01640
for (loop = 0; loop< (colorLutOutDim+1); loop++)
01641 calcParam->outputData[loop] = &bitMap->image[
Byte_Factor*loop];
01642 calcParam->cmOutputPixelOffset =
Byte_Factor*(colorLutOutDim+1);
01643 info->outputPixelSize =
Byte_Factor*(colorLutOutDim+1)*8;
01644 }
01645
break;
01646
case cmCMY24Space:
01647
if ( outColorSpace !=
icSigCmyData )
01648 err =
cmInvalidColorSpace;
01649
else
01650 {
01651 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01652 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01653 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01654 calcParam->cmOutputPixelOffset =
Byte_Factor*3;
01655 info->outputPixelSize =
Byte_Factor*24;
01656 }
01657
break;
01658
#endif
01659
01660
case cmCMYK32Space:
01661
if ( (outColorSpace !=
icSigCmykData) && (outColorSpace !=
icSigCmyData) )
01662 err =
cmInvalidColorSpace;
01663
else
01664 {
01665 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*0];
01666 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*1];
01667 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*2];
01668 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*3];
01669 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01670
if (outColorSpace ==
icSigCmyData)
01671 calcParam->clearMask =
TRUE;
01672 info->outputPixelSize =
Byte_Factor*32;
01673 }
01674
break;
01675
case cmKYMC32Space:
01676
if ( (outColorSpace !=
icSigCmykData) && (outColorSpace !=
icSigCmyData) )
01677 err =
cmInvalidColorSpace;
01678
else
01679 {
01680 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*0];
01681 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*1];
01682 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*2];
01683 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*3];
01684 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01685
if (outColorSpace ==
icSigCmyData)
01686 calcParam->clearMask =
TRUE;
01687 info->outputPixelSize =
Byte_Factor*32;
01688 }
01689
break;
01690
case cmARGB32Space:
01691
if (outColorSpace !=
icSigRgbData)
01692 err =
cmInvalidColorSpace;
01693
else
01694 {
01695 calcParam->outputData[0] = &bitMap->image[
Byte_Factor*1];
01696 calcParam->outputData[1] = &bitMap->image[
Byte_Factor*2];
01697 calcParam->outputData[2] = &bitMap->image[
Byte_Factor*3];
01698 calcParam->outputData[3] = &bitMap->image[
Byte_Factor*0];
01699 calcParam->cmOutputPixelOffset =
Byte_Factor*4;
01700 info->outputPixelSize =
Byte_Factor*32;
01701 }
01702
break;
01703
case cmMCFive8Space:
01704
if (outColorSpace !=
icSigMCH5Data)
01705 err =
cmInvalidColorSpace;
01706
else
01707 {
01708
for (loop = 0; loop< 5; loop++)
01709 calcParam->outputData[loop] = &bitMap->image[
Byte_Factor*loop];
01710 calcParam->cmOutputPixelOffset =
Byte_Factor*5;
01711 info->outputPixelSize =
Byte_Factor*40;
01712 }
01713
break;
01714
case cmMCSix8Space:
01715
if (outColorSpace !=
icSigMCH6Data)
01716 err =
cmInvalidColorSpace;
01717
else
01718 {
01719
for (loop = 0; loop< 6; loop++)
01720 calcParam->outputData[loop] = &bitMap->image[
Byte_Factor*loop];
01721 calcParam->cmOutputPixelOffset =
Byte_Factor*6;
01722 info->outputPixelSize =
Byte_Factor*48;
01723 }
01724
break;
01725
case cmMCSeven8Space:
01726
if (outColorSpace !=
icSigMCH7Data)
01727 err =
cmInvalidColorSpace;
01728
else
01729 {
01730
for (loop = 0; loop< 7; loop++)
01731 calcParam->outputData[loop] = &bitMap->image[
Byte_Factor*loop];
01732 calcParam->cmOutputPixelOffset =
Byte_Factor*7;
01733 info->outputPixelSize =
Byte_Factor*56;
01734 }
01735
break;
01736
case cmMCEight8Space:
01737
if (outColorSpace !=
icSigMCH8Data)
01738 err =
cmInvalidColorSpace;
01739
else
01740 {
01741
for (loop = 0; loop< 8; loop++)
01742 calcParam->outputData[loop] = &bitMap->image[
Byte_Factor*loop];
01743 calcParam->cmOutputPixelOffset =
Byte_Factor*8;
01744 info->outputPixelSize =
Byte_Factor*64;
01745 }
01746
break;
01747
#ifdef PI_Application_h
01748
case cmWord5ColorPacking +
cmLABSpace:
01749
if (outColorSpace !=
icSigLabData)
01750 err =
cmInvalidColorSpace;
01751
else{
01752 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 0 );
01753
if( err )
goto CleanupAndExit;
01754 }
01755
break;
01756
case cmWord5ColorPacking +
cmXYZSpace:
01757
if (outColorSpace !=
icSigXYZData)
01758 err =
cmInvalidColorSpace;
01759
else{
01760 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 0 );
01761
if( err )
goto CleanupAndExit;
01762 }
01763
break;
01764
case cmWord5ColorPacking +
cmYXYSpace:
01765
if (outColorSpace !=
icSigYxyData)
01766 err =
cmInvalidColorSpace;
01767
else{
01768 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 0 );
01769
if( err )
goto CleanupAndExit;
01770 }
01771
break;
01772
case cmWord5ColorPacking +
cmGenericSpace:
01773 {
01774 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 0 );
01775
if( err )
goto CleanupAndExit;
01776 }
01777
break;
01778
case cmWord565ColorPacking +
cmGenericSpace:
01779 {
01780 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 0 );
01781
if( err )
goto CleanupAndExit;
01782 info->origSizeOut = 6;
01783 }
01784
break;
01785
case cmWord5ColorPacking +
cmBGRSpace:
01786
if (outColorSpace !=
icSigRgbData)
01787 err =
cmInvalidColorSpace;
01788
else{
01789 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 1 );
01790
if( err )
goto CleanupAndExit;
01791 }
01792
break;
01793
case cmWord565ColorPacking +
cmBGRSpace:
01794
if (outColorSpace !=
icSigRgbData)
01795 err =
cmInvalidColorSpace;
01796
else{
01797 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 1 );
01798
if( err )
goto CleanupAndExit;
01799 info->origSizeOut = 6;
01800 }
01801
break;
01802
case cmRGB16_565Space:
01803
#endif
01804
case cmRGB16Space:
01805
if (outColorSpace !=
icSigRgbData)
01806 err =
cmInvalidColorSpace;
01807
else{
01808 err =
Do8To555Setup( calcParam, info, &linesAtOnce, 0 );
01809
if( err )
goto CleanupAndExit;
01810
#ifdef PI_Application_h
01811
if( outputBitMapColorSpace ==
cmRGB16_565Space ){
01812 info->origSizeOut = 6;
01813 }
01814
#endif
01815
}
01816
break;
01817
case cmNamedIndexed32Space:
01818
if( (outColorSpace ==
cmNamedIndexed32Space) && (outColorSpace !=
icSigNamedData)){
01819 err =
cmInvalidColorSpace;
01820 }
01821
else{
01822 calcParam->outputData[0] = &bitMap->image[0];
01823 calcParam->outputData[1] = &bitMap->image[1];
01824 calcParam->outputData[2] = &bitMap->image[2];
01825 calcParam->outputData[3] = &bitMap->image[3];
01826 calcParam->cmOutputPixelOffset = 4;
01827 info->outputPixelSize = 32;
01828 }
01829
break;
01830
case cmHSV32Space:
01831
case cmHLS32Space:
01832
case cmYXY32Space:
01833
case cmXYZ32Space:
01834
case cmLUV32Space:
01835
case cmLAB32Space:
01836
#ifdef PI_Application_h
01837
case cmBGRSpace +
cmLong10ColorPacking:
01838
case cmRGBSpace +
cmLong10ColorPacking:
01839
case cmGenericSpace +
cmLong10ColorPacking:
01840
#endif
01841
if ( ( ((outputBitMapColorSpace ==
cmHSV32Space) && (outColorSpace !=
icSigHsvData)) ||
01842 ((outputBitMapColorSpace ==
cmHLS32Space) && (outColorSpace !=
icSigHlsData)) ||
01843 ((outputBitMapColorSpace ==
cmYXY32Space) && (outColorSpace !=
icSigYxyData)) ||
01844 ((outputBitMapColorSpace ==
cmXYZ32Space) && (outColorSpace !=
icSigXYZData)) ||
01845 ((outputBitMapColorSpace ==
cmLUV32Space) && (outColorSpace !=
icSigLuvData)) ||
01846 ((outputBitMapColorSpace ==
cmLAB32Space) && (outColorSpace !=
icSigLabData))
01847
#ifdef PI_Application_h
01848
|| ((outputBitMapColorSpace ==
cmBGRSpace +
cmLong10ColorPacking) && (outColorSpace !=
icSigRgbData))
01849 || ((outputBitMapColorSpace ==
cmRGBSpace +
cmLong10ColorPacking) && (outColorSpace !=
icSigRgbData))
01850 || ((outputBitMapColorSpace ==
cmGenericSpace +
cmLong10ColorPacking) && (outColorSpace !=
icSigMCH3Data))
01851
#endif
01852
)
01853
#if ! realThing
01854
&&
FALSE
01855
#endif
01856
)
01857 err =
cmInvalidColorSpace;
01858
else{
01859 newRowBytes = calcParam->cmPixelPerLine * 3 *
sizeof(
SINT16);
01860 linesAtOnce = (
kMaxTempBlock) / newRowBytes;
01861
if (linesAtOnce == 0)
01862 linesAtOnce = 1;
01863
else if (linesAtOnce > calcParam->cmLineCount)
01864 linesAtOnce = calcParam->cmLineCount;
01865
01866 bufferSize = newRowBytes * linesAtOnce;
01867 info->processedLinesOut = 0;
01868 info->origSizeOut = 10;
01869 info->usedSizeOut = 16;
01870 info->tempOutBuffer = (
void*)
SmartNewPtr(bufferSize, &iErr);
01871 info->outputPixelSize = 32;
01872
if (iErr !=
noErr)
01873 {
01874 err = iErr;
01875
goto CleanupAndExit;
01876 }
01877
01878 calcParam->cmLineCount = linesAtOnce;
01879 calcParam->cmOutputBytesPerLine = newRowBytes;
01880
if( outputBitMapColorSpace ==
cmBGRSpace +
cmLong10ColorPacking ){
01881 calcParam->cmOutputColorSpace =
cmBGRSpace;
01882 calcParam->outputData[0] = ((
Ptr)info->tempOutBuffer)+4;
01883 calcParam->outputData[1] = ((
Ptr)info->tempOutBuffer)+2;
01884 calcParam->outputData[2] = ((
Ptr)info->tempOutBuffer)+0;
01885 }
01886
else{
01887 calcParam->cmOutputColorSpace =
cmRGBSpace;
01888 calcParam->outputData[0] = ((
Ptr)info->tempOutBuffer)+0;
01889 calcParam->outputData[1] = ((
Ptr)info->tempOutBuffer)+2;
01890 calcParam->outputData[2] = ((
Ptr)info->tempOutBuffer)+4;
01891 }
01892 calcParam->cmOutputPixelOffset = 6;
01893 }
01894
break;
01895
default:
01896 err =
cmInvalidDstMap;
01897
break;
01898 }
01899
01900 CleanupAndExit:
01901
LH_END_PROC(
"CheckOutputColorSpace")
01902 return err;
01903 }
01904
01905
01906
01907
01908
01909 CMError
01910 SetOutputColorSpaceInplace (
CMCalcParamPtr calcParam,
01911
ColorSpaceInfo* info,
01912 OSType outColorSpace )
01913 {
01914
CMError err =
noErr;
01915
01916
LH_START_PROC(
"SetOutputColorSpaceInplace")
01917
01918 switch ( outColorSpace )
01919 {
01920
case icSigXYZData:
01921 calcParam->cmOutputColorSpace =
cmXYZ32Space;
01922
break;
01923
case icSigLuvData:
01924 calcParam->cmOutputColorSpace =
cmLUV32Space;
01925
break;
01926
case icSigYxyData:
01927 calcParam->cmOutputColorSpace =
cmYXY32Space;
01928
break;
01929
case icSigHsvData:
01930 calcParam->cmOutputColorSpace =
cmHSV32Space;
01931
break;
01932
case icSigHlsData:
01933 calcParam->cmOutputColorSpace =
cmHLS32Space;
01934
break;
01935
case icSigGrayData:
01936
if (calcParam->cmInputPixelOffset == 1)
01937 calcParam->cmOutputColorSpace =
cmGraySpace|
cm8PerChannelPacking;
01938
else if (calcParam->cmInputPixelOffset == 2)
01939 calcParam->cmOutputColorSpace =
cmGraySpace;
01940
else
01941 calcParam->cmOutputColorSpace =
cmGrayASpace;
01942
break;
01943
01944
case icSigRgbData:
01945
01946
#ifdef PI_Application_h
01947
if( (calcParam->cmInputColorSpace & 0x1f) ==
cmBGRSpace ){
01948
if (info->inputPixelSize < 24){
01949
if (info->origSizeIn == 6){
01950 calcParam->cmOutputColorSpace =
cmBGRSpace|
cmWord565ColorPacking;
01951 }
01952
else{
01953 calcParam->cmOutputColorSpace =
cmBGRSpace|
cmWord5ColorPacking;
01954 }
01955 }
01956
if (info->inputPixelSize < 32)
01957 calcParam->cmOutputColorSpace =
cmBGR24Space;
01958
else if (info->inputPixelSize == 32)
01959 calcParam->cmOutputColorSpace =
cmBGR32Space;
01960
else if (info->inputPixelSize == 48)
01961 calcParam->cmOutputColorSpace =
cmBGRSpace |
cm16PerChannelPacking;
01962
else if (info->inputPixelSize == 64)
01963 calcParam->cmOutputColorSpace =
cmBGR32Space |
cm16PerChannelPacking;
01964
break;
01965 }
01966
#endif
01967
if (info->inputPixelSize < 24)
01968
#ifdef PI_Application_h
01969
if (info->origSizeIn == 6){
01970 calcParam->cmOutputColorSpace =
cmRGB16_565Space;
01971 }
01972
else
01973
#endif
01974
calcParam->cmOutputColorSpace =
cmRGB16Space;
01975
else if (info->inputPixelSize < 32)
01976 calcParam->cmOutputColorSpace =
cmRGB24Space;
01977
else if (info->inputPixelSize == 32)
01978 calcParam->cmOutputColorSpace =
cmRGB32Space;
01979
else if (info->inputPixelSize == 48)
01980 calcParam->cmOutputColorSpace =
cmRGBSpace |
cm16PerChannelPacking;
01981
else if (info->inputPixelSize == 64)
01982 calcParam->cmOutputColorSpace =
cmRGB32Space |
cm16PerChannelPacking;
01983
break;
01984
01985
case icSigLabData:
01986
01987
if (info->inputPixelSize < 32)
01988 calcParam->cmOutputColorSpace =
cmLAB24Space;
01989
else
01990 calcParam->cmOutputColorSpace =
cmLAB32Space;
01991
break;
01992
01993
case icSigCmyData:
01994 calcParam->cmOutputColorSpace =
cmCMY24Space;
01995
break;
01996
case icSigCmykData:
01997
#ifdef PI_Application_h
01998
if( (calcParam->cmInputColorSpace & 0x1f) ==
cmKYMCSpace ){
01999 calcParam->cmOutputColorSpace =
cmKYMC32Space;
02000
break;
02001 }
02002
#endif
02003
calcParam->cmOutputColorSpace =
cmCMYK32Space;
02004
break;
02005
02006
case icSigMCH5Data:
02007 calcParam->cmOutputColorSpace =
cmMCFive8Space;
02008
break;
02009
case icSigMCH6Data:
02010 calcParam->cmOutputColorSpace =
cmMCSix8Space;
02011
break;
02012
case icSigMCH7Data:
02013 calcParam->cmOutputColorSpace =
cmMCSeven8Space;
02014
break;
02015
case icSigMCH8Data:
02016 calcParam->cmOutputColorSpace =
cmMCEight8Space;
02017
break;
02018
default:
02019
break;
02020 }
02021
02022
LH_END_PROC(
"SetOutputColorSpaceInplace")
02023 return err;
02024 }
02025
02026
02027
02028
02029 CMError
02030 CheckOutputColorSpaceChk ( const
CMBitmap* bitMap,
02031
CMCalcParamPtr calcParam,
02032
ColorSpaceInfo* info )
02033 {
02034
CMError err =
noErr;
02035
SINT32 newRowBytes;
02036
SINT32 bufferSize;
02037
SINT32 linesAtOnce;
02038
SINT16 iErr =
noErr;
02039
02040
LH_START_PROC(
"CheckOutputColorSpaceChk")
02041 switch ( bitMap->space)
02042 {
02043
case cmGamutResult1Space:
02044 newRowBytes = calcParam->cmPixelPerLine;
02045 linesAtOnce = (
kMaxTempBlock) / newRowBytes;
02046
if (linesAtOnce == 0)
02047 linesAtOnce = 1;
02048
else if (linesAtOnce > calcParam->cmLineCount)
02049 linesAtOnce = calcParam->cmLineCount;
02050
02051 bufferSize = newRowBytes * linesAtOnce;
02052 info->processedLinesOut = 0;
02053 info->origSizeOut = 1;
02054 info->usedSizeOut = 8;
02055 info->tempOutBuffer = (
void*)
SmartNewPtr(bufferSize*info->usedSizeOut, &iErr);
02056
if (iErr !=
noErr)
02057 {
02058 err = iErr;
02059
goto CleanupAndExit;
02060 }
02061
02062 calcParam->cmLineCount = linesAtOnce;
02063 calcParam->cmOutputColorSpace =
cmGraySpace|
cm8PerChannelPacking;
02064 calcParam->cmOutputBytesPerLine = newRowBytes;
02065 calcParam->outputData[0] = (
Ptr)info->tempOutBuffer;
02066 calcParam->cmOutputPixelOffset = 1;
02067
break;
02068
case cmGamutResultSpace:
02069 newRowBytes = calcParam->cmPixelPerLine;
02070 linesAtOnce = (
kMaxTempBlock) / newRowBytes;
02071
if (linesAtOnce == 0)
02072 linesAtOnce = 1;
02073
else if (linesAtOnce > calcParam->cmLineCount)
02074 linesAtOnce = calcParam->cmLineCount;
02075
02076 bufferSize = newRowBytes * linesAtOnce;
02077 info->processedLinesOut = 0;
02078 info->origSizeOut = 8;
02079 info->usedSizeOut = 8;
02080 info->tempOutBuffer = 0;
02081
02082 calcParam->cmLineCount = linesAtOnce;
02083 calcParam->cmOutputColorSpace =
cmGraySpace|
cm8PerChannelPacking;
02084 calcParam->cmOutputBytesPerLine = newRowBytes;
02085 calcParam->cmOutputPixelOffset = 1;
02086 calcParam->outputData[0] = &bitMap->image[0];
02087
break;
02088
default:
02089 err =
cmInvalidDstMap;
02090
break;
02091 }
02092 CleanupAndExit:
02093
LH_END_PROC(
"CheckOutputColorSpaceChk")
02094 return err;
02095 }
02096
02097
02098
02099
02100 CMError
02101 AllocBufferCheckCM (
CMCalcParamPtr calcParam,
02102
ColorSpaceInfo* info )
02103 {
02104
CMError err =
noErr;
02105
SINT32 newRowBytes;
02106
SINT32 bufferSize;
02107
SINT32 linesAtOnce;
02108
SINT16 iErr =
noErr;
02109
02110
LH_START_PROC(
"AllocBufferCheckCM")
02111 newRowBytes = calcParam->cmPixelPerLine;
02112 linesAtOnce = (kMaxTempBlock) / newRowBytes;
02113 if (linesAtOnce == 0)
02114 linesAtOnce = 1;
02115 else if (linesAtOnce > calcParam->cmLineCount)
02116 linesAtOnce = calcParam->cmLineCount;
02117
02118 bufferSize = newRowBytes * linesAtOnce;
02119 info->processedLinesOut = 0;
02120 info->origSizeOut = 1;
02121 info->usedSizeOut = 8;
02122 info->tempOutBuffer = (
void*)SmartNewPtr(bufferSize, &iErr);
02123 if (iErr != noErr)
02124 {
02125 err = iErr;
02126
goto CleanupAndExit;
02127 }
02128
02129 calcParam->cmLineCount = linesAtOnce;
02130 calcParam->cmOutputColorSpace =
cmGraySpace|
cm8PerChannelPacking;
02131 calcParam->cmOutputBytesPerLine = newRowBytes;
02132 calcParam->outputData[0] = (
Ptr)info->tempOutBuffer;
02133 calcParam->cmOutputPixelOffset = 1;
02134
02135 CleanupAndExit:
02136
LH_END_PROC(
"AllocBufferCheckCM")
02137 return err;
02138 }
02139
02140
02141
02142
02143 CalcProcPtr
02144 FindLookupRoutine ( const
CMLutParam* lutParam,
02145 const
ColorSpaceInfo* info )
02146 {
02147
CalcProcPtr proc2call =
nil;
02148
#ifdef DEBUG_OUTPUT
02149
CMError err =
noErr;
02150
#endif
02151
LH_START_PROC(
"FindLookupRoutine")
02152
02153 switch ( lutParam->colorLutInDim )
02154 {
02155
case 3:
02156
switch ( lutParam->colorLutOutDim )
02157 {
02158
case 3:
02159
switch (info->usedSizeIn)
02160 {
02161
case 8:
02162
switch (info->usedSizeOut)
02163 {
02164
case 8:
02165
switch (lutParam->colorLutWordSize)
02166 {
02167
case 8:
02168
switch (lutParam->colorLutGridPoints)
02169 {
02170
#if LH_CALC_ENGINE_ALL_FORMATS_LO
02171
case 16:
02172 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16_LO);
02173
break;
02174
#endif
02175
case 32:
02176 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32_LO);
02177
break;
02178 }
02179
break;
02180
#if LH_CALC_ENGINE_ALL_FORMATS_LO
02181
case 16:
02182
switch (lutParam->colorLutGridPoints)
02183 {
02184
case 16:
02185 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G16_LO);
02186
break;
02187
case 32:
02188 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G32_LO);
02189
break;
02190 }
02191
break;
02192
#endif
02193
}
02194
break;
02195
#if LH_CALC_ENGINE_ALL_FORMATS_LO
02196
case 16:
02197
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02198
switch (lutParam->colorLutWordSize)
02199 {
02200
case 8:
02201
switch (lutParam->colorLutGridPoints)
02202 {
02203
case 16:
02204 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G16_LO);
02205
break;
02206
case 32:
02207 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G32_LO);
02208
break;
02209 }
02210
break;
02211
case 16:
02212
switch (lutParam->colorLutGridPoints)
02213 {
02214
case 16:
02215 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G16_LO);
02216
break;
02217
case 32:
02218 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G32_LO);
02219
break;
02220 }
02221
break;
02222 }
02223
#endif
02224
break;
02225
#endif
02226
}
02227
02228
break;
02229
#if LH_CALC_ENGINE_ALL_FORMATS_LO
02230
case 16:
02231
switch (info->usedSizeOut)
02232 {
02233
case 8:
02234
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02235
switch (lutParam->colorLutWordSize)
02236 {
02237
case 8:
02238
switch (lutParam->colorLutGridPoints)
02239 {
02240
case 16:
02241 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G16_LO);
02242
break;
02243
case 32:
02244 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G32_LO);
02245
break;
02246 }
02247
break;
02248
case 16:
02249
switch (lutParam->colorLutGridPoints)
02250 {
02251
case 16:
02252 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G16_LO);
02253
break;
02254
case 32:
02255 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G32_LO);
02256
break;
02257 }
02258
break;
02259 }
02260
#endif
02261
break;
02262
case 16:
02263
#if LH_CALC_ENGINE_16_BIT_LO
02264
switch (lutParam->colorLutWordSize)
02265 {
02266
case 8:
02267
switch (lutParam->colorLutGridPoints)
02268 {
02269
case 16:
02270 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G16_LO);
02271
break;
02272
case 32:
02273 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G32_LO);
02274
break;
02275 }
02276
break;
02277
case 16:
02278
switch (lutParam->colorLutGridPoints)
02279 {
02280
case 16:
02281 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G16_LO);
02282
break;
02283
case 32:
02284 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G32_LO);
02285
break;
02286 }
02287
break;
02288 }
02289
#endif
02290
break;
02291 }
02292
break;
02293
#endif
02294
}
02295
break;
02296
#if LH_CALC_ENGINE_ALL_FORMATS_LO
02297
case 4:
02298
switch (info->usedSizeIn)
02299 {
02300
case 8:
02301
switch (info->usedSizeOut)
02302 {
02303
case 8:
02304
switch (lutParam->colorLutWordSize)
02305 {
02306
case 8:
02307
switch (lutParam->colorLutGridPoints)
02308 {
02309
case 16:
02310 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16_LO);
02311
break;
02312
case 32:
02313 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32_LO);
02314
break;
02315 }
02316
break;
02317
case 16:
02318
switch (lutParam->colorLutGridPoints)
02319 {
02320
case 16:
02321 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G16_LO);
02322
break;
02323
case 32:
02324 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G32_LO);
02325
break;
02326 }
02327
break;
02328 }
02329
break;
02330
case 16:
02331
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02332
switch (lutParam->colorLutWordSize)
02333 {
02334
case 8:
02335
switch (lutParam->colorLutGridPoints)
02336 {
02337
case 16:
02338 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G16_LO);
02339
break;
02340
case 32:
02341 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G32_LO);
02342
break;
02343 }
02344
break;
02345
case 16:
02346
switch (lutParam->colorLutGridPoints)
02347 {
02348
case 16:
02349 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G16_LO);
02350
break;
02351
case 32:
02352 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G32_LO);
02353
break;
02354 }
02355
break;
02356 }
02357
#endif
02358
break;
02359 }
02360
break;
02361
case 16:
02362
switch (info->usedSizeOut)
02363 {
02364
case 8:
02365
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02366
switch (lutParam->colorLutWordSize)
02367 {
02368
case 8:
02369
switch (lutParam->colorLutGridPoints)
02370 {
02371
case 16:
02372 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G16_LO);
02373
break;
02374
case 32:
02375 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G32_LO);
02376
break;
02377 }
02378
break;
02379
case 16:
02380
switch (lutParam->colorLutGridPoints)
02381 {
02382
case 16:
02383 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G16_LO);
02384
break;
02385
case 32:
02386 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G32_LO);
02387
break;
02388 }
02389
break;
02390 }
02391
#endif
02392
break;
02393
case 16:
02394
#if LH_CALC_ENGINE_16_BIT_LO
02395
switch (lutParam->colorLutWordSize)
02396 {
02397
case 8:
02398
switch (lutParam->colorLutGridPoints)
02399 {
02400
case 16:
02401 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G16_LO);
02402
break;
02403
case 32:
02404 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G32_LO);
02405
break;
02406 }
02407
break;
02408
case 16:
02409
switch (lutParam->colorLutGridPoints)
02410 {
02411
case 16:
02412 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G16_LO);
02413
break;
02414
case 32:
02415 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G32_LO);
02416
break;
02417 }
02418
break;
02419 }
02420
#endif
02421
break;
02422 }
02423
break;
02424 }
02425
break;
02426
#endif
02427
}
02428
break;
02429
#if LH_CALC_ENGINE_ALL_FORMATS_LO
02430
case 4:
02431
switch ( lutParam->colorLutOutDim )
02432 {
02433
case 3:
02434
switch (info->usedSizeIn)
02435 {
02436
case 8:
02437
switch (info->usedSizeOut)
02438 {
02439
case 8:
02440
switch (lutParam->colorLutWordSize)
02441 {
02442
case 8:
02443
switch (lutParam->colorLutGridPoints)
02444 {
02445
case 8:
02446 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8_LO);
02447
break;
02448
case 16:
02449 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16_LO);
02450
break;
02451 }
02452
break;
02453
case 16:
02454
switch (lutParam->colorLutGridPoints)
02455 {
02456
case 8:
02457 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G8_LO);
02458
break;
02459
case 16:
02460 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G16_LO);
02461
break;
02462 }
02463
break;
02464 }
02465
break;
02466
case 16:
02467
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02468
switch (lutParam->colorLutWordSize)
02469 {
02470
case 8:
02471
switch (lutParam->colorLutGridPoints)
02472 {
02473
case 8:
02474 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G8_LO);
02475
break;
02476
case 16:
02477 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G16_LO);
02478
break;
02479 }
02480
break;
02481
case 16:
02482
switch (lutParam->colorLutGridPoints)
02483 {
02484
case 8:
02485 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G8_LO);
02486
break;
02487
case 16:
02488 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G16_LO);
02489
break;
02490 }
02491
break;
02492 }
02493
#endif
02494
break;
02495 }
02496
break;
02497
case 16:
02498
switch (info->usedSizeOut)
02499 {
02500
case 8:
02501
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02502
switch (lutParam->colorLutWordSize)
02503 {
02504
case 8:
02505
switch (lutParam->colorLutGridPoints)
02506 {
02507
case 8:
02508 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G8_LO);
02509
break;
02510
case 16:
02511 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G16_LO);
02512
break;
02513 }
02514
break;
02515
case 16:
02516
switch (lutParam->colorLutGridPoints)
02517 {
02518
case 8:
02519 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G8_LO);
02520
break;
02521
case 16:
02522 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G16_LO);
02523
break;
02524 }
02525
break;
02526 }
02527
#endif
02528
break;
02529
case 16:
02530
#if LH_CALC_ENGINE_16_BIT_LO
02531
switch (lutParam->colorLutWordSize)
02532 {
02533
case 8:
02534
switch (lutParam->colorLutGridPoints)
02535 {
02536
case 8:
02537 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G8_LO);
02538
break;
02539
case 16:
02540 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G16_LO);
02541
break;
02542 }
02543
break;
02544
case 16:
02545
switch (lutParam->colorLutGridPoints)
02546 {
02547
case 8:
02548 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G8_LO);
02549
break;
02550
case 16:
02551 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G16_LO);
02552
break;
02553 }
02554
break;
02555 }
02556
#endif
02557
break;
02558 }
02559
break;
02560 }
02561
break;
02562
case 4:
02563
switch (info->usedSizeIn)
02564 {
02565
case 8:
02566
switch (info->usedSizeOut)
02567 {
02568
case 8:
02569
switch (lutParam->colorLutWordSize)
02570 {
02571
case 8:
02572
switch (lutParam->colorLutGridPoints)
02573 {
02574
case 8:
02575 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8_LO);
02576
break;
02577
case 16:
02578 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16_LO);
02579
break;
02580 }
02581
break;
02582
case 16:
02583
switch (lutParam->colorLutGridPoints)
02584 {
02585
case 8:
02586 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G8_LO);
02587
break;
02588
case 16:
02589 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G16_LO);
02590
break;
02591 }
02592
break;
02593 }
02594
break;
02595
case 16:
02596
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02597
switch (lutParam->colorLutWordSize)
02598 {
02599
case 8:
02600
switch (lutParam->colorLutGridPoints)
02601 {
02602
case 8:
02603 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G8_LO);
02604
break;
02605
case 16:
02606 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G16_LO);
02607
break;
02608 }
02609
break;
02610
case 16:
02611
switch (lutParam->colorLutGridPoints)
02612 {
02613
case 8:
02614 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G8_LO);
02615
break;
02616
case 16:
02617 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G16_LO);
02618
break;
02619 }
02620
break;
02621 }
02622
#endif
02623
break;
02624 }
02625
break;
02626
case 16:
02627
switch (info->usedSizeOut)
02628 {
02629
case 8:
02630
#if LH_CALC_ENGINE_MIXED_DATAFORMAT
02631
switch (lutParam->colorLutWordSize)
02632 {
02633
case 8:
02634
switch (lutParam->colorLutGridPoints)
02635 {
02636
case 8:
02637 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G8_LO);
02638
break;
02639
case 16:
02640 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G16_LO);
02641
break;
02642 }
02643
break;
02644
case 16:
02645
switch (lutParam->colorLutGridPoints)
02646 {
02647
case 8:
02648 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G8_LO);
02649
break;
02650
case 16:
02651 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G16_LO);
02652
break;
02653 }
02654
break;
02655 }
02656
#endif
02657
break;
02658
case 16:
02659
#if LH_CALC_ENGINE_16_BIT_LO
02660
switch (lutParam->colorLutWordSize)
02661 {
02662
case 8:
02663
switch (lutParam->colorLutGridPoints)
02664 {
02665
case 8:
02666 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G8_LO);
02667
break;
02668
case 16:
02669 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G16_LO);
02670
break;
02671 }
02672
break;
02673
case 16:
02674
switch (lutParam->colorLutGridPoints)
02675 {
02676
case 8:
02677 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G8_LO);
02678
break;
02679
case 16:
02680 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G16_LO);
02681
break;
02682 }
02683
break;
02684 }
02685
#endif
02686
break;
02687 }
02688
break;
02689 }
02690
break;
02691 }
02692
break;
02693
#endif
02694
}
02695
02696
LH_END_PROC(
"FindLookupRoutine")
02697 return proc2call;
02698 }
02699
02700 #ifdef ALLOW_MMX
02701 #define cpuid __asm _emit 0x0F __asm _emit 0xA2
02702
02703 #define CPUID_FLAG 0x00200000
02704 #define MMX_FLAG 0x00800000
02705 #define FAMILY_5_FLAG 0x00000500
02706 #define FAMILY_MASK 0x00000F00
02707
02708
02709
02710
02711
02712
02713
02714
02715
02716
02717
02718
02719
02720
02721
02722 static LH_UINT32 DetectMMX (
void)
02723 {
02724
LH_UINT32 fMMX =
FALSE;
02725
02726 __asm {
02727
02728 push edx ;
02729 push ebx ;
02730 push eax ;
02731 pushfd ; Push flags on stack
02732 pop eax ; and get flags into eax
02733 xor eax, CPUID_FLAG ; Toggle
CPUID flag
02734 push eax ; Move flags back into
02735 popfd ; flags reg
02736 pushfd ; Get flags into ebx
02737 pop ebx
02738 and ebx, CPUID_FLAG ; Mask
CPUID flag
02739 and eax, CPUID_FLAG
02740 cmp eax, ebx ;
Test toggled bit
02741 jnz Done ; CPU does not support
CPUID
02742
02743 mov eax, 1 ; Set
CPUID mode
02744 cpuid
02745 test edx, MMX_FLAG ; Check MMX-Technology bit
02746 jz Done ; CPU has no MMX-Technology
02747 and eax, FAMILY_MASK ; mask
out family bits
02748 cmp eax, FAMILY_5_FLAG ; Check Family 5 bits
02749 jnz Done ; CPU has no MMX-Technology
02750
02751 mov fMMX,
TRUE ; CPU has MMX-Technology
02752 Done:
02753 ;pushfd ;
dummy
02754 pop eax ;
02755 pop ebx ;
02756 pop edx ;
02757 }
02758
02759
return (fMMX);
02760 }
02761
02762
#endif
02763
02764
02765
02766
CalcProcPtr
02767
FindCalcRoutine(
const CMCalcParam* calcParam,
02768
const CMLutParam* lutParam,
02769
const ColorSpaceInfo* info,
02770
const Boolean lookupOnly )
02771 {
02772
SINT32 index = 0;
02773
CalcProcPtr proc2call =
nil;
02774
#ifdef DEBUG_OUTPUT
02775
CMError err =
noErr;
02776
#endif
02777
02778
LH_START_PROC(
"FindCalcRoutine")
02779
02780 calcParam = calcParam;
02781
02782 #if 1
02783 if (lookupOnly)
02784 proc2call = FindLookupRoutine(lutParam, info);
02785 if (proc2call == nil)
02786 {
02787
switch ( lutParam->colorLutInDim )
02788 {
02789
case 1:
02790
switch ( lutParam->colorLutOutDim )
02791 {
02792
case 1:
02793
case 3:
02794
case 4:
02795
switch (info->usedSizeIn)
02796 {
02797
case 8:
02798
switch (info->usedSizeOut)
02799 {
02800
case 8:
02801
switch (lutParam->colorLutWordSize)
02802 {
02803
case 8:
02804
switch (lutParam->colorLutGridPoints)
02805 {
02806
#if LH_Calc1toX_Di8_Do8_Lut8_G128 != LH_CALC_USE_DO_N_DIM
02807
case 128:
02808 proc2call =
NewCalcProc(LHCalc1toX_Di8_Do8_Lut8_G128);
02809
break;
02810
#endif
02811
}
02812
break;
02813
case 16:
02814
switch (lutParam->colorLutGridPoints)
02815 {
02816
#if LH_Calc1toX_Di8_Do8_Lut16_G128 != LH_CALC_USE_DO_N_DIM
02817
case 128:
02818 proc2call =
NewCalcProc(LHCalc1toX_Di8_Do8_Lut16_G128);
02819
break;
02820
#endif
02821
}
02822
break;
02823 }
02824
break;
02825
case 16:
02826
switch (lutParam->colorLutWordSize)
02827 {
02828
case 8:
02829
switch (lutParam->colorLutGridPoints)
02830 {
02831
#if LH_Calc1toX_Di8_Do16_Lut8_G128 != LH_CALC_USE_DO_N_DIM
02832
case 128:
02833 proc2call =
NewCalcProc(LHCalc1toX_Di8_Do16_Lut8_G128);
02834
break;
02835
#endif
02836
}
02837
break;
02838
case 16:
02839
switch (lutParam->colorLutGridPoints)
02840 {
02841
#if LH_Calc1toX_Di8_Do16_Lut16_G128 != LH_CALC_USE_DO_N_DIM
02842
case 128:
02843 proc2call =
NewCalcProc(LHCalc1toX_Di8_Do16_Lut16_G128);
02844
break;
02845
#endif
02846
}
02847
break;
02848 }
02849
break;
02850 }
02851
break;
02852
case 16:
02853
switch (info->usedSizeOut)
02854 {
02855
case 8:
02856
switch (lutParam->colorLutWordSize)
02857 {
02858
case 8:
02859
switch (lutParam->colorLutGridPoints)
02860 {
02861
#if LH_Calc1toX_Di16_Do8_Lut8_G128 != LH_CALC_USE_DO_N_DIM
02862
case 128:
02863 proc2call =
NewCalcProc(LHCalc1toX_Di16_Do8_Lut8_G128);
02864
break;
02865
#endif
02866
}
02867
break;
02868
case 16:
02869
switch (lutParam->colorLutGridPoints)
02870 {
02871
#if LH_Calc1toX_Di16_Do8_Lut16_G128 != LH_CALC_USE_DO_N_DIM
02872
case 128:
02873 proc2call =
NewCalcProc(LHCalc1toX_Di16_Do8_Lut16_G128);
02874
break;
02875
#endif
02876
}
02877
break;
02878 }
02879
break;
02880
case 16:
02881
switch (lutParam->colorLutWordSize)
02882 {
02883
case 8:
02884
switch (lutParam->colorLutGridPoints)
02885 {
02886
#if LH_Calc1toX_Di16_Do16_Lut8_G128 != LH_CALC_USE_DO_N_DIM
02887
case 128:
02888 proc2call =
NewCalcProc(LHCalc1toX_Di16_Do16_Lut8_G128);
02889
break;
02890
#endif
02891
}
02892
break;
02893
case 16:
02894
switch (lutParam->colorLutGridPoints)
02895 {
02896
#if LH_Calc1toX_Di16_Do16_Lut16_G128 != LH_CALC_USE_DO_N_DIM
02897
case 128:
02898 proc2call =
NewCalcProc(LHCalc1toX_Di16_Do16_Lut16_G128);
02899
break;
02900
#endif
02901
}
02902
break;
02903 }
02904
break;
02905 }
02906
break;
02907 }
02908
break;
02909 }
02910
break;
02911
case 3:
02912
switch ( lutParam->colorLutOutDim )
02913 {
02914
case 3:
02915
switch (info->usedSizeIn)
02916 {
02917
case 8:
02918
switch (info->usedSizeOut)
02919 {
02920
case 8:
02921
switch (lutParam->colorLutWordSize)
02922 {
02923
case 8:
02924
switch (lutParam->colorLutGridPoints)
02925 {
02926
#if LH_Calc3to3_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
02927
case 16:
02928
#ifdef ALLOW_MMX
02929
if (DetectMMX()) {
02930 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16_F);
02931 }
02932
else
02933
#endif
02934
#if LH_CALC_USE_ADDITIONAL_OLD_CODE
02935
if( !info->inPlace ){
02936 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16_Old);
02937 }
02938
else
02939
#endif
02940
proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G16);
02941
break;
02942
#endif
02943
#if LH_Calc3to3_Di8_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM
02944
case 32:
02945
#ifdef ALLOW_MMX
02946
if (DetectMMX()) {
02947 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32_F);
02948 }
02949
else
02950
#endif
02951
#if LH_CALC_USE_ADDITIONAL_OLD_CODE
02952
if( !info->inPlace ){
02953 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32_Old);
02954 }
02955
else
02956
#endif
02957
proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut8_G32);
02958
break;
02959
#endif
02960
}
02961
break;
02962
case 16:
02963
switch (lutParam->colorLutGridPoints)
02964 {
02965
#if LH_Calc3to3_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
02966
case 16:
02967 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G16);
02968
break;
02969
#endif
02970
#if LH_Calc3to3_Di8_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM
02971
case 32:
02972 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do8_Lut16_G32);
02973
break;
02974
#endif
02975
}
02976
break;
02977 }
02978
break;
02979
case 16:
02980
switch (lutParam->colorLutWordSize)
02981 {
02982
case 8:
02983
switch (lutParam->colorLutGridPoints)
02984 {
02985
#if LH_Calc3to3_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
02986
case 16:
02987 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G16);
02988
break;
02989
#endif
02990
#if LH_Calc3to3_Di8_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM
02991
case 32:
02992 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut8_G32);
02993
break;
02994
#endif
02995
}
02996
break;
02997
case 16:
02998
switch (lutParam->colorLutGridPoints)
02999 {
03000
#if LH_Calc3to3_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03001
case 16:
03002 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G16);
03003
break;
03004
#endif
03005
#if LH_Calc3to3_Di8_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM
03006
case 32:
03007 proc2call =
NewCalcProc(LHCalc3to3_Di8_Do16_Lut16_G32);
03008
break;
03009
#endif
03010
}
03011
break;
03012 }
03013
break;
03014 }
03015
break;
03016
case 16:
03017
switch (info->usedSizeOut)
03018 {
03019
case 8:
03020
switch (lutParam->colorLutWordSize)
03021 {
03022
case 8:
03023
switch (lutParam->colorLutGridPoints)
03024 {
03025
#if LH_Calc3to3_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03026
case 16:
03027 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G16);
03028
break;
03029
#endif
03030
#if LH_Calc3to3_Di16_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM
03031
case 32:
03032 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut8_G32);
03033
break;
03034
#endif
03035
}
03036
break;
03037
case 16:
03038
switch (lutParam->colorLutGridPoints)
03039 {
03040
#if LH_Calc3to3_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03041
case 16:
03042 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G16);
03043
break;
03044
#endif
03045
#if LH_Calc3to3_Di16_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM
03046
case 32:
03047 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do8_Lut16_G32);
03048
break;
03049
#endif
03050
}
03051
break;
03052 }
03053
break;
03054
case 16:
03055
switch (lutParam->colorLutWordSize)
03056 {
03057
case 8:
03058
switch (lutParam->colorLutGridPoints)
03059 {
03060
#if LH_Calc3to3_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03061
case 16:
03062 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G16);
03063
break;
03064
#endif
03065
#if LH_Calc3to3_Di16_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM
03066
case 32:
03067 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut8_G32);
03068
break;
03069
#endif
03070
}
03071
break;
03072
case 16:
03073
switch (lutParam->colorLutGridPoints)
03074 {
03075
#if LH_Calc3to3_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03076
case 16:
03077 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G16);
03078
break;
03079
#endif
03080
#if LH_Calc3to3_Di16_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM
03081
case 32:
03082 proc2call =
NewCalcProc(LHCalc3to3_Di16_Do16_Lut16_G32);
03083
break;
03084
#endif
03085
}
03086
break;
03087 }
03088
break;
03089 }
03090
break;
03091 }
03092
break;
03093
case 4:
03094
switch (info->usedSizeIn)
03095 {
03096
case 8:
03097
switch (info->usedSizeOut)
03098 {
03099
case 8:
03100
switch (lutParam->colorLutWordSize)
03101 {
03102
case 8:
03103
switch (lutParam->colorLutGridPoints)
03104 {
03105
#if LH_Calc3to4_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03106
case 16:
03107
#ifdef ALLOW_MMX
03108
if (DetectMMX()) {
03109 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16_F);
03110 }
03111
else
03112
#endif
03113
#if LH_CALC_USE_ADDITIONAL_OLD_CODE
03114
if( !info->inPlace ){
03115 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16_Old);
03116 }
03117
else
03118
#endif
03119
proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G16);
03120
break;
03121
#endif
03122
#if LH_Calc3to4_Di8_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM
03123
case 32:
03124
#ifdef ALLOW_MMX
03125
if (DetectMMX()) {
03126 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32_F);
03127 }
03128
else
03129
#endif
03130
#if LH_CALC_USE_ADDITIONAL_OLD_CODE
03131
if( !info->inPlace ){
03132 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32_Old);
03133 }
03134
else
03135
#endif
03136
proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut8_G32);
03137
break;
03138
#endif
03139
}
03140
break;
03141
case 16:
03142
switch (lutParam->colorLutGridPoints)
03143 {
03144
#if LH_Calc3to4_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03145
case 16:
03146 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G16);
03147
break;
03148
#endif
03149
#if LH_Calc3to4_Di8_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM
03150
case 32:
03151 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do8_Lut16_G32);
03152
break;
03153
#endif
03154
}
03155
break;
03156 }
03157
break;
03158
case 16:
03159
switch (lutParam->colorLutWordSize)
03160 {
03161
case 8:
03162
switch (lutParam->colorLutGridPoints)
03163 {
03164
#if LH_Calc3to4_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03165
case 16:
03166 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G16);
03167
break;
03168
#endif
03169
#if LH_Calc3to4_Di8_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM
03170
case 32:
03171 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut8_G32);
03172
break;
03173
#endif
03174
}
03175
break;
03176
case 16:
03177
switch (lutParam->colorLutGridPoints)
03178 {
03179
#if LH_Calc3to4_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03180
case 16:
03181 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G16);
03182
break;
03183
#endif
03184
#if LH_Calc3to4_Di8_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM
03185
case 32:
03186 proc2call =
NewCalcProc(LHCalc3to4_Di8_Do16_Lut16_G32);
03187
break;
03188
#endif
03189
}
03190
break;
03191 }
03192
break;
03193 }
03194
break;
03195
case 16:
03196
switch (info->usedSizeOut)
03197 {
03198
case 8:
03199
switch (lutParam->colorLutWordSize)
03200 {
03201
case 8:
03202
switch (lutParam->colorLutGridPoints)
03203 {
03204
#if LH_Calc3to4_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03205
case 16:
03206 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G16);
03207
break;
03208
#endif
03209
#if LH_Calc3to4_Di16_Do8_Lut8_G32 != LH_CALC_USE_DO_N_DIM
03210
case 32:
03211 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut8_G32);
03212
break;
03213
#endif
03214
}
03215
break;
03216
case 16:
03217
switch (lutParam->colorLutGridPoints)
03218 {
03219
#if LH_Calc3to4_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03220
case 16:
03221 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G16);
03222
break;
03223
#endif
03224
#if LH_Calc3to4_Di16_Do8_Lut16_G32 != LH_CALC_USE_DO_N_DIM
03225
case 32:
03226 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do8_Lut16_G32);
03227
break;
03228
#endif
03229
}
03230
break;
03231 }
03232
break;
03233
case 16:
03234
switch (lutParam->colorLutWordSize)
03235 {
03236
case 8:
03237
switch (lutParam->colorLutGridPoints)
03238 {
03239
#if LH_Calc3to4_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03240
case 16:
03241 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G16);
03242
break;
03243
#endif
03244
#if LH_Calc3to4_Di16_Do16_Lut8_G32 != LH_CALC_USE_DO_N_DIM
03245
case 32:
03246 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut8_G32);
03247
break;
03248
#endif
03249
}
03250
break;
03251
case 16:
03252
switch (lutParam->colorLutGridPoints)
03253 {
03254
#if LH_Calc3to4_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03255
case 16:
03256 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G16);
03257
break;
03258
#endif
03259
#if LH_Calc3to4_Di16_Do16_Lut16_G32 != LH_CALC_USE_DO_N_DIM
03260
case 32:
03261 proc2call =
NewCalcProc(LHCalc3to4_Di16_Do16_Lut16_G32);
03262
break;
03263
#endif
03264
}
03265
break;
03266 }
03267
break;
03268 }
03269
break;
03270 }
03271
break;
03272 }
03273
break;
03274
case 4:
03275
switch ( lutParam->colorLutOutDim )
03276 {
03277
case 3:
03278
switch (info->usedSizeIn)
03279 {
03280
case 8:
03281
switch (info->usedSizeOut)
03282 {
03283
case 8:
03284
switch (lutParam->colorLutWordSize)
03285 {
03286
case 8:
03287
switch (lutParam->colorLutGridPoints)
03288 {
03289
#if LH_Calc4to3_Di8_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03290
case 8:
03291
#ifdef ALLOW_MMX
03292
if (DetectMMX()) {
03293 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8_F);
03294 }
03295
else
03296
#endif
03297
#if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM
03298
if( !info->inPlace ){
03299 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8_Old);
03300 }
03301
else
03302
#endif
03303
proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G8);
03304
break;
03305
#endif
03306
#if LH_Calc4to3_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03307
case 16:
03308
#ifdef ALLOW_MMX
03309
if (DetectMMX()) {
03310 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16_F);
03311 }
03312
else
03313
#endif
03314
#if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM
03315
if( !info->inPlace ){
03316 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16_Old);
03317 }
03318
else
03319
#endif
03320
proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut8_G16);
03321
break;
03322
#endif
03323
}
03324
break;
03325
case 16:
03326
switch (lutParam->colorLutGridPoints)
03327 {
03328
#if LH_Calc4to3_Di8_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03329
case 8:
03330 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G8);
03331
break;
03332
#endif
03333
#if LH_Calc4to3_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03334
case 16:
03335 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do8_Lut16_G16);
03336
break;
03337
#endif
03338
}
03339
break;
03340 }
03341
break;
03342
case 16:
03343
switch (lutParam->colorLutWordSize)
03344 {
03345
case 8:
03346
switch (lutParam->colorLutGridPoints)
03347 {
03348
#if LH_Calc4to3_Di8_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03349
case 8:
03350 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G8);
03351
break;
03352
#endif
03353
#if LH_Calc4to3_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03354
case 16:
03355 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut8_G16);
03356
break;
03357
#endif
03358
}
03359
break;
03360
case 16:
03361
switch (lutParam->colorLutGridPoints)
03362 {
03363
#if LH_Calc4to3_Di8_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03364
case 8:
03365 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G8);
03366
break;
03367
#endif
03368
#if LH_Calc4to3_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03369
case 16:
03370 proc2call =
NewCalcProc(LHCalc4to3_Di8_Do16_Lut16_G16);
03371
break;
03372
#endif
03373
}
03374
break;
03375 }
03376
break;
03377 }
03378
break;
03379
case 16:
03380
switch (info->usedSizeOut)
03381 {
03382
case 8:
03383
switch (lutParam->colorLutWordSize)
03384 {
03385
case 8:
03386
switch (lutParam->colorLutGridPoints)
03387 {
03388
#if LH_Calc4to3_Di16_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03389
case 8:
03390 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G8);
03391
break;
03392
#endif
03393
#if LH_Calc4to3_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03394
case 16:
03395 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut8_G16);
03396
break;
03397
#endif
03398
}
03399
break;
03400
case 16:
03401
switch (lutParam->colorLutGridPoints)
03402 {
03403
#if LH_Calc4to3_Di16_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03404
case 8:
03405 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G8);
03406
break;
03407
#endif
03408
#if LH_Calc4to3_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03409
case 16:
03410 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do8_Lut16_G16);
03411
break;
03412
#endif
03413
}
03414
break;
03415 }
03416
break;
03417
case 16:
03418
switch (lutParam->colorLutWordSize)
03419 {
03420
case 8:
03421
switch (lutParam->colorLutGridPoints)
03422 {
03423
#if LH_Calc4to3_Di16_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03424
case 8:
03425 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G8);
03426
break;
03427
#endif
03428
#if LH_Calc4to3_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03429
case 16:
03430 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut8_G16);
03431
break;
03432
#endif
03433
}
03434
break;
03435
case 16:
03436
switch (lutParam->colorLutGridPoints)
03437 {
03438
#if LH_Calc4to3_Di16_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03439
case 8:
03440 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G8);
03441
break;
03442
#endif
03443
#if LH_Calc4to3_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03444
case 16:
03445 proc2call =
NewCalcProc(LHCalc4to3_Di16_Do16_Lut16_G16);
03446
break;
03447
#endif
03448
}
03449
break;
03450 }
03451
break;
03452 }
03453
break;
03454 }
03455
break;
03456
case 4:
03457
switch (info->usedSizeIn)
03458 {
03459
case 8:
03460
switch (info->usedSizeOut)
03461 {
03462
case 8:
03463
switch (lutParam->colorLutWordSize)
03464 {
03465
case 8:
03466
switch (lutParam->colorLutGridPoints)
03467 {
03468
#if LH_Calc4to4_Di8_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03469
case 8:
03470
#ifdef ALLOW_MMX
03471
if (DetectMMX()) {
03472 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8_F);
03473 }
03474
else
03475
#endif
03476
#if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM
03477
if( !info->inPlace ){
03478 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8_Old);
03479 }
03480
else
03481
#endif
03482
proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G8);
03483
break;
03484
#endif
03485
#if LH_Calc4to4_Di8_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03486
case 16:
03487
#ifdef ALLOW_MMX
03488
if (DetectMMX()) {
03489 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16_F);
03490 }
03491
else
03492
#endif
03493
#if LH_CALC_USE_ADDITIONAL_OLD_CODE_4DIM
03494
if( !info->inPlace ){
03495 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16_Old);
03496 }
03497
else
03498
#endif
03499
proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut8_G16);
03500
break;
03501
#endif
03502
}
03503
break;
03504
case 16:
03505
switch (lutParam->colorLutGridPoints)
03506 {
03507
#if LH_Calc4to4_Di8_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03508
case 8:
03509 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G8);
03510
break;
03511
#endif
03512
#if LH_Calc4to4_Di8_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03513
case 16:
03514 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do8_Lut16_G16);
03515
break;
03516
#endif
03517
}
03518
break;
03519 }
03520
break;
03521
case 16:
03522
switch (lutParam->colorLutWordSize)
03523 {
03524
case 8:
03525
switch (lutParam->colorLutGridPoints)
03526 {
03527
#if LH_Calc4to4_Di8_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03528
case 8:
03529 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G8);
03530
break;
03531
#endif
03532
#if LH_Calc4to4_Di8_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03533
case 16:
03534 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut8_G16);
03535
break;
03536
#endif
03537
}
03538
break;
03539
case 16:
03540
switch (lutParam->colorLutGridPoints)
03541 {
03542
#if LH_Calc4to4_Di8_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03543
case 8:
03544 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G8);
03545
break;
03546
#endif
03547
#if LH_Calc4to4_Di8_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03548
case 16:
03549 proc2call =
NewCalcProc(LHCalc4to4_Di8_Do16_Lut16_G16);
03550
break;
03551
#endif
03552
}
03553
break;
03554 }
03555
break;
03556 }
03557
break;
03558
case 16:
03559
switch (info->usedSizeOut)
03560 {
03561
case 8:
03562
switch (lutParam->colorLutWordSize)
03563 {
03564
case 8:
03565
switch (lutParam->colorLutGridPoints)
03566 {
03567
#if LH_Calc4to4_Di16_Do8_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03568
case 8:
03569 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G8);
03570
break;
03571
#endif
03572
#if LH_Calc4to4_Di16_Do8_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03573
case 16:
03574 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut8_G16);
03575
break;
03576
#endif
03577
}
03578
break;
03579
case 16:
03580
switch (lutParam->colorLutGridPoints)
03581 {
03582
#if LH_Calc4to4_Di16_Do8_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03583
case 8:
03584 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G8);
03585
break;
03586
#endif
03587
#if LH_Calc4to4_Di16_Do8_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03588
case 16:
03589 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do8_Lut16_G16);
03590
break;
03591
#endif
03592
}
03593
break;
03594 }
03595
break;
03596
case 16:
03597
switch (lutParam->colorLutWordSize)
03598 {
03599
case 8:
03600
switch (lutParam->colorLutGridPoints)
03601 {
03602
#if LH_Calc4to4_Di16_Do16_Lut8_G8 != LH_CALC_USE_DO_N_DIM
03603
case 8:
03604 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G8);
03605
break;
03606
#endif
03607
#if LH_Calc4to4_Di16_Do16_Lut8_G16 != LH_CALC_USE_DO_N_DIM
03608
case 16:
03609 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut8_G16);
03610
break;
03611
#endif
03612
}
03613
break;
03614
case 16:
03615
switch (lutParam->colorLutGridPoints)
03616 {
03617
#if LH_Calc4to4_Di16_Do16_Lut16_G8 != LH_CALC_USE_DO_N_DIM
03618
case 8:
03619 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G8);
03620
break;
03621
#endif
03622
#if LH_Calc4to4_Di16_Do16_Lut16_G16 != LH_CALC_USE_DO_N_DIM
03623
case 16:
03624 proc2call =
NewCalcProc(LHCalc4to4_Di16_Do16_Lut16_G16);
03625
break;
03626
#endif
03627
}
03628
break;
03629 }
03630
break;
03631 }
03632
break;
03633 }
03634
break;
03635 }
03636
break;
03637 }
03638 }
03639
#endif
03640
03641
if ( ( proc2call ==
nil )
03642
#ifdef DEBUG_OUTPUT
03643
|| ( gUSE_NDIM_FOR_BITMAP )
03644
#endif
03645
)
03646 {
03647
switch (info->
usedSizeIn)
03648 {
03649
case 8:
03650
switch (info->
usedSizeOut)
03651 {
03652
case 8:
03653
switch (lutParam->
colorLutWordSize)
03654 {
03655
case 8:
03656 proc2call =
NewCalcProc(CalcNDim_Data8To8_Lut8);
03657
break;
03658
case 16:
03659 proc2call =
NewCalcProc(CalcNDim_Data8To8_Lut16);
03660
break;
03661 }
03662
break;
03663
case 16:
03664
switch (lutParam->
colorLutWordSize)
03665 {
03666
case 8:
03667 proc2call =
NewCalcProc(CalcNDim_Data8To16_Lut8);
03668
break;
03669
case 16:
03670 proc2call =
NewCalcProc(CalcNDim_Data8To16_Lut16);
03671
break;
03672 }
03673
break;
03674 }
03675
break;
03676
case 16:
03677
switch (info->
usedSizeOut)
03678 {
03679
case 8:
03680
switch (lutParam->
colorLutWordSize)
03681 {
03682
case 8:
03683 proc2call =
NewCalcProc(CalcNDim_Data16To8_Lut8);
03684
break;
03685
case 16:
03686 proc2call =
NewCalcProc(CalcNDim_Data16To8_Lut16);
03687
break;
03688 }
03689
break;
03690
case 16:
03691
switch (lutParam->
colorLutWordSize)
03692 {
03693
case 8:
03694 proc2call =
NewCalcProc(CalcNDim_Data16To16_Lut8);
03695
break;
03696
case 16:
03697 proc2call =
NewCalcProc(CalcNDim_Data16To16_Lut16);
03698
break;
03699 }
03700
break;
03701 }
03702
break;
03703 }
03704 }
03705
03706
#ifdef DEBUG_OUTPUT
03707
if ( DebugCheck(kThisFile, kDebugMiscInfo) )
03708 {
03709
if ( gUSE_NDIM_FOR_BITMAP )
03710
DebugPrint(
"DoNDIM: %1d->%1d Di %2d Do %2d Grid %2d Lut %2d\n", lutParam->
colorLutInDim, lutParam->
colorLutOutDim,
03711 info->
usedSizeIn, info->
usedSizeOut,
03712 lutParam->
colorLutGridPoints, lutParam->
colorLutWordSize);
03713
else
03714
DebugPrint(
"OPTIMIZED: %1d->%1d Di %2d Do %2d Grid %2d Lut %2d\n", lutParam->
colorLutInDim, lutParam->
colorLutOutDim,
03715 info->
usedSizeIn, info->
usedSizeOut,
03716 lutParam->
colorLutGridPoints, lutParam->
colorLutWordSize);
03717 }
03718
if (proc2call ==
nil)
03719
DebugPrint(
"¥ ERROR: FindCalcRoutine is nil !!!\n");
03720
#endif
03721
LH_END_PROC(
"FindCalcRoutine")
03722 return proc2call;
03723 }
03724
03725 #ifdef __MWERKS__
03726 #pragma mark ================ Match/Check CMColors ================
03727 #endif
03728
03729
03730
03731
03732 CMError
03733 LHMatchColorsPrivate (CMMModelPtr modelingData,
03734
CMColor* myColors,
03735 SINT32 count)
03736 {
03737
CMCalcParam calcParam;
03738
CMLutParam lutParam;
03739
CMError err = -1;
03740
ColorSpaceInfo info;
03741
CalcProcPtr calcRoutine =
nil;
03742
03743
LH_START_PROC(
"LHMatchColorsPrivate")
03744
03745
LOCK_DATA((modelingData)->lutParam.
inputLut);
03746
LOCK_DATA((modelingData)->lutParam.
colorLut);
03747
LOCK_DATA((modelingData)->lutParam.
outputLut);
03748
03749
03750
if (modelingData->hasNamedColorProf ==
NamedColorProfileOnly){
03751 err =
ConvertNamedIndexToColors(modelingData,myColors,count);
03752
goto CleanupAndExit;
03753 }
03754
else if (modelingData->hasNamedColorProf==
NamedColorProfileAtBegin){
03755 err =
ConvertNamedIndexToPCS(modelingData,myColors,count);
03756
if (err)
goto CleanupAndExit;
03757 }
03758
03759
SetMem(&info,
sizeof(
ColorSpaceInfo), 0);
03760
SetMem(&calcParam,
sizeof(
CMCalcParam), 0);
03761
03762 info.
origSizeIn = 16;
03763 info.
origSizeOut = 16;
03764 info.
usedSizeIn = 16;
03765 info.
usedSizeOut = 16;
03766
03767
FillLutParam(&lutParam, modelingData);
03768
FillCalcParamCM(&calcParam, &lutParam, myColors, count );
03769
03770 info.
inPlace =
TRUE;
03771 calcRoutine =
FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup );
03772
if (calcRoutine ==
nil)
03773 {
03774 err =
cmMethodError;
03775
goto CleanupAndExit;
03776 }
03777
03778 err =
CallCalcProc(calcRoutine,&calcParam, &lutParam);
03779
if (err)
03780
goto CleanupAndExit;
03781
03782
03783 err =
ConvertPCSToNamedIndex(modelingData,myColors,count);
03784
03785 CleanupAndExit:
03786
UNLOCK_DATA((modelingData)->lutParam.
inputLut);
03787
UNLOCK_DATA((modelingData)->lutParam.
colorLut);
03788
UNLOCK_DATA((modelingData)->lutParam.
outputLut);
03789
03790
LH_END_PROC(
"LHMatchColorsPrivate")
03791
return err;
03792 }
03793
03794
03795
03796
03797 CMError LHCheckColorsPrivateMS( CMMModelPtr modelingData,
03798
CMColor* myColors,
03799 UINT32 count,
03800 UINT8 *result )
03801 {
03802
CMCalcParam calcParam;
03803
CMLutParam lutParam;
03804
CMError err = -1;
03805
ColorSpaceInfo info;
03806
CalcProcPtr calcRoutine =
nil;
03807
03808
LH_START_PROC(
"LHCheckColorsPrivateMS")
03809
03810
if( (modelingData)->gamutLutParam.colorLut == 0 )
return cmMethodError;
03811
LOCK_DATA((modelingData)->gamutLutParam.inputLut);
03812
LOCK_DATA((modelingData)->gamutLutParam.colorLut);
03813
LOCK_DATA((modelingData)->gamutLutParam.outputLut);
03814
03815
03816
if (modelingData->hasNamedColorProf ==
NamedColorProfileOnly){
03817 err =
unimpErr;
03818
goto CleanupAndExit;
03819 }
03820
else if (modelingData->hasNamedColorProf==
NamedColorProfileAtBegin){
03821 err =
ConvertNamedIndexToPCS(modelingData,myColors,count);
03822
if (err)
goto CleanupAndExit;
03823 }
03824
03825
SetMem(&info,
sizeof(
ColorSpaceInfo), 0);
03826
SetMem(&calcParam,
sizeof(
CMCalcParam), 0);
03827
03828 info.
origSizeIn = 16;
03829 info.
origSizeOut = 8;
03830 info.
usedSizeIn = 16;
03831 info.
usedSizeOut = 8;
03832
03833
FillLutParamChk(&lutParam, modelingData);
03834
FillCalcParamCM(&calcParam, &lutParam, myColors, count );
03835 calcParam.
outputData[0] = (
Ptr)result;
03836 calcParam.
cmOutputBytesPerLine = count*
sizeof(
UINT8);
03837 calcParam.
cmOutputPixelOffset = 1;
03838 calcParam.
cmOutputColorSpace =
cmGraySpace8Bit;
03839
03840
03841 info.
inPlace = (
UINT8 *)myColors == result;
03842 calcRoutine =
FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup );
03843
if (calcRoutine ==
nil)
03844 {
03845 err =
cmMethodError;
03846
goto CleanupAndExit;
03847 }
03848
03849 err =
CallCalcProc(calcRoutine,&calcParam, &lutParam);
03850
if (err)
03851
goto CleanupAndExit;
03852
03853
03854
if( modelingData->hasNamedColorProf ==
NamedColorProfileAtEnd ){
03855 err =
unimpErr;
03856
goto CleanupAndExit;
03857 }
03858 CleanupAndExit:
03859
UNLOCK_DATA((modelingData)->gamutLutParam.inputLut);
03860
UNLOCK_DATA((modelingData)->gamutLutParam.colorLut);
03861
UNLOCK_DATA((modelingData)->gamutLutParam.outputLut);
03862
03863
LH_END_PROC(
"LHCheckColorsPrivateMS")
03864
return err;
03865 }
03866
03867
03868
03869
03870
CMError
03871 LHCheckColorsPrivate ( CMMModelPtr modelingData,
03872
CMColor* myColors,
03873 UINT32 count,
03874 UINT8 *result )
03875 {
03876
CMCalcParam calcParam;
03877
CMLutParam lutParam;
03878
CMError err = -1;
03879
ColorSpaceInfo info;
03880
CalcProcPtr calcRoutine =
nil;
03881
03882
LH_START_PROC(
"LHCheckColorsPrivate")
03883
03884
SetMem(&info,
sizeof(
ColorSpaceInfo), 0);
03885
SetMem(&calcParam,
sizeof(
CMCalcParam), 0);
03886
03887
03888
if ( modelingData->hasNamedColorProf ==
NamedColorProfileOnly ||
03889 modelingData->hasNamedColorProf ==
NamedColorProfileAtEnd ){
03890 err =
unimpErr;
03891
goto CleanupAndExit;
03892 }
03893
03894 info.
origSizeIn = 16;
03895 info.
origSizeOut = 16;
03896 info.
usedSizeIn = 16;
03897 info.
usedSizeOut = 16;
03898
03899
if( (modelingData)->gamutLutParam.colorLut == 0 )
return cmMethodError;
03900
LOCK_DATA((modelingData)->gamutLutParam.inputLut);
03901
LOCK_DATA((modelingData)->gamutLutParam.colorLut);
03902
LOCK_DATA((modelingData)->gamutLutParam.outputLut);
03903
03904
FillLutParamChk(&lutParam, modelingData);
03905
FillCalcParamCM(&calcParam, &lutParam, myColors, count );
03906
03907
AllocBufferCheckCM(&calcParam, &info);
03908
03909 info.
inPlace = info.
tempOutBuffer ==
nil;
03910 calcRoutine =
FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup );
03911
if (calcRoutine ==
nil)
03912 {
03913 err =
cmMethodError;
03914
goto CleanupAndExit;
03915 }
03916
03917 err =
CallCalcProc(calcRoutine, &calcParam, &lutParam);
03918
03919
Convert8To1( (
Ptr)info.
tempOutBuffer, (
Ptr)result, info.
processedLinesIn, calcParam.
cmLineCount, count, count*
sizeof(
CMColor));
03920
03921
DisposeIfPtr((
Ptr)info.
tempOutBuffer);
03922
03923 CleanupAndExit:
03924
UNLOCK_DATA((modelingData)->gamutLutParam.inputLut);
03925
UNLOCK_DATA((modelingData)->gamutLutParam.colorLut);
03926
UNLOCK_DATA((modelingData)->gamutLutParam.outputLut);
03927
03928
LH_END_PROC(
"LHCheckColorsPrivate")
03929
return err;
03930 }
03931
03932
void CopyIndexData(
CMBitmap *bitMapIn,
CMBitmap *bitMapOut,
ColorSpaceInfo *info );
03933
void CopyIndexData(
CMBitmap *bitMapIn,
CMBitmap *bitMapOut,
ColorSpaceInfo *info )
03934 {
03935
Ptr imgIn=
NULL;
03936
Ptr imgOut=
NULL;
03937
SINT32 i,j;
03938
#ifdef DEBUG_OUTPUT
03939
CMError err = -1;
03940
#endif
03941
LH_START_PROC(
"CopyIndexData")
03942
03943 for( i=0; i<bitMapIn->height; i++ ){
03944 imgIn = bitMapIn->
image + i * bitMapIn->
rowBytes;
03945 imgOut = bitMapOut->
image + i * bitMapOut->
rowBytes;
03946
if( info->
inputPixelSize == 24 ){
03947
if( info->
outputPixelSize == 24 ){
03948
for (j=0;j<bitMapIn->
width;j++) {
03949 *imgOut++ = *imgIn++;
03950 *imgOut++ = *imgIn++;
03951 *imgOut++ = *imgIn++;
03952 }
03953 }
03954
else if( info->
outputPixelSize == 32 ){
03955
for (j=0;j<bitMapIn->
width;j++) {
03956 *imgOut++ = *imgIn++;
03957 *imgOut++ = *imgIn++;
03958 *imgOut++ = *imgIn++;
03959 imgOut++;
03960 }
03961 }
03962 }
03963
else if( info->
inputPixelSize == 32 ){
03964
if( info->
outputPixelSize == 24 ){
03965
for (j=0;j<bitMapIn->
width;j++) {
03966 *imgOut++ = *imgIn++;
03967 *imgOut++ = *imgIn++;
03968 *imgOut++ = *imgIn++;
03969 imgIn++;
03970 }
03971 }
03972
else if( info->
outputPixelSize == 32 ){
03973
for (j=0;j<bitMapIn->
width;j++) {
03974 *imgOut++ = *imgIn++;
03975 *imgOut++ = *imgIn++;
03976 *imgOut++ = *imgIn++;
03977 imgOut++;
03978 imgIn++;
03979 }
03980 }
03981 }
03982 }
03983
LH_END_PROC(
"CopyIndexData")
03984 return;
03985 }
03986
03987 #ifdef __MWERKS__
03988 #pragma mark ================ Match/Check CMBitmaps ================
03989 #endif
03990
03991
03992
03993
03994 CMError
03995 LHMatchBitMapPrivate ( CMMModelPtr modelingData,
03996 const
CMBitmap * inBitMap,
03997 CMBitmapCallBackUPP progressProc,
03998
void * refCon,
03999
CMBitmap * outBitMap )
04000 {
04001
CMCalcParam calcParam;
04002
CMLutParam lutParam;
04003
CMError err = -1;
04004
ColorSpaceInfo info;
04005
CalcProcPtr calcRoutine =
nil;
04006
CMBitmap bitMapOut;
04007
CMBitmap bitMapIn = *inBitMap;
04008
OSType inColorSpace = modelingData->firstColorSpace;
04009
OSType outColorSpace = modelingData->lastColorSpace;
04010
Boolean progressProcWasCalled =
FALSE;
04011
SINT32 offset;
04012
SINT32 progressTimer;
04013
SINT32 dimLoop;
04014
Boolean matchInPlace =
FALSE;
04015
long progressProcCount = 0;
04016
SINT32 inLineCount;
04017
Ptr aBuffer;
04018
04019
LH_START_PROC(
"LHMatchBitMapPrivate")
04020
04021
LOCK_DATA((modelingData)->lutParam.
inputLut);
04022
LOCK_DATA((modelingData)->lutParam.
colorLut);
04023
LOCK_DATA((modelingData)->lutParam.
outputLut);
04024
04025
if( outBitMap ==
nil ){
04026 bitMapOut = *inBitMap;
04027 matchInPlace =
TRUE;
04028 }
04029
else{
04030 bitMapOut = *outBitMap;
04031 }
04032
04033
SetMem(&info,
sizeof(
ColorSpaceInfo), 0);
04034
SetMem(&calcParam,
sizeof(
CMCalcParam), 0);
04035
04036
FillLutParam(&lutParam, modelingData);
04037
FillCalcParam(&calcParam, &bitMapIn, &bitMapOut);
04038
04039 err =
CheckInputColorSpace( &bitMapIn, &calcParam, &info, inColorSpace, lutParam.
colorLutInDim );
04040 inLineCount = calcParam.
cmLineCount;
04041
if (err)
04042
goto CleanupAndExit;
04043
04044
if (matchInPlace){
04045 err =
SetOutputColorSpaceInplace( &calcParam, &info, outColorSpace);
04046
if (err)
04047
goto CleanupAndExit;
04048 }
04049 err =
CheckOutputColorSpace( &bitMapOut, &calcParam, &info, outColorSpace, lutParam.
colorLutOutDim );
04050
if (err)
04051
goto CleanupAndExit;
04052
04053
if (matchInPlace)
04054 {
04055
if (info.
inputPixelSize < info.
outputPixelSize)
04056 {
04057 err =
cmInvalidDstMap;
04058
goto CleanupAndExit;
04059 }
04060
04061 bitMapIn.
space = calcParam.
cmOutputColorSpace;
04062 }
else
04063 {
04064 calcParam.
copyAlpha = (calcParam.
cmInputColorSpace &
cmAlphaSpace) && (calcParam.
cmOutputColorSpace &
cmAlphaSpace);
04065 }
04066
04067 info.
inPlace = bitMapOut.
image == bitMapIn.
image && info.
tempInBuffer ==
nil && info.
tempOutBuffer ==
nil;
04068 calcRoutine =
FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup );
04069
if (calcRoutine ==
nil)
04070 {
04071 err =
cmMethodError;
04072
goto CleanupAndExit;
04073 }
04074
04075
if( info.
inPlace && calcParam.
cmInputPixelOffset < calcParam.
cmOutputPixelOffset ){
04076
for( dimLoop=0; dimLoop<8; dimLoop++){
04077 calcParam.
inputData[dimLoop] = (
Ptr)calcParam.
inputData[dimLoop] + (calcParam.
cmLineCount-1) * calcParam.
cmInputBytesPerLine + (calcParam.
cmPixelPerLine-1) * calcParam.
cmInputPixelOffset;
04078 calcParam.
outputData[dimLoop] = (
Ptr)calcParam.
outputData[dimLoop] + (calcParam.
cmLineCount-1) * calcParam.
cmOutputBytesPerLine + (calcParam.
cmPixelPerLine-1) * calcParam.
cmOutputPixelOffset;
04079 }
04080 calcParam.
cmInputPixelOffset = -calcParam.
cmInputPixelOffset;
04081 calcParam.
cmOutputPixelOffset = -calcParam.
cmOutputPixelOffset;
04082 calcParam.
cmInputBytesPerLine = -calcParam.
cmInputBytesPerLine;
04083 calcParam.
cmOutputBytesPerLine = -calcParam.
cmOutputBytesPerLine;
04084 }
04085
04086
if ((info.
tempInBuffer ==
nil) && (info.
tempOutBuffer ==
nil)&& modelingData->hasNamedColorProf ==
NoNamedColorProfile)
04087 {
04088
if (progressProc ==
nil)
04089 err =
CallCalcProc(calcRoutine,&calcParam, &lutParam);
04090
else
04091 {
04092 calcParam.
cmLineCount =
kMaxTempBlock / calcParam.
cmInputBytesPerLine;
04093
if (calcParam.
cmLineCount < 1)
04094 calcParam.
cmLineCount = 1;
04095
else if (calcParam.
cmLineCount > bitMapIn.
height)
04096 calcParam.
cmLineCount = bitMapIn.
height;
04097
04098 progressTimer =
TickCount();
04099
while ( info.
processedLinesIn < bitMapIn.
height )
04100 {
04101 err =
CallCalcProc(calcRoutine,&calcParam, &lutParam);
04102
04103
for (dimLoop = 0; dimLoop< lutParam.
colorLutInDim; dimLoop++)
04104 calcParam.
inputData[dimLoop] = (
Ptr)calcParam.
inputData[dimLoop] + calcParam.
cmLineCount * calcParam.
cmInputBytesPerLine;
04105
04106
for (dimLoop = 0; dimLoop< lutParam.
colorLutOutDim; dimLoop++)
04107 calcParam.
outputData[dimLoop] = (
Ptr)calcParam.
outputData[dimLoop] + calcParam.
cmLineCount * calcParam.
cmOutputBytesPerLine;
04108
04109 info.
processedLinesIn += calcParam.
cmLineCount;
04110
if ( info.
processedLinesIn + calcParam.
cmLineCount > bitMapIn.
height )
04111 calcParam.
cmLineCount = bitMapIn.
height-info.
processedLinesIn;
04112
04113
04114
if ( progressProc && ( progressTimer +
kProgressTicks < (
SINT32)
TickCount()) )
04115 {
04116 progressProcWasCalled =
TRUE;
04117
if (
CallCMBitmapCallBackProc ( progressProc, bitMapIn.
height, info.
processedLinesIn, (
void *)refCon ))
04118 {
04119 info.
processedLinesIn = bitMapIn.
height;
04120 err =
userCanceledErr;
04121 }
else
04122 progressTimer =
TickCount();
04123 progressProcCount = info.
processedLinesIn;
04124 }
04125 }
04126 }
04127 }
04128
else if (modelingData->hasNamedColorProf !=
NamedColorProfileOnly ){
04129 info.
processedLinesIn = 0;
04130 progressTimer =
TickCount();
04131
if( info.
tempInBuffer && info.
tempOutBuffer ){
04132
if( inLineCount > calcParam.
cmLineCount )inLineCount = calcParam.
cmLineCount;
04133 }
04134
else if( info.
tempInBuffer ){
04135
if( progressProc && modelingData->hasNamedColorProf ==
NamedColorProfileAtEnd ){
04136 inLineCount /= 32;
04137
if( inLineCount < 1 ) inLineCount = 1;
04138 }
04139 }
04140
else if( info.
tempOutBuffer ){
04141 inLineCount = calcParam.
cmLineCount;
04142 }
04143
else if( progressProc ){
04144 inLineCount =
kMaxTempBlock / calcParam.
cmInputBytesPerLine;
04145
if (inLineCount < 1)
04146 inLineCount = 1;
04147
else if (inLineCount > bitMapIn.
height)
04148 inLineCount = bitMapIn.
height;
04149
if( modelingData->hasNamedColorProf ==
NamedColorProfileAtEnd ){
04150 inLineCount /= 32;
04151
if( inLineCount < 1 ) inLineCount = 1;
04152 }
04153 }
04154
while ( info.
processedLinesIn < bitMapIn.
height )
04155 {
04156
if ( info.
processedLinesIn + inLineCount > bitMapIn.
height )
04157 inLineCount = bitMapIn.
height-info.
processedLinesIn;
04158
04159
if (info.
origSizeIn == 5 )
04160
Convert5To8 ( bitMapIn.
image, (
Ptr)info.
tempInBuffer, info.
processedLinesIn, inLineCount, bitMapIn.
width, bitMapIn.
rowBytes );
04161
#ifdef PI_Application_h
04162
else if (info.
origSizeIn == 6 )
04163 Convert565To8 ( bitMapIn.
image, (
Ptr)info.
tempInBuffer, info.
processedLinesIn, inLineCount, bitMapIn.
width, bitMapIn.
rowBytes );
04164
#endif
04165
else if (info.
origSizeIn == 10 )
04166
Convert10To16 ( bitMapIn.
image, (
Ptr)info.
tempInBuffer, info.
processedLinesIn, inLineCount, bitMapIn.
width, bitMapIn.
rowBytes );
04167
04168
if (modelingData->hasNamedColorProf ==
NamedColorProfileAtBegin ){
04169 err =
ConvertIndexToLabBitmap( modelingData, bitMapIn.
image,
04170 (
Ptr)info.
tempInBuffer, info.
processedLinesIn,
04171 inLineCount, bitMapIn.
width,
04172 bitMapIn.
rowBytes,
04173 calcParam.
cmInputBytesPerLine,
04174 calcParam.
cmInputPixelOffset*8 );
04175
if (err)
04176
goto CleanupAndExit;
04177 }
04178 calcParam.
cmLineCount = inLineCount;
04179 err =
CallCalcProc( calcRoutine, &calcParam, &lutParam );
04180
if (err)
04181
goto CleanupAndExit;
04182
04183
if (modelingData->hasNamedColorProf ==
NamedColorProfileAtEnd ){
04184
if( info.
tempOutBuffer )aBuffer = (
Ptr)info.
tempOutBuffer;
04185
else aBuffer = bitMapOut.
image;
04186 err =
ConvertLabToIndexBitmap( modelingData, aBuffer,
04187 info.
processedLinesIn,
04188 calcParam.
cmLineCount,
04189 bitMapOut.
width, bitMapOut.
rowBytes );
04190
if (err)
04191
goto CleanupAndExit;
04192 }
04193
04194
if( info.
origSizeOut == 5 )
04195
Convert8To5 ( (
Ptr)info.
tempOutBuffer, bitMapOut.
image, info.
processedLinesIn, calcParam.
cmLineCount, bitMapOut.
width, bitMapOut.
rowBytes);
04196
#ifdef PI_Application_h
04197
else if( info.
origSizeOut == 6 )
04198 Convert8To565 ( (
Ptr)info.
tempOutBuffer, bitMapOut.
image, info.
processedLinesIn, calcParam.
cmLineCount, bitMapOut.
width, bitMapOut.
rowBytes);
04199
#endif
04200
else if( info.
origSizeOut == 10 )
04201
Convert16To10 ( (
Ptr)info.
tempOutBuffer, bitMapOut.
image, info.
processedLinesIn, calcParam.
cmLineCount, bitMapOut.
width, bitMapOut.
rowBytes);
04202
04203 info.
processedLinesIn += inLineCount;
04204
04205
if ( progressProc && ( progressTimer +
kProgressTicks < (
SINT32)
TickCount()) )
04206 {
04207 progressProcWasCalled =
TRUE;
04208
if (
CallCMBitmapCallBackProc ( progressProc, bitMapIn.
height, info.
processedLinesIn, (
void *)refCon ))
04209 {
04210 info.
processedLinesIn = bitMapIn.
height;
04211 err =
userCanceledErr;
04212 }
else
04213 progressTimer =
TickCount();
04214 progressProcCount = info.
processedLinesIn;
04215 }
04216
if( !info.
tempInBuffer ){
04217 offset = calcParam.
cmLineCount * calcParam.
cmInputBytesPerLine;
04218
for (dimLoop = 0; dimLoop< lutParam.
colorLutInDim; dimLoop++)
04219 calcParam.
inputData[dimLoop] = (
Ptr)calcParam.
inputData[dimLoop] + offset;
04220 }
04221
if( !info.
tempOutBuffer ){
04222 offset = calcParam.
cmLineCount * calcParam.
cmOutputBytesPerLine;
04223
for (dimLoop = 0; dimLoop< lutParam.
colorLutOutDim; dimLoop++)
04224 calcParam.
outputData[dimLoop] = (
Ptr)calcParam.
outputData[dimLoop] + offset;
04225 }
04226 }
04227
DisposeIfPtr((
Ptr)info.
tempInBuffer);
04228
DisposeIfPtr((
Ptr)info.
tempOutBuffer);
04229 }
04230
else{
04231
CopyIndexData( &bitMapIn, &bitMapOut, &info );
04232
DisposeIfPtr((
Ptr)info.
tempInBuffer);
04233 }
04234
if (err)
04235
goto CleanupAndExit;
04236
04237
if( progressProcWasCalled && progressProcCount != bitMapIn.
height )
04238
CallCMBitmapCallBackProc ( progressProc, bitMapIn.
height, bitMapIn.
height, (
void *)refCon );
04239 CleanupAndExit:
04240
UNLOCK_DATA((modelingData)->lutParam.
inputLut);
04241
UNLOCK_DATA((modelingData)->lutParam.
colorLut);
04242
UNLOCK_DATA((modelingData)->lutParam.
outputLut);
04243
04244
LH_END_PROC(
"LHMatchBitMapPrivate")
04245
04246
return err;
04247 }
04248
04249
04250
04251
04252
CMError
04253 LHCheckBitMapPrivate ( CMMModelPtr modelingData,
04254
const CMBitmap *inBitMap,
04255 CMBitmapCallBackUPP progressProc,
04256
void * refCon,
04257
CMBitmap *outBitMap )
04258 {
04259
CMCalcParam calcParam;
04260
CMLutParam lutParam;
04261
CMError err = -1;
04262
ColorSpaceInfo info;
04263
CalcProcPtr calcRoutine =
nil;
04264
CMBitmap bitMapIn = *inBitMap;
04265
CMBitmap bitMapOut;
04266
OSType inColorSpace = modelingData->firstColorSpace;
04267
Boolean progressProcWasCalled =
FALSE;
04268
SINT32 offset;
04269
SINT32 progressTimer;
04270
SINT32 dimLoop;
04271
Boolean matchInPlace =
FALSE;
04272
long progressProcCount = 0;
04273
SINT32 inLineCount;
04274
04275
LH_START_PROC(
"LHCheckBitMapPrivate")
04276
04277
if( (modelingData)->gamutLutParam.colorLut == 0 )
return cmMethodError;
04278
LOCK_DATA((modelingData)->gamutLutParam.inputLut);
04279
LOCK_DATA((modelingData)->gamutLutParam.colorLut);
04280
LOCK_DATA((modelingData)->gamutLutParam.outputLut);
04281
04282
SetMem(&info,
sizeof(
ColorSpaceInfo), 0);
04283
SetMem(&calcParam,
sizeof(
CMCalcParam), 0);
04284
04285
if ( (outBitMap ==
nil ) || (modelingData->gamutLutParam.colorLut ==
nil) )
04286 {
04287 err =
cmInvalidDstMap;
04288
goto CleanupAndExit;
04289 }
04290 bitMapOut = *outBitMap;
04291
FillLutParamChk(&lutParam, modelingData);
04292
FillCalcParam(&calcParam, &bitMapIn, &bitMapOut);
04293
04294 err =
CheckInputColorSpace( &bitMapIn, &calcParam, &info, inColorSpace, lutParam.
colorLutInDim );
04295 inLineCount = calcParam.
cmLineCount;
04296
if (err)
04297
goto CleanupAndExit;
04298
04299 err =
CheckOutputColorSpaceChk( &bitMapOut, &calcParam, &info );
04300
if (err)
04301
goto CleanupAndExit;
04302
04303 info.
inPlace = bitMapOut.
image == bitMapIn.
image && info.
tempInBuffer ==
nil && info.
tempOutBuffer ==
nil;
04304 calcRoutine =
FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup );
04305
if (calcRoutine ==
nil)
04306 {
04307 err =
cmMethodError;
04308
goto CleanupAndExit;
04309 }
04310
04311
04312
if ((info.
tempInBuffer ==
nil) && (info.
tempOutBuffer ==
nil) && modelingData->hasNamedColorProf ==
NoNamedColorProfile)
04313 {
04314
if (progressProc ==
nil)
04315 err =
CallCalcProc(calcRoutine,&calcParam, &lutParam);
04316
else
04317 {
04318 calcParam.
cmLineCount =
kMaxTempBlock / calcParam.
cmInputBytesPerLine;
04319
if (calcParam.
cmLineCount < 1)
04320 calcParam.
cmLineCount = 1;
04321
else if (calcParam.
cmLineCount > bitMapIn.
height)
04322 calcParam.
cmLineCount = bitMapIn.
height;
04323
04324 progressTimer =
TickCount();
04325
while ( info.
processedLinesIn < bitMapIn.
height )
04326 {
04327 err =
CallCalcProc(calcRoutine,&calcParam, &lutParam);
04328
04329
for (dimLoop = 0; dimLoop< lutParam.
colorLutInDim; dimLoop++)
04330 calcParam.
inputData[dimLoop] = (
Ptr)calcParam.
inputData[dimLoop] + calcParam.
cmLineCount * calcParam.
cmInputBytesPerLine;
04331
04332
for (dimLoop = 0; dimLoop< lutParam.
colorLutOutDim; dimLoop++)
04333 calcParam.
outputData[dimLoop] = (
Ptr)calcParam.
outputData[dimLoop] + calcParam.
cmLineCount * calcParam.
cmOutputBytesPerLine;
04334
04335 info.
processedLinesIn += calcParam.
cmLineCount;
04336
if ( info.
processedLinesIn + calcParam.
cmLineCount > bitMapIn.
height )
04337 calcParam.
cmLineCount = bitMapIn.
height-info.
processedLinesIn;
04338
04339
04340
if ( progressProc && ( progressTimer +
kProgressTicks < (
SINT32)
TickCount()) )
04341 {
04342 progressProcWasCalled =
TRUE;
04343
if (
CallCMBitmapCallBackProc ( progressProc, bitMapIn.
height, info.
processedLinesIn, (
void *)refCon ))
04344 {
04345 info.
processedLinesIn = bitMapIn.
height;
04346 err =
userCanceledErr;
04347 }
else
04348 progressTimer =
TickCount();
04349 progressProcCount = info.
processedLinesIn;
04350 }
04351 }
04352 }
04353 }
04354
else if (modelingData->hasNamedColorProf !=
NamedColorProfileOnly ){
04355 info.
processedLinesIn = 0;
04356 progressTimer =
TickCount();
04357
if( info.
tempInBuffer && info.
tempOutBuffer ){
04358
if( inLineCount > calcParam.
cmLineCount )inLineCount = calcParam.
cmLineCount;
04359 }
04360
else if( info.
tempInBuffer ){
04361 }
04362
else if( info.
tempOutBuffer ){
04363 inLineCount = calcParam.
cmLineCount;
04364 }
04365
else if( progressProc ){
04366 inLineCount =
kMaxTempBlock / calcParam.
cmInputBytesPerLine;
04367
if (inLineCount < 1)
04368 inLineCount = 1;
04369
else if (inLineCount > bitMapIn.
height)
04370 inLineCount = bitMapIn.
height;
04371 }
04372
while ( info.
processedLinesIn < bitMapIn.
height )
04373 {
04374
if ( info.
processedLinesIn + inLineCount > bitMapIn.
height )
04375 inLineCount = bitMapIn.
height-info.
processedLinesIn;
04376
04377
if (info.
origSizeIn == 5 )
04378
Convert5To8 ( bitMapIn.
image, (
Ptr)info.
tempInBuffer, info.
processedLinesIn, inLineCount, bitMapIn.
width, bitMapIn.
rowBytes );
04379
#ifdef PI_Application_h
04380
else if (info.
origSizeIn == 6 )
04381 Convert565To8 ( bitMapIn.
image, (
Ptr)info.
tempInBuffer, info.
processedLinesIn, inLineCount, bitMapIn.
width, bitMapIn.
rowBytes );
04382
#endif
04383
else if (info.
origSizeIn == 10 )
04384
Convert10To16 ( bitMapIn.
image, (
Ptr)info.
tempInBuffer, info.
processedLinesIn, inLineCount, bitMapIn.
width, bitMapIn.
rowBytes );
04385
04386
if (modelingData->hasNamedColorProf ==
NamedColorProfileAtBegin ){
04387 err =
ConvertIndexToLabBitmap( modelingData, bitMapIn.
image,
04388 (
Ptr)info.
tempInBuffer, info.
processedLinesIn,
04389 inLineCount, bitMapIn.
width,
04390 bitMapIn.
rowBytes,
04391 calcParam.
cmInputBytesPerLine,
04392 calcParam.
cmInputPixelOffset*8 );
04393
if (err)
04394
goto CleanupAndExit;
04395 }
04396 calcParam.
cmLineCount = inLineCount;
04397 err =
CallCalcProc( calcRoutine, &calcParam, &lutParam );
04398
if (err)
04399
goto CleanupAndExit;
04400
04401
if( info.
origSizeOut == 1 )
04402
Convert8To1 ( (
Ptr)info.
tempOutBuffer, bitMapOut.
image, info.
processedLinesIn, calcParam.
cmLineCount, bitMapOut.
width, bitMapOut.
rowBytes);
04403
04404 info.
processedLinesIn += inLineCount;
04405
04406
if ( progressProc && ( progressTimer +
kProgressTicks < (
SINT32)
TickCount()) )
04407 {
04408 progressProcWasCalled =
TRUE;
04409
if (
CallCMBitmapCallBackProc ( progressProc, bitMapIn.
height, info.
processedLinesIn, (
void *)refCon ))
04410 {
04411 info.
processedLinesIn = bitMapIn.
height;
04412 err =
userCanceledErr;
04413 }
else
04414 progressTimer =
TickCount();
04415 progressProcCount = info.
processedLinesIn;
04416 }
04417
if( !info.
tempInBuffer ){
04418 offset = calcParam.
cmLineCount * calcParam.
cmInputBytesPerLine;
04419
for (dimLoop = 0; dimLoop< lutParam.
colorLutInDim; dimLoop++)
04420 calcParam.
inputData[dimLoop] = (
Ptr)calcParam.
inputData[dimLoop] + offset;
04421 }
04422
if( !info.
tempOutBuffer ){
04423 offset = calcParam.
cmLineCount * calcParam.
cmOutputBytesPerLine;
04424
for (dimLoop = 0; dimLoop< lutParam.
colorLutOutDim; dimLoop++)
04425 calcParam.
outputData[dimLoop] = (
Ptr)calcParam.
outputData[dimLoop] + offset;
04426 }
04427 }
04428
DisposeIfPtr((
Ptr)info.
tempInBuffer);
04429
DisposeIfPtr((
Ptr)info.
tempOutBuffer);
04430 }
04431
else{
04432
DisposeIfPtr((
Ptr)info.
tempInBuffer);
04433 err =
cmMethodError;
04434
goto CleanupAndExit;
04435 }
04436
if (err)
04437
goto CleanupAndExit;
04438
04439
if( progressProcWasCalled && progressProcCount != bitMapIn.
height )
04440
CallCMBitmapCallBackProc ( progressProc, bitMapIn.
height, bitMapIn.
height, (
void *)refCon );
04441 CleanupAndExit:
04442
UNLOCK_DATA((modelingData)->gamutLutParam.inputLut);
04443
UNLOCK_DATA((modelingData)->gamutLutParam.colorLut);
04444
UNLOCK_DATA((modelingData)->gamutLutParam.outputLut);
04445
04446
LH_END_PROC(
"LHCheckBitMapPrivate")
04447
04448
return err;
04449 }
04450
04451
#ifdef __MWERKS__
04452
#pragma mark ================ Match/Check CMBitmaps Plane ================
04453
#endif
04454
04455
04456
04457
04458
04459
04460
04461
04462
04463
CMError
04464 LHMatchBitMapPlanePrivate ( CMMModelPtr modelingData,
04465
const LH_CMBitmapPlane * bitMapLH,
04466 CMBitmapCallBackUPP progressProc,
04467
void * refCon,
04468
LH_CMBitmapPlane * matchedBitMapLH )
04469 {
04470
CMCalcParam calcParam;
04471
CMLutParam lutParam;
04472
CMError err = -1;
04473
ColorSpaceInfo info;
04474
CalcProcPtr calcRoutine =
nil;
04475
LH_CMBitmapPlane * secondBitmapLH = matchedBitMapLH;
04476
OSType inColorSpace = (modelingData)->firstColorSpace;
04477
OSType outColorSpace = (modelingData)->lastColorSpace;
04478
Boolean progressProcWasCalled =
FALSE;
04479
Boolean matchInPlace =
FALSE;
04480
SINT32 dimLoop;
04481
04482
LH_START_PROC(
"LHMatchBitMapPlanePrivate")
04483
04484
SetMem(&info,
sizeof(
ColorSpaceInfo), 0);
04485
SetMem(&calcParam,
sizeof(
CMCalcParam), 0);
04486
04487
if (secondBitmapLH ==
nil)
04488 {
04489 secondBitmapLH = (
LH_CMBitmapPlane *)bitMapLH;
04490 matchInPlace =
TRUE;
04491 }
04492
04493
LOCK_DATA((modelingData)->lutParam.
inputLut);
04494
LOCK_DATA((modelingData)->lutParam.
colorLut);
04495
LOCK_DATA((modelingData)->lutParam.
outputLut);
04496
04497
04498 {
04499
CMBitmap bitMap;
04500
CMBitmap secondBitmap;
04501
04502 bitMap.
image = bitMapLH->
image[0];
04503 bitMap.
width = bitMapLH->
width;
04504 bitMap.
height = bitMapLH->
height;
04505 bitMap.
rowBytes = bitMapLH->
rowBytes;
04506 bitMap.
pixelSize = bitMapLH->
pixelSize;
04507 bitMap.
space = bitMapLH->
space;
04508
04509 secondBitmap.
image = secondBitmapLH->
image[0];
04510 secondBitmap.
width = secondBitmapLH->
width;
04511 secondBitmap.
height = secondBitmapLH->
height;
04512 secondBitmap.
rowBytes = secondBitmapLH->
rowBytes;
04513 secondBitmap.
pixelSize = secondBitmapLH->
pixelSize;
04514 secondBitmap.
space = secondBitmapLH->
space;
04515
04516
FillLutParam(&lutParam, modelingData);
04517
FillCalcParam(&calcParam, &bitMap, &secondBitmap);
04518
04519 err =
CheckInputColorSpace(&bitMap,&calcParam, &info, inColorSpace, lutParam.
colorLutInDim );
04520
if (err)
04521
goto CleanupAndExit;
04522 err =
CheckOutputColorSpace(&secondBitmap,&calcParam, &info, outColorSpace, lutParam.
colorLutOutDim );
04523
if (err)
04524
goto CleanupAndExit;
04525 }
04526
04527
04528
for (dimLoop = 0; dimLoop < 8; dimLoop++)
04529 {
04530 calcParam.
inputData[dimLoop] = bitMapLH->
image[dimLoop];
04531 calcParam.
outputData[dimLoop] = secondBitmapLH->
image[dimLoop];
04532 }
04533
04534 calcParam.
cmInputPixelOffset = bitMapLH->
elementOffset;
04535 calcParam.
cmOutputPixelOffset = secondBitmapLH->
elementOffset;
04536
if (bitMapLH == secondBitmapLH)
04537 {
04538
if (calcParam.
cmInputPixelOffset < calcParam.
cmOutputPixelOffset)
04539 {
04540 err =
cmInvalidDstMap;
04541
goto CleanupAndExit;
04542 }
04543
if (info.
origSizeIn * lutParam.
colorLutInDim < info.
origSizeOut * lutParam.
colorLutOutDim)
04544 {
04545 err =
cmInvalidDstMap;
04546
goto CleanupAndExit;
04547 }
04548 }
else
04549 {
04550 calcParam.
copyAlpha = (calcParam.
cmInputColorSpace &
cmAlphaSpace) && (calcParam.
cmOutputColorSpace &
cmAlphaSpace);
04551 }
04552
04553 info.
inPlace = info.
tempInBuffer ==
nil && info.
tempOutBuffer ==
nil;
04554 calcRoutine =
FindCalcRoutine( &calcParam, &lutParam, &info, modelingData->lookup );
04555
if (calcRoutine ==
nil)
04556 {
04557 err =
cmMethodError;
04558
goto CleanupAndExit;
04559 }
04560
04561
04562
if ((info.
tempInBuffer ==
nil) && (info.
tempOutBuffer ==
nil))
04563 {
04564 err =
CallCalcProc(calcRoutine,&calcParam, &lutParam);
04565 }
04566
04567
else if ((info.
tempInBuffer !=
nil) && (info.
tempOutBuffer ==
nil))
04568 {
04569
DisposeIfPtr((
Ptr)info.
tempInBuffer);
04570 }
04571
04572
else if ((info.
tempInBuffer ==
nil) && (info.
tempOutBuffer !=
nil))
04573 {
04574
DisposeIfPtr((
Ptr)info.
tempOutBuffer);
04575 }
04576
04577
else
04578 {
04579
DisposeIfPtr((
Ptr)info.
tempInBuffer);
04580
DisposeIfPtr((
Ptr)info.
tempOutBuffer);
04581 }
04582
04583
if (progressProcWasCalled)
04584
CallCMBitmapCallBackProc ( progressProc, 0, 0, (
void *)refCon );
04585 CleanupAndExit:
04586
UNLOCK_DATA((modelingData)->lutParam.
inputLut);
04587
UNLOCK_DATA((modelingData)->lutParam.
colorLut);
04588
UNLOCK_DATA((modelingData)->lutParam.
outputLut);
04589
04590
LH_END_PROC(
"LHMatchBitMapPlanePrivate")
04591
return err;
04592 }
04593
04594
#ifdef __MWERKS__
04595
#pragma mark ================ Utilities for NamedColor ================
04596
#endif
04597
04598
04599
04600
04601
04602
04603 OSErr ConvertNamedIndexToColors( CMMModelPtr modelingData,
04604
CMColor *theData,
04605 SINT32 pixCnt )
04606 {
04607
UINT16 *tagTbl =
NULL;
04608
LUT_DATA_TYPE tagH =
NULL;
04609
OSErr err =
noErr;
04610
UINT32 i,index;
04611
UINT16 *colorPtr=
NULL;
04612
int elemSz,deviceChannelCount,count;
04613
04614
LH_START_PROC(
"ConvertNamedIndexToColors")
04615
04616
if ( modelingData->hasNamedColorProf!=
NoNamedColorProfile)
04617 {
04618
04619 tagH = modelingData->theNamedColorTagData;
04620
if (tagH==
NULL)
04621 {
04622 err =
cmparamErr;
04623
goto CleanUp;
04624 }
04625
LOCK_DATA(tagH);
04626
04627
04628
04629 tagTbl = (
UINT16 *)
DATA_2_PTR(tagH) + 61;
04630
04631
04632 count = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.count;
04633 deviceChannelCount = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.nDeviceCoords;
04634
if (deviceChannelCount==3)
04635 {
04636 elemSz = 32+(3+3)*
sizeof(
SINT16);
04637 }
else if (deviceChannelCount == 4)
04638 {
04639 elemSz = 32+(3+4)*
sizeof(
SINT16);
04640 }
else if (deviceChannelCount == 0)
04641 {
04642 elemSz = 32+(3+0)*
sizeof(
SINT16);
04643 }
else
04644 {
04645 err =
cmparamErr;
04646
goto CleanUp;
04647 }
04648 elemSz/=2;
04649
04650
04651
for (i=0; i<(
UINT32)pixCnt; i++)
04652 {
04653
04654 index = theData->
namedColor.
namedColorIndex;
04655
if (index > (
UINT32)count || index == 0 )
04656 {
04657 err =
cmNamedColorNotFound;
04658
goto CleanUp;
04659 }
04660 colorPtr = tagTbl + (index-1)*elemSz;
04661
04662
if (deviceChannelCount==3)
04663 {
04664 theData->
rgb.
red = *colorPtr++;
04665 theData->
rgb.
green = *colorPtr++;
04666 theData->
rgb.
blue = *colorPtr++;
04667 }
else if (deviceChannelCount==4)
04668 {
04669 theData->
cmyk.
cyan = *colorPtr++;
04670 theData->
cmyk.
magenta = *colorPtr++;
04671 theData->
cmyk.
yellow = *colorPtr++;
04672 theData->
cmyk.
black = *colorPtr++;
04673 }
04674 theData++;
04675 }
04676
UNLOCK_DATA(tagH);
04677 }
04678 CleanUp:
04679
LH_END_PROC(
"ConvertNamedIndexToColors")
04680
return err;
04681 }
04682
04683
04684
04685
04686
04687
04688 OSErr ConvertNamedIndexToPCS( CMMModelPtr cw,
04689
CMColor *theData,
04690 SINT32 pixCnt )
04691 {
04692
UINT16 *tagTbl =
NULL;
04693
LUT_DATA_TYPE tagH =
NULL;
04694
OSErr err =
noErr;
04695
UINT32 i,index;
04696
UINT16 *colorPtr=
NULL;
04697
int elemSz,deviceChannelCount,count;
04698
CMMModelPtr modelingData = (
CMMModelPtr)cw;
04699
04700
04701
LH_START_PROC(
"ConvertNamedIndexToPCS")
04702
if( cw == 0 )
return cmparamErr;
04703 {
04704
04705 tagH = modelingData->theNamedColorTagData;
04706
if (tagH ==
NULL)
04707 {
04708 err =
cmparamErr;
04709
goto CleanUp;
04710 }
04711
LOCK_DATA(tagH);
04712
04713
04714
04715 tagTbl = (
UINT16 *)
DATA_2_PTR(tagH) + 58;
04716
04717
04718 count = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.count;
04719 deviceChannelCount = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.nDeviceCoords;
04720
if (deviceChannelCount == 3)
04721 {
04722 elemSz = 32+(3+3)*
sizeof(
SINT16);
04723 }
else if (deviceChannelCount == 4)
04724 {
04725 elemSz = 32+(3+4)*
sizeof(
SINT16);
04726 }
else if (deviceChannelCount == 0)
04727 {
04728 elemSz = 32+(3+0)*
sizeof(
SINT16);
04729 }
else
04730 {
04731 err =
cmparamErr;
04732
goto CleanUp;
04733 }
04734 elemSz /= 2;
04735
04736
04737
for (i=0; i<(
UINT32)pixCnt; i++)
04738 {
04739
04740 index = theData->
namedColor.
namedColorIndex;
04741
if (index > (
UINT32)count || index == 0 )
04742 {
04743 err =
cmNamedColorNotFound;
04744
goto CleanUp;
04745 }
04746 colorPtr = tagTbl + (index-1)*elemSz;
04747
04748 theData->
Lab.
L = *colorPtr++;
04749 theData->
Lab.
a = *colorPtr++;
04750 theData->
Lab.
b = *colorPtr++;
04751 theData++;
04752 }
04753
UNLOCK_DATA(tagH);
04754 }
04755 CleanUp:
04756
LH_END_PROC(
"ConvertNamedIndexToPCS")
04757
return err;
04758 }
04759
04760
04761
04762 #define POS(x) ((x) > (0) ? (UINT32)(x) : (UINT32)(-(x)))
04763
04764
04765
04766
04767
04768 OSErr ConvertPCSToNamedIndex( CMMModelPtr modelingData,
04769
CMColor *theData,
04770 SINT32 pixCnt )
04771 {
04772
UINT16 *tagTbl =
NULL;
04773
LUT_DATA_TYPE tagH =
NULL;
04774
OSErr err =
noErr;
04775
UINT32 i,j,index,dE,dEnow;
04776
UINT16 *colorPtr=
NULL;
04777
int elemSz,deviceChannelCount,count;
04778
04779
LH_START_PROC(
"ConvertPCSToNamedIndex")
04780
if (modelingData->hasNamedColorProf ==
NamedColorProfileAtEnd)
04781 {
04782
04783 tagH = modelingData->theNamedColorTagData;
04784
if (tagH==
NULL)
04785 {
04786 err =
cmparamErr;
04787
goto CleanUp;
04788 }
04789
LOCK_DATA(tagH);
04790
04791
04792
04793 tagTbl = (
UINT16 *)
DATA_2_PTR(tagH) + 58;
04794
04795
04796 count = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.count;
04797 deviceChannelCount = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.nDeviceCoords;
04798
if (deviceChannelCount == 3)
04799 {
04800 elemSz = 32+(3+3)*
sizeof(
SINT16);
04801 }
else if (deviceChannelCount == 4)
04802 {
04803 elemSz = 32+(3+4)*
sizeof(
SINT16);
04804 }
else if (deviceChannelCount == 0)
04805 {
04806 elemSz = 32+(3+0)*
sizeof(
SINT16);
04807 }
else
04808 {
04809 err =
cmparamErr;
04810
goto CleanUp;
04811 }
04812 elemSz/=2;
04813
04814
04815
for (i=0; i < (
UINT32)pixCnt; i++)
04816 {
04817
04818 dEnow = 0x40000;
04819 index = (
UINT32)-1;
04820 colorPtr = tagTbl;
04821
for (j=0; j < (
UINT32)count; j++)
04822 {
04823 dE =
POS((
long)theData->
Lab.
a - *(colorPtr+1));
04824 dE = dE +
POS((
long)theData->
Lab.
b - *(colorPtr+2));
04825 dE = 2*dE + (dE>>1) +
POS((
long)theData->
Lab.
L - *(colorPtr));
04826
if (dE < dEnow)
04827 {
04828 index = j;
04829 dEnow = dE;
04830 }
04831 colorPtr += elemSz;
04832 }
04833 theData->
namedColor.
namedColorIndex = index+1;
04834 theData++;
04835 }
04836
UNLOCK_DATA(tagH);
04837 }
04838 CleanUp:
04839
LH_END_PROC(
"ConvertPCSToNamedIndex")
04840
return err;
04841 }
04842
04843
04844
04845
04846
04847
04848
CMError CMConvertNamedIndexToColors( CMWorldRef cw,
CMColor *theData,
unsigned long pixCnt );
04849
CMError CMConvertNamedIndexToColors( CMWorldRef cw,
CMColor *theData,
unsigned long pixCnt )
04850 {
04851
return ConvertNamedIndexToColors( (CMMModelPtr)cw, theData, (SINT32)pixCnt );
04852 }
04853
04854
04855
04856
04857
04858
CMError CMConvertNamedIndexToPCS( CMWorldRef cw,
CMColor *theData,
unsigned long pixCnt );
04859
CMError CMConvertNamedIndexToPCS( CMWorldRef cw,
CMColor *theData,
unsigned long pixCnt )
04860 {
04861
return ConvertNamedIndexToPCS( (CMMModelPtr)cw, theData, (SINT32)pixCnt );
04862 }
04863 CMError ConvertLabToIndexBitmap( CMMModelPtr modelingData,
04864 Ptr InBuffer,
04865 UINT32 processedLinesIn,
04866 UINT32 inLineCount,
04867 UINT32 width,
04868 UINT32 rowBytes )
04869 {
04870
OSErr err =
noErr;
04871
LUT_DATA_TYPE tagH=
NULL;
04872
UINT16 *tagTbl =
NULL,*colorPtr =
NULL;
04873
int deviceChannelCount,elemSz,count;
04874
UINT32 i,j,k,index,dE,dEnow;
04875
UINT16 LL,aa,bb;
04876
UINT8 *imgIn=
NULL,*imgOut=
NULL;
04877
UINT32 *imgInPtr=
NULL;
04878
UINT8 *imgInPtr8=
NULL;
04879
UINT8 *imgOutPtr8=
NULL;
04880
04881
LH_START_PROC(
"ConvertLabToIndexBitmap")
04882
04883 tagH = modelingData->theNamedColorTagData;
04884
if (tagH==
NULL){
04885 err =
cmparamErr;
04886
goto CleanUp;
04887 }
04888
LOCK_DATA(tagH);
04889 tagTbl = (
UINT16 *)
DATA_2_PTR(tagH) + 58;
04890 count = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.count;
04891 deviceChannelCount = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.nDeviceCoords;
04892
if (deviceChannelCount == 3){
04893 elemSz = 32+(3+3)*
sizeof(
SINT16);
04894 }
04895
else if (deviceChannelCount == 4){
04896 elemSz = 32+(3+4)*
sizeof(
SINT16);
04897 }
04898
else if (deviceChannelCount == 0){
04899 elemSz = 32+(3+0)*
sizeof(
SINT16);
04900 }
04901
else{
04902 err =
cmparamErr;
04903
goto CleanUp;
04904 }
04905 elemSz /= 2;
04906
04907
04908 imgIn = (
UINT8*)InBuffer + processedLinesIn * rowBytes;
04909 imgInPtr8=((
UINT8 *)imgIn);
04910 LL = *(imgInPtr8+0)+1;
04911
for (i = 0; i < inLineCount; i++){
04912
for (j = 0; j < width; j++){
04913 imgInPtr8=((
UINT8 *)imgIn+j*4);
04914
if( LL == *(imgInPtr8+0) ){
04915
if( aa == *(imgInPtr8+1) && bb == *(imgInPtr8+2) ){
04916 *((
UINT32 *)imgIn+j) = index+1;
04917
continue;
04918 }
04919 }
04920 LL = *(imgInPtr8+0);
04921 aa = *(imgInPtr8+1);
04922 bb = *(imgInPtr8+2);
04923
04924 dEnow = 0x40000;
04925 index =(
UINT32)-1;
04926 colorPtr = tagTbl;
04927
for (k = 0; k < (
UINT32)count; k++){
04928 dE =
POS((
long)aa - (*(colorPtr+1)>>8));
04929 dE = dE +
POS((
long)bb - (*(colorPtr+2)>>8));
04930 dE = 2*dE + (dE>>1) +
POS((
long)LL - (*(colorPtr)>>8));
04931
if (dE < dEnow){
04932 index = k;
04933 dEnow = dE;
04934 }
04935 colorPtr += elemSz;
04936 }
04937 *((
UINT32 *)imgIn+j) = index+1;
04938 }
04939 imgIn+=rowBytes;
04940 }
04941 CleanUp:
04942
UNLOCK_DATA(tagH);
04943
LH_END_PROC(
"ConvertLabToIndexBitmap")
04944
return err;
04945 }
04946 CMError ConvertIndexToLabBitmap( CMMModelPtr modelingData,
04947 Ptr InBuffer,
04948 Ptr OutBuffer,
04949 UINT32 processedLinesIn,
04950 UINT32 lineCount,
04951 UINT32 inWidth,
04952 UINT32 inRowBytes,
04953 UINT32 outRowBytes,
04954 UINT32 outputSize )
04955 {
04956
OSErr err =
noErr;
04957
LUT_DATA_TYPE tagH=
NULL;
04958
UINT16 *tagTbl =
NULL,*ColorPtr =
NULL;
04959
UINT32 *imgIn=
NULL;
04960
UINT8 *imgOut=
NULL;
04961
int deviceChannelCount,elemSz;
04962
UINT32 i,j,index,countNamesInProfile;
04963
04964
LH_START_PROC(
"ConvertIndexToLabBitmap")
04965
04966 tagH = modelingData->theNamedColorTagData;
04967
if (tagH==
NULL) {
04968 err =
cmparamErr;
04969
goto CleanUp;
04970 }
04971
04972
LOCK_DATA(tagH);
04973 tagTbl = (
UINT16 *)
DATA_2_PTR(tagH) + 58;
04974 deviceChannelCount = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.nDeviceCoords;
04975 countNamesInProfile = ((
icNamedColor2Type *)
DATA_2_PTR(tagH))->ncolor.count;
04976
if (deviceChannelCount==3) {
04977 elemSz = 32+(3+3)*
sizeof(
UINT16);
04978 }
else if (deviceChannelCount==4) {
04979 elemSz = 32+(3+4)*
sizeof(
UINT16);
04980 }
else if (deviceChannelCount==0) {
04981 elemSz = 32+(3+0)*
sizeof(
UINT16);
04982 }
else {
04983 err =
cmparamErr;
04984
goto CleanUp;
04985 }
04986 elemSz/=2;
04987
04988
04989
for( i=processedLinesIn; i<processedLinesIn+lineCount; i++ ){
04990 imgIn = (
UINT32 *)(InBuffer + i * inRowBytes);
04991 imgOut = (
UINT8*)OutBuffer + (i-processedLinesIn) * outRowBytes;
04992
if( outputSize == 24 ){
04993
for (j=0;j<inWidth;j++) {
04994 index = *imgIn++;
04995
if( index == 0 || index > countNamesInProfile ){
04996 err =
cmNamedColorNotFound;
04997
goto CleanUp;
04998 }
04999
05000 ColorPtr = tagTbl + (index-1)*elemSz;
05001 *imgOut++ = (*ColorPtr++)>>8;
05002 *imgOut++ = (*ColorPtr++)>>8;
05003 *imgOut++ = (*ColorPtr++)>>8;
05004 }
05005 }
05006
else if( outputSize == 32 ){
05007
for (j=0;j<inWidth;j++) {
05008 index = *imgIn++;
05009
if( index == 0 || index > countNamesInProfile ){
05010 err =
cmNamedColorNotFound;
05011
goto CleanUp;
05012 }
05013
05014 ColorPtr = tagTbl + (index-1)*elemSz;
05015 *imgOut++ = (*ColorPtr++)>>8;
05016 *imgOut++ = (*ColorPtr++)>>8;
05017 *imgOut = (*ColorPtr++)>>8;
05018 imgOut += 2;
05019 }
05020 }
05021 }
05022 CleanUp:
05023
UNLOCK_DATA(tagH);
05024
LH_END_PROC(
"ConvertIndexToLabBitmap")
05025
return err;
05026 }
05027
05028
#include <string.h>
05029
CMError CMConvNameToIndex(
icNamedColor2Type *Data, pcCMColorName Ptr2Name,
unsigned long *Arr2Indices,
unsigned long count );
05030
CMError CMConvNameToIndex(
icNamedColor2Type *Data, pcCMColorName Ptr2Name,
unsigned long *Arr2Indices,
unsigned long count )
05031 {
05032
OSErr err =
noErr;
05033
UINT32 i,index,l,len;
05034
char *colorPtr=
NULL;
05035
long elemSz,deviceChannelCount,countNamesInProfile;
05036
const char *aPtr;
05037
Ptr tagTbl;
05038
05039
LH_START_PROC(
"CMConvNameToIndex")
05040
05041 if( Data == 0 || count == 0 )return cmparamErr;
05042
05043 tagTbl = &Data->ncolor.data[0];
05044
05045 countNamesInProfile = Data->ncolor.count;
05046 deviceChannelCount = Data->ncolor.nDeviceCoords;
05047 if (deviceChannelCount==3){
05048 elemSz = 32+(3+3)*
sizeof(
SINT16);
05049 }
05050
else if (deviceChannelCount == 4){
05051 elemSz = 32+(3+4)*
sizeof(
SINT16);
05052 }
05053
else if (deviceChannelCount == 0){
05054 elemSz = 32+(3+0)*
sizeof(
SINT16);
05055 }
05056
else{
05057 err =
cmparamErr;
05058
goto CleanUp;
05059 }
05060
05061
for (i=0; i<(
UINT32)count; i++){
05062 colorPtr = tagTbl;
05063 len =
strlen( Ptr2Name[i] );
05064 aPtr = Ptr2Name[i];
05065
for( index = 0; index < (
UINT32)countNamesInProfile; index++ ){
05066
for( l = 0; l<len; l++ ){
05067
if( colorPtr[l] != aPtr[l] )
break;
05068
if( colorPtr[l] == 0 )
break;
05069 }
05070
if( l >= len )
break;
05071 colorPtr += elemSz;
05072 }
05073
if( l < len )index = 0;
05074
else index++;
05075
05076
05077
if( index == 0 ){
05078 err =
cmNamedColorNotFound;
05079
goto CleanUp;
05080 }
05081 Arr2Indices[i] = index;
05082 }
05083 CleanUp:
05084
LH_END_PROC(
"CMConvNameToIndex")
05085 return err;
05086 }
05087
05088 CMError CMConvNameToIndexCW( CMWorldRef *Storage, pcCMColorName Ptr2Name,
unsigned long *Arr2Indices,
unsigned long count);
05089 CMError CMConvNameToIndexCW( CMWorldRef *Storage, pcCMColorName Ptr2Name,
unsigned long *Arr2Indices,
unsigned long count)
05090 {
05091
Ptr tagTbl =
NULL;
05092
LUT_DATA_TYPE tagH =
NULL;
05093
CMError err =
noErr;
05094
char *colorPtr=
NULL;
05095
CMMModelPtr modelingData;
05096
icNamedColor2Type *namedData;
05097
05098
LH_START_PROC(
"CMConvNameToIndexCW")
05099
05100 if( Storage == 0 )return cmparamErr;
05101 LOCK_DATA( Storage );
05102 modelingData = (CMMModelPtr)(DATA_2_PTR( Storage ));
05103 if ( modelingData->hasNamedColorProf!=NoNamedColorProfile)
05104 {
05105
05106 tagH = modelingData->theNamedColorTagData;
05107
if (tagH==
NULL){
05108 err =
cmparamErr;
05109
goto CleanUp;
05110 }
05111
LOCK_DATA(tagH);
05112
05113 namedData = (
icNamedColor2Type *)
DATA_2_PTR(tagH);
05114 err =
CMConvNameToIndex( namedData, Ptr2Name, Arr2Indices, count );
05115
UNLOCK_DATA(tagH);
05116 }
05117 CleanUp:
05118
UNLOCK_DATA( Storage );
05119
LH_END_PROC(
"CMConvNameToIndexCW")
05120 return err;
05121 }
05122 CMError CMConvNameToIndexProfile( CMProfileRef aProf, pcCMColorName Ptr2Name,
unsigned long *Arr2Indices,
unsigned long count);
05123 CMError CMConvNameToIndexProfile( CMProfileRef aProf, pcCMColorName Ptr2Name,
unsigned long *Arr2Indices,
unsigned long count)
05124 {
05125
CMError err;
05126
short aOSerr;
05127
icNamedColor2Type *aName = 0;
05128
unsigned long byteCount;
05129
05130
LH_START_PROC(
"CMConvNameToIndexProfile")
05131
05132 if( aProf == 0 )return cmparamErr;
05133 err = CMGetPartialProfileElement( aProf,
05134 icSigNamedColor2Tag,
05135 0,
05136 &byteCount,
05137 0 );
05138 if (err)
05139 goto CleanupAndExit;
05140 aName = (
icNamedColor2Type *)SmartNewPtr( byteCount, &aOSerr );
05141 err = aOSerr;
05142 if (err)
05143 goto CleanupAndExit;
05144 err = CMGetPartialProfileElement( aProf,
05145 icSigNamedColor2Tag,
05146 0,
05147 &byteCount,
05148 (Ptr)aName );
05149 if (err){
05150
goto CleanupAndExit;
05151 }
05152
05153
#ifdef IntelMode
05154
SwapLongOffset( &aName->
ncolor.
count, 0, 4 );
05155 SwapLongOffset( &aName->
ncolor.
nDeviceCoords, 0, 4 );
05156
#endif
05157
err =
CMConvNameToIndex( aName, Ptr2Name, Arr2Indices, count );
05158
05159 CleanupAndExit:
05160
DisposeIfPtr( (Ptr)aName );
05161
LH_END_PROC(
"CMConvNameToIndexProfile")
05162 return err;
05163 }
05164
05165 CMError CMConvIndexToName(
icNamedColor2Type *Data,
unsigned long *Arr2Indices, pCMColorName Ptr2Name,
unsigned long count);
05166 CMError CMConvIndexToName(
icNamedColor2Type *Data,
unsigned long *Arr2Indices, pCMColorName Ptr2Name,
unsigned long count)
05167 {
05168
Ptr tagTbl =
NULL;
05169
OSErr err =
noErr;
05170
UINT32 i,index;
05171
char *colorPtr=
NULL;
05172
long elemSz,deviceChannelCount,countNamesInProfile;
05173
05174
LH_START_PROC(
"CMConvIndexToName")
05175
05176 if( Data == 0 || count == 0 )return cmparamErr;
05177 tagTbl = &Data->ncolor.data[0];
05178
05179
05180 countNamesInProfile = Data->ncolor.count;
05181 deviceChannelCount = Data->ncolor.nDeviceCoords;
05182 if (deviceChannelCount==3){
05183 elemSz = 32+(3+3)*
sizeof(
SINT16);
05184 }
05185
else if (deviceChannelCount == 4){
05186 elemSz = 32+(3+4)*
sizeof(
SINT16);
05187 }
05188
else if (deviceChannelCount == 0){
05189 elemSz = 32+(3+0)*
sizeof(
SINT16);
05190 }
05191
else{
05192 err =
cmparamErr;
05193
goto CleanUp;
05194 }
05195
05196
05197
for (i=0; i<(
UINT32)count; i++){
05198
05199 index = Arr2Indices[i];
05200
if (index > (
UINT32)countNamesInProfile || index == 0 )
05201 {
05202 err =
cmNamedColorNotFound;
05203
goto CleanUp;
05204 }
05205 colorPtr = tagTbl + (index-1)*elemSz;
05206
05207 strcpy( Ptr2Name[i], colorPtr );
05208 }
05209
05210 CleanUp:
05211
LH_END_PROC(
"CMConvIndexToName")
05212 return err;
05213 }
05214
05215 CMError CMConvIndexToNameCW( CMWorldRef *Storage,
unsigned long *Arr2Indices, pCMColorName Ptr2Name,
unsigned long count);
05216 CMError CMConvIndexToNameCW( CMWorldRef *Storage,
unsigned long *Arr2Indices, pCMColorName Ptr2Name,
unsigned long count)
05217 {
05218
Ptr tagTbl =
NULL;
05219
LUT_DATA_TYPE tagH =
NULL;
05220
CMError err =
noErr;
05221
char *colorPtr=
NULL;
05222
CMMModelPtr modelingData;
05223
icNamedColor2Type *namedData;
05224
05225
LH_START_PROC(
"CMConvIndexToNameCW")
05226
05227 if( Storage == 0 )return cmparamErr;
05228 LOCK_DATA( Storage );
05229 modelingData = (CMMModelPtr)(DATA_2_PTR( Storage ));
05230 if ( modelingData->hasNamedColorProf!=NoNamedColorProfile)
05231 {
05232
05233 tagH = modelingData->theNamedColorTagData ;
05234
if (tagH==
NULL){
05235 err =
cmparamErr;
05236
goto CleanUp;
05237 }
05238
LOCK_DATA(tagH);
05239
05240 namedData = (
icNamedColor2Type *)
DATA_2_PTR(tagH);
05241 err =
CMConvIndexToName( namedData, Arr2Indices, Ptr2Name, count );
05242
UNLOCK_DATA(tagH);
05243 }
05244 CleanUp:
05245
UNLOCK_DATA( Storage );
05246
LH_END_PROC(
"CMConvIndexToNameCW")
05247 return err;
05248 }
05249 CMError CMConvIndexToNameProfile( CMProfileRef aProf,
unsigned long *Arr2Indices, pCMColorName Ptr2Name,
unsigned long count);
05250 CMError CMConvIndexToNameProfile( CMProfileRef aProf,
unsigned long *Arr2Indices, pCMColorName Ptr2Name,
unsigned long count)
05251 {
05252
CMError err;
05253
short aOSerr;
05254
icNamedColor2Type *aName = 0;
05255
unsigned long byteCount;
05256
05257
LH_START_PROC(
"CMConvIndexToNameProfile")
05258
05259 if( aProf == 0 )return cmparamErr;
05260 err = CMGetPartialProfileElement( aProf,
05261 icSigNamedColor2Tag,
05262 0,
05263 &byteCount,
05264 0 );
05265 if (err)
05266 goto CleanupAndExit;
05267 aName = (
icNamedColor2Type *)SmartNewPtr( byteCount, &aOSerr );
05268 err = aOSerr;
05269 if (err)
05270 goto CleanupAndExit;
05271 err = CMGetPartialProfileElement( aProf,
05272 icSigNamedColor2Tag,
05273 0,
05274 &byteCount,
05275 (Ptr)aName );
05276 if (err){
05277
goto CleanupAndExit;
05278 }
05279
05280
#ifdef IntelMode
05281
SwapLongOffset( &aName->
ncolor.
count, 0, 4 );
05282 SwapLongOffset( &aName->
ncolor.
nDeviceCoords, 0, 4 );
05283
#endif
05284
err =
CMConvIndexToName( aName, Arr2Indices, Ptr2Name, count );
05285
05286 CleanupAndExit:
05287
DisposeIfPtr( (Ptr)aName );
05288
LH_END_PROC(
"CMConvIndexToNameProfile")
05289 return err;
05290 }
05291
05292 CMError CMGetNamedProfileInfoProfile( CMProfileRef aProf,
pCMNamedProfileInfo Info );
05293 CMError CMGetNamedProfileInfoProfile( CMProfileRef aProf,
pCMNamedProfileInfo Info )
05294 {
05295
CMError err =
noErr;
05296
Ptr tagTbl;
05297
short aOSerr;
05298
icNamedColor2Type *aName = 0;
05299
unsigned long byteCount;
05300
05301
LH_START_PROC(
"CMGetNamedProfileInfoProfile")
05302
05303 if( aProf == 0 )return cmparamErr;
05304 err = CMGetPartialProfileElement( aProf,
05305 icSigNamedColor2Tag,
05306 0,
05307 &byteCount,
05308 0 );
05309 if (err)
05310 goto CleanupAndExit;
05311 aName = (
icNamedColor2Type *)SmartNewPtr( byteCount, &aOSerr );
05312 err = aOSerr;
05313 if (err)
05314 goto CleanupAndExit;
05315 err = CMGetPartialProfileElement( aProf,
05316 icSigNamedColor2Tag,
05317 0,
05318 &byteCount,
05319 (Ptr)aName );
05320 if (err){
05321
goto CleanupAndExit;
05322 }
05323
05324
05325
05326 tagTbl = (
Ptr)aName + 8;
05327
05328
#ifdef IntelMode
05329
SwapLongOffset( &aName->
ncolor.
count, 0, 4 );
05330 SwapLongOffset( &aName->
ncolor.
nDeviceCoords, 0, 4 );
05331 SwapLongOffset( &aName->
ncolor.
vendorFlag, 0, 4 );
05332
#endif
05333
memcpy( Info, tagTbl,
sizeof(
CMNamedProfileInfo ));
05334 CleanupAndExit:
05335
LH_END_PROC(
"CMGetNamedProfileInfoProfile")
05336 return err;
05337 }
05338 CMError CMGetNamedProfileInfoCW( CMWorldRef *Storage,
pCMNamedProfileInfo Info );
05339 CMError CMGetNamedProfileInfoCW( CMWorldRef *Storage,
pCMNamedProfileInfo Info )
05340 {
05341
LUT_DATA_TYPE tagH =
NULL;
05342
OSErr err =
noErr;
05343
CMMModelPtr modelingData;
05344
Ptr tagTbl;
05345
05346
LH_START_PROC(
"CMGetNamedProfileInfoCW")
05347
05348 if( Storage == 0 )return cmparamErr;
05349 LOCK_DATA( Storage );
05350 modelingData = (CMMModelPtr)(DATA_2_PTR( Storage ));
05351 if( modelingData->hasNamedColorProf != NoNamedColorProfile ){
05352
05353 tagH = modelingData->theNamedColorTagData;
05354
if (tagH==
NULL){
05355 err =
cmparamErr;
05356
goto CleanUp;
05357 }
05358
LOCK_DATA(tagH);
05359
05360
05361
05362 tagTbl = (
Ptr)
DATA_2_PTR(tagH) + 8;
05363
05364 memcpy( Info, tagTbl,
sizeof(
CMNamedProfileInfo ));
05365
UNLOCK_DATA(tagH);
05366 }
05367 CleanUp:
05368
UNLOCK_DATA( Storage );
05369
LH_END_PROC(
"CMGetNamedProfileInfoCW")
05370 return err;
05371 }