test: memlink.c Source File

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

# memlink.c

Go to the documentation of this file.

    00001 /*
    00002         File:           MemLink.c
    00003
    00004         Contains:
    00005                 creation of mem based profiles
    00006
    00007         Written by:     U. J. Krabbenhoeft
    00008
    00009         Copyright:      © 1993-1997 by Heidelberger Druckmaschinen AG, all rights reserved.
    00010
    00011         Version:
    00012 */
    00013
    00014 #ifndef LHGeneralIncs_h
    00015 #include "General.h"
    00016 #endif
    00017
    00018 #if __IS_MSDOS
    00019 #include <wtypes.h>
    00020 #include <winbase.h>
    00021 #include <windowsX.h>
    00022 #ifdef RenderInt
    00023 #include "Windef.h"
    00024 #endif
    00025 #endif
    00026
    00027 #ifndef MemLink_h
    00028 #include "MemLink.h"
    00029 #endif
    00030
    00031 #if !__IS_MSDOS && !__IS_MAC
    00032 #include <time.h>
    00033 #endif
    00034
    00035 #ifdef DEBUG_OUTPUT
    00036 #define kThisFile kLHCMRuntimeID
    00037 #endif
    00038
    00039
    00040 #ifndef IntelMode
    00041 #define CMHelperICC2int16Const(a, b)                                                                                                                            \
    00042                   (*((UINT16 *)(a))) = (UINT16)(b);
    00043 #define CMHelperICC2int32Const(a, b)                                                                                                                            \
    00044                   (*((UINT32 *)(a))) = (UINT32)(b);
    00045 #else
    00046 #define CMHelperICC2int16Const(a, b)                                                                                                                            \
    00047                   (*((UINT16 *)(a))) = (((UINT16)(b)>>8)         | ((UINT16)((UINT8 )(b)) << 8));
    00048 #define CMHelperICC2int32Const(a, b)                                                                                                                            \
    00049                   (*((UINT32 *)(a))) = (((UINT32)(b)>>24)         | ((UINT32)(0x0ff0000&(UINT32)(b)) >> 8) | \
    00050                         ((UINT32)(0x0ff00&(UINT32)(b)) << 8) | ((UINT32)(0x0ff&(UINT32)(b)) << 24));
    00051 #endif
    00052
    00053 CMError MyAdd_NL_Header( UINT32 theSize, icHeader       *linkHeader,
    00054                                                  UINT32 aIntent, UINT32 aClass, UINT32 aColorSpace, UINT32 aConnectionSpace )
    00055 {
    00056         OSErr                                   err = noErr;
    00057 #if ! __IS_MSDOS
    00058         unsigned long                   secs;
    00059 #endif
    00060         DateTimeRec                             datetimeRec;
    00061         /*icHeader      linkHeader; */
    00062
    00063 #if __IS_MSDOS
    00064         SYSTEMTIME aSystemTime;
    00065         GetLocalTime( (SYSTEMTIME *)&aSystemTime);
    00066         datetimeRec.year         = aSystemTime.wYear;   datetimeRec.month        = aSystemTime.wMonth;
    00067         datetimeRec.day          = aSystemTime.wDay;    datetimeRec.hour         = aSystemTime.wHour;
    00068         datetimeRec.minute       = aSystemTime.wMinute; datetimeRec.second       = aSystemTime.wSecond;
    00069 #else
    00070 #if __IS_MAC
    00071         GetDateTime(&secs);
    00072         SecondsToDate(secs, &datetimeRec);/* Secs2Date  (link.*)=(.*); CMHelperICC2int32(\&(\1),\2); */
    00073 #else
    00074     struct tm* loctime;
    00075     time_t long_time;
    00076     time( &long_time );                /* Get time as long integer. */
    00077         loctime = localtime(&long_time);
    00078         datetimeRec.year         = loctime->tm_year;    datetimeRec.month       = loctime->tm_mon+1;
    00079         datetimeRec.day          = loctime->tm_mday;    datetimeRec.hour        = loctime->tm_hour;
    00080         datetimeRec.minute       = loctime->tm_min;             datetimeRec.second      = loctime->tm_sec;
    00081 #endif
    00082 #endif
    00083
    00084         CMHelperICC2int32Const(&(linkHeader->size                               ), theSize);            /* This is the total size of the CMProfileRef */
    00085         CMHelperICC2int32Const(&(linkHeader->cmmId                              ), 'Win ');                                                     /* CMM signature,  Registered with ICC consortium  */
    00086         CMHelperICC2int32Const(&(linkHeader->version                    ), icVersionNumber);                            /* Version of CMProfile format */
    00087         CMHelperICC2int32Const(&(linkHeader->deviceClass                ), aClass);                                     /* input, display, output, devicelink, abstract, or color conversion profile type */
    00088
    00089         CMHelperICC2int32Const(&(linkHeader->colorSpace                 ), aColorSpace);        /* color space of data = dataColorSpace of first profile*/
    00090
    00091         CMHelperICC2int32Const(&(linkHeader->pcs                                ), aConnectionSpace);   /* profile connection color space = dataColorSpace of last profile*/
    00092
    00093         CMHelperICC2int16(&(linkHeader->date.year                               ), &datetimeRec.year);                                  /* date and time of profile creation */
    00094         CMHelperICC2int16(&(linkHeader->date.month                              ), &datetimeRec.month);
    00095         CMHelperICC2int16(&(linkHeader->date.day                                ), &datetimeRec.day);
    00096         CMHelperICC2int16(&(linkHeader->date.hours                              ), &datetimeRec.hour);
    00097         CMHelperICC2int16(&(linkHeader->date.minutes                    ), &datetimeRec.minute);
    00098         CMHelperICC2int16(&(linkHeader->date.seconds                    ), &datetimeRec.second);
    00099         CMHelperICC2int32Const(&(linkHeader->magic                              ), icMagicNumber);                                      /* 'acsp' constant ICC file ID */
    00100         CMHelperICC2int32Const(&(linkHeader->platform                   ), icSigMicrosoft);                                     /* primary profile platform, Registered with ICC consortium */
    00101         CMHelperICC2int32Const(&(linkHeader->flags                              ), 0);                                                          /* profile flags */
    00102         CMHelperICC2int32Const(&(linkHeader->manufacturer               ), icSigMicrosoft);                                                     /* Registered with ICC consortium */
    00103         CMHelperICC2int32Const(&(linkHeader->model                              ), 0);                                                          /* Registered with ICC consortium */
    00104         CMHelperICC2int32Const(&(linkHeader->attributes[0]              ), 0);                                                          /* Attributes like paper type */
    00105         CMHelperICC2int32Const(&(linkHeader->attributes[1]              ), 0);
    00106         CMHelperICC2int32Const(&(linkHeader->renderingIntent    ), aIntent );                                                           /* preferred rendering intent of tagged object */
    00107         CMHelperICC2int32Const(&(linkHeader->illuminant.X               ), 0.9642 * 65536);                                     /* profile illuminant */
    00108         CMHelperICC2int32Const(&(linkHeader->illuminant.Y               ), 1.0000 * 65536);
    00109         CMHelperICC2int32Const(&(linkHeader->illuminant.Z               ), 0.8249 * 65536);
    00110         CMHelperICC2int32Const(&(linkHeader->creator                    ), 'UJK ');
    00111
    00112         return err;
    00113 }
    00114
    00115 CMError MyAdd_NL_HeaderMS       ( UINT32 theSize, icHeader      *linkHeader, unsigned long aIntent, icColorSpaceSignature sCS, icColorSpaceSignature dCS );
    00116 CMError MyAdd_NL_HeaderMS       ( UINT32 theSize, icHeader      *linkHeader, unsigned long aIntent, icColorSpaceSignature sCS, icColorSpaceSignature dCS )
    00117 {
    00118         OSErr                                   err = noErr;
    00119 #if ! __IS_MSDOS
    00120         unsigned long                   secs;
    00121 #endif
    00122         DateTimeRec                             datetimeRec;
    00123         /*icHeader      linkHeader; */
    00124
    00125 #if __IS_MSDOS
    00126         SYSTEMTIME aSystemTime;
    00127         GetLocalTime( (SYSTEMTIME *)&aSystemTime);
    00128         datetimeRec.year         = aSystemTime.wYear;   datetimeRec.month        = aSystemTime.wMonth;
    00129         datetimeRec.day          = aSystemTime.wDay;    datetimeRec.hour         = aSystemTime.wHour;
    00130         datetimeRec.minute       = aSystemTime.wMinute; datetimeRec.second       = aSystemTime.wSecond;
    00131 #else
    00132 #if __IS_MAC
    00133         GetDateTime(&secs);
    00134         SecondsToDate(secs, &datetimeRec);/* Secs2Date  (link.*)=(.*); CMHelperICC2int32(\&(\1),\2); */
    00135 #else
    00136     struct tm* loctime;
    00137     time_t long_time;
    00138     time( &long_time );                /* Get time as long integer. */
    00139         loctime = localtime(&long_time);
    00140         datetimeRec.year         = loctime->tm_year;    datetimeRec.month       = loctime->tm_mon+1;
    00141         datetimeRec.day          = loctime->tm_mday;    datetimeRec.hour        = loctime->tm_hour;
    00142         datetimeRec.minute       = loctime->tm_min;             datetimeRec.second      = loctime->tm_sec;
    00143 #endif
    00144 #endif
    00145
    00146
    00147         linkHeader->size                                = theSize;              /* This is the total size of the CMProfileRef */
    00148         linkHeader->cmmId                               = 'Win ';                                                       /* CMM signature,  Registered with ICC consortium  */
    00149         linkHeader->version                     = icVersionNumber;                              /* Version of CMProfile format */
    00150         linkHeader->deviceClass                 = icSigLinkClass;                                       /* input, display, output, devicelink, abstract, or color conversion profile type */
    00151
    00152         linkHeader->colorSpace                  = sCS;  /* color space of data = dataColorSpace of first profile*/
    00153
    00154         linkHeader->pcs                                 = dCS;  /* profile connection color space = dataColorSpace of last profile*/
    00155
    00156         linkHeader->date.year                   = datetimeRec.year;                                     /* date and time of profile creation */
    00157         linkHeader->date.month                  = datetimeRec.month;
    00158         linkHeader->date.day                    = datetimeRec.day;
    00159         linkHeader->date.hours                  = datetimeRec.hour;
    00160         linkHeader->date.minutes                = datetimeRec.minute;
    00161         linkHeader->date.seconds                = datetimeRec.second;
    00162         linkHeader->magic                               = icMagicNumber;                                        /* 'acsp' constant ICC file ID */
    00163         linkHeader->platform                    = icSigMicrosoft;                                       /* primary profile platform, Registered with ICC consortium */
    00164         linkHeader->flags                               = 0;                                                            /* profile flags */
    00165         linkHeader->manufacturer                = icSigMicrosoft;                                                       /* Registered with ICC consortium */
    00166         linkHeader->model                               = 0;                                                            /* Registered with ICC consortium */
    00167         linkHeader->attributes[0]               = 0;                                                            /* Attributes like paper type */
    00168         linkHeader->attributes[1]               = 0;
    00169         linkHeader->renderingIntent             = aIntent ;                                                             /* preferred rendering intent of tagged object */
    00170         linkHeader->illuminant.X                = (long)(0.9642 * 65536);                                       /* profile illuminant */
    00171         linkHeader->illuminant.Y                = (long)(1.0000 * 65536);
    00172         linkHeader->illuminant.Z                = (long)(0.8249 * 65536);
    00173         linkHeader->creator                             = 'UJK ';
    00174
    00175         return err;
    00176 }
    00177
    00178 CMError MyAdd_NL_DescriptionTag ( LHTextDescriptionType *descPtr, unsigned char *theText )
    00179 {
    00180         Ptr                                             thePtr;
    00181         OSErr                                   err = noErr;
    00182
    00183         theText[theText[0]] = 0x00;
    00184
    00185         /*descPtr = (LHTextDescriptionType*)NewPtrClear( theSize );      */
    00186         if (descPtr == 0)
    00187                 return -1;
    00188
    00189         /*------------------------------------------------------------------------ ASCII */
    00190         CMHelperICC2int32Const(&(descPtr->typeDescriptor ), icSigTextDescriptionType);
    00191         CMHelperICC2int32Const(&(descPtr->reserved ), 0);
    00192         CMHelperICC2int32Const(&(descPtr->ASCIICount     ), (long)theText[0]);
    00193         thePtr = (Ptr) &descPtr->ASCIIName[0];
    00194         BlockMove(&theText[1], thePtr, theText[0]);
    00195         thePtr += theText[0];
    00196
    00197         /*------------------------------------------------------------------------ Unicode */
    00199         /*thePtr+=sizeof(unsigned long); */
    00200         *thePtr++ = 0;
    00201         *thePtr++ = 0;
    00202         *thePtr++ = 0;
    00203         *thePtr++ = 0;
    00205         /*thePtr+=sizeof(unsigned long); */
    00206         *thePtr++ = 0;
    00207         *thePtr++ = 0;
    00208         *thePtr++ = 0;
    00209         *thePtr++ = 0;
    00210         /*BlockMove(&theText[1], thePtr, theText[0]);           //Unicode string  */
    00211         /*thePtr += theText[0]; */
    00212
    00213         /*------------------------------------------------------------------------ Macintosh */
    00216         *thePtr++ = 0;
    00217         *thePtr++ = 0;
    00218         BlockMove(&theText[0], thePtr, theText[0]+1);
    00219         return err;
    00220 }
    00221
    00222 CMError MyAdd_NL_ColorantTag    ( icXYZType *descPtr, MyXYZNumber *aColor )
    00223 {
    00224         OSErr                                   err = noErr;
    00225
    00226         CMHelperICC2int32Const(&(descPtr->base ), icSigXYZType);
    00227         CMHelperICC2int32Const((OSType*)&(descPtr->base )+1, 0);
    00228         CMHelperICC2int32(&(descPtr->data.data[0].X      ), &aColor->X);
    00229         CMHelperICC2int32(&(descPtr->data.data[0].Y      ), &aColor->Y);
    00230         CMHelperICC2int32(&(descPtr->data.data[0].Z      ), &aColor->Z);
    00231         return err;
    00232 }
    00233
    00234 CMError MyAdd_NL_CurveTag       ( icCurveType *descPtr, unsigned short Gamma )
    00235 {
    00236         OSErr                                   err = noErr;
    00237
    00238         CMHelperICC2int32Const(&(descPtr->base ), icSigCurveType);
    00239         CMHelperICC2int32Const((OSType*)&(descPtr->base )+1, 0);
    00240         CMHelperICC2int32Const(&(descPtr->curve.count ), 1);
    00241         CMHelperICC2int16(&(descPtr->curve.data[0] ), &Gamma );
    00242         return err;
    00243 }
    00244
    00245 CMError MyAdd_NL_CopyrightTag           ( unsigned char *copyrightText, LHTextType *aLHTextType )
    00246 {
    00247     OSErr                       err=noErr;
    00248
    00249     copyrightText[copyrightText[0]] = 0x00;
    00250     CMHelperICC2int32Const(&(aLHTextType->base ), icSigTextType);
    00251         CMHelperICC2int32Const((OSType*)&(aLHTextType->base )+1, 0);
    00252     BlockMove(&copyrightText[1], &aLHTextType->text[0], copyrightText[0]);
    00253
    00254 #ifdef DEBUG_OUTPUT
    00255     if ( err && DebugCheck(kThisFile, kDebugErrorInfo) )
    00256         DebugPrint("¥ MyAdd_NL_CopyrightTag-Error: result = %d\n",err);
    00257 #endif
    00258     return err;
    00259 }
    00260
    00261 /* ______________________________________________________________________
    00262     CMError
    00263     Fill_mft1_InputTable        ( Ptr                           theElut,
    00264                               icLut8*           lutPtr,
    00265                               CMMModelPtr       modelData)
    00266
    00267     Abstract:
    00268         Fill mft1 inputTable with the data from the given E-Lut.
    00269
    00270     Params:
    00271         theElut         (in)            Reference to E-Lut.
    00272         tempLutPtr      (in/out)        Reference to icLut8.
    00273
    00274     Return:
    00275         noErr           successful
    00276         System or result code if an error occurs.
    00277    _____________________________________________________________________ */
    00278 CMError Fill_mft1_InputTable(   Ptr                     theElut,
    00279                                         icLut8*         lutPtr,
    00280                                         CMMModelPtr     modelData);
    00281 CMError Fill_mft1_InputTable(   Ptr                     theElut,
    00282                                         icLut8*         lutPtr,
    00283                                         CMMModelPtr     modelData)
    00284 {
    00285     OSErr                       err = noErr;
    00286     long                        i;
    00287     long                        j;
    00288     unsigned long       factor;
    00289     unsigned long       round;
    00290     unsigned long       shift;
    00291     unsigned long       ulAux;
    00292     unsigned short      *wordElut = (unsigned short*)theElut;
    00293     unsigned long       newScale = 255;
    00294     unsigned long       oldScale = ((1U<< modelData->lutParam.inputLutWordSize) * (lutPtr->clutPoints-1)) / lutPtr->clutPoints;
    00295
    00296     if( modelData->currentCall == kCMMNewLinkProfile ){
    00297                 oldScale = 1<< modelData->lutParam.inputLutWordSize;
    00298         }
    00299         factor = (newScale << 24) / oldScale;
    00300     round  = (1<<(24-1))-1;
    00301     shift  = 24;
    00302
    00303     ulAux = ~( (1<< (32-modelData->lutParam.inputLutWordSize))-1);
    00304         while (factor & ulAux ) /* stay within 16 bits to prevent product overflow */
    00305     {
    00306         factor >>= 1;
    00307         round  >>= 1;
    00308         shift   -= 1;
    00309     }
    00310
    00311     for (i=0; i<(long)lutPtr->inputChan; i++)
    00312     {
    00313         for (j=0; j< 256; j++)
    00314         {
    00315             ulAux    = ((unsigned long)*wordElut * factor + round) >> shift;
    00316             lutPtr->data[i * 256 + j] = (UINT8)(ulAux );
    00317             wordElut++;
    00318         }
    00319     }
    00320     return err;
    00321 }
    00322
    00323 /* ______________________________________________________________________
    00324     CMError
    00325     Fill_mft1_OutputTable       ( Ptr                   theAlut,
    00326                               icLut8*   lutPtr,
    00327                               long                      offset,
    00328                               CMMModelPtr       modelData)
    00329
    00330     Abstract:
    00331         Fill mft1 outputTable with the data from the given A-Lut.
    00332
    00333     Params:
    00334         theAlut (in)            Reference to A-Lut.
    00335         lutPtr  (in/out)        Reference to icLut8.
    00336         offset  (in)            starting position for outputTable within icLut8
    00337
    00338     Return:
    00339         noErr           successful
    00340         System or  result code if an error occurs.
    00341    _____________________________________________________________________ */
    00342 CMError Fill_mft1_OutputTable(  Ptr                     theAlut,
    00343                                         icLut8*         lutPtr,
    00344                                         long            offset,
    00345                                         CMMModelPtr     modelData);
    00346 CMError Fill_mft1_OutputTable(  Ptr                     theAlut,
    00347                                         icLut8*         lutPtr,
    00348                                         long            offset,
    00349                                         CMMModelPtr     modelData)
    00350 {
    00351     OSErr       err = noErr;
    00352     long        i;
    00353     long        j;
    00354     UINT8*      byteAlut = (UINT8*)theAlut;
    00355     long        numOfAlutEntries = modelData->lutParam.outputLutEntryCount;
    00356
    00357     for (i=0; i<(long)lutPtr->outputChan; i++)
    00358     {
    00359         for (j=0; j<256; j++)
    00360         {
    00361             byteAlut = (UINT8*)theAlut + (j * (numOfAlutEntries-1)) / 255 ;
    00362             lutPtr->data[offset + i * 256 + j] = *byteAlut;
    00363         }
    00364                 theAlut +=  numOfAlutEntries;
    00365     }
    00366     return err;
    00367 }
    00368
    00369 /* ______________________________________________________________________
    00370     CMError
    00371     Fill_mft2_InputTable        ( Ptr                           theElut,
    00372                               icLut16*          lutPtr,
    00373                               CMMModelPtr       modelData)
    00374
    00375     Abstract:
    00376         Fill mft2 inputTable with the data from the given E-Lut.
    00377
    00378     Params:
    00379         theElut         (in)            Reference to E-Lut.
    00380         tempLutPtr      (in/out)        Reference to icLut8.
    00381
    00382     Return:
    00383         noErr           successful
    00384         System or  result code if an error occurs.
    00385    _____________________________________________________________________ */
    00386 CMError Fill_mft2_InputTable(   Ptr                             theElut,
    00387                                         icLut16*                lutPtr,
    00388                                         CMMModelPtr     modelData);
    00389 CMError Fill_mft2_InputTable(   Ptr                             theElut,
    00390                                         icLut16*                lutPtr,
    00391                                         CMMModelPtr     modelData)
    00392 {
    00393     OSErr                       err = noErr;
    00394     unsigned long       factor;
    00395     unsigned long       round;
    00396     unsigned long       shift;
    00397     unsigned long       ulAux;
    00398     long                        i;
    00399     long                        j;
    00400     UINT16*                     wordElut = (UINT16*)theElut;
    00401     UINT16*                     wordData = (UINT16*)lutPtr->data;
    00402     unsigned long       newScale = 65535;
    00403
    00404     unsigned long       oldScale = ( (1<<modelData->lutParam.inputLutWordSize) * (modelData->lutParam.colorLutGridPoints-1)) / modelData->lutParam.colorLutGridPoints;
    00405
    00406     if( modelData->currentCall == kCMMNewLinkProfile ){
    00407                 oldScale = 1<< modelData->lutParam.inputLutWordSize;
    00408         }
    00409         factor = (newScale << 15) / oldScale;
    00410     round  = (1<<(15-1))-1;
    00411     shift  = 15;
    00412
    00413     while (factor & 0xFFFF0000) /* stay within 16 bits to prevent product overflow */
    00414     {
    00415         factor >>= 1;
    00416         round  >>= 1;
    00417         shift   -= 1;
    00418     }
    00419
    00420      for (i=0; i<(long)lutPtr->inputChan; i++)
    00421     {
    00422         for (j=0; j< (long)lutPtr->inputEnt; j++)
    00423         {
    00424             ulAux    = ((unsigned long)*wordElut * factor + round) >> shift;
    00425                         CMHelperICC2int16Const( wordData, ulAux );
    00426                         wordData++;
    00427             wordElut++;
    00428         }
    00429     }
    00430     return err;
    00431 }
    00432 /* ______________________________________________________________________
    00433     CMError
    00434     Fill_mft2_OutputTable       ( Ptr                           theAlut,
    00435                               icLut16*          lutPtr,
    00436                               long                              offset,
    00437                               CMMModelPtr       modelData )
    00438
    00439     Abstract:
    00440         Fill mft2 outputTable with the data from the given A-Lut.
    00441
    00442     Params:
    00443         theAlut (in)            Reference to A-Lut.
    00444         lutPtr  (in/out)        Reference to icLut8.
    00445         offset  (in)            starting position for outputTable within CMLut8Type
    00446
    00447     Return:
    00448         noErr           successful
    00449         System or  result code if an error occurs.
    00450    _____________________________________________________________________ */
    00451 CMError Fill_mft2_OutputTable(  Ptr                     theAlut,
    00452                                         icLut16*        lutPtr,
    00453                                         long            offset,
    00454                                         CMMModelPtr     modelData );
    00455 CMError Fill_mft2_OutputTable(  Ptr                     theAlut,
    00456                                         icLut16*        lutPtr,
    00457                                         long            offset,
    00458                                         CMMModelPtr     modelData )
    00459 {
    00460     OSErr       err = noErr;
    00461     long        i;
    00462     long        j;
    00463     UINT16*     wordAlut = (UINT16*)theAlut;
    00464     UINT16*     wordData = (UINT16*)lutPtr->data + offset;
    00465
    00466     modelData = modelData;
    00467     for (i=0; i<(long)lutPtr->outputChan; i++)
    00468     {
    00469         for (j=0; j<(long)lutPtr->outputEnt; j++)
    00470         {
    00471             CMHelperICC2int16Const( wordData, *wordAlut );
    00472                         wordData++;
    00473             wordAlut++;
    00474         }
    00475     }
    00476     return err;
    00477 }
    00478
    00479 /* ______________________________________________________________________
    00480     CMError
    00481     Fill_mft2_ColorTable        ( Ptr                   theAlut,
    00482                               icLut16*          lutPtr,
    00483                               long                      offset,
    00484                               long                      count )
    00485
    00486     Abstract:
    00487         Fill mft2 outputTable with the data from the given A-Lut.
    00488
    00489     Params:
    00490         theAlut (in)            Reference to A-Lut.
    00491         lutPtr  (in/out)        Reference to icLut8.
    00492         offset  (in)            starting position for outputTable within CMLut8Type
    00493
    00494     Return:
    00495         noErr           successful
    00496         System or  result code if an error occurs.
    00497    _____________________________________________________________________ */
    00498 CMError Fill_mft2_ColorTable(   Ptr                     theClut,
    00499                                         icLut16*        lutPtr,
    00500                                         long            offset,
    00501                                         long            count );
    00502 CMError Fill_mft2_ColorTable(   Ptr                     theClut,
    00503                                         icLut16*        lutPtr,
    00504                                         long            offset,
    00505                                         long            count )
    00506 {
    00507     OSErr       err = noErr;
    00508     long        i;
    00509     UINT16*     wordClut = (UINT16*)theClut;
    00510     UINT16*     wordData = (UINT16*)lutPtr->data + offset;
    00511
    00512     for ( i=0; i<count; i++)
    00513     {
    00514         CMHelperICC2int16Const( wordData, *wordClut );
    00515                 wordData++;
    00516         wordClut++;
    00517     }
    00518     return err;
    00519 }
    00520
    00521 CMError MyAdd_NL_AToB0Tag_mft1( CMMModelPtr cw, icLut8Type *lutPtr, long colorLutSize )
    00522 {
    00523         CMError                 err;
    00524         icLut8                  *tempLutPtr;
    00525         long                    offset;
    00526         UINT16                  inputChannels;
    00527         UINT16                  outputChannels;
    00528         UINT16                  gridPoints;
    00529
    00530         LH_START_PROC("Add_NL_AToB0Tag_mft1")
    00531
    00532         LOCK_DATA(cw->lutParam.inputLut);
    00533         LOCK_DATA(cw->lutParam.colorLut);
    00534         LOCK_DATA(cw->lutParam.outputLut);
    00535
    00536         inputChannels  = (UINT16)cw->lutParam.colorLutInDim;
    00537         outputChannels = (UINT16)cw->lutParam.colorLutOutDim;
    00538         gridPoints         = (UINT16)cw->lutParam.colorLutGridPoints;
    00539
    00540         tempLutPtr      = &lutPtr->lut;
    00541         CMHelperICC2int32Const(&(lutPtr->base ), icSigLut8Type);
    00542         CMHelperICC2int32Const((OSType*)&(lutPtr->base )+1, 0);
    00543         tempLutPtr->inputChan   = (UINT8)inputChannels;
    00544         tempLutPtr->outputChan  = (UINT8)outputChannels;
    00545         tempLutPtr->clutPoints  = (UINT8)gridPoints;
    00546         tempLutPtr->e00 = tempLutPtr->e01 = tempLutPtr->e02 = 0;
    00547         tempLutPtr->e10 = tempLutPtr->e11 = tempLutPtr->e12 = 0;
    00548         tempLutPtr->e20 = tempLutPtr->e21 = tempLutPtr->e22 = 0;
    00549         CMHelperICC2int32Const(&(tempLutPtr->e00        ), 0x10000);
    00550         CMHelperICC2int32Const(&(tempLutPtr->e11        ), 0x10000);
    00551         CMHelperICC2int32Const(&(tempLutPtr->e22        ), 0x10000);
    00552
    00553         err = Fill_mft1_InputTable((Ptr)DATA_2_PTR(cw->lutParam.inputLut), tempLutPtr, cw);
    00554         if (err)
    00555                 goto CleanupAndExit;
    00556
    00557         offset = 256 * inputChannels;
    00558         BlockMoveData( DATA_2_PTR(cw->lutParam.colorLut), & tempLutPtr->data[0] + offset, colorLutSize);
    00559
    00560         offset = offset + colorLutSize;
    00561         err = Fill_mft1_OutputTable((Ptr)DATA_2_PTR(cw->lutParam.outputLut),  tempLutPtr, offset, cw);
    00562         if (err)
    00563                 goto CleanupAndExit;
    00564
    00565 CleanupAndExit:
    00566
    00567         #ifdef DEBUG_OUTPUT
    00568         if ( err  )
    00569                 DebugPrint("¥ MyAdd_NL_AToB0Tag_mft1-Error: result = %d\n",err);
    00570         #endif
    00571         UNLOCK_DATA(cw->lutParam.inputLut);
    00572         UNLOCK_DATA(cw->lutParam.colorLut);
    00573         UNLOCK_DATA(cw->lutParam.outputLut);
    00574         LH_END_PROC("Add_NL_AToB0Tag_mft1")
    00575         return err;
    00576 }
    00577
    00578 UINT32 GetSizes( CMMModelPtr cw, UINT32 *clutSize );
    00579 UINT32 GetSizes( CMMModelPtr cw, UINT32 *clutSize )
    00580 {
    00581         UINT16                  inputChannels;
    00582         UINT16                  outputChannels;
    00583         UINT16                  gridPoints;
    00584         SINT32                  colorLutSize;
    00585         UINT32                  i,theSize;
    00586
    00587         LOCK_DATA(cw->lutParam.inputLut);
    00588         LOCK_DATA(cw->lutParam.colorLut);
    00589         LOCK_DATA(cw->lutParam.outputLut);
    00590
    00591         inputChannels  = (UINT16)cw->lutParam.colorLutInDim;
    00592         outputChannels = (UINT16)cw->lutParam.colorLutOutDim;
    00593         gridPoints         = (UINT16)cw->lutParam.colorLutGridPoints;
    00594
    00595         colorLutSize = outputChannels;
    00596         for(i = 0; i < inputChannels; i++)
    00597                 colorLutSize *= gridPoints;
    00598
    00599         if ( cw->lutParam.colorLutWordSize != 8){
    00600                 theSize = sizeof(OSType) + sizeof(UINT32) + (4 * sizeof(UINT8)) + (9 * sizeof(Fixed))                   /* typeDescriptor...matrix */
    00601                                         + 2 * sizeof(icUInt16Number)                                                                                                            /* inputLutEntryCount outputLutEntryCount*/
    00602                                         + (inputChannels * cw->lutParam.inputLutEntryCount * sizeof(UINT16))                            /* inputTable */
    00603                                         + (outputChannels * cw->lutParam.outputLutEntryCount * sizeof(UINT16))                          /* CLUT */
    00604                                         + colorLutSize * sizeof(UINT16);                                                                                                                                                /* outputTable */
    00605         }
    00606         else{
    00607                 theSize = sizeof(OSType) + sizeof(UINT32) + (4 * sizeof(UINT8)) + (9 * sizeof(Fixed))                   /* typeDescriptor...matrix */
    00608                                         + (inputChannels * 256 * sizeof(UINT8))                                                                                         /* inputTable */
    00609                                         + (outputChannels * 256 * sizeof(UINT8))                                                                                        /* CLUT */
    00610                                         + colorLutSize;                                                                                                                                         /* outputTable */
    00611         }
    00612         *clutSize = colorLutSize;
    00613         UNLOCK_DATA(cw->lutParam.inputLut);
    00614         UNLOCK_DATA(cw->lutParam.colorLut);
    00615         UNLOCK_DATA(cw->lutParam.outputLut);
    00616         return theSize;
    00617 }
    00618
    00619 CMError MyAdd_NL_AToB0Tag_mft2( CMMModelPtr cw, icLut16Type *lutPtr, long colorLutSize )
    00620 {
    00621         CMError                 err;
    00622         icLut16                 *tempLutPtr;
    00623         long                    offset;
    00624         UINT16                  inputChannels;
    00625         UINT16                  outputChannels;
    00626         UINT16                  gridPoints;
    00627
    00628         LH_START_PROC("Add_NL_AToB0Tag_mft2")
    00629
    00630         LOCK_DATA(cw->lutParam.inputLut);
    00631         LOCK_DATA(cw->lutParam.colorLut);
    00632         LOCK_DATA(cw->lutParam.outputLut);
    00633
    00634         inputChannels  = (UINT16)cw->lutParam.colorLutInDim;
    00635         outputChannels = (UINT16)cw->lutParam.colorLutOutDim;
    00636         gridPoints         = (UINT16)cw->lutParam.colorLutGridPoints;
    00637
    00638         tempLutPtr      = &lutPtr->lut;
    00639         CMHelperICC2int32Const(&(lutPtr->base ), icSigLut16Type);
    00640         CMHelperICC2int32Const((OSType*)&(lutPtr->base )+1, 0);
    00641         tempLutPtr->inputChan   = (UINT8)inputChannels;
    00642         tempLutPtr->outputChan  = (UINT8)outputChannels;
    00643         tempLutPtr->clutPoints  = (UINT8)((gridPoints>255)?255:gridPoints);
    00644         tempLutPtr->e00 = tempLutPtr->e01 = tempLutPtr->e02 = 0;
    00645         tempLutPtr->e10 = tempLutPtr->e11 = tempLutPtr->e12 = 0;
    00646         tempLutPtr->e20 = tempLutPtr->e21 = tempLutPtr->e22 = 0;
    00647         CMHelperICC2int32Const(&(tempLutPtr->e00        ), 0x10000);
    00648         CMHelperICC2int32Const(&(tempLutPtr->e11        ), 0x10000);
    00649         CMHelperICC2int32Const(&(tempLutPtr->e22        ), 0x10000);
    00650
    00651         tempLutPtr->inputEnt    = (UINT16)cw->lutParam.inputLutEntryCount;
    00652         tempLutPtr->outputEnt   = (UINT16)cw->lutParam.outputLutEntryCount;
    00653         err = Fill_mft2_InputTable((Ptr)DATA_2_PTR(cw->lutParam.inputLut), tempLutPtr, cw);
    00654         if (err)
    00655                 goto CleanupAndExit;
    00656
    00657         offset = cw->lutParam.inputLutEntryCount * inputChannels;
    00658         Fill_mft2_ColorTable( (Ptr)DATA_2_PTR(cw->lutParam.colorLut), tempLutPtr, offset, colorLutSize);
    00659
    00660         offset = offset + colorLutSize;
    00661         err = Fill_mft2_OutputTable((Ptr)DATA_2_PTR(cw->lutParam.outputLut),  tempLutPtr, offset, cw);
    00662         if (err)
    00663                 goto CleanupAndExit;
    00664
    00665         CMHelperICC2int16Const(&(tempLutPtr->inputEnt   ), (UINT16)cw->lutParam.inputLutEntryCount);
    00666         CMHelperICC2int16Const(&(tempLutPtr->outputEnt  ), (UINT16)cw->lutParam.outputLutEntryCount);
    00667
    00668 CleanupAndExit:
    00669
    00670         #ifdef DEBUG_OUTPUT
    00671         if ( err  )
    00672                 DebugPrint("¥ MyAdd_NL_AToB0Tag_mft2-Error: result = %d\n",err);
    00673         #endif
    00674         UNLOCK_DATA(cw->lutParam.inputLut);
    00675         UNLOCK_DATA(cw->lutParam.colorLut);
    00676         UNLOCK_DATA(cw->lutParam.outputLut);
    00677         LH_END_PROC("Add_NL_AToB0Tag_mft2")
    00678         return err;
    00679 }
    00680
    00681 CMError MyGetColorSpaces(       CMConcatProfileSet      *profileSet,
    00682                                                         UINT32                          *sCS,
    00683                                                         UINT32                          *dCS );
    00684 CMError MyGetColorSpaces(       CMConcatProfileSet      *profileSet,
    00685                                                         UINT32                          *sCS,
    00686                                                         UINT32                          *dCS )
    00687 {
    00688         CMError                                         err;
    00689         icHeader                                        profHeader;
    00690
    00691         LH_START_PROC("MyGetColorSpaces")
    00692
    00693         err = CMGetProfileHeader(profileSet->profileSet[0], (CMCoreProfileHeader *)&profHeader);
    00694         if (err)
    00695                 goto CleanupAndExit;
    00696         *sCS = profHeader.colorSpace;
    00697
    00698         err = CMGetProfileHeader(profileSet->profileSet[profileSet->count-1], (CMCoreProfileHeader *)&profHeader);
    00699         if (err)
    00700                 goto CleanupAndExit;
    00701         *dCS = profHeader.colorSpace;
    00702
    00703 CleanupAndExit:
    00704         LH_END_PROC("MyAdd_NL_SequenceDescTag")
    00705         return err;
    00706 }
    00707 /* ______________________________________________________________________
    00708         CMError
    00709         MyAdd_NL_SequenceDescTag        ( CMProfileRef           linkProfile,
    00710                                                           CMConcatProfileSet *profileSet )
    00711
    00712         Abstract:
    00713                 Create the ProfileSequenceDescTag for the NewDeviceLink CMProfileRef.
    00714                 Copy the data from the profiles in profileSet
    00715
    00716         Params:
    00717                 linkProfile     (in/out)        Reference to new profile.
    00718                 profileSet      (in)            Reference to CMConcatProfileSet.
    00719
    00720         Return:
    00721                 noErr           successful
    00722                 System or  result code if an error occurs.
    00723    _____________________________________________________________________ */
    00724 CMError MyAdd_NL_SequenceDescTag(       CMConcatProfileSet                      *profileSet,
    00725                                                                         icProfileSequenceDescType       *pSeqPtr,
    00726                                                                         long                                            *aSize )
    00727 {
    00728         CMError                                         err;
    00729         OSErr                                           aOSerr;
    00730         /*icProfileSequenceDescType*    pSeqPtr         = nil;*/
    00731         Ptr                                                     thePtr          = nil;
    00732         icHeader                                        profHeader;
    00733         SINT32                                          loop;
    00734         OSType                                          technology;
    00735         UINT32                                          elementSize;
    00736         icSignatureType                         theSignature;
    00737         icTextDescriptionType*          descPtr         = nil;
    00738         char                                            descPtrNull[90]={0};
    00739
    00740         LH_START_PROC("MyAdd_NL_SequenceDescTag")
    00741
    00742         CMHelperICC2int32Const(&(((icTextDescriptionType*)descPtrNull)->base ), icSigTextDescriptionType );
    00743         CMHelperICC2int32Const(((OSType*)&((icTextDescriptionType*)descPtrNull)->base )+1, 0);
    00744         CMHelperICC2int32Const(&(((icTextDescriptionType*)descPtrNull)->desc.count ), 1 );
    00745         /*pSeqPtr =  (icProfileSequenceDescType*)SmartNewPtrClear(5000, &aOSerr);
    00746         err = aOSerr;
    00747         if (err)
    00748                 goto CleanupAndExit;*/
    00749         CMHelperICC2int32Const(&(pSeqPtr->base ), icSigProfileSequenceDescType);
    00750         CMHelperICC2int32Const((OSType*)&(pSeqPtr->base )+1, 0);
    00751         CMHelperICC2int32Const(&(pSeqPtr->desc.count ), profileSet->count );
    00752         thePtr = (Ptr)( (SIZE_T)&(pSeqPtr->desc.count) + sizeof(SINT32) ) ;
    00753
    00754         for (loop = 0; loop < (SINT32)profileSet->count; loop++)
    00755         {
    00756                 err = CMGetProfileHeader(profileSet->profileSet[loop], (CMCoreProfileHeader *)&profHeader);
    00757                 if (err)
    00758                         goto CleanupAndExit;
    00759                 CMHelperICC2int32Const(thePtr, profHeader.manufacturer);
    00760                 thePtr += sizeof(OSType);
    00761                 CMHelperICC2int32Const(thePtr, profHeader.model);
    00762                 thePtr += sizeof(OSType);
    00763                 CMHelperICC2int32Const(thePtr, profHeader.attributes[0]);
    00764                 thePtr += sizeof(UINT32);
    00765                 CMHelperICC2int32Const(thePtr, profHeader.attributes[1]);
    00766                 thePtr += sizeof(UINT32);
    00767
    00768                 /* ----------------------------------------------------------------- icSigTechnologyTag */
    00769                 technology = 0;
    00770                 if ( CMGetProfileElement(profileSet->profileSet[loop], icSigTechnologyTag, &elementSize, nil) == noErr)
    00771                 {
    00772                         if (elementSize == sizeof(icSigTechnologyTag))
    00773                         {
    00774                                 if ( CMGetProfileElement(profileSet->profileSet[loop], icSigTechnologyTag, &elementSize, &theSignature) == noErr)
    00775                                         technology = theSignature.signature;
    00776                         }
    00777                 }
    00778                 *((OSType*)thePtr) = technology;                                                                        /* signature */
    00779                 thePtr += sizeof(OSType);
    00780
    00781                 /* ----------------------------------------------------------------- icSigDeviceMfgDescTag */
    00782                 if ( CMGetProfileElement(profileSet->profileSet[loop], icSigDeviceMfgDescTag, &elementSize, nil) == noErr)
    00783                 {
    00784                         descPtr = (icTextDescriptionType*)SmartNewPtr(elementSize,&aOSerr);
    00785                         err = aOSerr;
    00786                         if (err)
    00787                                 goto CleanupAndExit;
    00788                         if ( CMGetProfileElement(profileSet->profileSet[loop], icSigDeviceMfgDescTag, &elementSize, descPtr) == noErr)
    00789                         {
    00790                                 BlockMoveData( descPtr, thePtr, elementSize);
    00791                                 thePtr += elementSize;
    00792                         }
    00793                         descPtr = (icTextDescriptionType*)DisposeIfPtr((Ptr)descPtr);
    00794                 } else
    00795                 {
    00796                         BlockMoveData( descPtrNull, thePtr, sizeof(descPtrNull));
    00797                         thePtr += sizeof(descPtrNull);
    00798                 }
    00799                 /* ----------------------------------------------------------------- icSigDeviceModelDescTag */
    00800                 if ( CMGetProfileElement(profileSet->profileSet[loop], icSigDeviceModelDescTag, &elementSize, nil) == noErr)
    00801                 {
    00802                         descPtr = (icTextDescriptionType*)SmartNewPtr(elementSize,&aOSerr);
    00803                         err = aOSerr;
    00804                         if (err)
    00805                                 goto CleanupAndExit;
    00806                         if ( CMGetProfileElement(profileSet->profileSet[loop], icSigDeviceModelDescTag, &elementSize, descPtr) == noErr)
    00807                         {
    00808                                 BlockMoveData( descPtr, thePtr, elementSize);
    00809                                 thePtr += elementSize;
    00810                         }
    00811                         descPtr =  (icTextDescriptionType*)DisposeIfPtr((Ptr)descPtr);
    00812                 } else
    00813                 {
    00814                         BlockMoveData( descPtrNull, thePtr, sizeof(descPtrNull));
    00815                         thePtr += sizeof(descPtrNull);
    00816                 }
    00817                 /* ----------------------------------------------------------------- */
    00818         }
    00819
    00820    //Sundown safe truncation
    00821         *aSize = (LONG)((ULONG_PTR)thePtr - (ULONG_PTR)pSeqPtr);
    00822
    00823 CleanupAndExit:
    00824         descPtr = (icTextDescriptionType*)DisposeIfPtr((Ptr)descPtr);
    00825         LH_END_PROC("MyAdd_NL_SequenceDescTag")
    00826         return err;
    00827 }
    00828
    00829
    00830 MyXYZNumber MakeXYZNumber( MyXYZNumber *x );
    00831 MyXYZNumber MakeXYZNumber( MyXYZNumber *x )
    00832 {
    00833         MyXYZNumber ret;
    00834         ret.X = x->X>>14;
    00835         ret.Y = x->Y>>14;
    00836         ret.Z = x->Z>>14;
    00837         return ret;
    00838 }
    00839
    00840 void  MakeMyDoubleXYZ( MyXYZNumber *x, MyDoubleXYZ *ret );
    00841 void  MakeMyDoubleXYZ( MyXYZNumber *x, MyDoubleXYZ *ret )
    00842 {
    00843         ret->X = x->X/(double)(1<<30);
    00844         ret->Y = x->Y/(double)(1<<30);
    00845         ret->Z = x->Z/(double)(1<<30);
    00846 }
    00847 Boolean  doubMatrixInvert(      double  inpMat[3][3],
    00848                                                 double  outMat[3][3] );
    00849 void  TransposeMatrix(  double  inpMat[3][3] );
    00850 void  TransposeMatrix(  double  inpMat[3][3] )
    00851 {
    00852         long i,j;
    00853         double sav;
    00854         for( i=0; i< 3; i++ ){
    00855                 for( j=i+1; j< 3; j++ ){
    00856                         sav                      =  inpMat[i][j];
    00857                         inpMat[i][j] =  inpMat[j][i];
    00858                         inpMat[j][i] =  sav;
    00859                 }
    00860         }
    00861
    00862 }
    00863 #define Round(a) (((a)>0.)?((a)+.5):((a)-.5))
    00864
    00865 double GetMatrixedVal( double m[3][3], long color, MyDoubleXYZ *aXYZ );
    00866 double GetMatrixedVal( double m[3][3], long color, MyDoubleXYZ *aXYZ )
    00867 {
    00868         double tmp;
    00869         tmp = m[color][0] * aXYZ->X;
    00870         tmp+= m[color][1] * aXYZ->Y;
    00871         tmp+= m[color][2] * aXYZ->Z;
    00872         return tmp;
    00873 }
    00874
    00875 void NormalizeColor( MyXYZNumber *r, MyXYZNumber *g, MyXYZNumber *b, MyDoubleXYZ *Illuminant, MyXYZNumber *resR, MyXYZNumber *resG, MyXYZNumber *resB );
    00876 void NormalizeColor( MyXYZNumber *r, MyXYZNumber *g, MyXYZNumber *b, MyDoubleXYZ *Illuminant, MyXYZNumber *resR, MyXYZNumber *resG, MyXYZNumber *resB )
    00877 {
    00878         double  factorX,factorY,factorZ;
    00879         double inMat[3][3];
    00880
    00881         MakeMyDoubleXYZ( r, (MyDoubleXYZ*)&inMat[0][0] );
    00882         MakeMyDoubleXYZ( g, (MyDoubleXYZ*)&inMat[1][0] );
    00883         MakeMyDoubleXYZ( b, (MyDoubleXYZ*)&inMat[2][0] );
    00884
    00885         factorX = inMat[0][0] + inMat[1][0] + inMat[2][0];
    00886         factorY = inMat[0][1] + inMat[1][1] + inMat[2][1];
    00887         factorZ = inMat[0][2] + inMat[1][2] + inMat[2][2];
    00888
    00889         factorX = Illuminant->X / factorX * 65536;
    00890         factorY = Illuminant->Y / factorY * 65536;
    00891         factorZ = Illuminant->Z / factorZ * 65536;
    00892
    00893         resR->X = (long)Round(inMat[0][0] * factorX);                   /* red primary */
    00894         resR->Y = (long)Round(inMat[0][1] * factorY);
    00895         resR->Z = (long)Round(inMat[0][2] * factorZ);
    00896         resG->X = (long)Round(inMat[1][0] * factorX);                   /* green primary */
    00897         resG->Y = (long)Round(inMat[1][1] * factorY);
    00898         resG->Z = (long)Round(inMat[1][2] * factorZ);
    00899         resB->X = (long)Round(inMat[2][0] * factorX);                   /* blue primary */
    00900         resB->Y = (long)Round(inMat[2][1] * factorY);
    00901         resB->Z = (long)Round(inMat[2][2] * factorZ);
    00902 }
    00903
    00904 void NormalizeWithWhiteAdaption( MyXYZNumber *r, MyXYZNumber *g, MyXYZNumber *b, MyDoubleXYZ *Illuminant, MyXYZNumber *resR, MyXYZNumber *resG, MyXYZNumber *resB );
    00905 void NormalizeWithWhiteAdaption( MyXYZNumber *r, MyXYZNumber *g, MyXYZNumber *b, MyDoubleXYZ *Illuminant, MyXYZNumber *resR, MyXYZNumber *resG, MyXYZNumber *resB )
    00906 {
    00907         double  factorR,factorG,factorB;
    00908         double inMat[3][3];
    00909         double outMat[3][3];
    00910
    00911         MakeMyDoubleXYZ( r, (MyDoubleXYZ*)&inMat[0][0] );
    00912         MakeMyDoubleXYZ( g, (MyDoubleXYZ*)&inMat[1][0] );
    00913         MakeMyDoubleXYZ( b, (MyDoubleXYZ*)&inMat[2][0] );
    00914
    00915         if( !doubMatrixInvert(inMat, outMat) )
    00916         {
    00917                 return ;
    00918         }
    00919
    00920         TransposeMatrix( outMat );
    00921
    00922         factorR =  GetMatrixedVal( outMat, 0, Illuminant )*65536;
    00923         factorG =  GetMatrixedVal( outMat, 1, Illuminant )*65536;
    00924         factorB =  GetMatrixedVal( outMat, 2, Illuminant )*65536;
    00925
    00926         resR->X = (long)Round(inMat[0][0] * factorR);                   /* red primary */
    00927         resR->Y = (long)Round(inMat[0][1] * factorR);
    00928         resR->Z = (long)Round(inMat[0][2] * factorR);
    00929         resG->X = (long)Round(inMat[1][0] * factorG);                   /* green primary */
    00930         resG->Y = (long)Round(inMat[1][1] * factorG);
    00931         resG->Z = (long)Round(inMat[1][2] * factorG);
    00932         resB->X = (long)Round(inMat[2][0] * factorB);                   /* blue primary */
    00933         resB->Y = (long)Round(inMat[2][1] * factorB);
    00934         resB->Z = (long)Round(inMat[2][2] * factorB);
    00935 }
    00936
    00937 #ifdef WRITE_PROFILE
    00938 void WriteProf( Ptr name, icProfile *theProf, long currentSize );
    00939 #endif
    00940
    00941 #define MyTagCount 9
    00942
    00943 #if __IS_MSDOS && defined(RenderInt)
    00944 CMError MyNewAbstract( LPLOGCOLORSPACEA lpColorSpace, icProfile **theProf )
    00945 {
    00946         CMError                 err = unimpErr;
    00947         OSErr                   aOSerr = unimpErr;
    00948 #ifdef __MWERKS__
    00949         unsigned char   theText[] = "\pLogColorSpProfile   ";
    00950         char                    copyrightText[] = "\p©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    00951 #elif __IS_MSDOS
    00952         char                    theText[] = "\030LogColorSpProfile      ";
    00953         char                    copyrightText[] = "\060©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    00954 #else
    00955         char                    theText[] = "\030LogColorSpProfile      ";
    00956         char                    copyrightText[] = "\060©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    00957 #endif
    00958         icProfile               *aProf=0;
    00959         long                    theTagTabSize;
    00960         long                    theHeaderSize;
    00961         long                    theDescSize;
    00962         long                    theMediaSize;
    00963         long                    theEndPointSize;
    00964         long                    theTRCSize;
    00965         long                    theCopyRightSize;
    00966         long                    currentSize=0;
    00967         long                    theTotalSize=0;
    00968         icTag                   aTag;
    00969         unsigned long   aIntent;
    00970
    00971         MyXYZNumber     rXYZ,gXYZ,bXYZ;
    00972         MyDoubleXYZ D50XYZ = { 0.9642, 1.0000, 0.8249 };
    00973         MyXYZNumber D50 = { (unsigned long)(D50XYZ.X * 65536), (unsigned long)(D50XYZ.Y * 65536), (unsigned long)(D50XYZ.Z * 65536)};
    00974         theHeaderSize = sizeof(icHeader);
    00975         theDescSize   =                                                                           sizeof(OSType)                        /* type descriptor */
    00976                                                                                                                 + sizeof(unsigned long)         /* reserved */
    00977                                                                                                                 + sizeof(unsigned long)         /* ASCII length */
    00978                                                                                                                 + theText[0]                            /* ASCII profile description */
    00979                                                                                                                 + sizeof(unsigned long)         /* Unicode code */
    00980                                                                                                                 + sizeof(unsigned long)         /* Unicode character count */
    00981                                                                                                                 + sizeof(unsigned short)        /* Macintosh script code */
    00982                                                                                                                 + sizeof(unsigned char)         /* Macintosh string length */
    00983                                                                                                                 + 67                                            /* Macintosh string */
    00984                                                                                                                 ;
    00985         theCopyRightSize   =                                                              sizeof(OSType)                        /* type descriptor */
    00986                                                                                                                 + sizeof(unsigned long)         /* reserved */
    00987                                                                                                                 + copyrightText[0]                      /* ASCII profile description */
    00988                                                                                                                 ;
    00989         theMediaSize = sizeof( icXYZType );;
    00990         theEndPointSize = sizeof( icXYZType );;
    00991         theTRCSize = 4*((sizeof( icCurveType ) +3)/4);
    00992
    00993         theTagTabSize = MyTagCount * sizeof( icTag ) + sizeof( unsigned long );
    00994
    00995         theTotalSize = theHeaderSize + theTagTabSize + theDescSize + theCopyRightSize
    00996                 + theMediaSize + 3*theEndPointSize + 3*theTRCSize;
    00997         aProf = (icProfile *)GlobalAllocPtr( GHND, theTotalSize );
    00998         if( aProf == 0 ){
    00999                 err = GetLastError();
    01000                 goto CleanupAndExit;
    01001         }
    01002
    01003         switch( lpColorSpace->lcsIntent ){
    01004           case LCS_GM_BUSINESS:
    01005                 aIntent = icSaturation;
    01006                 break;
    01007           case LCS_GM_GRAPHICS:
    01008                 aIntent = icRelativeColorimetric;
    01009                 break;
    01010           case LCS_GM_ABS_COLORIMETRIC:
    01011                 aIntent = icAbsoluteColorimetric;
    01012                 break;
    01013           default:
    01014                 aIntent = icPerceptual;
    01015                 break;
    01016         }
    01017         err = MyAdd_NL_Header(theTotalSize, (icHeader*)((Ptr)aProf+currentSize), aIntent, icSigInputClass, icSigRgbData, icSigXYZData );
    01018         if (err)
    01019                 goto CleanupAndExit;
    01020
    01021         /*----------------------------------------------------------------------------------------- cmProfileDescriptionTag */
    01022         currentSize = theHeaderSize + theTagTabSize;
    01023         CMHelperICC2int32Const(&(aProf->tagList.count ), MyTagCount);
    01024
    01025         CMHelperICC2int32Const(&(aTag.sig ), icSigProfileDescriptionTag);
    01026         CMHelperICC2int32Const(&(aTag.offset ), currentSize);
    01027         CMHelperICC2int32Const(&(aTag.size ), theDescSize);
    01028         aProf->tagList.tags[0] = aTag;
    01029         err =MyAdd_NL_DescriptionTag    ( (LHTextDescriptionType *)((Ptr)aProf+currentSize), (unsigned char *)theText );
    01030         if (err)
    01031                 goto CleanupAndExit;
    01032         currentSize += theDescSize;
    01033
    01034         CMHelperICC2int32Const(&(aTag.sig ), icSigMediaWhitePointTag);
    01035         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01036         CMHelperICC2int32Const(&(aTag.size ), theMediaSize);
    01037         aProf->tagList.tags[1] = aTag;
    01038         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &D50);
    01039         currentSize += theMediaSize;
    01040
    01041         NormalizeColor( (icXYZNumber*)&lpColorSpace->lcsEndpoints.ciexyzRed,
    01042                                         (icXYZNumber*)&lpColorSpace->lcsEndpoints.ciexyzGreen,
    01043                                         (icXYZNumber*)&lpColorSpace->lcsEndpoints.ciexyzBlue,
    01044                                         &D50XYZ,
    01045                                         &rXYZ,
    01046                                         &gXYZ,
    01047                                         &bXYZ );
    01048         CMHelperICC2int32Const(&(aTag.sig ), icSigRedColorantTag);
    01049         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01050         CMHelperICC2int32Const(&(aTag.size ), theEndPointSize);
    01051         aProf->tagList.tags[2] = aTag;
    01052         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &rXYZ );
    01053         currentSize += theEndPointSize;
    01054
    01055         CMHelperICC2int32Const(&(aTag.sig ), icSigGreenColorantTag);
    01056         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01057         CMHelperICC2int32Const(&(aTag.size ), theEndPointSize);
    01058         aProf->tagList.tags[3] = aTag;
    01059         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &gXYZ );
    01060         currentSize += theEndPointSize;
    01061
    01062         CMHelperICC2int32Const(&(aTag.sig ), icSigBlueColorantTag);
    01063         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01064         CMHelperICC2int32Const(&(aTag.size ), theEndPointSize);
    01065         aProf->tagList.tags[4] = aTag;
    01066         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &bXYZ );
    01067         currentSize += theEndPointSize;
    01068
    01069         CMHelperICC2int32Const(&(aTag.sig ), icSigRedTRCTag);
    01070         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01071         CMHelperICC2int32Const(&(aTag.size ), sizeof( icCurveType ));
    01072         aProf->tagList.tags[5] = aTag;
    01073         MyAdd_NL_CurveTag((icCurveType  *)((Ptr)aProf+currentSize), (unsigned short)(lpColorSpace->lcsGammaRed>>8) );
    01074         currentSize += theTRCSize;
    01075
    01076         CMHelperICC2int32Const(&(aTag.sig ), icSigGreenTRCTag);
    01077         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01078         CMHelperICC2int32Const(&(aTag.size ), sizeof( icCurveType ));
    01079         aProf->tagList.tags[6] = aTag;
    01080         MyAdd_NL_CurveTag((icCurveType  *)((Ptr)aProf+currentSize), (unsigned short)(lpColorSpace->lcsGammaGreen>>8) );
    01081         currentSize += theTRCSize;
    01082
    01083         CMHelperICC2int32Const(&(aTag.sig ), icSigBlueTRCTag);
    01084         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01085         CMHelperICC2int32Const(&(aTag.size ), sizeof( icCurveType ));
    01086         aProf->tagList.tags[7] = aTag;
    01087         MyAdd_NL_CurveTag((icCurveType  *)((Ptr)aProf+currentSize), (unsigned short)(lpColorSpace->lcsGammaBlue>>8) );
    01088         currentSize += theTRCSize;
    01089
    01090         CMHelperICC2int32Const(&(aTag.sig ), icSigCopyrightTag);
    01091         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01092         CMHelperICC2int32Const(&(aTag.size ), theCopyRightSize);
    01093         aProf->tagList.tags[8] = aTag;
    01094         err = MyAdd_NL_CopyrightTag( (unsigned char *)copyrightText, (LHTextType *)((Ptr)aProf+currentSize));
    01095         if (err)
    01096                 goto CleanupAndExit;
    01097         currentSize += theCopyRightSize;
    01098
    01099         *theProf = aProf;
    01100 #ifdef WRITE_PROFILE
    01101         WriteProf( "MyNewAbstract.pf", aProf, currentSize );
    01102 #endif
    01103         return noErr;
    01104
    01105 CleanupAndExit:
    01106         if( aProf )GlobalFreePtr( aProf );
    01107         return err;
    01108 }
    01109
    01110
    01111 CMError MyNewAbstractW( LPLOGCOLORSPACEW        lpColorSpace, icProfile **theProf )
    01112 {
    01113         CMError                 err = unimpErr;
    01114         OSErr                   aOSerr = unimpErr;
    01115 #ifdef __MWERKS__
    01116         unsigned char   theText[] = "\pLogColorSpProfile   ";
    01117         char                    copyrightText[] = "\p©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    01118 #elif __IS_MSDOS
    01119         char                    theText[] = "\030LogColorSpProfile      ";
    01120         char                    copyrightText[] = "\060©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    01121 #else
    01122         char                    theText[] = "\030LogColorSpProfile      ";
    01123         char                    copyrightText[] = "\060©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    01124 #endif
    01125         icProfile               *aProf=0;
    01126         long                    theTagTabSize;
    01127         long                    theHeaderSize;
    01128         long                    theDescSize;
    01129         long                    theMediaSize;
    01130         long                    theEndPointSize;
    01131         long                    theTRCSize;
    01132         long                    theCopyRightSize;
    01133         long                    currentSize=0;
    01134         long                    theTotalSize=0;
    01135         icTag                   aTag;
    01136         unsigned long   aIntent;
    01137
    01138         MyXYZNumber     rXYZ,gXYZ,bXYZ;
    01139         MyDoubleXYZ D50XYZ = { 0.9642, 1.0000, 0.8249 };
    01140         MyXYZNumber D50 = { (unsigned long)(D50XYZ.X * 65536), (unsigned long)(D50XYZ.Y * 65536), (unsigned long)(D50XYZ.Z * 65536)};
    01141         theHeaderSize = sizeof(icHeader);
    01142         theDescSize   =                                                                           sizeof(OSType)                        /* type descriptor */
    01143                                                                                                                 + sizeof(unsigned long)         /* reserved */
    01144                                                                                                                 + sizeof(unsigned long)         /* ASCII length */
    01145                                                                                                                 + theText[0]                            /* ASCII profile description */
    01146                                                                                                                 + sizeof(unsigned long)         /* Unicode code */
    01147                                                                                                                 + sizeof(unsigned long)         /* Unicode character count */
    01148                                                                                                                 + sizeof(unsigned short)        /* Macintosh script code */
    01149                                                                                                                 + sizeof(unsigned char)         /* Macintosh string length */
    01150                                                                                                                 + 67                                            /* Macintosh string */
    01151                                                                                                                 ;
    01152         theCopyRightSize   =                                                              sizeof(OSType)                        /* type descriptor */
    01153                                                                                                                 + sizeof(unsigned long)         /* reserved */
    01154                                                                                                                 + copyrightText[0]                      /* ASCII profile description */
    01155                                                                                                                 ;
    01156         theMediaSize = sizeof( icXYZType );;
    01157         theEndPointSize = sizeof( icXYZType );;
    01158         theTRCSize = 4*((sizeof( icCurveType ) +3)/4);
    01159
    01160         theTagTabSize = MyTagCount * sizeof( icTag ) + sizeof( unsigned long );
    01161
    01162         theTotalSize = theHeaderSize + theTagTabSize + theDescSize + theCopyRightSize
    01163                 + theMediaSize + 3*theEndPointSize + 3*theTRCSize;
    01164         aProf = (icProfile *)GlobalAllocPtr( GHND, theTotalSize );
    01165         if( aProf == 0 ){
    01166                 err = GetLastError();
    01167                 goto CleanupAndExit;
    01168         }
    01169
    01170         switch( lpColorSpace->lcsIntent ){
    01171           case LCS_GM_BUSINESS:
    01172                 aIntent = icSaturation;
    01173                 break;
    01174           case LCS_GM_GRAPHICS:
    01175                 aIntent = icRelativeColorimetric;
    01176                 break;
    01177           case LCS_GM_GRAPHICS+1:
    01178                 aIntent = icAbsoluteColorimetric;
    01179                 break;
    01180           default:
    01181                 aIntent = icPerceptual;
    01182                 break;
    01183         }
    01184         err = MyAdd_NL_Header(theTotalSize, (icHeader*)((Ptr)aProf+currentSize), aIntent, icSigInputClass, icSigRgbData, icSigXYZData );
    01185         if (err)
    01186                 goto CleanupAndExit;
    01187
    01188         /*----------------------------------------------------------------------------------------- cmProfileDescriptionTag */
    01189         currentSize = theHeaderSize + theTagTabSize;
    01190         CMHelperICC2int32Const(&(aProf->tagList.count ), MyTagCount);
    01191
    01192         CMHelperICC2int32Const(&(aTag.sig ), icSigProfileDescriptionTag);
    01193         CMHelperICC2int32Const(&(aTag.offset ), currentSize);
    01194         CMHelperICC2int32Const(&(aTag.size ), theDescSize);
    01195         aProf->tagList.tags[0] = aTag;
    01196         err =MyAdd_NL_DescriptionTag    ( (LHTextDescriptionType *)((Ptr)aProf+currentSize), (unsigned char *)theText );
    01197         if (err)
    01198                 goto CleanupAndExit;
    01199         currentSize += theDescSize;
    01200
    01201         CMHelperICC2int32Const(&(aTag.sig ), icSigMediaWhitePointTag);
    01202         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01203         CMHelperICC2int32Const(&(aTag.size ), theMediaSize);
    01204         aProf->tagList.tags[1] = aTag;
    01205         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &D50);
    01206         currentSize += theMediaSize;
    01207
    01208         NormalizeColor( (icXYZNumber*)&lpColorSpace->lcsEndpoints.ciexyzRed,
    01209                                         (icXYZNumber*)&lpColorSpace->lcsEndpoints.ciexyzGreen,
    01210                                         (icXYZNumber*)&lpColorSpace->lcsEndpoints.ciexyzBlue,
    01211                                         &D50XYZ,
    01212                                         &rXYZ,
    01213                                         &gXYZ,
    01214                                         &bXYZ );
    01215         CMHelperICC2int32Const(&(aTag.sig ), icSigRedColorantTag);
    01216         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01217         CMHelperICC2int32Const(&(aTag.size ), theEndPointSize);
    01218         aProf->tagList.tags[2] = aTag;
    01219         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &rXYZ );
    01220         currentSize += theEndPointSize;
    01221
    01222         CMHelperICC2int32Const(&(aTag.sig ), icSigGreenColorantTag);
    01223         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01224         CMHelperICC2int32Const(&(aTag.size ), theEndPointSize);
    01225         aProf->tagList.tags[3] = aTag;
    01226         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &gXYZ );
    01227         currentSize += theEndPointSize;
    01228
    01229         CMHelperICC2int32Const(&(aTag.sig ), icSigBlueColorantTag);
    01230         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01231         CMHelperICC2int32Const(&(aTag.size ), theEndPointSize);
    01232         aProf->tagList.tags[4] = aTag;
    01233         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &bXYZ );
    01234         currentSize += theEndPointSize;
    01235
    01236         CMHelperICC2int32Const(&(aTag.sig ), icSigRedTRCTag);
    01237         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01238         CMHelperICC2int32Const(&(aTag.size ), sizeof( icCurveType ));
    01239         aProf->tagList.tags[5] = aTag;
    01240         MyAdd_NL_CurveTag((icCurveType  *)((Ptr)aProf+currentSize), (unsigned short)(lpColorSpace->lcsGammaRed>>8) );
    01241         currentSize += theTRCSize;
    01242
    01243         CMHelperICC2int32Const(&(aTag.sig ), icSigGreenTRCTag);
    01244         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01245         CMHelperICC2int32Const(&(aTag.size ), sizeof( icCurveType ));
    01246         aProf->tagList.tags[6] = aTag;
    01247         MyAdd_NL_CurveTag((icCurveType  *)((Ptr)aProf+currentSize), (unsigned short)(lpColorSpace->lcsGammaGreen>>8) );
    01248         currentSize += theTRCSize;
    01249
    01250         CMHelperICC2int32Const(&(aTag.sig ), icSigBlueTRCTag);
    01251         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01252         CMHelperICC2int32Const(&(aTag.size ), sizeof( icCurveType ));
    01253         aProf->tagList.tags[7] = aTag;
    01254         MyAdd_NL_CurveTag((icCurveType  *)((Ptr)aProf+currentSize), (unsigned short)(lpColorSpace->lcsGammaBlue>>8) );
    01255         currentSize += theTRCSize;
    01256
    01257         CMHelperICC2int32Const(&(aTag.sig ), icSigCopyrightTag);
    01258         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01259         CMHelperICC2int32Const(&(aTag.size ), theCopyRightSize);
    01260         aProf->tagList.tags[8] = aTag;
    01261         err = MyAdd_NL_CopyrightTag( (unsigned char *)copyrightText, (LHTextType *)((Ptr)aProf+currentSize));
    01262         if (err)
    01263                 goto CleanupAndExit;
    01264         currentSize += theCopyRightSize;
    01265
    01266         *theProf = aProf;
    01267 #ifdef WRITE_PROFILE
    01268         WriteProf( "MyNewAbstractW.pf", aProf, currentSize );
    01269 #endif
    01270         return noErr;
    01271
    01272 CleanupAndExit:
    01273         if( aProf )GlobalFreePtr( aProf );
    01274         return err;
    01275 }
    01276 #endif
    01277
    01278 #define MyTagCountLink 5
    01279 #define LINK_BUFFER_MAX 3000
    01280
    01281 CMError DeviceLinkFill( CMMModelPtr cw,
    01282                                                 CMConcatProfileSet *profileSet,
    01283                                                 icProfile **theProf,
    01284                                                 unsigned long aIntent )
    01285 {
    01286         CMError                 err = unimpErr;
    01287         OSErr                   aOSerr = unimpErr;
    01288 #ifdef __MWERKS__
    01289         unsigned char   theText[] = "\pDeviceLink profile  ";
    01290         char                    copyrightText[] = "\p©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    01291 #elif __IS_MSDOS
    01292         char                    theText[] = "\030DeviceLink profile     ";
    01293         char                    copyrightText[] = "\060©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    01294 #else
    01295         char                    theText[] = "\030DeviceLink profile     ";
    01296         char                    copyrightText[] = "\060©1996 by Heidelberger Druckmaschinen AG  U.J.K.";
    01297 #endif
    01298         icProfile               *aProf=0;
    01299         long                    theTagTabSize;
    01300         long                    theHeaderSize;
    01301         long                    theDescSize;
    01302         long                    theMediaSize;
    01303         long                    theSequenceDescSize;
    01304         long                    theA2B0Size;
    01305         long                    theCopyRightSize;
    01306         long                    currentSize=0;
    01307         long                    theTotalSize=0;
    01308         icTag                   aTag;
    01309         UINT32                  sCS,dCS,clutSize;
    01310         Ptr                             aPtr=0;
    01311
    01312         MyDoubleXYZ D50XYZ = { 0.9642, 1.0000, 0.8249 };
    01313         MyXYZNumber D50 = { (unsigned long)(0.9642 * 65536), (unsigned long)(1.0000 * 65536), (unsigned long)(0.8249 * 65536)};
    01314         theHeaderSize = sizeof(icHeader);
    01315         theDescSize   =                                                                           sizeof(OSType)                        /* type descriptor */
    01316                                                                                                                 + sizeof(unsigned long)         /* reserved */
    01317                                                                                                                 + sizeof(unsigned long)         /* ASCII length */
    01318                                                                                                                 + theText[0]                            /* ASCII profile description */
    01319                                                                                                                 + sizeof(unsigned long)         /* Unicode code */
    01320                                                                                                                 + sizeof(unsigned long)         /* Unicode character count */
    01321                                                                                                                 + sizeof(unsigned short)        /* Macintosh script code */
    01322                                                                                                                 + sizeof(unsigned char)         /* Macintosh string length */
    01323                                                                                                                 + 67                                            /* Macintosh string */
    01324                                                                                                                 ;
    01325         theCopyRightSize   =                                                              sizeof(OSType)                        /* type descriptor */
    01326                                                                                                                 + sizeof(unsigned long)         /* reserved */
    01327                                                                                                                 + copyrightText[0]                      /* ASCII profile description */
    01328                                                                                                                 ;
    01329         theMediaSize = sizeof( icXYZType );;
    01330
    01331         theTagTabSize = MyTagCountLink * sizeof( icTag ) + sizeof( unsigned long );
    01332
    01333         *theProf = 0;
    01334
    01335         if( cw->hasNamedColorProf != NoNamedColorProfile ){
    01336                 err = cmProfileError;
    01337                 goto CleanupAndExit;
    01338         }
    01339         err = MyGetColorSpaces( profileSet, &sCS, &dCS );
    01340         if (err)
    01341                 goto CleanupAndExit;
    01342
    01343         aProf = (icProfile *)SmartNewPtrClear( LINK_BUFFER_MAX, &aOSerr );
    01344         err = aOSerr;
    01345         if (err)
    01346                 goto CleanupAndExit;
    01347
    01348         err = MyAdd_NL_Header(theTotalSize, (icHeader*)((Ptr)aProf+currentSize), aIntent, icSigLinkClass, sCS, dCS );
    01349         if (err)
    01350                 goto CleanupAndExit;
    01351
    01352         /*----------------------------------------------------------------------------------------- cmProfileDescriptionTag */
    01353         currentSize = theHeaderSize + theTagTabSize;
    01354         CMHelperICC2int32Const(&(aProf->tagList.count ), MyTagCountLink);
    01355
    01356         CMHelperICC2int32Const(&(aTag.sig ), icSigProfileDescriptionTag);
    01357         CMHelperICC2int32Const(&(aTag.offset ), currentSize);
    01358         CMHelperICC2int32Const(&(aTag.size ), theDescSize);
    01359         aProf->tagList.tags[0] = aTag;
    01360         err =MyAdd_NL_DescriptionTag    ( (LHTextDescriptionType *)((Ptr)aProf+currentSize), (unsigned char *)theText );
    01361         if (err)
    01362                 goto CleanupAndExit;
    01363         currentSize += theDescSize;
    01364         currentSize = ( currentSize + 3 ) & ~ 3;
    01365
    01366         CMHelperICC2int32Const(&(aTag.sig ), icSigMediaWhitePointTag);
    01367         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01368         CMHelperICC2int32Const(&(aTag.size ), theMediaSize);
    01369         aProf->tagList.tags[1] = aTag;
    01370         MyAdd_NL_ColorantTag((icXYZType *)((Ptr)aProf+currentSize), &D50);
    01371         currentSize += theMediaSize;
    01372         currentSize = ( currentSize + 3 ) & ~ 3;
    01373
    01374         CMHelperICC2int32Const(&(aTag.sig ), icSigCopyrightTag);
    01375         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01376         CMHelperICC2int32Const(&(aTag.size ), theCopyRightSize);
    01377         aProf->tagList.tags[2] = aTag;
    01378         err = MyAdd_NL_CopyrightTag( (unsigned char *)copyrightText, (LHTextType *)((Ptr)aProf+currentSize));
    01379         if (err)
    01380                 goto CleanupAndExit;
    01381         currentSize += theCopyRightSize;
    01382         currentSize = ( currentSize + 3 ) & ~ 3;
    01383
    01384         err = MyAdd_NL_SequenceDescTag( profileSet, (icProfileSequenceDescType *)((Ptr)aProf+currentSize), &theSequenceDescSize );
    01385         CMHelperICC2int32Const(&(aTag.sig ), icSigProfileSequenceDescTag);
    01386         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01387         CMHelperICC2int32Const(&(aTag.size ), theSequenceDescSize);
    01388         aProf->tagList.tags[3] = aTag;
    01389         currentSize += theSequenceDescSize;
    01390         currentSize = ( currentSize + 3 ) & ~ 3;
    01391
    01392     theA2B0Size = GetSizes( (CMMModelPtr)cw, &clutSize );
    01393
    01394         CMHelperICC2int32Const(&(aTag.sig ), icSigAToB0Tag);
    01395         CMHelperICC2int32Const(&(aTag.offset ), currentSize );
    01396         CMHelperICC2int32Const(&(aTag.size ), theA2B0Size);
    01397         aProf->tagList.tags[4] = aTag;
    01398
    01399 #if __IS_MSDOS
    01400         aPtr = GlobalAllocPtr( GHND, theA2B0Size+currentSize );
    01401         if( aPtr == 0 ){
    01402                 err = GetLastError();
    01403                 goto CleanupAndExit;
    01404         }
    01405 #else
    01406         aPtr =  SmartNewPtr( theA2B0Size+currentSize, &aOSerr );
    01407         err = aOSerr;
    01408         if( err ){
    01409                 goto CleanupAndExit;
    01410         }
    01411 #endif
    01412
    01413
    01414         if ( cw->lutParam.colorLutWordSize == 8 )
    01415         err = MyAdd_NL_AToB0Tag_mft1( (CMMModelPtr)cw, (icLut8Type *)(aPtr+currentSize), clutSize );
    01416     else
    01417         err = MyAdd_NL_AToB0Tag_mft2( (CMMModelPtr)cw, (icLut16Type *)(aPtr+currentSize), clutSize );
    01418
    01419         if (err)
    01420                 goto CleanupAndExit;
    01421
    01422         BlockMove( (Ptr)aProf, aPtr, currentSize );
    01423         aProf = (icProfile *)DisposeIfPtr( (Ptr)aProf );
    01424
    01425         CMHelperICC2int32Const( aPtr, theA2B0Size+currentSize );
    01426
    01427         *theProf = (icProfile *)aPtr;
    01428 #ifdef WRITE_PROFILE
    01429         WriteProf( "DeviceLinkFill.pf", (icProfile *)aPtr, theA2B0Size+currentSize );
    01430 #endif
    01431         return noErr;
    01432
    01433 CleanupAndExit:
    01434         *theProf = (icProfile *)DisposeIfPtr( (Ptr)aProf );
    01435 #if __IS_MSDOS
    01436         if( aPtr )GlobalFreePtr( aPtr );
    01437 #else
    01438         aPtr = DisposeIfPtr( (Ptr)aPtr );
    01439 #endif
    01440         return err;
    01441 }
    01442
    01443